N-dimensional N ^ N matriz llena de N

62

En:  Suficiente memoria y un entero positivo N

Fuera:  N-N N ^ N matriz llena de N, donde N ^ N significa N términos de N-por-N-por-N-por ...

Ejemplos:

1: [1]que es una matriz 1D (una lista) de longitud 1, que contiene un solo 1

2: [[2,2],[2,2]]que es una matriz 2D (una tabla) con 2 filas y 2 columnas, llenas de 2

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]]]que es una matriz 3D (un cubo) con 3 capas, 3 filas y 3 columnas, llenas de 3

4: [[[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]]],[[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]]],[[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]]],[[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]],[[4,4,4,4],[4,4,4,4],[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 y 6: Vea una de las respuestas.

Adán
fuente
Si nuestro idioma no admite matrices, ¿cuál sería un formato de salida aceptable?
Okx
17
Dado que "Memoria suficiente" es parte de la entrada, quiero ver una respuesta que controle a un robot para tomar la memoria como entrada y enchufarla antes de usarla.
user2357112
1
¿Todas las matrices deben ser objetos distintos?
Neil
1
@ user2357112 Creo que es más un problema de tipo de condición previa. Dudo que el operador realmente espere que la función acepte la memoria como entrada.
The Great Duck
2
@TheGreatDuck Correcto, pero estoy bastante seguro de que user2357112 lo dijo en broma.
Adám

Respuestas:

50

Python , 32 bytes

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

Pruébalo en línea!

Hace una cadena como "[[[n]*n]*n]*n"con nmultiplcaciones, y la evalúa como código Python. Como la evaluación se realiza dentro del alcance de la función, el nombre de la variable se nevalúa como entrada de la función.

xnor
fuente
3
el truco del alcance es genial
Griffin
+1, ese truco eval realmente juega muchos bytes
MilkyWay90
31

J, 4 bytes

$~#~

Pruébalo en línea!

Explicación

$~#~  Input: integer n
  #~  Create n copies of n
$~    Shape n into an array with dimensions n copies of n
millas
fuente
66
Cuando vi el título del desafío, pensé en J inmediatamente. Es genial que J incluso le gane a Jelly (el lenguaje de golf inspirado en J).
Dane
1
También $~$~hay un equivalente que también se repite
millas
2
$~$~traducido al inglés ... DINERO, obtener más, DINERO, obtener más de ...
Magic Octopus Urn
12

Mathematica, 22 20 bytes

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

(* or *)

Table@@Table[#,#+1]&
JungHwan Min
fuente
9

R, 26

Esta es la respuesta obvia, pero ¿quizás hay algo más inteligente?

n=scan();array(n,rep(n,n))
Flounderer
fuente
es scan()necesario?
Adám
Mirando las otras respuestas, ¿parece que tiene que ser una función o aceptar información de alguna manera?
Flounderer
1
Bien, no sé R en absoluto. Solo pensé que podría especificar una función de alguna manera.
Adám
Sí, puede reemplazar n=scan();por function(n)pero lo hace más largo.
Flounderer
55
Puede guardar un byte poniendo la nasignación interna de array: array(n<-scan(),rep(n,n)).
rturnbull
8

JavaScript (ES6),  44  40 bytes

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

Manifestación

Arnauld
fuente
8

Haskell , 52 bytes

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

Pruébalo en línea!

Inspirado por la respuesta de @ nimi , pero usando más funciones predefinidas.

  • Utiliza iteratey en !!lugar de una función de ayuda recursiva.
  • En lugar de construir delimitadores de lista "a mano", se utiliza filter(>'"').showpara formatear una lista de cadenas y luego se eliminan los "caracteres adicionales .
Ørjan Johansen
fuente
8

05AB1E (heredado) , 6 5 bytes

-1 gracias a Kevin Cruijssen

F¹.D)

Pruébalo en línea!

F     # For 0 .. input
 ¹.D) # Push <input> copies of the result of the last step as an array
Riley
fuente
El inicio Dpuede eliminarse porque la entrada se usa implícitamente de nuevo (no estoy seguro si esto fue algo cuando publicaste la respuesta, pero ya no necesitas el explícito D).
Kevin Cruijssen
1
@KevinCruijssen Creo que esta es una de las respuestas que nos dio la idea de tomar entradas implícitas varias veces :)
Riley
Ah ok De hecho, esperaba que aún no fuera implícita al momento de la publicación, pero me di cuenta de eso después de publicar mi comentario (que edité). ;) A veces es divertido la cantidad de cosas explícitas que se hacen con la respuesta anterior (generalmente antes de 2017), y cuánto más corto se puede hacer ahora.
Kevin Cruijssen
7

Octava, 35 33 25 23 20 bytes

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

Pruébalo en línea!

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

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

