rip-offของrip-offของrip-offของrip-off ลงคะแนนโหวตเหล่านั้น!

งานของคุณถ้าคุณต้องการที่จะยอมรับมันคือการเขียนโปรแกรม / ฟังก์ชั่นที่เอาต์พุต / ส่งกลับอินพุต / อาร์กิวเมนต์¹ ส่วนที่ยุ่งยากคือถ้าฉันแปลงรหัสต้นฉบับ²ของคุณผลลัพธ์ / ผลก็ต้องถูกเปลี่ยนเช่นกัน

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 + จำนวน, 45 ไบต์

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

ลองออนไลน์!

ขอบคุณ @EriktheOutgolfer ที่ชี้จุดบกพร่องของรุ่นก่อนหน้า

ย้าย:

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

ลองออนไลน์!

ฟังก์ชั่นใช้ numpy matrix เป็นอินพุทและเอาท์พุท numpy matrix โซลูชันไม่พึ่งพาข้อคิดเห็นเช่นเดียวกับโซลูชันอื่น ๆ แต่จะใช้ประโยชน์จากสตริงหลายบรรทัดแทน

เยลลี่ 2 ไบต์

อินพุตเป็นรายการของรายการ ขอบคุณ Luis Mendo และ Nick Kennedy สำหรับการปรับปรุงคำตอบ

ZZ

ลองออนไลน์! ลองเปลี่ยนเป็น!

โปรแกรมแปลงสัญญาณอินพุตสองครั้งเพื่อคืนค่าอินพุตดั้งเดิม เวอร์ชันที่ถูกข้ามจะละเว้นบรรทัดแรกและโอนย้ายเพียงครั้งเดียว

R , 5 4 ไบต์

#t
I

ลองออนไลน์!

ฟังก์ชั่น R ทั้งฟังก์ชั่นเอกลักษณ์Iหรือฟังก์ชั่นขนย้ายtขนย้ายเมื่อย้าย Footer on 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

ลองออนไลน์!

transposed, 75 ไบต์

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

ลองออนไลน์!

Haskell , 51 ไบต์

รุ่นนี้ถูกต้อง แต่ขัดข้องด้วย[]เป็นอินพุตสำหรับเวอร์ชัน transposed

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

ลองออนไลน์! ขนย้าย

Haskell , 75 67 57 ไบต์

บันทึกอย่างน้อย 7 ไบต์ต้องขอบคุณØrjan Johansen

รุ่นนี้ส่งออก[]เมื่อได้รับ[]เป็นอินพุต

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

ลองออนไลน์!

ขนย้าย

Python 3 , 51 ไบต์

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

ลองออนไลน์!

ขึ้นอยู่กับวิธีการของโจเอล อินพุตเป็นtupleของtuples และเอาต์พุตคือzip(แปลงเป็นtupleover TIO เพื่อการมองเห็นที่ดีขึ้น)

ย้าย:

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

ลองออนไลน์!

Perl 6 , 20 11 ไบต์

#&
*[
#Z
 ]

ลองออนไลน์!

ขนย้าย

#*# 
&[Z]

ลองออนไลน์!

ฟังก์ชั่นทั้งสองทำงานในรายการของรายการ

*[ ] เป็น AnythingCode ที่ส่งคืนชิ้นส่วนของการโต้แย้งของมันได้อย่างมีประสิทธิภาพฟังก์ชั่นตัวตน

&[Z] เป็นตัวดำเนินการ zip

Haskell, 185 161 ไบต์

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 ไบต์ขอบคุณ @ Ørjan Johansen

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เงื่อนไขซึ่งเป็นเท็จเสมอ «จากนั้นเริ่มบล็อกรหัสถ่านไร้ความหมายซึ่งไม่เคยถูกเรียกใช้งาน (อาจเป็นไปได้ที่จะลบบางส่วนของไบต์เหล่านั้น แต่ในกรณีนั้นฉันไม่แน่ใจว่า Charcoal จะแยกวิเคราะห์โปรแกรมอย่างถูกต้องหรือไม่) Transposed, 17 ไบต์:

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

