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
, 3
e 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 number
com 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,
24
podem suportar24
A oferta de recompensa não tem prazo de validade. Adicionarei e recompensarei a recompensa se aparecer uma prova.
3-2-5-7
torre 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?