We Keep Coding

Question about an attempt to print all permutations of a given list

I just wanted to find out what is the reason that the python shell doesn't give the output i expect for the following recursive code:
def permutator(list,track):
if len(list)==1:
track.append(list[0])
print (track)
else:
for n in range(len(list)):
track.append(list[n])
return permutator(list[:n]+list[n+1:],track)
I expect this script to print all permutations of a given list when the variable ''track'' is initiallized as an empty list ([]); for example, i expected permutator([1,2],[]) to print [1,2] and [2,1]. But it prints only [1,2]... and it really dissapointed me, since it took me a lot of time to concieve of the idea to treat the permutator function as function of two variable instead of one, in such a way that the track "documents" the recursion process (the sequential iterative process) until one arrives at a permutation of the original list.
So what is my mistake? is it fundamental (so the whole idea of the code is wrong...) or maybe there is only a small variation i need to do in order for it to start working?
I really tried to achieve success on this problem on my own but i have given up, so every help will be blessed!

When you return the function ends and the rest of the loop never executes. Also, you don't want to append to the list becuase that effects the list that gets passed to the functions called later - instead just pass the list as it would be after appending as an argument. Specifically here, since you just want to print values, there's no need to return, so you can do:
def permutator(list,track):
if len(list)==1:
track.append(list[0])
print (track)
else:
for n in range(len(list)):
permutator(list[:n]+list[n+1:],track + [list[n]])
If you decide you want to return all permutations instead of printing them, the change is easy enough:
def permutator(list,track):
if len(list)==1:
return track + [list[0]]
else:
perms = []
for n in range(len(list)):
perms.append(permutator(list[:n]+list[n+1:],track + [list[n]]))
return perms

How to find depth of an expression?

I have tried this code to find depth of an expression.Could you tell me where I am going wrong and what I should do to get the correct answer.
k=0
m=0
def fn(x):
global k,m
if isinstance(x,(tuple,list))== False : return "xyz"
if isinstance(x,(tuple,list))== True :
k=k+1
if k>m: m=k
for i in x:
print i
print k
if isinstance (i,(list,tuple)):
fn(i)
else:
if k>1: k=m
else:k=1
fn([[['x',[1,[8,9],2],'y',[7,6]]]])
print "depth is",m

The one-letter forest is too eye-boggling to follow easily; I can help you improve your debugging practices.
(1) You have print statements in a couple of useful places, but you should also label the output to make the trace more readable.
(2) Use good variable names. single-letter variables don't tell us much. For instance, 'k' tells me nothing of the purpose. I have no way of knowing whether "k=k+1" is in the right spot.
(3) Don't use global variables for your computations. If this is a recursive routine, then code it that way. Call it "list_depth"; it accepts a list and returns an integer, the depth of that object. The way you've written this, it seems to return "xyz" for an atom (what does "xyz" mean???) and some convoluted computation otherwise.
(4) Those paired "if" statements at the top show flawed logic. Test the type once: if it's a list/tuple, recur to find the depth; if not, return a depth of 1.
I hope this helps you simplify and improve your algorithm.

Recently, I happened to come across this issue and couldn't find any definite guide. So I thought of leaving this answer for someone who might need it in the future.
I tried many alternatives and came up with this solution.
def depth(in_data, current_depth=0):
current_max_depth = 0
if isinstance(in_data, (list, tuple)):
current_depth += 1
for data in in_data:
d = depth(data, current_depth)
if d > current_max_depth:
current_max_depth = d
return current_max_depth
return current_depth
In this code, every time the program returns true for isinstance() it increases the current depth by 1 and passes this current depth together with the new elements to the function again. When it returns false it returns back the current depth with no change.
Then by storing and comparing the current depth we can find the maximum depth.
I hope this helps.

How to reset a variable assigned to function in Python 2.73?

so basically a guy helped me improve my code. The problem is, it's still dead disappointing and does not work. What I wanna do, is reset the lenRecur.number so I could use the function again, using other strings and getting correct answers (not too big answers)
I guess, the problem is with hasattr. But I can't remove it, because if I do, my string length calculator won't work.
Anyway, even if I add lenRecur.number = 0 after the function, it still doesn't work.
It's like impossible, because when the function hits "return", it's done, period. If I reset it before "return", it will return 0, not correct answer so yeah I'm in deep trouble here.
def lenRecur(aStr):
if not hasattr(lenRecur, 'number'):
lenRecur.number = 0
'''
aStr: a string
returns: int, the length of aStr
'''
if aStr == '':
return lenRecur.number
else:
lenRecur.number += 1
return lenRecur(aStr[:-1])
P.s. the goal of my program(?) / script(?) is to measure the length of input string, without using input() method. As trying to re-create the length() method, with using more primitive means.
The script will have to have many different inputs, so it shall reset.

