I am sorry your comment did not show up earlier as my spam filter marked it as spam. But that is an excellent solution which we all missed. Thanks for the link.

def changeXY(string_name):
final_string=list(string_name) #allocate all once
for i in xrange(len(final_string)):
….if final_string[i]==”x”:
……..final_string[i]=”y”
return “”.join(final_string)

def naiveChange(string_name):
final_string=”" #start empty and append
for i in xrange(len(string_name)):
….if string_name[i]==”x”:
……..final_string+=”y”
….else:
……..final_string+=string_name[i]
return final_string

The thing is that the discussion is pretty academic anyway because the correct way is to use string.replace().

Here is the runtime for the solution you submitted:

time python res.py
boneywasawarriorwayayiykicksasteriyandobeliybutt

real    0m0.268s
user    0m0.031s
sys     0m0.139s

I think sage is right. The “appending” seems to be the problem here. Of course, anyone familiar with Python would know what

str1 += str2

is inefficient and in general, a bad idea because str1 is being reconstructed everytime. I hence used a list to collect all the characters and used the join() method at the end. I believe Joel was not speaking about this but was thinking of something else (for instance Ruby has mutable strings and ruby programmers can append to strings using something like str1[len(str1)] = char). So, Joel might be hintins that walking and appending is the wrong way to do things. Walking over the data seems to be unavoidable. Even the find() method needs to walk over the input to check where “x” appears.

The first solution (the recursive one) seems to have a complexity of O(n). The second one should have something better than that as it has a lesser runtime for the very same input. Can someone figure out the complexity of the algorithm where I used string slices ?

I’m also curious about that example… But I have an idea.
You assumed the inefficiency reside in “to go over all the characters in the string and when they find an “x””. I think the inefficiancy reside in “they append a”.

To append a char to a string may be inefficient (depending of the internal implementation of the string). If the string is implemented with a chained list, it’s totally efficient, but if it’s a fixed size buffer, appending mean (potential?) reallocation.

append => reallocation => inefficient.

the replacement is not in O(n) but in O(n^2) if you need to reallocate at each iteration.

[e:\test\python]py24 str_replace.py
changeXY
0.0348 secs for 10000 reps

TESTSTR.replace
0.0054 secs for 10000 reps

I’d say it speaks for itself.

def changeXY3(string_name):
return ‘y’.join(string_name.split(’x'))

This runs 3 times faster than changeXY2 and about 770 times faster than changeXY1, and it’s much shorter. This is idiomatic Python. I presented a tutorial on the subject at PyCon 2007, and the materials are on the web: http://python.net/~goodger/projects/pycon/2007/idiomatic/handout.html

In python the obvious thing do do is cheat and use “avnxdef”.replace(”x”, “y”).
Still it would have been nice to get timings for that and:

res = “”.join(l if l != “x” else “y” for l in string)

which is the closest approximation to a C implementation.