Rip-off của một rip-off của một rip-off của một rip-off . Đi lên những người!

Nhiệm vụ của bạn, nếu bạn muốn chấp nhận nó, là viết một chương trình / hàm xuất / trả về đầu vào / đối số của nó¹. Phần khó khăn là nếu tôi hoán đổi mã nguồn của bạn², đầu ra / kết quả cũng phải được chuyển đổi.

1. Bạn có thể chọn loại dữ liệu 2D mà giải pháp của bạn có thể chấp nhận. Ví dụ: danh sách các danh sách, ma trận, danh sách các chuỗi, v.v. Bạn có thể giả định rằng đầu vào sẽ luôn là hình chữ nhật và sẽ có độ dài từ 1 trở lên dọc theo mỗi chiều.

2. Đối với mục đích chuyển vị, các dòng ngắn trong mã nguồn của bạn sẽ được coi là được đệm với các khoảng trắng ở cuối cho đến khi nó là hình chữ nhật, tuy nhiên, các khoảng trắng được đệm này không đóng góp vào chiều dài mã của bạn.

Vì đây là môn đánh gôn , mục tiêu là tối ưu hóa số byte của mã nguồn gốc (không phải phiên bản chuyển đổi).

Ví dụ

Giả sử giải pháp của bạn có ma trận số và mã nguồn của bạn là

AB
DEF

và đầu vào / đối số của nó là [[1,2],[3,4],[5,6]]. Nếu tôi viết

AD
BE
 F

thay vào đó và chạy nó, đầu ra / kết quả phải được [[1,3,5],[2,4,6]].

Giả sử giải pháp của bạn có một chuỗi được phân tách bằng nguồn cấp dữ liệu và mã nguồn của bạn là

ABC

và đầu vào / đối số của nó là "96\n". Nếu tôi viết

A
B
C

thay vào đó và chạy nó, đầu ra / kết quả phải được "9\n6\n".

Python 3 + gọn gàng, 45 byte

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

Hãy thử trực tuyến!

Cảm ơn @EriktheOutgolfer đã chỉ ra một lỗi của phiên bản trước

Chuyển đổi:

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

Hãy thử trực tuyến!

Các hàm lấy một ma trận numpy làm đầu vào và đầu ra một ma trận numpy. Giải pháp không dựa vào nhận xét như nhiều giải pháp khác làm mà thay vào đó khai thác chuỗi nhiều dòng.

Thạch , 2 byte

Đầu vào là một danh sách các danh sách. Cảm ơn Luis Mendo và Nick Kennedy đã cải thiện câu trả lời.

ZZ

Hãy thử trực tuyến! Hãy thử chuyển đổi!

Chương trình chuyển đổi đầu vào hai lần, trả về đầu vào ban đầu. Phiên bản chuyển đổi bỏ qua dòng đầu tiên và chỉ chuyển đổi một lần.

R , 5 4 byte

#t
I

Hãy thử trực tuyến!

Hàm R, hoặc hàm nhận dạng I hoặc hàm hoán vịt chuyển vị khi chuyển vị. Footer trên TIO hiển thị đầu ra của cả hai.

Cảm ơn @RobinRyder vì đã tiết kiệm một byte!

C (gcc) , 209 205 203 201 byte

Bình thường

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

Hãy thử trực tuyến!

Chuyển

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

Hãy thử trực tuyến!

Haskell , 51 byte

Phiên bản này hợp lệ, nhưng sẽ không dừng lại khi được đưa []vào làm đầu vào.

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

Hãy thử trực tuyến!

Chuyển đổi, 75 byte

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

Hãy thử trực tuyến!

Haskell , 51 byte

Phiên bản này là hợp lệ, nhưng gặp sự cố với []đầu vào cho phiên bản được chuyển đổi.

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

Hãy thử trực tuyến! Chuyển

Haskell , 75 67 57 byte

Ít nhất 7 byte được lưu nhờ rjan Johansen

Phiên bản này xuất ra []khi được đưa ra []làm đầu vào.

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

Hãy thử trực tuyến!

Chuyển

Python 3 , 51 byte

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

Hãy thử trực tuyến!

Dựa trên phương pháp của Joel . Đầu vào là một tupletrong tuples, và đầu ra là một zip(chuyển đổi sang mộttuple trong TIO cho tầm nhìn tốt hơn).

Chuyển đổi:

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

Hãy thử trực tuyến!

Perl 6 , 20 11 byte

#&
*[
#Z
 ]

Hãy thử trực tuyến!

Chuyển

#*# 
&[Z]

Hãy thử trực tuyến!

Cả hai chức năng làm việc trên danh sách các danh sách.

*[ ] là một AnyCode trả về lát zen của đối số của nó, có hiệu quả là hàm nhận dạng.

