Soygun a soygun a soygun a soygun . Git onları oyla!

Göreviniz kabul etmek isterseniz, girişini / argümanını¹ veren / veren bir program / işlev yazmaktır. İşin zor yanı, kaynak kodunuzu² dönüştürürsem, çıktı / sonucun da aktarılması gerektiğidir.

1. Çözümünüzün hangi tür 2D verilerini kabul edebileceğini seçebilirsiniz. Örneğin, bir liste listesi, bir matris, bir dize listesi vs. Girişin her zaman dikdörtgen olacağını ve her boyut boyunca 1 veya daha fazla uzunluğa sahip olacağını varsayabilirsiniz.

2. Transposing amacıyla, kaynak kodunuzdaki kısa satırlar dikdörtgen alana kadar iz bırakma boşlukları ile doldurulmuş olarak kabul edilecektir, ancak bu iz bırakılmış iz bırakma boşlukları kod uzunluğunuza katkıda bulunmaz.

Bu kod golf olduğundan, hedef orijinal kaynak kodunun bayt sayısını optimize etmektir (aktarılan sürüm değil).

Örnekler

Diyelim ki çözümünüz sayısal bir matris alıyor ve kaynak kodunuz

AB
DEF

ve onun girişi / argümanı [[1,2],[3,4],[5,6]]. Eğer yazarsam

AD
BE
 F

Bunun yerine ve çalıştırın, çıktı / sonuç olması gerekir [[1,3,5],[2,4,6]].

Diyelim ki çözümünüz satırdan ayrılmış bir dize alıyor ve kaynak kodunuz

ABC

ve onun girişi / argümanı "96\n". Eğer yazarsam

A
B
C

Bunun yerine ve çalıştırın, çıktı / sonuç olması gerekir "9\n6\n".

Python 3 + numpy, 45 bayt

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

Çevrimiçi deneyin!

@EriktheOutgolfer önceki sürümün bir hatayı işaret eden teşekkürler

Transpoze:

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

Çevrimiçi deneyin!

İşlevler, girişli olarak bir matris matrisi alır ve bir matris matrisi çıkarır. Çözüm, diğer birçok çözümde olduğu gibi yorumlara dayanmaz, bunun yerine çok satırlı dizeleri kullanır.

Jöle , 2 bayt

Giriş, listelerin bir listesidir. Cevabı iyileştirdiği için Luis Mendo ve Nick Kennedy'ye teşekkürler.

ZZ

Çevrimiçi deneyin! Transpolasyonu dene!

Program girişi iki kez çevirir ve orijinal girişi döndürür. Transpoze edilmiş versiyon ilk satırı göz ardı eder ve sadece bir kez transpozit eder.

R , 5 4 bayt

#t
I

Çevrimiçi deneyin!

Bir R işlevi, kimlik işlevi Iveya transpoze tedildiğinde transpoze işlevi . TIO'daki altbilgi, her ikisinin de çıktısını gösterir.

Bir bayt tasarrufu için @RobinRyder teşekkürler!

C (gcc) , 209 205 203 201 bayt

Normal

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

Çevrimiçi deneyin!

Transpoze

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

Çevrimiçi deneyin!

Haskell , 51 bayt

Bu sürüm geçerlidir, ancak []girdi olarak verildiğinde durmayacak .

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

Çevrimiçi deneyin!

Transfer, 75 bayt

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

Çevrimiçi deneyin!

Haskell , 51 bayt

Bu sürüm geçerlidir, ancak []aktarılan sürüm için girdi olarak çöküyor .

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

Çevrimiçi deneyin! Transpoze

Haskell , 75 67 57 bayt

Ørjan Johansen sayesinde en az 7 bayt kurtarıldı

Bu sürüm girdi olarak []verildiğinde çıkar [].

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

Çevrimiçi deneyin!

Transpoze

Python 3 , 51 bayt

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

Çevrimiçi deneyin!

Joel'in yaklaşımına dayanarak . Girişi olan tuplebir tuples ve çıkış a, zip(a dönüştürülen tupledaha iyi görülmesi için TIO üzerinden).

Transpoze:

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

Çevrimiçi deneyin!

Perl 6 , 20 11 bayt

#&
*[
#Z
 ]

Çevrimiçi deneyin!

Transpoze

#*# 
&[Z]

Çevrimiçi deneyin!

Her iki işlev de listelerde çalışır.

*[ ] argümanının zen dilimini, etkin bir şekilde kimlik işlevini döndüren bir WhateverCode'dur.

