Sie müssen eine Funktion erzeugen, die eine Zeichenfolge sinnerhalb eines Arrays nmal verschachtelt

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

Parameter:

1. s - Eine Ascii-Saite
2. n - Eine ganze Zahl >= 0

Regeln

• Kürzester Code gewinnt.
• Der Ausgang wird ein verschachtelt werden array, listoder tuple(oder ähnlicher Typ aus einer Anordnung basierte)

Testfälle

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

_{Inspiriert von: N-maliges Verschachteln einer Zeichenfolge in einer Liste, dh Liste einer Liste einer Liste}

Gelee , 2 Bytes

W¡

Etwas verwirrend, da: (1) Jelly keine Schnüre hat, nur Listen von Charakteren; und 2); Die Ausgabe zeigt nicht die Verschachtelung. Um zu sehen, dass dies tatsächlich das tut, was gefragt wird, schauen Sie sich eine Python-String-Darstellung des Ergebnisses an mit:

W¡ŒṘ

Ein zusätzliches Paar von []ist vorhanden, da die Zeichenfolge selbst eine Liste von Zeichen ist. Beispielsweise

Wie?

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

Der Proof-of-Concept-Code fügt hinzu:

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

Java und C #, 62 Bytes

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

Sollte ohne Änderungen in Java und C # funktionieren.

05AB1E , 3 Bytes

Code

`F)

Erläuterung

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

Dies bedeutet, dass dies auch für den 0- Testfall funktioniert, da sich der String bereits auf dem Stack befindet.

Probieren Sie es online!

JavaScript (ES6), 20 Byte

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

Obwohl die Leute mich normalerweise nerven, meine Funktionen für die 1-Byte-Speicherung zu curry, ist dies ein Fall, in dem dies tatsächlich zur Lösung beiträgt.

Mathematica, 13 Bytes

List~Nest~##&

CJam , 7 6 Bytes

{{a}*}

Online-Dolmetscher

Dies ist eine Funktion , die unnamed ihre Argumente vom Stapel nimmt als S N, Sdie Saite zu sein undN die Packungen zu sein. Sie können es mit dem ~Operator, also eval, ausführen .

Erläuterung:

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

Rekursive Funktion

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 ergibt die gleiche Länge

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

Brachylog , 10 Bytes

tT,?h:T:gi

Probieren Sie es online!

Erläuterung

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

Dies wären 3 Bytes, wenn es nicht fehlerhaft wäre. Hier brauchen wir all das, um die Liste zu bekommen [String, T, built-in_group], obwohl dies [String, T]bereits unser Input ist.

Leider :gergibt sich direkt [[String, T], built-in_group], was nicht richtig erkannt wird, ida die ganze Zahl Tin der ersten Liste steht.

MATL, 6 Bytes

ji:"Xh

Dies erzeugt ein verschachteltes Zellenarray als Ausgabe. Bei der Standardanzeige von MATL können Sie jedoch nicht unbedingt erkennen, dass dies der Fall ist, da nicht alle geschweiften Klammern angezeigt werden. Die folgende Demo ist eine leicht modifizierte Version, die die Zeichenfolgendarstellung der Ausgabe zeigt.

ji:"Xh]&D

Probieren Sie es online

Erläuterung

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

Probieren Sie es hier aus!

Pyth , 3 Bytes

]Fw

Permalink

Dies wird so etwas wie ausgeben ...[[[[['string']]]]].... Es wird nicht für Null Tiefe zitieren: string.

Erläuterung:

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

Wenn Sie die Tiefe Null angeben möchten, verwenden Sie stattdessen diese 4-Byte-Lösung (Erläuterung):

`]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, wenn es nur nach der Aufgabe aussieht

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

Ruby: 23 Bytes

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

Dies wurde aktualisiert, um es zu einem aufrufbaren Proc zu machen und nicht zum Original-Snippet. Mich würde interessieren, ob es einen Weg gibts implizit zurückgegeben zu werden, anstatt ihn explizit zurückgeben zu müssen.

C, 44 Bytes , 41 Bytes

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

Sie können es folgendermaßen testen:

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

Die Ausgabe:

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

