ในการท้าทายนี้คุณจะได้รับบล็อคข้อความและคุณต้องทำการไตร่ตรองข้อความ

การป้อนข้อมูล:

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

เวอร์ชั่นใหม่ใช้สตริงที่ชัดเจนเข้าร่วมเกินพิกัดที่ใช้ IEnumerable โซลูชันแรกคือใช้งานโดยไม่ได้ตั้งใจฉันก็สามารถใช้งานได้กับอีกด้านหนึ่งของไตรภาคเช่นกัน

ปรับปรุง:

เวอร์ชันใหม่เป็นแลมบ์ดานิรนามและใช้การแกงเพื่อบันทึกผลรวม 21 ไบต์ นี่เป็นการเปลี่ยนแปลงการใช้งานf("text")(false)โดยที่ f คือฟังก์ชันที่ไม่ระบุตัวตน

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 ไบต์

!I_)ncX

ลองที่นี่!

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

Brainfuck, 143 140 131 ไบต์

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

เอาชนะs C #

ความท้าทายนั้นง่ายพอสำหรับ Brainfuck และเห็นได้ชัดว่าฉันเหนื่อยมากพอที่จะทำมัน

ใช้บูลีนเป็น0x00(falsy) หรือไบต์ (ความจริง) อื่น ๆ ในจุดเริ่มต้นของอินพุตจากนั้นเป็นสตริงที่มีเบาะสี่เหลี่ยมผืนผ้า

แสดงบรรทัดใหม่ต่อท้ายสำหรับการพลิก Y และไม่มีการพลิก X

ต้องใช้ล่ามว่าสถานที่หน่วยความจำสนับสนุนไปทางซ้ายของการเริ่มต้น (ไม่แน่ใจว่ายังคงจำเป็นต้องใช้) และให้ EOF 0x00เป็น หนึ่งล่ามดังกล่าวคือที่นี่ เห็นได้ชัดว่าไม่รองรับไบต์ว่างในอินพุตเนื่องจากสิ่งนั้น

รหัสมีบล็อกจำนวนมากที่มี 10 +หรือ-วินาที สิ่งเหล่านั้นอาจลดลงได้

แสดงความคิดเห็นรุ่น

, 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) หรือย้อนกลับแต่ละบรรทัด (เท็จ) และเข้าร่วมในสายเดียวอีกครั้ง ในกรณีที่มีการ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.

Python ขนาด 56 ไบต์

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

โทรหาสตริงsและ truthy 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)

นี่คืออีกเวอร์ชั่นที่มีความยาวเท่ากันซึ่งถือว่าอินพุตเป็นสี่เหลี่ยมผืนผ้า แต่คราวนี้ a ชื่อฟังก์ชั่นคือคุณไม่ได้ตั้งชื่อให้มันแรกหรือห่อมันไว้ภายในprint():

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

J(<Bool Value>,<String>)เพียงโทรหนึ่งเช่นนี้

ดูสิ่งนี้ใน Action! (repl.it)

อย่างไรก็ตามฉันไม่ใช่คนหยุดที่นั่น แม้ว่าเราจะได้รับอนุญาตให้สมมติว่าเป็นอินพุตแบบสี่เหลี่ยม แต่ฉันก็สร้างเวอร์ชันที่ไม่ถือว่าประเภทอินพุตนั้น ดังนั้นมันจะเว้นวรรคทุกบรรทัดให้มีความยาวเท่ากันโดยขึ้นอยู่กับบรรทัดที่มีความยาวสูงสุดถ้าหาก<Bool>อินพุตนั้นFalseเป็นเพียงการสะท้อน X เท่านั้นที่จะส่งผลให้สตริงเป็น "พลิก" ตอนนี้หากไม่มี ado เพิ่มเติมต่อไปนี้เป็นเวอร์ชันสมมติที่ไม่ใช่รูปสี่เหลี่ยมผืนผ้าที่มีความยาว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 คือ[... ...]หรือ[..., ...](เครื่องหมายจุลภาคเป็นตัวเลือก) ตัวอย่างเช่นอินพุตสามารถเป็นดังนี้ (การต่อข้อมูลสตริง, linefeed และสตริงอื่น):

['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

Brachylog , 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 + utils ทั่วไปของ linux, 16

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

ส่งค่าบูลีน (ศูนย์หรือไม่เป็นศูนย์) เป็นพารามิเตอร์บรรทัดคำสั่ง I / O ของบล็อคข้อความผ่าน 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));}

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

การใช้งาน:

การรวบรวมข้อโต้แย้ง:

gcc -O3 -ansi

อินพุตตัวอย่าง:

อินพุตมีค่าหรือไม่สำหรับความจริงของเท็จตามด้วยลีดนำของนักข่าวและสตริงที่มีการติดตาม

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

Julia ขนาด 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 /

Mathematica, 70 ไบต์

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

ฟังก์ชัน Anonymous ใช้ค่าบูลีนเป็นอาร์กิวเมนต์แรก (อย่างชัดเจนTrueหรือFalseใน Mathematica) และสตริง (multiline) เป็นอาร์กิวเมนต์ที่สอง อิมพอร์ตสตริงเป็นรายการสตริงที่สอดคล้องกับบรรทัดของสตริงหลายบรรทัด (สตริงไม่ถูกส่งผ่านไปยังฟังก์ชันเป็นอาร์เรย์) ถ้า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

ลองออนไลน์!

เป็นกลุ่ม 33 ไบต์

เปลี่ยนคำตอบ V ก่อนหน้าเป็น Vim คำตอบ V ใด ๆ จะแตกต่างกันไปดังนั้นมันจึงไม่ยุติธรรมเลย

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

ลองออนไลน์!

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                                       .