• Parameter x has a value of 16 which means the if condition is not met. Therefore the following steps are taken:
  
• Print the return value of a call of h with the argument 16. The return value of h is 1.
  OUTPUT: 1
• Call f with the argument 16 / 3 + 1. The argument value is 6.
  
  • Parameter x has a value of 6 which means the if condition is not met. Therefore the following steps are taken:
    
  • Print the return value of a call of h with the argument 6 (binary representation of 6: 110). The return value of h is 2.
    OUTPUT: 2
  • Call f with the argument 6 / 3 + 1. The argument value is 3.
    
    • Parameter x has a value of 3 which means the if condition is met. Therefore the following step is taken:
      
    • Print the return value of a call of h with the argument 3 - 1 == 2 (binary representation of 2: 10). The return value of h is 1.
      OUTPUT: 1
    • End function f with n == 3.
  • End function f with n == 6.
• End function f with n == 16.

• Parameter x has a value of 16 which means the if condition is not met. Therefore the following steps are taken:
  
• Call f with the argument 16 / 3 + 1. The argument value is 6.
  
  • Parameter x has a value of 6 which means the if condition is not met. Therefore the following steps are taken:
    
  • Call f with the argument 6 / 3 + 1. The argument value is 3.
    
    • Parameter x has a value of 3 which means the if condition is met. Therefore the following step is taken:
      
    • Print the return value of a call of h with the argument 3 - 1 == 2 (binary representation of 2: 10). The return value of h is 1.
      OUTPUT: 1
    • End function f with n == 3.
  • Print the return value of a call of h with the argument 6 (binary representation of 6: 110). The return value of h is 2.
    OUTPUT: 2
  • End function f with n == 6.
• Print the return value of a call of h with the argument 16. The return value of h is 1.
  OUTPUT: 1
• End function f with n == 16.

• Where 1 == n / 3 + 1 n can only be 2 (binary: 10).
  
• Where 2 == n / 3 + 1 n can only be 4 (binary: 100).
  
• Where 4 == n / 3 + 1 n can only be 10 (binary: 1010).
  
• Where 10 == n / 3 + 1 n can only be 28 (binary: 11100).
  
• Where 28 == n / 3 + 1 n can only be 82 (binary: 1010010).

• (15 - 1) * 3 == (42 || 44).
  
• Binary representation of 42: 101010
  
• Binary representation of 44: 101100

• (23 - 1) * 3 == (66 || 68).
  
• Binary representation of 66: 1000010
  
• Binary representation of 68: 1000100

• 111 (decimal: 7)
  
• 1011 (decimal: 11)
  
• 1101 (decimal: 13)
  
• 10011 (decimal: 19)
  
• 10101 (decimal: 21)
  
• 11001 (decimal: 25)

• Parameter s must be comprised of character or string data types because ret_val is defined as an empty string to which at least one element of s is added.
  
• The if condition is met when the value of i is either smaller than p or greater than or equal to p + l. It appears reasonable to conclude that p determines position and l determines length.
  
• In order for the if condition to make sense with the variable i it has to be part of a loop which can only be the for loop.
  
• There are only two lines left now: the increment statement for i and the assignment statement for s. Both of them only have one resonable place left.

• Two for loops
  
• Two if sections
  
• Two return statements
  
• One break statement
  
• One assignment statement for flag

• One of the if conditions accesses variables i and j. That means one of the for loops is nested inside the other and the if section is nested within both loops. At this point it is only an assumption but usually j loops are nested in i loops, not the other way around.
  
• In order to make sense of that construct it is time to look at the call statement for g to understand the parameters better. g is called from within the h function. Retracing back to the main function it becomes clear
  
  • that both s and t hold string values and
    
  • that start holds an integer value.
  That means the construct of the last step would do the following:
  For each character of s it checks if starting from this position the content of s does not match the value of t.
  In more plain english:If t holds two characters the for-for-if construct checks if the first two characters of s do not match up with t, if the second and the third character of s do not match up with t, and so on until the end of s.
  