&[Z] là toán tử zip.

Haskell, 185 161 byte

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
 )

Hãy thử trực tuyến!

Chuyển đổi:

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

Hãy thử trực tuyến!

Không có bình luận, không có chuỗi ký tự, chỉ một số định nghĩa hàm bổ sung.

Chỉnh sửa: -24 byte nhờ @ janrjan Johansen.

PHP (7.4), 114 86 70 byte

Trải nghiệm đầu tiên của tôi khi làm một cái gì đó như thế này trong PHP, phải có một cách tốt hơn mà tôi không thể thấy! Đầu vào là một mảng các mảng như [[1,2],[3,4],[5,6]].

Bình thường:

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

Hãy thử trực tuyến!

Transposed (đệm không gian):

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

Hãy thử trực tuyến!

Than , 19 byte

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

Hãy thử trực tuyến! Đưa đầu vào như một mảng của chuỗi. Giải thích: Ａin ngầm định đầu vào rõ ràng, trong khi ¿⁰là một điều kiện, với 0điều kiện, do đó luôn luôn là sai. «sau đó bắt đầu một khối mã Char than vô nghĩa không bao giờ được thực thi. (Có thể xóa một số byte đó nhưng trong trường hợp đó tôi không chắc liệu Char than có phân tích chương trình chính xác hay không.) Transposed, 17 byte:

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

Hãy thử trực tuyến! Giải thích: Giống như chương trình trước, ngoại trừ việc bổ sung lệnh chuyển vị ‖↗.

Tôi có một giải pháp thay thế trong đó cả chương trình gốc và chương trình chuyển đổi là 18 byte:

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

Hãy thử trực tuyến! Giải thích: Ａnhư trên; ⊞υđẩy một giá trị vào danh sách trống được xác định trước (không ảnh hưởng đến đầu ra); ”ybắt đầu một chuỗi tùy ý (kết thúc ở cuối chương trình hoặc khớp ”). Chuyển đổi:

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

Hãy thử trực tuyến! Giải thích: Ａ‖↗như trên; ⊞υnhư trên; sự khác biệt nhỏ ở đây là tôi đang đẩy các chuỗi nhỏ hơn, vì tôi không muốn lặp lại ”.

Brain-Flak (BrainHack) , 382 375 337 byte

Miễn bình luận!

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

Hãy thử trực tuyến!

Đối với đầu vào, hai số đầu tiên là kích thước của ma trận và phần còn lại là nội dung của ma trận. Đầu ra được đưa ra trong cùng một định dạng.

Chuyển

Brain-Flak (BrainHack) , 465 byte

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

Hãy thử trực tuyến!

Japt , 2 byte

ÕU

Hãy thử nó | Chuyển

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

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

Hãy thử trực tuyến!

Cải thiện với bố cục khác

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

Haskell ,153 144 byte

(cảm ơn, Sriotchilism O'Z cổ )

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

Hãy thử trực tuyến!

Hãy thử nó chuyển!

APL (Dyalog Unicode) , 7 byte

{⍵
⍉
⍵}

Hãy thử trực tuyến!

Chuyển đổi:

{⍉⍵
⍵ }

Có lẽ là một câu trả lời khá nhàm chán, nhưng dù sao ở đây nó đi.

Định nghĩa hàm nội tuyến {...}có thể trải rộng trên nhiều dòng. Trong trường hợp này, mỗi dòng được thực hiện tuần tự, nhưng bất kỳ dòng nào không có phép gán ←ngay lập tức trả về giá trị tính toán của nó. Vì vậy, hàm đầu tiên trả về ⍵trong khi hàm thứ hai trả về⍉⍵ .

Câu trả lời thậm chí nhàm chán hơn sẽ là lạm dụng bình luận:

APL (Dyalog Unicode) , 4 byte

⍝⍉
⊢

Không cần TIO, tôi đoán ...

05AB1E , 3 byte

øø
q

Hãy thử trực tuyến.

øq
ø

Hãy thử nó chuyển.

Giải trình:

Không giống như một số ngôn ngữ khác, các dòng mới chỉ bị bỏ qua trong 05AB1E, vì vậy tôi không nghĩ rằng có thể sử dụng 2-byter (mặc dù tôi rất muốn được chứng minh là sai).

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

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

Hãy thử trực tuyến!

Hông phải vuông! (Hầu hết)

Chấp nhận ma trận ruby ​​làm đầu vào (mảng của mảng)

Sạch sẽ , 64 byte

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

Hãy thử trực tuyến!

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

Hãy thử nó chuyển!

Con trăn 3 , 118 95 byte

Đầu vào và kết quả là danh sách các bộ dữ liệu.

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

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

Hãy thử trực tuyến!

Ngôn ngữ Wolfram (Mathicala) , 13 byte

#&(*
 *)
