^{Diese Herausforderung wurde durch eine Frage zu Mathematica.SE inspiriert .}

Angenommen, Sie haben eine verschachtelte Liste / ein Array mit einer beliebigen Struktur (die Listen auf jeder Ebene müssen nicht unbedingt die gleiche Länge haben). Der Einfachheit halber nehmen wir an, dass die Knoten nicht negative ganze Zahlen oder leere Arrays sind. Als Beispiel

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

Manchmal ist es bequemer, diese Liste zu reduzieren, um die Knoten zu manipulieren, z

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

Am Ende möchten Sie jedoch die ursprüngliche Struktur beibehalten und diese dann wieder herstellen

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

Ihre Aufgabe ist es, diesen letzten Schritt durchzuführen.

Wenn eine verschachtelte Liste beliebiger nicht negativer Ganzzahlen, die die gewünschte Struktur des Ergebnisses darstellt, und eine flache Liste nicht negativer Ganzzahlen, die die gewünschten Werte darstellen, die flache Liste in die Form der strukturierten Liste umformen. Sie können davon ausgehen, dass beide Listen die gleiche Anzahl von ganzen Zahlen enthalten.

Wie üblich müssen Sie sich nicht mit ungültigen Eingaben befassen (z. B. wenn die zweite Liste nicht flach ist, die Eingabe syntaktisch fehlerhaft ist, keine Ganzzahlen als Knoten usw.). Sie können die Eingabearrays in Ihrem Code ändern.

Sie können eine Funktion oder ein Programm schreiben, indem Sie eine Eingabe über STDIN, ein Befehlszeilenargument oder ein Funktionsargument vornehmen, und Sie können das Ergebnis zurückgeben oder es an STDOUT ausgeben. Sie können jedes beliebige Listen- oder Zeichenfolgenformat verwenden, um die Eingabe und Ausgabe darzustellen (sofern das Format eindeutig ist und die Eingabe nicht vorverarbeitet wurde). Außerdem muss das Format beider Eingaben konsistent sein (sodass Sie eine Eingabe beispielsweise nicht als Zeichenfolge und die andere nicht als Liste verwenden können). Sie können die Eingabelisten in beliebiger Reihenfolge verwenden, geben Sie jedoch in Ihrer Antwort die genaue Eingabemethode an.

Eine weitere Einschränkung: Sie dürfen keine regulären Ausdrücke verwenden. Dies ist eine Array-Manipulationsaufforderung, keine String-Manipulationsaufforderung.

Dies ist Codegolf, daher gewinnt die kürzeste Antwort (in Bytes).

Testfälle

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 Bytes

lA,sNerN%l~]z

Übernimmt die Eingabe über STDIN im selben Format wie die vorherige CJam-Antwort:

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

und gibt die Ergebniszeichenfolge an STDOUT aus

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

Ich behandle einfach die erste Zeile als Zeichenfolge, wandle alle Ziffern in Zeilenumbrüche um, teile sie bei einem oder mehreren Vorkommen von Zeilenumbrüchen auf, lege die zweite Zeile als Array auf einen Stapel, wickle ein Array ein und reiße die beiden Arrays (Zeilen) zusammen. Der Ausdruck erfolgt automatisch, und da die erste Zeile als Zeichenfolge behandelt wurde, bleiben ihre Klammern erhalten.

Code-Erweiterung

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";

Vielen Dank an @ user23013 für das Speichern von 3 Bytes.

Probieren Sie es hier online aus

JavaScript, ES6, 44 Byte

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

Dies erzeugt eine Funktion, fdie wie folgt aufgerufen werden kann

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

dh das verschachtelte Array und das Werte-Array als Eingabeargumente. Die Ausgabe der Funktion ist das konvertierte verschachtelte Array.

Diese Frage ist eine sehr schöne Frage für die Rekursion, deshalb ist die Antwort eine nette und nette Rekursionsfunktion. Ich erstelle eine Funktion f, die das erste Argument mit der mapMethode konvertiert . Wenn das Element ein Array ist, ruft es für jedes Element ferneut auf. Andernfalls ruft es für Ganzzahlen das i- ^te Element ab und gibt dieses zurück, wobei der Wert von inkrementiert wird i. Der Wert von iwird bei jedem rekursiven Aufruf weitergegeben, um die Reihenfolge korrekt zu halten.

Die Array-gegen-Integer-Erkennung wird erneut mit dieser mapMethode durchgeführt. Für eine Array-Variable mapist eine gültige Funktion, während für ganzzahlige Variablen keine Eigenschaft oder Funktion mapdefiniert ist, die als definiert bezeichnet wird.

