Arranque de um arranque de um arranque de um arranque . Voto a favor!

Sua tarefa, se você deseja aceitá-la, é escrever um programa / função que produz / retorna sua entrada / argumento¹. A parte complicada é que, se eu transpor seu código fonte², a saída / resultado também deverá ser transposta.

1. Você pode escolher que tipo de dados 2D sua solução pode aceitar. Por exemplo, uma lista de listas, uma matriz, uma lista de seqüências de caracteres, etc. Indique qual delas ele manipula. Você pode assumir que a entrada sempre será retangular e terá um comprimento de 1 ou mais ao longo de cada dimensão.

2. Para fins de transposição, as linhas curtas no seu código-fonte serão consideradas preenchidas com espaços à direita até que sejam retangulares; no entanto, esses espaços à direita não contribuem para o comprimento do código.

Como se trata de código-golfe , o objetivo é otimizar a contagem de bytes do código-fonte original (não a versão transposta).

Exemplos

Digamos que sua solução tenha uma matriz numérica e seu código-fonte seja

AB
DEF

e sua entrada / argumento é [[1,2],[3,4],[5,6]]. Se eu escrever

AD
BE
 F

em vez disso e execute-o, a saída / resultado deve ser [[1,3,5],[2,4,6]].

Digamos que sua solução use uma string separada por avanço de linha e seu código-fonte seja

ABC

e sua entrada / argumento é "96\n". Se eu escrever

A
B
C

em vez disso e execute-o, a saída / resultado deve ser "9\n6\n".

Python 3 + numpy, 45 bytes

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

Experimente online!

Graças a @EriktheOutgolfer apontando um bug da versão anterior

Transposto:

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

Experimente online!

As funções recebem uma matriz numpy como entrada e produzem uma matriz numpy. A solução não se baseia em comentários, como muitas outras soluções, mas explora seqüências de várias linhas.

Geléia , 2 bytes

Entrada é uma lista de listas. Agradecemos a Luis Mendo e Nick Kennedy por melhorar a resposta.

ZZ

Experimente online! Experimente transposto!

O programa transpõe a entrada duas vezes, retornando a entrada original. A versão transposta ignora a primeira linha e transpõe apenas uma vez.

R , 5 4 bytes

#t
I

Experimente online!

Uma função R, a função de identidade Iou a função de transposiçãot quando transposta. Rodapé no TIO mostra a saída de ambos.

Obrigado a @RobinRyder por salvar um 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    */

Experimente online!

Transposto

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

Experimente online!

Haskell , 51 bytes

Esta versão é válida, mas não será interrompida quando fornecida []como entrada.

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

Experimente online!

Transposto, 75 bytes

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

Experimente online!

Haskell , 51 bytes

Esta versão é válida, mas trava com a []entrada da versão transposta.

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

Experimente online! Transposto

Haskell , 75 67 57 bytes

Pelo menos 7 bytes salvos graças a Ørjan Johansen

Esta versão é []emitida quando fornecida []como entrada.

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

Experimente online!

Transposto

Python 3 , 51 bytes

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

Experimente online!

Baseado na abordagem de Joel . A entrada é a tuplede tuples e a saída é a zip(convertida em umtuple over TIO para melhor visibilidade).

Transposto:

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

Experimente online!

Perl 6 , 20 11 bytes

#&
*[
#Z
 ]

Experimente online!

Transposto

#*# 
&[Z]

Experimente online!

Ambas as funções funcionam na lista de listas.

*[ ] é um WhateverCode retornando a fatia zen de seu argumento, efetivamente a função de identidade.

&[Z] é o 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
 )

Experimente online!

Transposto:

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

Experimente online!

Sem comentários, sem literais de string, apenas algumas definições de função adicionais.

Edit: -24 bytes graças a @ Ørjan Johansen.

PHP (7.4), 114 86 70 bytes

Minha primeira experiência fazendo algo assim em PHP, deve haver uma maneira melhor que eu não possa ver! Input é uma matriz de matrizes como[[1,2],[3,4],[5,6]] .

Normal:

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

Experimente online!

Transposto (espaço preenchido):

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

Experimente online!

Carvão , 19 bytes

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

Experimente online!Recebe entrada como uma matriz de seqüências de caracteres. Explicação: Ａimprime implicitamente a entrada explícita, enquanto ¿⁰é uma condicional, com 0como a condição, que é, portanto, sempre falsa. «então inicia um bloco de código de carvão sem sentido que nunca é executado. (Pode ser possível remover alguns desses bytes, mas, nesse caso, não tenho certeza se o Charcoal analisará o programa corretamente.) Transposto, 17 bytes:

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

Experimente online! Explicação: Muito parecido com o programa anterior, exceto pela adição do comando transpose ‖↗.

Eu tenho uma solução alternativa onde o programa original e o transposto são 18 bytes:

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

Experimente online! Explicação: Ａcomo acima;⊞υenvia um valor para a lista vazia predefinida (que não afeta a saída); ”yinicia uma sequência arbitrária (termina no final do programa ou na correspondência ”). Transposto:

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

Experimente online! Explicação: Ａ‖↗como acima; ⊞υcomo acima; a menor diferença aqui é que estou pressionando concatenações de cadeias menores, pois não quero repetir a ”.

Flacidez Cerebral (BrainHack) , 382 375 337 bytes

Sem comentários!

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

Experimente online!

Para a entrada, os dois primeiros números são as dimensões da matriz e o restante é o conteúdo da matriz. A saída é fornecida no mesmo formato.

