Tarea: Dada una entrada que consiste exactamente en uno de los caracteres <>^v, genera una segunda entrada que consiste en los caracteres ASCII imprimibles (desde el espacio hasta la tilde), orientados con la flecha.

Supongamos que la segunda entrada al programa es ABC. Esto es lo que debe hacer:

• Entrada >: imprimir ABC.
• Entrada <: imprimir CBA.
• Entrada ^: imprimir C\nB\nA, o la entrada giró -90 °.
• Entrada v: imprimir A\nB\nC, o la entrada giró 90 °.

Casos de prueba

input => \n output
---
">", "thanks!" =>
thanks!
---
"<", "Hello, World!" =>
!dlroW ,olleH
---
"^", "This is text." =>
.
t
x
e
t

s
i

s
i
h
T
---
"v", "Tokyo" =>
T
o
k
y
o
---
"<", ">>>" =>
>>>

Este es un código de golf , por lo que gana el programa más corto en bytes.

MATL , 10 6 bytes

¡4 bytes guardados gracias a Martin!

19\qX!

Pruébalo en línea!

19\            % implicitly take input (a character) and compute mod-19 of its ASCII code
   q           % subtract 1. Gives 17, 2, 3, 4 for the characters '^<v>' respectively.
               % These numbers correspond to 1, 2, 3, 4 modulo 4, and so are the numbers
               % of 90-degree rotations required by each character
    X!         % implicitly take input (string). Rotate the computed number of times
               % in steps of 90 degrees. Implicitly display

Versión anterior, sin operaciones de módulo: 10 bytes

'^<v>'=fX!

Pruébalo en línea!

'^<v>'         % push string
      =        % implicitly take input (a char) and test for equality
       f       % find index of matching character
        X!     % implicitly take input (string). Rotate that number of times
               % in steps of 90 degrees. Implicitly display

Python 3, 64 51 48 bytes

Guardado 6 bytes gracias a xnor.

Guardado 7 bytes gracias a Lynn.

Guardado 3 bytes gracias a DSM y Morgan de manera pitón.

lambda c,s:'\n'[c<'?':].join(s[::1|-(c in'<^')])

La función acepta uno de los caracteres <>^vcomo primer argumento y la cadena que debe rotarse como segundo argumento.

Aquí hay una versión más legible:

lambda c, s: ('\n' if c in '^v' else '').join(s[::-1 if c in'<^' else 1])

Haskell, 57 bytes

f">"=id
f"<"=reverse
f"v"=init.((:"\n")=<<)
f _=f"<".f"v"

Ejemplo de uso: f "v" "ABC"-> "A\nB\nC".

La dirección >es la función de identidad, <invierte su argumento, vagrega una nueva línea a cada carácter en la cadena y suelta el último y ^es vseguido por <.

Japt, 9 bytes

VzUc %B+1

Inspirado por la respuesta de @ DonMuesli, aunque acabo de notar que el CJam usa exactamente la misma técnica. ¡Pruébelo en línea!

Cómo funciona

           // Implicit: U = arrow char, V = text
  Uc %B    // Take the char code of U, mod 11.
           // This converts ">", "v", "<", and "^" to 7, 8, 5, and 6, respectively.
Vz     +1  // Add one and rotate V by 90° clockwise that many times.

CJam, 13 bytes

l(iB%{W%z}*N*

La entrada es el carácter de orientación seguido directamente por la cadena a rotar.

Pruébalo aquí.

Explicación

Yay para módulo de magia. Tomando los cuatro caracteres, el módulo 11 los asigna a:

> 7 
v 8 
< 5
^ 6

Estos son todos distintos módulo 4 y más importante es que están aumentando claramente: 3, 0, 1, 2. Eso significa que podemos usar el resultado de mod 11para determinar con qué frecuencia rotar (sin necesidad de un explícito mod 4, ya que cuatro rotaciones son un no-op de todos modos). Normalmente tendríamos que compensar estos números por 1, de modo que >realmente rinda 8y se convierta en un no-op, pero la forma en que los estoy rotando, en realidad invierte la cadena en la primera aplicación de modo que siempre obtengamos una rotación gratis.

l    e# Read input.
(i   e# Pull off the first character and convert to its character code.
B%   e# Modulo 11.
{    e# That many times...
 W%  e#   Reverse... on the first iteration this reverses the string. Afterwards
     e#   we'll have an Nx1 or 1xN grid of characters on the stack, where
     e#   this reverses the rows instead.
 z   e#   Transpose. On the first iteration, this simply wraps the string in
     e#   array, turning it into a grid without changing its orientation further
     e#   beyond the reversal that just happened. On subsequent iterations, a
     e#   transpose combined with reversing the rows rotates the grid 90 degrees
     e#   clockwise.
}*
N*   e# Join with linefeeds.

Pyth 17 15

jWgz\^_W}z"<^"w

Pruébelo aquí o ejecute Test Suite

¡2 bytes guardados gracias a Jakube!

Alternativamente usando trucos mod:

@s_MBjBz)h%Cw11

Probar aquí .

