Ti viene dato un albero, che nella tradizione informatica ha la radice nella parte superiore e le foglie nella parte inferiore. I nodi foglia sono etichettati con numeri. Il tuo obiettivo è quello di prendere la foglia speciale contrassegnata -1e spostarla verso l'alto per essere la nuova radice.

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

Puoi immaginare di ruotare la foglia speciale verso l'alto e lasciare che il resto dell'albero penda da esso. Mantenere l'albero nel piano mentre lo si ruota per ottenere l'ordine corretto da sinistra a destra di tutti i rami.

Il nuovo albero ha tutte le foglie dell'albero originale tranne -1.

Ingresso:

Un albero le cui foglie sono interi positivi distinti, ad eccezione di una foglia di -1. La radice dell'albero avrà almeno due rami che si staccano.

L'input è dato come un elenco nidificato [3, [[16], -1], [[4]]]o come rappresentazione di stringa. I delimitatori sono opzionali e dipende da te, ma i numeri adiacenti devono essere separati.

Produzione:

Stampa o stampa l'albero capovolto nello stesso formato dell'input. L'ordine delle voci dell'elenco deve essere corretto. La modifica sul posto va bene.

Se l'input / output è un tipo di dati, deve essere quello che stampa nel formato richiesto per impostazione predefinita. Non sono consentiti incorporati che svolgono sostanzialmente il compito per te.

Casi test:

>> [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 byte

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

Provalo online .

Grazie Dennis per aver rimosso 2 byte.

Spiegazione

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.

Pyth, 26 25 24 23 byte

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

Dimostrazione. Collaudare l'imbragatura.

Questo definisce una funzione, yche accetta come input un elenco Pyth nidificato.

Esistono tre casi da esplorare in questa funzione ricorsiva, dovuta al ternario ?, e alla funzione try - tranne .x. Nella funzione, l'ingresso è b.

Il primo caso si verifica quando }\-`Jtbè vero. Questo verifica se -nella rappresentazione di stringa è presente una tb"coda" di b, che è tutto btranne il suo primo elemento. tbè anche memorizzato in J. Dal momento che tutte le etichette sono positive ad eccezione di -1, ciò sarà vero se e solo se -1non si trova nel primo elemento dell'elenco.

In questo caso, spostiamo ciclicamente a destra bdi 1 con .>b1, quindi chiamiamo la funzione in modo ricorsivo. Questo assicura che passeremo al passaggio successivo con l'elemento contenente -1come head (primo elemento) dell'elenco.

Nei prossimi due casi, quanto sopra è falso, quindi -1è in testa alla lista.

Nel secondo caso, ahbJnon genera un errore. Verrà generato un errore se e solo sehb è un numero intero. Se questo non è il caso, allora hbè un elenco e dobbiamo ruotare l'albero in modo che la -1foglia sia più vicina alla radice. ahbJrealizza questo aggiungendo Jcome elemento singolo alla fine di hb, che sposta efficacemente la radice dell'albero da ba hb.

Nel terzo e ultimo caso, viene generato un errore. Pertanto, hbè un singolo elemento. A causa del test nel primo caso, hbdeve essere -1. Quindi, possiamo restituire il resto b, vale a direJ , racchiuso in un elenco, ovvero ]J.