In:  Yeterli bellek ve pozitif bir tamsayı N

Çıkışı:  N boyutlu N ^ N dizisi N ile doldurulur, burada N ^ N N-by-N-by-N-by ...

Örnekler:

1: 1 [1]uzunluğunda 1D dizisi (bir liste)

2: [[2,2],[2,2]]2 sıra ile dolu 2 sıra ve 2 sütun içeren 2 boyutlu bir dizi (tablo)

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]]]3 katmanla dolu 3 katman, 3 satır ve 3 sütun içeren bir 3B dizi (küp)

4: [[[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]]],[[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]]],[[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]]],[[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[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 ve 6: Lütfen cevaplardan birine bakınız.

Python , 32 bayt

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

Çevrimiçi deneyin!

Gibi bir dize yapar "[[[n]*n]*n]*n"ile nçarpımı, ve Python kodu olarak değerlendirerek. Değerlendirme fonksiyon kapsamı içinde gerçekleştiğinden, değişken ismi nfonksiyon girişine göre değerlendirilir.

J, 4 bayt

$~#~

Çevrimiçi deneyin!

açıklama

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

APL (Dyalog APL) , 4 bayt

⍴⍨⍴⊢

Çevrimiçi deneyin!

Mathematica, 22 20 bayt

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

(* or *)

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

R, 26

Bu açık cevap ama belki daha zekice bir şey var mı?

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

JavaScript (ES6),  44  40 bayt

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

gösteri

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 bayt

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

Çevrimiçi deneyin!

@ Nimi'nin cevabından ilham aldı , ancak daha önceden tanımlanmış fonksiyonları kullanıyor.

• Özyinelemeli yardım işlevini kullanır iterateve kullanır !!.
• Liste sınırlayıcıları "el ile" oluşturmak yerine, filter(>'"').showbir dize listesini biçimlendirmek için kullanır , ardından fazladan "karakterleri çıkarır .

05AB1E (eski) , 6 5 bayt

-1 Kevin Cruijssen sayesinde

F¹.D)

Çevrimiçi deneyin!

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

Octave, 35 33 25 23 20 bayt

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

Çevrimiçi deneyin!

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

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

@LuisMendo sayesinde 8 bayt kaydedildi

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

Çevrimiçi deneyin!

Önceki cevap:

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

Çevrimiçi deneyin!

Haskell, 62 bayt

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

Kullanım örneği: f 2-> "[[2,2],[2,2]]". Çevrimiçi deneyin! .

Haskell'in katı tip sistemi, farklı derinliklerde iç içe geçmiş listeler döndüren bir işlevi önlediğinden, sonucu bir dizge olarak yapıyorum.

Nasıl çalışır:

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 bayt

ttY"l$l*

MATL Online'da deneyin ( Çıkışın asıl boyutunu gösteren bir kod ekledim , çünkü MATL'deki tüm n boyutlu çıktılar,> 2'nin tüm boyutlarının ikinci boyuta düzleştirildiği 2D matrisler olarak gösterilir).

açıklama

        % 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 bayt

@CalculatorFeline sayesinde -2 bayt

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

Çevrimiçi deneyin!

CJam , 12 bayt

ri:X{aX*}X*p

Çevrimiçi deneyin!

açıklama

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

Jöle , 5 bayt

⁾Wẋẋv

Çevrimiçi deneyin!

Nasıl?

⁾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 bayt

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 bayt

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

Bunun belleğe aç sürümü 45 bayttır:

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

Bash + GNU yardımcı programları, 117 bayt

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

Çevrimiçi deneyin!

Program temel olarak n'nin girdi olduğu n bazında 0 ile (n ^ n) -1 arasında sayılır. Sayıdaki her bir baz-n sayısı için, aşağıdakileri yapar:

1. K, en az bir basamak 0 ile bitiyorsa, k'nin sonunda her basamak 0 için bir '[' bas.
2. Yazdır
3. K, en az bir rakam n-1 ile bitiyorsa, k'nin sonunda n-1 her rakam için bir ']' yazdırın.

(N = 1 değerinin, özel durum olarak eklenen parantezlere sahip olması gerekir. Bu giriş değeri, standart PPCG kuralları altında göz ardı edilebilecek stderr için de bir miktar çıktı oluşturur.)

Belki bu fikri hayata geçirmenin daha kısa bir yolu vardır.

Örnek çalışma:

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

Jöle , 4 bayt

R»µ¡

Çevrimiçi deneyin!

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

Aynı şey, ancak tek bir monad ile ve zincir ayırıcıya ihtiyaç duyulmadan:

4 bayt

»€`¡

Jöle , 5 bayt

Wẋ³µ¡

Çevrimiçi deneyin!

açıklama

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

Python 3 , 57 53 50 38 bayt

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

Çevrimiçi deneyin!

@CalculatorFeline sayesinde -4 bayt

34 bayt:

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

Olarak adlandırılması gerekiyor f(4,4)

Ruby, 28 26 bayt

2 bayt kaydettiğiniz için Cyoce'ye teşekkürler !

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

Xnor 'ın mükemmel cevabından utanmadan çalındı .

Ruby, 27 bayt

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

Sadece 1 bayt daha fazla ama xnor'un harika Python cevabındaki 'eval' numarası yerine farklı bir yaklaşım kullanıyor.

Perl 6 , 25 bayt

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

İle başlar niteratif ve "tekrar n kere" dönüşüm uygular nkez, her defasında ek bir düzeyde oluşturmak Listyuva.

Çevrimiçi deneyin!

PHP, 70 62 bayt

Bu bulabildiğim en basit şey.

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

Girdiyi ilk argüman olarak alır ve elde edilen diziyi ekrana basar.

Bana 8 byte kaydettiğiniz için @ user59178'e teşekkürler !

Clojure, 36 bayt

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

Argüman nzamanlarını tekrarlayan fonksiyonu tekrar eder , bu elemanların sonsuz dizisini oluşturur ve daha sonra nth elemanını alır .

Çevrimiçi görün

Rebol, 45 bayt

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

Toplu iş, 141 bayt

@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%

Toplu iş aslında dizilere sahip değildir, bu yüzden bu sadece bir dizinin dize gösterimini basar. Açıklama: İlk iki satır değişkende N .s ile ayrılan tekrarlı bir s deseni oluşturur . Dördüncü satır daha sonra bunu -diyatif diziyi oluşturmak için ikame deseni süreleri olarak kullanır . Ve ifadeleri nasıl çalıştığı için çift gereklidir . İlk olarak, komut değişkenleri değiştirir. Olduğu gibi, tüm işaretlerim iki katına çıkar, bu da sonuçta hepsini alıntıdan başka hiçbir şey yapmaz . Daha sonra elde edilen ifade zamanlarını tekrar eder . Her seferinde komut değişkenleri değiştirir. Bu noktada, değişken yalnızca tek bir kümeye sahiptirN-1 ,tNNcallforsetfor%call call set s=[%%t:.=%s%%%]Ncalls%s, böylece sübstitüe edilir, (örn.) ile sonuçlanır call set s=[%t:.=[2,2]%]. İç çağrı daha sonra tdeğişkenin yerine geçer, (örneğin) set s=[[2,2],[2,2]]istenen görevi yerine getirir. Son değeri sdaha sonra yazdırılır.

Clojure, 49 bayt

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

En kısa Clojure örneği değil ama kendimi alıntı ve alıntılarla eğlendirdim.

Ben , 7 bayt

Bunu meslektaşım olan I'in yaratıcısından aldım.

#Bbhph~

#Bb     Kopyalama #fonksiyonu B duyulsa için b INDING
   hp   h (sağ) için bakınız bağımsız değişken p (tekrar) ower fonksiyonu
     h~ h bakınız sola bağımsız değişken ~(tüm Elde edilen fonksiyon)

Çevrimiçi deneyin!

Ortak Lisp, 128 102 95 79 bayt

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

Çevrimiçi deneyin!