If you just want a recursive strength-length function, that's easy:
def len_recur(a_str):
if not a_str:
return 0
else:
return 1 + len_recur(a_str[1:])
Of course that's not tail-recursive, but then Python doesn't optimize tail recursion anyway, so it doesn't matter.
And if you want it to be tail recursive just for the hell of it—or because you've read Paul Butler's trick for Tail Recursion in Python and want to try it out—you still don't want to do that by storing the accumulator as an attribute of the function. Just use the usual trick of defining a local function (or using a mutable default parameter, if you prefer):
def len_tail_recur(a_str):
def tail(a_str, acc):
if not a_str:
return acc
else:
return tail(a_str[1:], acc+1)
return tail(a_str, 0)
If you want to convert this to a real tail-recursive function so it doesn't bomb on lists of 1001 elements, and don't understand the Paul Butler link above, see my answer to Get length of list in Python using recursion, which solves exactly this problem. (Another answer to that question also shows how to solve the problem with log N recursive calls instead of N, which is a different way of getting around the problem, unless you have impossibly long lists.)
All that being said, even though your implementation is the wrong way to do it, it actually works just fine. (So far, I've been PEP8-ifying your code to look more like idiomatic Python; from here on I'm just going to copy-paste as-is, but your real code should look like the above.)
def lenRecur(aStr):
if not hasattr(lenRecur, 'number'):
lenRecur.number = 0
'''
aStr: a string
returns: int, the length of aStr
'''
if aStr == '':
return lenRecur.number
else:
lenRecur.number += 1
return lenRecur(aStr[:-1])
print lenRecur('abc')
lenRecur.number = 0
print lenRecur('abcd')
This prints 3, then 4. Of course you have to set lenRecur.number from outside the function, because inside the function you still need the value. But you can solve that with the same kind of wrapper:
def lenRecur(aStr):
lenRecur.number = 0
'''
aStr: a string
returns: int, the length of aStr
'''
def recur(aStr):
if aStr == '':
return lenRecur.number
else:
lenRecur.number += 1
return recur(aStr[:-1])
return recur(aStr)

You don't have to use a state variable inside the function. If you want to make a recursive length calculator, then just do
def lenRecur (aStr):
if (aStr == ""):
return 0
else
return lenRecur (aStr [:-1]) + 1
Also note that this style has no error checking etc, but for the purposes of learning about recursion, it works fine.

If you're trying to understand recursion by implementing the length function using recursion then you can use something like this:
#!python
def lenRecur(something, curlen=0):
if something:
return lenRecur(something[1:], curlen+1)
else:
return curlen
... I won't claim that this is particularly good code. But it should work with any sort of sequence (string, list, tuple) ... anything for which the [1:] slice operation will work so long as it doesn't exceed the maximum recursion limit in your running Python instance.
In your example you're trying to implement a similar concept by using hasattr to "monkey patch" your function's object with a "number" attribute. In my example I'm using a default parameter as a way of passing the variable down into the recursive calls.
So in the initial call curlen is zero (calling this with the "optional" extra argument would give bogus results). From that call the function calls itself with a slice of the original sequence (string) that lops off the head (making it one shorter) and with the optional (curlen) argument incremented. At the end the string/sequence is of zero length, the zero is returned up through each of the previous (recursive) calls.
It's a lame way to accomplish this, and it could be a starting point for a discussion on tail recursion elimination (Google for it). But it will work without monkey patching your function/object.

Failing to understand recursion

New to Python and trying to understand recursion. I'm trying to make a program that prints out the number of times string 'key' is found in string 'target' using a recursive function, as in Problem 1 of the MIT intro course problem set. I'm having a problem trying to figure out how the function will run. I've read the documentation and some tutorials on it, but does anyone have any tips on how to better comprehend recursion to help me fix this code?
from string import *
def countR(target,key):
numb = 0
if target.find(key) == -1:
print numb
else:
numb +=1
return countR(target[find(target,key):],key)
countR('ajdkhkfjsfkajslfajlfjsaiflaskfal','a')

