Tarefa: Dada uma entrada que consiste exatamente de um dos caracteres <>^v, produza uma segunda entrada que consiste nos caracteres ASCII imprimíveis (do espaço ao til), orientados com a seta.

Vamos supor que a segunda entrada para o programa seja ABC. Isto é o que deve fazer:

• Entrada >: impressão ABC.
• Entrada <: impressão CBA.
• Entrada ^: impressão C\nB\nAou a entrada girou -90 °.
• Entrada v: imprima A\nB\nCou a entrada girou 90 °.

Casos de teste

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 é um código de golfe , portanto o programa mais curto em bytes vence.

MATL , 10 6 bytes

4 bytes salvos graças ao Martin!

19\qX!

Experimente online!

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

Versão antiga, sem operações de módulo: 10 bytes

'^<v>'=fX!

Experimente online!

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

Economizou 6 bytes graças ao xnor.

Economizou 7 bytes graças a Lynn.

Economizou 3 bytes graças ao DSM e Morgan de tão python.

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

A função aceita um dos caracteres de <>^vcomo o primeiro argumento e a string que precisa ser girada como o segundo argumento.

Aqui está uma versão mais legível:

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"

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

Direction >é a função de idendidade, <inverte seu argumento, vacrescenta uma nova linha a cada caractere na string e descarta o último e ^é vseguido por <.

Japonês, 9 bytes

VzUc %B+1

Inspirado na resposta de @ DonMuesli, embora eu tenha acabado de notar que o CJam usa exatamente a mesma técnica. Teste online!

Como 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*

Entrada é o caractere de orientação seguido diretamente pela sequência a ser girada.

Teste aqui.

Explicação

Yay para módulo de magia. Tomando os quatro caracteres, o módulo 11 os mapeia para:

> 7 
v 8 
< 5
^ 6

Estes são todos modulo distinta 4 e mais importante é que eles são nitidamente crescente: 3, 0, 1, 2. Isso significa que podemos apenas usar o resultado de mod 11para determinar com que freqüência girar (sem precisar de um explícito mod 4, pois quatro rotações são opcionais). Normalmente, teríamos que compensar esses números por 1, de modo que >realmente produza 8e se torna um no-op, mas a maneira como estou girando-os, na verdade, inverte a string no primeiro aplicativo, para que sempre tenhamos uma rotação gratuitamente.

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

Experimente aqui ou execute o Test Suite

2 bytes salvos graças ao Jakube!

Como alternativa, usando truques de mod:

@s_MBjBz)h%Cw11

Experimente aqui .

Julia, 51 bytes

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

Esta é uma função que aceita Charuma string e retorna uma string.

Seja do caractere que indica a direção e sseja a string. Se dfor deixado para cima ou para cima, usamos o inverso de s, caso contrário, usamos scomo fornecido. Construímos um separador como a string vazia, se dfor esquerda ou direita, ou uma nova linha, se destiver acima ou abaixo. Passe a string e o separador para join, que inserirá o separador entre cada caractere da string e retornará uma string.

Verifique todos os casos de teste online

Utilitários Bash + GNU, 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>`>`?`
`:``)

Porto da resposta de @Alex A. na Julia. Editar: salvou 9 bytes graças a @ETHproductions. Salvou dois bytes separadamente graças a @ edc65.

Perl, 54 51 + 1 = 52 bytes

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

Requer a -nbandeira e o livre -M5.010| -E. Aceita as seguintes entradas direction\nline:

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

Eu gosto disso $/x/[v^]/parece uma substituição.

Como funciona:

                                                    # -n read first line into $_
@.=<>=~/./g;                                        # Read next line and split
            @.=reverse@.if/[<^]/;                   # 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]

Isso será uma bobagem completa para pessoas não familiarizadas com o PowerShell. Vamos passar por isso.

Recebe entrada param([char]$a,$b), com um elenco explícito para caractere $a. O restante do programa é uma declaração. Começaremos com o primeiro semestre, até o -join.

Estamos criando uma nova matriz dinâmica (...,...)e fazendo a indexação nela $a%7-eq6. Os valores ASCII para ve >são 116e 62, respectivamente, e 116%7 = 62%7 = 6, e essas são as duas direções que "aumentam" para baixo e para a direita. Então, se isso -eqé$true , vamos dar o segundo valor, o que é $b[0..$c], ou uma matriz de caracteres de $baté o final . Nós obtemos o valor $cdo primeiro valor, $b[($c=$b.length)..0]que é selecionado se o caractere de entrada é ^ou <( ou seja, ele passa a string para trás). Importante notar que, mesmo que o segundo valor seja selecionado, o $cvalor ainda será calculado e armazenado, para que possamos reutilizá-lo como um atalho como esse.

Então, agora temos uma variedade de caracteres indo para frente ou para trás. Em seguida, -joinesses caracteres são combinados com o resultado de outro índice de matriz dinâmica. Desta vez, selecionamos com base se o valor ASCII para$a está abaixo 90(realmente muitos valores funcionariam, selecionei este apenas porque). Como >e <ambos têm um valor abaixo 90, o -lté $false, então selecionamos a string vazia ""e, portanto, o array de caracteres é simplesmente concatenado. Caso contrário, selecionamos o caractere de nova linha "`n"para associar o conjunto de caracteres a novas linhas.

Essa sequência resultante é deixada no pipeline e a saída é implícita.

Exemplo

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

C, 123 119 117 114 bytes

Golfe:

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 teste, com explicações e código não-destruído:

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

Dicas bem-vindas!

Retina , 60 bytes

Precisa de golfe ...

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

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

A entrada é toda como uma sequência, por exemplo ^ABC.

• Se ^ou <, inverta a sequência
• Inserir novas linhas após cada caractere
• Se <ou >, remova as novas linhas

Experimente online.

Dyalog APL , 15 bytes

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

⍪transformar string em tabela de 1 coluna
⍣(‍… )repetir ( n ) vezes ⍞obter
⎕UCSconversão de entrada de string em ponto de código UCS
11| resto de divisão de quando dividido por 11
⌽∘⍉gire -90 ° (transposição invertida)

Método alternativo (mesmo comprimento):

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

⎕obter entrada avaliada (para que seja necessário inserir, por exemplo, '^' ou o nome de um programa / variável que retorna o caractere desejado), o
'<^>v'⍳índice na string

Jolf, 22 bytes

Experimente aqui! Você deve substituir ƒpor \x9f. Toma a picada, depois o caractere direcional.

.‘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)]

Constrói as seqüências necessárias e obtém o índice em que se aencontra. indexOfÉ usado porque ^é um token regex. Obrigado a ETHproductions pela correção de bugs e bytes raspados!

JavaScript (ES6) 71

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

Teste

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 mais um para -p

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

A entrada é uma única sequência cujo primeiro caractere define a orientação.

DUP , 48 bytes

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

Try it here.

Lambda anônima que aceita entrada de argumento e STDIN. Uso:

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

Explicação

[                                               ] {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}

Sério, 41 bytes

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

Leva a string como a primeira entrada e a direção (><v^ ) como a segunda entrada.

Experimente online!

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

: c

Menos golfe:

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