^{Wyzwanie to zostało zainspirowane pytaniem na Mathematica.SE .}

Załóżmy, że masz zagnieżdżoną listę / tablicę o dowolnej strukturze (listy na każdym poziomie niekoniecznie mają taką samą długość). Dla uproszczenia założymy, że węzły to nieujemne liczby całkowite lub puste tablice. Jako przykład

[[[1, 3], 2], [1, 4], 12, [[0, [], 0], [5, [7]]]]

Czasami wygodniej jest spłaszczyć tę listę, aby wykonać pewne manipulacje węzłami, np

--> [1, 3, 2, 1, 4, 12, 0, 0, 5, 7]
--> [1, 1, 0, 1, 0, 0, 0, 0, 1, 1]

Ale ostatecznie chcesz zachować oryginalną strukturę, więc chcesz z powrotem to zmienić

--> [[[1, 1], 0], [1, 0], 0, [[0, [], 0], [1, [1]]]

Twoim zadaniem jest wykonanie ostatniego kroku.

Biorąc pod uwagę zagnieżdżoną listę dowolnych nieujemnych liczb całkowitych, która reprezentuje pożądaną strukturę wyniku, oraz płaską listę nieujemnych liczb całkowitych, które reprezentują pożądane wartości, przekształca płaską listę w formę listy strukturalnej. Możesz założyć, że obie listy zawierają tę samą liczbę liczb całkowitych.

Jak zwykle nie musisz radzić sobie z nieprawidłowymi danymi wejściowymi (np. Druga lista nie jest płaska, dane wejściowe są zniekształcone składniowo, nie mają liczb całkowitych jako węzłów itp.). Możesz modyfikować tablice wejściowe w swoim kodzie.

Możesz napisać funkcję lub program, przyjmując dane wejściowe przez STDIN, argument wiersza poleceń lub argument funkcji, i możesz zwrócić wynik lub wydrukować go do STDOUT. Możesz użyć dowolnego wygodnego formatu listy lub łańcucha do reprezentowania danych wejściowych i wyjściowych (o ile format jest jednoznaczny, a dane wejściowe nie są przetwarzane wstępnie). Ponadto format obu danych wejściowych musi być spójny (na przykład nie można traktować jednego wejścia jako ciągu, a drugiego jako listy). Możesz wziąć listy wprowadzania w dowolnej kolejności, ale proszę podać dokładną metodę wprowadzania w odpowiedzi.

Jeszcze jedno ograniczenie: nie wolno używać wyrażeń regularnych. Jest to wyzwanie manipulacji tablicą, a nie wyzwanie manipulacji ciągiem.

To jest kod golfowy, więc wygrywa najkrótsza odpowiedź (w bajtach).

Przypadki testowe

Structure                             Values                 Result
[[[1,3],2],[1,4],12,[[0,0],[5,[7]]]]  [1,1,0,1,0,0,0,0,1,1]  [[[1,1],0],[1,0],0,[[0,0],[1,[1]]]]
[[[0,0],0],[0,0],0,[[0,0],[0,[0]]]]   [1,1,0,1,0,0,0,0,1,1]  [[[1,1],0],[1,0],0,[[0,0],[1,[1]]]]
[]                                    []                     []
[[]]                                  []                     [[]]
[0,1,2,3]                             [5,1,0,5]              [5,1,0,5]
[[[[[0]]]]]                           [123]                  [[[[[123]]]]]
[0,[1,[]],[[]],[2,3],[]]              [1,6,1,8]              [1,[6,[]],[[]],[1,8],[]]

CJam, 18 16 13 bajtów

lA,sNerN%l~]z

Pobiera dane wejściowe przez STDIN w tym samym formacie, co poprzednia odpowiedź CJam:

[0 [11 []] [[]] [2 3] []]
[1 6 1 8] 

i przekazuje ciąg wynikowy do STDOUT

[1 [6 []] [[]] [1 8] []]

Po prostu traktuję pierwszy wiersz jako ciąg, przekształcam wszystkie znaki cyfrowe na znaki nowej linii, dzielę na jedno lub więcej wystąpień nowych linii, umieszczam drugą linię jako tablicę na stosie, zawijam tablicę i spakowujemy razem dwie tablice (rzędy). Drukowanie jest automatyczne, a ponieważ pierwszy wiersz został potraktowany jako ciąg znaków, zachowuje nawiasy.

