Fregatura di una fregatura di una fregatura di una fregatura . Votare quelli!

Il tuo compito, se desideri accettarlo, è scrivere un programma / funzione che emetta / restituisca il suo input / argomento¹. La parte difficile è che se traspongo il codice sorgente², anche l'output / risultato deve essere trasposto.

1. È possibile scegliere il tipo di dati 2D che la soluzione può accettare. Ad esempio un elenco di elenchi, una matrice, un elenco di stringhe, ecc. Indica quale (i) gestisce. Si può presumere che l'input sarà sempre rettangolare e avrà una lunghezza di 1 o più lungo ciascuna dimensione.

2. Ai fini della trasposizione, le linee brevi nel codice sorgente verranno considerate riempite di spazi finali fino a quando non saranno rettangolari, tuttavia, questi spazi finali imbottiti non contribuiscono alla lunghezza del codice.

Poiché si tratta di code-golf , l'obiettivo è ottimizzare il conteggio dei byte del codice sorgente originale (non la versione trasposta).

Esempi

Diciamo che la tua soluzione prende una matrice numerica e il tuo codice sorgente è

AB
DEF

e il suo input / argomento è [[1,2],[3,4],[5,6]]. Se scrivo

AD
BE
 F

invece ed eseguirlo, l'output / risultato deve essere [[1,3,5],[2,4,6]].

Supponiamo che la tua soluzione prenda una stringa separata da linefeed e che sia il tuo codice sorgente

ABC

e il suo input / argomento è "96\n". Se scrivo

A
B
C

invece ed eseguirlo, l'output / risultato deve essere "9\n6\n".

Python 3 + numpy, 45 byte

lambda\
a:a
ma= """
b.    "
dT"   "
a "
\ """

Provalo online!

Grazie a @EriktheOutgolfer sottolineando un bug della versione precedente

trasposto:

lambda\
a:a.T  
ma= """
b     "
d "   "
a "    
\ """  

Provalo online!

Le funzioni prendono una matrice numpy come input e producono una matrice numpy. La soluzione non si basa su commenti come fanno molte altre soluzioni, ma sfrutta invece le stringhe multilinea.

Gelatina , 2 byte

L'input è un elenco di elenchi. Grazie a Luis Mendo e Nick Kennedy per aver migliorato la risposta.

ZZ

Provalo online! Provalo trasposto!

Il programma traspone due volte l'input, restituendo l'input originale. La versione trasposta ignora la prima riga e traspone solo una volta.

R , 5 4 byte

#t
I

Provalo online!

Una funzione R, la funzione identità Io la funzione di trasposizionet trasposizione quando trasposta. Il piè di pagina su TIO mostra l'output di entrambi.

Grazie a @RobinRyder per aver salvato un byte!

C (gcc) , 209 205 203 201 byte

Normale

f(n,L,r,c)char**L;{for(c=0;0?L+  c:c<n;c+=puts(""))for(r=0;0?r :L[c][r];r++)putchar(L[ c ][ r ]);}/*
          \\\      \\      1 [0][]      \ \\\  \   \\      1 <n          \  \\\\\\   r+-c c+-r    */

Provalo online!

trasposto

f 
( 
n 
, 
L 
, 
r 
, 
c 
) 
c\
h\
a\
r 
* 
* 
L 
; 
{ 
f\
o\
r 
( 
c 
= 
0 
; 
01
? 
L[
+0
 ]
 [
c]
: 
c 
< 
n 
; 
c 
+\
= 
p\
u\
t\
s 
( 
"\
" 
) 
) 
f\
o\
r 
( 
r 
= 
0 
; 
01
? 
r<
 n
: 
L 
[ 
c 
] 
[ 
r 
] 
; 
r 
+\
+ 
) 
p\
u\
t\
c\
h\
a\
r 
( 
L 
[r
 +
c-
 c
] 
[c
 +
r-
 r
] 
) 
; 
} 
/*
*/

Provalo online!

Haskell , 51 byte

Questa versione è valida, ma non si arresterà quando viene fornita []come input.

