W tym wyzwaniu otrzymasz blok tekstu i musisz przemyśleć tekst.

Wkład:

1. Ciąg do odzwierciedlenia. Tekst nie może być dostarczony jako tablica, której elementami są wiersze tekstu. Na przykład, "ab\ncd"i ['a','b','\n','c','d']są dozwolone, ale ['ab','cd']czy [['a','b'],['c','d']]nie. Możesz założyć, że wszystkie linie mają tę samą liczbę znaków (w razie potrzeby uzupełnione białymi spacjami).
2. Wartość logiczna, gdzie Truewskazuje odbicie Y i Falseodbicie X

Dwa wejścia można przekazać w dowolnej kolejności.

Wydajność:

Odbity ciąg. Postacie się nie zmieniają, tylko ich pozycja. Powstały blok obrazu powinien być wyrównany do lewego górnego rogu (pierwszy wiersz i kolumna muszą zawierać znak spacji). Końcowe białe znaki (w dowolnym wierszu) są dozwolone.

Przypadki testowe:

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

To jest golf golfowy , więc odpowiedz na najkrótszą odpowiedź w swoim ulubionym języku!

C #, 168 144 141 120 bajtów

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

Nowa wersja wykorzystuje oczywisty ciąg. Przeciążenie dołączenia, które wymaga IEnumerable, pierwsze rozwiązanie używało go nieumyślnie. Byłem w stanie użyć go również po drugiej stronie trójki.

Aktualizacja:

Nowa wersja to anonimowa lambda i używa curry, aby zaoszczędzić łącznie 21 bajtów. Zmienia to użycie, f("text")(false)gdzie f jest funkcją anonimową.

Nie golfowany:

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 bajtów

!I_)ncX

Wypróbuj tutaj!

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

Brainfuck, 143 140 131 bajtów

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

Beat s C #.

Wyzwanie było dość łatwe dla Brainfuck, a ja najwyraźniej byłem dość zmęczony, by po prostu to zrobić.

Pobiera wartość logiczną jako 0x00(fałsz) lub jakikolwiek inny (prawda) bajt na początku danych wejściowych, a następnie ciąg znaków wypełniony prostokątem.

Generuje końcowy znak nowej linii dla klapki Y i żadnej dla klapki X.

Wymaga interpretera, który obsługuje lokalizacje pamięci po lewej stronie startu (niepewny, czy nadal jest wymagany) i podaje EOF jako 0x00. Jeden taki tłumacz jest tutaj . Z tego powodu oczywiście nie obsługuje bajtów zerowych na wejściu.

Kod ma wiele bloków zawierających 10 +lub 10 -; można je prawdopodobnie zmniejszyć.

Skomentowana wersja

, 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-bitowy kod maszynowy x86, 76 bajtów

W hex:

31c031c9495789f7fcf2aef7d15192b00a89f7f2ae5829f7f7f787f95f4b89c3741287d94b534b8a041eaa75f95b01dea4e2f2c348f7e101c6b00a5651f3a4595e29ce4f4b0f44c3aa75f0c3

Wejście:: EBXflaga kierunku (0/1),: ESIciąg wejściowy,: EDIbufor wyjściowy. Dane wejściowe muszą być prostokątne.

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 bajtów

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

Przykład użycia:

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

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

Podziel na linie, odwróć linie (True) lub odwróć każdą linię (False) i ponownie połącz w jeden ciąg. W przypadku danych Truewejściowych map r:[r|b]jest to lista dwóch funkcji, [<reverse each line>, <reverse lines>]a dla Falsedanych wejściowych lista z jedną funkcją [<reverse each line>]. lastwybiera ostatni element tej listy.

Galaretka , 8 bajtów

ṣ⁷ṚU⁴?j⁷

Wypróbuj tutaj.

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

Python, 56 bajtów

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

Wywołanie z ciągiem si dowolną wartością true / falsey r.

Python 3.5, 61 bajtów:

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

Prosta anonimowa funkcja lambda, która zakłada wejście prostokątne. Wywołaj go, nazywając najpierw funkcję, a następnie wywołując ją w środku print(). Innymi słowy, jeśli funkcja zostały nazwane H, nazywają to podoba print(H(<Bool value>, <String>)), gdzie <Bool Value>jest jakaś wartość prawda lub fałsz (tj 0/1, true/falseitp) i <String>jest ciąg wejściowy.

Zobacz w akcji! (repl.it)