Julia, 51 bytes

f(d,s)=join(d∈"<^"?reverse(s):s,d∈"^v"?"\n":"")

Esta es una función que acepta una Chary una cadena y devuelve una cadena.

Deje dser el personaje que denota la dirección y ssea ​​la cadena. Si dse deja hacia arriba o hacia arriba, usamos el reverso de s, de lo contrario, usamos scomo se indica. Construimos un separador como la cadena vacía si des izquierda o derecha, o una nueva línea si des arriba o abajo. Pasan la cadena y el separador a join, que insertará el separador entre cada carácter de la cadena y devolverá una cadena.

Verifique todos los casos de prueba en línea

Bash + GNU Utilities, 67

(egrep -q '>|v'<<<$1&&cat||rev)|(egrep -q '<|>'<<<$1&&cat||fold -1)

JavaScript (ES6), 76 67 65 bytes

(a,b)=>(/v|>/.test(a)?[...b]:[...b].reverse()).join(a>`>`?`
`:``)

Puerto de la respuesta de @Alex A. Julia. Editar: Guardado 9 bytes gracias a @ETHproductions. Guardado dos bytes por separado gracias a @ edc65.

Perl, 54 51 + 1 = 52 bytes

@.=<>=~/./g;@[email protected]/[<^]/;$,=$/x/[v^]/;say@.

Requiere la -nbandera y la libre -M5.010| -E. Toma datos como los siguientes direction\nline:

$ perl -nE'@.=<>=~/./g;@[email protected]/[<^]/;$,=$/x/[v^]/;say@.' <<< $'^\nhello'
o
l
l
e
h

Me gusta que $/x/[v^]/parece una sustitución.

Cómo funciona:

                                                    # -n read first line into $_
@.=<>=~/./g;                                        # Read next line and split
            @[email protected]/[<^]/;                   # Reverse `@.` if matches 
                                                    # `<` or `^`
                                 $,=                # An array will be concatena-
                                                    # ted with the value of 
                                                    # `$,` when printed. 
                                     $/             # Contains a newline
                                        /[v^]/      # boolean 
                                       x            # "\n" x 1 -> "\n"
                                                    # "\n" x 0 -> ""
                                              say@. # Print the array

PowerShell, 84 bytes

param([char]$a,$b)($b[($c=$b.length)..0],$b[0..$c])[$a%7-eq6]-join("","`n")[90-lt$a]

Esto será un completo galimatías para las personas que no están familiarizadas con PowerShell. Vamos a atravesarlo.

Toma entrada param([char]$a,$b), con un elenco explícito para el personaje $a. El resto del programa es una declaración. Comenzaremos con la primera mitad, hasta la -join.

Estamos creando una nueva matriz dinámica (...,...)e indexándola con ella $a%7-eq6. Los valores ASCII para vy >son 116y 62, respectivamente, y 116%7 = 62%7 = 6, y esas son las dos direcciones que "aumentan" hacia abajo y hacia la derecha. Entonces, si -eqes así $true, tomaremos el segundo valor, que es $b[0..$c], o una matriz de los caracteres $bhasta el final . Obtenemos el valor $cdel primer valor, $b[($c=$b.length)..0]que se selecciona si el carácter de entrada es ^o <(es decir, pasa por la cadena hacia atrás). Es importante tener en cuenta que incluso si se selecciona el segundo valor, el $cvalor aún se calcula y almacena, por lo que podemos reutilizarlo como un acceso directo como este.

Entonces, ahora tenemos una variedad de personajes que van hacia adelante o hacia atrás. Luego, -joinesos caracteres junto con el resultado de otro índice de matriz dinámica. Esta vez estamos seleccionando en función de si el valor ASCII para $aestá por debajo 90(realmente funcionarían muchos valores, seleccioné este solo porque). Dado que >y <ambos tienen un valor a continuación 90, el -ltes $false, por lo que seleccionamos la cadena vacía ""y, por lo tanto, la matriz de caracteres simplemente se concatena. De lo contrario, seleccionamos el carácter de nueva línea "`n"para unir el conjunto de caracteres junto con las nuevas líneas.

Esta cadena resultante se deja en la tubería y la salida es implícita.

Ejemplo

PS C:\Tools\Scripts\golfing> .\orthogonal-orientation.ps1 "^" "TimmyD"
D
y
m
m
i
T

C, 123 119 117 114 bytes

Golfizado:

f(char*d,char*a){char*b=a,c=*d%21,s[3]={0,c&8?10:0};while(*++b);while(*s=c&4?*a++:*--b)printf(s);if(c&16)puts(b);}

Programa de prueba, con explicaciones y código un tanto descuidado

#include <stdio.h>
#include <stdlib.h>

// c     c%21   
// <    10010     => if(c&8), vertical; if(c&16), horizontal
// >    10100     => if(c&4), backwards
// ^    01010
// v    01101
int f(char*d,char*a){
    char *b=a,c=*d%21,s[3]={0,c&8?10:0};
    while(*++b);     // b = a + strlen(a) - 1; this is shorter
    while(*s=c&4?*a++:*--b)printf(s);
    if(c&16)puts(b); // single trailing newline if horizontal
}