Natürlich erhalten Sie Warnungen. Dies funktioniert unter gccBash auf meinem Windows-Computer ( gcc version 4.8.4 (Ubuntu 4.8.4-2ubuntu1~14.04.3)sowie auf einem echten Linux-Computer ( 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 Zeichen

Schreiben Sie die Python-Lösung von jamylak neu .

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

Probelauf:

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

Genannt wie in der Antwort von manatwork , aber eine seltsamere Implementierung. *sBricht die Eingabe (eine möglicherweise verschachtelte Zeichenfolge) in ein Array ein. Wenn ndann Null ist, wird s[n]das erste Element von zurückgegeben s, wodurch die Funktion in ein No-Op umgewandelt wird. Andernfalls wird zurückgegeben, nilda simmer nur ein Element vorhanden ist, sodass wir zum rekursiven Aufruf übergehen.

V , 6 Bytes

Àñys$]

Probieren Sie es online!

Erläuterung:

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

Perl 6 , 23 Bytes

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

Erweitert:

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

Da der Rückgabetyp der Funktion von der als Argument angegebenen Zahl abhängt, ist dies eindeutig ein Fall, in dem eine abhängig typisierte Sprache verwendet werden sollte. Leider ist Golfen in einer Sprache, in der Sie Naturals und Listen importieren müssen, um sie zu verwenden, nicht einfach. Auf der positiven Seite verwenden sie, sucwo ich das ausführliche erwartet hätte succ. Also hier ist mein Code:

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 ]

(Ich hoffe , dass ich alle Orte gefunden , wo Räume verzichtet werden kann.) LIst eine Art Funktion , die eine natürliche gegeben nund ein Typ agibt den Typ nmal verschachtelt Listen a, so L 3 Boolwäre die Art von Listen von Listen von Listen Bool(wenn wir hatten importiert Bool). Dies ermöglicht es uns, die Art unserer Funktion als auszudrücken(n : ℕ) -> {a : Set} -> a -> L n a , dass die geschweiften Klammern dieses Argument implizieren. Der Code verwendet einen kürzeren Weg, um diesen Typ zu schreiben. Die Funktion kann jetzt auf offensichtliche Weise durch Mustervergleich beim ersten Argument definiert werden.

Diese Datei Laden mit einer .agdaErweiterung in Emacs Verwendung erlaubt C-c C-n(bewertet Begriff Normalform), Eingang zum Beispiel f 2 3und die richtige Antwort in einer unangenehmen Form erhalten: (3 ∷ []) ∷ []. Wenn du das mit Strings machen willst, musst du sie natürlich importieren ...

k, 3 Bytes

,:/

Wird als dyadische Funktion /interpretiert und wendet die linke Funktion ,:( enlist) n-mal iterativ auf das zweite Argument an.

Beispiel:

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

PHP, 44 Bytes

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

nichts Anspruchsvolles, nur eine rekursive Funktion

Python 2, 32 Bytes

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

Setzt noffene Klammern vor die Zeichenfolge und nschließende Klammern vor die Zeichenfolge und wertet das Ergebnis aus. Wenn eine Zeichenfolgenausgabe zulässig ist, evalkann die entfernt werden.

Eigentlich 4 Bytes

Eingabe ist stringdann n. Golfvorschläge sind willkommen. Probieren Sie es 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 bis 40 Bytes

BEARBEITEN: Korrigiert die n=0 Problem wurde dank @rturnbull behoben.

Funktion, die zwei Eingaben s(Zeichenfolge) und n(Verschachtelung) akzeptiert und die verschachtelte Liste ausgibt. Beachten Sie, dass R-class die listAusgabe von Haus aus anders ausgibt als die meisten anderen Sprachen, jedoch funktional einer Schlüssel- / Wertzuordnung (mit möglicherweise unbenannten Schlüsseln) oder einer Liste in Python ähnelt.

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

Beispiel

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

Schläger 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)

Testen:

(f "test" 3)

Ausgabe:

"[[['test']]]"

Haskell, 40 38 Bytes

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

Das strikte Typensystem von Haskell verhindert die Rückgabe verschiedener Typen (Strings vs. Liste der Strings vs. Liste der Strings, ...), daher muss ich meinen eigenen Typ definieren, der all diese Fälle berücksichtigt. Die Hauptfunktion fruft rekursiv nmal den Konstruktor Cfür die Verschachtelung und Nfür den Basisfall auf.

Anwendungsbeispiel (mit deriving (Show)dem neuen dataTyp hinzugefügt, um es drucken zu können): f 4 "codegolf"-> C (C (C (C (N "codegolf")))).

Edit: @Christian Sievers sparte 2 Bytes, indem er die Funktion für das String-Argument in einem Punkt-freien Stil umschrieb. Vielen Dank!

tinylisp (repl), 34 bytes

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

Definiert eine Funktion F. Technisch gesehen hat tinylisp keine Strings, aber dieser Code funktioniert für jeden angegebenen Datentyp.

Ungolfed (Schlüssel zu 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))))

Anwendungsbeispiel:

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 ist hier etwas konkurrenzfähig. iterateErstellt eine Folge von x, (f x), (f (f x)) ..., nthgibt das benötigte Element zurück.

Sehen Sie es online: https://ideone.com/2rQ166