У цьому виклику вам буде наданий текстовий блок, і вам потрібно виконати роздуми над текстом.

Вхід:

1. Рядок для відображення. Текст може не подаватися у вигляді масиву, елементами якого є рядки тексту. Наприклад, "ab\ncd"і ['a','b','\n','c','d']допускається, але ['ab','cd']чи [['a','b'],['c','d']]немає. Ви можете припустити, що всі рядки мають однакову кількість символів (там, де це потрібно, залиті пробілом).
2. Булевий, де Trueвказується відбиття Y і Falseпозначається X відбиття

Два входи можна передавати в будь-якому порядку.

Вихід:

Відображена рядок. Персонажі не змінюються, лише їх положення. Отриманий блок зображення повинен бути вирівняний у верхньому лівому куті (перший рядок і стовпець повинні містити символ, що не містить пробілів). Допускається пробіл пробілів (на будь-якій з ліній).

Тестові приклади:

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

Це кодовий гольф , тому відповідайте найкоротшою відповіддю улюбленою мовою!

C #, 168 144 141 120 байт

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

Нова версія використовує очевидний string.Join перевантаження, яке сприймає IEnumerable, перше рішення було використовувати його ненавмисно. Я просто міг використовувати його і для іншої сторони потрійного.

Оновлення:

Нова версія - це анонімна лямбда і використовує currying, щоб зберегти 21 байт. Це змінює використання, щоб бути f("text")(false)там, де f - анонімна функція.

Безголівки:

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

Пайк, 7 байт

!I_)ncX

Спробуйте тут!

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

Brainfuck, 143 140 131 байт

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

Beat s C #.

Виклик був досить легким для Brainfuck, і я, мабуть, втомився досить, щоб просто це зробити.

Бульський сприймає як a 0x00 сигнал (фальшивий) або будь-який інший (трибутий) байт на початку введення, а потім рядок, наповнений прямокутником.

Виводить нову лінію для перевороту Y, а жодну - для перевороту X.

Потрібен інтерпретатор, який підтримує місця пам'яті зліва від початку (не впевнений, якщо це все ще потрібно) та надає EOF як 0x00. Один такий перекладач є тут . Очевидно, не підтримує нульові байти вхідних даних через це.

У коді багато блоків з 10 + або- s; ці, ймовірно, можуть бути зменшені.

Коментована версія

, 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-розрядний машинний код x86, 76 байт

У шістнадцятковій формі:

31c031c9495789f7fcf2aef7d15192b00a89f7f2ae5829f7f7f787f95f4b89c3741287d94b534b8a041eaa75f95b01dea4e2f2c348f7e101c6b00a5651f3a4595e29ce4f4b0f44c3aa75f0c3

Вхід:: EBXпрапор напряму (0/1),: ESIрядок введення,: EDIвихідний буфер. Вхід повинен бути прямокутним.

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 байт

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

Приклад використання:

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

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

Розділіть на рядки або переверніть рядки (True) або переверніть кожен рядок (False) і знову з'єднайтеся в один рядок. У випадку Trueвведення map r:[r|b]- це список двох функцій, [<reverse each line>, <reverse lines>]а для Falseвведення - список з однією функцією [<reverse each line>]. lastвибирає останній елемент цього списку.

Желе , 8 байт

ṣ⁷ṚU⁴?j⁷

Спробуйте тут.

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

Пітон, 56 байт

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

Дзвінок за допомогою рядка sта будь-якого значення truthy / falsey r.

Python 3,5, 61 байт:

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

Проста анонімна лямбда-функція, яка передбачає прямокутний ввід. Викличте його, спочатку назвавши функцію, а потім зателефонувавши до неї всередині print(). Іншими слова, якщо функція була названа H, називають це подобається print(H(<Bool value>, <String>)), де <Bool Value>будь-яка істина або брехня значення (тобто 0/1, true/falseі т.д.) і <String>є рядком введення.

Дивіться це в дії! (repl.it)

