Modifica: puzzle Bounty alla fine della domanda.

Dato un insieme di numeri a 1 cifra, dovresti determinare l'altezza che possono costruire una torre.

Le cifre vivono su un piano orizzontale con un livello del suolo dove possono stare. Nessuna cifra vuole essere confusa con un numero a più cifre, quindi hanno sempre uno spazio vuoto su entrambi i lati.

4 2  1 9  6  8

Una cifra può trovarsi sopra un'altra:

2
6

o può essere supportato da altri due in diagonale al di sotto di esso:

 9
5 8

Il (i) inferiore (i) deve sostenere il peso supportato dal superiore (se presente), più il peso del superiore che è sempre 1 . Se ci sono due sostenitori, dividono uniformemente il peso totale di quello superiore (50% -50%).

Il peso di ogni cifra è 1 indipendente dal suo valore.

Se una cifra ne supporta altre due, deve essere in grado di supportare la somma del loro peso corrispondente. Una cifra può supportare al massimo il suo valore numerico.

Alcune torri validi (con altezze 4, 3e 5):

            0          
7           1
5    1     1 1         9 supports a total weight of 1.5 = (1+1/2)/2 + (1+1/2)/2
2   5 4    5 5        
3  5 9 5  5 6 3        6 supports a total weight of 3 =  1.5 + 1.5 = (2*1+(2*1/2))/2 + (2*1+(2*1/2))/2

Alcune torri non valide:

1         5           The problems with the towers are (from left to right):
1  12    2 3     8      1 can't support 1+1; no space between 1 and 2;
1  5 6  1 1 1   9       1 can't support 1.5 = (1+1/2)/2 + (1+1/2)/2; 8 isn't properly supported (digits at both bottom diagonals or exactly below the 8)    

Dovresti scrivere un programma o una funzione che fornisca un elenco di cifre come output di input o restituisca l'altezza della torre più alta costruibile usando alcune (forse tutte) di quelle cifre.

Ingresso

• Un elenco di numeri a una sola cifra non negativi con almeno un elemento.

Produzione

• Un unico numero intero positivo, l'altezza della torre più alta costruibile.
• La tua soluzione deve risolvere qualsiasi caso di test di esempio in meno di un minuto sul mio computer (testerò solo casi chiusi. Ho un PC sotto la media.).

Esempi

Il formato è Input list => Output numbercon una possibile torre sulle righe successive che non fa parte dell'output.

[0]  =>  1

0

[0, 1, 1, 1, 1, 1]  =>  3

  0
  1
 1 1

[1, 1, 1, 1, 1, 2, 2]  =>  4

   1
   1
  1 1
 1 2 2

[0, 0, 2, 2, 2, 2, 2, 5, 5, 5, 7, 7, 9]  =>  9

0
2
2
5
5
5
7
7
9

[1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5]  =>  9

   1
   2
   2
   3
   4
   5
  3 3
 4 4 4
5 5 5 5

[0, 0, 0, 0, 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 5, 5, 5, 5, 7, 7, 9]  =>  11

   0
   1
   2
   3
   4
   5
  3 3
  4 5
  5 5
 3 7 3
2 7 9 2

[0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9]  =>  12

 0
 1
 2
 3
 4
 5
 6
 7
4 5
6 7
8 8
9 9

[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9]  =>  18

      0
      1
      2
      3
      4
      5
      6
      7
      8
      9
     5 5
     6 6
     7 7
    4 8 4
   3 7 7 3
  2 6 8 6 2
 2 5 8 8 5 2
 3 9 9 9 9 3

Questo è code-golf, quindi vince l'ingresso più breve.

generosità

Assegnerò 100 ricompense di reputazione (non correlate a quella già assegnata) per aver risolto il problema esteso di seguito in tempo polinomiale (per quanto riguarda la lunghezza della lista di input) o per dimostrare che non è possibile (supponendo P! = NP). Dettagli del problema esteso:

• i numeri di input possono essere numeri interi non negativi e non solo cifre
• i numeri a più cifre occupano lo stesso posto dei numeri a una cifra
• i numeri a più cifre possono supportare il loro valore numerico, ad esempio 24possono supportare24

L'offerta generica non ha una data di scadenza. Aggiungerò e ricompenserò la generosità se appare una prova.

Python 2 - 326

Funziona facilmente sotto il limite di tempo per tutti gli esempi forniti, anche se ho sacrificato un po 'di efficienza per le dimensioni, che probabilmente sarebbe evidente dato input molto più grandi. Ora che ci penso, dal momento che sono ammessi solo numeri a una sola cifra, la torre più grande possibile potrebbe non essere molto grande, e mi chiedo quale sia il massimo.

def S(u,c=0,w=[]):
 for(s,e)in[(len(w),lambda w,i:w[i]),(len(w)+1,lambda w,i:.5*sum(([0]+w+[0])[i:i+2]))]:
    m=u[:];l=[-1]*s
    for n in u:
     for i in range(s):
        if 0>l[i]and n>=e(w,i):m.remove(n);l[i]=n;break
    if([]==l or-1in l)==0:
     for r in S(m,c+1,[1+e(w,i)for i in range(s)]):yield r
 yield c
print max(S(sorted(input())))