Dalam tantangan ini, Anda akan diberi blok teks, dan Anda perlu melakukan refleksi pada teks.

Memasukkan:

1. String yang akan direfleksikan. Teks mungkin tidak disediakan sebagai array yang elemen-elemennya adalah garis-garis teks. Misalnya, "ab\ncd"dan ['a','b','\n','c','d']diperbolehkan, namun ['ab','cd']atau [['a','b'],['c','d']]tidak. Anda dapat mengasumsikan bahwa semua garis memiliki jumlah karakter yang sama (diisi dengan spasi putih jika diperlukan).
2. Boolean di mana Truemenunjukkan refleksi Y dan Falsemenunjukkan refleksi X

Dua input dapat dikirimkan dalam urutan apa pun.

Keluaran:

String yang dipantulkan. Karakter tidak berubah, hanya posisinya. Blok gambar yang dihasilkan harus disejajarkan ke kiri atas (baris dan kolom pertama masing-masing harus mengandung karakter non-spasi). Trailing whitespace (pada sembarang garis) diizinkan.

Kasus uji:

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

Ini adalah kode-golf , jadi jawablah dengan jawaban terpendek dalam bahasa favorit Anda!

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

Versi baru menggunakan string yang jelas. Bergabung berlebihan yang mengambil IEnumerable, solusi pertama adalah menggunakannya secara tidak sengaja saya hanya bisa menggunakannya untuk sisi lain dari ternary juga.

Memperbarui:

Versi baru adalah lambda anonim dan menggunakan currying untuk menyimpan total 21 byte. Ini mengubah penggunaan menjadi di f("text")(false)mana f adalah fungsi anonim.

Tidak Disatukan:

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

Coba di sini!

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

Brainfuck, 143 140 131 byte

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

Kocok s C #.

Tantangannya cukup mudah bagi Brainfuck, dan saya tampaknya cukup lelah untuk melakukannya.

Mengambil boolean sebagai 0x00byte (falsy) atau byte (kebenaran) lainnya di awal input, kemudian string yang berlapis persegi panjang.

Menghasilkan baris tambahan untuk Y flip, dan tidak ada untuk X flip.

Membutuhkan juru bahasa yang mendukung lokasi memori di sebelah kiri awal (tidak yakin jika masih diperlukan) dan memberikan EOF sebagai 0x00. Salah satu penerjemah semacam itu ada di sini . Jelas tidak mendukung byte nol di input karena itu.

Kode ini memiliki banyak blok dengan 10 +'s atau -' s; itu mungkin bisa dikurangi.

Versi yang dikomentari

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

Kode mesin x86 32-bit, 76 byte

Dalam hex:

31c031c9495789f7fcf2aef7d15192b00a89f7f2ae5829f7f7f787f95f4b89c3741287d94b534b8a041eaa75f95b01dea4e2f2c348f7e101c6b00a5651f3a4595e29ce4f4b0f44c3aa75f0c3

Input:: EBXbendera arah (0/1),: ESIstring input,: EDIbuffer output. Input harus berbentuk persegi panjang.

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

Contoh penggunaan:

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

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

Membagi menjadi beberapa baris, baik membalikkan garis (Benar) atau membalikkan setiap baris (Salah) dan bergabung menjadi satu string lagi. Dalam hal Trueinput, map r:[r|b]adalah daftar dua fungsi [<reverse each line>, <reverse lines>]dan untukFalse input daftar dengan satu fungsi [<reverse each line>]. lastpilih elemen terakhir dari daftar ini.

Jelly , 8 byte

ṣ⁷ṚU⁴?j⁷

Coba di sini.

ṣ⁷         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])

Panggil dengan string sdan nilai truey / falsey r.

Python 3.5, 61 byte:

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

Fungsi lambda anonim sederhana yang mengasumsikan input persegi panjang. Sebut dengan terlebih dahulu memberi nama fungsi, dan kemudian memanggilnya terbungkus di dalamnya print(). Dengan kata lain, jika fungsi bernama H, sebut saja seperti print(H(<Bool value>, <String>)), di mana <Bool Value>adalah setiap nilai benar atau salah (yaitu 0/1, true/false, dll) dan <String>merupakan input string.

