En este desafío, se le dará un bloque de texto y deberá realizar una reflexión sobre el texto.

Entrada:

1. Una cuerda para ser reflejada. El texto no se puede suministrar como una matriz cuyos elementos son las líneas de texto. Por ejemplo, "ab\ncd"y ['a','b','\n','c','d']están permitidos, pero ['ab','cd']o [['a','b'],['c','d']]no lo son. Puede suponer que todas las líneas tienen el mismo número de caracteres (rellenadas con espacios en blanco donde sea necesario).
2. Un valor booleano donde Trueindica reflexión Y e Falseindica reflexión X

Las dos entradas se pueden pasar en cualquier orden.

Salida:

La cuerda reflejada. Los personajes no cambian, solo su posición. El bloque de imagen resultante debe estar alineado con la esquina superior izquierda (la primera fila y la columna deben contener un carácter que no sea un espacio en blanco). Se permite el espacio en blanco al final (en cualquiera de las líneas).

Casos de prueba:

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

Este es un código de golf , ¡así que responda con la respuesta más corta en su idioma favorito!

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

La nueva versión utiliza la cadena obvia. Sobrecarga conjunta que toma un IEnumerable, la primera solución fue usarlo inadvertidamente. También pude usarlo para el otro lado del ternario.

Actualizar:

La nueva versión es una lambda anónima y utiliza curry para guardar un total de 21 bytes. Esto cambia el uso para ser f("text")(false)donde f es la función anónima.

Sin golf:

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 bytes

!I_)ncX

Pruébalo aquí!

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

Brainfuck, 143 140 131 bytes

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

Batir s C #.

El desafío fue bastante fácil para Brainfuck, y aparentemente estaba lo suficientemente cansado como para tener que hacerlo.

Toma el booleano como un 0x00(falso) o cualquier otro byte (verdadero) al comienzo de la entrada, luego una cadena rellena de rectángulo.

Emite una nueva línea final para el flip Y, y ninguna para el flip X.

Requiere un intérprete que admita ubicaciones de memoria a la izquierda del inicio (no estoy seguro si aún es necesario) y proporciona EOF como 0x00. Uno de esos intérpretes está aquí . Obviamente, no admite bytes nulos en la entrada debido a eso.

El código tiene muchos bloques con 10 +'s o -' s; Es probable que se puedan reducir.

Versión comentada

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

Código de máquina x86 de 32 bits, 76 bytes

En hexadecimal:

31c031c9495789f7fcf2aef7d15192b00a89f7f2ae5829f7f7f787f95f4b89c3741287d94b534b8a041eaa75f95b01dea4e2f2c348f7e101c6b00a5651f3a4595e29ce4f4b0f44c3aa75f0c3

Entrada:: EBXindicador de dirección (0/1),: ESIcadena de entrada,: EDIbúfer de salida. Se requiere que la entrada sea rectangular.

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 bytes

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

Ejemplo de uso:

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

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

Divida en líneas, invierta las líneas (Verdadero) o invierta cada línea (Falso) y vuelva a unirlas en una sola cadena. En el caso de una Trueentrada, map r:[r|b]es una lista de dos funciones [<reverse each line>, <reverse lines>]y para una Falseentrada una lista con una función [<reverse each line>]. lastselecciona el último elemento de esta lista.

Jalea , 8 bytes

ṣ⁷ṚU⁴?j⁷

Pruébalo aquí

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

Python, 56 bytes

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

Llame con una cadena sy cualquier valor verdadero / falso r.

Python 3.5, 61 bytes:

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

Una función lambda anónima simple que asume una entrada rectangular. Llámalo nombrando primero la función y luego llamándola envuelta dentro print(). En otras palabras, si la función fueron nombrados H, llamar así print(H(<Bool value>, <String>)), donde <Bool Value>es cualquier valor verdadero o falso (es decir 0/1, true/false, etc.) y <String>es la cadena de entrada.

¡Véalo en acción! (repl.it)

Aquí hay otra versión con la misma longitud que también asume una entrada rectangular, pero esta vez una función con nombre , es decir, no tiene que nombrarla primero ni envolverla dentro print():

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

Simplemente llame a este como J(<Bool Value>,<String>).

¡Mira esto en acción! (repl.it)

Sin embargo, no soy yo quien se detiene allí. Aunque se nos permite asumir una entrada rectangular, también creé una versión que no asume ese tipo de entrada. Por lo tanto, espaciará todas las líneas a la misma longitud en función de la línea con la longitud máxima si y solo si la <Bool>entrada es False, ya que solo una reflexión X dará como resultado que la cadena se "voltee". Ahora, sin más preámbulos, aquí está la versión de suposición no rectangular con una longitud de 134 129 bytes en forma de una función 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')]))

¡Mira este último en acción! (repl.it)

MATL , 11 bytes

10&Ybc2i-&P

Pruébalo en línea!

La primera entrada es la cadena multilínea. Dado que MATL no reconoce \ncomo salto de línea, la cadena multilínea debe definirse como una concatenación de subcadenas o caracteres individuales y 10(ASCII para salto de línea, que se interpreta como un carácter). La concatenación en MATL es [... ...]o [..., ...](las comas son opcionales). Entonces, por ejemplo, la entrada puede ser la siguiente (concatenación de una cadena, salto de línea y otra cadena):

['first line' 10 'second']

o equivalente (concatenación de caracteres individuales)

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

o (lo mismo con comas)

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

La segunda entrada se puede ingresar como 1/ 0o equivalentemente como T/ Fpara true/ falserespectivamente.

Explicación

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 bytes

t1,?h@nr~@nw|hrw

Espera una lista que contiene la cadena y el booleano 1o 0, por ejemplo

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

Explicación

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 bytes

j?Q_.z_M.z

Banco de pruebas.

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 + utilidades comunes de Linux, 16

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

Valor booleano (cero o no cero) pasado como un parámetro de línea de comandos. E / S del bloque de texto a través de STDIN / STDOUT. Asume que todas las líneas tienen la misma longitud, como se indica en los comentarios .

C (Ansi), 193 bytes

Golfizado:

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

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

Uso:

Argumentos de compilación:

gcc -O3 -ansi

Entrada de ejemplo:

La entrada es t o no para verdadero o falso seguido de un encabezado de espacio de noticias y una cadena arrastrada.

./reverseString t "
truck
ducky
quack
moose
"

Salida de ejemplo:

moose
quack
ducky
truck

JavaScript (ES 6) 83 bytes

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

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

Pruébalo en línea!

J, 29 bytes

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

La entrada LHS es el booleano donde 0 es falso y 1 es verdadero. RHS es la entrada de cadena.

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 bytes

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

Golfizado:

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 bytes

Código de 34 bytes + 1 para -n.

Requiere que las líneas de entrada se rellenen con espacios. 13 (!) Bytes guardados gracias 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 bytes

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

Función anónima, toma un valor booleano como primer argumento (explícitamente Trueo Falseen Mathematica) y la cadena (multilínea) como segundo argumento. Importa la cadena como una lista de cadenas correspondientes a las líneas de la cadena multilínea (la cadena NO se pasa a la función como una matriz). Si True, invierte la lista. Si False StringReversela lista, que se aplica automáticamente a cada elemento a su vez. Luego, exporte la lista como una cadena, donde cada elemento es una nueva línea.

05AB1E , 10 bytes

U|XiRë€R}»

Explicación

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

Pruébalo en línea!

Vim, 33 bytes

Se cambió la respuesta V anterior a Vim. Cualquier respuesta V sería muy diferente, por lo que no fue realmente justo.

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

Pruébalo en línea!

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                                       .