In dieser Herausforderung erhalten Sie einen Textblock und müssen den Text reflektieren.

Eingang:

1. Ein String, der reflektiert werden soll. Der Text darf nicht als Array übergeben werden, dessen Elemente die Textzeilen sind. Zum Beispiel "ab\ncd"und ['a','b','\n','c','d']sind erlaubt, aber ['ab','cd']oder [['a','b'],['c','d']]nicht. Sie können davon ausgehen, dass alle Zeilen die gleiche Anzahl von Zeichen enthalten (bei Bedarf mit Leerzeichen aufgefüllt).
2. Ein Boolescher Wert, bei dem TrueY-Reflexion und FalseX-Reflexion angegeben werden

Die beiden Eingaben können in beliebiger Reihenfolge übergeben werden.

Ausgabe:

Die reflektierte Zeichenfolge. Die Zeichen ändern sich nicht, nur ihre Position. Der resultierende Bildblock sollte oben links ausgerichtet sein (die erste Zeile und Spalte müssen jeweils ein Nicht-Leerzeichen enthalten). Leerzeichen (in allen Zeilen) dürfen nachgestellt werden.

Testfälle:

False
  o /
--|/
  |
 / \

/ o
 /|--
  |
 \ /

True
  o /
--|/
  |
 / \

 / \
  |
--|/
  o /

True
text

text

False
text

txet

True
P
P
C
G

G
C
P
P

False
P
P
C
G

P
P
C
G

True
abcde
fghij
kl mn
opqrs
tuvwx

tuvwx
opqrs
kl mn
fghij
abcde

Dies ist ein Code-Golf , also antworten Sie mit der kürzesten Antwort in Ihrer Lieblingssprache!

C #, 168 144 141 120 Bytes

using System.Linq;i=>y=>string.Join("\n",y?i.Split('\n').Reverse():i.Split('\n').Select(x=>string.Concat(x.Reverse())));

Neue Version verwendet die offensichtliche Zeichenfolge. Join-Überladung, die einen IEnumerable benötigt, die erste Lösung war die versehentliche Verwendung. Ich konnte sie nur für die else-Seite des Ternarys verwenden.

Aktualisieren:

Die neue Version ist ein anonymes Lambda und spart mit dem Currying insgesamt 21 Bytes. Dies ändert die Verwendung dahingehend, dass f("text")(false)f die anonyme Funktion ist.

Ungolfed:

using System.Linq;

//Using currying to save one byte
input => IsYReflect =>
         //Lambda makes return implicit
         string.Join("\n", IsYReflect
            //Y Reflect, just need to reverse the array
            ? input.Split('\n').Reverse()
            //X Reflect, reverse each line into an IEnumerable
            : input.Split('\n').Select(x => string.Concat(x.Reverse())));

Pyke, 7 Bytes

!I_)ncX

Probieren Sie es hier aus!

!I )    - if not boolean:
  _     -  input = reversed(input)
    nc  - input.split("\n")
      X - splat(input)
        -  (print lines backwards)

Brainfuck, 143 140 131 Bytes

,[,[---------->+<[>-]>[->]<,]<[[<]>[++++++++++.>]++++++++++.<[<]<]],[---------->+<[++++++++++>-]>[-<<[.<]++++++++++.[>]>>]<,]<[.<]

Schlage s C #.

Die Herausforderung war für Brainfuck einfach genug und ich war anscheinend müde genug, es einfach tun zu müssen.

Nimmt den Booleschen 0x00Wert als (falsch) oder ein anderes (wahres) Byte am Anfang der Eingabe und dann als mit einem Rechteck aufgefüllte Zeichenfolge.

Gibt eine nachgestellte Zeile für den Y-Flip und keine für den X-Flip aus.

Benötigt einen Interpreter, der Speicherorte links vom Start unterstützt (nicht sicher, ob noch erforderlich) und EOF als gibt 0x00. Ein solcher Dolmetscher ist hier . Unterstützt aus diesem Grund offensichtlich keine Null-Bytes in der Eingabe.

Der Code enthält viele Blöcke mit +Zehner- oder -Zehnerzeichen. diese können wahrscheinlich reduziert werden.

Kommentierte Version

