Abzocke einer Abzocke einer Abzocke einer Abzocke . Geht und stimmt denen zu!

Wenn Sie es akzeptieren möchten, müssen Sie ein Programm / eine Funktion schreiben, das / die die Eingabe / das Argument¹ ausgibt / zurückgibt. Der schwierige Teil ist, dass, wenn ich Ihren Quellcode ² transponiere, die Ausgabe / das Ergebnis ebenfalls transponiert werden muss.

1. Sie können auswählen, welche Art von 2D-Daten Ihre Lösung akzeptieren kann. Zum Beispiel eine Liste von Listen, eine Matrix, eine Liste von Zeichenfolgen usw. Geben Sie an, welche (s) es behandelt. Sie können davon ausgehen, dass die Eingabe immer rechteckig ist und in jeder Dimension eine Länge von 1 oder mehr aufweist.

2. Beim Transponieren werden kurze Zeilen in Ihrem Quellcode als mit Leerzeichen aufgefüllt betrachtet, bis sie rechteckig sind. Diese aufgefüllten Leerzeichen tragen jedoch nicht zu Ihrer Codelänge bei.

Da es sich um Code-Golf handelt , besteht das Ziel darin, die Byte-Anzahl des ursprünglichen Quellcodes (nicht der transponierten Version) zu optimieren.

Beispiele

Angenommen, Ihre Lösung verwendet eine numerische Matrix und Ihr Quellcode lautet

AB
DEF

und seine Eingabe / Argument ist [[1,2],[3,4],[5,6]]. Wenn ich schreibe

AD
BE
 F

Stattdessen muss die Ausgabe / das Ergebnis lauten und ausgeführt werden [[1,3,5],[2,4,6]].

Angenommen, Ihre Lösung besteht aus einer durch Zeilenvorschub getrennten Zeichenfolge, und Ihr Quellcode lautet

ABC

und seine Eingabe / Argument ist "96\n". Wenn ich schreibe

A
B
C

Stattdessen muss die Ausgabe / das Ergebnis lauten und ausgeführt werden "9\n6\n".

Python 3 + Anzahl, 45 Bytes

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

Probieren Sie es online!

Vielen Dank an @EriktheOutgolfer, der auf einen Fehler der Vorgängerversion hinweist

Transponiert:

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

Probieren Sie es online!

Die Funktionen nehmen eine Zahlenmatrix als Eingabe und geben eine Zahlenmatrix aus. Die Lösung basiert nicht wie viele andere Lösungen auf Kommentaren, sondern nutzt mehrzeilige Zeichenfolgen.

Gelee , 2 Bytes

Eingabe ist eine Liste von Listen. Vielen Dank an Luis Mendo und Nick Kennedy für die Verbesserung der Antwort.

ZZ

Probieren Sie es online! Probieren Sie es transponiert!

Das Programm transponiert die Eingabe zweimal und gibt die ursprüngliche Eingabe zurück. Die transponierte Version ignoriert die erste Zeile und transponiert nur einmal.

R , 5 4 Bytes

#t
I

Probieren Sie es online!

Eine R-Funktion, entweder die Identitätsfunktion Ioder die transponierte Funktion, twenn transponiert. Die Fußzeile auf TIO zeigt die Ausgabe von beiden.

Vielen Dank an @RobinRyder für das Speichern eines Bytes!

C (gcc) , 209 205 203 201 Bytes

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

Probieren Sie es online!

Transponiert

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

Probieren Sie es online!

Haskell , 51 Bytes

Diese Version ist gültig, wird aber bei []Eingabe nicht angehalten .

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

Probieren Sie es online!

Transponiert, 75 Bytes

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

Probieren Sie es online!

Haskell , 51 Bytes

Diese Version ist gültig, stürzt aber mit []als Eingabe für die transponierte Version ab.

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

Probieren Sie es online! Transponiert

Haskell , 75 67 57 Bytes

Mindestens 7 Bytes gespart dank Ørjan Johansen

Diese Version wird []ausgegeben, wenn sie []als Eingabe angegeben wird.

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

Probieren Sie es online!

Transponiert

Python 3 , 51 Bytes

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

Probieren Sie es online!

Basierend auf Joels Ansatz . Die Eingabe ist a tuplevon tuples, und die Ausgabe ist a zip( tuplezur besseren Sichtbarkeit in eine über TIO konvertiert ).

Transponiert:

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

Probieren Sie es online!

Perl 6 , 20 11 Bytes

#&
*[
#Z
 ]

Probieren Sie es online!

Transponiert

#*# 
&[Z]

Probieren Sie es online!

Beide Funktionen arbeiten mit Listenlisten.

*[ ] ist ein WhateverCode, der das Zen-Segment seines Arguments zurückgibt, also die Identitätsfunktion.

