Dado un número entero positivo n, Ngenera la "matriz" de identidad dimensional, que es la N^Nmatriz con la 1que todos los componentes de los índices son iguales y de lo 0contrario. N^Nsignifica N-por-N-por-N-por -...

1 -> [1]

2 -> [[1,0],[0,1]]

3 -> [[[1,0,0],[0,0,0],[0,0,0]],[[0,0,0],[0,1,0],[0,0,0]],[[0,0,0],[0,0,0],[0,0,1]]]

4 -> [[[[1,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]],[[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,1,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]],[[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,1,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]],[[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,1]]]]

Por ejemplo, si aes la 4identidad de "matriz" -dimensional, a continuación, las únicas entradas con 1serían a[0][0][0][0], a[1][1][1][1], a[2][2][2][2], y a[3][3][3][3].

Este es el código de golf . La respuesta más corta en bytes gana. Se aplican lagunas estándar .

Octava, 29 bytes

@(n)accumarray((x=1:n)'+!x,1)

Pruébalo en línea!

Jalea , 8 bytes

×=¥þ’¡`Ṡ

Pruébalo en línea!

Ooh, parece que puedo superar al golf @Dennis en su propio idioma nuevamente :-)

Esta es una función de 1 argumento (porque el formato de salida predeterminado de Jelly para listas anidadas es un poco ambiguo, lo que significa que posiblemente no cumple con la especificación como un programa completo).

Explicación

×=¥þ’¡`Ṡ
     ¡    Repeatedly apply the following operation,
    ’     {input-1} times in total:
   þ        For each element of the current value {perhaps made into a range}
      `     and of {the range from 1 to the} {input}:
 =            Compare corresponding elements, giving 0 for equal or 1 for unequal
× ¥           then multiply by one of the elements
       Ṡ  then replace each element with its sign

Para entender esto, es útil mirar los pasos intermedios. Para una entrada de 3, obtenemos los siguientes pasos intermedios:

1. [1,2,3](entrada, hecha en un rango implícitamente por el þ)
2. [[1,0,0],[0,2,0],[0,0,3]](haga una tabla con [1,2,3], compare para obtener igualdad [[1,0,0],[0,1,0],[0,0,1]], luego multiplique por uno de los valores que comparamos)
3. [[[1,0,0],[0,0,0],[0,0,0]],[[0,0,0],[0,2,0],[0,0,0]],[[0,0,0],[0,0,0],[0,0,3]]] (la misma idea otra vez)
4. [[[1,0,0],[0,0,0],[0,0,0]],[[0,0,0],[0,1,0],[0,0,0]],[[0,0,0],[0,0,0],[0,0,1]]](reemplace cada elemento con su signo usando Ṡ)

Tenga en cuenta el hecho de que la entrada comienza en 1 dimensión significa que tenemos que hacer un bucle (input-1) veces para agregar dimensiones (input-1), produciendo una lista de entrada-dimensional.

Dato curioso: este programa contiene cinco quicks en una fila, ¥þ’¡`. (Un rápido es un modificador de un "enlace", o incorporado, utilizado para modificar su comportamiento o combinarlo con otro enlace).

Mathematica, 30 bytes

Array[Boole@*Equal,#~Table~#]&

APL (Dyalog) , 10 bytes

1=≢∘∪¨⍳⍴⍨⎕

Pruébalo en línea!

1= [es] 1 igual a

≢ el número

∘ de

∪ elementos unicos

¨ en cada

⍳ los índices en una matriz con las dimensiones de

⍴⍨ la auto-remodelación ( N copias de N ) de

⎕ la entrada ( N ) [?]

Jalea , 9 bytes

ðṗE€ṁ+þ’¡

Pruébalo en línea!

Cómo funciona

Lograr la tarea directamente parece ser difícil (no he encontrado una manera), pero construir matrices de los mismos números y matrices de la misma forma es bastante fácil.

ðhace que la cadena sea diádica, y la entrada entera n sirve como argumento izquierdo y derecho para la cadena. Es posible usar una cadena monádica en su lugar, pero las reglas de análisis para las diádicas ahorran tres bytes aquí (dos después de buscar ð).

El átomo de poder cartesianoṗ , con argumento izquierdo y derecho igual a n , construye la matriz de todos los vectores de longitud n que consisten en elementos de [1, ..., n] , ordenados lexicográficamente.

Cuando n = 3 , esto produce

[[1, 1, 1], [1, 1, 2], [1, 1, 3], [1, 2, 1], [1, 2, 2], [1, 2, 3], [1, 3, 1], [1, 3, 2], [1, 3, 3], [2, 1, 1], [2, 1, 2], [2, 1, 3], [2, 2, 1], [2, 2, 2], [2, 2, 3], [2, 3, 1], [2, 3, 2], [2, 3, 3], [3, 1, 1], [3, 1, 2], [3, 1, 3], [3, 2, 1], [3, 2, 2], [3, 2, 3], [3, 3, 1], [3, 3, 2], [3, 3, 3]]

La igualdad de cada enlace rápido E€prueba los elementos de todos los vectores construidos para la igualdad.

Cuando n = 3 , obtenemos

[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]

cuáles son los elementos de la matriz de identidad tridimensional, en una matriz plana.

El enlace rápido diádico +þ’¡se llama con argumento izquierdo y argumento derecho n . La ¡llamada rápida llama al átomo de decremento ’, que produce n-1 , luego llama a la tabla de adición enlace rápido +þ n-1 veces.

Inicialmente, los argumentos de +þson ambos n . Después de cada llamada, el argumento derecho se reemplaza por el izquierdo, y el izquierdo se reemplaza por el valor de retorno de la llamada.

La tabla llama rápidamente al átomo de adición+ para cada elemento de su argumento izquierdo y cada elemento de su argumento derecho, construyendo una tabla / matriz del valor de retorno. Los argumentos enteros iniciales n se promueven a los rangos [1, ... n] .

Cuando n = 3 , después de la promoción pero antes de la primera iteración, ambos argumentos son

[1, 2, 3]

Agregar cada número entero en esta matriz a cada número entero en esta matriz produce

[[2, 3, 4], [3, 4, 5], [4, 5, 6]]

En la próxima invocación, agregamos cada una de estas matrices a los enteros en [1, 2, 3] . La suma vectoriza (agregar un número entero a una matriz lo agrega a cada elemento), por lo que obtenemos

[[[3, 4, 5], [4, 5, 6], [5, 6, 7]],
 [[4, 5, 6], [5, 6, 7], [6, 7, 8]],
 [[5, 6, 7], [6, 7, 8], [7, 8, 9]]]

Esta matriz tiene la misma forma que la matriz de identidad tridimensional, pero no los elementos correctos.

Finalmente, el átomo del moldeṁ descarta las entradas enteras del resultado a la derecha y las reemplaza en orden con los elementos del resultado a la izquierda.

Python , 70 bytes

f=lambda n,l=[]:[f(n,l+[i])for i in(len(l)<n)*range(n)]or+(l==l[:1]*n)

Pruébalo en línea!

Una solución recursiva. Pensando en la matriz como una lista de matrices una dimensión más pequeña, itera sobre esa lista para ir hacia abajo en el árbol. Recuerda los índices recogidos l, y cuando los níndices se han elegido, asignamos un 1o 0dependiendo de si son todos iguales.

Python 2 , 73 bytes

n=input();r=0
exec'r=eval(`[r]*n`);'*n+('n-=1;r'+'[n]'*n+'=1;')*n
print r

Pruébalo en línea!

Una mejora en el método totalmente humano de hacer una matriz de ceros y luego asignar unos a la diagonal.

Python 2 , 88 bytes

n=input()
t=tuple(range(n))
print eval('['*n+'+(i0'+'==i%d'*n%t+')'+'for i%d in t]'*n%t)

Pruébalo en línea!

Algunas tonterías con eval, generar una lista anidada y sustitución de formato de cadena. La cadena a evaluar se ve así:

[[[+(i0==i0==i1==i2)for i0 in t]for i1 in t]for i2 in t]

Python 2 + NumPy , 80 72 70 bytes

Ahora empatado con la respuesta de Python superior!

from numpy import*
n=input()
a=zeros((n,)*n)
a[[range(n)]*n]=1
print a

Pruébalo en línea

_{Guardado 8 bytes gracias a Andras Deak y 2 por officialaimm}

Python 2 , 99 93 90 bytes

¡Gracias a Rod por un poco más de ayuda que lo hizo funcionar y también recortó 6 bytes! -3 bytes gracias a xnor.

n=input()
r=eval(`eval('['*n+'0'+']*n'*n)`)
for i in range(n):exec'r'+`[i]`*n+'=1'
print r

Pruébalo en línea!

JavaScript (ES6), 67 bytes

f=(n,d=n-1,i)=>[...Array(n)].map((_,j)=>d?f(n,d-1,j-i?n:j):j-i?0:1)

Explicación: ise utiliza para realizar un seguimiento de si la celda está en la diagonal principal o no. Inicialmente no está definido, por lo que en la primera llamada recursiva siempre pasamos la primera dimensión, mientras que en las llamadas recursivas posteriores solo la pasamos si el índice de dimensión actual es igual a todas las dimensiones anteriores, de lo contrario, pasamos un índice nque indica que todos las celdas recursivas deben ser cero.

Brainfuck , 61 bytes

>,[->+>+<<]>[-<<+>>]>-[->+.-<<<<[->+>+<<]>[-<+>]>[->>.<<]>]+.

Sin golf

Los números después de los corchetes angulares indican la celda sobre la que se ha terminado la cabeza.

>,                   read n to 1
[->+>+<<]            move 1 to 2 and 3
>2[-<<+>>]>3         move 2 to 0 
                     (tape: n 0 0 n 0)
-[                   while cell 3 {
    -                  dec 3
    >4+.-<3            print \x1
    <<<0[->+>+<<]      move 0 to 1 and 2
    >1[-<+>]>2         move 1 to 0
                       (tape: 0 0 n rows_left 0)
    [                  while cell 2 {
        -                dec 2
        >>4.<<           print \x0
    ]>3                }
]                    }
+.                   print \x1

Pruébalo en línea!

La entrada es un número binario. La salida es una matriz almacenada en orden de fila mayor.

R , 64 49 bytes

-15 bytes gracias a Jarko Dubbeldam

x=array(0,rep(n<-scan(),n));x[seq(1,n^n,l=n)]=1;x

Lee desde stdin y devuelve una matriz, imprimiendo como matrices. seqgenera una secuencia uniformemente espaciada de 1a n^ncon longitud l=n, lo que hace el truco bastante bien para indexar dónde van los 1s.

Pruébalo en línea!

versión antigua:

n=scan();x=rep(0,n^n);x=array(x,rep(n,n));x[matrix(1:n,n,n)]=1;x

Lee nde stdin; devuelve una matriz, imprimiendo los resultados como matrices. Luché con esto durante un tiempo hasta que leí los documentos [, que indican que una matriz se puede usar para indexar una matriz, donde cada fila de la matriz representa el conjunto de índices. ¡Ordenado!

Pruébalo en línea!

J , 16 15 bytes

i.@#~=i.*]#.#&1

Pruébalo en línea!

Python 3 + numpy, 81 77 bytes

from numpy import*
f=lambda n:all([a==range(n)for a in indices((n,)*n)],0)+0

No estoy completamente seguro de que lo anterior se ajuste a todas las pautas: devuelve un ndarray con las propiedades dadas. Sé que las funciones anónimas generalmente están bien, pero en realidad se imprimirá un shell interactivo

>>> f(2)
array([[1, 0],
       [0, 1]])

Si el flujo de matriz hace que lo anterior no sea válido, tengo que print()agregar un para algo así como 7 bytes adicionales.

Pruébalo en línea!

Pyth, 14 bytes

ucGQtQms!t{d^U

Banco de pruebas

Explicación:, ^Uque es implícitamente ^UQQ, dónde Qestá la entrada, calcula todas las posibles listas de elementos Q del rango 0 ... n-1.ms!t{dasigna los que tienen todos los elementos iguales a 1 y el resto a 0. Esto da la salida aplanada

ucGQtQ ejecuta lo siguiente, Q - 1 veces: corta la entrada en listas de tamaño Q.

C # (.NET Core) , 166 bytes

n=>{var c=new int[n];int i=0,d;for(;i<n;c[i++]=n);var m=System.Array.CreateInstance(typeof(int),c);for(i=0;i<n;i++){for(d=0;d<n;c[d++]=i);m.SetValue(1,c);};return m;}

Pruébalo en línea!

Al principio pensé que no se podía hacer con una expresión lambda en C # ... ^ __ ^ U

Lisp común, 147133 bytes

(defun i(n)(flet((m(x)(fill(make-list n)x)))(let((a(make-array(m n):initial-element 0)))(dotimes(i n)(incf(apply #'aref a(m i))))a)))

Pruébalo en línea!

El habitual ceceo súper largo. Reducido 12 bytes gracias a @ceilingcat!

Explicación:

(defun i (n)
  (flet ((m (x) (fill (make-list n) x)))            ; function to build a list of n values x
    (let ((a (make-array (m n) :initial-element 0))); build the array with all 0
      (dotimes (i n)                                ; for i from 0 to n-1
        (incf (apply #'aref a (m i))))              ; add 1 to a[i]..[i] 
      a)))                                          ; return the array

SOGL V0.12 , 22 bytes

.^κ.H/ 0* 1.H≤Οčr.H{.n

Pruébalo aquí!
Deja la salida en la pila , visible en la consola. Si se permitiera que los números en la salida fueran cadenas, entonces rpodrían eliminarse.
Solo como una prueba divertida de cómo SOGL hace frente a los desafíos, no estaba hecho para: p

input: x
.^                      push  x^x
  κ                     subtract x    (x^x)-x
   .H/                  divide by x   ((x^x) - x)/x
       0*               get that many zeroes
          1             push "1"
           .H           push x-1
             ≤          pull the first item from the stack to the top
              Ο         encase (x-1 times the zeroes, separated, started and ended with 1s)
               č        chop to a char-array
                r       convert each character to a number
                 .H{    repeat x-1 times:
                    .n    in the top array, for each group of x contents, encase that in an array

Clojure, 92 bytes

#(reduce(fn[v i](assoc-in v(repeat % i)1))(nth(iterate(fn[v](vec(repeat % v)))0)%)(range %))

Es bueno que assoc-in funcione también con vectores, no solo con hash-maps.