• The previous finding would be in line with the first statements of the main function and the corrsponding output where apparently certain characters have to be removed from the string "abracadabra" during print. Only the following is left to accomplish: If in one iteration of the i loop the currently checked part of s matches up with t that part has to be removed. But there is no statement that modifies s. The reason for that is that function g achieves the intended return with a recursive algorithm as can be seen in one of the return statements.
  If s holds at least one set of characters that match up with the value of t function g returns a string that is the return value of a recursive call of function g with the matching section of s cut. The section of s matching t is cut by calling function h within the recursive call of g.
  The following examplifies how the recursion of g works to cut "a" out of "abracadabra".
  
  • First call (s = "abracadabra): Check if the first letter of s is not "a". Because it is call g with the arguments "bracadabra" for s, "a" for t and position 0 for start.
    
  • Second call (s = "bracadabra): Check if the first letter of s is not "a": Yes. Check if the second letter of s is not "a": Yes. Check if the third letter of s is not "a". Because it is call g with the arguments "brcadabra" for s, "a" for t and position 2 for start.
    
  • Three more calls like this each taking care of one "a" in the remaining string.
    
  • The final recursive call of g verifies that there is no set of characters left in s that matches t and returns the value of s all the way back as a return value to the first call of g.

• In the first part, the main function features a loop with six iterations each of which calls gcd two times through print statements. That means that the first twelve output lines of the goal have to be achieved here. Each print statement has to output true which according to
  
  print (gcd (tests[i][0], tests[i][1]) == results[i]) print (gcd (tests[i][1], tests[i][0]) == results[i])
  means that when processed by function gcd the values of each point element of matrix tests have to produce the corresponding value in vector results regardless of the argument order.
  
• With that knowledge it helps to look at the last two elements of tests
  
  [-1, 9] [0, 0]
  because according to results both of them require a gcd return value of -1. That means that
  return -1
  must be allocated to the if section with the condition
  a <= 0 || b < 0
  because that is the only condition that is met by the values of both elements of tests regardless of the argument order of the gcd call. Furthermore, this if section has to precede the other if section in order for the gdc calls with the last element of tests as arguments to return -1.
  
• The remaining two return statements can be allocated with the knowledge that a division by 0 will cause a runtime error.

• The lines
  
  if (gcd (x + i, n) == 1) return [x, i]
  must be part of both loops
  
  for (var i = 0; i < n; ++i) for (x : d)
  because they reference both i and x. Accordingly, one of the loops must be nested inside the other. Furthermore, it is fair to assume for the time being that the return statement is part of the if section because the return statement would return exactly the elements tested in the condition.
  
• The line
  d.push_back (i)
  must be part of the for loop that iterates i. If you look at the definition statement for d
  var d = []
  it becomes apparent that before entering the for loop
  for (x : d)
  at least one element must be assigned to d because otherwise that loop would never trigger. That means that
  d.push_back (i)
  must precede that loop and, in turn, that the for loop iterating x must be nested inside the for loop iterating i.
  
• That leaves only
  
  if (n % i == 0) return [0, 0]
  Let's look at the condition first. It must be part of the for loop iterating i and it is met only when n can be divided by i without remainder, i.e. when i is a divisor of n. In order to allocate that condition the goal output becomes important. The main function calls f consecutively with seven integer values. The expected return for each call is two integer values that are divisors of the call argument unless, apparently, the argument is a square number in which case the return values should both be 0.
  Given that the return values greater than 0 must be caused by
  return [x, i]
  and that x is an element of d one can assume that all statements in the for loop iterating i are conditioned by the remaining if section. Otherwise, there would be the possibility that f returns values that are not divisors of n through both x and i.
  It would follow that the remaining return statement must be placed at the end of function f to make any sense.

1. The value of a is added to the value of b.
   
2. The difference of the values of b and a is assigned to a, effectively assigning to a the original value of b in this iteration of the loop.

Originally posted by wikipedia:

If a Fibonacci number is divided by its immediate predecessor in the sequence, the quotient approximates φ; e.g., 987/610 ≈ 1.6180327868852. These approximations are alternately lower and higher than φ, and converge to φ as the Fibonacci numbers increase.

• The first step is to divide the desired output value by the Golden Ratio. Make sure to use sufficient decimal places to get proper result:
  
  1000 / 1.618033 == 618,0343664189791
  Round that to 618 and you have your predecessor to 1000 in the sequence!
  
• Secondly, work your way backwards by subtracting the predecessor and count the steps.
  
  1. 1000 - 618 == 382
     
  2. 618 - 382 == 236
     
  3. 382 - 236 == 146
     
  4. 236 - 146 == 90
     
  5. 146 - 90 == 56
     
  6. 90 - 56 == 34
     
  7. 56 - 34 == 22
     
  8. 34 - 22 == 12
  • The result of a subtraction must be greater than -1 and smaller than 36 to qualify as value for a AND
    
  • The subtrahend, i.e. the value being subtracted, must be greater than -1 and smaller than 31 to qualify as value for b.
    
  • The value for n is the amount of subtractions performed until both of the previous conditions are met.
  So there you have your input values to achieve an output of 1000: 12 22 8.
  In fact there are three more sets of integers to get to 1000. Care to try and find them?

• a[0] to a[m - 1]
  
• a[m] to a[a.size () - m - 1]
  
• a[a.size () - m] to a[a.size () - 1]

• [4, 1]: size of output vector: 4 / characters exchanged from beginning and end: 1
  
• [9, 3]: size of output vector: 9 / characters exchanged from beginning and end: 3
  
• [10, 5]: size of output vector: 10 / characters exchanged from beginning and end: 5

• Like in previous levels with matrices there are two lines that indicate the positioning of the loops and the if section:
  
  var cx = x + dir[0] * i var cy = y + dir[1] * i
  It follows that the only reasonable place for
  ++m[cx][cy]
  is in the if section.
  
• The remaining lines
  
  var cp = min (p, m.size () - 1) m[x][y] += cp
  are also easy to place.

• The four lines of the main function following f, especially
  
  f (m, 3, 2, 1) f (m, 2, 0, 0)
  would test the correct assembly of f. But since the remaining lines of the main function are not assembled that is not an option. It can be said however, that the already sorted parts of the main function would print the first two matrices in the goal because there are two calls of print_matrix. Therefore the remaining main function lines must be responsible for the remaining five matrices in the goal.
  
• Apart from
  
  • four variable definition statements,
    
  • two loops, and
    
  • one condition
  there are three lines of particular interest:
  
  f (m, p, x, y) print_matrix (m) m = generate (n)
  Obviously, these lines are responsible for the creating, manipulating and printing the matrices required for the goal.
  
• It should not be too hard to bring all the lines in order considering the above and the following:
  
  • The same process has to be executed for each of the five target matrices, i.e. five times.
    
  • The only way to exit the while loop is by using the condition.

• Five manipulations with cp == 1
  
• Four manipulations with cp == 2
  
• One manipulations with cp == 3

• either adds them to stack if the element is a digit
  
• or processes the last two elements of stack by use of the current element of s into a new last element of stack which replaces the processed two elements.

• First operator: (1, 2)
  
• Second operator: (3, 4)
  
• Third operator: ((1, 2), (3, 4))

• Start by placing the following lines in the only possible order:
  
  while (n > 0) { } var n = m.size () --n
• Remaining lines are
  
  var px = x var py = y ++m[px][py] px = (px + dx) % m.size () py = (py + dy) % m.size ()
  The first two of these lines only make sense if they are placed before the while loop.Concurrently, the last three lines only make sense if they are placed inside the while loop.
  
• That's all for function f. It does exactly what the goal requires:
  
  • Specific elements of matrix parameter m are incremented by one.
    
  • The amount of elements incremented is determined by the size of m.
    
  • Depending on the order of the lines in the while loop the incrementation process starts at the index specified by x and y or x + dx and y + dy.
    
  • The index of the element to be incremented in each following iteration of the while loop is determined by parameters dx and dy in relation to the previously incremented element.
    
  • The modulo operation ensures that the incrementation process cannot surpass the limits of m.

• At the end of the main function the goal requires an output of four matrices with sizes from three to six which suggests that the for loop encompasses most if not all the remaining lines.
  
• The first line in the for loop should obviously be
  a = generate (n)
• The last line of the for loop will probably be
  print_matrix (a)
• The while loop manages the calls of f that are required to reach each target matrix and should be easy to assemble with this knowledge.