Bir dize nests bir işlev üretmek gerekir s, bir dizi içindeki ndefa

>>> N("stackoverflow",2)
[['stackoverflow']]

Parametreler:

1. s - Bir ascii dizesi
2. n - Bir tam sayı >= 0

kurallar

• En kısa kod kazanır.
• Çıkış iç içe olacak array, listya da tuple(bir dizi kapalı tabanlı veya benzer tipte)

Test Durumları

>>> N("stackoverflow",0)
'stackoverflow'
>>> N("stackoverflow",1)
['stackoverflow']
>>> N("stackoverflow",5)
[[[[['stackoverflow']]]]]

_{Esinlenen: Bir dizeyi bir listeye n kez yerleştirme, yani bir liste listesinin listesi}

Jöle , 2 bayt

W¡

Biraz kafa karıştırıcı, çünkü: (1) Jelly'in dizeleri yok, sadece karakter listeleri var; ve 2); çıktı yuvalama göstermez. Bunun aslında ne yapıldığını görmek için sonucun bir Python dizesi temsiline bakın:

W¡ŒṘ

[]Dizenin kendisi bir karakter listesi olacağından fazladan bir çift mevcut olacaktır. Örneğin

Nasıl?

W¡ - Main link: s, n
W  - wrap left, initially s, in a list
 ¡ - repeat previous link n times

Kavram kanıtı kodu şunları ekler:

W¡ŒṘ - Main link: s, n
  ŒṘ - Python string representation

Java ve C #, 62 bayt

Object f(String s,int n){return n<1?s:new Object[]{f(s,n-1)};}

Java ve C # 'de değişiklik yapılmadan çalışmalıdır.

05AB1E , 3 bayt

kod

`F)

açıklama

`   # Flatten the input array on the stack.
 F  # Element_2 times do:
  ) # Wrap the total stack into a single array.

Bu , dize zaten yığın üzerinde olduğu için bunun 0 -testcase için de işe yarayacağı anlamına gelir .

Çevrimiçi deneyin!

JavaScript (ES6), 20 bayt

d=>g=n=>n--?[g(n)]:d

İnsanlar normalde 1 baytlık tasarruf için işlevlerimi köreltmeme rağmen, bu aslında çözüme katkıda bulunduğu bir durumdur.

Mathematica, 13 bayt

List~Nest~##&

CJam , 7 6 bayt

{{a}*}

Çevrimiçi tercüman

Bu şekilde istiften kendi bağımsız değişkenleri alır isimsiz fonksiyonudur S N, Sdize olan ve Nsargısı olan. ~Operatör ile çalıştırabilirsiniz , yani eval.

Açıklama:

{{a}*}
{      Open block    [A B]
 {     Open block    [A]
  a    Wrap in array [[A]]
   }   Close block   [A B λwrap]
    *  Repeat        [A:wrap(*B)]
     } Close block   ["S" N λ(λwrap)repeat]

Javascript ES6, 23 bayt

Özyinelemeli işlev

f=(a,i)=>i?f([a],--i):a

console.log(f("stackoverflow",0))
console.log(f("stackoverflow",1))
console.log(f("stackoverflow",2))
console.log(f("stackoverflow",5))

Aynı uzunlukta kurutma sonuçları

f=a=>i=>i?f([a])(--i):a

Brachylog , 10 bayt

tT,?h:T:gi

Çevrimiçi deneyin!

açıklama

tT,            T is the integer (second element of the Input)
   ?h:T:g      The list [String, T, built-in_group]
         i     Iterate: Apply built-in_group T times to String

Eğer hata olmasaydı bu 3 bayt olurdu. Burada zaten [String, T, built-in_group]girdimiz olsa bile listeyi almak için tüm bunlara ihtiyacımız var [String, T].

Ne yazık ki :gdoğrudan sonuçlanır [[String, T], built-in_group], bu itamsayı Tilk listenin içinde olduğu için doğru şekilde tanınmaz .

MATL, 6 bayt

ji:"Xh

Bu, çıktı olarak iç içe bir hücre dizisi üretir. Ancak MATL'in varsayılan ekranı ile, tüm kıvırcık parantezleri göstermeyeceğinden bunun ne olduğunu göremezsiniz . Aşağıdaki demo, çıktının dize olarak temsilini gösteren biraz değiştirilmiş bir sürümdür.

ji:"Xh]&D

Çevrimiçi Deneyin

açıklama

j       % Explicitly grab the first input as a string
i       % Explicitly grab the second input as an integer (n)
:"      % Create an array [1...n] and loop through it
    Xh  % Each time through the loop place the entire stack into a cell array
        % Implicit end of for loop and display

Pyke, 3 bayt

V]1

Burada deneyin!

Pyth , 3 bayt

]Fw

kalıcı

Bu gibi bir şey çıktı ...[[[[['string']]]]].... Sıfır derinlik için teklif vermeyecektir:string .

Açıklama:

]Fw
   Q Implicit: Eval first input line
]    Function: Wrap in array
  w  Input line
 F   Apply multiple times

