^{Bu zorluk, Mathematica.SE konusundaki bir sorudan esinlenmiştir .}

Diyelim ki bazı keyfi yapıların iç içe geçmiş bir listesi / dizisi var (her seviyedeki listelerin mutlaka aynı uzunlukta olması gerekmez). Basit olması için, düğümlerin negatif olmayan tamsayılar veya boş diziler olduğunu varsayacağız. Örnek olarak

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

Bazen bu listeyi düzleştirmek, düğümlerin bazı manipülasyonlarını gerçekleştirmek için örneğin

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

Ama sonunda, aslında orijinal yapıyı korumak istiyorsunuz, bu yüzden bunu tekrar açmak istiyorsunuz.

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

Göreviniz bu son adımı gerçekleştirmek.

Sonuçta istenen yapıyı temsil eden iç içe geçmiş bir tamsayı olmayan negatif tamsayı listesi ve istenen değerleri temsil eden düz olmayan bir tamsayı listesi göz önüne alındığında, düz listeyi yapılandırılmış liste biçiminde yeniden şekillendirir. Her iki listenin de aynı sayıda tam sayı içerdiğini varsayabilirsiniz.

Her zamanki gibi geçersiz girdiyle uğraşmak zorunda değilsiniz (örneğin ikinci liste düz değil, girdi sözdizimsel olarak bozuk, düğüm gibi tamsayılar yok, vb.). Giriş dizilerini kodunuzda değiştirebilirsiniz.

STDIN, komut satırı argümanı veya işlev argümanı üzerinden girdi alarak bir işlev veya program yazabilir ve sonucu döndürebilir veya STDOUT'a yazdırabilirsiniz. Girdi ve çıktıyı temsil etmek için herhangi bir uygun liste veya dize biçimini kullanabilirsiniz (biçim belirsiz ve girdi önceden işlenmediği sürece). Ayrıca, her iki girişin biçiminin de tutarlı olması gerekir (bu nedenle örneğin bir girişi dize, diğerini liste olarak alamazsınız). Giriş listelerini her iki sırada da alabilirsiniz, ancak lütfen cevabınızdaki giriş yöntemini tam olarak belirtin.

Bir kısıtlama daha: normal ifadeler kullanmamalısınız. Bu bir dizi manipülasyon mücadelesi değil, bir dizi manipülasyon mücadelesidir.

Bu kod golf, yani en kısa cevap (bayt cinsinden) kazanır.

Test Kılıfları

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 bayt

lA,sNerN%l~]z

STDIN ile girişi önceki CJam cevabıyla aynı formatta alır:

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

ve sonuç dizgisini STDOUT'a gönderir

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

İlk satırı string olarak ele alıyorum, tüm rakam karakterlerini yeni satırlara dönüştürüyorum, bir ya da daha fazla sayıda yeni satırın üzerine böldüm, ikinci satırı yığına bir dizi olarak koydum, bir diziye sardım ve iki diziyi bir araya getirdim (satırlar). Baskı işlemi otomatiktir ve ilk satır dize olarak kabul edildiğinden, parantezlerini korur.

Kod genişletme

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

3 byte tasarruf için @ user23013 teşekkürler.

Burada çevrimiçi deneyin

JavaScript, ES6, 44 bayt

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

Bu fgibi çağrılabilir bir fonksiyon yaratır

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

yani, yuvalanmış dizi ve değerler dizi olarak giriş argümanları. Fonksiyonun çıktısı dönüştürülmüş iç içe dizidir.

Bu soru, özyineleme için çok güzel bir sorudur, bu yüzden cevabın düzgün ve tatlı bir özyineleme işlevi olduğu söylenebilir. Yöntemi fkullanarak ilk argümanı dönüştüren bir fonksiyon yarattım map. Eleman diziyse Her öğe için, bu aramaları faksi takdirde tamsayılar için, bu i alır, yine ^inci madde ve değerini artmasından getiriyi i. Değeri, iher bir özyinelemeli çağrıda sırasını doğru tutabilmek için aktarılır.

Dizi ve Tamsayılı algılama yine mapyöntem kullanılarak yapılmıştır . Bir dizi değişkeni mapiçin geçerli bir işlevdir, tamsayılı değişkenler mapiçin ise değişken için tanımlanmış bir özellik veya işlev yoktur .