ลองออนไลน์! คำอธิบาย: ‖↗มากเช่นเดียวกับโครงการก่อนหน้านี้ยกเว้นสำหรับการเพิ่มขึ้นของคำสั่ง

ฉันมีทางเลือกอื่นซึ่งโปรแกรมต้นฉบับและ transposed มีขนาด 18 ไบต์:

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

ลองออนไลน์! คำอธิบาย: Ａดังกล่าวข้างต้น; ⊞υส่งค่าไปยังรายการว่างที่กำหนดไว้ล่วงหน้า (ซึ่งไม่มีผลกับเอาต์พุต); ”yเริ่มต้นสตริงโดยพลการ (สิ้นสุดที่ส่วนท้ายของโปรแกรมหรือการจับคู่” ) ย้าย:

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

ลองออนไลน์! คำอธิบาย: Ａ‖↗ดังกล่าวข้างต้น; ⊞υดังกล่าวข้างต้น; ความแตกต่างเล็ก ๆ น้อย ๆ ที่นี่เป็นที่ฉันดัน concatenations ”ของสตริงที่มีขนาดเล็กตั้งแต่ฉันไม่ต้องการที่จะทำซ้ำ

Brain-Flak (BrainHack) , 382 375 337 ไบต์

ไม่มีความคิดเห็น!

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

ลองออนไลน์!

สำหรับอินพุตตัวเลขสองตัวแรกคือขนาดของเมทริกซ์และส่วนที่เหลือคือเนื้อหาของเมทริกซ์ เอาต์พุตถูกกำหนดในรูปแบบเดียวกัน

ขนย้าย

Brain-Flak (BrainHack) , 465 ไบต์

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

ลองออนไลน์!

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

Haskell ,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

Ruby , 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
` };

ลองออนไลน์!

หรือ transposed:

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]]จะได้รับการแสดงในรูปแบบอาร์เรย์ที่ซ้อนกันเป็นการสนับสนุนขั้นต่ำสำหรับอาร์เรย์แบบขรุขระ (เฉพาะอันสุดท้ายเท่านั้นที่สามารถสั้นได้) แต่เมื่ออินพุตถูกคาดหวังว่าจะเป็นสี่เหลี่ยม

เอาท์พุทจะแสดงในรูปแบบเดียวกัน (รุ่น transposed เอาท์พุทกับ newlines แต่มันเป็นศูนย์ไบต์ที่แตกต่างกันเพื่อใช้ช่องว่างแทน) เวอร์ชันปกติมีช่องว่างต่อท้ายเวอร์ชันที่ถูกย้ายมีคอมม่าต่อท้ายและขึ้นบรรทัดใหม่ (เนื่องจากความยากลำบากในการพิจารณาเมื่อไม่มีข้อมูลที่จะพิมพ์อีกต่อไป)

รุ่นปกติมีตัวดัดแปลงในสถานที่แปลก ๆ (เช่น 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 และ newline และวนซ้ำค่าจะถูกป้อนอีกครั้ง เพื่อดำเนินการ (มิเรอร์สำหรับการอ่าน) ซึ่งเป็นคำสั่งยกเลิกการดำเนินการ:. \',$!.6ak$?....../การเปลี่ยนakเป็น'<space>จะพิมพ์ช่องว่างแทนการขึ้นบรรทัดใหม่

การดำเนินการหยุดลงเมื่อโปรแกรมพยายามเขียนจากสแต็กเปล่า นี่คือเหตุผลว่าทำไมความพรวนของแถวสุดท้ายจึงทำงานได้อย่างถูกต้องและเหตุใดจึงมีการต่อท้าย,ในผลลัพธ์: เครื่องหมายจุลภาคถูกพิมพ์ไปแล้วก่อนที่โปรแกรมจะรู้ว่าไม่มีข้อมูลอีกต่อไป