Trong thử thách này, bạn sẽ được cung cấp một khối văn bản và bạn cần thực hiện phản chiếu trên văn bản.

Đầu vào:

1. Một chuỗi được phản ánh. Văn bản có thể không được cung cấp dưới dạng một mảng có các thành phần là các dòng văn bản. Ví dụ, "ab\ncd"và ['a','b','\n','c','d']được cho phép, nhưng ['ab','cd']hoặc [['a','b'],['c','d']]không. Bạn có thể giả sử rằng tất cả các dòng có cùng số lượng ký tự (được thêm vào khoảng trắng khi cần thiết).
2. Boolean trong đó Truechỉ ra phản xạ Y và Falsechỉ ra phản xạ X

Hai đầu vào có thể được thông qua theo thứ tự bất kỳ.

Đầu ra:

Chuỗi phản ánh. Các nhân vật không thay đổi, chỉ vị trí của họ. Khối hình ảnh kết quả phải được căn chỉnh ở trên cùng bên trái (mỗi hàng và cột đầu tiên phải chứa một ký tự không phải khoảng trắng). Khoảng trắng lưu trữ (trên bất kỳ dòng nào) được cho phép.

Các trường hợp thử nghiệm:

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

Đây là một môn đánh gôn , vì vậy hãy trả lời bằng câu trả lời ngắn nhất bằng ngôn ngữ yêu thích của bạn!

C #, 168 144 141 120 byte

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

Phiên bản mới sử dụng chuỗi rõ ràng. Quá tải quá mức cần một IEnumerable, giải pháp đầu tiên là vô tình sử dụng tôi cũng có thể sử dụng nó cho phía bên kia của ternary.

Cập nhật:

Phiên bản mới là lambda ẩn danh và sử dụng currying để tiết kiệm tổng cộng 21 byte. Điều này thay đổi cách sử dụng thành f("text")(false)nơi f là hàm ẩn danh.

Ung dung:

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 byte

!I_)ncX

Hãy thử nó ở đây!

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

Brainfuck, 143 140 131 byte

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

Beat của C #.

Thử thách đã đủ dễ dàng cho Brainfuck, và rõ ràng tôi đã đủ mệt mỏi khi phải làm điều đó.

Lấy boolean dưới dạng một 0x00byte (giả) hoặc bất kỳ byte (trung thực) nào khác khi bắt đầu nhập, sau đó là một chuỗi hình chữ nhật có đệm.

Xuất ra một dòng mới theo dõi cho lật Y và không có dòng nào cho lật X.

Yêu cầu một trình thông dịch hỗ trợ các vị trí bộ nhớ ở bên trái của sự khởi đầu (không chắc chắn nếu vẫn được yêu cầu) và cung cấp EOF như 0x00. Một thông dịch viên như vậy là ở đây . Rõ ràng là không hỗ trợ byte rỗng trong đầu vào vì điều đó.

Mã này có rất nhiều khối với 10 +hoặc -s; những người có lẽ có thể được giảm.

Phiên bản đã bình luận

, 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
]

Mã máy 32 bit x86, 76 byte

Trong hex:

31c031c9495789f7fcf2aef7d15192b00a89f7f2ae5829f7f7f787f95f4b89c3741287d94b534b8a041eaa75f95b01dea4e2f2c348f7e101c6b00a5651f3a4595e29ce4f4b0f44c3aa75f0c3

Đầu vào :: EBXcờ hướng (0/1) , ESI: chuỗi đầu vào , EDI: bộ đệm đầu ra. Đầu vào được yêu cầu phải là hình chữ nhật.

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 byte

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

Ví dụ sử dụng:

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

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

Chia thành các dòng, đảo ngược các dòng (Đúng) hoặc đảo ngược từng dòng (Sai) và nối lại thành một chuỗi. Trong trường hợp Trueđầu vào, map r:[r|b]là danh sách gồm hai hàm [<reverse each line>, <reverse lines>]và đối với Falseđầu vào là danh sách có một hàm [<reverse each line>]. lastchọn yếu tố cuối cùng của danh sách này.

Thạch , 8 byte

ṣ⁷ṚU⁴?j⁷

Hãy thử nó ở đây.

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

Python, 56 byte

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

Gọi với một chuỗi svà bất kỳ giá trị trung thực / falsey r.

Python 3.5, 61 byte:

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

Một hàm lambda ẩn danh đơn giản giả định đầu vào hình chữ nhật. Gọi nó bằng cách trước tiên đặt tên hàm, và sau đó gọi nó được bọc bên trong print(). Nói cách khác, nếu các chức năng được đặt tên H, gọi nó là thích print(H(<Bool value>, <String>)), nơi <Bool Value>là bất kỳ giá trị đúng hay sai (ví dụ 0/1, true/falsevv) và <String>là chuỗi đầu vào.