f
--(:[|,<zabf=]f
--abx(y-i$]
-- ):x) pf;x[:x
 y =y

Provalo online!

Trasposto, 75 byte

f---
 ---y
 (a
 :b)=
 [x:y
 |(x
 ,y)
 <-
 zip
 a$f
 b];
 f x
 = [
 ] :
 f x

Provalo online!

Haskell , 51 byte

Questa versione è valida, ma si arresta in modo anomalo []come input per la versione trasposta.

f
--d[(idi)z[.]d!0
-- m!)|,<i0.$ !]
-- a! (_-p
 p=p

Provalo online! trasposto

Haskell , 75 67 57 byte

Almeno 7 byte salvati grazie a Ørjan Johansen

Questa versione []viene emessa quando fornita []come input.

f
--[[d(i<di)z[.$!0
--]]=!)$|,<i0.d!]
-- ;[! >(_-p ]
 f=f

Provalo online!

trasposto

Python 3 , 51 byte

lambda\
a:a
mz= '''
bi'   '
dp'   '
a('
 *
 a
\)'''

Provalo online!

Basato sull'approccio di Joel . L'input è a tupledi tuples e l'output è a zip(convertito in atuple over TIO per una migliore visibilità).

trasposto:

lambda  \
a:zip(*a)
ma='''  '
b       '
d '     '
a '      
\ '''    

Provalo online!

Perl 6 , 20 11 byte

#&
*[
#Z
 ]

Provalo online!

trasposto

#*# 
&[Z]

Provalo online!

Entrambe le funzioni funzionano su un elenco di elenchi.

*[ ] è un qualunque codice che restituisce la fetta zen del suo argomento, in effetti la funzione identità.

&[Z] è l'operatore zip.

Haskell, 185 161 byte

t i
 =
 i
af

 n m
 u a e i
 l p s d
 lu h=u
 (
 h
 e
 a
 d

 a
 )
 t
 h
 e
 n
 [
 ]
 e
 l
 s
 e

 m
 a
 p

 h
 e
 a
 d

 a
 :
 t
 (
 m
 a
 p

 t
 a
 i
 l

 a
 )

Provalo online!

trasposto:

t  a
 =if null(head a)then[]else map head a:t(map tail a)
i       u
     map
        h
      es=
        u
      id

Provalo online!

Nessun commento, nessun valore letterale di stringa, solo alcune definizioni di funzioni aggiuntive.

Modifica: -24 byte grazie a @ Ørjan Johansen.

PHP (7.4), 114 86 70 byte

La mia prima esperienza in assoluto nel fare qualcosa del genere in PHP, deve esserci un modo migliore che non riesco a vedere! L'input è una matrice di array come[[1,2],[3,4],[5,6]] .

Normale:

fn($a)=>$a/*
nu         /
(l
$l
a,
).
=.
>.
a$
ra
r)
a/
y*
_
m
a
p
(*/

Provalo online!

Trasposto (spazio imbottito):

fn($a)=>array_map(
null,...$a)/*    *
(                /
$                 
a                 
)                 
=                 
>                 
$                 
a                 
/                 
*/                

Provalo online!

Carbone , 19 byte

Ａ¿⁰«
‖⁰¿
↗⁰
¿⁰
⁰¿
«

Provalo online! Accetta input come una matrice di stringhe. Spiegazione: Ａstampa implicitamente l'input esplicito, mentre ¿⁰è un condizionale, con 0come condizione, che è quindi sempre falso. «quindi avvia un blocco di codice carboncino senza significato che non viene mai eseguito. (Potrebbe essere possibile rimuovere alcuni di quei byte, ma in quel caso non sono sicuro che Charcoal analizzerà correttamente il programma.) Trasposto, 17 byte:

Ａ‖↗¿⁰«
¿⁰⁰⁰¿
⁰¿
«

Provalo online! Spiegazione: Molto simile al programma precedente, ad eccezione dell'aggiunta del comando transpose‖↗ .

Ho una soluzione alternativa in cui sia il programma originale che quello trasposto sono 18 byte:

Ａ⊞υ”y
‖υ⁺y
↗⁺
⊞⁺
υ

Provalo online! Spiegazione: Ａcome sopra; ⊞υinserisce un valore nell'elenco vuoto predefinito (che non influisce sull'output); ”yinizia una stringa arbitraria (termina alla fine del programma o della corrispondenza ”). trasposto:

Ａ‖↗⊞υ
⊞υ⁺⁺
υ⁺
”y
y

Provalo online! Spiegazione: Ａ‖↗come sopra; ⊞υcome sopra; la differenza minore qui è che sto spingendo concatenazioni di stringhe più piccole, dal momento che non voglio ripetere il ”.

Brain-Flak (BrainHack) , 382 375 337 byte

Non ci sono commenti!

  ( <( <>)<> ><>) ({})  {}{}   {( )()<({}<{}<><>>{}<><>{}) ( <>) ({}<><( [ ]({}<{}( )<({}()<{}<><>>){} ><><{}<< ><> ( [ ]( <>)<>)>{}<>>>)){}>)> ( ){ {}[]} <>[]{
(({}({}  ( ))   <>( ))[( [ ])])({}[ ] [ ](   )  (   ) < ><>{}  <>(   ){{}()<( )( ({} {  [ ](   )   } <>)  (  (())  {{}()<{}    >}  )  ) >}    )}[] {} ( ){} ( ){}({}<>)<>([])}<>

