Плагіат з рип-офф у вигляді плагіату з більш плагіату . Ідіть, піднявши ці пропозиції!

Ваше завдання, якщо ви бажаєте прийняти це, - написати програму / функцію, яка виводить / повертає вхід / аргумент¹. Складна частина полягає в тому, що якщо я транспоную ваш вихідний код², результат / результат повинен бути також переміщений.

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 "    
\ """  

Спробуйте в Інтернеті!

Функції приймають матричну нумеру як вхідну та виводять матричну нумеру. Рішення не покладається на коментарі, як багато інших рішень, а натомість використовує багаторядкові рядки.

Желе , 2 байти

Введення - це список списків. Дякуємо Луїсу Мендо та Ніку Кеннеді за вдосконалення відповіді.

ZZ

Спробуйте в Інтернеті! Спробуйте перенести!

Програма переміщує вхід двічі, повертаючи початковий вхід. Транспонована версія ігнорує перший рядок і транспонує лише один раз.

R , 5 4 байти

#t
I

Спробуйте в Інтернеті!

Функція R, або функція ідентичності, Iабо функція транспонуванняt транспонування під час транспонування. Footer на 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
] 
) 
; 
} 
/*
*/

Спробуйте в Інтернеті!

Хаскелл , 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

Спробуйте в Інтернеті!

Хаскелл , 51 байт

Ця версія є дійсною, але виходить з ладу, []як вхід для транспонованої версії.

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

Спробуйте в Інтернеті! Перенесено

Хаскелл , 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в tupleсек, а вихідний сигнал єzip (перетворюється вtuple більш TIO для кращої видимості).

Перенесено:

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

Спробуйте в Інтернеті!

Perl 6 , 20 11 байт

#&
*[
#Z
 ]

Спробуйте в Інтернеті!

Перенесено

#*# 
&[Z]

Спробуйте в Інтернеті!

Обидві функції працюють у списку списків.

*[ ] є WickerCode, що повертає зенський фрагмент свого аргументу, фактично функцію ідентичності.

&[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, там повинен бути кращий спосіб, якого я не бачу! Input - це масив подібних масивів [[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умовою, яка тому завжди помилкова. «потім починається блок безглуздого коду деревного вугілля, який ніколи не виконується. (Можливо, можливо, видалити деякі з цих байтів, але в такому випадку я не впевнений, чи правильно розібрав би програму вугілля.) Перенесено, 17 байт:

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

Спробуйте в Інтернеті! Пояснення: Настільки ж, як і в попередній програмі, за винятком додавання команди транспонування‖↗ .

У мене є альтернативне рішення, коли і вихідна, і транспонована програма мають 18 байт:

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

Спробуйте в Інтернеті! Пояснення: Ａяк зазначено вище; ⊞υвисуває значення до попередньо визначеного порожнього списку (що не впливає на вихід); ”yпочинається довільна рядок (закінчується в кінці програми або збігу ”). Перенесено:

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

Спробуйте в Інтернеті! Пояснення: Ａ‖↗як зазначено вище; ⊞υяк зазначено вище; незначна різниця тут полягає в тому, що я підштовхую конкатенації менших рядків, оскільки я не хочу повторювати ”.

Brain-Flak (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 байти

(спасибі, сріотчілізм О'Заїк )

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

Спробуйте перенести!

Пітон 3 , 118 95 байт

Введення та результат - це списки кортежів.

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

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

Спробуйте в Інтернеті!

Мова Вольфрама (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 та новий рядок, і цикл значень знову вводиться. Порядок виконання (дзеркально для зручності читання) , де .представляє собою команду ип-виконується: \',$!.6ak$?....../. Зміна akна '<space>друковані пробіли замість нових рядків.

Виконання зупиняється, коли програма намагається записати з порожнього стека; тому правильність працює лише в останньому ряду, і чому ,у висновку є трейлінг : кома вже була надрукована до того, як програма дізнається, що даних більше немає.