Matriz N-dimensional N ^ N preenchida com N


62

In:  Memória suficiente e um número inteiro positivo N

Fora:  N-dimensional N ^ N matriz preenchida com N, onde N ^ N significa N termos de N-por-N-por-N-por ...

Exemplos:

1: [1]que é uma matriz 1D (uma lista) de comprimento 1, contendo um único 1

2: [[2,2],[2,2]]que é uma matriz 2D (uma tabela) com 2 linhas e 2 colunas, preenchida com 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]]]que é uma matriz 3D (um cubo) com 3 camadas, 3 linhas e 3 colunas, preenchidas com 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 e 6: Veja uma das respostas.


Se nosso idioma não suportar matrizes, qual seria um formato de saída aceitável?
Okx 28/02

17
Como "Memória suficiente" faz parte da entrada, desejo ver uma resposta que controle um robô para realmente pegar a memória como entrada e conectá-la antes de usá-la.
user2357112

11
Todas as matrizes precisam ser objetos distintos?
Neil

11
@ user2357112 Acho que isso é mais um problema do tipo pré-condição. Duvido que o op realmente espere que a função aceite a memória como entrada.
The Great Duck

2
@TheGreatDuck Correto, mas tenho certeza que user2357112 foi uma piada.
Adám 01/03/19

Respostas:


50

Python , 32 bytes

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

Experimente online!

Cria uma string como "[[[n]*n]*n]*n"com nmultiplicações e avalia como código Python. Como a avaliação ocorre no escopo da função, o nome da variável é navaliado na entrada da função.


3
o truque escopo é gênio
Griffin

+1, esse truque de avaliação realmente reduz muitos bytes
MilkyWay90

31

J, 4 bytes

$~#~

Experimente online!

Explicação

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

6
Quando vi o título do desafio, pensei em J imediatamente. Muito legal que J até derrote Jelly (a linguagem do golfe inspirada em J).
Dane

11
Há também o $~$~que é equivalente ao mesmo tempo que se repete
milhas

2
$~$~traduzidas para Inglês ... DINHEIRO, obter mais de, dinheiro, obter mais de ...
Magia Octopus Urna


12

Mathematica, 22 20 bytes

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

(* or *)

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

9

R, 26

Esta é a resposta óbvia, mas talvez haja algo mais inteligente?

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

é scan()necessário?
Adám 28/02

Olhando para as outras respostas, parece que isso tem que ser uma função ou aceitar entrada de alguma forma?
Flounderer

11
Certo, eu não conheço R. Eu apenas pensei que você poderia especificar uma função de alguma forma.
Adám 28/02

Sim, você pode substituir n=scan();por, function(n)mas o torna mais longo.
Solha

5
Você pode salvar um byte, colocando a natribuição dentro de array: array(n<-scan(),rep(n,n)).
R17 # r17:

8

JavaScript (ES6),  44  40 bytes

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

Demo


8

Haskell , 52 bytes

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

Experimente online!

Inspirado na resposta de @ nimi , mas usando funções mais predefinidas.

  • Usa iteratee, em !!vez de uma função de ajuda recursiva.
  • Em vez de construir delimitadores de lista "à mão", usa filter(>'"').showpara formatar uma lista de seqüências de caracteres e, em seguida, retira os "caracteres extras .

8

05AB1E (herdado) , 6 5 bytes

-1 graças a Kevin Cruijssen

F¹.D)

Experimente online!

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

O líder Dpode ser removido porque a entrada é usada implicitamente novamente (não tenho certeza se isso foi algo quando você postou a resposta, mas você não precisa mais do explícito Dagora).
Kevin Cruijssen em 21/02

11
@KevinCruijssen Acho que essa é uma das respostas que nos deu a ideia de receber sugestões implicitamente várias vezes :)
Riley

Ah ok. Eu realmente esperava que ainda não estivesse implicitamente no momento da postagem, mas percebi isso depois de postar meu comentário (que editei). ;) Às vezes, é engraçado o quanto as coisas explícitas estão sendo feitas pela resposta antiga (geralmente antes de 2017) e quanto mais curto isso pode ser feito agora.
Kevin Cruijssen em 21/02