Provalo online!

Per l'input i primi due numeri sono le dimensioni della matrice e il resto è il contenuto della matrice. L'output è dato nello stesso formato.

trasposto

Brain-Flak (BrainHack) , 465 byte

 (
 (
({
 }
<(
({
 }
<
>
)(
<
>)
 )
>
<
>
)<
 >
((
{
})
))
 [
 (
{
}[
{
}]
 )
 ]
 )
{(
({
 }
)[
(
)]
<
([
{
}]
<( 
{
}
<
>)
<
>
>(
{
}
<
>)
<
><
{
}>
)<
 >
({
 }
<
>
)<
 >
((
{
}
<
>)
<{
({
 }
[(
 )
]<
((
{
})
<(
{
}(
({
 }
)
<{
(
{
}[
(
)]
<(
{
}
<
>)
<
>
> 
)}
{
}<
 >
>)
<
>
<(
{
}
<(
<(
 )
>)
<
>
 {
({
 }
[(
 )
]<
({
 }
<
>
)
<
>>
)}
>
{
})
<
>
>)
>
)>
)}
{
}
>
)
>)
 }
([
 ]
)
{{
 }
{
}(
[
])
}{
 }
<
>(
[
])
{{
 }
 (
 {
 }
 <
 >
 )
 <
 >
 (
 [
 ]
 )
 }
 <
 >

Provalo online!

Japt , 2 byte

ÕU

Provalo | trasposto

ÕU     :Implicit input of string/array U
Õ      :Transpose U
 U     :Original U
       :Implicit output

Õ\nU     :Implicit input of string/array U
Õ        :Transpose U
 \n      :Reassign to U
   U     :Newly transposed U
         :Implicit output

JavaScript (Node.js) , 62 byte

//m0()m  ]
//=](=a  )
//>.a>p( )
//mm,m/aa
//[ap./=[
   p  =>p

Provalo online!

Migliorato con un layout diverso

///// 
///// 
m=>m[ 
0].map 
((a,p 
)=>m. 
map//= 
  (a=> 
   a[p 
])) 

Haskell ,153 144 byte

(grazie, Sriotchilism O'Zaic )

f
 [
 ]=
   [
   ];
    f(
     x:
      l)
       =(
        :)
         x l
-- :   z $
-- f   i f
-- [   p
-- ]   W
--     i
--     t
--     h

Provalo online!

Provalo trasposto!

APL (Dyalog Unicode) , 7 byte

{⍵
⍉
⍵}

Provalo online!

trasposto:

{⍉⍵
⍵ }

Probabilmente una risposta piuttosto noiosa, ma comunque qui va.

La definizione della funzione inline {...}può comprendere più righe. In questo caso, ogni riga viene eseguita in sequenza, ma qualsiasi riga senza un'assegnazione ←restituisce immediatamente il suo valore calcolato. Quindi ritorna la prima funzione⍵ mentre la seconda ritorna⍉⍵ .

Ancora più noiosa risposta sarebbe l'abuso dei commenti:

APL (Dyalog Unicode) , 4 byte

⍝⍉
⊢

Nessun TIO è necessario, immagino ...

05AB1E , 3 byte

øø
q

Provalo online.

øq
ø

Provalo trasposto.

Spiegazione:

A differenza di alcune altre lingue, le nuove righe vengono semplicemente ignorate in 05AB1E, quindi non credo sia possibile un 2-byte (anche se mi piacerebbe essere smentito).

ø    # Transpose the (implicit) input
 ø   # Transpose it back
  q  # Stop the program (and output the top of the stack implicitly as result)

ø    # Transpose the (implicit) input
 q   # Stop the program (and output the top of the stack implicitly as result)
  ø  # No-op, since the program has already stopped

Rubino , 35 byte

#-sz##
->hip{
 hip  }
#{f
#ht*
#..h

Provalo online!

Anca per essere quadrato! (Quasi)

Accetta matrici ruby ​​come input (matrici di matrici)

Pulito , 64 byte

//i$
//mp
$ p=p
//ot
//rr
//ta
// n
//Ss
//tp
//do
//Ls
//ie
//b

Provalo online!

//$//////////
// //////////
import StdLib
$p=transpose
  p

Provalo trasposto!

Python 3 , 118 95 byte

Input e risultato sono elenchi di tuple.

f=lambda i:i;"""
=              "
l              "
a
m
b
d
a

i
:
[
*
z
i
p
(
*
i
)
]
;
"
"
"""

Provalo online!

Wolfram Language (Mathematica) , 13 byte

#&(*
 *)
