Zadanie: Biorąc pod uwagę dane wejściowe składające się z dokładnie jednego ze znaków <>^v, wypisz drugie dane wejściowe składające się z drukowalnych znaków ASCII (od spacji do tyldy), zorientowanych strzałką.

Załóżmy, że drugim wejściem do programu jest ABC. Oto, co powinien zrobić:

• Wejście >: wydruk ABC.
• Wejście <: wydruk CBA.
• Wejście ^: wydruk C\nB\nAlub wejście obrócone o -90 °.
• Wejście v: wydruk A\nB\nClub wejście obrócone o 90 °.

Przypadki testowe

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
---
"<", ">>>" =>
>>>

To jest golf golfowy , więc wygrywa najkrótszy program w bajtach.

MATL , 10 6 bajtów

4 bajty zapisane dzięki Martinowi!

19\qX!

Wypróbuj 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

Stara wersja bez operacji modulo: 10 bajtów

'^<v>'=fX!

Wypróbuj 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 bajtów

Zaoszczędzono 6 bajtów dzięki xnor.

Zaoszczędź 7 bajtów dzięki Lynn.

Zaoszczędzono 3 bajty dzięki DSM i Morganowi z tak python.

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

Funkcja przyjmuje jeden ze znaków <>^vjako pierwszy argument, a ciąg, który należy obrócić jako drugi argument.

Oto bardziej czytelna wersja:

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

Haskell, 57 bajtów

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

Przykład użycia: f "v" "ABC"-> "A\nB\nC".

Kierunek >jest funkcja idendity, <odwraca To argumentu, vdołącza do nowej linii do każdego znaku w łańcuchu i spadnie ostatni i ^jest vnastępnie <.

Japt, 9 bajtów

VzUc %B+1

Zainspirowany odpowiedzią @ DonMuesli, chociaż zauważyłem, że CJam używa dokładnie tej samej techniki. Przetestuj online!

Jak to działa

           // 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 bajtów

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

Dane wejściowe to znak orientacji, po którym bezpośrednio następuje łańcuch, który ma zostać obrócony.

Sprawdź to tutaj.

Wyjaśnienie

Tak, magia modulo. Biorąc cztery znaki modulo 11 mapuje je na:

> 7 
v 8 
< 5
^ 6

Są to odrębne modulo 4, a co ważniejsze, są one starannie zwiększając: 3, 0, 1, 2. Oznacza to, że możemy po prostu użyć wyniku z, mod 11aby określić, jak często się obracać (bez potrzeby wyraźnego wyrażenia mod 4, ponieważ cztery obroty i tak nie działają). Zwykle musielibyśmy przesunąć te liczby o 1, tak że >faktycznie daje 8i staje się brakiem operacji, ale sposób, w jaki je obracam, faktycznie odwraca ciąg w pierwszej aplikacji, dzięki czemu zawsze otrzymujemy jeden obrót za darmo.

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

Wypróbuj tutaj lub uruchom pakiet testowy

2 bajty zapisane dzięki Jakube!

Alternatywnie przy użyciu sztuczek mod:

@s_MBjBz)h%Cw11

Wypróbuj tutaj .

Julia, 51 bajtów

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

Jest to funkcja, która akceptuje Charciągi i oraz zwraca ciąg.

Niech dbędzie znakiem oznaczającym kierunek i sbędzie łańcuchem. Jeśli djest pozostawione lub podniesione, używamy odwrotności s, w przeciwnym razie używamy szgodnie z podanymi. Konstruujemy separator jako pusty ciąg, jeśli djest lewy lub prawy, lub nowy wiersz, jeśli djest w górę lub w dół. Przekaż ciąg i separator do join, który wstawi separator między każdym znakiem ciągu i zwróci ciąg.

Sprawdź wszystkie przypadki testowe online

Bash + GNU Utilities, 67

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

JavaScript (ES6), 76 67 65 bajtów

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

Port odpowiedzi Julii @Alex A. Edycja: Zapisano 9 bajtów dzięki @ETHproductions. Zaoszczędzono dwa bajty osobno dzięki @ edc65.

Perl, 54 51 + 1 = 52 bajty

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

Wymaga -nflagi i darmowego -M5.010| -E. Przyjmuje dane wejściowe w następujący sposób direction\nline:

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

