你必须出示其嵌套字符串函数s的数组中，n倍

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

参数：

1. s -ASCII字符串
2. n -一个整数 >= 0

规则

• 最短的代码获胜。
• 输出将是一个嵌套array，list或tuple（基于关阵列或类似类型）

测试用例

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

_{启发：将字符串嵌套在列表中n次，即列表的列表中的列表}

果冻，2 个字节

W¡

由于：（1）果冻没有字符串，只有字符列表；因此略有混乱。及（2）; 输出不会显示嵌套。要查看这实际上在做什么，请查看结果的Python字符串表示形式：

W¡ŒṘ

[]由于字符串本身将是一个字符列表，因此将额外出现一对。例如

怎么样？

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

概念验证代码增加了：

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

Java和C＃，62个字节

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

应该在Java和C＃中都无需修改即可工作。

05AB1E，3个字节

码

`F)

说明

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

这意味着这也适用于0 -testcase，因为字符串已经在堆栈中。

在线尝试！

JavaScript（ES6），20个字节

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

尽管人们通常会me缩我的功能以节省1个字节，但这种情况实际上有助于解决方案。

Mathematica，13个字节

List~Nest~##&

CJam，7 6字节

{{a}*}

在线口译

这是一个未命名的函数，该函数从堆栈中获取其参数为S N，S是字符串和N是自动换行。您可以使用~运算符执行它，即eval。

说明：

{{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个字节

递归函数

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

固化结果的长度相同

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

Brachylog，10个字节

tT,?h:T:gi

在线尝试！

说明

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

如果没有错误，这将是3个字节。[String, T, built-in_group]尽管[String, T]已经是我们的输入，但在这里我们需要所有这些来获取列表。

不幸的是，:g直接导致[[String, T], built-in_group]，i由于整数T在第一个列表内，因此无法正确识别。

MATL，6个字节

ji:"Xh

这将产生一个嵌套的单元格数组作为输出。但是，使用MATL的默认显示，您不必看到它的样子，因为它不会显示所有花括号。下面的演示是一个稍作修改的版本，显示了输出的字符串表示形式。

ji:"Xh]&D

在线尝试

说明

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个字节

V]1

在这里尝试！

Pyth，3个字节

]Fw

固定链接

这将输出类似...[[[[['string']]]]]...。不会引用零深度：string。

说明：

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

如果要引用零深度，请改用以下4字节解决方案（解释）：

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

PHP，60字节

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

48字节（如果仅看起来像任务）

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

Ruby：23个字节

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

已对其进行更新，使其成为可调用的Proc，而不是原始代码段。我很想知道是否有一种方法可以s隐式地返回而不是显式地返回它。

C，44字节，41字节

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

您可以通过执行以下操作对其进行测试：

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

输出：

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

当然，您会收到警告。这可以在gccWindows计算机（gcc version 4.8.4 (Ubuntu 4.8.4-2ubuntu1~14.04.3)）和真正的Linux计算机（gcc version 4.6.3 (Ubuntu/Linaro 4.6.3-1ubuntu5)）上的bash上使用。

Python，32字节

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

Ruby，25个字符

重写jamylak的Python解决方案。

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

样品运行：

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字节

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

Ruby，24个字节

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

称为与manatwork的答案相同，但实施起来很奇怪。*s将输入（可能是嵌套的字符串）包装在数组中。然后，如果n为零，则s[n]返回的第一个元素s，从而将该函数转换为无操作。否则，它将返回，nil因为s将永远只有一个元素，因此我们进行递归调用。

V，6个字节

Àñys$]

在线尝试！

说明：

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

Perl 6、23个字节

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

展开：

{ # 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个字节

由于函数的返回类型取决于作为参数给出的数字，因此很明显应该使用依赖类型的语言。不幸的是，打高尔夫球并不是要使用自然语言和清单来使用它们的语言。从好的方面来说，他们使用的suc是我期望的冗长位置succ。所以这是我的代码：

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 ]

（我希望我发现所有可以省略空格的地方。）L是一个给定自然值的类型函数，n并且类型a返回的n嵌套列表的时间类型a，所以（如果有的话）L 3 Bool将是嵌套列表的列表类型。Bool进口Bool）。这使我们可以将函数的类型表示为(n : ℕ) -> {a : Set} -> a -> L n a，其中花括号使该参数成为隐式。该代码使用一种较短的方法来编写此类型。现在可以通过在第一个参数上进行模式匹配以明显的方式定义该函数。

将带有.agda扩展名的文件加载到emacs中可以使用C-c C-n（将术语评估为普通格式），例如输入f 2 3并以尴尬的形式获取正确的答案：(3 ∷ []) ∷ []。现在当然，如果您要使用字符串来执行此操作，则必须导入它们...

k，3个字节

,:/

作为二元函数，/它将对第二个参数重复应用左手函数,:（enlist）n次。

例：

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

PHP，44字节

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

没有什么复杂的，只是一个递归函数

Python 2，32字节

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

将n开括号放在字符串之前，将方括号放在字符串n之前，然后评估结果。如果允许输出字符串，则eval可以将其删除。

实际上，4个字节

string然后输入n。欢迎打高尔夫球。在线尝试！

`k`n

开球

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

R，39 40字节

编辑：修复了n=0问题，感谢@rturnbull。

该函数需要两个输入s（字符串）和n（嵌套）并输出嵌套列表。请注意，R类在list本机上的打印输出与大多数其他语言不同，但是在功能上类似于键/值映射（可能带有未命名的键）或python中的列表。

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

例

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

拍子83字节

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

取消高尔夫：

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

测试：

(f "test" 3)

输出：

"[[['test']]]"

Haskell，40 38字节

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

Haskell的严格类型系统可防止返回不同的类型（字符串vs.字符串列表vs.字符串列表，...），因此我必须定义自己的类型以适应所有情况。main函数f递归调用嵌套和基本情况n的构造C方法N。

用法示例（已deriving (Show)添加到新data类型中以便能够打印）：f 4 "codegolf"-> C (C (C (C (N "codegolf"))))。

编辑：@Christian Sievers通过以无点样式为字符串参数重写函数来节省2个字节。谢谢！

tinylisp（repl），34个字节

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

定义一个函数F。从技术上讲，tinylisp没有字符串，但是此代码可用于给定的任何数据类型。

Ungolfed（内置关键字：d=定义，q=引用，i=如果，c=缺点，s=减去）：

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

用法示例：

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个字节

#(nth(iterate list %)%2)

Clojure在这里有些竞争力。iterate创建一个序列x, (f x), (f (f x)) ...，nth返回所需的元素。

在线查看：https：//ideone.com/2rQ166