Arnaque d'une arnaque d'une arnaque d'une arnaque . Allez upvote ceux-ci!

Votre tâche, si vous souhaitez l'accepter, est d'écrire un programme / une fonction qui génère / renvoie son entrée / argument¹. La partie délicate est que si je transpose votre code source², la sortie / résultat doit également être transposé.

1. Vous pouvez choisir le type de données 2D que votre solution peut accepter. Par exemple, une liste de listes, une matrice, une liste de chaînes, etc. Indiquez celle (s) qu'elle gère. Vous pouvez supposer que l'entrée sera toujours rectangulaire et aura une longueur de 1 ou plus le long de chaque dimension.

2. Aux fins de la transposition, les lignes courtes de votre code source seront considérées comme remplies d'espaces de fin jusqu'à ce qu'elles soient rectangulaires, cependant, ces espaces de fin remplis ne contribuent pas à la longueur de votre code.

Puisqu'il s'agit de code-golf , l'objectif est d'optimiser le nombre d'octets du code source d'origine (pas la version transposée).

Exemples

Disons que votre solution prend une matrice numérique et que votre code source est

AB
DEF

et son entrée / argument est [[1,2],[3,4],[5,6]]. Si j'écris

AD
BE
 F

au lieu de cela et exécutez-le, la sortie / résultat doit être [[1,3,5],[2,4,6]].

Imaginons que votre solution prenne une chaîne séparée par des sauts de ligne et que votre code source soit

ABC

et son entrée / argument est "96\n". Si j'écris

A
B
C

au lieu de cela et exécutez-le, la sortie / résultat doit être "9\n6\n".

Python 3 + numpy, 45 octets

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

Essayez-le en ligne!

Merci à @EriktheOutgolfer de signaler un bug de la version précédente

Transposé:

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

Essayez-le en ligne!

Les fonctions prennent une matrice numpy en entrée et produisent une matrice numpy. La solution ne repose pas sur les commentaires comme le font de nombreuses autres solutions, mais exploite à la place des chaînes multi-lignes.

Gelée , 2 octets

L'entrée est une liste de listes. Merci à Luis Mendo et Nick Kennedy d'avoir amélioré la réponse.

ZZ

Essayez-le en ligne! Essayez-le transposé!

Le programme transpose l'entrée deux fois, renvoyant l'entrée d'origine. La version transposée ignore la première ligne et ne transpose qu'une seule fois.

R , 5 4 octets

#t
I

Essayez-le en ligne!

Une fonction R, soit la fonction d'identité, soit la fonction de Itransposition tlorsqu'elle est transposée. Le pied de page sur TIO affiche la sortie des deux.

Merci à @RobinRyder d'avoir enregistré un octet!

C (gcc) , 209 205 203 201 octets

Ordinaire

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

Essayez-le en ligne!

Transposée

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

Essayez-le en ligne!

Haskell , 51 octets

Cette version est valide, mais ne s'arrêtera pas lorsqu'elle sera donnée []en entrée.

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

Essayez-le en ligne!

Transposé, 75 octets

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

Essayez-le en ligne!

Haskell , 51 octets

Cette version est valide, mais se bloque avec []comme entrée pour la version transposée.

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

Essayez-le en ligne! Transposée

Haskell , 75 67 57 octets

Au moins 7 octets économisés grâce à Ørjan Johansen

Cette version sort []lorsqu'elle est donnée []en entrée.

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

Essayez-le en ligne!

Transposée

Python 3 , 51 octets

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

Essayez-le en ligne!

Basé sur l'approche de Joel . L'entrée est un tuplede tuples, et la sortie est un zip(converti en un tupleover TIO pour une meilleure visibilité).

Transposé:

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

Essayez-le en ligne!

Perl 6 , 20 11 octets

#&
*[
#Z
 ]

Essayez-le en ligne!

Transposée

#*# 
&[Z]

Essayez-le en ligne!

Les deux fonctions fonctionnent sur une liste de listes.

*[ ] est un WwhatCode renvoyant la tranche zen de son argument, en fait la fonction d'identité.

&[Z] est l'opérateur zip.

Haskell, 185 161 octets

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
 )

