Bu zorlukta size bir metin bloğu verilecek ve metne yansıtma yapmanız gerekecek.

Giriş:

1. Yansıtılacak bir dize. Metin olabilir değil , elemanları metin satırları olan bir dizi olarak temin edilebilir. Örneğin, "ab\ncd"ve ['a','b','\n','c','d']izin verilir ancak ['ab','cd']ya [['a','b'],['c','d']]değildir. Tüm satırların aynı sayıda karaktere sahip olduğunu varsayabilirsiniz (gerektiğinde boşlukla doldurulmuş olarak).
2. TrueY yansımasını Falsegösteren ve X yansımasını gösteren bir boolean

İki giriş herhangi bir sırayla geçirilebilir.

Çıktı:

Yansıyan dize. Karakterler değişmez, sadece konumlarını değiştirir. Sonuçta ortaya çıkan görüntü bloğu sola doğru hizalanmalıdır (ilk satır ve sütunların her biri beyaz olmayan bir karakter içermelidir). İzleyen boşlukta (satırların herhangi birinde) izin verilir.

Test durumları:

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

Bu bir kod golf , bu nedenle en sevdiğiniz dilde en kısa cevaba cevap verin!

C #, 168 144 141 120 Bayt

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

Yeni sürüm açık dize kullanır. Bir IEnumerable alır aşırı yükleme, ilk çözüm yanlışlıkla onu kullanıyordu Ben sadece üçlünün diğer tarafı için de kullanabildim.

Güncelleştirme:

Yeni sürüm anonim bir lambdadır ve toplamda 21 byte tasarruf etmek için currying kullanır. Bu f("text")(false), f'nin adsız işlev olduğu yerde kullanımı değiştirir .

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 bayt

!I_)ncX

Burada dene!

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

Brainfuck, 143 140 131 bayt

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

Beat s C #.

Sorun Brainfuck için yeterince kolaydı ve görünüşe göre bunu yapmak için yeterince yorgundum.

0x00Booleanı girişin başlangıcında bir (sahte) veya başka herhangi bir (truthy) bayt, ardından dikdörtgen şeklinde bir dize olarak alır.

Y çevirme için sondaki yeni satırı, X çevirme içinse hiçbiri çıkarmaz.

Başının solundaki hafıza konumlarını destekleyen bir tercüman gerektirir (hala gerekliyse emin değil) ve EOF olarak 0x00. Böyle bir tercüman burada . Açıkçası bu nedenle girişteki boş baytları desteklemiyor.

Kodda 10 +veya daha fazla blok var -. bunlar muhtemelen azaltılabilir.

Yorumlanan sürüm

, 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 bit x86 makine kodu, 76 bayt

Onaltılı olarak:

31c031c9495789f7fcf2aef7d15192b00a89f7f2ae5829f7f7f787f95f4b89c3741287d94b534b8a041eaa75f95b01dea4e2f2c348f7e101c6b00a5651f3a4595e29ce4f4b0f44c3aa75f0c3

Giriş:: EBXyön bayrağı (0/1),: ESIgiriş dizesi ,: EDIçıkış tamponu. Giriş dikdörtgen olmalı.

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 bayt

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

Kullanım örneği:

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

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

Çizgilere ayırın, çizgileri ters çevirin (Doğru) veya her çizgiyi ters çevirin (Yanlış) ve tekrar tek bir dizeye birleştirin. Bir Truegiriş olması durumunda, map r:[r|b]iki fonksiyonun listesi [<reverse each line>, <reverse lines>]ve bir Falsegiriş için bir fonksiyona sahip bir listedir [<reverse each line>]. lastbu listenin son öğesini seçer.

Jöle , 8 bayt

ṣ⁷ṚU⁴?j⁷

Burada dene.

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

Python, 56 bayt

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

Bir dize sve herhangi bir truthy / falsey değeri ile arayın r.

Python 3.5, 61 bayt:

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

Dikdörtgen giriş yapan basit bir anonim lambda işlevi. Önce işlevi isimlendirerek ve sonra içine sarılmış olarak adlandırın print(). Fonksiyon adında olsaydı Başka bir deyişle, Hbu gibi çağrı print(H(<Bool value>, <String>))nerede, <Bool Value>herhangi doğru veya yanlış değeri (yani 0/1, true/falsevs.) ve <String>giriş dizedir.

Eylemde görün! (Repl.it)

