Estafa de una estafa de una estafa de una estafa . ¡Vota esos!

Su tarea, si desea aceptarla, es escribir un programa / función que genere / devuelva su entrada / argumento¹. La parte difícil es que si transpongo su código fuente², la salida / resultado también debe transponerse.

1. Puede elegir qué tipo de datos 2D puede aceptar su solución. Por ejemplo, una lista de listas, una matriz, una lista de cadenas, etc. Indique cuál (es) maneja. Puede suponer que la entrada siempre será rectangular y tendrá una longitud de 1 o más a lo largo de cada dimensión.

2. A los fines de la transposición, las líneas cortas en su código fuente se considerarán rellenadas con espacios finales hasta que sea rectangular; sin embargo, estos espacios finales rellenados no contribuyen a la longitud de su código.

Como se trata de código de golf , el objetivo es optimizar el recuento de bytes del código fuente original (no la versión transpuesta).

Ejemplos

Digamos que su solución toma una matriz numérica y su código fuente es

AB
DEF

y su entrada / argumento es [[1,2],[3,4],[5,6]]. Si yo escribo

AD
BE
 F

en su lugar y ejecutarlo, la salida / resultado debe ser [[1,3,5],[2,4,6]].

Digamos que su solución toma una cadena separada por salto de línea y su código fuente es

ABC

y su entrada / argumento es "96\n". Si yo escribo

A
B
C

en su lugar y ejecutarlo, la salida / resultado debe ser "9\n6\n".

Python 3 + numpy, 45 bytes

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

Pruébalo en línea!

Gracias a @EriktheOutgolfer señalando un error de la versión anterior

Transpuesto:

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

Pruébalo en línea!

Las funciones toman una matriz numpy como entrada y salida de una matriz numpy. La solución no se basa en comentarios como muchas otras soluciones, sino que explota cadenas de varias líneas.

Jalea , 2 bytes

La entrada es una lista de listas. Gracias a Luis Mendo y Nick Kennedy por mejorar la respuesta.

ZZ

Pruébalo en línea! ¡Inténtalo transpuesto!

El programa transpone la entrada dos veces, devolviendo la entrada original. La versión transpuesta ignora la primera línea y solo se transpone una vez.

R , 5 4 bytes

#t
I

Pruébalo en línea!

Una función R, ya sea la función de identidad Io la función de transposiciónt transposición cuando se transpone. El pie de página en TIO muestra la salida de ambos.

¡Gracias a @RobinRyder por guardar un byte!

C (gcc) , 209 205 203 201 bytes

Normal

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    */

Pruébalo en línea!

Transpuesto

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
] 
) 
; 
} 
/*
*/

Pruébalo en línea!

Haskell , 51 bytes

Esta versión es válida, pero no se detendrá cuando se proporcione []como entrada.

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

Pruébalo en línea!

Transpuesto, 75 bytes

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

Pruébalo en línea!

Haskell , 51 bytes

Esta versión es válida, pero se bloquea []como entrada para la versión transpuesta.

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

Pruébalo en línea! Transpuesto

Haskell , 75 67 57 bytes

Al menos 7 bytes guardados gracias a Ørjan Johansen

Esta versión sale []cuando se da []como entrada.

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

Pruébalo en línea!

Transpuesto

Python 3 , 51 bytes

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

Pruébalo en línea!

Basado en el enfoque de Joel . La entrada es a tuplede tuples, y la salida es a zip(convertida atuple TIO superior para una mejor visibilidad).

Transpuesto:

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

Pruébalo en línea!

Perl 6 , 20 11 bytes

#&
*[
#Z
 ]

Pruébalo en línea!

Transpuesto

#*# 
&[Z]

Pruébalo en línea!

Ambas funciones funcionan en la lista de listas.

*[ ] es un WhateverCode que devuelve el segmento zen de su argumento, efectivamente la función de identidad.

&[Z] es el operador zip.

Haskell, 185 161 bytes

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
 )

Pruébalo en línea!

