Плагиат из рип-офф в виде плагиата из более плагиата . Иди голосуй!

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

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при транспонировании. Нижний колонтитул на 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 байт

По крайней мере, 7 байтов сэкономлено благодаря Эрджану Йохансену

Эта версия выводится []при []вводе.

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]

Попробуйте онлайн!

Обе функции работают со списком списков.

*[ ] это какой-то код, который возвращает дзенский фрагмент своего аргумента, фактически функцию тождества.

&[Z] это почтовый оператор.

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 Йохансен.

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 правильно анализировать программу.) Транспонировано, 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 байта

⍝⍉
⊢

Думаю, нет необходимости в ТИО ...

05AB1E , 3 байта

øø
q

Попробуйте онлайн.

øq
ø

Попробуй это транспонировать.

Объяснение:

В отличие от некоторых других языков, в 05AB1E символы новой строки просто игнорируются, поэтому я не думаю, что возможен двухбайтовый код (хотя я бы хотел, чтобы его ошиблись).

ø    # 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 Language (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 и newline, и цикл ввода значений снова вводится. Порядок выполнения (зеркально для удобства чтения) , где .представляет собой команду ип-выполняется: \',$!.6ak$?....../. Переход akна '<space>печатные места вместо новых строк.

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