Comments on: Binary Search and Vector Rotation - Jon Bentley Inspired http://shriphani.com/blog/2008/06/12/binary-search-vector-rotation/ Weblog of an Aspiring Computer Scientist Thu, 04 Dec 2008 19:37:36 +0000 http://wordpress.org/?v=2.6.1 By: Paul McGuire http://shriphani.com/blog/2008/06/12/binary-search-vector-rotation/#comment-272 Paul McGuire Tue, 17 Jun 2008 16:39:01 +0000 http://shriphani.com/blog/?p=154#comment-272 No, I studied Mechanical Engineering at RPI, the CS stuff came later. I've been very fortunate to have worked with a number of *very* smart CS folks, and some of it rubbed off on me. No, I studied Mechanical Engineering at RPI, the CS stuff came later. I’ve been very fortunate to have worked with a number of *very* smart CS folks, and some of it rubbed off on me.

]]> By: Shriphani http://shriphani.com/blog/2008/06/12/binary-search-vector-rotation/#comment-265 Shriphani Sat, 14 Jun 2008 04:09:49 +0000 http://shriphani.com/blog/?p=154#comment-265 Well, I agree I didn't use any brain when I copied Jon's implementation directly (the writing style is so cool that one can get carried away with ease), but thanks for such an excellent comment. Did you go to Purdue CS as well? Shriphani Well, I agree I didn’t use any brain when I copied Jon’s implementation directly (the writing style is so cool that one can get carried away with ease), but thanks for such an excellent comment.

Did you go to Purdue CS as well?

Shriphani

]]> By: Paul McGuire http://shriphani.com/blog/2008/06/12/binary-search-vector-rotation/#comment-263 Paul McGuire Fri, 13 Jun 2008 18:33:12 +0000 http://shriphani.com/blog/?p=154#comment-263 We used to have a saying when I was in college, "you can code FORTRAN in any language." In this case, Jon Bentley's code, while beautiful, elegant, fast, etc., is very C-oriented. Your example using .reverse() looks like a direct transliteration from C using strrev. Yes, it's interesting, especially when designing optimal algorithms within the confines of C, but it is a poor way to teach yourself Python. Just like the elegance of C's in-place of 2 integers or pointers, cleverly implemented as a C macro: #define swap(a,b) (a)^=(b);(b)^=(a);(a)^=(b) is much more clearly implemented using Python's tuple assignment: a,b = b,a Here are two renditions of rotate using more Pythonic idioms ("idia"?), first using list slices, and second using iterators: def rotate(list_name, i): """Rotate i elements of the given list, using normal Python list slicing""" return list_name[i:] + list_name[:i] def iterrotate(list_name, i): """Rotate i elements of the given list, using iterators so no copies or slices are constructed""" retiter = iter(list_name) ii = i if i >= 0 else len(list_name)+i try: while(ii): retiter.next() ii -= 1 except StopIteration: pass else: for item in retiter: yield item retiter = iter(list_name) ii = i if i >= 0 else len(list_name)+i while(ii): yield retiter.next() ii -= 1 I'm sure the iterator-based solution has room for improvement, this is left as an exercise for the reader. :) Of course, test cases on the boundaries are always useful, not just testing the nominal case: def test(title,rotsize): print "\n%s (%d)" % (title,rotsize) print rotate(list("abcdefghij"), rotsize) for c in iterrotate(list("abcdefghij"), rotsize): print c, print test("test rotation", 3) test("test rotation size longer than list", 50) test("test rotation size = list length", 10) test("test zero rotation size", 0) test("test negative sizes", -4) test("test rotation size = -list length", -10) test("test rotation size < -list length", -15) Prints: test rotation (3) ['d', 'e', 'f', 'g', 'h', 'i', 'j', 'a', 'b', 'c'] d e f g h i j a b c test rotation size longer than list (50) ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'] a b c d e f g h i j test rotation size = list length (10) ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'] a b c d e f g h i j test zero rotation size (0) ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'] a b c d e f g h i j test negative sizes (-4) ['g', 'h', 'i', 'j', 'a', 'b', 'c', 'd', 'e', 'f'] g h i j a b c d e f test rotation size = -list length (-10) ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'] a b c d e f g h i j test rotation size < -list length (-15) ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'] a b c d e f g h i j (Your originally posted rotate() method passed all of these tests, too.) As for binary search, check out the bisect module. Cheers, and good luck at Purdue! -- Paul We used to have a saying when I was in college, “you can code FORTRAN in any language.” In this case, Jon Bentley’s code, while beautiful, elegant, fast, etc., is very C-oriented. Your example using .reverse() looks like a direct transliteration from C using strrev. Yes, it’s interesting, especially when designing optimal algorithms within the confines of C, but it is a poor way to teach yourself Python. Just like the elegance of C’s in-place of 2 integers or pointers, cleverly implemented as a C macro:

