Eu escrevi alguns desafios relacionados a matrizes, e comum para todos é que eu uso um formato como o abaixo para representar as matrizes, tanto em exemplos quanto em casos de teste:
16 2 3 13
5 11 10 8
9 7 6 12
4 14 15 1
Este é provavelmente um formato complicado em muitos idiomas.
Desafio:
Escreva um programa / função que possa assumir uma matriz no formulário fornecido na parte superior como entrada (copie / cole diretamente desta postagem) e imprima a mesma matriz em todos os outros três formatos convencionais mostrados abaixo .
O formato de entrada:
Números separados por um número variável de espaços e novas linhas para representar linhas (consulte casos de teste).
- Não é garantido que o número de espaços entre os números seja consistente. No entanto, você pode supor que o último dígito em cada coluna esteja alinhado (se isso ajudar algum).
- Pode haver números inteiros e flutuantes, e eles podem ser positivos, negativos ou zero. Uma matriz não conterá números inteiros e flutuantes ao mesmo tempo.
- Você pode supor que nenhum número tenha mais de 10 caracteres, incluindo o ponto negativo e decimal para flutuações negativas.
- Você pode assumir que há o mesmo número de entradas em cada linha e em cada coluna.
- Não haverá matrizes de entrada vazias, mas pode haver números únicos ou matrizes com apenas uma linha ou coluna.
- Nesses casos, você pode escolher entre os formatos de saída mostrados nos casos de teste
Seu programa / função deve manipular a entrada se ela for copiada diretamente desta postagem e colada no intérprete (STDIN ou como argumento de função ou algo equivalente). Você pode ter o que quiser (colchetes, aspas, parênteses) na frente e / ou após a matriz, mas deve considerar a matriz como uma sequência de caracteres que não podem ser alterados (que inclui as novas linhas).
Para esclarecer: Suponha que sua função / programa seja chamado f
e a matriz seja:
1 -2
3 5
6 7
então você pode fornecer à matriz argumentos de função como este (e infinitamente muitas outras opções):
f(1 -2
3 5
6 7)
f([1 -2
3 5
6 7])
f("""1 -2
3 5
6 7""")
Se seu idioma não puder, de forma alguma, tomar a matriz de copiar / colar como entrada, receio que você precise escolher outro idioma.
O formato de saída:
Você deve produzir a matriz nos três formatos a seguir (ordem não importa):
[[16, 2, 3, 13], [5, 11, 10, 8], [9, 7, 6, 12], [4, 14, 15, 1]]
{{16, 2, 3, 13}, {5, 11, 10, 8}, {9, 7, 6, 12}, {4, 14, 15, 1}}
[16, 2, 3, 13; 5, 11, 10, 8; 9, 7, 6, 12; 4, 14, 15, 1]
- Você pode separar as três saídas da maneira que desejar (por exemplo, uma nova linha)
- Você deve imprimir os números usando a mesma precisão que a entrada (por exemplo, você não deve aparar o número de casas decimais, nem imprimir números inteiros como valores flutuantes).
- Os espaços são obrigatórios
- Você deve usar
-
para números negativos, não_
ou similares.
Casos de teste:
16 2 3 13
5 11 10 8
9 7 6 12
4 14 15 1
----
[[16, 2, 3, 13], [5, 11, 10, 8], [9, 7, 6, 12], [4, 14, 15, 1]]
{{16, 2, 3, 13}, {5, 11, 10, 8}, {9, 7, 6, 12}, {4, 14, 15, 1}}
[16, 2, 3, 13; 5, 11, 10, 8; 9, 7, 6, 12; 4, 14, 15, 1]
0.14778 0.27114 0.24415
0.45997 0.12287 0.67470
0.28945 0.37928 0.51887
----
[[0.14778, 0.27114, 0.24415], [0.45997, 0.12287, 0.6747], [0.28945, 0.37928, 0.51887]]
{{0.14778, 0.27114, 0.24415}, {0.45997, 0.12287, 0.6747}, {0.28945, 0.37928, 0.51887}}
[0.14778, 0.27114, 0.24415; 0.45997, 0.12287, 0.6747; 0.28945, 0.37928, 0.51887]
-0.0398301 0.2403455 -0.2253368 0.3565870 0.0605803 0.0830780
-0.3254422 -0.1185191 -0.2989537 0.1647319 0.3621135 0.2018815
-0.0022281 -0.3362287 -0.3568447 0.4419063 0.3801872 -0.2847033
---
[[-0.0398301, 0.2403455, -0.2253368, 0.3565870, 0.0605803, 0.0830780], [-0.3254422, -0.1185191, -0.2989537, 0.1647319, 0.3621135, 0.2018815], [-0.0022281, -0.3362287, -0.3568447, 0.4419063, 0.3801872, -0.2847033],]
{{-0.0398301, 0.2403455, -0.2253368, 0.3565870, 0.0605803, 0.0830780}, {-0.3254422, -0.1185191, -0.2989537, 0.1647319, 0.3621135, 0.2018815}, {-0.0022281, -0.3362287, -0.3568447, 0.4419063, 0.3801872, -0.2847033},}
[-0.0398301, 0.2403455, -0.2253368, 0.3565870, 0.0605803, 0.0830780; -0.3254422, -0.1185191, -0.2989537, 0.1647319, 0.3621135, 0.2018815; -0.0022281, -0.3362287, -0.3568447, 0.4419063, 0.3801872, -0.2847033]
0 4 1 0
0 0 -6 0
0 1 4 -3
2 0 0 8
0 0 0 0
----
[[0, 4, 1, 0], [0, 0, -6, 0], [0, 1, 4, -3], [2, 0, 0, 8], [0, 0, 0, 0]]
{{0, 4, 1, 0}, {0, 0, -6, 0}, {0, 1, 4, -3}, {2, 0, 0, 8}, {0, 0, 0, 0}}
[0, 4, 1, 0; 0, 0, -6, 0; 0, 1, 4, -3; 2, 0, 0, 8; 0, 0, 0, 0]
1
----
[1] (or [[1]])
{1} (or {{1}})
[1] (or 1)
1 2
----
[1, 2] (or [[1, 2]])
{1, 2} (or {{1, 2}})
[1, 2]
4
5
----
[[4], [5]]
{{4}, {5}}
[4; 5]
Estou plenamente ciente disso , mas neste desafio, o formato de E / S complicado é o ponto principal. O desafio será a formatação da saída em alguns idiomas, enquanto a leitura da entrada será a parte mais difícil em outros idiomas.
Por favor, não desanime se a leitura da entrada for difícil, pois essas submissões podem ser as mais interessantes. Curto não é necessariamente o mesmo que impressionante. E como sempre, explicações são incentivadas!
Japonês ,
6353 bytesIsso estava chegando a 44 bytes antes de eu perceber que o espaçamento na saída era obrigatório.
Teste-o
Explicação
fonte
Perl 5 , 71 bytes
69 bytes de código +
-p0
sinalizadores.Experimente online!
Explicações
s/^ *(.+)/[$1]/gm;
adiciona em[]
torno de cada linha enquanto remove os espaços iniciais.s/\s+/, /g;
substitui execuções de espaços e novas linhas por vírgula e espaço.A primeira saída é, então, obtido por circundante com cintas:
[$_]
.O segundo precisa substituir chaves por colchetes (
y/[]/{}/r
) e cercar por colchetes"{" ... "}"
.Para o terceiro,
], [
são substituídos por um ponto e vírgula e um espaço (s/], \[/; /gr
).Depois de escrever esta solução, tentei adaptar a resposta Retina de Martin Ender, mas ela acabou 10 bytes mais ( TryItOnline ):
Para esta versão, consulte a resposta de Martin para as explicações.
fonte
MATL , 60 bytes
Experimente online!
Muito obrigado a Luis Mendo por cortar um quarto do meu número de pessoal em uma aula master no chat.
Cole a entrada, seguida por uma linha vazia.
fonte
05AB1E ,
4544 bytesExperimente online!
Primeira saída
Segunda saída
Terceira saída
fonte
Python 2 , 143 bytes
Experimente online!
fonte
Javascript (ES6),
121110106 bytes-15 bytes graças a @Shaggy e @Justin
Exemplo de trecho de código:
fonte
map(x=>x.trim().replace(/ +/g,", "))
paramap(x=>x.match(/\S+/g).join`, `)
.Python 2 ,
163152150145 145 bytes-5 bytes graças a Felipe Nardi Batista, que sugeriu o uso de splats (desculpe, só preciso de uma desculpa para dizer essa palavra: P).
Experimente online!
fonte
Python 3 ,
184 178 174 173 169 163 * 157 *153 bytesFormato de Entrada / Saída: Saída com um espaço entre as matrizes e entrada com esta chamada de função (como mostrado no TIO):
Esta é a função:
Experimente online!
* Economizei 6 bytes graças a @officialaimm (de 169 a 163 bytes).
* Economizou 4 bytes graças a @FelipeNardiBatista.
Explicação a seguir após mais golfe.
fonte
C, 415 bytes
É um monstro e waaayyyy por muito tempo, mas eu terminei com isso. Provavelmente deveria ter adotado uma abordagem diferente.
Experimente online!
Segundo caso de teste | Terceiro caso de teste | Quarto caso de teste | Quinto caso de teste | Sexto caso de teste | Sétimo caso de teste
fonte
Geléia , 37 bytes
Um programa completo imprimindo os três formatos em três linhas.
Experimente online!
Quão?
fonte
V , 41 bytes
Experimente online!
Explicação
fonte
R , 132 bytes
Experimente online!
uma função anônima. Toma entrada como
Ele os imprime na mesma ordem que os casos de teste, mas com espaços como separador.
Explicação:
Primeiro ele troca espaços
,
e salva o resultado comoy
. Em seguida, alterna novas linhas com], [
, põe[[
e]]
em ambos os lados e salva o resultado disso comoz
.Em seguida,
chartr
muda[
com{
e]
com}
noz
.Finalmente, leva
y
, troca de novas linhas com,;
coloca[
e]
em cada extremidade.Todos os resultados são transmitidos na ordem em
cat
que são impressos, todos bem formatados e separados por um único espaço.Ligeiramente não-destruído:
fonte
Java 8 com Netbeans 8+, 209 bytes
A contagem é 208 do código, mais 1 bytes para executá-lo pressionando
F6
.Resposta complicada para um desafio complicado: p
Como usar?
Dentro Netbeans, cole este código em um arquivo chamado
M.java
. Em seguida, copie a matriz que você deseja usar. Entre os dois caracteres consecutivos""
, pressionectrl
+v
conforme exigido pelo desafio.Agora pressione
F6
! Isso irá compilar o código, executá-lo e gerar as representações esperadas da matriz.fonte
\n
, produzindo o resultado o que você viu. Então eu não entendo direito, para ser sincero: s #Mathematica, 129 bytes
A terceira e quarta linhas juntas definem uma função pura, recebendo uma string como entrada; por exemplo, se definirmos
f=Print...&
, o último caso de teste será chamado como:O trecho
analisa a string de entrada como uma matriz (de strings - nunca tentamos interpretar as entradas como quantidades numéricas) e converte a expressão resultante novamente em uma string; isso gera automaticamente o formato de saída com chaves. Em seguida,
Print[#,n,#~r~{"{"->"[","}"->"]"},n,#~r~{"{{"->"[","}}"->"]","}, {"->"; "}]
imprime esse formato de saída e os outros dois, separados por novas linhas, usando regras simples de substituição de string.fonte
Pip ,
4946 bytes45 bytes de código, +1 para
-r
sinalizador.Recebe entrada de stdin. Experimente online!
Explicação
(Esse formato de explicação parece um pouco complicado para mim, então, deixe-me saber se alguma coisa não fazia sentido.)
fonte
SCALA, 590 bytes
Foi difícil, mas acho que terminei
Explicação rápida: tomo as entradas entre aspas triplas e depois removo os espaços não necessários; divida a string duas vezes (uma vez para linhas e outra para colunas); e imprimo com minhas três rotinas. Pode ser possível definir uma função para mutualizar, mas não sei como.
Experimente online!
fonte
05AB1E , 34 bytes
Experimente online!
ε...}
foi substituídovy...})
pelo TIO, pois ainda não foi puxado para lá.fonte
C # (.NET Core) , 214 bytes
Experimente online!
Pega Matrix como uma sequência, retorna os três formatos como uma sequência separada por novas linhas.
fonte
using System.Text.RegularExpressions
é necessária adicionando (pela minha contagem) 37 bytes adicionais.Carvão , 38 bytes
Experimente online! Nota: Espaço à direita. Link é a versão detalhada do código. O carvão vegetal tem uma opção de entrada multilinha delimitada usando
["""
e"""]
. Explicação:Isso pega a entrada e a prepara dividindo-a em linhas e normalizando os separadores.
Isso lida com
[[ ... ], [ ... ]]
e{{ ... }, { ... }}
casos .Isso lida com o
[ ... ; ... ]
caso.Antes de tirar um byte da solução acima, eu costumava ter duas soluções de 39 bytes; este é o outro:
Experimente online! Nota: Espaço à direita. Link é a versão detalhada do código. Explicação:
fonte