, get mode
[ check truthy input
    ,[ loop thru input
        ---------- subtract newline
        >+ set flag
        < go back to char
        [ was not newline
            > move to flag
            - reset flag
        ]
        > move to flag or one past flag
        [ hit flag; was newline
            - reset flag
            > skip a cell
        ]
        < go to next position
        , read next input
    ]
    < find end of line
    [ loop thru lines
        [<]> find start of line
        [ loop thru line
            ++++++++++ add newline back
            . print this cell
            > go to next cell
        ]
        ++++++++++ change to newline
        . print newline
        <[<]< find end of previous line
    ]
]
,[ loop thru any input left
    ---------- subtract newline
    >+ set flag
    < go back to char
    [ was not newline
        ++++++++++ add newline back
        > move to flag
        - reset flag
    ]
    > move to flag or one past flag
    [ hit flag; was newline
        - clear flag
        < go back to char
        < go back to line chars
        [ loop thru line
            . print this cell
            < go to previous cell
        ]
        ++++++++++. print newline
        [>]>> find empty cell
    ]
    < go to next position
    , read next input
]
< go to line
[ loop thru line
    . print this cell
    < go to previous cell
]

32-Bit-x86-Computercode, 76 Byte

In hex:

31c031c9495789f7fcf2aef7d15192b00a89f7f2ae5829f7f7f787f95f4b89c3741287d94b534b8a041eaa75f95b01dea4e2f2c348f7e101c6b00a5651f3a4595e29ce4f4b0f44c3aa75f0c3

Eingabe:: EBXRichtungsflag (0/1),: ESIEingabezeichenfolge,: EDIAusgabepuffer. Die Eingabe muss rechteckig sein.

0:  31 c0               xor eax,eax         ;EAX=0
2:  31 c9               xor ecx,ecx         
4:  49                  dec ecx             ;ECX=(uint)-1
5:  57                  push edi            
6:  89 f7               mov edi,esi         
8:  fc                  cld                 
9:  f2 ae               repne scasb         ;Scan input string for terminating NULL
b:  f7 d1               not ecx             ;ECX==<input string length (including NULL)>
d:  51                  push ecx            
e:  92                  xchg edx,eax        ;EDX=0
f:  b0 0a               mov al,0x0a         ;'\n'
11: 89 f7               mov edi,esi         
13: f2 ae               repne scasb         ;Scan input string for the first newline
15: 58                  pop eax             ;EAX==<input string length (including NULL)>
16: 29 f7               sub edi,esi         ;EDI==<single line length (including '\n')>
18: f7 f7               div edi             ;EAX==<# of lines>
1a: 87 f9               xchg ecx,edi        ;ECX=EDI
1c: 5f                  pop edi             ;EDI=<dest buffer>
1d: 4b                  dec ebx             ;Test input flag (0/1)
1e: 89 c3               mov ebx,eax         ;EBX=<# of lines>
20: 74 12               je _vertical        
22: 87 d9               xchg ecx,ebx        ;Horisontal flip, exchange ECX & EBX so we can use LOOP
24: 4b                  dec ebx             ;EBX=<single line length (excluding '\n')>
_hfouter:
25: 53                  push ebx            
_hfinner:
26: 4b                  dec ebx             ;Decrement inner loop counter
27: 8a 04 1e            mov al,[esi+ebx]    ;AL=ESI[EBX]
2a: aa                  stosb               ;*EDI++=AL
2b: 75 f9               jne _hfinner        ;EBX==0 => break
2d: 5b                  pop ebx             
2e: 01 de               add esi,ebx         ;*ESI=='\n' (\0 on the last line)
30: a4                  movsb               ;*EDI++=*ESI++, ESI now points to the next line
31: e2 f2               loop _hfouter       ;--ECX==0 => break
33: c3                  ret                 ;Nothing more to do here
_vertical:
34: 48                  dec eax             ;# of strings less one
35: f7 e1               mul ecx             ;Line length (including '\n')
37: 01 c6               add esi,eax         ;ESI+=ECX*(EAX-1), ESI now points to the beginning of the last line
39: b0 0a               mov al,0x0a         ;'\n'
_vfloop:
3b: 56                  push esi            
3c: 51                  push ecx            
3d: f3 a4               rep movsb           ;Copy the whole line to the output including newline/NULL at the end
3f: 59                  pop ecx             
40: 5e                  pop esi             
41: 29 ce               sub esi,ecx         ;Set ESI to the beginning of the previous line
43: 4f                  dec edi             ;*EDI=='\n' (0 on the first iteration), should overwrite it with correct value
44: 4b                  dec ebx             ;Decrement loop counter
45: 0f 44 c3            cmove eax,ebx       ;if (EBX==0) EAX=EBX, this clears EAX on the last iteration
48: aa                  stosb               ;*EDI++=EBX?'\n':0
49: 75 f0               jne _vfloop         ;EBX==0 => break
4b: c3                  ret                 