Essayez-le en ligne!

Transposé:

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

Essayez-le en ligne!

Pas de commentaires, pas de littéraux de chaîne, juste quelques définitions de fonctions supplémentaires.

Edit: -24 octets grâce à @ Ørjan Johansen.

PHP (7.4), 114 86 70 octets

Ma toute première expérience à faire quelque chose comme ça en PHP, il doit y avoir une meilleure façon que je ne peux pas voir! L'entrée est un tableau de tableaux comme [[1,2],[3,4],[5,6]].

Ordinaire:

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

Essayez-le en ligne!

Transposée (espace rembourré):

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

Essayez-le en ligne!

Fusain , 19 octets

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

Essayez-le en ligne! Prend l'entrée comme un tableau de chaînes. Explication: Ａimprime implicitement l'entrée explicite, tandis que ¿⁰est un conditionnel, avec 0comme condition, qui est donc toujours fausse. «démarre alors un bloc de code Charcoal vide de sens qui n'est jamais exécuté. (Il pourrait être possible de supprimer certains de ces octets mais dans ce cas, je ne sais pas si Charcoal analyserait correctement le programme.) Transposé, 17 octets:

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

Essayez-le en ligne! Explication: à peu près la même chose que le programme précédent, à l'exception de l'ajout de la commande transpose ‖↗.

J'ai une solution alternative où le programme original et le programme transposé font 18 octets:

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

Essayez-le en ligne! Explication: Ａcomme ci-dessus; ⊞υenvoie une valeur à la liste vide prédéfinie (ce qui n'affecte pas la sortie); ”ycommence une chaîne arbitraire (se termine à la fin du programme ou de la correspondance ”). Transposé:

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

Essayez-le en ligne! Explication: Ａ‖↗comme ci-dessus; ⊞υcomme ci-dessus; la petite différence ici est que je pousse les concaténations de petites cordes, car je ne veux pas répéter le ”.

Brain-Flak (BrainHack) , 382 375 337 octets

Sans commentaires!

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

Essayez-le en ligne!

Pour l'entrée, les deux premiers nombres sont les dimensions de la matrice et le reste est le contenu de la matrice. La sortie est donnée dans le même format.

Transposée

Brain-Flak (BrainHack) , 465 octets

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

Essayez-le en ligne!

Japt , 2 octets

ÕU

Essayez-le | Transposée

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

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

Essayez-le en ligne!

Amélioré avec une disposition différente

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

Haskell ,153 144 octets

(merci, Sriotchilism O'Zaic )

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

Essayez-le en ligne!

Essayez-le transposé!

APL (Dyalog Unicode) , 7 octets

{⍵
⍉
⍵}

Essayez-le en ligne!

Transposé:

{⍉⍵
⍵ }

Probablement une réponse plutôt ennuyeuse, mais de toute façon ça y est.

La définition de la fonction en ligne {...}peut s'étendre sur plusieurs lignes. Dans ce cas, chaque ligne est exécutée séquentiellement, mais toute ligne sans affectation ←renvoie immédiatement sa valeur calculée. Ainsi, la première fonction revient ⍵tandis que la seconde revient ⍉⍵.

Une réponse encore plus ennuyeuse serait l'abus de commentaire:

APL (Dyalog Unicode) , 4 octets

⍝⍉
⊢

Aucun TIO n'est nécessaire, je suppose ...

05AB1E , 3 octets

øø
q

Essayez-le en ligne.

øq
ø

Essayez-le transposé.

Explication:

Contrairement à certaines autres langues, les sauts de ligne sont simplement ignorés dans 05AB1E, donc je ne pense pas qu'un 2-byter soit possible (même si j'adorerais me tromper).

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

Rubis , 35 octets

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

Essayez-le en ligne!

Hanche pour être carré! (Presque)

Accepte les matrices rubis en entrée (tableaux de tableaux)

Nettoyer , 64 octets

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

Essayez-le en ligne!

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

Essayez-le transposé!

Python 3 , 118 95 octets

L'entrée et le résultat sont des listes de tuples.

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

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

Essayez-le en ligne!

Wolfram Language (Mathematica) , 13 octets

#&(*
 *)
