Você deve produzir uma função que aninhe uma string sdentro de uma matriz, nvezes

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

Parâmetros:

1. s - Uma string ascii
2. n - um inteiro >= 0

Regras

• O menor código vence.
• A saída será um aninhada array, listou tuple(tipo ou semelhante baseado fora uma matriz)

Casos de teste

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

_{Inspirado por: Aninhando uma string dentro de uma lista n vezes, ou seja, lista de uma lista de uma lista}

Geléia , 2 bytes

W¡

Um pouco confuso, já que: (1) Jelly não tem cordas, apenas listas de caracteres; e (2); a saída não mostrará o aninhamento. Para ver que isso realmente está fazendo o que é solicitado, observe uma representação de sequência Python do resultado com:

W¡ŒṘ

Um par extra de []estará presente, pois a própria string será uma lista de caracteres. Por exemplo

Quão?

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

O código de prova de conceito acrescenta:

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

Java e C #, 62 bytes

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

Deve funcionar sem modificação em Java e C #.

05AB1E , 3 bytes

Código

`F)

Explicação

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

Isso significa que isso também funciona para o 0- case, já que a string já está na pilha.

Experimente online!

JavaScript (ES6), 20 bytes

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

Embora as pessoas normalmente me importunem em organizar minhas funções para economizar 1 byte, este é um caso em que realmente contribui para a solução.

Mathematica, 13 bytes

List~Nest~##&

CJam , 7 6 bytes

{{a}*}

Intérprete online

Esta é uma função sem nome que leva os seus argumentos a partir da pilha como S N, Ssendo a corda e Nsendo os envoltórios. Você pode executá-lo com o ~operador, ou seja, avaliar.

Explicação:

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

Função recursiva

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 resulta no mesmo comprimento

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

Braquilog , 10 bytes

tT,?h:T:gi

Experimente online!

Explicação

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

Isso seria de 3 bytes se não fosse corrigido. Aqui precisamos de tudo isso para obter a lista, [String, T, built-in_group]mesmo que [String, T]já seja nossa contribuição.

Infelizmente, :gresulta diretamente [[String, T], built-in_group], o que não é reconhecido corretamente iporque o número inteiro Testá dentro da primeira lista.

MATL, 6 bytes

ji:"Xh

Isso produz uma matriz de células aninhadas como saída. Com a exibição padrão do MATL, no entanto, você não pode ver que é isso que é, pois não mostrará todas as chaves. A demonstração abaixo é uma versão ligeiramente modificada que mostra a representação em cadeia da saída.

ji:"Xh]&D

Experimente Online

Explicação

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 bytes

V]1

Experimente aqui!

Pitão , 3 bytes

]Fw

Permalink

Isso produzirá algo como ...[[[[['string']]]]].... Não vou citar para a profundidade zero: string.

Explicação:

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

Se você deseja citar com profundidade zero, use esta solução de 4 bytes (explicação):

`]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 se parecer apenas com a tarefa

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

Ruby: 23 bytes

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

Isso é atualizado para torná-lo um Proc exigível, e não o snippet original. Eu estaria interessado em saber se existe uma maneira de sretornar implicitamente, em vez de precisar devolvê-lo explicitamente.

C, 44 bytes , 41 bytes

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

Você pode testá-lo fazendo o seguinte:

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

A saída:

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

Claro, você receberá avisos. Isso funciona no gccbash na minha máquina Windows ( gcc version 4.8.4 (Ubuntu 4.8.4-2ubuntu1~14.04.3), bem como em uma verdadeira máquina Linux ( 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 caracteres

Reescrever de jamylak 's solução Python .

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

Exemplo de execução:

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

Chamado o mesmo que na resposta do manatwork , mas uma implementação mais estranha. *squebra a entrada (uma sequência possivelmente aninhada) em uma matriz. Então, se nfor zero, s[n]retorna o primeiro elemento de s, transformando a função em um no-op. Caso contrário, ele retornará, nilpois ssó terá um elemento, então passamos para a chamada recursiva.

V , 6 bytes

Àñys$]

Experimente online!

Explicação:

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

Perl 6 , 23 bytes

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

Expandido:

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

Como o tipo de retorno da função depende do número fornecido como argumento, este é claramente um caso em que uma linguagem tipicamente dependente deve ser usada. Infelizmente, o golfe não é fácil em um idioma em que é necessário importar listas e naturais para usá-los. No lado positivo, eles usam suconde eu esperava o verboso succ. Então, aqui está o meu código:

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 ]

(Espero encontrar todos os lugares onde os espaços podem ser omitidos.) LÉ uma função de tipo que, dada uma natural ne um tipo, aretorna o tipo de nvezes que as listas aninhadas são a, o mesmo L 3 Boolseria o tipo de listas de listas de listas de Bool(se tivéssemos importado Bool). Isso nos permite expressar o tipo de nossa função como(n : ℕ) -> {a : Set} -> a -> L n a , onde os chavetas tornam esse argumento implícito. O código usa uma maneira mais curta de escrever esse tipo. A função agora pode ser definida de maneira óbvia pela correspondência de padrões no primeiro argumento.

Carregando este arquivo com uma .agdaextensão para emacs permite uso C-c C-n(avaliar termo à forma normal), de entrada, por exemplo, f 2 3e obter a resposta correta em uma forma estranha: (3 ∷ []) ∷ []. Agora, é claro, se você quiser fazer isso com strings, precisará importá-las ...

k, 3 bytes

,:/

Tomada como uma função diádica, /aplicará iterativamente a função da esquerda ,:( enlist) n vezes ao segundo argumento.

Exemplo:

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

PHP, 44 bytes

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

nada sofisticado, apenas uma função recursiva

Python 2, 32 bytes

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

Coloca nos colchetes abertos antes da cadeia e nfecha os colchetes antes dela e avalia o resultado. Se uma saída de string for permitida, ela evalpoderá ser removida.

Na verdade , 4 bytes

A entrada é stringentão n. Sugestões de golfe são bem-vindas. Experimente 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: corrigido o n=0problema graças a @rturnbull.

Função que recebe duas entradas s(sequência) e n(aninhamento) e gera a lista aninhada. Observe que a classe R listimprime nativamente a saída de maneira diferente da maioria das outras linguagens, no entanto, é funcionalmente semelhante a um mapa de chave / valor (com possíveis chaves sem nome) ou a uma lista em python.

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

Exemplo

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

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

Teste:

(f "test" 3)

Resultado:

"[[['test']]]"

Haskell, 40 38 bytes

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

O sistema de tipos estritos de Haskell impede o retorno de tipos diferentes (Strings vs. Lista de Strings vs. Lista de Strings, ...), então eu tenho que definir meu próprio tipo que acomode todos esses casos. A função principal fchama recursivamente nvezes o construtor Cpara aninhar e Npara o caso base.

Exemplo de uso (com deriving (Show)adicionado ao novo datatipo para poder imprimi-lo):f 4 "codegolf" ->C (C (C (C (N "codegolf")))) .

Edit: @Christian Sievers salvou 2 bytes reescrevendo a função em um estilo sem pontos para o argumento da string. Obrigado!

tinylisp (repl), 34 bytes

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

Define uma função F. Tecnicamente, tinylisp não possui seqüências de caracteres, mas esse código funcionará para qualquer tipo de dado fornecido.

Ungolfed (chave para builtins: d= define, q= cita, i= se, c= contras, s= subtrai):

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

Exemplo de uso:

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 é um pouco competitivo aqui. iteratecria uma sequência de x, (f x), (f (f x)) ...,nth retorna o elemento necessário.

Veja on-line: https://ideone.com/2rQ166