Ви повинні створити функцію, яка розміщує рядок 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-байтового збереження, це випадок, коли він насправді сприяє вирішенню.

Математика, 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)).

Пітон, 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]}

Називається так само, як у відповіді на маневреність , але більш дивною реалізацією. *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
}

Агда, 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 разів 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)

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