int main() {
    char *c="<>^v";
    for(;*c;c++) { 
        printf("--- %c ---\n", *c); 
        f(c,"hello world!"); 
    }
    return 0;
}

Consejos bienvenidos!

Retina , 60 bytes

Necesita golf ...

$
¶
+`^([<^].*)(.)(¶.*)
$1$3$2
¶

.
$&¶
+`([<>].*)¶
$1
^.¶?

La entrada es todo como una cadena, por ejemplo ^ABC.

• Si ^o <, invierta la cadena
• Insertar nuevas líneas después de cada personaje
• Si <o >, elimine las nuevas líneas

Pruébalo en línea.

Dyalog APL , 15 bytes

⌽∘⍉⍣(11|⎕UCS⍞)⍪

⍪convierta la cadena en una tabla de 1 columna
⍣(‍... )repita ( n ) veces ⍞obtenga la entrada de la cadena,
⎕UCSconvierta a la
11|división del punto de código UCS, descanse cuando se divida entre 11
⌽∘⍉gire -90 ° (flip-transpose)

Método alternativo (misma longitud):

⌽∘⍉⍣('<^>v'⍳⎕)⍪

⎕obtener una entrada evaluada (por lo que se debe ingresar, por ejemplo, '^' o el nombre de un programa / variable que devuelve el carácter deseado)
'<^>v'⍳índice en la cadena

Jolf, 22 bytes

Pruébalo aquí! Deberías reemplazar ƒcon \x9f. Toma el aguijón, luego el carácter direccional.

.‘I_IγƒGIE_γ’ i"><v^"i
 ‘                      golfy array
  I                     the input
   _I                   input reversed
      ƒGIE              split by "" and join by newlines
     γ                  γ = that
          _γ            gamma reversed
.            _i"><v^"i  get the respective index

JavaScript ES6, 91 83 84 bytes

(a,b)=>[b,(c=[...b].reverse()).join``,[...b].join`
`,c.join`
`]["><v^".indexOf‌​(a)]

Construye las cadenas necesarias y obtiene el índice en el que se aencuentra. indexOfSe utiliza porque ^es un token regex. ¡Gracias a ETHproductions por la corrección de errores y los bytes afeitados!

JavaScript (ES6) 71

(a,b)=>([...b].map(c=>(a>'A'?c+=`
`:0,r=/v|>/.test(a)?r+c:c+r),r=''),r)

Prueba

F=(a,b)=>([...b].map(c=>(a>'A'?c+=`
`:0,r=/v|>/.test(a)?r+c:c+r),r=''),r)  

console.log=x=>O.textContent+=x+'\n';

for(d of '<>^v') console.log(d+'\n'+F(d,'ABCDE')+'\n')

<pre id=O></pre>

Perl 5, 67 bytes

66 más uno para -p

$_=reverse if/^[<^]/;$&?s/.$//:s/.//;$&=~/[v^]/&&s/(.)(?=.)/$1\n/g

La entrada es una sola cadena cuyo primer carácter define la orientación.

DUP , 48 bytes

[`5/%$$a:4<&[1$][1_]?\1-[$;$][,^+a;2>['
,][]?]#]

Try it here.

Lambda anónima que toma tanto el argumento como la entrada STDIN. Uso:

0"asdf"[`5/%$$a:4<&[1$][1_]?\1-[$;$][,^+a;2>['
,][]?]#]! {make sure to put one of <>^v in STDIN}

Explicación

[                                               ] {lambda}
 `5/%$$a:                                         {store STDIN char (mod 5) to a}
         4<&                                      {is 0<a<4?}
            [  ][  ]?                             {conditional}
             1$                                     {if so, push 2 1's}
                 1_                                 {otherwise, push -1}
                                                    {determines whether to output in reverse or not}
                     \1-                          {swap, -1}
                        [   ][                ]#  {while loop}
                         $;$                        {if there is a char at index}
                              ,                     {output that char}
                               ^+                   {increment/decrement index}
                                 a;2>               {check if a>2}
                                     [    ][]?      {conditional}
                                      '\n,          {if so, output newline}

En serio, 41 bytes

,' 9uc#;+"? R #'{}j #R'{}j"fs,"><v^"í@E£ƒ

Toma la cadena como la primera entrada y la dirección (><v^ ) como la segunda entrada.

Pruébalo en línea!

D, 198 bytes

import std.stdio,std.array,std.algorithm;void main(string[]a){auto x=a[2].split("");char[]y;if(canFind(["^","<"],a[1]))x.reverse;if(canFind(["v","^"],a[1]))y=x.join("\n");else y=x.join("");y.write;}

:do

Menos golfizado:

import std.stdio;
import std.array;
import std.algorithm;

void main(string[]a) {

  auto x=a[2].split("");
  string y;

  if(canFind(["^","<"],a[1]))
    x.reverse;

  if(canFind(["v","^"], a[1]))
    y=join(x,"\n");

  else
    y=join(x,"");

  y.write;
}