Rozszerzenie kodu

lA,sNerN%l~]z
l                     "Read the first line of input. This is the nested array";
 A,s                  "Get array [0,1,2...9] and  convert it to string '012..9'";
    Ner               "Replace all occurrences of 0,1,2,..9 with new line";
       N%             "Split on one or more occurrences of new line";
         l~           "Read the second line as an array";
           ]          "Wrap both the splitted string and the second line array";
                      "in an array";
            z         "Transpose the array, there by placing the numbers from second";
                      "input array in the split holes of first input string";

Dzięki @ user23013 za zapisanie 3 bajtów.

Wypróbuj online tutaj

JavaScript, ES6, 44 bajty

f=(a,b,i=0)=>a.map(x=>x.map?f(x,b,i):b[i++])

Tworzy to funkcję, fktórą można wywołać jak

f([0,[1,[]],[[]],[2,3],[]],[1,6,1,8])

tj. tablica zagnieżdżona i tablica wartości jako argumenty wejściowe. Dane wyjściowe funkcji to przekonwertowana tablica zagnieżdżona.

To pytanie jest bardzo miłe dla rekurencji, dlatego odpowiedź jest zgrabną i słodką funkcją rekurencji. Tworzę funkcję, fktóra konwertuje pierwszy argument za pomocą mapmetody. Dla każdego elementu, jeśli element jest tablicą, wywołuje fponownie, w przeciwnym razie, dla liczb całkowitych, pobiera ^ity element i zwraca go, zwiększając wartość i. Wartość ijest przekazywana w każdym wywołaniu rekurencyjnym, aby utrzymać prawidłową kolejność.

Wykrywanie tablic vs. liczby całkowite jest ponownie wykonywane przy użyciu tej mapmetody. Dla zmiennej tablicowej mapjest prawidłową funkcją, podczas gdy dla zmiennych całkowitych nie ma właściwości ani funkcji wywoływanej mapzdefiniowanej dla zmiennej.

Działa to w najnowszej przeglądarce Firefox (z powodu ES6).

JavaScript, ES6, 41 bajtów

Byłem pod wrażeniem odpowiedzi Optimizera , zrobiono to bardzo sprytnie i wiele się nauczyłem. Jednak po przejrzeniu go znalazłem sposób, aby go nieco skrócić i naprawić mały błąd:

f=(a,b)=>a.map(x=>x.map?f(x,b):b.shift())

Wyjąłem izmienną i zastąpiłem ją shift(). To sprawia, że ​​jest nieco krótszy i rozwiązuje problem z faktem, że ijest przekazywany przez wartość, a nie przez odniesienie, co spowodowało, że niektóre liczby z końcowej tablicy powtórzyły się, a niektóre na końcu nie były używane. Znów odpowiedź Optimizera była naprawdę dobrze przemyślana, lepiej niż mogłem to zrobić, po prostu trochę ją naprawiłem.

Dyalog APL, 14 znaków

To nie myślenia: (∊a)←b.

Zwykle ∊aoznacza aspłaszczony, ale gdy pojawia się po lewej stronie zadania, robi dokładnie to, o co prosi ten problem. Aby spełnić wymóg bycia funkcją, potrzebuje kilku dodatkowych zawijasów: {a←⍺⋄(∊a)←⍵⋄a}(nawiasy klamrowe dla lambda; ⍺oraz ⍵dla lewego i prawego argumentu; ⋄dla separatora instrukcji).

Przetestuj na tryapl.org. Zauważ, że w APL pusty wektor numeryczny jest oznaczony przez ⍬(„zilde”). Wektory jednoelementowe są konstruowane za pomocą, (,A)ponieważ (A)oznaczałoby skalar. W danych wyjściowych ta rzecz:

┌⊖┐
│0│
└~┘

reprezentuje pusty wektor numeryczny. 0W środku pokazuje „prototypowy elementu”, który nie jest elementem macierzy.

Python, 51

f=lambda a,b:[b.pop(0)if x<[]else f(x,b)for x in a]

Przykład:

>>> f([0,[1,[]],[[]],[2,3],[]], [1,6,1,8])
[1, [6, []], [[]], [1, 8], []]

Python 2, 50

f=lambda s,v:v.pop(0)if s<[]else[f(x,v)for x in s]

To był bardzo piękny problem. Pracując nad tym, zdałem sobie sprawę, że fragmenty mojego kodu były niepotrzebne, a logika zamieniła się w proste wyrażenie. Większość golfa polegała na znalezieniu odpowiedniego algorytmu.

sto struktura i vpłaska lista. Chodzi o to, aby sprawdzić, czy sjest liczbą całkowitą s<[](Python 2 traktuje liczby jako mniejsze niż listy). Jeśli tak, po prostu weź i zwróć pierwszy element v, usuwając go v. W przeciwnym razie wróć na listy podrzędne s.

pop Jest kawałek bezwzględnej magii w kodzie bardzo funkcjonalnym stylu. Ponieważ wszystkie vwskazują na to samo wystąpienie, usunięcie elementu z jednego powoduje usunięcie go z vcałego drzewa wykonania, więc każda liczba w vjest używana tylko raz. Zrozumienie listy[f(x,v)for x in s] tworzy drzewo wywołań, które jest rozszerzane w pierwszej kolejności i od lewej do prawej, powodując, że elementy vsą rozmieszczane we właściwej kolejności.