Podoba mi się, że $/x/[v^]/wygląda jak zmiana.

Jak to działa:

                                                    # -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 bajty

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

To będzie kompletny bełkot dla osób nie znających PowerShell. Przejdźmy przez to.

Pobiera dane wejściowe param([char]$a,$b), z wyraźnym oddaniem dla postaci $a. Reszta programu to jedna instrukcja. Zaczniemy od pierwszej połowy, aż do -join.

Tworzymy nową tablicę dynamiczną (...,...)i indeksujemy w niej za pomocą $a%7-eq6. Wartości ASCII vi >są 116i 62, odpowiednio, i 116%7 = 62%7 = 6, i to są dwa kierunki, że „wzrost” w dół i na prawo. Więc jeśli to -eqjest $true, weźmiemy drugą wartość, która jest $b[0..$c]lub tablicę znaków $baż do końca . Otrzymujemy wartość $cod pierwszej wartości, $b[($c=$b.length)..0]która jest wybierana, jeśli wejściowy znak char to ^lub <(tzn. Tak, że przechodzi on przez łańcuch do tyłu). Ważne jest, aby pamiętać, że nawet jeśli wybrana zostanie druga wartość, $cwartość jest nadal obliczana i zapisywana, dzięki czemu możemy ponownie użyć jej jako takiego skrótu.

Tak więc mamy teraz szereg znaków, które idą do przodu lub do tyłu. Następnie -joinznaki te łączymy z wynikiem innego dynamicznego indeksu tablicowego. Tym razem wybieramy na podstawie tego, czy wartość ASCII dla $ajest poniżej 90(naprawdę wiele wartości by działało, wybrałem tę właśnie dlatego). Ponieważ >i <oba mają poniżej wartość 90, -ltjest $false, więc wybieramy pusty ciąg "", a zatem tablica znaków jest po prostu łączona. W przeciwnym razie wybieramy znak nowej linii, "`n"aby połączyć tablicę znaków z znakami nowej linii.

Ten wynikowy ciąg zostaje pozostawiony w potoku, a dane wyjściowe są niejawne.

Przykład

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

C, 123 119 117 114 bajtów

Gra w golfa:

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

Program testowy z objaśnieniami i nieco niepoznanym kodem:

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

Wskazówki mile widziane!

Siatkówka , 60 bajtów

Potrzebuje gry w golfa ...

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

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

Dane wejściowe mają postać jednego ciągu, np ^ABC.

• Jeśli ^lub <, odwróć ciąg
• Wstaw nowe znaki po każdym znaku
• Jeśli <lub >, usuń znaki nowej linii

Wypróbuj online.

Dyalog APL , 15 bajtów

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

⍪przekształć ciąg w tabelę 1-kolumnową
⍣(‍… )powtórz ( n ) razy ⍞uzyskaj ciąg wejściowy
⎕UCSprzekonwertuj na
11|podział kodu punktowego UCS reszta po podzieleniu przez 11
⌽∘⍉obrót -90 ° (przełożenie-transpozycja)

Metoda alternatywna (ta sama długość):

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

⎕uzyskać analizowane dane wejściowe (więc należy wprowadzić np. „^” lub nazwę programu / zmiennej, która zwraca żądany znak)
'<^>v'⍳indeks do ciągu

Jolf, 22 bajty

Wypróbuj tutaj! Należy wymienić ƒz \x9f. Bierze żądło, a następnie kierunkową postać.

.‘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 bajtów

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

Konstruuje niezbędne ciągi i uzyskuje indeks, w którym ależy. indexOfJest używany, ponieważ ^jest tokenem wyrażenia regularnego. Dzięki ETHproductions za naprawę błędu i ogolone bajty!

JavaScript (ES6) 71

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

Test

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 bajtów

66 plus jeden za -p

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

Dane wejściowe to pojedynczy ciąg, którego pierwszy znak określa orientację.

DUP , 48 bajtów

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

Try it here.

Anonimowa lambda, która pobiera zarówno argument, jak i dane wejściowe STDIN. Stosowanie:

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

Wyjaśnienie

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

Poważnie, 41 bajtów

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

Bierze ciąg jako pierwsze wejście, a kierunek ( ><v^) jako drugie wejście.

Wypróbuj online!

D, 198 bajtów

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

Mniej golfa:

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