Gracias a @LuisMendo ahorró 8 bytes

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

Pruébalo en línea!

Respuesta anterior:

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

Pruébalo en línea!

rahnema1
fuente
@LuisMendo Rats, solo iba a publicar esa;)
vaso
@beaker Whoops :-)
Luis Mendo
7

Haskell, 62 bytes

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

Ejemplo de uso: f 2-> "[[2,2],[2,2]]". Pruébalo en línea! .

El sistema de tipo estricto de Haskell impide una función que devuelve listas anidadas de diferentes profundidades, por lo que construyo el resultado como una cadena.

Cómo funciona:

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         
nimi
fuente
Podemos hacer la misma idea más corto con más funciones incorporadas: f n=iterate(filter(>'#').show.(<$[1..n]))(show n)!!n.
Ørjan Johansen
@ ØrjanJohansen: esa es una gran idea. Por favor publíquelo como una respuesta separada.
nimi
¿Podrías afeitarte un byte (#0)=show? No muy familiarizado con Haskell
Cyoce
@Cyoce: No, eso es un error de sintaxis. Para una sintaxis correcta, podría voltear los argumentos y usarlos (#)0=show, pero todas las definiciones de una función deben tener el mismo número de argumentos. La segunda línea ( n#l='['...) necesita dos argumentos, por lo que la primera línea también debe tener dos argumentos.
nimi
6

MATL, 8 bytes

ttY"l$l*

Pruébelo en MATL Online (he agregado un código que muestra el tamaño real de la salida ya que todas las salidas n-dimensionales en MATL se muestran como matrices 2D donde todas las dimensiones> 2 se aplanan en la segunda dimensión).

Explicación

        % 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  
Suever
fuente
Realmente no puedo decir desde MATL Online si su envío hace lo correcto. Parece que cada respuesta es una matriz amplia.
Adám
44
@ Adám Las dimensiones más allá del segundo se muestran como contraídas en el segundo. Entonces, el ejemplo muestra una matriz 3x9 en lugar de la matriz 3x3x3 producida. Si agrega Zyal final del código, indica el tamaño real
Luis Mendo
6

Python 2 , 36 bytes

-2 bytes gracias a @CalculatorFeline

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

Pruébalo en línea!

Trelzevir
fuente
~-n== (n-1).
CalculatorFeline
¿Sería posible incluir un enlace TIO ?
Adám
1
De hecho, esto! (-8 bytes debido al algoritmo optimizado, +9 bytes para agregar salida)
CalculatorFeline
@CalculatorFeline Puede poner cosas en Encabezado y Pie de página para evitar su inclusión en el recuento de bytes.
Adám
1
¿No se requieren entradas y salidas en los envíos completos del programa?
CalculatorFeline
5

CJam , 12 bytes

ri:X{aX*}X*p

Pruébalo en línea!

Explicación

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
Gato de negocios
fuente
5

Jalea , 5 bytes

⁾Wẋẋv

Pruébalo en línea!

¿Cómo?

⁾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]]]
Jonathan Allan
fuente
Segunda respuesta Jelly de 5 bytes. Todavía inaceptablemente largo en comparación con J :-)
Adám
2
... y no por falta de intentar: D
Jonathan Allan
5

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

Sin golf:

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

}
anacron
fuente
1
puedes reemplazar i<=1con i<2?
Cliffroot
Sí @cliffrott. Eso funciono. ¡¡Gracias!!
anacron
1
Puede guardar algunos bytes con una lambda:(n,i)->{...}
Java 8 lambdas ftw
1
Hmm, parece que esto requiere una entrada extra. Tendrá que hacer un método separado de un solo parámetro para que esto sea válido.
Jakob
5

JavaScript (ES6), 38 bytes

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

La versión de esto que necesita mucha memoria es de 45 bytes:

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

Bash + utilidades GNU, 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] \ []

Pruébalo en línea!


El programa esencialmente cuenta de 0 a (n ^ n) -1 en la base n, donde n es la entrada. Para cada número base-n k en el recuento, hace lo siguiente:

  1. Si k termina con al menos un dígito 0, imprima un '[' para cada dígito 0 al final de k.
  2. Imprimir n.
  3. Si k termina con al menos un dígito n-1, imprima un ']' para cada dígito n-1 al final de k.

(El valor n = 1 necesita tener corchetes agregados como un caso especial. Este valor de entrada también genera algo de salida para stderr, que puede ignorarse bajo las reglas estándar de PPCG).

Quizás haya una forma más corta de implementar esta idea.


Ejecución de muestra:

./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]]]
Mitchell Spector
fuente
5

Jalea , 4 bytes

R»µ¡

Pruébalo en línea!

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

Lo mismo pero con una sola mónada y sin necesidad del separador de cadena:

4 bytes