Ось ще одна версія такої ж довжини, яка також передбачає прямокутне введення, але цього разу названа функція, тобто вам не потрібно її називати спочатку і не загортати всередину print():

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

Просто назвіть цю схожу J(<Bool Value>,<String>).

Дивіться це в дії! (repl.it)

Однак я не зупиняюся на цьому. Хоча нам дозволяється приймати прямокутний ввід, я також створив версію, яка цього не робить передбачає такого типу введення. Таким чином, він буде прокладати пробіли всі рядки на однакову довжину на основі рядка з максимальною довжиною, якщо і тільки тоді, коли <Bool>вхід є False, оскільки лише X-відображення призведе до того, що рядок буде "перевернуто". Тепер, без зайвих помилок, ось не прямокутна припущенна версія довжиною 134 129 байт у формі нормальної функції:

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

Дивіться цю останню в дії! (repl.it)

MATL , 11 байт

10&Ybc2i-&P

Спробуйте в Інтернеті!

Перший входом є многострочной рядком. Оскільки MATL не розпізнає подачу \nрядків, рядок багаторядкових слід визначати як об'єднання підрядів або окремих символів та 10(ASCII для каналу рядків, що інтерпретується як символ). З'єднання в MATL є [... ...]або [..., ...](коми не є обов'язковими). Так, наприклад, введення може бути таким (об'єднання рядка, передача рядків та інший рядок):

['first line' 10 'second']

або рівнозначно (об'єднання окремих символів)

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

або (те саме з комами)

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

Другий вхід може бути введений як 1/ 0або , що еквівалентно , як T/ Fдля true/ falseвідповідно.

Пояснення

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

Брахілог , 26 24 16 байт

t1,?h@nr~@nw|hrw

Очікує список, що містить рядок і булева 1або 0, наприклад,

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

Пояснення

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 байт

j?Q_.z_M.z

Тестовий набір.

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 + загальні утиліти Linux, 16

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

Булеве значення (нульове або ненульове) передається як параметр командного рядка. Введення / виведення текстового блоку через STDIN / STDOUT. Припускає, що всі рядки однакової довжини, як зазначено в коментарях .

C (Ansi), 193 байт

Гольф:

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

Безголівки:

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

Використання:

Аргументи компіляції:

gcc -O3 -ansi

Приклад введення:

Введення не відповідає t або не відповідає дійсності false, після чого слід вести простір новин і прострочену рядок.

./reverseString t "
truck
ducky
quack
moose
"

Приклад Вихід:

moose
quack
ducky
truck

JavaScript (ES 6) 83 байти

(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  
  /|--
   |  
  \ / "

Джулія, 59 байт

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

Спробуйте в Інтернеті!

J, 29 байт

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

LHS-вхід булевий, де 0 неправдиво, а 1 - істинне. RHS - рядок.

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 байт

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

Гольф:

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 байт

34 байти код + 1 для -n .

Потрібно, щоб рядки вводу були пробілами. 13 (!) Байтів збережено завдяки @ Dada .

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

Використання

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

/ o  
 /|--
  |  
 \ / 

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

Математика, 70 байт

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

Анонімна функція, приймає булеве значення як перший аргумент (явно) True або Falseв Mathematica), а (багаторядковий) рядок як другий аргумент. Імпортує рядок у вигляді списку рядків, відповідних рядкам багаторядкової рядка (рядок НЕ передається функції як масив). Якщо True, перевірте список. Якщо False StringReverseсписок, який автоматично застосовується до кожного елемента по черзі. Потім експортуйте список у вигляді рядка, де кожен елемент є новим рядком.

05AB1E , 10 байт

U|XiRë€R}»

Пояснення

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

Спробуйте в Інтернеті!

Vim, 33 байти

Змінено попередню V відповідь на Vim. Будь-яка відповідь V була б по-іншому, тому це було не зовсім справедливо.

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

Спробуйте в Інтернеті!

Гексдумп

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                                       .