Bu, en son Firefox tarayıcısında çalışır (ES6 nedeniyle).

JavaScript, ES6, 41 bayt

Optimizer’ın cevabından gerçekten etkilendim , çok akıllıca yapıldı ve çok şey öğrendim. Ancak üzerine baktığımda onu biraz kısaltmanın ve küçük bir hatayı düzeltmenin bir yolunu buldum:

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

iDeğişkeni çıkardım ve a ile değiştirdim shift(). Bu, onu biraz daha kısaltır ve ireferansla değil, değere göre iletilen gerçeği ile sorunu düzeltir , cadı son diziden bazı sayıların tekrarlanmasına ve sonunda kullanılmamasına neden olur. Yine, Optimizer’in cevabı gerçekten iyi düşünülmüş, yapabileceğimden daha iyi, sadece biraz düzelttim.

Dyalog APL, 14 karakter

Bu no-beyin geçerli: (∊a)←b.

Normal olarak, düzleştirilmiş ∊ademektir a, ancak bir ödevin sol tarafında gerçekleştiğinde, tam olarak bu sorunun ne istediğini yapar. İşlev olmanın gerekliliğine uymak için birkaç ekstra kargaşaya ihtiyaç duyar: {a←⍺⋄(∊a)←⍵⋄a}(lambda için kıvırcık ayraçlar; ⍺ve ⍵sol ve sağ argüman için; ⋄deyim ayırıcı için).

Tryapl.org'da test edin. ⍬APL'de boş sayısal vektörün ("zilde") ile belirtildiğine dikkat edin. Tek eleman vektörler ile inşa edilir (,A)çünkü (A)bir sayıl anlamına gelecektir. Çıktıda, bu şey:

┌⊖┐
│0│
└~┘

boş bir sayısal vektörü temsil eder. 0Merkezinde dizinin bir unsuru değildir "prototip elemanı" gösterilmektedir.

Python, 51

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

Örnek:

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

Bu çok güzel bir problemdi. Üzerinde çalışmaya devam ederken, kodumun bitlerinin gereksiz olduğunu ve mantığın basit bir ifadeyle çöktüğünü farkettim. Golfün çoğu doğru algoritmayı bulmaktaydı.

syapı ve vlistenin düz listesidir. Fikir, sbir tamsayı olup olmadığını kontrol etmektir s<[](Python 2, sayıları listelerden daha küçük olarak kabul eder). Eğer öyleyse, basitçe ilk elemanını alıp geri vgetirin v. Aksi takdirde, alt listelerinin üzerine tekrar gelin s.

Bu pop , çok fonksiyonel stil kodunda zorunlu bir sihir parçasıdır. Hepsi vaynı örneğe işaret ettiğinden , bir elemanın bir tanesinden alınması onu vtüm yürütme ağacından kaldırır , bu nedenle her sayı vyalnızca bir kez kullanılır. Liste anlayışı [f(x,v)for x in s], derinliklerin ilk önce ve soldan sağa doğru genişleyen ve elemanların vdoğru sırayla yarılmasını sağlayan bir çağrı ağacı oluşturur .

Bunu, grc'nin cevabından bağımsız olarak yazdım , ancak aynı, tek [(ve değişken isimleri) taşımak kadar aynı oldu . Hareket boşluk nedeniyle bir karakter kaydeder. Parantez hareketi, düşünmediğim liste kavrayışının bir parçası olarak değil, düğüm vakasını işlevde hemen ele almak anlamına gelir.

Giriş gereksinimlerini STDIN'den ve yapıyı bir işlev argümanı olarak almak için girdi koşullarını genişletirsek, 49 için bir karakter kaydedebiliriz . Bu bize kullanmamızı sağlar map.

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

Ruby, 39

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

Listedeki eleman bir tamsayı oluncaya kadar tekrarlar.
Integer.map'i çağırmak bir istisna sağladığından
, ikinci listeden 1. elemanı “çıkaran / değiştiren” kurtarma kısmına gider.

Regex soln ... biraz daha uzun:

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

Bazı test durumlarında deneyin