Haskell, 51 49 45 Bytes

r=reverse
f b=unlines.last(map r:[r|b]).lines

Anwendungsbeispiel:

f True "abc\ndef\nghi\njkl"
"jkl\nghi\ndef\nabc\n"

f False "abc\ndef\nghi\njkl"
"cba\nfed\nihg\nlkj\n"

In Zeilen aufteilen, entweder die Zeilen umkehren (True) oder jede Zeile umkehren (False) und wieder zu einer einzelnen Zeichenfolge zusammenfügen. Bei einer TrueEingabe map r:[r|b]handelt es sich um eine Liste mit zwei Funktionen [<reverse each line>, <reverse lines>]und bei einer FalseEingabe um eine Liste mit einer Funktion [<reverse each line>]. lastwählt das letzte Element dieser Liste aus.

Gelee , 8 Bytes

ṣ⁷ṚU⁴?j⁷

Probieren Sie es hier aus.

ṣ⁷         Split over newlines.
  ṚU⁴?     If ⁴ (2nd argument), then Ṛ (reverse rank ∞), else U (reverse rank 1).
      j⁷   Join with newlines.

Python, 56 Bytes

lambda s,r:'\n'.join(s[::2*bool(r)-1].split('\n')[::-1])

Rufe mit einer Zeichenkette sund jedem Wahrheitsgehalt / Falschwert r.

Python 3.5, 61 Bytes:

lambda f,j:[print(r[::-1])for r in j[::[1,-1][f]].split('\n')]

Eine einfache anonyme Lambda-Funktion, die eine rechteckige Eingabe annimmt. Rufen Sie es auf, indem Sie zuerst die Funktion benennen und dann die Funktion in einem Wrapper aufrufen print(). Mit anderen Worten, wenn die Funktion genannt wurden H, rufen Sie es mögen print(H(<Bool value>, <String>)), wo <Bool Value>irgendein wahr oder falsch Wert (dh 0/1, true/falseusw.) und <String>ist die Eingabezeichenfolge.

Sehen Sie es in Aktion! (Repl.it)

Hier ist eine andere Version mit der gleichen Länge, die ebenfalls eine rechteckige Eingabe annimmt, diesmal jedoch eine benannte Funktion, dh Sie müssen sie nicht zuerst benennen oder in sie einschließen print():

def J(f,j):[print(r[::-1])for r in j[::[1,-1][f]].split('\n')]

Nenne das einfach so J(<Bool Value>,<String>).

Sehen Sie dies in Aktion! (Repl.it)

Ich bin jedoch nicht derjenige, der hier aufhört. Obwohl wir eine rechteckige Eingabe annehmen dürfen, habe ich auch eine Version erstellt, die diese Art von Eingabe nicht annimmt. Daher werden alle Zeilen auf der Grundlage der Zeile mit der maximalen Länge auf die gleiche Länge gesetzt, wenn und nur wenn die <Bool>Eingabe dies ist False, da nur eine X-Reflexion dazu führt, dass die Zeichenfolge "gespiegelt" wird. Hier nun ohne weiteres die nicht rechteckige unterstellte Version mit einer Länge von 134.129 Bytes in Form einer normalen Funktion:

def J(f,j):print('\n'.join([' '*((max([len(i)for i in j.split('\n')])-len(r))*(not f))+r[::-1]for r in j[::[1,-1][f]].split('\n')]))

Sehen Sie diesen Letzten in Aktion! (Repl.it)

MATL , 11 Bytes

10&Ybc2i-&P

Probieren Sie es online!