7

Haskell, 62 bytes

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

Exemplo de uso: f 2-> "[[2,2],[2,2]]". Experimente online! .

O sistema de tipo estrito de Haskell evita uma função que retorna listas aninhadas de diferentes profundidades; portanto, construo o resultado como uma string.

Como 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         

Nós podemos fazer a mesma idéia mais curto com mais funções embutidas: f n=iterate(filter(>'#').show.(<$[1..n]))(show n)!!n.
Ørjan Johansen

@ ØrjanJohansen: é uma ótima idéia. Poste-o como uma resposta separada.
nimi

Você poderia barbear um byte (#0)=show? Não
estou

@ Cyy: Não, isso é um erro de sintaxe. Para uma sintaxe correta, eu poderia inverter os argumentos e usá-los (#)0=show, mas todas as definições de uma função devem ter o mesmo número de argumentos. A segunda linha ( n#l='['...) precisa de dois argumentos; portanto, a primeira linha também deve ter dois argumentos.
nimi

6

MATL, 8 bytes

ttY"l$l*

Experimente no MATL Online (adicionei algum código que mostra o tamanho real da saída, pois todas as saídas n-dimensionais no MATL são mostradas como matrizes 2D, onde todas as dimensões> 2 são achatadas na segunda dimensão).

Explicação

        % 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  

Eu realmente não posso dizer pelo MATL Online se o seu envio faz a coisa certa. parece que toda resposta é uma matriz ampla.
Adám 28/02

4
@ Adám As dimensões além do segundo são exibidas como recolhidas no segundo. Portanto, o exemplo mostra uma matriz 3x9 em vez da matriz 3x3x3 produzida. Se você adicionar Zyno final do código, ele informará o tamanho real.
Luis Mendo

6

Python 2 , 36 bytes

-2 bytes graças a @CalculatorFeline

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

Experimente online!


~-n== (n-1).
CalculatorFeline

Seria possível incluir um link TIO ?
Adám 28/02

11
De fato, isso! (-8 bytes devido ao algoritmo otimizado, +9 bytes para adicionar saída)
CalculatorFeline

@CalculatorFeline Você pode colocar itens no Cabeçalho e Rodapé para evitar a inclusão na contagem de bytes.
Adám 28/02

11
Não são necessárias entradas e saídas nos envios completos do programa?
CalculatorFeline

5

CJam , 12 bytes

ri:X{aX*}X*p

Experimente online!

Explicação

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

5

Gelatina , 5 bytes

⁾Wẋẋv

Experimente online!

Quão?

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

Segunda resposta de geléia de 5 bytes. Ainda inaceitavelmente longo quando comparado com J :-)
Adám

2
... e não por falta de tentativa: 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;}

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

}

11
você pode substituir i<=1com i<2?
Cliffroot

Sim @cliffrott. Isso funcionou. obrigado!!
Anacron # 1/17

11
Você pode salvar alguns bytes com um lambda:(n,i)->{...}

Java 8 lambdas ftw

11
Hmm, parece que isso requer uma entrada extra. Você precisará criar um método separado de apenas um parâmetro para que seja válido.
Jakob

5

JavaScript (ES6), 38 bytes

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

A versão que requer muita memória é de 45 bytes:

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

5

Utilitários Bash + 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] \ []

Experimente online!


O programa conta essencialmente de 0 a (n ^ n) -1 na base n, onde n é a entrada. Para cada número de base n na contagem, ele faz o seguinte:

  1. Se k terminar com pelo menos um dígito 0, imprima um '[' para cada dígito 0 no final de k.
  2. Imprimir n.
  3. Se k terminar com pelo menos um dígito n-1, imprima um ']' para cada dígito n-1 no final de k.

(O valor n = 1 precisa ter colchetes adicionados como um caso especial. Esse valor de entrada também gera alguma saída para o stderr, que pode ser ignorada pelas regras padrão do PPCG.)

Talvez haja uma maneira mais curta de implementar essa ideia.


Exemplo de execução:

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

5

Gelatina , 4 bytes

R»µ¡

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

A mesma coisa, mas com uma única mônada e sem a necessidade do separador de correntes:

4 bytes

