Ho scritto alcune sfide relative alle matrici e comune a tutti è che uso un formato come quello sotto per rappresentare le matrici, sia negli esempi che nei casi di test:
16 2 3 13
5 11 10 8
9 7 6 12
4 14 15 1
Questo è probabilmente un formato ingombrante in molte lingue.
Sfida:
Scrivi un programma / funzione che può assumere una matrice sul modulo indicato in alto come input (direttamente copiato / incollato da questo post) e genera la stessa matrice su tutti gli altri tre formati convenzionali mostrati di seguito .
Il formato di input:
Numeri separati da un numero variabile di spazi e newline per rappresentare le righe (vedere casi di test).
- Non è garantito che il numero di spazi tra i numeri sia coerente. Si può tuttavia presumere che l'ultima cifra in ciascuna colonna sia allineata (se ciò aiuta qualsiasi).
- Possono esserci sia numeri interi che float e possono essere positivi, negativi o zero. Una matrice non conterrà numeri interi e float contemporaneamente.
- Si può presumere che nessun numero sia più lungo di 10 caratteri, inclusi il segno meno e il punto decimale per i float negativi.
- Si può presumere che ci sia lo stesso numero di voci in ciascuna riga e in ciascuna colonna.
- Non ci saranno matrici di input vuote, ma possono esserci numeri singoli o matrici con una sola riga o colonna.
- In questi casi è possibile scegliere tra i formati di output mostrati nei casi di test
Il tuo programma / funzione deve gestire l'input se è direttamente copiato da questo post e incollato nell'interprete (STDIN o come argomento di funzione o qualcosa di equivalente). Potresti avere quello che ti piace (parentesi, virgolette, parentesi) davanti e / o dopo la matrice, ma devi considerare la matrice una sequenza di caratteri che non può essere modificata (che include le nuove righe).
Per chiarire: supponiamo che la vostra funzione / programma sia chiamata fe la matrice sia:
1 -2
3 5
6 7
allora puoi dare alla matrice come argomenti di funzione come questa (e infinitamente molte altre opzioni):
f(1 -2
3 5
6 7)
f([1 -2
3 5
6 7])
f("""1 -2
3 5
6 7""")
Se la tua lingua non può, in alcun modo, prendere la matrice copia / incollata come input, temo che tu debba scegliere un'altra lingua.
Il formato di output:
Dovresti generare la matrice nei seguenti tre formati (l'ordine non ha importanza):
[[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]
- È possibile separare le tre uscite nel modo desiderato (ad es. Una nuova riga)
- È necessario generare i numeri utilizzando la stessa precisione dell'input (ad esempio, non è necessario tagliare il numero di decimali, né numeri interi di output come float).
- Gli spazi sono obbligatori
- È necessario utilizzare
-per numeri negativi, non_o simili.
Casi test:
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]
Sono pienamente consapevole di questo , ma in questa sfida, il formato ingombrante I / O è il punto. La sfida consisterà nel formattare l'output in alcune lingue, mentre la lettura dell'input sarà la parte più difficile in altre lingue.
Si prega di non scoraggiarsi se la lettura dell'input è difficile, tali invii potrebbero essere i più interessanti. Corto non è necessariamente uguale a impressionante. E come sempre, le spiegazioni sono incoraggiate!