Die erste Eingabe ist die mehrzeilige Zeichenfolge. Da MATL keinen \nZeilenvorschub erkennt , sollte die mehrzeilige Zeichenfolge als Verkettung von Teilzeichenfolgen oder einzelnen Zeichen definiert werden 10(ASCII für Zeilenvorschub, der als Zeichen interpretiert wird). Die Verkettung in MATL ist [... ...]oder [..., ...](Kommas sind optional). Die Eingabe kann beispielsweise wie folgt erfolgen (Verkettung einer Zeichenfolge, eines Zeilenvorschubs und einer anderen Zeichenfolge):

['first line' 10 'second']

oder gleichwertig (Verkettung einzelner Zeichen)

['f' 'i' 'r' 's' 't' ' ' 'l' 'i' 'n' 'e' 10 's' 'e' 'c' 'o' 'n' 'd']

oder (gleich mit Komma)

['f', 'i', 'r', 's', 't', ' ', 'l', 'i', 'n', 'e', 10, 's', 'e', 'c', 'o', 'n', 'd']

Die zweite Eingabe kann als 1/ 0oder gleichwertig als T/ Ffür true/ erfolgen false.

Erläuterung

10     % Push 10 (ASCII for linefeed)
&Yb    % Take input string implicitly. Split at linefeeds. Gives a cell array
c      % Convert to a 2D char array, right-padding with spaces
i~Q    % Input Boolean value. Negate and add 1. Gives 1/2 for true/false resp.
&P     % Flip along that dimension (1: vertically; 2: horizontally). Display implicitly

Brachylog , 26 24 16 Bytes

t1,?h@nr~@nw|hrw

Erwartet eine Liste mit dem String und dem Booleschen Wert 1oder 0z