Transposto

Brain-Flak (BrainHack) , 465 bytes

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

Experimente online!

Japonês , 2 bytes

ÕU

Experimente | Transposto

Õ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

Experimente online!

Melhorado com um layout diferente

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

Haskell ,153 144 bytes

(obrigado, Sriotchilism O'Zaic )

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

Experimente online!

Experimente transposto!

APL (Dyalog Unicode) , 7 bytes

{⍵
⍉
⍵}

Experimente online!

Transposto:

{⍉⍵
⍵ }

Provavelmente uma resposta bastante chata, mas de qualquer maneira aqui vai.

A definição da função embutida {...}pode abranger várias linhas. Nesse caso, cada linha é executada sequencialmente, mas qualquer linha sem uma atribuição ←retorna imediatamente seu valor calculado. Então a primeira função retorna ⍵enquanto a segunda retorna⍉⍵ .

Uma resposta ainda mais chata seria o abuso de comentários:

APL (Dyalog Unicode) , 4 bytes

⍝⍉
⊢

Nenhum TIO é necessário, eu acho ...

05AB1E , 3 bytes

øø
q

Experimente online.

øq
ø

Experimente transposto.

Explicação:

Ao contrário de alguns dos outros idiomas, as novas linhas são simplesmente ignoradas no 05AB1E, portanto, não acho que seja possível um byter de 2 bytes (embora eu adoraria provar que estou errado).

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

Experimente online!

Quadril para ser quadrado! (Quase)

Aceita matrizes ruby ​​como entrada (matrizes de matrizes)

Limpo , 64 bytes

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

Experimente online!

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

Experimente transposto!

Python 3 , 118 95 bytes

Entrada e resultado são listas de tuplas.

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

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

Experimente online!

Wolfram Language (Mathematica) , 13 bytes

#&(*
 *)
\

Experimente online! / Transposto

Cjam , 13 bytes

qo
~
z
`

Experimente online!

Versão transposta:

q~z`
o

Experimente online!

Formato de entrada

O formato de entrada é o formato padrão da matriz CJam: [[1 2] [3 4]]

Nenhuma versão de falha, 12 bytes

A versão normal falha após a impressão da matriz. Uma versão que não trava seria:

qo{
~
z
` };

Experimente online!

ou transposto:

q~z`
o
{  };

Experimente online!

Provavelmente existem alguns bytes extras que podem ser salvos. Trabalhei acidentalmente na versão transposta primeiro, o que levou a algumas quebras de linha extras e já faz muito tempo desde a última vez que usei o CJam. Quaisquer melhorias são bem-vindas.

Zsh , 75 bytes

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

$
#
s

TIO: Transposto normal

O lixo abaixo da impressão principal é inofensivo, imprime um erro ao encontrar uma nova linha após fa<e sai. 86 bytes para remover esse erro.

A versão transposta está aqui. Depois de imprimir, erros ao ver <no final de uma linha e sai.

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

Encantos Rúnicos , 88 bytes

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

$

Experimente online!
Experimente transposto!

A entrada é separada por espaço para cada valor e separada por vírgula para cada linha (novas linhas são opcionais) e suporta seqüências de caracteres e números (diferentes de zero). Isso facilita a análise da entrada, pois a entrada é interrompida automaticamente por espaços e novas linhas. Então, por exemplo, a entrada:

1 2 3 , 4 5 6 , 7 8 9

Seria representado em forma de matriz aninhada como [[1,2,3],[4,5,6],[7,8,9]] . Suporte mínimo para matrizes irregulares (apenas a última pode ser curta), mas como as entradas devem ser retangulares, isso atende a esse requisito.

A saída é representada no mesmo formato (a versão transposta sai com novas linhas, mas seus zero bytes são diferentes para usar um espaço). A versão normal possui um espaço à direita, a versão transposta possui uma vírgula à direita e uma nova linha (devido à dificuldade de determinar quando não há mais dados para imprimir).

A versão normal possui caracteres modificadores em lugares estranhos (por exemplo, 7̸0 ), mas isso se deve à necessidade deles no lugar certo quando a fonte é transposta e a execução normal utiliza apenas a coluna de instruções à esquerda.

Explicação

A explicação da fonte transposta será em uma forma não transposta. As setas representam a direcionalidade de IP na entrada e saída de vários blocos.

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

A entrada é lida e, quando um ,caractere é encontrado, uma nova sub-pilha é enviada. Isso permite que cada pilha mantenha cada linha separadamente na memória. Entra na próxima seção a partir do topo.

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

[0(executado à esquerda) configura uma pilha vazia para atuar como um limite entre a primeira linha e a última linha e depois gira para a primeira pilha ( {̹) e inicia a impressão de elementos e pilhas rotativas. O i!não é executado e {̹L [0ré executado apenas uma vez. Quando uma pilha de tamanho zero é encontrada, o loop sai.

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

Quando a pilha vazia é encontrada, a ,e newline são impressas e o loop de valor é digitado novamente. Ordem de execução (espelhado para facilitar a leitura), onde .é um comando executado-un: \',$!.6ak$?....../. Alterar akpara '<space>imprimir espaços em vez de novas linhas.

A execução é interrompida quando o programa tenta gravar de uma pilha vazia; é por isso que apenas a irregularidade da última linha funciona corretamente e por que há um rastro ,na saída: a vírgula já foi impressa antes que o programa saiba que não há mais dados.