/*
  From 
  Muhammad Zain Sarwar: "People With an IQ of 140+ Can Solve This Missing Number Puzzle!"
  https://medium.com/puzzle-sphere/people-with-an-iq-of-140-can-solve-this-missing-number-puzzle-2fda397e9161
  """
      78    62   17
      35    97   86
      21    73    ?


  It is a repeating pattern based on a specific number sequence 786217359.
  ...
  From the pattern 786217359, the last missing number should be 59.
  """

  Here we test two approaches:
  - for the rows: missing_number8_rows
    Found some equation using div and mod

  - for the columns: missing_number8_columns
    Found a solution using div.
    But the solution using digit_sum is much more fun
    (and it's the one I wrote in the comment to the post).

*/


/*
  AllGood:
  [program = 10 - A + (B + 10) + (B + 10 * A + 10) div (B + 10 div 10), res = 75, count = 1]

  resultMap = [75 = 1]

  Converted to a little nicer form using Maple:

                                                    B + 10 A + 10
                                       20 - A + B + -------------
                                                        B + 1


  AllGood:
  [program = (B - 10 - 10 div 10) div (A div (10 + 10)), res = 62, count = 1]

  resultMap = [62 = 1]

  Simplified:
                                               20 B - 220
                                               ----------
                                                   A

  AllGood:
  [program = (10 * A mod (B + A) + (10 + 10) mod (B div 10)) mod B - 10 div ((10 + B) div (A div A) div (10 + 10)), res = 26, count = 794]

  resultMap = [26 = 1]


  AllGood:
  [program = A mod (A - 10 div 10) + B - (B - 10 - A mod B mod 10) mod A, res = 54, count = 663]
  [program = B + (10 * 10 div B + B) mod B - (B - 10 - A mod B mod 10) mod A, res = 54, count = 373]
  [program = (10 + (10 - 10)) div 10 + B - (B - 10 - A mod B mod 10) mod A, res = 54, count = 330]
  [program = B + B div B - (B - 10 - A mod B mod 10) mod A, res = 54, count = 295]
  [program = 10 div 10 + B - (B - 10 - A mod B mod 10) mod A, res = 54, count = 277]
  [program = B + B div ((A + A) mod B) - (B - 10 - A mod B mod 10) mod A, res = 54, count = 170]

  resultMap = [54 = 6]


*/

/*
data(missing_number8_rows,Data,Vars,Unknown,Ops,Constants,MaxSize,Params) :-

  Data = [ [[78,62],17],
           [[35,97],86]
          ],
  % Ops = [+,-,*,/,digit_sum],
  Ops = [+,-,*,div,mod],    
  Unknown = [21,73],
  Vars = "AB",
  Constants = [10], % No constants
  MaxSize = 11,
  Params = new_map([
                     init_size=1000,
                     num_gens=1000
                   ]).
*/


/*
  Columns:


  * Using digit_sum:

  AllGood:
  [program = B - digit_sum(B) - digit_sum(digit_sum(A)), res = 64, count = 939]
  [program = B - digit_sum(B) - digit_sum(digit_sum(digit_sum(A))), res = 64, count = 349]
  [program = B - digit_sum(B) - (A * B + digit_sum(digit_sum(A)) - A * B), res = 64, count = 275]

  resultMap = [64 = 3]


  AllGood:
  [program = B - digit_sum(B) - digit_sum(digit_sum(A)), res = 64, count = 1]

  resultMap = [64 = 1]

  AllGood:
  [program = B - digit_sum(digit_sum(A)) - digit_sum(B), res = 64, count = 765]
  [program = B - digit_sum(B) - digit_sum(digit_sum(A)), res = 64, count = 458]

  resultMap = [64 = 2]


  Checking B - digit_sum(B) - digit_sum(digit_sum(A))
   78,35 -> 21
   35 - digit_sum(35) - digit_sum(digit_sum(78))
   35 - 8 - digit_sum(15) 
   35 - 8 - 6 = 21
  
   62,97 -> 73

   97 - digit_sum(97) - digit_sum(digit_sum(62))
   97 - 16 - digit_sum(digit_sum(8))
   97 - 16 - digit_sum(8)
   97 - 16 - 8 = 73

  Answer:
   17,86 -> 64

   86 - digit_sum(86) - digit_sum(digit_sum(17))
   86 - 14 - digit_sum(8)
   86 - 14 - 8 = 64



  * A different solution using div and 10 (? = 23 here)

  AllGood:
  [program = 10 + B div A + A div (10 - B div 10), res = 23, count = 646]
  [program = A div (10 - B div 10) + (10 + B div A), res = 23, count = 552]

  resultMap = [23 = 2]

  Simplified:
                                                        10 A
                                           10 + B/A - --------
                                                      -100 + B

*/

data(missing_number8_columns,Data,Vars,Unknown,Ops,Constants,MaxSize,Params) :-

  Data = [ [[78,35],21],
           [[62,97],73]
          ],
  Ops = [+,-,*,/,digit_sum],
  % Ops = [+,-,*,/,div,mod],
  Unknown = [17,86],
  Vars = "AB",
  Constants = [],
  % Constants = [10], % for div
  MaxSize = 11,
  Params = new_map([init_size=1000,
                    num_gens=1000
                   ]).