Torre mais alta de um conjunto de dígitos


20

Edit: quebra-cabeça de recompensa no final da pergunta.

Dado um conjunto de números de um dígito, você deve determinar a altura da torre que eles podem construir.

Os dígitos vivem em um plano horizontal com um nível do solo onde podem ficar. Nenhum dígito quer ser confundido com um número de vários dígitos, portanto, eles sempre têm um espaço vazio nos dois lados.

4 2  1 9  6  8

Um dígito pode estar em cima de outro:

2
6

ou pode ser suportado por outras duas na diagonal abaixo:

 9
5 8

A parte inferior precisa suportar o peso que a parte superior suporta (se houver), mais a parte superior, que é sempre 1 . Se houver dois apoiadores, eles dividem o peso total da parte superior igualmente (50% -50%).

O peso de cada dígito é 1, independentemente do seu valor.

Se um dígito suporta dois outros, ele deve ser capaz de suportar a soma do peso correspondente. Um dígito pode suportar no máximo seu valor numérico.

Algumas torres válidos (com alturas 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

Algumas torres inválidas:

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)    

Você deve escrever um programa ou função que forneça uma lista de dígitos como saídas de entrada ou retorne a altura da torre mais alta construível usando alguns (talvez todos) desses dígitos.

Entrada

  • Uma lista de números de um dígito não negativos com pelo menos um elemento.

Saída

  • Um único número inteiro positivo, a altura da torre construtiva mais alta.
  • Sua solução precisa resolver qualquer exemplo de caso de teste em menos de um minuto no meu computador (apenas testarei casos encerrados. Tenho um PC abaixo da média.).

Exemplos

O formato é Input list => Output numbercom uma torre possível nas próximas linhas que não faz parte da saída.

[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

Isso é código-golfe, então a entrada mais curta vence.

Recompensa

Premiarei 100 recompensas de reputação (não relacionadas à já premiada) por resolver o problema estendido abaixo em tempo polinomial (em relação ao comprimento da lista de entradas) ou provar que isso não é possível (assumindo P! = NP). Detalhes do problema estendido:

  • números de entrada podem ser números inteiros não negativos e não apenas dígitos
  • números de vários dígitos ocupam o mesmo lugar que números de um dígito
  • números de vários dígitos podem suportar valor numérico, por exemplo, 24podem suportar24

A oferta de recompensa não tem prazo de validade. Adicionarei e recompensarei a recompensa se aparecer uma prova.


1
Você tem dinheiro suficiente para um novo PC? Então eu tenho uma solução: P
ThreeFx

1
Sua 3-2-5-7torre me confunde. Você diz que "o (s) inferior (es) têm de suportar o peso que o superior suporta (se houver), mais o superior (sempre) 1.", que entra em conflito com você dizendo que um dígito pode suportar no máximo 'seu valor numérico' - se o peso de cada dígito é um, então qual é o sentido de ter um número diferente?
MI Wright

3
@MIWright o número indica quanto peso você pode empilhar em cima do número. Mas o peso do número em si é sempre 1.
Martin Ender

@ MartinBüttner OH, duh. Obrigado.
MI Wright

O título menciona conjuntos de dígitos, mas considerando os exemplos, parece que você quis dizer listas . Os conjuntos não podem ter duplicatas.
Grimmy #

Respostas:


10

Python 2 - 326

Funciona facilmente abaixo do limite de tempo para todos os exemplos dados, embora eu tenha sacrificado alguma eficiência pelo tamanho, o que provavelmente seria perceptível devido a entradas muito maiores. Agora que penso nisso, uma vez que apenas números de um dígito são permitidos, a maior torre possível pode não ser muito grande, e me pergunto qual é o máximo.

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())))

2
Parece que a altura máxima é de 18 anos
Kyle Gullion
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.