Dikdörtgen giriş de kabul eden aynı uzunlukta başka bir sürüm, ancak bu kez adlandırılmış bir işlev, yani önce onu adlandırmanız veya içine sarmanız gerekmiyor print():

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

Buna basitçe buna benzer diyoruz J(<Bool Value>,<String>).

Bunu Eylemde Gör! (Repl.it)

Ancak, orada duracak olan ben değilim. Dikdörtgen giriş almamıza izin verilmesine rağmen, ben de bu giriş tipini almayan bir sürüm oluşturdum . Bu nedenle, yalnızca <Bool>girişlerin olması durumunda, Falseyalnızca X yansıması dizginin "çevrilmesi" ile sonuçlanacağından ve yalnızca girdi olması durumunda, maksimum uzunluktaki çizgiye bağlı olarak tüm satırları aynı uzunluğa yerleştirir . Şimdi, daha fazla uzatmadan, normal bir işlev biçiminde 134 129 bayt uzunluğundaki dikdörtgen olmayan varsayım sürümü :

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

Bu Sonuncuyu Hareket Halinde Gör! (Repl.it)

MATL , 11 bayt

10&Ybc2i-&P

Çevrimiçi deneyin!

İlk giriş satırlı dizedir. MATL \nsatır besleme olarak tanımadığından , çok satırlı dize, alt dizelerin veya tek tek karakterlerin birleştirilmesi olarak tanımlanmalıdır ve 10(karakter olarak yorumlanan satır besleme için ASCII). MATL'deki birleştirme [... ...]veya [..., ...](virgül isteğe bağlıdır). Örneğin, giriş aşağıdaki gibi olabilir (bir dize, satır beslemesi ve başka bir dize bitiştirme):

['first line' 10 'second']

veya eşdeğerde (tek tek karakterlerin birleştirilmesi)

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

veya (virgüllerle aynı)

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

İkinci giriş olarak girilebilir 1/ 0veya eşdeğer şekilde T/ Fiçin true/ falsesırasıyla.

açıklama

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 bayt

t1,?h@nr~@nw|hrw

Dizeyi ve boole içeren bir liste Bekliyor 1veya 0, örneğin

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

açıklama

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 bayt

j?Q_.z_M.z

Test odası.

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 + ortak linux araçları, 16

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

Boole değeri (sıfır veya sıfır olmayan) komut satırı parametresi olarak iletildi. STDIN / STDOUT aracılığıyla metin bloğunun G / Ç'si. Yorumlarda belirtildiği gibi tüm satırların aynı uzunlukta olduğunu varsayalım .

C (Ansi), 193 Bayt

golfed:

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

Kullanımı:

Derleme Bağımsız Değişkenleri:

gcc -O3 -ansi

Örnek Giriş:

Girdi yanlış olduğunda doğrudur, ardından bir gazete lideri ve izlenen dize.

./reverseString t "
truck
ducky
quack
moose
"

Örnek çıktı:

moose
quack
ducky
truck

JavaScript (ES 6) 83 bayt

(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 bayt

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

Çevrimiçi deneyin!

J, 29 bayt

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

LHS girişi, 0 değerinin yanlış ve 1 değerinin geçerli olduğu boole değeridir. RHS dize girişidir.

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 bayt

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

golfed:

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 bayt

İçin 34 bayt kodu + 1 -n.

Giriş hatlarının boşluklarla doldurulmasını gerektirir. @ Dada sayesinde 13 (!) Bayt kaydedildi .

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

kullanım

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

/ o  
 /|--
  |  
 \ / 

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

Mathematica, 70 bayt

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

Anonim işlev, birinci argüman (açıkça Trueveya FalseMathematica'da) ve bir ikinci argüman olarak (multiline) dizesi olarak bir boolean değeri alır . Dize, çok satırlı dizenin satırlarına karşılık gelen dizelerin bir listesi olarak alır (dizi, işleve dizi olarak iletilmez). Varsa Truelisteyi tersine çevirin. Eğer False StringReverseher bir elemana otomatik olarak uygulanan liste sırayla uygulanırsa. Sonra listeyi her elemanın yeni bir satır olduğu bir string olarak dışa aktarın.

05AB1E , 10 bayt

U|XiRë€R}»

açıklama

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

Çevrimiçi deneyin!

Vim, 33 bayt

Vim'deki önceki V cevabı değiştirildi. Herhangi bir V cevabı çok farklı olurdu, bu yüzden adil değildi.

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

Çevrimiçi deneyin!

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                                       .