Вы должны создать функцию, которая вложит строку 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 -теста, поскольку строка уже находится в стеке.

Попробуйте онлайн!

JavaScript (ES6), 20 байт

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

Хотя люди обычно настаивают на том, чтобы я каррировал мои функции для сохранения 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

Брахилог , 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

Пайк, 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;

Рубин: 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']]]]]]]]]]

Конечно, вы получите предупреждения. Это работает на gccbash на моей машине с Windows ( 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)).

Python, 32 байта

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

Рубин, 25 символов

Переписать из jamylak «s решение 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);

Рубин, 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]}

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
}

Агда, 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 ∷ []) ∷ []. Теперь, конечно, если вы хотите сделать это со строками, вы должны импортировать их ...

к, 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близкие скобки перед ним, то Evals результата. Если вывод строки разрешен, его evalможно удалить.

На самом деле , 4 байта

Вклад stringтогда n. Предложения по игре в гольф приветствуются. Попробуйте онлайн!

`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 байт

РЕДАКТИРОВАТЬ: Исправлена 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

Ungolfed:

(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 не позволяет возвращать различные типы («Строки» против «Список строк» ​​или «Список списка строк», ...), поэтому я должен определить свой собственный тип, который учитывает все эти случаи. Основная функция fрекурсивно вызывает nраз конструктор Cдля вложения и Nдля базового случая.

Пример использования (с deriving (Show)добавлением к новому dataтипу, чтобы можно было его напечатать): f 4 "codegolf"->C (C (C (C (N "codegolf")))) .

Редактировать: @Christian Sievers сохранил 2 байта, переписав функцию в стиле без точки для строкового аргумента. Благодарность!

тинилисп (repl), 34 байта

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

Определяет функцию F. Технически, tinylisp не имеет строк, но этот код будет работать для любого типа данных.

Ungolfed (ключ к встроенным: d= определить, q= цитата,i = if, c= cons, 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