&[Z] ist der Zip-Operator.

Haskell, 185 161 Bytes

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
 )

Probieren Sie es online!

Transponiert:

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

Probieren Sie es online!

Keine Kommentare, keine String-Literale, nur einige zusätzliche Funktionsdefinitionen.

Edit: -24 Bytes dank @ Ørjan Johansen.

PHP (7.4), 114 86 70 Bytes

Meine allererste Erfahrung mit so etwas in PHP, es muss einen besseren Weg geben, den ich nicht sehen kann! Input ist ein Array von Arrays wie [[1,2],[3,4],[5,6]].

Normal:

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

Probieren Sie es online!

Transponiert (mit Leerzeichen):

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

Probieren Sie es online!

Holzkohle , 19 Bytes

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

Probieren Sie es online! Nimmt Eingaben als ein Array von Zeichenfolgen. Erläuterung: ＡGibt implizit die explizite Eingabe aus, während ¿⁰es sich bei 0der Bedingung um eine Bedingung handelt , die daher immer falsch ist. «Dann beginnt ein Block mit bedeutungslosem Charcoal-Code, der niemals ausgeführt wird. (Es könnte möglich sein, einige dieser Bytes zu entfernen, aber in diesem Fall bin ich mir nicht sicher, ob Charcoal das Programm korrekt analysieren würde.) Transponiert, 17 Bytes:

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

Probieren Sie es online! Erläuterung: Ähnlich wie im vorherigen Programm, mit Ausnahme des Hinzufügens des Transponierungsbefehls ‖↗.

Ich habe eine alternative Lösung, bei der sowohl das ursprüngliche als auch das transponierte Programm 18 Bytes umfasst:

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

Probieren Sie es online! Erklärung: Ａwie oben; ⊞υverschiebt einen Wert in die vordefinierte leere Liste (was sich nicht auf die Ausgabe auswirkt); ”yBeginnt eine beliebige Zeichenfolge (endet am Ende des Programms oder des Abgleichs ”). Transponiert:

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

Probieren Sie es online! Erklärung: Ａ‖↗wie oben; ⊞υwie oben; Der kleine Unterschied besteht darin, dass ich Verkettungen kleinerer Zeichenfolgen drücke, da ich das nicht wiederholen möchte ”.

Brain-Flak (BrainHack) , 382 375 337 Bytes

Keine Kommentare!

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

Probieren Sie es online!

Für die Eingabe sind die ersten beiden Zahlen die Dimensionen der Matrix und der Rest ist der Inhalt der Matrix. Die Ausgabe erfolgt im gleichen Format.

Transponiert

Brain-Flak (BrainHack) , 465 Bytes

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

Probieren Sie es online!

Japt , 2 Bytes

ÕU

Versuchen Sie es | Transponiert

Õ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

Probieren Sie es online!

Verbessert mit einem anderen Layout

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

Haskell ,153 144 Bytes

(Danke, Sriotchilism O'Zaic )

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

Probieren Sie es online!

Probieren Sie es transponiert!

APL (Dyalog Unicode) , 7 Bytes

{⍵
⍉
⍵}

Probieren Sie es online!

Transponiert:

{⍉⍵
⍵ }

Wahrscheinlich eine ziemlich langweilige Antwort, aber hier geht es trotzdem.

Die Inline-Funktionsdefinition {...}kann mehrere Zeilen umfassen. In diesem Fall wird jede Zeile nacheinander ausgeführt, aber jede Zeile ohne Zuweisung gibt ←sofort ihren berechneten Wert zurück. Die erste Funktion kehrt also zurück, ⍵während die zweite zurückkehrt ⍉⍵.

Eine noch langweiligere Antwort wäre der Missbrauch von Kommentaren:

APL (Dyalog Unicode) , 4 Bytes

⍝⍉
⊢

Es ist wohl kein TIO nötig ...

05AB1E , 3 Bytes

øø
q

Probieren Sie es online aus.

øq
ø

Versuchen Sie es transponiert.

Erläuterung:

Im Gegensatz zu einigen anderen Sprachen werden Zeilenumbrüche in 05AB1E einfach ignoriert, daher halte ich ein 2-Byte-Format nicht für möglich (obwohl ich mich gerne als falsch erweisen würde).

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

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

Probieren Sie es online!

Hüfte, zum quadratisch zu sein! (Fast)

Akzeptiert Ruby-Matrizen als Eingabe (Arrays von Arrays)

Sauber , 64 Bytes

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

Probieren Sie es online!

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

Probieren Sie es transponiert!

Python 3 , 118 95 Bytes

Eingabe und Ergebnis sind Tupellisten.

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

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

Probieren Sie es online!

Wolfram Language (Mathematica) , 13 Byte

#&(*
 *)
\

