In:  Genug Speicher und eine positive ganze Zahl N

Out:  N-dimensionales N ^ N-Array, gefüllt mit N, wobei N ^ N N-mal-N-mal-N-mal-N bedeutet ...

Beispiele:

1: [1]Dies ist ein 1D-Array (eine Liste) der Länge 1, das eine einzelne 1 enthält

2: [[2,2],[2,2]]Dies ist ein 2D-Array (eine Tabelle) mit 2 Zeilen und 2 Spalten, gefüllt mit 2s

3: [[[3,3,3],[3,3,3],[3,3,3]],[[3,3,3],[3,3,3],[3,3,3]],[[3,3,3],[3,3,3],[3,3,3]]]Dies ist ein 3D-Array (ein Würfel) mit 3 Ebenen, 3 Zeilen und 3 Spalten, gefüllt mit 3s

4: [[[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]]],[[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]]],[[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]]],[[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]]]]

5 und 6: Bitte sehen Sie eine der Antworten.

Python , 32 Bytes

lambda n:eval('['*n+'n'+']*n'*n)

Probieren Sie es online!

Erstellt einen String wie "[[[n]*n]*n]*n"bei nMultiplikationen und wertet ihn als Python-Code aus. Da die Auswertung innerhalb des Funktionsumfangs erfolgt, wird der Variablenname nzur Funktionseingabe ausgewertet.

J, 4 Bytes

$~#~

Probieren Sie es online!

Erläuterung

$~#~  Input: integer n
  #~  Create n copies of n
$~    Shape n into an array with dimensions n copies of n

APL (Dyalog APL) , 4 Bytes

⍴⍨⍴⊢

Probieren Sie es online!

Mathematica, 22-20 Bytes

(t=Table)@@t[#,#+1]&

(* or *)

Table@@Table[#,#+1]&

R 26

Dies ist die offensichtliche Antwort, aber vielleicht gibt es etwas Klügeres?

n=scan();array(n,rep(n,n))

JavaScript (ES6),  44 bis  40 Byte

f=(n,k=i=n)=>i--?f(n,Array(n).fill(k)):k

Demo

f=(n,k=i=n)=>i--?f(n,Array(n).fill(k)):k

console.log(JSON.stringify(f(1)))
console.log(JSON.stringify(f(2)))
console.log(JSON.stringify(f(3)))
console.log(JSON.stringify(f(4)))

Haskell , 52 Bytes

f n=iterate(filter(>'"').show.(<$[1..n]))(show n)!!n

Probieren Sie es online!

Inspiriert von der Antwort von @ nimi , aber mit mehr vordefinierten Funktionen.

• Verwendet iterateund !!anstelle einer rekursiven Hilfefunktion.
• Anstatt Listentrennzeichen "von Hand" filter(>'"').showzu erstellen, wird eine Liste mit Zeichenfolgen formatiert und die zusätzlichen "Zeichen entfernt.

05AB1E (Legacy) , 6 5 Bytes

-1 dank Kevin Cruijssen

F¹.D)

Probieren Sie es online!

F     # For 0 .. input
 ¹.D) # Push <input> copies of the result of the last step as an array

Oktave, 35 33 25 23 20 Bytes

@(N)ones(N+!(1:N))*N

Probieren Sie es online!

@(N)ones(N*ones(1,N))*N

@(N)repmat(N,N*ones(1,N))

Dank @LuisMendo 8 Bytes gespart

@(N)ones(num2cell(!(1:N)+N){:})*N

Probieren Sie es online!

Vorherige Antwort:

@(N)repmat(N,num2cell(!(1:N)+N){:})

Probieren Sie es online!

Haskell, 62 Bytes

n#0=show n
n#l='[':tail((',':)=<<n#(l-1)<$[1..n])++"]"
f n=n#n

Anwendungsbeispiel: f 2-> "[[2,2],[2,2]]". Probieren Sie es online! .

Das strenge Typensystem von Haskell verhindert, dass eine Funktion verschachtelte Listen mit unterschiedlichen Tiefen zurückgibt. Daher konstruiere ich das Ergebnis als String.

Wie es funktioniert:

n#l=                         n with the current level l is
    '[':                     a literal [ followed by
           n#(l-1)<$[1..n]   n copies of   n # (l-1)
        (',':)=<<            each prepended by a , and flattened into a single list
      tail                   and the first , removed
                  ++"]"      followed by a literal ]

n#0=show n                   the base case is n as a string

f n=n#n                      main function, start with level n         

MATL, 8 Bytes

ttY"l$l*

