Anda harus menghasilkan fungsi yang membuat string sdi dalam array, nkali

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

Parameter:

1. s - Sebuah string ascii
2. n - Bilangan bulat >= 0

Aturan

• Kode terpendek menang.
• Outputnya akan bersarang array, listatau tuple(atau sejenisnya berdasarkan dari array)

Uji Kasus

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

_{Terinspirasi oleh: Menempatkan string di dalam daftar n kali yaitu daftar daftar daftar}

Jelly , 2 byte

W¡

Agak membingungkan, karena: (1) Jelly tidak memiliki string, hanya daftar karakter; dan (2); output tidak akan menunjukkan sarang. Untuk melihat bahwa ini sebenarnya adalah melakukan apa yang diminta, lihat representasi string Python dari hasil dengan:

W¡ŒṘ

Sepasang tambahan []akan hadir karena string itu sendiri akan menjadi daftar karakter. Sebagai contoh

Bagaimana?

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

Kode proof-of-concept menambahkan:

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

Java dan C #, 62 byte

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

Harus bekerja tanpa modifikasi di Java dan C #.

05AB1E , 3 byte

Kode

`F)

Penjelasan

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

Ini berarti bahwa ini juga berfungsi untuk 0 -testcase, karena string sudah ada di stack.

Cobalah online!

JavaScript (ES6), 20 byte

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

Meskipun orang biasanya mengomel saya untuk menjelajah fungsi saya untuk penghematan 1-byte, ini adalah kasus di mana ia sebenarnya berkontribusi pada solusi.

Mathematica, 13 byte

List~Nest~##&

CJam , 7 6 byte

{{a}*}

Penerjemah online

Ini adalah fungsi tanpa nama yang mengambil argumennya dari stack sebagai S N, Smenjadi string danN menjadi pembungkus. Anda dapat menjalankannya dengan ~operator, yang berarti eval.

Penjelasan:

{{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 byte

Fungsi rekursif

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

Currying menghasilkan panjang yang sama

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

Brachylog , 10 byte

tT,?h:T:gi

Cobalah online!

Penjelasan

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

Ini akan menjadi 3 byte jika tidak disadap. Di sini kita perlu semua ini untuk mendapatkan daftar [String, T, built-in_group]meskipun [String, T]sudah menjadi masukan kita.

Sayangnya :glangsung menghasilkan [[String, T], built-in_group], yang tidak dikenali dengan benar ikarena bilangan bulat Tada di dalam daftar pertama.

MATL, 6 byte

ji:"Xh

Ini menghasilkan array sel bersarang sebagai output. Namun, dengan tampilan standar MATL, Anda tidak perlu melihat seperti itu karena tidak akan menampilkan semua kurung kurawal. Demo di bawah ini adalah versi yang sedikit dimodifikasi yang menunjukkan representasi string dari output.

ji:"Xh]&D

Cobalah secara Online

Penjelasan

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 byte

V]1

Coba di sini!

Pyth , 3 byte

]Fw

Permalink

Ini akan menampilkan sesuatu seperti ...[[[[['string']]]]].... Itu tidak akan mengutip untuk kedalaman nol:string.

Penjelasan:

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

Jika Anda ingin mengutip pada kedalaman nol, gunakan solusi 4-byte ini sebagai gantinya (penjelasan):

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

PHP, 60 Bytes

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

48 Bytes jika terlihat hanya seperti tugas

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

Ruby: 23 bytes

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

This is updated to make it a callable Proc rather than the original snippet. I'd be interested to know whether there's a way to have s implicitly returned rather than having to explicitly return it.

C, 44 byte , 41 byte

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

Anda dapat mengujinya dengan melakukan hal berikut:

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

Hasil:

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

Tentu saja, Anda akan mendapat peringatan. Ini berfungsi pada gccbash di mesin Windows saya ( gcc version 4.8.4 (Ubuntu 4.8.4-2ubuntu1~14.04.3), dan juga pada mesin Linux yang sebenarnya ( gcc version 4.6.3 (Ubuntu/Linaro 4.6.3-1ubuntu5)).

Python, 32 bytes

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

Ruby, 25 characters

Rewrite of jamylak's Python solution.

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

Sample run:

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 bytes

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

Ruby, 24 bytes

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

Disebut sama dengan jawaban manatwork, but a weirder implementation. *s wraps the input (a possibly-nested string) in an array. Then if n is zero, s[n] returns the first element of s, turning the function into a no-op. Otherwise, it returns nil since s will only ever have one element, so we pass through to the recursive call.

V , 6 byte

Àñys$]

Cobalah online!

Penjelasan:

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

Perl 6 , 23 byte

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

Diperluas:

{ # 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 byte

Karena tipe kembalinya fungsi tergantung pada angka yang diberikan sebagai argumen, ini jelas merupakan kasus di mana bahasa yang diketik secara dependen harus digunakan. Sayangnya, bermain golf tidak mudah dalam bahasa di mana Anda harus mengimpor naturals dan daftar untuk menggunakannya. Di sisi positifnya, mereka menggunakan di sucmana saya harapkan verbose succ. Jadi, inilah kode saya:

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 ]

(Saya harap saya menemukan semua tempat di mana spasi dapat dihilangkan.) LAdalah fungsi tipe yang diberikan alami ndan tipe amengembalikan jenis nkali daftar bersarang a, jadi L 3 Boolakan menjadi jenis daftar daftar daftar Bool(jika kita memiliki diimpor Bool). Ini memungkinkan kita untuk mengekspresikan jenis fungsi kita sebagai (n : ℕ) -> {a : Set} -> a -> L n a, di mana kurung kurawal membuat argumen itu tersirat. Kode ini menggunakan cara yang lebih pendek untuk menulis jenis ini. Fungsi sekarang dapat didefinisikan dengan cara yang jelas dengan pencocokan pola pada argumen pertama.

Memuat file ini dengan .agdaekstensi ke emacs memungkinkan untuk digunakan C-c C-n(mengevaluasi jangka ke bentuk normal), masukan misalnya f 2 3dan mendapatkan jawaban yang benar dalam bentuk canggung: (3 ∷ []) ∷ []. Sekarang tentu saja jika Anda ingin melakukannya dengan string, Anda harus mengimpornya ...

k, 3 byte

,:/

Diambil sebagai fungsi diad, / secara iteratif akan menerapkan fungsi tangan kiri ,:( enlist) n kali pada argumen kedua.

Contoh:

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

PHP, 44 byte

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

tidak ada yang canggih, hanya fungsi rekursif

Python 2, 32 byte

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

Letakkan ntanda kurung di depan string dan ntutup tanda kurung di depannya, lalu evaluasi hasilnya. Jika output string diizinkan, evaldapat dihapus.

Sebenarnya , 4 byte

Masukan stringkemudian n. Saran golf diterima. Cobalah online!

`k`n

Tidak melakukanolf

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

R, 39 40 byte

EDIT: Memperbaiki n=0masalah ini berkat @rturnbull.

Fungsi yang mengambil dua input s(string) dan n(nestedness) dan menampilkan daftar bersarang. Perhatikan bahwa R-class listmencetak hasil asli secara berbeda dari kebanyakan bahasa lain, secara fungsional mirip dengan peta kunci / nilai (dengan kunci yang mungkin tidak disebutkan namanya) atau daftar dengan python.

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

Contoh

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

Racket 83 byte

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

Tidak Terkumpul:

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

Pengujian:

(f "test" 3)

Keluaran:

"[[['test']]]"

Haskell, 40 38 byte

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

Sistem tipe ketat Haskell mencegah pengembalian tipe yang berbeda (Strings vs. List of Strings vs. List of Strings, ...), jadi saya harus mendefinisikan tipe saya sendiri yang mengakomodasi semua case. Fungsi utama fsecara rekursif memanggil nkali konstruktor Cuntuk bersarang dan Nuntuk kasing.

Contoh penggunaan (dengan deriving (Show)ditambahkan ke datatipe baru untuk dapat mencetaknya):f 4 "codegolf" -> C (C (C (C (N "codegolf")))).

Edit: @Christian Sievers saved 2 bytes by rewriting the function in a point-free style for the string argument. Thanks!

tinylisp (repl), 34 bytes

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

Defines a function F. Technically, tinylisp doesn't have strings, but this code will work for any data type it's given.

Ungolfed (key to builtins: d = define, q = quote, i = if, c = cons, s = subtract):

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

Example usage:

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 bytes

#(nth(iterate list %)%2)

Clojure is somewhat competitive here. iterate creates a sequence of x, (f x), (f (f x)) ..., nth returns needed element.

See it online: https://ideone.com/2rQ166