Probieren Sie es online! / Transponiert

Cjam , 13 Bytes

qo
~
z
`

Probieren Sie es online!

Transponierte Fassung:

q~z`
o

Probieren Sie es online!

Eingabeformat

Das Eingabeformat ist das Standard-CJam-Array-Format: [[1 2] [3 4]]

Keine Absturzversion, 12 Bytes

Die normale Version stürzt nach dem Drucken des Arrays ab. Eine Version, die nicht abstürzt, wäre:

qo{
~
z
` };

Probieren Sie es online!

oder transponiert:

q~z`
o
{  };

Probieren Sie es online!

Es gibt wahrscheinlich ein paar zusätzliche Bytes, die gespeichert werden können. Ich habe versehentlich zuerst an der transponierten Version gearbeitet, was zu ein paar zusätzlichen Zeilenumbrüchen führte und es ist lange her, seit ich CJam das letzte Mal verwendet habe. Verbesserungen sind willkommen.

Zsh , 75 Bytes

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

$
#
s

TIO: Normal transponiert

Der Papierkorb unter dem Hauptdruck ist harmlos. Er gibt einen Fehler aus, wenn nach dem Drucken eine neue Zeile angezeigt wird, fa<und wird beendet. 86 Bytes, um diesen Fehler zu beheben.

Die transponierte Fassung ist hier. Nach dem Drucken wird es am <Zeilenende fehlerhaft angezeigt und beendet.

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

Runenverzauberungen , 88 Bytes

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

$

Probieren Sie es online!
Probieren Sie es transponiert!

Die Eingabe ist für jeden Wert durch Leerzeichen und für jede Zeile durch Kommas getrennt (Zeilenumbrüche sind optional) und unterstützt sowohl Zeichenfolgen als auch Zahlen (ungleich Null). Dies erleichtert das Parsen der Eingabe, da die Eingabe automatisch durch Leerzeichen und Zeilenumbrüche unterbrochen wird. So zum Beispiel die Eingabe:

1 2 3 , 4 5 6 , 7 8 9

Würde in geschachtelter Arrayform dargestellt als [[1,2,3],[4,5,6],[7,8,9]]. Minimale Unterstützung für gezackte Arrays (nur das letzte Array kann kurz sein). Da die Eingaben jedoch rechteckig sein sollen, wird diese Anforderung erfüllt.

Die Ausgabe wird im gleichen Format dargestellt (Ausgabe in transponierter Version mit Zeilenumbrüchen, jedoch mit unterschiedlichen Nullbytes, um stattdessen ein Leerzeichen zu verwenden). Normale Version hat ein Leerzeichen am Ende, transponierte Version hat ein Komma am Ende und eine neue Zeile (aufgrund der Schwierigkeit festzustellen, wann keine Daten mehr zu drucken sind).

In der normalen Version gibt es an seltsamen Stellen (z. B. 7̸0) Modifikatorzeichen. Dies liegt jedoch daran, dass diese beim Transponieren der Quelle an der richtigen Stelle benötigt werden und bei der normalen Ausführung nur die linke Spalte der Anweisungen verwendet wird.

Erläuterung

Die Erläuterung der transponierten Quelle erfolgt in nicht transponierter Form. Pfeile repräsentieren die IP-Richtung am Ein- und Ausgang verschiedener Blöcke.

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

Die Eingabe wird gelesen, und wenn ein ,Zeichen gefunden wird, wird ein neuer Teilstapel verschoben. Dadurch kann jeder Stapel jede Zeile separat im Speicher halten. Öffnet den nächsten Abschnitt von oben.

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

[0(nach links ausgeführt) Richtet einen leeren Stapel als Grenze zwischen der ersten und der letzten Reihe ein und dreht sich dann zum ersten Stapel ( {̹) und startet das Drucken von Elementen und das Drehen von Stapeln. Das i!wird nicht ausgeführt und {̹L [0rwird nur einmal ausgeführt. Wenn ein Stapel mit der Größe Null gefunden wird, wird die Schleife beendet.

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

Wenn der leere Stapel gefunden wird, werden ein ,und eine neue Zeile gedruckt, und die Werteschleife wird erneut eingegeben. Ausführungsreihenfolge (zur besseren Lesbarkeit gespiegelt) , wo .ein nicht ausgeführten Befehl: \',$!.6ak$?....../. Ändern akzu '<space>würde drucken Leerzeichen statt Zeilenumbrüchen.

Die Ausführung wird angehalten, wenn das Programm versucht, von einem leeren Stapel zu schreiben. Aus diesem Grund funktioniert nur die Zackigkeit ,in der letzten Zeile richtig und die Ausgabe weist einen Fehler auf : Das Komma wurde bereits gedruckt, bevor das Programm weiß, dass keine Daten mehr vorhanden sind.