\

Provalo online! / Trasposto

Cjam , 13 byte

qo
~
z
`

Provalo online!

Versione trasposta:

q~z`
o

Provalo online!

Formato di input

Il formato di input è il formato di array CJam standard: [[1 2] [3 4]]

Nessuna versione crash, 12 byte

La versione normale si arresta in modo anomalo dopo aver stampato l'array. Una versione che non si blocca sarebbe:

qo{
~
z
` };

Provalo online!

o trasposto:

q~z`
o
{  };

Provalo online!

Probabilmente ci sono alcuni byte extra che possono essere salvati, ho accidentalmente lavorato prima alla versione trasposta, il che ha portato a qualche interruzione di riga in più ed è passato molto tempo dall'ultima volta che ho usato CJam. Eventuali miglioramenti sono benvenuti.

Zsh , 75 byte

  <<<${(F)@}
fa<
o[<
r+$
 +{
si(
;]F
i+)
==a
&$}
&s
r[
ei
p+
e1
a]
t

$
#
s

TIO: normale trasposto

La spazzatura sotto la stampa principale è innocua, stampa un errore quando incontra una nuova riga dopo fa<ed esce. 86 byte per rimuovere quell'errore.

La versione trasposta è qui. Dopo averlo stampato, si verifica un errore nel vedere <alla fine di una riga ed esce.

 for s;i=&&repeat $#s
 a[++i]+=$s[i+1]
<<<${(F)a}
<
<
$
{
(
F
)
@
}

Incantesimi runici , 88 byte

vrlril1-{)?\:',=4*?~r0[
i! '${U [0r/?*7̸0l{$
$ka6 ̹\!$,'/;? =  ̹
'              ̸

$

Provalo online!
Provalo trasposto!

L'input è spazio separato per ogni valore e virgola separata per ogni riga (le nuove righe sono opzionali) e supporta sia stringhe che numeri (diversi da zero). Ciò semplifica l'analisi dell'input poiché l'input viene automaticamente interrotto da spazi e newline. Quindi, ad esempio, l'input:

1 2 3 , 4 5 6 , 7 8 9

Sarebbe rappresentato in forma di matrice nidificata come [[1,2,3],[4,5,6],[7,8,9]]. Supporto minimo per array frastagliati (solo l'ultimo può essere corto), ma poiché gli input dovrebbero essere rettangolari, questo soddisfa tale requisito.

L'output è rappresentato nello stesso formato (output della versione trasposta con newline, ma i suoi zero byte diversi per utilizzare invece uno spazio). La versione normale ha uno spazio finale, la versione trasposta ha una virgola finale e una nuova riga (a causa della difficoltà di determinare quando non ci sono più dati da stampare).

La versione normale ha caratteri modificatori in posti strani (ad es. 7̸0 ), Ma ciò è dovuto alla necessità di averli nel posto giusto quando viene trasposta la fonte e l'esecuzione normale utilizza solo la colonna di istruzioni più a sinistra.

Spiegazione

La spiegazione della fonte trasposta sarà in una forma non trasposta. Le frecce rappresentano la direzionalità IP all'ingresso e all'uscita di vari blocchi.

→rlril1-{)?\:',≠4*?~r0[    Initial position. Read and parse input.
           ↓               Input loop exit and direction

L'input viene letto e quando ,viene trovato un carattere, viene premuto un nuovo sottoinsieme. Ciò consente a ogni stack di contenere ciascuna riga separatamente in memoria. Entra nella sezione successiva dall'alto.

           ↓
.. '${̹L [0r/?*7≠0l{̹$       When no more input:
      ↑    ↓

[0(eseguito a sinistra) imposta uno stack vuoto che funge da confine tra la prima riga e l'ultima riga, quindi ruota sul primo stack ( {̹) e inizia a stampare elementi e ruotare pile. Non i!viene eseguito e {̹L [0rviene eseguito solo una volta. Quando viene trovato uno stack di dimensioni zero, il loop viene chiuso.

      ↑    ↓
$ka6  \!$,'/;?             Row separation formatting

Quando viene trovata la pila vuota, ,vengono stampati a e newline e viene reinserito il valore loop. Ordine di esecuzione (mirroring per migliorare la leggibilità), dove .è un comando non-esecuzione: \',$!.6ak$?....../. Passando aka '<space>si stamperebbero gli spazi anziché le nuove righe.

L'esecuzione si interrompe quando il programma tenta di scrivere da uno stack vuoto; questo è il motivo per cui solo il jagginess dell'ultima riga funziona correttamente e c'è un trailing ,nell'output: la virgola è già stata stampata prima che il programma sappia che non ci sono più dati.