Compito

Dati gli attraversamenti pre-ordine e post-ordine di un albero binario completo, restituisci il suo attraversamento in ordine.

Gli attraversamenti saranno rappresentati come due elenchi, entrambi contenenti n interi positivi distinti, ciascuno identificando in modo univoco un nodo. Il tuo programma può prendere questi elenchi e generare il risultante attraversamento in ordine, usando qualsiasi formato I / O ragionevole.

È possibile supporre che l'input sia valido (ovvero, gli elenchi in realtà rappresentano gli attraversamenti di alcuni alberi).

Questo è code-golf , quindi vince il codice più breve in byte.

definizioni

Un albero binario completo è una struttura finita di nodi , rappresentata qui da interi positivi unici.

Un albero binario completo è una foglia , costituita da un singolo nodo :

                                      1

O un ramo , costituito da un nodo con due sottotitoli (chiamati sottotitoli sinistro e destro ), ciascuno dei quali è, a sua volta, un albero binario completo:

                                      1
                                    /   \
                                  …       …

Ecco un esempio completo di un albero binario completo:

                                        6
                                      /   \
                                    3       4
                                   / \     / \
                                  1   8   5   7
                                     / \
                                    2   9

L' attraversamento del preordine di un albero binario completo è definito in modo ricorsivo come segue:

• L'attraversamento del preordine di una foglia contenente un nodo n è l'elenco [ n ].
• L'incrocio di pre-ordine di un ramo che contiene un nodo n e sotto-alberi (L, R) è l'elenco [ n ] +  preordine ( L ) +  preordine ( R ), dove + è l'operatore di concatenazione elenco.

Per l'albero sopra, questo è [6, 3, 1, 8, 2, 9, 4, 5, 7] .

La traversata post ordine di un albero binario completo è definita in modo ricorsivo come segue:

• La traversata post ordine di una foglia contenente un nodo n è la lista [ n ].
• L' incrocio post ordine di un ramo contenente un nodo n e sotto-alberi (L, R) è l'elenco postordine ( L ) +  postordine ( R ) + [ n ].

Per l'albero sopra, questo è [1, 2, 9, 8, 3, 5, 7, 4, 6] .

L' incrocio in ordine di un albero binario completo è definito ricorsivamente come segue:

• La traversata in ordine di una foglia contenente un nodo n è la lista [ n ].
• L'incrocio in ordine di un ramo contenente un nodo n e sotto-alberi (L, R) è l'elenco inorder ( L ) + [ n ] +  inorder ( R ).

Per l'albero sopra, questo è [1, 3, 2, 8, 9, 6, 5, 4, 7] .

In conclusione: data la coppia di liste [6, 3, 1, 8, 2, 9, 4, 5, 7] (pre) e [1, 2, 9, 8, 3, 5, 7, 4, 6] (post) come input, il tuo programma dovrebbe produrre [1, 3, 2, 8, 9, 6, 5, 4, 7] .

Casi test

Ogni caso di test è nel formato preorder, postorder → expected output.

[8], [8] → [8]
[3,4,5], [4,5,3] → [4,3,5]
[1,2,9,8,3], [9,8,2,3,1] → [9,2,8,1,3]
[7,8,10,11,12,2,3,4,5], [11,12,10,2,8,4,5,3,7] → [11,10,12,8,2,7,4,3,5]
[1,2,3,4,5,6,7,8,9], [5,6,4,7,3,8,2,9,1] → [5,4,6,3,7,2,8,1,9]

Perl, 69 66 62 56 53 byte

Include +1 per -p

Accetta il postordine seguito dal preordine come una riga separata dallo spazio su STDIN (notare l'ordine di pre e post). I nodi sono rappresentati come lettere univoche (qualsiasi carattere che non sia spazio o newline è OK).

inpost.pl <<< "98231 12983"

inpost.pl:

#!/usr/bin/perl -p
s%(.)(.)+\K(.)(.+)\3(\1.*)\2%$4$5$3$2%&&redo;s;.+ ;;

L'uso del formato puramente numerico originale richiede molta più attenzione per identificare esattamente un singolo numero e arriva a 73 byte

#!/usr/bin/perl -p
s%\b(\d+)(,\d+)+\K,(\d+\b)(.+)\b\3,(\1\b.*)\2\b%$4$5,$3$2%&&redo;s;.+ ;;

Usare come

inpostnum.pl <<< "11,12,10,2,8,4,5,3,7 7,8,10,11,12,2,3,4,5"

Haskell, 84 83 byte

(a:b:c)#z|i<-1+length(fst$span(/=b)z),h<- \f->f i(b:c)#f i z=h take++a:h drop
a#_=a

JavaScript (ES6), 100 byte

f=(s,t,l=t.search(s[1]))=>s[1]?f(s.slice(1,++l+1),t.slice(0,l))+s[0]+f(s.slice(l+1),t.slice(l)):s[0]

L'I / O è in stringhe di caratteri "sicuri" (ad es. Lettere o cifre). Approccio alternativo, anche 100 byte:

f=(s,t,a=0,b=0,c=s.length-1,l=t.search(s[a+1])-b)=>c?f(s,t,a+1,b,l)+s[a]+f(s,t,l+2+a,l+1,c-l-2):s[a]