Lihat dalam Aksi! (repl.it)

Berikut adalah versi lain dengan panjang yang sama yang juga mengasumsikan input persegi panjang, tetapi kali ini sebuah fungsi bernama , yaitu Anda tidak harus menyebutkannya terlebih dahulu atau membungkusnya di dalam print():

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

Sebut saja seperti ini J(<Bool Value>,<String>).

Lihat ini dalam Aksi! (repl.it)

Namun, saya bukan orang yang berhenti di situ. Meskipun kami diizinkan untuk menerima input persegi panjang, saya juga membuat versi yang tidak berasumsi tipe input itu. Oleh karena itu, itu akan spasi-pad semua garis dengan panjang yang sama berdasarkan pada garis dengan panjang maksimum jika dan hanya jika <Bool>input False, karena hanya refleksi-X akan menghasilkan string yang "terbalik". Sekarang, tanpa basa-basi lagi, berikut adalah versi asumsi non-persegi panjang dengan panjang 134 129 byte dalam bentuk fungsi normal:

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

Lihat Aksi Terakhir Ini! (repl.it)

MATL , 11 byte

10&Ybc2i-&P

Cobalah online!

The masukan pertama adalah string multiline. Karena MATL tidak dikenali \nsebagai linefeed, string multiline harus didefinisikan sebagai gabungan dari substring, atau karakter individu, dan 10(ASCII untuk umpan baris, yang ditafsirkan sebagai karakter). Penggabungan dalam MATL adalah [... ...]atau [..., ...](koma opsional). Jadi misalnya, input dapat berupa sebagai berikut (rangkaian string, linefeed, dan string lain):

['first line' 10 'second']

atau setara (gabungan karakter individu)

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

atau (sama dengan koma)

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

The input kedua dapat dimasukkan sebagai 1/ 0atau ekuivalen sebagai T/ Funtuk true/false masing-masing.

Penjelasan

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

Mengharapkan daftar yang berisi string dan boolean 1atau 0, misalnya

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

Penjelasan

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 byte

j?Q_.z_M.z

Suite uji.

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 + utilitas linux umum, 16

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

Nilai Boolean (nol atau non-nol) dilewatkan sebagai parameter baris perintah. I / O dari blok teks melalui STDIN / STDOUT. Asumsikan bahwa semua baris memiliki panjang yang sama, seperti yang ditunjukkan dalam komentar .

C (Ansi), 193 Bytes

Golf:

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

Tidak Disatukan:

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

Pemakaian:

Argumen Kompilasi:

gcc -O3 -ansi

Input Contoh:

Input adalah t atau tidak untuk true of false diikuti oleh lead koran dan string tertinggal.

./reverseString t "
truck
ducky
quack
moose
"

Contoh Output:

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

Cobalah online!

J, 29 byte

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

Input LHS adalah boolean di mana 0 salah dan 1 benar. RHS adalah input string.

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

Golf:

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

34 byte kode +1 untuk -n.

Membutuhkan garis input diisi dengan spasi. 13 (!) Byte disimpan berkat @ Dada .

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

Pemakaian

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

/ o  
 /|--
  |  
 \ / 

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

Mathematica, 70 byte

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

Fungsi anonim, mengambil nilai boolean sebagai argumen pertama (secara eksplisit Trueatau Falsedalam Mathematica) dan string (multiline) sebagai argumen kedua. Mengimpor string sebagai daftar string yang sesuai dengan garis-garis string multiline (string TIDAK diteruskan ke fungsi sebagai array). Jika True, balik daftar. Jika False StringReversedaftar, yang secara otomatis diterapkan ke setiap elemen secara bergantian. Kemudian ekspor daftar sebagai string, di mana setiap elemen adalah baris baru.

05AB1E , 10 byte

U|XiRë€R}»

Penjelasan

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

Cobalah online!

Vim, 33 byte

Mengubah jawaban V sebelumnya ke Vim. Setiap jawaban V akan sangat berbeda, jadi itu tidak terlalu adil.

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

Cobalah 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                                       .