\

Hãy thử trực tuyến! / Chuyển

Cjam , 13 byte

qo
~
z
`

Hãy thử trực tuyến!

Phiên bản chuyển đổi:

q~z`
o

Hãy thử trực tuyến!

định dạng đầu vào

Định dạng đầu vào là định dạng mảng CJam tiêu chuẩn: [[1 2] [3 4]]

Không có phiên bản sự cố, 12 byte

Phiên bản bình thường gặp sự cố sau khi in mảng. Một phiên bản không bị sập sẽ là:

qo{
~
z
` };

Hãy thử trực tuyến!

hoặc chuyển đổi:

q~z`
o
{  };

Hãy thử trực tuyến!

Có lẽ có một vài byte bổ sung có thể được lưu, tôi đã làm việc trên phiên bản chuyển đổi đầu tiên, điều này dẫn đến một vài ngắt dòng bổ sung và đã lâu tôi mới sử dụng CJam. Bất kỳ cải tiến đều được chào đón.

Zsh , 75 byte

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

$
#
s

TIO: Chuyển đổi bình thường

Rác bên dưới bản in chính là vô hại, nó in một lỗi khi gặp một dòng mới sau fa<và thoát. 86 byte để loại bỏ lỗi đó.

Phiên bản chuyển đổi là đây. Sau khi in, nó gặp lỗi khi nhìn thấy <ở cuối dòng và thoát.

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

Runic bùa mê , 88 byte

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

$

Hãy thử trực tuyến!
Hãy thử chuyển đổi!

Đầu vào là không gian được phân tách cho từng giá trị và dấu phẩy được phân tách cho mỗi hàng (dòng mới là tùy chọn) và hỗ trợ cả chuỗi và số (khác không). Điều này làm cho việc phân tích cú pháp đầu vào dễ dàng hơn vì đầu vào tự động bị phá vỡ bởi khoảng trắng và dòng mới. Vì vậy, ví dụ, đầu vào:

1 2 3 , 4 5 6 , 7 8 9

Sẽ được biểu diễn dưới dạng mảng lồng nhau như [[1,2,3],[4,5,6],[7,8,9]] . Hỗ trợ tối thiểu cho các mảng lởm chởm (chỉ cái cuối cùng có thể ngắn), nhưng vì đầu vào dự kiến ​​là hình chữ nhật, điều này đáp ứng yêu cầu đó.

Đầu ra được biểu diễn ở cùng định dạng (phiên bản đầu ra được chuyển đổi với dòng mới, nhưng các byte bằng 0 của nó khác nhau để sử dụng khoảng trắng thay thế). Phiên bản bình thường có không gian dấu, phiên bản chuyển đổi có dấu phẩy và dòng mới (do khó xác định khi không có thêm dữ liệu để in).

Phiên bản bình thường không có ký tự sửa đổi ở những nơi kỳ lạ (ví dụ. 7̸0 ), nhưng điều này là do cần chúng ở đúng vị trí khi nguồn được chuyển đổi và việc thực thi bình thường chỉ sử dụng cột hướng dẫn ngoài cùng bên trái.

Giải trình

Giải thích về nguồn chuyển đổi sẽ ở dạng không chuyển đổi. Mũi tên sẽ đại diện cho hướng IP ở lối vào và lối ra của các khối khác nhau.

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

Đầu vào được đọc và khi ,tìm thấy một ký tự, một khối phụ mới được đẩy. Điều này cho phép mỗi ngăn xếp giữ từng hàng riêng biệt trong bộ nhớ. Nhập phần tiếp theo từ đầu.

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

[0(thực hiện bên trái) thiết lập một ngăn xếp trống để hoạt động như một ranh giới giữa hàng đầu tiên và hàng cuối cùng và sau đó xoay sang ngăn xếp đầu tiên ( {̹) và bắt đầu in các phần tử và ngăn xếp xoay. Không i!được thực hiện và{̹L [0r chỉ được thực hiện một lần. Khi tìm thấy ngăn xếp có kích thước bằng không, vòng lặp sẽ thoát.

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

Khi tìm thấy ngăn xếp trống, a ,và dòng mới được in và vòng lặp giá trị được nhập lại. Lệnh thực thi (được nhân đôi để dễ đọc) trong đó .là lệnh chưa được thực thi : \',$!.6ak$?....../. Thay đổiak thành '<space>in không gian thay vì dòng mới.

Việc thực thi tạm dừng khi chương trình cố gắng ghi từ một ngăn xếp trống; đây là lý do tại sao chỉ có jagginess hàng cuối hoạt động chính xác và tại sao có dấu vết ,ở đầu ra: dấu phẩy đã được in trước khi chương trình biết rằng không còn dữ liệu nữa.