Sıfır derinlikte alıntı yapmak istiyorsanız, bunun yerine bu 4 baytlık çözümü kullanın (açıklama):

`]Fw
    Q Implicit: Eval first input line
 ]    Function: Wrap in array
   w  Input line
  F   Apply multiple times
`     Representation

PHP, 60 Bayt

for($r=$argv[1];$i++<$argv[2];)$r=[$r];echo json_encode($r);

48 Görev yalnızca görev gibi görünüyorsa

for($r=$argv[1];$i++<$argv[2];)$r="[$r]";echo$r;

Yakut: 23 bayt

->n,s{n.times{s=[s]};s}

Bu, orijinal snippet yerine çağrılabilir bir Proc olacak şekilde güncellenir. sAçıkça iade etmek yerine dolaylı olarak geri dönmenin bir yolu olup olmadığını bilmek isterim .

C, 44 bayt , 41 bayt

int*n(int*s,int a){return a?n(&s,a-1):s;}

Aşağıdakileri yaparak test edebilirsiniz:

int main(void) {
    char* s = "stackoverflow";

    /* Test Case 0 */
    int* a = n(s,0);
    printf("'%s'\n", a);

    /* Test Case 1 */
    int* b = n(s,1);
    printf("['%s']\n", *b);

    /* Test Case 2 */
    int** c = n(s,2);
    printf("[['%s']]\n", **c);

    /* Test Case 3 */
    int*** d = n(s,3);
    printf("[[['%s']]]\n", ***d);

    /* Test Case 4 */
    int********** e = n(s,10);
    printf("[[[[[[[[[['%s']]]]]]]]]]\n", **********e);

    return 0;
}

Çıktı:

'stackoverflow'
['stackoverflow']
[['stackoverflow']]
[[['stackoverflow']]]
[[[[[[[[[['stackoverflow']]]]]]]]]]

Tabii ki uyarılar alacaksınız. Bu, gccWindows makinemde ( gcc version 4.8.4 (Ubuntu 4.8.4-2ubuntu1~14.04.3)ve gerçek bir Linux makinesinde ( gcc version 4.6.3 (Ubuntu/Linaro 4.6.3-1ubuntu5)) bash üzerinde çalışır .

Python, 32 bayt

N=lambda s,n:n and[N(s,n-1)]or s

Ruby, 25 karakter

Arasında yeniden yaz jamylak 'ın Python çözümü .

f=->s,n{n>0?[f[s,n-1]]:s}

Örnek çalışma:

irb(main):001:0> f=->s,n{n>0?[f[s,n-1]]:s}
=> #<Proc:0x00000002006e80@(irb):1 (lambda)>

irb(main):002:0> f["stackoverflow",0]
=> "stackoverflow"

irb(main):003:0> f["stackoverflow",1]
=> ["stackoverflow"]

irb(main):004:0> f["stackoverflow",5]
=> [[[[["stackoverflow"]]]]]

C # 6, 50 bayt

dynamic a(dynamic s,int n)=>n<2?s:a(new[]{s},n-1);

Yakut, 24 bayt

f=->*s,n{s[n]||f[s,n-1]}

İnsanoğlunun cevabı ile aynı denir , ama bir garip uygulama. *sgirdiyi (muhtemelen iç içe dizgi) bir diziye sarar. Sonra nsıfır ise , işlevinin no-op haline dönüştürülmesinin s[n]ilk öğesini döndürür s. Aksi takdirde, döner nilberi sbiz özyinelemeli çağrısına geçmesine böylece sadece hiç bir eleman olacaktır.

V , 6 bayt

Àñys$]

Çevrimiçi deneyin!

Açıklama:

À      "Arg1 times
 ñ     "repeat:
  ys$  "surround this line
     ] "with square brackets

Perl 6 , 23 bayt

{($^a,{[$_]}...*)[$^b]}

Expanded:

{ # bare block lambda with two placeholder parameters ｢$a｣ and ｢$b｣
  (

    # generate Sequence

    $^a,       # declare first input
    { [ $_ ] } # lambda that adds one array layer
    ...        # do that until
    *          # Whatever

  )[ $^b ]     # index into the sequence
}

Agda, 173 bayt

İşlevin dönüş türü bağımsız değişken olarak verilen sayıya bağlı olduğundan, bu açıkça bağımlı bir şekilde yazılan bir dilin kullanılması gereken bir durumdur. Ne yazık ki, golf kullanmak için doğalları ve listeleri almak zorunda olduğunuz bir dilde golf yapmak kolay değildir. Artı tarafta, sucayrıntılı olmasını beklediğim yerde kullanıyorlarsucc . İşte benim kod:

module l where
open import Data.List
open import Data.Nat
L : ℕ -> Set -> Set
L 0 a = a
L(suc n)a = List(L n a)
f : ∀ n{a}-> a -> L n a
f 0 x = x
f(suc n)x = [ f n x ]