By recursion you want to split the problem into smaller sub-problems that you can solve independently and then combine their solution together to get the final solution.
In your case you can split the task in two parts: Checking where (if) first occurence of key exists and then counting recursively for the rest.
Is there a key in there:
- No: Return 0.
- Yes: Remove key and say that the number of keys is 1 + number of key in the rest
In Code:
def countR(target,key):
if target.find(key) == -1:
return 0
else:
return 1+ countR(target[target.find(key)+len(key):],key)
Edit:
The following code then prints the desired result:
print(countR('ajdkhkfjsfkajslfajlfjsaiflaskfal','a'))

This is not how recursion works. numb is useless - every time you enter the recursion, numb is created again as 0, so it can only be 0 or 1 - never the actual result you seek.
Recursion works by finding the answer the a smaller problem, and using it to solve the big problem. In this case, you need to find the number of appearances of the key in a string that does not contain the first appearance, and add 1 to it.
Also, you need to actually advance the slice so the string you just found won't appear again.
from string import *
def countR(target,key):
if target.find(key) == -1:
return 0
else:
return 1+countR(target[target.find(key)+len(key):],key)
print(countR('ajdkhkfjsfkajslfajlfjsaiflaskfal','a'))

Most recursive functions that I've seen make a point of returning an interesting value upon which higher frames build. Your function doesn't do that, which is probably why it's confusing you. Here's a recursive function that gives you the factorial of an integer:
def factorial(n):
"""return the factorial of any positive integer n"""
if n > 1:
return n * factorial(n - 1)
else:
return 1 # Cheating a little bit by ignoring illegal values of n
The above function demonstrates what I'd call the "normal" kind of recursion – the value returned by inner frames is operated upon by outer frames.
Your function is a little unusual in that it:
Doesn't always return a value.
Outer frames don't do anything with the returned value of inner frames.
Let's see if we can refactor it to follow a more conventional recursion pattern. (Written as spoiler syntax so you can see if you can get it on your own, first):
def countR(target,key):
idx = target.find(key)`
if idx > -1:
return 1 + countR(target[idx + 1:], key)
else:
return 0
Here, countR adds 1 each time it finds a target, and then recurs upon the remainder of the string. If it doesn't find a match it still returns a value, but it does two critical things:
When added to outer frames, doesn't change the value.
Doesn't recur any further.
(OK, so the critical things are things it doesn't do. You get the picture.)
Meta/Edit: Despite this meta article it's apparently not possible to actually properly format code in spoiler text. So I'll leave it unformatted until that feature is fixed, or forever, whichever comes first.

If key is not found in target, print numb, else create a new string that starts after the the found occurrence (so cut away the beginning) and continue the search from there.

Why is one code faster than other even when iterations are more?

My code is short and has lesser number of iterations than the other but still it gets a time limit exceeded error while the other code is accepted on codechef.com. The codes are solution to the "Ambiguous permutation" problem on codechef.com
Why is this code:
def inverse(data,x):
temp=[]
for i in range(x):
temp.append(0)
for i in range(x):
temp[data[i]-1]=i+1
return temp
def main():
while 1:
x=input()
if not x:
return
data=raw_input().split(' ')
for i in range(len(data)):
data[i]=int(data[i])
temp = inverse(data,x)
if temp==data:
print 'ambiguous'
else:
print 'not ambiguous'
if __name__ == "__main__":
main()
faster than this code:
while True:
output=[]
n= input()
if n==0: break
caseList= raw_input().split()
amb=1
for i in range(1, n+1):
output.append(str(caseList.index(str(i))+1))
if output==caseList:
print ("ambiguous")
else:
print ("not ambiguous")
Please help me out...

I take it your second code isn't inside a function.
Access to local variables in a function is significantly faster than accessing global variables. That means code run in global scope is always likely to be slower.

When such a consistent time difference shows up, we are not talking about something that is 2, or 3 times slower - if one method passes, and the other always times out, it is a huge time difference- normally tied to algorithm complexity.
Although the first code has plenty of room to get better (usage of xrange instead of range, for example), in the final array, the result is update by random access, straight by the index caculated by data[i] - 1- while in the second snippet, you use caseList.index(str(i)) to retrieve each index. The "index" lisr method performs a linear search on the list, starting at the beginning. It may seem little, but when it is doen for each element in the list, your algorithm which was O(N) becomes O(N²) - which expains the dramatic speed down in this second form.

It looks like you're using strings where the other code is using ints, which will slow you down somewhat.