Xem nó trong hành động! (thay thế)

Đây là một phiên bản khác có cùng độ dài cũng giả sử đầu vào hình chữ nhật, nhưng lần này là một hàm được đặt tên , tức là bạn không phải đặt tên cho nó trước cũng như không bọc nó bên trong print():

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

Đơn giản chỉ cần gọi cái này như thế J(<Bool Value>,<String>).

Xem điều này trong hành động! (thay thế)

Tuy nhiên, tôi không phải là người dừng lại ở đó. Mặc dù chúng tôi được phép giả định đầu vào hình chữ nhật, tôi cũng đã tạo một phiên bản không giả định loại đầu vào đó. Do đó, nó sẽ đệm không gian tất cả các dòng có cùng độ dài dựa trên dòng có độ dài tối đa khi và chỉ khi <Bool>đầu vào là False, vì chỉ có phản xạ X sẽ dẫn đến chuỗi bị "lật". Bây giờ, không cần phải quảng cáo thêm, đây là phiên bản giả định không phải hình chữ nhật với độ dài 134 129 byte ở dạng hàm bình thường:

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

Xem cái cuối cùng này trong hành động! (thay thế)

MATL , 11 byte

10&Ybc2i-&P

Hãy thử trực tuyến!

Đầu vào đầu tiên là chuỗi multiline. Vì MATL không nhận dạng \nlà 10nguồn cấp dữ liệu, nên chuỗi đa dòng phải được định nghĩa là nối các chuỗi con hoặc các ký tự riêng lẻ và (ASCII cho nguồn cấp dữ liệu, được hiểu là một ký tự). Ghép trong MATL là [... ...]hoặc [..., ...](dấu phẩy là tùy chọn). Vì vậy, ví dụ, đầu vào có thể như sau (nối chuỗi, chuỗi cấp và chuỗi khác):

['first line' 10 'second']

hoặc tương đương (ghép các ký tự riêng lẻ)

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

hoặc (giống với dấu phẩy)

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

Đầu vào thứ hai có thể được nhập dưới dạng 1/ 0hoặc tương ứng là T/ Fcho true/ falsetương ứng.

Giải trình

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 byte

t1,?h@nr~@nw|hrw

Yêu cầu một danh sách chứa chuỗi và boolean 1hoặc 0, vd

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

Giải trình

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

Bình thường, 10 byte

j?Q_.z_M.z

Bộ thử nghiệm.

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 + tiện ích linux phổ biến, 16

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

Giá trị Boolean (không hoặc không khác) được truyền dưới dạng tham số dòng lệnh. I / O của khối văn bản thông qua STDIN / STDOUT. Giả sử rằng tất cả các dòng có cùng độ dài, như được nêu trong các ý kiến .

C (Ansi), 193 byte

Chơi gôn

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

Ung dung:

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

Sử dụng:

Lập luận tổng hợp:

gcc -O3 -ansi

Ví dụ đầu vào:

Đầu vào là hoặc không đúng với sai, theo sau là một đầu báo và chuỗi kéo.

./reverseString t "
truck
ducky
quack
moose
"

Kết quả ví dụ:

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 byte

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

Hãy thử trực tuyến!

J, 29 byte

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

Đầu vào LHS là boolean trong đó 0 là sai và 1 là đúng. RHS là đầu vào chuỗi.

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 byte

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

Chơi gôn

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 byte

Mã 34 byte + 1 cho -n .

Yêu cầu các dòng đầu vào được đệm bằng khoảng trắng. 13 (!) Byte được lưu nhờ @ Dada .

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

Sử dụng

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

/ o  
 /|--
  |  
 \ / 

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

Toán học, 70 byte

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

Hàm ẩn danh, lấy giá trị boolean làm đối số thứ nhất (rõ ràng Truehoặc Falsetrong Mathicala) và chuỗi (multiline) làm đối số thứ hai. Nhập chuỗi dưới dạng danh sách các chuỗi tương ứng với các dòng của chuỗi đa dòng (chuỗi KHÔNG được truyền cho hàm dưới dạng một mảng). Nếu True, đảo ngược danh sách. Nếu False StringReversedanh sách, lần lượt tự động được áp dụng cho từng yếu tố. Sau đó xuất danh sách dưới dạng một chuỗi, trong đó mỗi phần tử là một dòng mới.

05AB1E , 10 byte

U|XiRë€R}»

Giải trình

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

Hãy thử trực tuyến!

Vim, 33 byte

Thay đổi câu trả lời V trước đó cho Vim. Bất kỳ câu trả lời V sẽ khác nhau, vì vậy nó không thực sự công bằng.

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

Hãy thử trực tuyến!

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                                       .