run_from_file('code.bl',["P
|    P
|    C
|    G":1]).

Erläuterung

t1,              If the tail of the input is 1
   ?h@n              Split the string on \n
       r             Reverse the resulting list
        ~@n          Join the list of strings with \n
           w         Write to STDOUT
|                Or
hr                   Reverse the string
  w                  Write to STDOUT

Pyth, 10 Bytes

j?Q_.z_M.z

Testsuite.

j?Q_.z_M.z  first line evaluated as Q, all other lines as .z
 ?Q         if Q:
   _.z         yield reverse(.z)
      _M.z  else: yield map(reverse, .z)
j           join by newlines

Bash + gemeinsame Linux-Utils, 16

(($1))&&tac||rev

Boolescher Wert (null oder nicht null), der als Befehlszeilenparameter übergeben wird. E / A des Textblocks über STDIN / STDOUT. Es wird davon ausgegangen, dass alle Zeilen dieselbe Länge haben, wie in den Kommentaren angegeben .

C (Ansi), 193 Bytes

Golf gespielt:

i,y,x;main(g,o,p)char**o;{p=(o[1][0]=='t');while(o[2][++i]!='\n');p?y=(strlen(o[2])-1)/i:(x=i);do do printf("%c",o[2][x+y*i]);while(p?++x<i:x-->0);while(p?x=0,y--:++y<(x=i-1,strlen(o[2])/i));}

Ungolfed:

i,y,x;
main(g,o,p)char**o;{
    p=(o[1][0]=='t');
    while(o[2][++i]!='\n'); 
    p?y=(strlen(o[2])-1)/i:(x=i);
    do{
        do{
            printf("%c",o[2][x+y*i]);
        }while(p?++x<i:x-->0);
    }while(p?x=0,y--:++y<(x=i-1,strlen(o[2])/i));
}

Verwendung:

Zusammenstellungsargumente:

gcc -O3 -ansi

Beispiel Eingabe:

Die Eingabe ist bei oder nicht t für wahr oder falsch, gefolgt von einem NewSpace-Lead und einem nachgestellten String.

./reverseString t "
truck
ducky
quack
moose
"

Beispielausgabe:

moose
quack
ducky
truck

JavaScript (ES 6) 83 Byte

(c,b)=>(p=c.split`
`)&&(b?p.reverse():p.map(a=>a.split``.reverse().join``)).join`
`

f=(c,b)=>(p=c.split`
`)&&(b?p.reverse():p.map(a=>a.split``.reverse().join``)).join`
`

f("abcde\nfghij\nkl mn\nopqrs\ntuvwx",1)

c="
  o / 
--|/
  | 
 / \
";

f(c,1)
" / \
   | 
 --|/
   o / "

f(c,0)
"/ o  
  /|--
   |  
  \ / "

Julia, 59 Bytes

x\y=(y=split(y,'
');! =reverse;join(x?!y:[!a for a=y],'
'))

Probieren Sie es online!

J, 29 Bytes

}:@,@(,.&LF@{|."1,:|.)>@cutLF

Die LHS-Eingabe ist der Boolesche Wert, bei dem 0 falsch und 1 wahr ist. RHS ist die Zeichenfolgeeingabe.

JavaScript (ES6), 76

s=>b=>(s=s.split`
`,b?s.reverse():s.map(r=>[...r].reverse().join``)).join`
`

F=s=>b=>(s=s.split`
`,b?s.reverse():s.map(r=>[...r].reverse().join``)).join`
`

function test()
{
  var rows=I.value, r
  
  // Trim trailing newlines, pad to blank
  rows=rows.split('\n')
  while(!(r=rows.pop()));
  rows.push(r)
  var maxlen=Math.max(...rows.map(r=>r.length))
  rows=rows.map(r=>r+' '.repeat(maxlen-r.length)).join`\n`

  var t1=F(rows)(false)
  var t2=F(rows)(true)
  
  O.textContent = 'False\n'+t1+'\n\nTrue\n'+t2
}

test()

#I { width:50%; height:10em }

<textarea id=I>
  o /
--|/
  |
 / \
</textarea>  
<button onclick=test()>Go</button>
<pre id=O></pre>

Java 99 Bytes

public String[] reverse(String[]a){
  int i=-1,j=a.length;
  for(;++i<--j;){
    String b=a[i];
    a[i]=a[j];
    a[j]=b;
  }
  return a;
}

Golf gespielt:

String[] e(String[]a){int i=-1,j=a.length;for(;++i<--j;){String b=a[i];a[i]=a[j];a[j]=b;}return a;}

Perl, 35 Bytes

34 Byte Code + 1 für -n.

Erfordert, dass die Eingabezeilen mit Leerzeichen aufgefüllt werden. Dank @ Dada werden 13 (!) Bytes gespeichert .

print/T/?reverse<>:map~~reverse,<>

Verwendung

perl -ne 'print/T/?reverse<>:map~~reverse,<>' <<< 'False
  o /
--|/ 
  |  
 / \ '

/ o  
 /|--
  |  
 \ / 

 perl -ne 'print/T/?reverse<>:map~~reverse,<>' <<< 'True
  o /
--|/ 
  |  
 / \ '
 / \ 
  |  
--|/ 
  o /

Mathematica, 70 Bytes

If[#,Reverse,StringReverse]@ImportString[#2,l="Lines"]~ExportString~l&

Bei einer anonymen Funktion wird ein boolescher Wert als erstes Argument (explizit Trueoder Falsein Mathematica) und die (mehrzeilige) Zeichenfolge als zweites Argument verwendet. Importiert die Zeichenfolge als Liste von Zeichenfolgen, die den Zeilen der mehrzeiligen Zeichenfolge entsprechen (die Zeichenfolge wird NICHT als Array an die Funktion übergeben). Wenn Trueja, kehren Sie die Liste um. Ist False StringReversedie Liste, die automatisch auf jedes Element der Reihe nach angewendet wird. Exportieren Sie dann die Liste als Zeichenfolge, wobei jedes Element eine neue Zeile ist.

05AB1E , 10 Bytes

U|XiRë€R}»

Erläuterung

U          Remove the first input line and store it in variable X
 |         Aggregate the rest of the input into an array
  XiR      If x is true, revert the array
     ë€R   Else revert each element
        }  End if
         » Join everything with newlines and implicitly display

Probieren Sie es online!

Vim, 33 Bytes

Die vorherige V-Antwort wurde zu Vim geändert. Jede V-Antwort wäre ganz anders, also war es nicht wirklich fair.

DgJ:if@"
g/^/m0
el
se ri
en
cG"

Probieren Sie es online!

Hexdump

00000000: 4467 4a3a 6966 4022 0a67 2f5e 2f6d 300a  DgJ:if@".g/^/m0.
00000010: 656c 0a73 6520 7269 0a65 6e0a 6347 1222  el.se ri.en.cG."
00000020: 08                                       .