Dies funktioniert in einem aktuellen Firefox-Browser (aufgrund von ES6).

JavaScript, ES6, 41 Byte

Die Antwort von Optimizer hat mich wirklich beeindruckt , es war sehr geschickt und ich habe viel gelernt. Als ich es mir jedoch ansah, fand ich eine Möglichkeit, es leicht zu verkürzen und einen kleinen Fehler zu beheben:

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

Ich nahm die iVariable heraus und ersetzte sie durch eine shift(). Dies macht es etwas kürzer und behebt das Problem mit der Tatsache, dass ies als Wert und nicht als Referenz übergeben wird, wodurch einige Zahlen aus dem endgültigen Array wiederholt und einige am Ende nicht verwendet wurden. Auch hier war die Antwort von Optimizer sehr gut durchdacht, besser als ich es hätte tun können, ich habe sie nur ein wenig korrigiert.

Dyalog APL, 14 Zeichen

Dies ist ein Kinderspiel: (∊a)←b.

Normalerweise ∊abedeutet aabgeflacht, aber wenn es auf der linken Seite einer Aufgabe auftritt, tut es genau das, wonach dieses Problem verlangt. Um die Anforderung zu erfüllen, eine Funktion zu sein, sind einige zusätzliche Kringel erforderlich: {a←⍺⋄(∊a)←⍵⋄a}(geschweifte Klammern für Lambda; ⍺und ⍵für linkes und rechtes Argument; ⋄für Anweisungstrennzeichen).

Test auf tryapl.org. Beachten Sie, dass in APL der leere numerische Vektor mit ⍬("zilde") bezeichnet wird. Vektoren mit einem Element werden konstruiert, (,A)weil (A)dies einen Skalar bedeuten würde. In der Ausgabe dieses Ding:

┌⊖┐
│0│
└~┘

steht für einen leeren numerischen Vektor. Die 0in der Mitte zeigt das "prototypische Element", das kein Element des Arrays ist.

Python, 51

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

Beispiel:

>>> 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]

Das war ein sehr schönes Problem. Während ich weiter daran arbeitete, bemerkte ich immer wieder, dass Teile meines Codes unnötig waren und die Logik zu einem einfachen Ausdruck zusammenfiel. Das meiste Golfspiel bestand darin, den richtigen Algorithmus zu finden.

sist die Struktur und vist die flache Liste der Liste. Die Idee ist zu überprüfen, ob seine Ganzzahl mit s<[](Python 2 behandelt Zahlen als kleiner als Listen). Wenn dies der Fall ist, nehmen Sie einfach das erste Element von und geben Sie es zurück, und ventfernen Sie es aus v. Andernfalls lesen Sie die Unterlisten von s.

Das pop ist ein Stück imperativer Magie in sehr funktionalem Code. Da alle vauf dieselbe Instanz verweisen, wird ein Element, das von einer Instanz abgesetzt wird, aus vder gesamten Ausführungsstruktur entfernt, sodass jede Zahl in vnur einmal verwendet wird. Das Listenverständnis [f(x,v)for x in s]erstellt einen Aufrufbaum, der von links nach rechts und von unten nach unten erweitert wird, sodass die Elemente vin der richtigen Reihenfolge angeordnet werden.