&[Z] zip operatörüdür.

Haskell, 185 161 bayt

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
 )

Çevrimiçi deneyin!

Transpoze:

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

Çevrimiçi deneyin!

Yorum yok, string hazırlayıcı yok, sadece bazı ek fonksiyon tanımları.

Düzenleme: @ Ørjan Johansen sayesinde -24 bayt.

PHP (7.4), 114 86 70 bayt

PHP'de böyle bir şey yaparken ilk deneyimim, göremememin daha iyi bir yolu olmalı! Giriş, gibi bir dizi dizisidir[[1,2],[3,4],[5,6]] .

Normal:

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

Çevrimiçi deneyin!

Transfer (boşluk yastıklı):

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

Çevrimiçi deneyin!

Kömür , 19 bayt

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

Çevrimiçi deneyin! Dizeleri bir dizi olarak girdi alır. Açıklama: koşullu olarak Ａaçık girdiyi dolaylı olarak yazdırır , bu nedenle koşul olarak her zaman yanlıştır. daha sonra hiç çalıştırılmayan anlamsız bir Kömür kodu bloğu başlatır. (Bu baytların bazılarını kaldırmak mümkün olabilir, ancak bu durumda Kömürün programı doğru şekilde ayrıştırıp ayırmayacağından emin değilim.) Transposed, 17 byte:¿⁰0«

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

Çevrimiçi deneyin! Açıklama: Transpose komutunun eklenmesi dışında önceki program ile aynı ‖↗.

Hem orijinal hem de aktarılan programın 18 bayt olduğu alternatif bir çözümüm var:

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

Çevrimiçi deneyin! Açıklama: Ａyukarıdaki gibi; ⊞υönceden tanımlanmış boş listeye bir değeri (çıktıyı etkilemez) iter; ”yisteğe bağlı bir dizge başlar (programın sonunda veya eşleşmenin sonunda biter ”). Transpoze:

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

Çevrimiçi deneyin! Açıklama: Ａ‖↗yukarıdaki gibi; ⊞υyukarıdaki gibi; Buradaki küçük fark, tekrarlamak istemediğim için, daha küçük dizelerin birleştirmelerini bastırmamdır ”.

Brain-Flak (BrainHack) , 382 375 337 bayt

Yorum yok!

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

Çevrimiçi deneyin!

Girdi için ilk iki sayı matrisin boyutları ve geri kalanı matrisin içeriğidir. Çıktı aynı formatta verilir.

Transpoze

Brain-Flak (BrainHack) , 465 bayt

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

Çevrimiçi deneyin!

Japt , 2 bayt

ÕU

Deneyin | Transpoze

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

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

Çevrimiçi deneyin!

Farklı bir düzen ile geliştirildi

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

Haskell ,153 144 bayt

(teşekkürler, Sriotchilism O'Zaic )

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

Çevrimiçi deneyin!

Transpolasyonu dene!

APL (Dyalog Unicode) , 7 bayt

{⍵
⍉
⍵}

Çevrimiçi deneyin!

Transpoze:

{⍉⍵
⍵ }

Muhtemelen oldukça sıkıcı bir cevap, ama yine de burada gidiyor.

Satır içi işlev tanımı {...}, birden çok satıra yayılabilir. Bu durumda, her satır sırayla yürütülür, ancak ataması olmayan herhangi bir satır ←derhal hesaplanan değerini döndürür. Böylece ⍵ikinci fonksiyon dönerken ilk fonksiyon döner ⍉⍵.

Daha da sıkıcı cevap, yorumun kötüye kullanılması olacaktır:

APL (Dyalog Unicode) , 4 bayt

⍝⍉
⊢

TIO gerekli değil sanırım ...

05AB1E , 3 bayt

øø
q

Çevrimiçi deneyin.

øq
ø

Tercüme edilmiş deneyin.

Açıklama:

Diğer dillerden bazılarının aksine, yeni satırlar 05AB1E'de basitçe göz ardı edilir, bu yüzden 2-bayt'ın mümkün olduğunu sanmıyorum (yanlış ispatlanmayı sevdiğim halde).

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

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

Çevrimiçi deneyin!

Kalça kare olmak! (Neredeyse)

Yakut matrisleri girdi olarak kabul eder (dizi dizileri)

Temiz , 64 bayt

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

Çevrimiçi deneyin!

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

Transpolasyonu dene!

Python 3 , 118 95 bayt

Giriş ve sonuç, kayıtların listesidir.

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

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

Çevrimiçi deneyin!

Wolfram Dili (Mathematica) , 13 bayt

#&(*
 *)
