In questa sfida, ti verrà assegnato un blocco di testo e dovrai eseguire una riflessione sul testo.

Ingresso:

1. Una stringa da riflettere. Il testo non può essere fornito come una matrice i cui elementi sono le righe di testo. Ad esempio, "ab\ncd"e ['a','b','\n','c','d']sono ammessi, ma ['ab','cd']o [['a','b'],['c','d']]non lo sono. Puoi presumere che tutte le righe abbiano lo stesso numero di caratteri (riempite con spazi bianchi dove necessario).
2. Un valore booleano dove Trueindica il riflesso Y e Falseindica il riflesso X.

I due ingressi possono essere passati in qualsiasi ordine.

Produzione:

La stringa riflessa. I personaggi non cambiano, solo la loro posizione. Il blocco di immagini risultante deve essere allineato in alto a sinistra (la prima riga e colonna devono contenere ciascuna un carattere non bianco). È consentito lo spazio bianco finale (su qualsiasi linea).

Casi test:

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

Questo è un codice-golf , quindi rispondi con la risposta più breve nella tua lingua preferita!

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

La nuova versione utilizza la stringa ovvia. Unendo il sovraccarico che prende un IEnumerable, la prima soluzione lo stava usando inavvertitamente, ero solo in grado di usarlo anche per l'altro lato del ternario.

Aggiornare:

La nuova versione è un lambda anonimo e utilizza il curry per salvare 21 byte in totale. Questo cambia l'utilizzo per essere f("text")(false)dove f è la funzione anonima.

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 byte

!I_)ncX

Provalo qui!

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

Brainfuck, 143 140 131 byte

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

Batti s C #.

La sfida è stata abbastanza facile per Brainfuck, e apparentemente ero abbastanza stanco da doverlo fare.

Prende il booleano come un 0x00byte (falso) o qualsiasi altro (verità) all'inizio dell'ingresso, quindi una stringa riempita con un rettangolo.

Emette una nuova riga finale per il Flip Y e nessuna per il Flip X.

Richiede un interprete che supporti le posizioni di memoria a sinistra dell'inizio (incerto se ancora richiesto) e fornisce EOF come 0x00. Uno di questi interpreti è qui . Ovviamente non supporta byte null nell'input a causa di ciò.

Il codice ha molti blocchi con 10 +'o -' s; quelli possono probabilmente essere ridotti.

Versione commentata

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

Codice macchina x86 a 32 bit, 76 byte

In esadecimale:

31c031c9495789f7fcf2aef7d15192b00a89f7f2ae5829f7f7f787f95f4b89c3741287d94b534b8a041eaa75f95b01dea4e2f2c348f7e101c6b00a5651f3a4595e29ce4f4b0f44c3aa75f0c3

Input:: EBXdirection flag (0/1),: ESIinput string EDI,: output buffer. L'ingresso deve essere rettangolare.

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

Esempio di utilizzo:

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

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

Dividi in linee, inverti le linee (Vero) o inverti ogni linea (Falso) e unisciti nuovamente in una singola stringa. Nel caso di un Trueinput, map r:[r|b]è un elenco di due funzioni [<reverse each line>, <reverse lines>]e per un Falseinput un elenco con una funzione [<reverse each line>]. lastseleziona l'ultimo elemento di questo elenco.

Gelatina , 8 byte

ṣ⁷ṚU⁴?j⁷

Provalo qui.

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

Chiama con una stringa se qualsiasi valore di verità / falsità r.

Python 3.5, 61 byte:

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

Una semplice funzione lambda anonima che assume input rettangolari. Chiamalo chiamando prima la funzione, quindi chiamandola racchiusa all'interno print(). In altre parole, se la funzione sono stati nominati H, come chiamarla print(H(<Bool value>, <String>)), dove <Bool Value>è alcuna vera o falsa valore (cioè 0/1, true/falseetc.) ed <String>è la stringa di input.

Guardalo in azione! (Repl.it)

Ecco un'altra versione con la stessa lunghezza che assume anche un input rettangolare, ma questa volta una funzione con nome , ovvero non è necessario nominarla per prima né racchiuderla al suo interno print():

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

Chiamalo semplicemente come J(<Bool Value>,<String>).

Guarda questo in azione! (Repl.it)

Tuttavia, non sono io a fermarmi qui. Sebbene ci sia consentito assumere un input rettangolare, ho anche creato una versione che non assume quel tipo di input. Pertanto, spazerà su tutte le linee della stessa lunghezza in base alla linea con la lunghezza massima se e solo se l' <Bool>input è False, poiché solo una riflessione X comporterà il "capovolgimento" della stringa. Ora, senza ulteriori indugi, ecco la versione ipotetica non rettangolare con una lunghezza di 134 129 byte sotto forma di una normale funzione:

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

Guarda quest'ultimo in azione! (Repl.it)

MATL , 11 byte

10&Ybc2i-&P

Provalo online!

Il primo input è la stringa multilinea. Poiché MATL non riconosce \ncome avanzamento riga, la stringa multilinea deve essere definita come una concatenazione di sottostringhe o singoli caratteri e 10(ASCII per avanzamento riga, che viene interpretato come carattere). La concatenazione in MATL è [... ...]o [..., ...](le virgole sono facoltative). Quindi, ad esempio, l'input può essere il seguente (concatenazione di una stringa, avanzamento di riga e un'altra stringa):

['first line' 10 'second']

o equivalentemente (concatenazione di singoli personaggi)

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

o (lo stesso con le virgole)

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

Il secondo ingresso può essere inserito come 1/ 0o equivalentemente come T/ Fper true/ falserispettivamente.

Spiegazione

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

Si aspetta un elenco contenente la stringa e il valore booleano 1o 0, ad es

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

Spiegazione

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 di test.

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 + utility Linux comuni, 16

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

Valore booleano (zero o diverso da zero) passato come parametro della riga di comando. I / O del blocco di testo tramite STDIN / STDOUT. Presuppone che tutte le righe abbiano la stessa lunghezza, come indicato nei commenti .

C (Ansi), 193 byte

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

Uso:

Argomenti di compilazione:

gcc -O3 -ansi

Esempio di input:

L'input è at o no per true of false seguito da un lead dello spazio news e una stringa trainata.

./reverseString t "
truck
ducky
quack
moose
"

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

Provalo online!

J, 29 byte

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

L'ingresso LHS è il valore booleano in cui 0 è falso e 1 è vero. RHS è l'input della stringa.

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

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 byte

34 byte codice + 1 per -n.

Richiede che le linee di input siano riempite di spazi. 13 (!) Byte salvati grazie a @ Dada .

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

uso

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&

Funzione anonima, assume un valore booleano come primo argomento (esplicitamente Trueo Falsein Mathematica) e la stringa (multilinea) come secondo argomento. Importa la stringa come un elenco di stringhe corrispondenti alle linee della stringa multilinea (la stringa NON viene passata alla funzione come matrice). Se True, invertire l'elenco. Se False StringReversel'elenco, che viene applicato automaticamente a ciascun elemento a sua volta. Quindi esporta l'elenco come stringa, in cui ogni elemento è una nuova riga.

05AB1E , 10 byte

U|XiRë€R}»

Spiegazione

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

Provalo online!

Vim, 33 byte

Modificata la precedente risposta V a Vim. Qualsiasi risposta V sarebbe molto diversa, quindi non era davvero corretta.

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

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