CJam, 43 37 35 33 bayt

Bu, JS yanıtımın doğrudan dönüştürülmesidir . Biraz uzun, çoğu tip tespiti ile alınır.

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

İki giriş dizisini STDIN benzeri iki satırda alır.

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

ve STDOUT benzeri çıktılar

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

Burada çevrimiçi deneyin

Haskell, 113 104 bayt (veri türü bildirgesinden 86 + 18)

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'in yerleşik bir iç içe dizi veri türü olmadığı için kendimi yuvarlamak zorunda kaldım. Bu nedenle, program sadece desen eşleştirme ve açık yapısal özyineleme içerir. Son test durumu okuyor

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

ve değerlendirir

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

Mathematica, 41 bayt

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

Bu, yapıyı ilk argüman ve değerlerin listesini ikinci argüman olarak alan (ve bir liste döndüren) adsız bir işlevdir.

Bu, bu zorluğa ilham veren soru üzerine kabul edilen cevabın golf versiyonudur . Bunu kendim gönderiyorum ve bu cevabı kabul etmeyeceğim (şüphelendiğim en kısa kalması gerekiyorsa). Bu, temelde cevabı kopyalayarak başkasının mücadeleyi kazanmasını önlemek içindir.

Nasıl çalışır:

• ListableSaf bir fonksiyon tanımlarız . Düzenlenebilir işlevler otomatik olarak listenin kendisi yerine liste argümanındaki öğelere (tekrarlı olarak) uygulanır, bu nedenle fyapılandırılmış listeyi çağırmak temelde her tamsayı ile ideğiştirilen aynı yapının bir listesini döndürür f[i].
• Değer listesini global olarak mvei .
• Her aradığımızda f(bağımsız değişken ne olursa olsun) bir sonraki elementi döndürürüz 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
        ]
    ]
]

Örnek:

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

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

Bunu gerektirir:

using System;using o=System.Object;

S'yi object[]argüman olarak kabul eder.

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

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

Listelerdeki listeleri sevdiğini duydum, böylece fonksiyonlara fonksiyon koydum.

Düzenleme: grc'nin cevabına şimdi bakınca bunun tamamen gereksiz olduğunu farkettim. Oh iyi...

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

Örnek çalışma:

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

[]Sorguda sonuncusu , bu soruya gerek duyulmayan uyumsuz sayıda elemanı kontrol etmek içindir.

Erlang, 116 93 Bayt

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.

İki saf olmayan fonksiyon kullanır fve g. Düz fsözlüğe ayarlayarak işlem sözlüğünü değiştirir ve niç içe listenin her bir öğesini eşleştirir g(X). gdaha sonra n, liste dışı bir değerle her karşılaştığında düz listenin kuyruğuna ayarlar ve düz listenin başını döndürür.

Perl 5, 49 bayt

İlk argüman şablon yapısı, ikincisi ise değerlerdir.

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

Test programı

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

giriş dizisi $ i, eşleme $ m, çıktı $ o

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

$ h özyinelemeli işlevi içeren bir dizedir ve bir dizgede bulunan kodu. $ h ile çalıştırabilirsiniz. Ve eğer powershell, tek değer dizilerini skalerlere düzleştirmek konusunda ısrar etmediyse 30 bayt daha kısa olacaktır. null değerine tek bir boş değer ile

ve sonuçları doğrulamak için kullanışlı bir dizi yapısı görüntüleyicisi

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

düzenleme: 149

unflatten.ps1 olarak kaydet:

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

düzenleme: 136, satır içi çıktı dizisi oluşturma ve yazma çıktısı

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

ile arama. \ unflatten.ps1 [giriş dizisi] [eşleme dizisi]

Çıktı boru hattına yazılır - ilk önce bunu çalıştırın:

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

ve koş

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

C #, (40 + 123) = 163 bayt VEYA (67 + 81) = 148 bayt

C # statik yazımdan ve burada uzun ad alanlarından muzdarip.

Dizi yöntemi

İfadeleri kullanarak:

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

Stack yöntemi (diziler yerine Stack yapısını kullanır)

İfadeleri kullanarak:

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

İlk deneme, ilk kod burada golf.