Napisałem to niezależnie od odpowiedzi grc , ale okazało się, że aż do przeniesienia jednego[ (i nazw zmiennych). Ruch zapisuje znak z powodu odstępów. Przesunięcie nawiasu oznacza natychmiastowe rozpatrzenie przypadku węzła w funkcji, a nie w ramach zrozumienia listy, którego nie wziąłem pod uwagę.

Możemy zapisać znak dla 49, jeśli rozciągniemy wymagania wejściowe, aby pobrać wartość ze STDIN i struktury jako argument funkcji. To pozwala nam korzystać map.

v=input()
g=lambda s:v.pop(0)if s<[]else map(g,s)

Ruby, 39 lat

f=->a,b{a.map{|d|f[d,b]}rescue b.shift}

Powtarza się, dopóki element na liście nie będzie liczbą całkowitą.
Ponieważ wywołanie Integer.map daje wyjątek,
przechodzi do części ratunkowej, która „wyskakuje / przesuwa” pierwszy element z drugiej listy.

Regex soln ... trochę dłużej:

f=->a,b{eval a.to_s.split(/\d+/).zip(b)*''}

Wypróbuj z niektórymi przypadkami testowymi

CJam, 43 37 35 33 bajtów

Ten jest bezpośrednią konwersją mojej odpowiedzi JS . Trochę długi, z których większość jest zajęta przez wykrywanie typu.

q~:B;{{_`La`&{F}{;BW):W=}?}%}:F~`

Bierze dwie tablice wejściowe na dwóch liniach STDIN jak

[[[1 3] 2] [1 4] 12 [] [[0 0] [5 [7]]]]
[1 1 0 1 0 0 0 0 1 1]

i wyjścia jak STDOUT

[[[1 1] 0] [1 0] 0 "" [[0 0] [1 [1]]]]

Wypróbuj online tutaj

Haskell, 113 104 bajty (86 + 18 z deklaracji typu danych)

data N=I Int|L[N]
L[]!v=(L[],v)
L(a:b)!v|(c,w)<-a!v,(L d,u)<-L b!w=(L$c:d,u)
_!(n:m)=(I n,m)
s#v=fst$s!v

Haskell nie ma wbudowanego typu danych z zagnieżdżonej tablicy, więc musiałem rzucić własny. Z tego powodu program zawiera tylko dopasowanie wzorca i wyraźną rekurencję strukturalną. Ostatni przypadek testowy brzmi

L[I 0,L[I 1,L[]],L[L[]],L[I 2,I 3],L[]]#[1,6,1,8]

i ocenia

L[I 1,L[I 6,L[]],L[L[]],L[I 1,I 8],L[]]

Mathematica, 41 bajtów

Function[,m[[i++]],Listable][i=1;m=#2;#]&

Jest to funkcja bez nazwy, która przyjmuje strukturę jako pierwszy argument, a listę wartości jako drugi argument (i zwraca listę).

To jest golfowa wersja zaakceptowanej odpowiedzi na pytanie, które zainspirowało to wyzwanie. Ja to piszę i nie zaakceptuję tej odpowiedzi (jeśli rzeczywiście pozostanie najkrótsza, w co wątpię). Ma to na celu zapobieżenie wygraniu wyzwania przez inne osoby poprzez skopiowanie odpowiedzi.

Jak to działa:

• Definiujemy funkcję Listableczystą. Funkcje listowane są automatycznie stosowane do elementów argumentu listy (rekurencyjnie) zamiast samej listy, więc wywołanie flisty strukturalnej w zasadzie zwróci listę tej samej struktury z każdą liczbą całkowitą izastąpioną przez f[i].
• Przechowujemy listę wartości w globalnej mi licznik w i.
• Za każdym razem, gdy wywołujemy f(niezależnie od argumentu), zwracamy następny element m.

Rebol - 87 66 60

f: func[a[block!]b][map-each n a[any[attempt[f n b]take b]]]

Nie golfowany:

f: func [a [block!] b] [
    map-each n a [
        any [
            attempt [f n b]  
            take b
        ]
    ]
]

Przykład:

>> f [0 [1 []] [[]] [2 3] []]   [1 6 1 8]           
== [1 [6 []] [[]] [1 8] []]

C #, 225 + 13 = 239 185 + 35 = 220 172 + 35 = 207 bajtów

Wymaga tego:

using System;using o=System.Object;

Akceptuje object[]s jako argumenty.

o[]u(o[]a,o[]b){var c=a;int i=0;Action<o[],o[]>d=null;d=(e, f)=>{for(int j=0;j<e.Length;j++){if(e[j]is int){f[j]=b[i];i++;}else{d((o[])e[j],(o[])f[j]);}}};d(a,c);return c;}

Nieskluczony kod:

object[] Unflatten(object[] structure, object[] values)
{
    var c = structure;
    int i = 0;
    Action<object[], object[]> recursiveFunc = null;
    recursiveFunc = (e, f) =>
    {
        for (int j = 0; j < e.Length; j++)
        {
            if (e[j] is int)
            {
                f[j] = values[i]; i++;
            }
            else
            {
                recursiveFunc((object[])e[j], (object[])f[j]);
            }
        }
    };
    recursiveFunc(structure, c);
    return c;
}

Python 2, 64 bajty

def g(N,L):f=lambda N:L.pop(0)if`N`<":"else map(f,N);return f(N)

Słyszałem, że lubisz listy na listach, więc umieściłem funkcje w funkcjach.

Edycja: Patrząc teraz na odpowiedź grc, zdaję sobie sprawę, że było to całkowicie niepotrzebne. No cóż...

SWI-Prolog 82

f([],A,[],A):-!.
f([H|T],A,[J|U],B):-(is_list(H),!,f(H,A,J,C);A=[J|C]),f(T,C,U,B).

Przykładowy przebieg:

?- f([[[1,3],2],[1,4],12,[[0,[],0],[5,[7]]]],[1,1,0,1,0,0,0,0,1,1],R,[]).
R = [[[1,1],0],[1,0],0,[[0,[],0],[1,[1]]]].

Ostatnie []w zapytaniu dotyczy sprawdzenia niedopasowanej liczby elementów, co nie wydaje się konieczne w tym pytaniu.

Erlang, 116 93 bajtów

f(R,F)->put(n,F),[g(X)||X<-R].
g([H|T])->[g(H)|g(T)];g([])->[];g(E)->[H|T]=get(n),put(n,T),H.

Używa dwóch nieczystych funkcji fi g. fmanipuluje słownikiem procesów, ustawiając ngo na płaską listę i odwzorowując każdy element listy zagnieżdżonej g(X). gnastępnie ustawia nsię na końcu płaskiej listy za każdym razem, gdy napotyka wartość inną niż lista i zwraca nagłówek płaskiej listy.

Perl 5, 49 bajtów

Pierwszy argument to struktura szablonu, drugi to wartości.

sub u{($t,$l)=@_;ref$t?[map{u$_,$l}@$t]:shift@$l}

Program testowy

use Test::More;
use Test::Deep;

sub u{($t,$l)=@_;ref$t?[map{u$_,$l}@$t]:shift@$l}

cmp_deeply u([[[1,3],2],[1,4],12,[[0,0],[5,[7]]]],[1,1,0,1,0,0,0,0,1,1]),[[[1,1],0],[1,0],0,[[0,0],[1,[1]]]];
cmp_deeply u([[[0,0],0],[0,0],0,[[0,0],[0,[0]]]],[1,1,0,1,0,0,0,0,1,1]),[[[1,1],0],[1,0],0,[[0,0],[1,[1]]]];
cmp_deeply u([], []), [];
cmp_deeply u([[]], []), [[]];
cmp_deeply u([0,1,2,3], [5,1,0,5]), [5,1,0,5];
cmp_deeply u([[[[[0]]]]], [123]), [[[[[123]]]]];
cmp_deeply u([0,[1,[]],[[]],[2,3],[]], [1,6,1,8]), [1,[6,[]],[[]],[1,8],[]];
done_testing;

PowerShell: 115

tablica wejściowa to $ i, mapowanie to $ m, wyjście to $ o

$h={if($_.GetType().IsArray){if($_.c -eq 0){,@()}else{,@($_|%{.$h})}}else{$m[$c++]}};$i|%{$o=@();$c=0}{$o+=,(.$h)}

$ h jest ciągiem zawierającym funkcję rekurencyjną i można wykonać kod zawarty w ciągu za pomocą. $ h ... I byłby o 30 bajtów krótszy, gdyby PowerShell nie nalegał na spłaszczanie tablic pojedynczej wartości do skalarów i tablicy z pojedynczą wartością null na null

oraz przydatna przeglądarka struktury tablic do weryfikacji wyników

$j={if($_.GetType().IsArray){write-host '(' -n;($_|%{.$j});write-host ')' -n}else{write-host "$_" -n}};write-host '(' -n;$o|%{(.$j)}; write-host ')' -n;

edycja: 149

zapisz jako unflatten.ps1:

$m=[array]$args[1];$h={if($_.GetType().IsArray){if($_.c -eq 0){,@()}else{,@($_|%{.$h})}}else{$m[$c++]}};$args[0]|%{$o=@();$c=0}{$o+=,(.$h)};echo $o;

edycja: 136, tworzenie wbudowanej tablicy wyjściowej i zapisywanie-wyprowadzanie

$m=[array]$args[1];$h={if($_.GetType().IsArray){if($_.c -eq 0){,@()}else{,@($_|%{.$h})}}else{$m[$c++]}};echo(,@($args[0]|%{$c=0}{.$h}))

wywołanie z. \ unflatten.ps1 [tablica wejściowa] [tablica mapowania]

dane wyjściowe są zapisywane w potoku, więc uruchom najpierw:

Function View-Array{
Param([Parameter(ValueFromPipeline=$True,ValueFromPipelinebyPropertyName=$True)]
      [array]$o)

    PROCESS{
    $j={if($_.GetType().IsArray){write-host '(' -n;($_|%{.$j});write-host ')' -n}else{write-host "$_" -n}};
    write-host '(' -n;$o|%{(.$j)}; write-host ')' -n;
    }
}

i biegnij z

.\unflatten.ps1 [input array] [mapping array] | View-Array

C #, (40 + 123) = 163 bajty LUB (67 + 81) = 148 bajtów

C # cierpi z powodu swojego statycznego pisania i długich przestrzeni nazw tutaj.

Metoda tablicowa

Za pomocą instrukcji:

using o=System.Object;using System.Linq;

Kod:

o[] u(o[] x,o[] y){int i=0;Func<o[],o[],o[]> f=null;f=(a,b)=>a.Select(e=>e is int?b[i++]:f((o[])e,b)).ToArray();return f(x,y);}

Metoda stosu (używa struktury stosu zamiast tablic)

Za pomocą instrukcji:

using s=System.Collections.Generic.Stack<object>;using System.Linq;

Kod:

System.Func<s,s,s>f=null;f=(a,b)=>new s(a.Select(e=>e is int?b.Pop():f((s)e,b)));

Pierwsze próby, pierwszy golf tutaj.