W:  Wystarczająca ilość pamięci i dodatnia liczba całkowita N

Out:  N-wymiarowa tablica N ^ N wypełniona N, gdzie N ^ N oznacza N wyrażenia N-by-N-by-N-by ...

Przykłady:

1: [1]która jest tablicą 1D (lista) o długości 1, zawierającą pojedynczą 1

2: [[2,2],[2,2]]czyli tablica 2D (tabela) z 2 rzędami i 2 kolumnami, wypełniona 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]]]która jest macierzą 3D (sześcian) z 3 warstwami, 3 rzędami i 3 kolumnami, wypełnionymi 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 i 6: Zobacz jedną z odpowiedzi.

Python , 32 bajty

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

Wypróbuj online!

Tworzy ciąg znaków "[[[n]*n]*n]*n"z nmnożenia i ocenia go jako kod Pythona. Ponieważ ocena odbywa się w zakresie funkcji, nazwa zmiennej jest nprzetwarzana na dane wejściowe funkcji.

J, 4 bajty

$~#~

Wypróbuj online!

Wyjaśnienie

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

APL (Dyalog APL) , 4 bajty

⍴⍨⍴⊢

Wypróbuj online!

Mathematica, 22 20 bajtów

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

(* or *)

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

R 26

To oczywista odpowiedź, ale może jest coś mądrzejszego?

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

JavaScript (ES6),  44  40 bajtów

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

Próbny

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 bajty

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

Wypróbuj online!

Zainspirowany odpowiedzią @ nimi , ale używając bardziej zdefiniowanych funkcji.

• Używa iteratei !!zamiast funkcji pomocy rekurencyjnej.
• Zamiast konstruować ograniczniki listy „ręcznie”, używa filter(>'"').showdo formatowania listy ciągów znaków, a następnie usuwania dodatkowych "znaków.

05AB1E (starsza wersja) , 6 5 bajtów

-1 dzięki Kevin Cruijssen

F¹.D)

Wypróbuj online!

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

Oktawa, 35 33 25 23 20 bajtów

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

Wypróbuj online!

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

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

Dzięki @LuisMendo zapisano 8 bajtów

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

Wypróbuj online!

Poprzednia odpowiedź:

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

Wypróbuj online!

Haskell, 62 bajty

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

Przykład użycia: f 2-> "[[2,2],[2,2]]". Wypróbuj online! .

System ścisłego typu Haskell zapobiega funkcji, która zwraca zagnieżdżone listy o różnych głębokościach, więc wynik tworzę jako ciąg znaków.

Jak to działa:

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 bajtów

ttY"l$l*

Wypróbuj go w MATL Online (dodałem kod pokazujący rzeczywisty rozmiar danych wyjściowych, ponieważ wszystkie n-wymiarowe dane wyjściowe w MATL są pokazane jako macierze 2D, w których wszystkie wymiary> 2 są spłaszczone do drugiego wymiaru).

Wyjaśnienie

        % 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 bajtów

-2 bajty dzięki @CalculatorFeline

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

Wypróbuj online!

CJam , 12 bajtów

ri:X{aX*}X*p

Wypróbuj online!

Wyjaśnienie

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

Galaretka , 5 bajtów

⁾Wẋẋv

Wypróbuj online!

W jaki sposób?

⁾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 bajtów

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

Nie golfowany:

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 bajtów

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

Wersja głodna pamięci to 45 bajtów:

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

Narzędzia Bash + GNU, 117 bajtów

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] \ []

Wypróbuj online!

Program zasadniczo liczy od 0 do (n ^ n) -1 w bazie n, gdzie n jest wejściem. Dla każdej liczby bazowej n w zliczeniu wykonuje następujące czynności:

1. Jeśli k kończy się co najmniej jedną cyfrą 0, wypisz „[” dla każdej cyfry 0 na końcu k.
2. Drukuj n.
3. Jeśli k kończy się co najmniej jedną cyfrą n-1, wypisz „]” dla każdej cyfry n-1 na końcu k.