Probieren Sie es bei MATL Online aus (ich habe einen Code hinzugefügt, der die tatsächliche Größe der Ausgabe anzeigt, da alle n-dimensionalen Ausgaben in MATL als 2D-Matrizen angezeigt werden, bei denen alle Dimensionen> 2 in die zweite Dimension abgeflacht sind).

Erläuterung

        % Implicitly grab the input (N)
tt      % Make two copies of N
Y"      % Perform run-length decoding to create N copies of N
l$1     % Create a matrix of ones that is this size  
*       % Multiply this matrix of ones by N
        % Implicitly display the result  

Python 2 , 36 Bytes

-2 Bytes dank @CalculatorFeline

a=n=input()
exec"a=[a]*n;"*n
print a

Probieren Sie es online!

CJam , 12 Bytes

ri:X{aX*}X*p

Probieren Sie es online!

Erläuterung

ri:X          Read an integer from input, store it in X (leaves it on the stack)
    {   }X*   Execute this block X times:
     a          Wrap the top of stack in an array
      X*        Repeat the array X times
           p  Print nicely

Gelee , 5 Bytes

⁾Wẋẋv

Probieren Sie es online!

Wie?

⁾Wẋẋv - Main link: n                            e.g.       3
⁾Wẋ   - character pair literal ['W','ẋ']                  "Wẋ"
   ẋ  - repeat list n times                               "WẋWẋWẋ"
    v - evaluate as Jelly code with input n          eval("WẋWẋWẋ", 3)
      - ...
        WẋWẋ... - toEval: n                e.g. 3
        W        - wrap                        [3]
         ẋ       - repeat list n times         [3,3,3]
          Wẋ     - wrap and repeat            [[3,3,3],[3,3,3],[3,3,3]]
            ...  - n times total             [[[3,3,3],[3,3,3],[3,3,3]],[[3,3,3],[3,3,3],[3,3,3]],[[3,3,3],[3,3,3],[3,3,3]]]

Java 97 96 95 Bytes

Object c(int n,int i){Object[]a=new Object[n];for(int j=0;j<n;)a[j++]=i<2?n:c(n,i-1);return a;}

Ungolfed:

public class N_Dim {

    public static Object create(int n) {
        return create(n, n);
    }

    public static Object create(int n, int i) {
        Object[] array = new Object[n];
        for(int j=0;j<n;j++) {
            array[j] = i<2?n:create(n, i - 1);
        }
        return array;
    }

    public static void main(String[] args) {
        System.out.println(Arrays.deepToString((Object[]) create(3)));
    }

}

JavaScript (ES6), 38 Byte

f=(n,m=n)=>m?Array(n).fill(f(n,m-1)):n

Die speicherhungrige Version davon ist 45 Bytes:

f=(n,m=n)=>m?[...Array(n)].map(_=>f(n,m-1)):n

Bash + GNU-Dienstprogramme, 117 Bytes

n=$[$1**$1]
seq -f$1o%.fd$n+1-p $n|dc|rev|sed -r "s/(0+|$[$1-1]*).*$/\1/;s/^(0*)/\1$1/;s/^1/[1]/"|tr \\n0$[$1-1] \ []

Probieren Sie es online!

Das Programm zählt im Wesentlichen von 0 bis (n ^ n) -1 in der Basis n, wobei n die Eingabe ist. Für jede Basis-n-Zahl k in der Zählung wird Folgendes ausgeführt:

1. Wenn k mit mindestens einer Ziffer 0 endet, geben Sie am Ende von k für jede Ziffer 0 ein '[' aus.
2. Drucke n.
3. Wenn k mit mindestens einer Ziffer n-1 endet, geben Sie am Ende von k für jede Ziffer n-1 ein ']' aus.

(Für den Wert n = 1 müssen als Sonderfall Klammern hinzugefügt werden. Dieser Eingabewert generiert auch eine Ausgabe an stderr, die unter Standard-PPCG-Regeln ignoriert werden kann.)

Vielleicht gibt es einen kürzeren Weg, um diese Idee umzusetzen.

Probelauf:

./array 3
[[[3 3 3] [3 3 3] [3 3 3]] [[3 3 3] [3 3 3] [3 3 3]] [[3 3 3] [3 3 3] [3 3 3]]]

Gelee , 4 Bytes

R»µ¡

Probieren Sie es online!

R»µ¡
R     Range. 2 -> [1, 2]
 »    Max between left arg and right arg. Vectorizes. -> [2, 2]
  µ   Separates into a new chain.
   ¡  Repeat 2 times. After another iteration this yields [[2, 2], [2, 2]].