»€`¡


4

Python 3 , 57 53 50 38 bytes

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

Experimente online!


-4 bytes graças a @CalculatorFeline


34 bytes:

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

Precisa ser chamado como f(4,4)


Por que suas linhas de código são revertidas em comparação ao seu link TIO?
Adám 28/02

Você pode substituir c>1por c para salvar 1 byte. (Markdown, pare de desduplicar espaços em `s)
CalculatorFeline

@CalculatorFeline Não acho que ele possa; isso seria c>0neste caso particular.
Erik the Outgolfer

Então mude o fim para <space>n. Problema resolvido e bônus - mais bytes salvos! : D (Portanto, os espaços no final do código embutido são possíveis, mas não o começo? Isso é estranho ...) Link TIO
CalculatorFeline

@ Adám: No TIO para permitir que a função principal seja atribuída no cabeçalho e aqui para manter a função principal na última linha.
CalculatorFeline


4

Ruby, 27 bytes

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

Apenas 1 byte a mais, mas usando uma abordagem diferente em vez do truque 'eval' da maravilhosa resposta Python do xnor.


3

Perl 6 , 25 bytes

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

Inicia ne aplica iterativamente os tempos de transformação "repetir n vezes" n, sempre criando um nível adicional de Listaninhamento.

Experimente online!


Em $_vez disso, use para salvar um byte
Jo King

@ JoKing: Eu já uso $_como o parâmetro do bloco interno, então não posso usá-lo como o parâmetro do bloco externo também.
SMLS

Sim, mas $ne $_sempre tem o mesmo valor. Experimente online!
Jo rei

3

PHP, 70 62 bytes

Este é o mais simples que eu posso apresentar.

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

Pega a entrada como o primeiro argumento e imprime a matriz resultante na tela.


Obrigado a @ user59178 por me salvar 8 bytes !


Pré-atribuir variáveis ​​como essa é desnecessário, como é $l. Descartar $i=0,e substituir $lpor $n salva 7 bytes. Um byte adicional pode ser salvo por não atribuir $F, atribuindo $nno condicional e usando um ternário $F?:$nnaarray_fill()
user59178

@ user59178 Não sei se é isso que você tinha em mente ou não, mas obrigado pelas dicas. Você me salvou 8 bytes!
Ismael Miguel

3

Clojure, 36 bytes

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

Repete a função que repete seus ntempos de argumento , produz uma sequência infinita de tais elementos e, em seguida, pega seu nth elemento.

Veja on-line


3

Rebol, 45 bytes

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

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%

O lote não possui matrizes, portanto, isso apenas imprime a representação de sequência de uma matriz. Explicação: As duas primeiras linhas constroem um padrão repetido de N .s separado por N-1 ,s na variável t. A quarta linha usa isso como um padrão de substituição Nvezes para criar a Nmatriz -dimensional. O duplo callé necessário por causa de como as instruções fore setfuncionam. Primeiro, o forcomando substitui variáveis. Por acaso, todos os meus %sinais são duplicados, então isso não faz nada, exceto para citar todos eles, resultando em call call set s=[%%t:.=%s%%%]. Em seguida, repete os Ntempos de instrução resultantes . Cada vez, o callcomando substitui variáveis. Nesse ponto, a svariável possui apenas um único conjunto de%s, para que seja substituído, resultando em (por exemplo) call set s=[%t:.=[2,2]%]. A chamada interna substitui a tvariável, resultando em (por exemplo) set s=[[2,2],[2,2]], executando a atribuição desejada. O valor final de sé então impresso.


+1 Uau, eu não esperava isso. Todos saudam o humilde arquivo .bat!
Adám 01/03/19

3

Clojure, 49 bytes

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

Não é o exemplo mais curto de Clojure, mas me diverti com as citações e as citações.


3

I , 7 bytes

Eu recebi isso do meu colega, o criador de I.

#Bbhph~

#Bb     a cópia #função B ound para b inding
   hp  h ook o argumento de (a direita) da p função ower (repetição)
     h~h ook o argumento para a esquerda ~(de toda a função resultante)

Experimente online!


3

Lisp comum, 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)))))

Experimente online!

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.