Summing numbers and then increasing used numbers

Question

I was making a mathematical game (viewable here: www.michaelprimo.it/beta) where you have a 3x3 grid, one central yellow button with a generated number and the other eight blue buttons with clickable and summable numbers. I thought: "what if everything is predictable?" So I made this:

• There are eight numbers: 1, 1, 1, 1, 1, 1, 1, 1, and a main number of value 2
• You must sum the numbers you have to reach exactly that number
• After that, all the numbers used for the sum AND the main number will be increased by 1
  • The next move will have 2, 2, 1, 1, 1, 1, 1, 1, and 3 as a main number. Now we must select numbers to make a sum of 3.
• This is repeated until you finish the moves

What is the biggest main number you can reach? More importantly, is the game doable (as in no particular tricks and it's not broken in some way)

I want to know if this puzzle I accidentally created during my game is good or not. I am not good with game theory, but I am interested in the argument.

Answer 1

The biggest number you can reach is

38

This is because

I ran an exhaustive brute force search to play all possible games. (Disclaimer: this python code is just a quick hack, there are better ways to implement this.)

from sympy.utilities.iterables import multiset_partitions

for K in range(1,9):
    G = [[2]+[1 for i in range(K)]]
    m = 2
    game_states = set()
    while True:
      game = G.pop(-1)
      if tuple(game) not in game_states:
          game_states.add(tuple(game))
          if sum(game[1:])==game[0]:
              G.append([i+1 for i in game])
              if G[-1][0]>m:
                  m=G[-1][0]
          else:
              for msp in multiset_partitions(game[1:],2):
                  if sum(msp[0])==game[0]:
                      G.append(sorted([game[0]+1]+[i+1 for i in msp[0]]+msp[1],reverse=True))
                  elif sum(msp[1])==game[0]:
                      G.append(sorted([game[0]+1]+[i+1 for i in msp[1]]+msp[0],reverse=True))
                  if len(G)>0 and G[-1][0]>m:
                      m=G[-1][0]
      if len(G)==0:
          break
  print(K,m)

As a bonus, highest reachable numbers a(k) on k=1,2,...,8 tiles are:

k a(k)
1 2
2 3
3 5
4 5
5 8
6 11
7 17
8 38