Debe producir una función que anida una cadena sdentro de una matriz, nveces

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

Parámetros:

1. s - Una cuerda ascii
2. n - un entero >= 0

Reglas

• El código más corto gana.
• La salida será una anidada array, listo tuple(tipo o similar basado fuera una matriz)

Casos de prueba

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

_{Inspirado por: Anidar una cadena dentro de una lista n veces, es decir, lista de una lista de una lista}

Jalea , 2 bytes

W¡

Ligeramente confuso, ya que: (1) Jelly no tiene cadenas, solo listas de caracteres; y 2); la salida no mostrará el anidamiento. Para ver que esto realmente está haciendo lo que se le pide, mire una representación en cadena de Python del resultado con:

W¡ŒṘ

Un par adicional de []estará presente ya que la cadena en sí será una lista de caracteres. Por ejemplo

¿Cómo?

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

El código de prueba de concepto agrega:

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

Java y C #, 62 bytes

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

Debería funcionar sin modificaciones tanto en Java como en C #.

05AB1E , 3 bytes

Código

`F)

Explicación

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

Esto significa que esto también funciona para el caso de prueba 0 , ya que la cadena ya está en la pila.

Pruébalo en línea!

JavaScript (ES6), 20 bytes

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

Aunque la gente normalmente me molesta para que modifique mis funciones para el ahorro de 1 byte, este es un caso en el que realmente contribuye a la solución.

Mathematica, 13 bytes

List~Nest~##&

CJam , 7 6 bytes

{{a}*}

Intérprete en línea

Esta es una función sin nombre que toma sus argumentos de la pila como S N, Ssiendo la cadena yN las envolturas. Puede ejecutarlo con el ~operador, lo que significa evaluar.

Explicación:

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

Función 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))

Resultados de curry en la misma longitud

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

Brachylog , 10 bytes

tT,?h:T:gi

Pruébalo en línea!

Explicación

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

Esto sería de 3 bytes si no se corrigió. Aquí necesitamos todo esto para obtener la lista [String, T, built-in_group], aunque [String, T]ya es nuestra entrada.

Desafortunadamente, :gresulta directamente [[String, T], built-in_group], lo que no se reconoce correctamente iporque el número entero Testá dentro de la primera lista.

MATL, 6 bytes

ji:"Xh

Esto produce una matriz de celdas anidadas como salida. Sin embargo, con la pantalla predeterminada de MATL, no es necesario ver que es lo que es, ya que no mostrará todas las llaves. La demostración a continuación es una versión ligeramente modificada que muestra la representación de cadena de la salida.

ji:"Xh]&D

Pruébalo en línea

Explicación

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

Pruébalo aquí!

Pyth , 3 bytes

]Fw

Enlace permanente

Esto generará algo como ...[[[[['string']]]]].... No va a citar para la profundidad cero: string.

Explicación:

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

Si desea citar en profundidad cero, use esta solución de 4 bytes (explicación):

`]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 si solo se parece a la tarea

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

Rubí: 23 bytes

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

Esto se actualiza para convertirlo en un Proc invocable en lugar del fragmento original. Me interesaría saber si hay una manera de haber sdevuelto implícitamente en lugar de tener que devolverlo explícitamente.

C, 44 bytes , 41 bytes

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

Puede probarlo haciendo lo siguiente:

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

La salida:

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

Por supuesto, recibirás advertencias. Esto funciona en gccbash en mi máquina Windows ( gcc version 4.8.4 (Ubuntu 4.8.4-2ubuntu1~14.04.3)así como en una verdadera 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.

Reescribe la solución Python de jamylak .

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

Ejecución de muestra:

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

Rubí, 24 bytes.

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

Llamado igual que en la respuesta de manatwork , pero una implementación más extraña. *senvuelve la entrada (una cadena posiblemente anidada) en una matriz. Entonces, si nes cero, s[n]devuelve el primer elemento de s, convirtiendo la función en un no-op. De lo contrario, regresa nilya sque solo tendrá un elemento, por lo que pasamos a la llamada recursiva.

V , 6 bytes

Àñys$]