Oto kolejna wersja o tej samej długości, która również przyjmuje prostokątne dane wejściowe, ale tym razem nazwana funkcja, tzn. Nie musisz jej najpierw nazywać ani zawijać w nią print():

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

Po prostu nazywaj to tak J(<Bool Value>,<String>).

Zobacz to w akcji! (repl.it)

Jednak to nie ja się na tym zatrzymuję. Chociaż możemy zakładać prostokątne dane wejściowe, stworzyłem również wersję, która nie zakłada tego typu danych wejściowych. W związku z tym spowoduje spację wszystkich linii do tej samej długości w oparciu o linię o maksymalnej długości wtedy i tylko wtedy, gdy <Bool>dane wejściowe są False, ponieważ tylko odbicie X spowoduje „odwrócenie” łańcucha. Teraz, bez zbędnych ceregieli, oto nie-prostokątna wersja przyjmująca o długości 134 129 bajtów w postaci normalnej funkcji:

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')]))

Zobacz ten ostatni w akcji! (repl.it)

MATL , 11 bajtów

10&Ybc2i-&P

Wypróbuj online!

Pierwsze wejście jest multiline ciąg. Ponieważ MATL nie rozpoznaje źródła, wiersz \nwielowierszowy powinien być zdefiniowany jako konkatenacja podłańcuchów lub pojedynczych znaków oraz 10(ASCII dla wstawiania wiersza, który jest interpretowany jako znak). Łączenie w MATL to [... ...]lub [..., ...](przecinki są opcjonalne). Na przykład dane wejściowe mogą wyglądać następująco (konkatenacja ciągu, wysuwu wiersza i innego ciągu):

['first line' 10 'second']

lub równoważnie (łączenie pojedynczych znaków)

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

lub (to samo z przecinkami)

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

Drugie wejście może zostać wprowadzony w 1/ 0lub równoważnie w T/ Fo true/ false, odpowiednio.

Wyjaśnienie

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 bajtów

t1,?h@nr~@nw|hrw

Oczekuje listy zawierającej ciąg i wartość logiczną 1lub 0np

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

Wyjaśnienie

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 bajtów

j?Q_.z_M.z

Zestaw testowy.

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 + wspólne narzędzia linux, 16

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

Wartość logiczna (zero lub niezerowa) przekazana jako parametr wiersza polecenia. I / O bloku tekstowego przez STDIN / STDOUT. Zakłada, że ​​wszystkie linie mają tę samą długość, jak wskazano w komentarzach .

C (Ansi), 193 bajtów

Gra w golfa:

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));}

Nie golfowany:

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));
}

Stosowanie:

Argumenty kompilacyjne:

gcc -O3 -ansi

Przykładowe dane wejściowe:

Dane wejściowe są równe t lub nie dla true lub false, po których następuje nowy znak spacji i ciąg znaków.

./reverseString t "
truck
ducky
quack
moose
"

Przykładowe dane wyjściowe:

moose
quack
ducky
truck

JavaScript (ES 6) 83 bajty

(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 bajtów

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

Wypróbuj online!

J, 29 bajtów

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

Wejście LHS to wartość logiczna, gdzie 0 to fałsz, a 1 to prawda. RHS jest wejściowym ciągiem znaków.

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 bajtów

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;
}

Gra w golfa:

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 bajtów

34 bajty kod + 1 dla -n.

Wymaga wypełnienia linii wejściowych spacjami. 13 (!) Bajtów zapisanych dzięki @ Dada .

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

Stosowanie

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

/ o  
 /|--
  |  
 \ / 

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

Mathematica, 70 bajtów

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

Funkcja anonimowa przyjmuje wartość logiczną jako pierwszy argument (jawnie Truelub Falsew Mathematica), a łańcuch (wielowierszowy) jako drugi argument. Importuje ciąg jako listę ciągów odpowiadających wierszom ciągu wielowierszowego (ciąg NIE jest przekazywany do funkcji jako tablica). Jeśli Trueodwróć listę. Jeśli False StringReverselista, która jest automatycznie stosowana do każdego elementu z kolei. Następnie wyeksportuj listę jako ciąg znaków, w którym każdy element jest nową linią.

05AB1E , 10 bajtów

U|XiRë€R}»

Wyjaśnienie

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

Wypróbuj online!

Vim, 33 bajty

Zmieniono poprzednią odpowiedź V na Vima. Każda odpowiedź V byłaby inna, więc nie była tak naprawdę uczciwa.

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

Wypróbuj 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                                       .