敲竹杠一个的敲竹杠一个的敲竹杠一个的敲竹杠。去投票那些！

您的任务（如果希望接受）是编写一个程序/函数，该程序输出/返回其输入/参数¹。棘手的部分是，如果我转置您的源代码²，那么输出/结果也必须转置。

1. 您可以选择解决方案可以接受的2D数据类型。例如，列表列表，矩阵，字符串列表等。说明要处理的列表。您可以假设输入将始终为矩形，并且每个尺寸的长度为1或更大。

2. 为了进行转置，源代码中的短行将被视为用尾随空格填充，直到它变成矩形为止，但是，这些尾随空格不会影响您的代码长度。

由于这是代码高尔夫，因此目标是优化原始源代码（而不是转置版本）的字节数。

例子

假设您的解决方案采用数字矩阵，而您的源代码为

AB
DEF

其输入/参数为[[1,2],[3,4],[5,6]]。如果我写

AD
BE
 F

而是运行它，输出/结果必须为[[1,3,5],[2,4,6]]。

假设您的解决方案采用换行符分隔的字符串，而您的源代码为

ABC

其输入/参数为"96\n"。如果我写

A
B
C

而是运行它，输出/结果必须为"9\n6\n"。

Python 3 + numpy，45个字节

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

在线尝试！

感谢@EriktheOutgolfer指出先前版本的错误

转置：

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

在线尝试！

这些函数以一个numpy矩阵作为输入并输出一个numpy矩阵。该解决方案不像许多其他解决方案那样依赖注释，而是利用多行字符串。

果冻，2个字节

输入是列表列表。感谢Luis Mendo和Nick Kennedy改善了答案。

ZZ

在线尝试！ 尝试换位！

程序对输入进行两次移置，返回原始输入。转置版本忽略第一行，仅转置一次。

R，5 4字节

#t
I

在线尝试！

R函数，即I转置t时的标识函数或转置函数。TIO上的页脚显示了两者的输出。

感谢@RobinRyder节省了一个字节！

C（GCC） ，209个 205 203 201字节

正常

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

在线尝试！

转置

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

在线尝试！

Haskell，51个字节

此版本有效，但在[]作为输入提供时不会停止。

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

在线尝试！

转置，75字节

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

在线尝试！

Haskell，51个字节

此版本有效，但会以[]转置版本的输入崩溃。

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

在线尝试！ 转置

Haskell，75 67 57字节

ØrjanJohansen节省了至少7个字节

[]当[]作为输入给出时，此版本输出。

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

在线尝试！

转置

Python 3，51个字节

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

在线尝试！

基于Joel的方法。输入是a tuple的tuples，输出是a zip（转换为tupleover TIO以获得更好的可见性）。

转置：

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

在线尝试！

Perl 6的，20 11个字节

#&
*[
#Z
 ]

在线尝试！

转置

#*# 
&[Z]

在线尝试！

这两个功能都在列表列表上起作用。

*[ ] 是一个WhateverCode，它返回其参数的zen切片，有效地是恒等函数。

&[Z] 是zip运算符。

Haskell，185161字节

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
 )

在线尝试！

转置：

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

在线尝试！

没有注释，没有字符串文字，只有一些附加的函数定义。

编辑：-24个字节，感谢@ØrjanJohansen。

PHP（7.4），114 86 70字节

我第一次在PHP中执行类似操作的经验，一定有更好的方法让我看不到！输入是类似的数组的数组[[1,2],[3,4],[5,6]]。

正常：

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

在线尝试！

转置（填充空格）：

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

在线尝试！

木炭，19字节

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

在线尝试！将输入作为字符串数组。说明：作为条件，Ａ隐式打印显式输入，¿⁰条件0为，因此始终为false。«然后启动一个永远不会执行的无意义的木炭代码块。（可能可以删除其中一些字节，但是在那种情况下，我不确定木炭是否会正确解析程序。）转置后的17个字节：

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

在线尝试！说明：除了添加了transpose命令之外，它与先前的程序几乎相同‖↗。

我有一个替代解决方案，其中原始程序和转置程序均为18个字节：

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

在线尝试！说明：Ａ同上；⊞υ将值推送到预定义的空列表（不影响输出）；”y开始一个任意字符串（在程序结尾或match结束”）。转置：

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

在线尝试！说明：Ａ‖↗同上；⊞υ如上; 此处的次要区别是，我要推送较小字符串的串联，因为我不想重复”。

脑高射炮（BrainHack） ，382个 375 337字节