(Wartość n = 1 wymaga dodania nawiasów jako szczególnego przypadku. Ta wartość wejściowa generuje również dane wyjściowe do stderr, które można zignorować zgodnie ze standardowymi regułami PPCG.)

Może istnieje krótszy sposób na wdrożenie tego pomysłu.

Przykładowy przebieg:

./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]]]

Galaretka , 4 bajty

R»µ¡

Wypróbuj 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]].

To samo, ale z jedną monadą i bez potrzeby stosowania separatora łańcucha:

4 bajty

»€`¡

Galaretka , 5 bajtów

Wẋ³µ¡

Wypróbuj online!

Wyjaśnienie

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

Python 3 , 57 53 50 38 bajtów

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

Wypróbuj online!

-4 bajty dzięki @CalculatorFeline

34 bajty:

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

Musi być nazwany jako f(4,4)

Rubinowy, 28 26 bajtów

Dzięki Cyoce za zapisanie 2 bajtów!

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

Skradziony bezwstydnie z XNOR jest doskonałą odpowiedzią .

Rubinowy, 27 bajtów

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

Tylko 1 bajt więcej, ale stosując inne podejście zamiast sztuczki „eval” z cudownej odpowiedzi xnora na Pythona.

Perl 6 , 25 bajtów

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

Zaczyna się ni iteracyjnie stosuje czasy transformacji „powtórz n razy” n, za każdym razem tworząc dodatkowy poziom Listzagnieżdżenia.

Wypróbuj online!

PHP, 70 62 bajtów

To najprostszy, jaki mogę wymyślić.

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

Pobiera dane wejściowe jako pierwszy argument i drukuje wynikową tablicę na ekranie.

Dzięki @ user59178 za uratowanie mnie 8 bajtów !

Clojure, 36 bajtów

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

Iteruje funkcję, która powtarza swoje nczasy argumentów , tworzy nieskończoną sekwencję takich elementów, a następnie pobiera swój nelement th.

Zobacz online

Rebol, 45 bajtów

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

Partia, 141 bajtów

@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 tak naprawdę nie ma tablic, więc po prostu drukuje reprezentację ciągu tablicy. Objaśnienie: Pierwsze dwie linie tworzą powtarzalny wzorzec N .s oddzielony przez N-1 ,s w zmiennej t. Czwarta linia używa tego jako wzorca podstawienia Nrazy do utworzenia Ntablicy -wymiarowej. Podwajanie calljest konieczne ze względu na działanie instrukcji fori set. Po pierwsze, forpolecenie zastępuje zmienne. Tak się składa, że ​​wszystkie moje %znaki są podwojone, więc nic nie robi poza tym, że cofnęłam je wszystkie, w wyniku czego call call set s=[%%t:.=%s%%%]. Następnie powtarza wynikowe Nczasy instrukcji . Za każdym razem callpolecenie zastępuje zmienne. W tym momencie szmienna ma tylko jeden zestaw%s, więc zostaje podstawiony, co powoduje (np call set s=[%t:.=[2,2]%]. ) . Wewnętrzne wywołanie następnie zastępuje tzmienną, co powoduje (np.) set s=[[2,2],[2,2]]Wykonanie żądanego przypisania. Ostateczna wartość sjest następnie drukowana.

Clojure, 49 bajtów

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

Nie najkrótszy przykład Clojure, ale bawiłem się cytowaniem i nie cytowaniem.

I , 7 bajtów

Dostałem to od mojego kolegi, twórcy I.

#Bbhph~

#Bb     kopiowanie #funkcji B ound do b inding
   hp   wys OOK argument do (na prawo), str funkcji ower (powtarzanie)
     h~ wys OOK argument w lewo ~(w stosunku do całej funkcji wynikających)

Wypróbuj online!

Common Lisp, 128 102 95 79 bajtów

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

Wypróbuj online!