\

Çevrimiçi deneyin! / Tercüme

Cjam , 13 bayt

qo
~
z
`

Çevrimiçi deneyin!

Devrik versiyon:

q~z`
o

Çevrimiçi deneyin!

Giriş formatı

Giriş formatı standart CJam dizi formatıdır: [[1 2] [3 4]]

Kilitlenme sürümü yok, 12 bayt

Dizi yazdırıldıktan sonra normal sürüm kilitleniyor . Çökmeyen bir sürüm şöyle olabilir:

qo{
~
z
` };

Çevrimiçi deneyin!

veya devredilen:

q~z`
o
{  };

Çevrimiçi deneyin!

Muhtemelen kaydedilebilecek birkaç ekstra bayt vardır, yanlışlıkla ilk önce transpoze edilmiş sürümde çalıştım, bu da birkaç ekstra satır çizgisine neden oldu ve CJam'ı kullanmamdan bu yana uzun zaman oldu. Herhangi bir gelişme kabul edilir.

Zsh , 75 bayt

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

$
#
s

TIO: Normal Aktarılan

Ana baskının altındaki çöpler zararsızdır, bir satırdan sonra yeni bir satırla karşılaşır fa<ve çıkar. Bu hatayı kaldırmak için 86 bayt.

Transpoze edilmiş versiyon burada. Yazdırdıktan sonra <, bir satırın sonunda görerek hata yapar ve çıkar.

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

Runik Büyüleri , 88 bayt

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

$

Çevrimiçi deneyin!
Transpolasyonu dene!

Giriş, her değer için ayrılmış alan ve virgül ile ayrılmış her bir sıra (yeni satır isteğe bağlıdır) ve destekler de dize ve (sıfır olmayan) sayılar için. Bu, girdi boşluklar ve yeni satırlar tarafından otomatik olarak kesildiği için girişi ayrıştırmayı kolaylaştırır. Örneğin, giriş:

1 2 3 , 4 5 6 , 7 8 9

Olarak iç içe dizi biçiminde gösterilecek [[1,2,3],[4,5,6],[7,8,9]]. Pürüzlü diziler için minimum destek (sadece sonuncusu kısa olabilir), ancak girdilerin dikdörtgen olması beklendiğinden, bu gereksinimi karşılar.

Çıktı aynı formatta (çevrilmiş sürüm yeni satırlarla çıkar, ancak bunun yerine bir boşluk kullanmak için sıfır baytı) gösterilir. Normal sürümde sonda boşluk var, aktarılmış sürümde son virgül ve yeni satır var (yazdırılacak başka veri olmadığında belirleme zorluğundan dolayı).

Normal sürümün garip yerlerde değiştirici karakterleri vardır (örn. 7̸0 ) , ancak bunun nedeni kaynak aktarılırken doğru yerde olmaları ve normal uygulama yalnızca talimatların en solundaki sütunu kullanmasıdır.

açıklama

Aktarılan kaynağın açıklaması aktarılmamış bir biçimde olacaktır. Oklar, çeşitli blokların girişinde ve çıkışında IP yönlülüğünü temsil edecektir.

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

Giriş okunur ve bir ,karakter bulunduğunda, yeni bir alt isteme basılır. Bu, her yığının her satırı ayrı ayrı bellekte tutmasına izin verir. Üstten bir sonraki bölüme girer.

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

[0(sola doğru yürütülür), ilk satır ile son satır arasında bir sınır gibi davranacak boş bir yığın oluşturur ve ardından ilk yığına ( {̹) döner ve yazdırma öğelerini ve dönen yığınları başlatır. i!Yürütülmez ve {̹L [0rsadece bir kez yürütülür. Sıfır boyutlu bir yığın bulunduğunda, döngü çıkar.

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

Boş yığın bulunduğunda, a ,ve newline yazdırılır ve değer döngüsü tekrar girilir. (Okunabilirlik için yansıtılmış) Yürütme sırası .un-idam komut şöyledir: \',$!.6ak$?....../. Değişen akiçin'<space> yerine satırbaşıyla arasında boşluk ekrana getirir.

Program boş bir yığından yazmaya çalıştığında yürütme durur; bu nedenle sadece son satırdaki titizlik düzgün çalışıyor ve çıktıda neden bir iz var ,: virgül, programın daha fazla veri olmadığını bilmeden önce zaten basılmış durumda.