»€`¡
dylnan
fuente
4

Python 3 , 57 53 50 38 bytes

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

Pruébalo en línea!


-4 bytes gracias a @CalculatorFeline


34 bytes:

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

Necesita ser llamado como f(4,4)

ovs
fuente
¿Por qué se invierten sus líneas de código en comparación con su enlace TIO?
Adám
Puede reemplazar c>1con c para guardar 1 byte. (Markdown, deje de deduplicar espacios en `s)
CalculatorFeline
@CalculatorFeline No creo que pueda; eso sería c>0en este caso particular.
Erik the Outgolfer
Luego cambia el final a <space>n. Problema resuelto y bonificación: ¡más bytes guardados! : D (¿Entonces los espacios al final del código en línea son posibles, pero no el comienzo? Eso es extraño ...) Enlace TIO
CalculatorFeline
@ Adám: en TIO para permitir que la función principal se asigne en el encabezado y aquí para mantener la función principal en la última línea.
CalculatorFeline
4

Rubí, 28 26 bytes

¡Gracias a Cyoce por guardar 2 bytes!

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

Robado descaradamente de la excelente respuesta de xnor .

adrianmp
fuente
1
¿Necesitas esos parens?
Cyoce
4

Rubí, 27 bytes

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

Solo 1 byte más pero usando un enfoque diferente en lugar del truco 'eval' de la maravillosa respuesta de Python de xnor.

GB
fuente
3

Perl 6 , 25 bytes

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

Comienza con n, y aplica iterativamente los tiempos de transformación "repetir n veces" n, creando cada vez un nivel adicional de Listanidamiento.

Pruébalo en línea!

smls
fuente
Utilice en su $_lugar para guardar un byte
Jo King
@JoKing: ya lo uso $_como parámetro del bloque interno, por lo que no puedo usarlo también como parámetro del bloque externo.
sonríe el
Sí, pero $ny $_siempre tienen el mismo valor. Pruébalo en línea!
Jo King
3

PHP, 70 62 bytes

Esto es lo más simple que se me ocurre.

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

Toma la entrada como primer argumento e imprime la matriz resultante en la pantalla.


¡Gracias a @ user59178 por salvarme 8 bytes !

Ismael Miguel
fuente
Preasignar variables como esa es innecesario, como es $l. Descartar $i=0,y reemplazar $lcon $n ahorra 7 bytes. Un byte adicional puede ser salvado por no asignar $F, la asignación $nde la condicional y el uso de un ternario $F?:$nen elarray_fill()
user59178
@ user59178 No sé si esto es lo que tenía en mente o no, pero gracias por los consejos. ¡Me has guardado 8 bytes!
Ismael Miguel
3

Clojure, 36 bytes

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

Itera la función que repite sus ntiempos de argumento , produce una secuencia infinita de tales elementos y luego toma su nelemento th.

Véalo en línea

acantilado
fuente
3

Rebol, 45 bytes

func[n][array/initial append/dup copy[]n n n]
draegtun
fuente
3

Lote, 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 en realidad no tiene matrices, por lo que solo imprime la representación de cadena de una matriz. Explicación: Las dos primeras líneas crean un patrón repetido de N .s separado por N-1 ,s en la variable t. La cuarta línea luego usa esto como un patrón de sustitución Nveces para crear la Nmatriz dimensional. El doble calles necesario debido a cómo funcionan las declaraciones fory set. Primero, el forcomando sustituye variables. Como sucede, todos mis %signos se duplican, por lo que esto no hace nada más que ponerlos entre comillas, lo que resulta en call call set s=[%%t:.=%s%%%]. Luego repite los Ntiempos de declaración resultantes . Cada vez, el callcomando sustituye variables. En este punto, la svariable solo tiene un único conjunto de%s, por lo que se sustituye, lo que resulta en (por ejemplo) call set s=[%t:.=[2,2]%]. La llamada interna luego sustituye la tvariable, lo que resulta en (por ejemplo) set s=[[2,2],[2,2]], realizar la asignación deseada. sLuego se imprime el valor final de .

Neil
fuente
+1 Wow, no hubiera esperado eso. ¡Todos saludan el humilde archivo .bat!
Adám
3

Clojure, 49 bytes

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

No es el ejemplo más corto de Clojure, pero me divertí con las citas y las citas.

MattPutnam
fuente
3

I , 7 bytes

Obtuve esto de mi colega, el creador de I.

#Bbhph~

#Bb     la copia #función B ound a ab ncontrar
   hp  h ook el argumento para (la derecha) de la p función ower (repetición)
     h~h ook el argumento a la izquierda ~(de la totalidad de la función resultante)

Pruébalo en línea!

Adán
fuente
3

Lisp común, 128102 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)))))

Pruébalo en línea!

techo
fuente