Transpuesto:

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

Pruébalo en línea!

Sin comentarios, sin literales de cadena, solo algunas definiciones de funciones adicionales.

Editar: -24 bytes gracias a @ Ørjan Johansen.

PHP (7.4), 114 86 70 bytes

Mi primera experiencia en hacer algo como esto en PHP, debe haber una mejor manera que no puedo ver. La entrada es una matriz de matrices como [[1,2],[3,4],[5,6]].

Normal:

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

Pruébalo en línea!

Transpuesta (espacio acolchado):

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

Pruébalo en línea!

Carbón de leña , 19 bytes

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

Pruébalo en línea! Toma la entrada como una matriz de cadenas. Explicación: Ａimprime implícitamente la entrada explícita, mientras que ¿⁰es condicional, con 0la condición, que por lo tanto siempre es falsa. «luego comienza un bloque de código de carbón sin sentido que nunca se ejecuta. (Puede ser posible eliminar algunos de esos bytes, pero en ese caso no estoy seguro de si Charcoal analizará el programa correctamente). Transpuesta, 17 bytes:

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

Pruébalo en línea! Explicación: casi lo mismo que el programa anterior, excepto por la adición del comando de transposición ‖↗.

Tengo una solución alternativa donde el programa original y el transpuesto son 18 bytes:

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

Pruébalo en línea! Explicación: Ａcomo arriba;⊞υempuja un valor a la lista vacía predefinida (que no afecta la salida); ”ycomienza una cadena arbitraria (termina al final del programa o coincidencia ”). Transpuesto:

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

Pruébalo en línea! Explicación: Ａ‖↗como arriba; ⊞υcomo anteriormente; La pequeña diferencia aquí es que estoy presionando concatenaciones de cadenas más pequeñas, ya que no quiero repetir el ”.

Brain-Flak (BrainHack) , 382 375 337 bytes

¡Sin comentarios!

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

Pruébalo en línea!

Para la entrada, los dos primeros números son las dimensiones de la matriz y el resto es el contenido de la matriz. La salida se da en el mismo formato.

Transpuesto

Brain-Flak (BrainHack) , 465 bytes

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

Pruébalo en línea!

Japt , 2 bytes

ÕU

Pruébalo | Transpuesto

Õ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 bytes

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

Pruébalo en línea!

Mejorado con un diseño diferente

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

Haskell ,153 144 bytes

(gracias, Sriotchilism O'Zaic )

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

Pruébalo en línea!

¡Inténtalo transpuesto!

APL (Dyalog Unicode) , 7 bytes

{⍵
⍉
⍵}

Pruébalo en línea!

Transpuesto:

{⍉⍵
⍵ }

Probablemente una respuesta bastante aburrida, pero de todos modos aquí va.

La definición de la función en línea {...}puede abarcar varias líneas. En este caso, cada línea se ejecuta secuencialmente, pero cualquier línea sin una asignación ←devuelve inmediatamente su valor calculado. Entonces la primera función regresa ⍵mientras que la segunda regresa ⍉⍵.

Una respuesta aún más aburrida sería el abuso de comentarios:

APL (Dyalog Unicode) , 4 bytes

⍝⍉
⊢

No es necesario un TIO, supongo ...

05AB1E , 3 bytes

øø
q

Pruébalo en línea.

øq
ø

Pruébalo transpuesto.

Explicación:

A diferencia de algunos de los otros idiomas, las líneas nuevas simplemente se ignoran en 05AB1E, por lo que no creo que sea posible un byte 2 (aunque me encantaría que se demuestre que está equivocado).

ø    # 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

Ruby , 35 bytes

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

Pruébalo en línea!

¡Cadera para ser cuadrada! (Casi)

Acepta matrices ruby ​​como entrada (matrices de matrices)

Limpio , 64 bytes

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

Pruébalo en línea!

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

¡Inténtalo transpuesto!

Python 3 , 118 95 bytes

La entrada y el resultado son listas de tuplas.

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

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

Pruébalo en línea!

Wolfram Language (Mathematica) , 13 bytes

#&(*
 *)
