# Road to Genius — Python Series level 4

--

Welcome to the fourth level where we solve Python Challenges from Codr’s Ranked mode. The goal is to reach the Genius level, so join me at Codr!

This is quite a lot of code, but it doesn’t look super complicated, since we only have to fix three bugs. The first droplet bug we encounter is an operator, and it’s probably a simple assignment.

The second panda bug is likely to be a variable that gives `pre`

an initial value. From the if statements below, a lot of nodes are receiving `cur`

as value, I would like to bet that `pre`

starts of with `cur`

value as well. It's not a scientific approach but saves us a lot of time here.

The final snowman bug is a Node since it needs a `val`

field. At that point we have three candidates for this bug `HD, cur and TARGET`

. Since HD and cur are already being used but TARGET is not, this may give TARGET a purpose after all.

Here’s some short algorithm with a quite complex if-statement. But we don’t have to understand it solve the two bugs which are of form `x -= y`

. To figure out x and y we can have a peak at the while-condition, which states `i-1`

and if you look further, the value of `i`

remains untouched, so this is the ideal place to decrement `i`

by one to prevent an infinite loop.

To solve this challenge we have to calculate it. Feel free to cheat by copy pasting the code and printing `S`

's value. But all that this algorithm does is count the number times when `i % j == 0`

within the specified ranges. There may be a mathematical formula that gives the exact number for this. If there isn't one, you'll have to manually determine it or run the code. You can also represent this algorithm in a 2D grid where the X represents that `i%j==0`

:

Let’s solve four of the bugs. The first moneybag is the 2nd parameter for the function, and it should be `WD`

since it isn't declared anywhere else.

The rocket and droplet seem to be of the pattern: `len(something)+1`

. If we look two lines up, we see that `len(str)+1`

repeat itself, so that length is likely to be needed for the for loop as well.

The snowman bug should be some variable that contains an integer, since it’s used for indexing the `dp`

list. We see that `i`

is used for indexing `dp`

and `str`

exclusively, so that's likely to be it.

Here we have to fix three bugs. The red apple is going to be an assignment, it’s the only valid possibility.

The blue droplet must be some integer of the list. We have to be careful choosing this value because it may have an impact on the expected output of `A`

. Similarly the green moneybag bug is some operator which is hard to guess.

I do notice that the value for `n`

is 2. This means that every for loop in the function will index nothing beyond any index of 2. This means that the value for the blue droplet won't matter, we can pick anything.

The output of A exclusively relies on the value of `x[0]`

, so that value is the only thing we have to track. This information together with the two x[...] assignments in the function are of similar fashion ~ `x[] = (...) / b[]`

, this may reveal that the moneybag should be a division. After a quick calculation this proves to be correct.

The final challenge has four bugs for us to fix. The first blue droplet should be the `elif`

keyword.

The diamond should be number one, because the first condition in that while statement ensures that `right - 1`

is within bounds.

The green moneybag should be the array `nums`

, since it's used all over the place in that fashion.

Finally the snowman might be tricky, it represents the input for the algorithm. Honestly I have no idea what this code actually does, but the function’s name may save us from a deep analysis. The function name `threeSum`

may indicate that it's looking for a bunch of unique values as a result of summing three values from the input array. Notice that our input array contains a snowman, a one and four zeros. Given the fact that the output of A is one, I'm strongly suspecting the bug should be zero, otherwise A wouldn't be equal to one. And this assumption was correct!

Just like that we made it to the Genius level stay tuned for that! If you enjoyed this post, make sure to join Codr, like and follow me on DEV ❤!