Dado um número inteiro positivo n
, N
imprima a "matriz" de identidade dimensional, que é a N^N
matriz com a 1
qual todos os componentes dos índices são iguais ou 0
não. N^N
significa 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 exemplo, se a
é o 4
dimensional identidade "matriz", em seguida, as únicas entradas com 1
seria a[0][0][0][0]
, a[1][1][1][1]
, a[2][2][2][2]
, e a[3][3][3][3]
.
Isso é código-golfe . A resposta mais curta em bytes vence. Aplicam-se brechas padrão .
code-golf
math
array-manipulation
integer
generation
Freira Furada
fonte
fonte
Respostas:
Oitava, 29 bytes
Experimente online!
fonte
Geléia , 8 bytes
Experimente online!
Ooh, parece que eu consigo superar @Dennis no seu próprio idioma novamente :-)
Esta é uma função de um argumento (porque o formato de saída padrão do Jelly para listas aninhadas é um pouco ambíguo, o que significa que provavelmente não atende às especificações como um programa completo).
Explicação
Para entender isso, é útil examinar as etapas intermediárias. Para uma entrada 3, obtemos as seguintes etapas intermediárias:
[1,2,3]
(entrada, transformada em um intervalo implicitamente peloþ
)[[1,0,0],[0,2,0],[0,0,3]]
(faça uma tabela com[1,2,3]
, compare para obter igualdade[[1,0,0],[0,1,0],[0,0,1]]
e depois multiplique por um dos valores que comparamos)[[[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]]]
(a mesma ideia novamente)[[[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]]]
(substitua cada elemento pelo seu sinal usandoṠ
)Observe o fato de que a entrada começa unidimensional significa que temos que fazer um loop (entrada-1) vezes para adicionar dimensões (entrada-1), produzindo uma lista dimensional de entrada.
Curiosidade: este programa contém cinco rápidas seguidas
¥þ’¡`
,. (Um rápido é um modificador para um "link", ou interno, usado para modificar seu comportamento ou combiná-lo com outro link.)fonte
Mathematica, 30 bytes
fonte
Table
é uma adição recente. Mathics ainda precisa de uma lista Singleton lá: tio.run/##y00sychMLv7/P83WsagosTLaKT8/...Array[Boole@*Equal,#~Table~{#}]&
para trabalhar em Matemática. Versões mais antigas do Mathematica não suportam um número inteiro como segundo argumentoTable
, e acho que o Mathics se baseia nisso.APL (Dyalog) , 10 bytes
Experimente online!
1=
[é] 1 igual a≢
o número∘
do∪
elementos únicos¨
em cada um⍳
os índices em uma matriz com as dimensões de⍴⍨
a auto-remodelação ( N cópias de N ) de⎕
a entrada ( N ) [?]fonte
Geléia , 9 bytes
Experimente online!
Como funciona
Realizar a tarefa diretamente parece difícil (não encontrei uma maneira), mas construir matrizes com os mesmos números e matrizes da mesma forma é bastante fácil.
ð
torna a cadeia diádica e a entrada inteira n serve como argumento esquerdo e direito para a cadeia. É possível usar uma cadeia monádica, mas as regras de análise para díades economizam três bytes aqui (dois após a pesquisað
).O átomo de potência cartesiano
ṗ
, com o argumento esquerdo e direito igual a n , constrói a matriz de todos os vetores de comprimento n que consistem em elementos de [1, ..., n] , classificados lexicograficamente.Quando n = 3 , isso gera
O igual a cada link rápido
E€
testa os elementos de todos os vetores construídos quanto à igualdade.Quando n = 3 , obtemos
que são os elementos da matriz de identidade tridimensional, em uma matriz plana.
O link rápido diádico
+þ’¡
é chamado com argumento à esquerda e argumento à direita n . A¡
chamada rápida do átomo de decremento’
, que gera n-1 , chama o link rápido da tabela de adição+þ
n-1 vezes.Inicialmente, os argumentos de
+þ
são ambos n . Após cada chamada, o argumento da direita é substituído pelo da esquerda e o da esquerda é substituído pelo valor de retorno da chamada.A tabela chama rapidamente o átomo de adição
+
para cada elemento de seu argumento esquerdo e cada elemento de seu argumento direito, construindo uma tabela / matriz do valor de retorno. Os argumentos inteiros iniciais n são promovidos para os intervalos [1, ... n] .Quando n = 3 , após a promoção, mas antes da primeira iteração, os dois argumentos são
Adicionar cada número inteiro nessa matriz a cada número inteiro nessa matriz gera
Na próxima invocação, adicionamos cada uma dessas matrizes aos números inteiros em [1, 2, 3] . A adição vetoriza (adicionar um número inteiro a uma matriz adiciona-o a cada elemento), então obtemos
Essa matriz tem o mesmo formato da matriz de identidade tridimensional, mas não os elementos corretos.
Por fim, o átomo do molde
ṁ
descarta as entradas inteiras do resultado para a direita e as substitui em ordem pelos elementos do resultado à esquerda.fonte
Python , 70 bytes
Experimente online!
Uma solução recursiva. Pensando na matriz como uma lista de matrizes de uma dimensão menor, ele itera sobre essa lista para descer pela árvore. Ele lembra os índices escolhidos
l
e, quando osn
índices são escolhidos, atribuímos um1
ou,0
dependendo se eles são iguais.Python 2 , 73 bytes
Experimente online!
Uma melhoria no método totalmente humano de criar uma matriz de zeros e depois atribuí- los à diagonal.
Python 2 , 88 bytes
Experimente online!
Algumas bobagens com
eval
, gerando uma lista aninhada e substituição no formato de string. A sequência a ser avaliada se parece com:fonte
Python 2 + NumPy ,
807270 bytesAgora empatado com a melhor resposta Python!
Experimente online
Economizou 8 bytes graças a Andras Deak e 2 por officialaimm
fonte
a[[range(n)]*n]=1
vez de seu exec.fill_diagonal(a,1)
para esta finalidade, mas isso é um byte mais)i
, que deve economizar 2 bytes.Python 2 ,
999390 bytesAgradeço ao Rod por
algumaajuda ainda maior que o fez funcionar e também eliminou 6 bytes! -3 bytes graças ao xnor.Experimente online!
fonte
def/return
nunca é melhor do queinput/print
(no melhor cenário é igual), você também pode soltar o()
em('[%d]'%i)
reduzir para 93 bytes'[%d]'%i
passa a ser o representante da string de[i]
.JavaScript (ES6), 67 bytes
Explicação:
i
é usado para controlar se a célula está na diagonal principal ou não. Inicialmente, é indefinido; portanto, na primeira chamada recursiva, sempre passamos a primeira dimensão, enquanto nas chamadas recursivas subsequentes a transmitimos apenas se o índice de dimensão atual for igual a todas as dimensões anteriores, caso contrário, passamos um índicen
que indica que todos as células recursivas devem ser zero.fonte
Brainfuck , 61 bytes
Ungolfed
Os números após os colchetes angulares indicam a célula em que a cabeça acabou.
Experimente online!
A entrada é um número binário. Saída é uma matriz armazenada na ordem principal da linha.
fonte
R ,
6449 bytes-15 bytes graças a Jarko Dubbeldam
Lê de stdin e retorna uma matriz, imprimindo como matrizes.
seq
gera uma sequência uniformemente espaçada de1
paran^n
com comprimentol=n
, que faz o truque bastante para indexar para onde os 1s vão.Experimente online!
versão antiga:
Lê
n
de stdin; retorna uma matriz, imprimindo os resultados como matrizes. Eu lutei com isso por um tempo até ler os documentos para[
, que indicam que uma matriz pode ser usada para indexar uma matriz, em que cada linha da matriz representa o conjunto de índices. Arrumado!Experimente online!
fonte
array(0, rep(n,n)
funciona, então você não precisa fazerrep
. Você também pode levarn
adiantearray(0, rep(n<-scan(),n))
.x[seq(1,n^n,l=n)]=1
é 1 byte mais curto.J ,
1615 bytesExperimente online!
fonte
Python 3 + numpy,
8177 bytesNão estou inteiramente certo de que os ajustes acima todas as diretrizes: ele retorna um ndarray com as propriedades dadas. Eu sei que funções anônimas geralmente são boas, mas um shell interativo realmente imprime
Se o cotão da matriz invalida o
print()
item acima, eu tenho que adicionar um para algo como 7 bytes adicionais.Experimente online!
fonte
Pitão, 14 bytes
Suíte de teste
Explicação:,
^U
que é implicitamente^UQQ
, ondeQ
está a entrada, calcula todas as listas possíveis de elementos Q do intervalo0 ... n-1
.ms!t{d
mapeia aqueles com todos os elementos iguais a 1 e o restante a 0. Isso fornece a saída achatadaucGQtQ
executa o seguinte, Q - 1 vezes: Pique a entrada em listas de tamanho Q.fonte
C # (.NET Core) , 166 bytes
Experimente online!
No começo eu pensei que não poderia ser feito com uma expressão lambda em C # ... ^ __ ^ U
fonte
Lisp comum,
147133 bytesExperimente online!
O cocô super longo e usual. 12 bytes reduzidos graças a @ceilingcat!
Explicação:
fonte
SOGL V0.12 , 22 bytes
Experimente aqui!
Deixa a saída na pilha , visível no console. Se fosse permitido que os números na saída fossem seqüências de caracteres, o valor
r
poderia ser removido.Assim como um teste divertido de como o SOGL se sai em desafios, ele não foi feito completamente para: p
fonte
Clojure, 92 bytes
É bom que assoc-in funcione também com vetores, não apenas com mapas de hash.
fonte