\

Essayez-le en ligne! / Transposé

Cjam , 13 octets

qo
~
z
`

Essayez-le en ligne!

Version transposée:

q~z`
o

Essayez-le en ligne!

Format d'entrée

Le format d'entrée est le format de tableau CJam standard: [[1 2] [3 4]]

Pas de version crash, 12 octets

La version normale se bloque après l' impression du tableau. Une version qui ne plante pas serait:

qo{
~
z
` };

Essayez-le en ligne!

ou transposé:

q~z`
o
{  };

Essayez-le en ligne!

Il y a probablement quelques octets supplémentaires qui peuvent être enregistrés, j'ai accidentellement travaillé sur la version transposée en premier, ce qui a conduit à quelques sauts de ligne supplémentaires et cela fait longtemps que je n'ai pas utilisé CJam pour la dernière fois. Toutes les améliorations sont les bienvenues.

Zsh , 75 octets

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

$
#
s

TIO: Normal Transposed

La poubelle sous l'impression principale est inoffensive, elle imprime une erreur lors de la rencontre d'une nouvelle ligne après fa<et se termine. 86 octets pour supprimer cette erreur.

La version transposée est ici. Après l'impression, il affiche des erreurs en voyant <à la fin d'une ligne et quitte.

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

Enchantements runiques , 88 octets

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

$

Essayez-le en ligne!
Essayez-le transposé!

L'entrée est séparée par des espaces pour chaque valeur et séparée par des virgules pour chaque ligne (les retours à la ligne sont facultatifs) et prend en charge les chaînes et les nombres (non nuls). Cela facilite l'analyse de l'entrée car elle est automatiquement interrompue par des espaces et des sauts de ligne. Ainsi, par exemple, l'entrée:

1 2 3 , 4 5 6 , 7 8 9

Serait représenté sous forme de tableau imbriqué comme [[1,2,3],[4,5,6],[7,8,9]]. Prise en charge minimale des tableaux irréguliers (seul le dernier peut être court), mais comme les entrées devraient être rectangulaires, cela satisfait cette exigence.

La sortie est représentée dans le même format (la version transposée sort avec des sauts de ligne, mais ses zéro octets sont différents pour utiliser un espace à la place). La version normale a un espace de fin, la version transposée a une virgule de fin et une nouvelle ligne (en raison de la difficulté à déterminer quand il n'y a plus de données à imprimer).

La version normale a des caractères modificateurs dans des endroits étranges (par exemple 7̸0), mais cela est dû au fait qu'ils en ont besoin au bon endroit lorsque la source est transposée et que l'exécution normale utilise uniquement la colonne d'instructions la plus à gauche.

Explication

L'explication de la source transposée se fera sous une forme non transposée. Les flèches représenteront la directionnalité IP à l'entrée et à la sortie de divers blocs.

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

L'entrée est lue et lorsqu'un ,caractère est trouvé, une nouvelle sous-pile est poussée. Cela permet à chaque pile de conserver chaque ligne séparément en mémoire. Entre dans la section suivante par le haut.

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

[0(exécuté vers la gauche) définit une pile vide pour servir de frontière entre la première et la dernière ligne, puis pivote vers la première pile ( {̹) et démarre l'impression des éléments et la rotation des piles. Le i!n'est pas exécuté et {̹L [0rn'est exécuté qu'une seule fois. Lorsqu'une pile de taille nulle est trouvée, la boucle se ferme.

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

Lorsque la pile vide est trouvée, un ,et une nouvelle ligne sont imprimés et la boucle de valeur est à nouveau saisie. Ordre d'exécution ( en miroir pour une meilleure lisibilité) où .est une commande exécutée non: \',$!.6ak$?....../. Changer akpour '<space>imprimerait des espaces au lieu de nouvelles lignes.

L'exécution s'arrête lorsque le programme tente d'écrire à partir d'une pile vide; c'est pourquoi seul le jagginess de dernière ligne fonctionne correctement et pourquoi il y a une fin ,dans la sortie: la virgule a déjà été imprimée avant que le programme ne sache qu'il n'y a plus de données.