Você recebe uma árvore que, na tradição da ciência da computação, tem a raiz na parte superior e as folhas na parte inferior. Os nós das folhas são rotulados com números. Seu objetivo é pegar a folha especial marcada -1e movê-la para ser a nova raiz.

[3, [[16], -1], [4]] --> [[[[4], 3], [16]]]

Você pode imaginar girando a folha especial para o topo e deixando o resto da árvore pendurar nela. Mantenha a árvore no plano enquanto a gira para obter a ordem correta da esquerda para a direita de todos os galhos.

A nova árvore possui todas as folhas da árvore original, exceto -1.

Entrada:

Uma árvore cujas folhas são inteiros positivos distintos, exceto uma folha de -1. A raiz da árvore terá pelo menos dois galhos saindo.

A entrada é fornecida como uma lista aninhada [3, [[16], -1], [[4]]]ou como sua representação de string. Os delimitadores são opcionais e dependem de você, mas os números adjacentes precisam ser separados.

Resultado:

Saída ou imprima a árvore invertida no mesmo formato que sua entrada. A ordem das entradas da lista deve estar correta. A modificação no local está correta.

Se sua entrada / saída é um tipo de dados, deve ser aquele que é impresso no formato exigido por padrão. Built-ins que basicamente fazem a tarefa para você não são permitidos.

Casos de teste:

>> [3, [[16], -1], [4]]
[[[[4], 3], [16]]]

>> [2, -1]
[[2]]

>> [44, -1, 12]
[[12, 44]]

>> [[[[-1]]], [[[[4]]]]]
[[[[[[[[[4]]]]]]]]]

>> [[1, 2, 3], [4, -1, 6], [7, 8, 9]]
[[6, [[7, 8, 9], [1, 2, 3]], 4]]

>> [9, [8, [7, [6, -1, 4], 3], 2], 1]
[[4, [3, [2, [1, 9], 8], 7], 6]]

CJam, 24 24 22 bytes

l~{):T]{s$}$(+T1+}gW<p

Experimente online .

Obrigado Dennis por remover 2 bytes.

Explicação

l~          e# Read the input.
{           e# Do:
    ):T     e# Save the last item to T.
    ]       e# Wrap everything else (as an array) and the last item into an array,
    {s$}$   e#   where the one with -1 (having "-" if stringified) is the first item.
    (+      e# Insert the second array into the first array as the first item,
            e#   or just move the -1 to the end if the first item is already -1.
    T1+     e# Check if the array before this iteration ended with -1.
}g          e# Continue the loop if it did't.
W<p         e# Remove the -1 and print.

Pitão, 26 25 24 23 bytes

L?y.>b1}\-`Jtb.xyahbJ]J

Demonstração. Equipamento de teste.

Isso define uma função, yque recebe uma lista Pyth aninhada como entrada.

Há três casos a serem explorados nessa função recursiva, devido à função ternária ?, e try - except .x,. Na função, a entrada é b.

O primeiro caso ocorre quando }\-`Jtbé verdade. Isso testa se existe uma representação -na cadeia de caracteres tb, a "cauda" de b, que é tudo bexceto seu primeiro elemento. tbtambém é armazenado em J. Como todos os rótulos são positivos, exceto -1, isso será verdadeiro se e somente se o -1não estiver no primeiro elemento da lista.

Nesse caso, alternamos ciclicamente com a tecla b1 e .>b1, em seguida, chamamos a função recursivamente. Isso garante que avançaremos para a próxima etapa com o elemento que contém -1como cabeçalho (primeiro elemento) da lista.

Nos próximos dois casos, o exposto acima é falso, assim -1como o cabeçalho da lista.

No segundo caso, ahbJnão gera um erro. Um erro será gerado se e somente se hbfor um número inteiro. Se não for esse o caso, hbé uma lista e precisamos rotacionar a árvore para que a -1folha fique mais próxima da raiz. ahbJrealiza isso anexando Jcomo um único elemento no final de hb, que efetivamente move a raiz da árvore de bpara hb.

No terceiro e último caso, um erro é gerado. Assim, hbé um único elemento. Por causa do teste no primeiro caso, hbdeve ser -1. Assim, podemos retornar o restante de b, a saber J, agrupados em uma lista, a saber ]J.