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.

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.
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".

code-golf matrix source-layout Adán
fuente

23

Dios mío. Podemos parar?

JL2210

3

@ Night2 No, complica las cosas.

Adám

14

@ JL2210 No, tengo uno grande en proceso.

Adám

77

Estos desafíos se están volviendo imposibles en los lenguajes de procedimiento sin un abuso serio de comentarios.

JL2210

2

@ Transformaciones JL2210 .

Adám

27

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.

Joel
fuente

3

Eso es realmente genial!

Adám

Hm, estoy bastante seguro de que la versión transpuesta se rellenará con espacios, por lo que la última línea contendrá espacios finales, por lo tanto \, arrojará un SyntaxError. Necesitas mover las comillas en ambas direcciones para arreglar esto.

Erik the Outgolfer

@EriktheOutgolfer Fijo. Gracias.

Joel

15

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.

ovs
fuente

13

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!

Nick Kennedy
fuente

No necesitas la final #.

Robin Ryder

@RobinRyder gracias! Por alguna razón, estaba rellenando un rectángulo a pesar de que había visto la declaración de que era innecesario.

Nick Kennedy

10

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!

gastropner
fuente

8

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

Asistente de trigo
fuente

60 bytes

Ørjan Johansen

@ ØrjanJohansen ¡Gracias! Había intentado algo así antes, pero no pude hacerlo funcionar. También hay una manera bastante fácil de quitar 3 bytes más de sus 60.

Wheat Wizard

7

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!

Erik el Outgolfer
fuente

5

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.

nwellnhof
fuente

5

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.

nimi
fuente

2

161 bytes

Ørjan Johansen

4

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!

Noche2
fuente

3

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 ”.

Neil
fuente

3

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!

Asistente de trigo
fuente

3

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

Lanudo
fuente

2

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 
]))

AZTECCO
fuente

2

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!

dejó de girar en sentido antihorario
fuente

Aquí hay una versión de 144 bytes mientras mantiene su estructura. ( Transpuesta ).

Wheat Wizard

Aquí hay una versión de 70 bytes que sigue siendo similar pero con algunos cambios estructurales. ( Transpuesta ).

Wheat Wizard

Gracias. Sin embargo, la segunda versión carece de la idea central (reutilizar la foldrrecursividad para ambas versiones), no me gusta eso.

dejó de girar en contra del reloj el

Ya sabes, este desafío y tu nombre de usuario se contradicen entre sí, ya que tu código se volvió en sentido antihorario en esa versión transpuesta. ;pags

Kevin Cruijssen

2

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 ...

Bubbler
fuente

1

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

Kevin Cruijssen
fuente

1

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)

GB
fuente

1

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!

Οurous
fuente

0

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!

Nishioka
fuente

0

Wolfram Language (Mathematica) , 13 bytes

#&(*
 *)
\

Pruébalo en línea! / Transpuesto

attinat
fuente

0

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.

Roman Gräf
fuente

0

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
)
@
}

Función Gamma
fuente

0

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.

Draco18s
fuente

Transpongo el código fuente, ¡tú transpones la entrada!

Ejemplos

Respuestas:

Python 3 + numpy, 45 bytes

Transpuesto:

Jalea , 2 bytes

R , 5 4 bytes

C (gcc) , 209 205 203 201 bytes

Normal

Transpuesto

Haskell , 51 bytes

Transpuesto, 75 bytes

Haskell , 51 bytes

Haskell , 75 67 57 bytes

Python 3 , 51 bytes

Perl 6 , 20 11 bytes

Transpuesto

Haskell, 185 161 bytes

PHP (7.4), 114 86 70 bytes

Normal:

Transpuesta (espacio acolchado):

Carbón de leña , 19 bytes

Brain-Flak (BrainHack) , 382 375 337 bytes

Transpuesto

Brain-Flak (BrainHack) , 465 bytes

Japt , 2 bytes

JavaScript (Node.js) , 62 bytes

Haskell ,153 144 bytes

APL (Dyalog Unicode) , 7 bytes

APL (Dyalog Unicode) , 4 bytes

05AB1E , 3 bytes

Ruby , 35 bytes

Limpio , 64 bytes

Python 3 , 118 95 bytes

Wolfram Language (Mathematica) , 13 bytes

Cjam , 13 bytes

Versión transpuesta:

Formato de entrada

Sin versión de bloqueo, 12 bytes

Zsh , 75 bytes

Encantamientos rúnicos , 88 bytes

Explicación