(Umarım boşlukların atlanabileceği tüm yerleri buldum.) LDoğal verilen bir tür fonksiyonudur nve bir tür iç içe listelerin türünü adöndürür , bu yüzden listelerin liste listelerinin türü olurdu ( ithal ). Bu, işlevimizin türünü şu şekilde ifade etmemizi sağlar:naL 3 BoolBoolBool(n : ℕ) -> {a : Set} -> a -> L n a , kıvırcık parantezlerin bu argümanı örtülü kıldığı . Kod, bu tür yazmak için daha kısa bir yol kullanır. Fonksiyon artık ilk argümandaki desen eşleşmesi ile açık bir şekilde tanımlanabilir.

Bir Bu dosyayı yükleme .agdaemacs'dan uzantıya kullanımına izin veren C-c C-nörneğin girişi (normal forma terimini değerlendirmek) f 2 3ve garip bir biçimde doğru cevabı alıyorum: (3 ∷ []) ∷ []. Şimdi elbette bunu dizelerle yapmak istiyorsanız, onları içe aktarmanız gerekir ...

k, 3 bayt

,:/

İkili bir işlev olarak alındığında /, soldaki işlevi ,:( enlist) n kez ikinci bağımsız değişkene yinelemeli olarak uygular .

Misal:

k),:/[3;"hello"]
,,,"hello"

PHP, 44 bayt

function n($s,$n){return$n?n([$s],--$n):$s;}

sofistike bir şey yok, sadece özyinelemeli bir işlev

Python 2, 32 bayt

lambda s,n:eval('['*n+`s`+']'*n)

nAçık parantezleri dizenin önüne koyar ve nparantezleri önünden kapatır, ardından sonucu değiştirir. Bir dize çıktısına izin verilirse, evalkaldırılabilir.

Aslında 4 bayt

Girdi stringSonran . Golf önerileri hoş geldiniz. Çevrimiçi deneyin!

`k`n

Ungolfing

          Implicit input string, then n.
`...`n    Run the function n times.
  k         Wrap the stack in a list.
          Implicit return.

R, 39 40 bayt

DÜZENLEME: Sabit n=0 @rturnbull sayesinde sorun .

İki giriş s(dize) ve n(iç içe geçme) alan ve iç içe liste çıkaran işlev. Ancak R-sınıfının listçıktıyı yerel olarak diğer dillerden farklı şekilde yazdırdığını, ancak işlevsel olarak bir anahtar / değer haritasına (muhtemelen adsız anahtarlarla) veya python'daki bir listeye benzediğini unutmayın.

f=function(s,n)if(n)list(f(s,n-1))else s

Misal

> f=function(s,n)if(n)list(f(s,n-1))else s
> f("hello",3)
[[1]]
[[1]][[1]]
[[1]][[1]][[1]]
[1] "hello"


> # to access the string nested 5 times in the "list-object" named "list" we can do the following
> list = f("nested string",5)
> list[[1]][[1]][[1]][[1]][[1]]
[1] "nested string"

Raket 83 bayt

(for((c n))(set! s(apply string-append(if(= c 0)(list"[\'"s"\']")(list"["s"]")))))s

Ungolfed:

(define (f s n)
  (for ((c n))
    (set! s (apply string-append
                   (if (= c 0)
                       (list "[\'" s "\']")
                       (list "[" s "]"))
                   )))
  s)

Test yapmak:

(f "test" 3)

Çıktı:

"[[['test']]]"

Haskell, 40 38 bayt

data L=N[Char]|C L 
f 0=N
f n=C. f(n-1)

Haskell'in katı tip sistemi farklı türlerin (Dizeler vs Dizeler Listesi vs Dizeler Listesi, ...) geri dönmesini önler, bu yüzden tüm bu durumları barındıran kendi tipimi tanımlamalıyım. Ana işlev , yapıcı ve temel durum için yapıcıyı ftekrar tekrar çağırır .nCN

Kullanım örneği ( yazdırabilmek deriving (Show)için yeni datatüre eklenmiş olarak ): f 4 "codegolf"->C (C (C (C (N "codegolf")))) .

Düzenleme: @Christian Sievers işlevi dize argümanı için noktasız bir tarzda yeniden yazarak 2 bayt kaydetti. Teşekkürler!

tinylisp (repl), 34 bayt

(d F(q((S N)(i N(F(c S())(s N 1))S

Bir işlevi tanımlar F. Teknik olarak tinylisp dizeleri içermez, ancak bu kod verilen herhangi bir veri türü için çalışır.

Ungolfed (yerleşiklerin anahtarı: d= tanımla, q= alıntı yap, i= if, c= eksileri, s= çıkar):

(d nest
 (q
  ((item number)
   (i number
    (nest (c item ()) (s number 1))
    item))))

Örnek kullanım:

tl> (d F(q((S N)(i N(F(c S())(s N 1))S
F
tl> (F 2 3)
(((2)))
tl> (F () 1)
(())
tl> (F (q Hello!) 7)
(((((((Hello!)))))))
tl> (F c 3)
(((<builtin function tl_cons>)))

Clojure, 24 bayt

#(nth(iterate list %)%2)

Clojure burada biraz rekabetçidir. iteratebir dizi oluşturur x, (f x), (f (f x)) ...,nth gerekli öğeyi döndürür.

Çevrimiçi görün: https://ideone.com/2rQ166