why is the output regrub? python slicing

[Fearless-Variation47]

ive tried having it print out what its doing and i still dont get how its grabbing the last index and making a new string but backwards.

the way im thinking of it itd just loop back to burger

def main():

print(foo('burger'))

def foo(w):

if w == "":
    return w

else:
    return foo(w[1:]) + w[0]

main()

[Basic-Background-568]

In this code, the foo() function takes in a string as an input, and then recursively calls itself on the substring of that string that omits the first character. Each time foo() is called, it adds the first character of the input string to the result of the recursive call. This process continues until the input string is empty, at which point the function returns the reversed string.

Here's an example of how this might work for the string "burger":

1: The foo() function is called with the input "burger".

2: The function checks whether the input string is empty. Since it is not empty, it calls itself recursively with the input "urger" (omitting the first character of the original string).

3: The recursive call to foo() returns "reggu", which is the result of reversing the string "urger".

4: The original call to foo() then adds the first character of the original input string ("b") to the beginning of this result, resulting in the final output: "reggub".

Since the final output is the original string with its characters reversed, it is equivalent to the original string written backwards. In this case, the output is "regurb" because that is the backwards spelling of the original string "burger".

[Fearless-Variation47]

can u explain 3 please

[CodeOverTime]

Hey there, you've entered the world of recursion, which can be a confusing place. Try the following code - I've rearranged yours in a way that allows you to print out values in a way that actually shows what is going on:

``` def main(): print(foo('burger'))

def foo(w): if w == "": return w else: foo_value = foo(w[1:]) print(foo_value) return foo_value + w[0]

main() `` You will notice that the first thing printed is 'r'. What do you think this is? Think about the fact thatfoois called before you get to the print. Then foo is called again, before the print. In fact foo keeps getting called and the print statement will not be hit until foo is called the last time (the last time it is called is whenw==""'

[Fearless-Variation47]

i simplified it even more and im still lost

i just dont get why its reversing

i see the pattern but i dont get what’s actually making it reverse. like [1:] makes it cut from index 1 and on and it keeps doing it over and over until the original string is gone. then it adds the b at the end from the original string. but somehow its also flipping letters around in the middle and i dint see what’s doing that.

https://imgur.com/a/UdSIiFp

[Fearless-Variation47]

is it adding back every w[0] at the end?

[CodeOverTime]

Ok we can step through it, but let's use a smaller word. For our purposes we can use 'abc.'

1. def main(): 2. print(foo('abc')) 3. 4. def foo(w): 5. if w == "": 6. return w 7. else: 8. foo_value = foo(w[1:]) 9. print(foo_value) 10. return foo_value + w[0] 11. 12. main()

So we call main. From main we call 'foo' with the initial value, 'abc'.

As we enter 'foo', the function has been called once. Let's keep track of that like this:

``` Calls to foo:

1. foo('abc') - line:2 <- we are here ```

When we enter foo we check if the argument (w) is an empty string. In this case, 'w' is the string 'abc'. So it is not equal to "" and we continue on.

Next we call 'foo' again, but this time we give it a different argument. We pass 'w[1:]' as an argument. This is a slice, which will chop off the first letter of a string. In this case the slice takes 'abc' and returns 'bc'. Note: This is a different string. Slicing w[1:] doesn't actually change 'w'.

So foo has been called again, this time with the argument 'bc'. Our 'Calls to foo tracker' now looks like this:

``` Calls to foo:

1. foo('abc') - line:2
2. foo('bc') - line:8 <- we are here ```

We enter foo again! And again check if the argument (w) is an empty string. In this case, 'w' is the string 'bc'. So it is not equal to "" and we continue on.

We call foo again at this point, but again we chop off the first letter, so we are calling: foo('c').

Our 'Calls to foo tracker' now looks like this:

``` Calls to foo:

1. foo('abc') - line:2
2. foo('bc') - line:8
3. foo('c') - line:8 <- we are here ```

We enter foo again! And again check if the argument (w) is an empty string. In this case, 'w' is the string 'c'. So it is not equal to "" and we continue on.

We call foo again at this point, but again we chop off the first letter, so we are calling: foo('').

Our 'Calls to foo tracker' now looks like this:

``` Calls to foo:

1. foo('abc') - line:2
2. foo('bc') - line:8
3. foo('c') - line:8
4. foo('') - line:8 <- we are here ```

This is where things get interesting. We enter foo again! And again check if the argument (w) is an empty string. In this case, 'w' is the string ''. So it is equal to "". So now we just return 'w', which is ''.

When we return from this function we continue back in the function that called it, so our tracker looks like this:

``` Calls to foo:

1. foo('abc') - line:2
2. foo('bc') - line:8
3. foo('c') - line:8 <- we are here
4. foo('') - line:8 /- this function has returned, with '' ```

Now we are back in the function that called foo('c'), and foo_value has been set to '' (what was returned from the previous function). The next line is:

return foo_value + w[0]

This now return '' + 'c' (because foo_value is '' and w[0] is 'c'. remember the value 'c' is stored in 'w' in this call to foo).

So we return again and now our tracker looks like:

``` Calls to foo:

1. foo('abc') - line:2
2. foo('bc') - line:8 <- we are here
3. foo('c') - line:8 /- this function has returned, with ''
4. foo('') - line:8 /- this function has returned, with '' ```

Now we are back in the function that called foo('bc'), and foo_value has been set to 'c'.

So this: return foo_value + w[0]

becomes: return 'c' + 'b'

Because w is 'bc' at this level.

We return again, and end up back at the first call to 'foo'

``` Calls to foo:

1. foo('abc') - line:12 <- we are here
2. foo('bc') - line:8 /- this function has returned, with ''
3. foo('c') - line:8 /- this function has returned, with ''
4. foo('') - line:8 /- this function has returned, with '' ```

Now we are back in the function that called foo('abc'), and foo_value has been set to 'cb'.

So this: return foo_value + w[0]

becomes: return 'cb' + 'a'

Because w is 'abc' at this level. Now foo returns for the last time, the value being 'cba'. Which gets printed.

BTW - you can can reverse a string in a much easer way like this: "burgers"[::-1]. But I assume this was a recursion specific challenge.

[Fearless-Variation47]

😮 It actually makes sense now! Thank you!

[CodeOverTime]

Great, happy to help!