Das Gleiche, aber mit einer einzigen Monade und ohne Kettenseparator:

4 Bytes

»€`¡

Gelee , 5 Bytes

Wẋ³µ¡

Probieren Sie es online!

Erläuterung

         Implicit input: N
   µ¡    Apply N times to input:
Wẋ³        “N copies of”

Python 3 , 57 53 50 38 Bytes

f=lambda n,c=0:n-c and[f(n,c+1)*n]or 1

Probieren Sie es online!

-4 Bytes dank @CalculatorFeline

34 Bytes:

f=lambda c,n:c and[f(c-1,n)*n]or 1

Muss aufgerufen werden als f(4,4)

Ruby, 28 26 Bytes

Vielen Dank an Cyoce für das Speichern von 2 Bytes!

->n{eval'['*n+'n'+']*n'*n}

Schamlos gestohlen xnor ‚s ausgezeichnete Antwort .

Ruby, 27 Bytes

->a{(z=a).times{z=[z]*a};z}

Nur noch 1 Byte, aber mit einem anderen Ansatz als dem 'Eval'-Trick von xnors wundervoller Python-Antwort.

Perl 6 , 25 Bytes

{($^n,{$_ xx$n}...*)[$n]}

Beginnt mit nden Transformationszeiten "n-mal wiederholen" und wendet diese iterativ an n, wobei jedes Mal eine zusätzliche ListVerschachtelungsebene erstellt wird.

Probieren Sie es online!

PHP, 70 62 Bytes

Dies ist das einfachste, was ich mir vorstellen kann.

for(;$i++<$n=$argv[1];)$F=array_fill(0,$n,$F?:$n);print_r($F);

Nimmt die Eingabe als erstes Argument und druckt das resultierende Array auf dem Bildschirm.

Vielen Dank an @ user59178 für das Speichern von 8 Bytes !

Clojure, 36 Bytes

#(nth(iterate(fn[a](repeat % a))%)%)

Iteriert eine Funktion, die ihre Argumentationszeiten wiederholt n, erzeugt sie eine unendliche Folge solcher Elemente und nimmt dann ihr nth-Element.

Sehen Sie es online

Rebol, 45 Bytes

func[n][array/initial append/dup copy[]n n n]

Batch, 141 Bytes

@set t=.
@for /l %%i in (2,1,%1)do @call set t=%%t%%,.
@set s=%1
@for /l %%i in (1,1,%1)do @call call set s=[%%%%t:.=%%s%%%%%%]
@echo %s%

Batch enthält eigentlich keine Arrays, daher wird nur die Zeichenfolgendarstellung eines Arrays gedruckt. Erläuterung: Die ersten beiden Zeilen bilden ein sich wiederholendes Muster von N .s, das N-1 ,in der Variablen durch s getrennt ist t. In der vierten Zeile wird dies dann als Substitutionsmuster Nverwendet, um das Neindimensionale Array zu erstellen . Das Doppelte callist notwendig, weil die Anweisungen forund setfunktionieren. Erstens ersetzt der forBefehl Variablen. Zufälligerweise werden alle meine %Zeichen verdoppelt, was nichts anderes bewirkt, als sie alle zu entfernen, was zur Folge hat call call set s=[%%t:.=%s%%%]. Anschließend werden die resultierenden Anweisungszeiten wiederholt N. Der callBefehl ersetzt jedes Mal Variablen. Zu diesem Zeitpunkt hat die sVariable nur eine einzige Menge von%s, also wird es ersetzt, was zu (zB) führt call set s=[%t:.=[2,2]%]. Der innere Aufruf ersetzt dann die tVariable, was dazu führt, dass (z. B.) set s=[[2,2],[2,2]]die gewünschte Zuweisung ausgeführt wird. Der Endwert von swird dann gedruckt.

Clojure, 49 Bytes

(defmacro r[n]`(->> ~n ~@(repeat n`(repeat ~n))))

Nicht das kürzeste Clojure-Beispiel, aber ich habe mich mit dem Zitieren und Nichtzitieren amüsiert.

ich , 7 Bytes

Das habe ich von meinem Kollegen bekommen, dem Schöpfer von I.

#Bbhph~

#Bb     die #Kopierfunktion B ound b inding
   hp   h so schnell und das Argument (rechts von) der p ower Funktion (repeat)
     h~ h so schnell und das Argument nach links ~(der gesamte sich ergebende Funktion)

Probieren Sie es online!

Common Lisp, 128 102 95 79 Bytes

(defun f(x &optional y)(if(if y(< y 2))x(fill(make-list x)(f x(if y(1- y)x)))))

Probieren Sie es online!