#define swap(a,b) (a)^=(b);(b)^=(a);(a)^=(b)

is much more clearly implemented using Python’s tuple assignment:

a,b = b,a

Here are two renditions of rotate using more Pythonic idioms (”idia”?), first using list slices, and second using iterators:

def rotate(list_name, i):
“”"Rotate i elements of the given list, using normal Python
list slicing”"”
return list_name[i:] + list_name[:i]

def iterrotate(list_name, i):
“”"Rotate i elements of the given list, using iterators so no
copies or slices are constructed”"”
retiter = iter(list_name)
ii = i if i >= 0 else len(list_name)+i
try:
while(ii):
retiter.next()
ii -= 1
except StopIteration:
pass
else:
for item in retiter:
yield item

retiter = iter(list_name)
ii = i if i >= 0 else len(list_name)+i
while(ii):
yield retiter.next()
ii -= 1

I’m sure the iterator-based solution has room for improvement, this is left as an exercise for the reader. :)

Of course, test cases on the boundaries are always useful, not just testing the nominal case:

def test(title,rotsize):
print “\n%s (%d)” % (title,rotsize)
print rotate(list(”abcdefghij”), rotsize)
for c in iterrotate(list(”abcdefghij”), rotsize):
print c,
print

test(”test rotation”, 3)
test(”test rotation size longer than list”, 50)
test(”test rotation size = list length”, 10)
test(”test zero rotation size”, 0)
test(”test negative sizes”, -4)
test(”test rotation size = -list length”, -10)
test(”test rotation size < -list length”, -15)

Prints:

test rotation (3)
['d', 'e', 'f', 'g', 'h', 'i', 'j', 'a', 'b', 'c']
d e f g h i j a b c

test rotation size longer than list (50)
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
a b c d e f g h i j

test rotation size = list length (10)
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
a b c d e f g h i j

test zero rotation size (0)
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
a b c d e f g h i j

test negative sizes (-4)
['g', 'h', 'i', 'j', 'a', 'b', 'c', 'd', 'e', 'f']
g h i j a b c d e f

test rotation size = -list length (-10)
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
a b c d e f g h i j

test rotation size < -list length (-15)
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
a b c d e f g h i j

(Your originally posted rotate() method passed all of these tests, too.)

As for binary search, check out the bisect module.

Cheers, and good luck at Purdue!
– Paul

]]> By: Shriphani http://shriphani.com/blog/2008/06/12/binary-search-vector-rotation/#comment-257 Shriphani Thu, 12 Jun 2008 10:39:04 +0000 http://shriphani.com/blog/?p=154#comment-257 @Ben, Thanks for pointing it out. I have fixed it now and it seems to work. @Ben,

Thanks for pointing it out. I have fixed it now and it seems to work.

]]> By: Ben http://shriphani.com/blog/2008/06/12/binary-search-vector-rotation/#comment-255 Ben Thu, 12 Jun 2008 10:21:04 +0000 http://shriphani.com/blog/?p=154#comment-255 Yup. Jon Bentley is right: most binary search implementations are broken. Yours doesn't terminate when the value sought isn't in the list. Yup. Jon Bentley is right: most binary search implementations are broken. Yours doesn’t terminate when the value sought isn’t in the list.

]]>