没意见！

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

在线尝试！

对于输入，前两个数字是矩阵的维数，其余的是矩阵的内容。输出以相同格式给出。

转置

Brain-Flak（BrainHack），465字节

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

在线尝试！

Japt，2 个字节

ÕU

试试吧 | 转置

Õ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字节

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

在线尝试！

改进了其他布局

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

哈斯克尔，153 144字节

（感谢Sriotchilism O'Zaic）

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

在线尝试！

尝试换位！

APL（Dyalog Unicode），7个字节

{⍵
⍉
⍵}

在线尝试！

转置：

{⍉⍵
⍵ }

可能是一个很无聊的答案，但无论如何，它都会成功。

内联函数定义{...}可以跨越多行。在这种情况下，每行将被顺序执行，但是任何没有赋值的行将←立即返回其计算值。因此，第一个函数返回，⍵而第二个函数返回⍉⍵。

更无聊的答案将是评论滥用：

APL（Dyalog Unicode），4个字节

⍝⍉
⊢

我想不需要TIO。

05AB1E，3 个字节

øø
q

在线尝试。

øq
ø

尝试换位。

说明：

与其他一些语言不同，换行符在05AB1E中只是被忽略，因此我认为2乘以法是不可能的（尽管我希望证明自己是错误的）。

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

红宝石，35字节

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

在线尝试！

臀部要方形！（几乎）

接受红宝石矩阵作为输入（数组的数组）

干净，64字节

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

在线尝试！

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

尝试换位！

Python 3中，118个 95字节

输入和结果是元组列表。

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

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

在线尝试！

Wolfram语言（Mathematica），13个字节

#&(*
 *)
\

在线尝试！/ 转置

Cjam，13个字节

qo
~
z
`

在线尝试！

转置版本：

q~z`
o

在线尝试！

输入格式

输入格式是标准的CJam数组格式： [[1 2] [3 4]]

没有崩溃版本，12字节

普通版本在打印阵列后崩溃。不会崩溃的版本是：

qo{
~
z
` };

在线尝试！

或转置：

q~z`
o
{  };

在线尝试！

可能还有一些额外的字节可以保存，我不小心首先处理了转置版本，这导致了一些额外的换行符，距离我上次使用CJam已有很长时间了。欢迎任何改进。

Zsh，75个字节

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

$
#
s

TIO：正常 移调

主打印下方的垃圾是无害的，在之后遇到换行符fa<并退出时将打印错误。86个字节来消除该错误。

转置版本在这里。打印后，看到<行末错误并退出。

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

符文附魔，88字节

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

$

在线尝试！
尝试换位！

输入是空间分离的每个值和逗号分隔的每一行（换行是可选的），并支持两个字符串和（非零）的数字。由于输入会被空格和换行符自动打断，因此解析输入变得更加容易。因此，例如，输入：

1 2 3 , 4 5 6 , 7 8 9

将以嵌套数组形式表示为[[1,2,3],[4,5,6],[7,8,9]]。对锯齿状数组的支持最少（仅最后一个可以短），但是由于预期输入为矩形，因此可以满足该要求。

输出以相同格式表示（换位版本输出带换行符，但其零字节不同，以代替空格）。普通版本具有尾随空格，转置版本具有尾随逗号和换行符（由于难以确定何时没有更多数据可打印）。

普通版本的确在怪异的位置（例如7̸0）有修饰符，但这是由于在对源进行转置时需要将它们放在正确的位置，并且正常执行仅利用指令的最左列。

说明

转置源的说明将为非转置形式。箭头将代表各个块的入口和出口处的IP方向性。

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

读取输入，,找到字符后，将推送新的子堆栈。这允许每个堆栈将每一行分别保存在内存中。从顶部进入下一部分。

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

[0（向左执行）设置一个空堆栈作为第一行和最后一行之间的边界，然后旋转到第一堆栈（{̹），开始打印元素和旋转堆栈。在i!不执行，{̹L [0r只执行一次。找到零大小的堆栈时，循环退出。

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

找到空堆栈后，,将打印a 和换行符，并重新输入value循环。执行顺序（出于可读性而镜像）.是未执行的命令：\',$!.6ak$?....../。更改ak为'<space>会打印空格而不是换行符。

当程序尝试从空堆栈进行写入时，执行将停止；这就是为什么只有最后一行的锯齿才能正确工作的原因,，并且输出中会有尾随的原因：在程序知道没有更多数据之前，逗号已经被打印了。