Ich schrieb dies unabhängig von der Antwort von grc , aber es stellte sich heraus, dass es sich um das Verschieben eines einzelnen [(und von Variablennamen) handelte. Die Bewegung spart ein Zeichen aufgrund des Abstands. Das Verschieben der Klammern bedeutet, dass der Knotenfall sofort in der Funktion behandelt wird und nicht als Teil des Listenverständnisses, das ich nicht berücksichtigt habe.

Wir können ein Zeichen für 49 speichern, wenn wir die Eingabeanforderungen erweitern, um den Wert aus STDIN und der Struktur als Funktionsargument zu übernehmen. Dies können wir verwenden map.

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

Rubin, 39

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

Wiederholt, bis das Element in der Liste eine Ganzzahl ist.
Da der Aufruf von Integer.map eine Ausnahme darstellt,
wird der Rettungsabschnitt aufgerufen , der das erste Element aus der zweiten Liste "herausspringt / verschiebt".

Regex-Lösung ... etwas länger:

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

Probieren Sie es mit einigen Testfällen

CJam, 43 37 35 33 Bytes

Dies ist eine direkte Umsetzung meiner JS-Antwort . Ein bisschen lang, das meiste davon wird von der Typenerkennung in Anspruch genommen.

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

Nimmt die beiden Input Arrays auf zwei Zeilen von STDIN wie

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

und Ausgänge zu STDOUT wie

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

Probieren Sie es hier online aus

Haskell, 113 104 Byte (86 + 18 aus Datentypdeklaration)

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 hat keinen eingebauten verschachtelten Array-Datentyp, daher musste ich meinen eigenen rollen. Aus diesem Grund enthält das Programm nur Pattern Matching und explizite Strukturrekursionen. Der letzte Testfall lautet

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

und bewertet zu

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

Mathematica, 41 Bytes

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

Dies ist eine unbenannte Funktion, die die Struktur als erstes Argument und die Werteliste als zweites Argument verwendet (und eine Liste zurückgibt).

Dies ist eine gelungene Version der akzeptierten Antwort auf die Frage, die diese Herausforderung inspiriert hat. Ich poste dies selbst und werde diese Antwort nicht akzeptieren (sollte es tatsächlich die kürzeste bleiben, was ich bezweifle). Auf diese Weise soll verhindert werden, dass jemand anderes die Herausforderung gewinnt, indem die Antwort im Grunde genommen kopiert wird.

Wie es funktioniert:

• Wir definieren eine Listablereine Funktion. Auflistbare Funktionen werden automatisch auf die Elemente eines Listenarguments (rekursiv) anstelle der Liste selbst angewendet. Wenn Sie also fdie strukturierte Liste aufrufen, wird grundsätzlich eine Liste mit derselben Struktur zurückgegeben, wobei jede Ganzzahl idurch ersetzt wird f[i].
• Wir speichern die Werteliste im globalen mund einen Zähler im i.
• Bei jedem Aufruf f(unabhängig vom Argument) geben wir das nächste Element von zurück m.

Rebol - 87 66 60

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

Ungolfed:

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

Beispiel:

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

C #, 225 + 13 = 239 185 + 35 = 220 172 + 35 = 207 Bytes

Benötigt dies:

using System;using o=System.Object;

Akzeptiert object[]s als Argumente.

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;}

Ungolfed-Code:

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 Bytes

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

Ich habe gehört, Sie mögen Listen in Listen, also setze ich Funktionen in Funktionen.

Edit: Wenn ich mir jetzt die Antwort von grc ansehe, wird mir klar, dass das völlig unnötig war. Naja...

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).

Probelauf:

?- 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]]]].

Das letzte []Element in der Abfrage dient zum Überprüfen der nicht übereinstimmenden Anzahl von Elementen, was in dieser Frage nicht erforderlich zu sein scheint.

Erlang, 116 93 Bytes

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.

Verwendet zwei unreine Funktionen fund g. fmanipuliert das Prozesswörterbuch, indem es nauf die flache Liste setzt und jedes Element der verschachtelten Liste zuordnet g(X). gSetzt dann njedes Mal, wenn er auf einen Nicht-Listenwert stößt, auf das Ende der flachen Liste und gibt den Kopf der flachen Liste zurück.

Perl 5, 49 Bytes

Das erste Argument ist die Vorlagenstruktur, das zweite sind die Werte.

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

Testprogramm

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

Das Eingabearray ist $ i, das Mapping ist $ m, die Ausgabe ist $ o

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

$ h ist eine Zeichenfolge, die die rekursive Funktion enthält, und Sie können Code ausführen, der in einer Zeichenfolge enthalten ist, mit. $ h ... Und es wäre 30 Byte kürzer, wenn Powershell nicht darauf bestehen würde, Einzelwert-Arrays auf Skalare und ein Array zu reduzieren mit einem einzelnen Nullwert auf Null

und ein praktischer Array-Struktur-Viewer zur Überprüfung der Ergebnisse

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

Bearbeiten: 149

als unflatten.ps1 speichern:

$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;

edit: 136, Inline-Ausgabe-Array-Erstellung und Schreibausgabe

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

Aufruf mit. \ unflatten.ps1 [Eingabe-Array] [Mapping-Array]

Die Ausgabe wird in die Pipeline geschrieben. Führen Sie dies zuerst aus:

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;
    }
}

und renne mit

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

C #, (40 + 123) = 163 Bytes ODER (67 + 81) = 148 Bytes

C # leidet hier unter seiner statischen Typisierung und langen Namespaces.

Array-Methode

Anweisungen verwenden:

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

Code:

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);}

Stack-Methode (verwendet die Stack-Struktur anstelle von Arrays)

Anweisungen verwenden:

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

Code:

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

Erste Versuche, erster Code Golf hier.