Pruébalo en línea!

Explicación:

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

Dado que el tipo de retorno de la función depende del número dado como argumento, este es claramente un caso en el que se debe usar un lenguaje de tipo dependiente. Desafortunadamente, jugar al golf no es fácil en un idioma en el que tienes que importar productos naturales y listas para usarlos. En el lado positivo, usan sucdonde hubiera esperado lo detallado succ. Entonces aquí está mi 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 haber encontrado todos los lugares donde se pueden omitir espacios). LEs una función de tipo que dada una natural ny un tipo adevuelve el tipo de nveces de listas anidadas a, por L 3 Boollo que sería el tipo de listas de listas de listas de Bool(si tuviéramos importado Bool). Esto nos permite expresar el tipo de nuestra función como (n : ℕ) -> {a : Set} -> a -> L n a, donde las llaves hacen implícito ese argumento. El código usa una forma más corta de escribir este tipo. La función ahora se puede definir de una manera obvia mediante la coincidencia de patrones en el primer argumento.

Cargado este archivo con una .agdaextensión en emacs permite el uso C-c C-n(evaluar término de forma normal), de entrada, por ejemplo, f 2 3y obtener la respuesta correcta en una forma incómoda: (3 ∷ []) ∷ []. Ahora, por supuesto, si quieres hacer eso con cadenas, tienes que importarlas ...

k, 3 bytes

,:/

Tomado como una función diádica, /aplicará iterativamente la función de la izquierda ,:( enlist) n veces al segundo argumento.

Ejemplo:

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

PHP, 44 bytes

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

nada sofisticado, solo una función recursiva

Python 2, 32 bytes

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

Pone nlos corchetes abiertos antes de la cadena y ncierra los corchetes antes de ella, luego evalúa el resultado. Si se permite una salida de cadena, evalse puede eliminar.

En realidad , 4 bytes

La entrada es stringentonces n. Sugerencias de golf bienvenidas. Pruébalo en línea!

`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

EDITAR: se corrigió el n=0 problema gracias a @rturnbull.

Función que toma dos entradas s(cadena) y n(anidamiento) y genera la lista anidada. Tenga en cuenta que la clase R listimprime de forma nativa la salida de manera diferente a la mayoría de los otros idiomas, sin embargo, es funcionalmente similar a un mapa de clave / valor (con claves posiblemente sin nombre) o una lista en Python.

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

Ejemplo

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

Raqueta 83 bytes

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

Sin golf:

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

Pruebas:

(f "test" 3)

Salida:

"[[['test']]]"

Haskell, 40 38 bytes

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

El estricto sistema de tipos de Haskell evita la devolución de diferentes tipos (cadenas frente a lista de cadenas frente a lista de cadenas, ...), por lo que tengo que definir mi propio tipo que se adapte a todos esos casos. La función principal fllama recursivamente nveces al constructor Cpara anidar y Npara el caso base.

Ejemplo de uso (con deriving (Show)agregado al nuevo datatipo para poder imprimirlo): f 4 "codegolf"->C (C (C (C (N "codegolf")))) .

Editar: @Christian Sievers guardó 2 bytes reescribiendo la función en un estilo sin puntos para el argumento de cadena. ¡Gracias!

tinylisp (repl), 34 bytes

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

Define una función F. Técnicamente, tinylisp no tiene cadenas, pero este código funcionará para cualquier tipo de datos que se le dé.

Sin golf (clave para construir: d= definir, q= citar, i= si, c= contras, s= restar):

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

Ejemplo 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 es algo competitivo aquí. iteratecrea una secuencia de x, (f x), (f (f x)) ...,nth devuelve el elemento necesario.

Véalo en línea: https://ideone.com/2rQ166