\

Pruébalo en línea! / Transpuesto

Cjam , 13 bytes

qo
~
z
`

Pruébalo en línea!

Versión transpuesta:

q~z`
o

Pruébalo en línea!

Formato de entrada

El formato de entrada es el formato de matriz CJam estándar: [[1 2] [3 4]]

Sin versión de bloqueo, 12 bytes

La versión normal se bloquea después de imprimir la matriz. Una versión que no se bloquea sería:

qo{
~
z
` };

Pruébalo en línea!

o transpuesto:

q~z`
o
{  };

Pruébalo en línea!

Probablemente hay algunos bytes adicionales que se pueden guardar, accidentalmente trabajé primero en la versión transpuesta, lo que condujo a algunos saltos de línea adicionales y ha pasado mucho tiempo desde la última vez que usé CJam. Cualquier mejora bienvenida.

Zsh , 75 bytes

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

$
#
s

TIO: normal transpuesto

La basura debajo de la impresión principal es inofensiva, imprime un error al encontrar una nueva línea después fa<y sale. 86 bytes para eliminar ese error.

La versión transpuesta está aquí. Después de imprimirlo, aparece un error al ver <al final de una línea y sale.

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

Encantamientos rúnicos , 88 bytes

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

$

Pruébalo en línea!
¡Inténtalo transpuesto!

La entrada está separada por espacios para cada valor y separada por comas para cada fila (las nuevas líneas son opcionales) y admite cadenas y números (distintos de cero). Esto facilita el análisis de la entrada ya que la entrada se divide automáticamente por espacios y nuevas líneas. Entonces, por ejemplo, la entrada:

1 2 3 , 4 5 6 , 7 8 9

Se representaría en forma de matriz anidada como [[1,2,3],[4,5,6],[7,8,9]]. Soporte mínimo para matrices irregulares (solo el último puede ser corto), pero como se espera que las entradas sean rectangulares, esto satisface ese requisito.

La salida se representa en el mismo formato (la versión transpuesta sale con líneas nuevas, pero sus bytes cero son diferentes para usar un espacio). La versión normal tiene un espacio final, la versión transpuesta tiene una coma final y una nueva línea (debido a la dificultad de determinar cuándo no hay más datos para imprimir).

La versión normal tiene caracteres modificadores en lugares extraños (p. Ej. 7̸0 ), Pero esto se debe a que los necesita en el lugar correcto cuando se transpone la fuente y la ejecución normal solo utiliza la columna de instrucciones más a la izquierda.

Explicación

La explicación de la fuente transpuesta será en forma no transpuesta. Las flechas representarán la direccionalidad de IP en la entrada y salida de varios bloques.

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

Se lee la entrada y, cuando ,se encuentra un carácter, se empuja un nuevo subconjunto. Esto permite que cada pila contenga cada fila por separado en la memoria. Entra en la siguiente sección desde arriba.

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

[0(ejecutado hacia la izquierda) configura una pila vacía para que actúe como límite entre la primera fila y la última fila y luego gira a la primera pila ( {̹) y comienza a imprimir elementos y pilas giratorias. El i!no se ejecuta y {̹L [0rsolo se ejecuta una vez. Cuando se encuentra una pila de tamaño cero, el ciclo sale.

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

Cuando se encuentra la pila vacía, ,se imprimen una nueva línea y se vuelve a ingresar el bucle de valor. Orden de ejecución (duplicado para facilitar la lectura), donde .es un comando ejecutado un-: \',$!.6ak$?....../. Cambiar aka '<space>imprimiría espacios en lugar de líneas nuevas.

La ejecución se detiene cuando el programa intenta escribir desde una pila vacía; esta es la razón por la que solo la irregularidad de la última fila funciona correctamente y por qué hay un seguimiento ,en la salida: la coma ya se ha impreso antes de que el programa sepa que no hay más datos.