Należy utworzyć funkcję, która zagnieżdża ciąg znaków sw tablicy nrazy

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

Parametry:

1. s - Ciąg ascii
2. n - Liczba całkowita >= 0

Zasady

• Najkrótszy kod wygrywa.
• Wyjście być zagnieżdżona array, listi tuple(lub podobnego typu opiera się na tablicy)

Przypadki testowe

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

_{Inspirowane przez: Zagnieżdżenie ciągu na liście n razy, tj. Lista listy listy}

Galaretka , 2 bajty

W¡

Nieco mylące, ponieważ: (1) Galaretka nie ma łańcuchów, tylko listy znaków; i (2); wyjście nie pokaże zagnieżdżenia. Aby zobaczyć, że faktycznie robi to, o co pytamy, spójrz na reprezentację wyniku w Pythonie za pomocą:

W¡ŒṘ

Dodatkowa para []będzie obecna, ponieważ sam ciąg będzie listą znaków. Na przykład

W jaki sposób?

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

Kod weryfikacji koncepcji dodaje:

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

Java i C #, 62 bajty

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

Powinien działać bez modyfikacji zarówno w Javie, jak i C #.

05AB1E , 3 bajty

Kod

`F)

Wyjaśnienie

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

Oznacza to, że działa to również w przypadku 0 , ponieważ ciąg znaków znajduje się już na stosie.

Wypróbuj online!

JavaScript (ES6), 20 bajtów

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

Chociaż ludzie zwykle nudzą mnie, żebym sprawdził moje funkcje w celu zaoszczędzenia 1 bajtu, jest to przypadek, w którym faktycznie przyczynia się do rozwiązania.

Mathematica, 13 bajtów

List~Nest~##&

CJam , 7 6 bajtów

{{a}*}

Tłumacz online

Jest to nienazwana funkcja, która bierze swoje argumenty ze stosu jako S N, Sbędąc ciągiem iN zawijaniem. Możesz to wykonać za pomocą~ operatora, co znaczy eval.

Wyjaśnienie:

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

Funkcja rekurencyjna

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

Efekt curry ma taką samą długość

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

Brachylog , 10 bajtów

tT,?h:T:gi

Wypróbuj online!

Wyjaśnienie

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

Byłyby to 3 bajty, gdyby nie było błędu. Tutaj potrzebujemy tego wszystkiego, aby uzyskać listę, [String, T, built-in_group]mimo że [String, T]jest to już nasz wkład.

Niestety :gwyniki bezpośrednio [[String, T], built-in_group], co nie jest poprawnie rozpoznawane przez, iponieważ liczba całkowita Tznajduje się na pierwszej liście.

MATL, 6 bajtów

ji:"Xh

To tworzy zagnieżdżoną tablicę komórek jako wynik. Jednak domyślny wyświetlacz MATL-a nie pozwala zobaczyć , co to jest, ponieważ nie wyświetla wszystkich nawiasów klamrowych. Poniższa wersja demonstracyjna jest nieco zmodyfikowaną wersją, która pokazuje ciąg reprezentujący dane wyjściowe.

ji:"Xh]&D

Wypróbuj online

Wyjaśnienie

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 bajty

V]1

Wypróbuj tutaj!

Pyth , 3 bajty

]Fw

Permalink

Spowoduje to wyświetlenie czegoś podobnego ...[[[[['string']]]]].... To nie będzie zacytować na głębokości zera: string.

Wyjaśnienie:

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

Jeśli chcesz cytować na głębokości zerowej, użyj zamiast tego 4-bajtowego rozwiązania (objaśnienie):

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

PHP, 60 bajtów

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

48 bajtów, jeśli wygląda tylko na zadanie

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

Rubin: 23 bajty

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

Zostało to zaktualizowane, aby uczynić z niego proces, który można wywołać, a nie oryginalny fragment kodu. Byłbym zainteresowany, aby wiedzieć, czy istnieje sposób na sdomniemane zwrócenie, zamiast jawnego zwrotu.

C, 44 bytes, 41 bytes

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

You can test it by doing the following:

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

The output:

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

Of course, you'll get warnings. This works on gcc on bash on my Windows machine (gcc version 4.8.4 (Ubuntu 4.8.4-2ubuntu1~14.04.3), as well as on a true Linux machine (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]}

Called the same as in manatwork's answer, 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 bytes

Àñys$]

Try it online!

Explanation:

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

Perl 6, 23 bytes

{($^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 bytes

Since the return type of the function depends on the number given as argument, this is clearly a case where a dependently typed language should be used. Unfortunately, golfing isn't easy in a language where you have to import naturals and lists to use them. On the plus side, they use suc where I would have expected the verbose succ. So here is my code:

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 ]

(I hope I found all places where spaces can be omitted.) L is a type function that given a natural n and a type a returns the type of n times nested lists of a, so L 3 Bool would be the type of lists of lists of lists of Bool (if we had imported Bool). This allows us to express the type of our function as (n : ℕ) -> {a : Set} -> a -> L n a, where the curly braces make that argument implicit. The code uses a shorter way to write this type. The function can now be defined in an obvious way by pattern matching on the first argument.

Loading this file with an .agda extension into emacs allows to use C-c C-n (evaluate term to normal form), input for example f 2 3 and get the correct answer in an awkward form: (3 ∷ []) ∷ []. Now of course if you want to do that with strings you have to import them...

k, 3 bytes

,:/

Taken as a dyadic function, / will iteratively apply the left-hand function ,: (enlist) n times to the second argument.

Example:

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

PHP, 44 bytes

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

nothing sophisticated, just a recursive function

Python 2, 32 bytes

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

Puts n open brackets before the string and n close brackets before it, then evals the result. If a string output is allowed, the eval can be removed.

Actually, 4 bytes

Input is string then n. Golfing suggestions welcome. Try it online!

`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 bytes

EDIT: Fixed the n=0 issue thanks to @rturnbull.

Function that takes two inputs s (string) and n (nestedness) and outputs the nested list. Note that R-class list natively prints output differently than most other languages, however, is functionally similar to a key/value map (with possibly unnamed keys) or a list in python.

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

Example

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

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

Testing:

(f "test" 3)

Output:

"[[['test']]]"

Haskell, 40 38 bytes

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

Haskell's strict type system prevents returning different types (Strings vs. List of Strings vs. List of List of Strings,...), so I have to define my own type that accommodates all those cases. The main function f recursively calls n times the constructor C for nesting and N for the base case.

Usage example (with deriving (Show) added to the new data type to be able to print it): 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