Aufgabe: Bei einer Eingabe, die genau aus einem der Zeichen besteht <>^v, geben Sie eine zweite Eingabe aus, die aus den druckbaren ASCII-Zeichen (vom Leerzeichen bis zur Tilde) besteht und auf den Pfeil ausgerichtet ist.

Angenommen, die zweite Eingabe für das Programm lautet ABC. Das sollte es tun:

• Eingabe >: Drucken ABC.
• Eingabe <: Drucken CBA.
• Eingabe ^: Drucken C\nB\nAoder Eingabe um -90 ° gedreht.
• Eingabe v: Drucken A\nB\nCoder Eingabe um 90 ° gedreht.

Testfälle

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

Dies ist ein Code-Golf , also gewinnt das kürzeste Programm in Bytes.

MATL , 10 6 Bytes

4 Bytes gespart dank Martin!

19\qX!

Probieren Sie es 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

Alte Version, ohne Modulo-Operationen: 10 Bytes

'^<v>'=fX!

Probieren Sie es 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

6 Bytes gespart dank xnor.

7 Bytes dank Lynn gespart.

3 Bytes gespart dank DSM und Morgan aus so Python.

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

Die Funktion akzeptiert eines der Zeichen von <>^vals erstes Argument und die Zeichenfolge, die gedreht werden muss, als zweites Argument.

Hier ist eine besser lesbare Version:

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"

Anwendungsbeispiel: f "v" "ABC"-> "A\nB\nC".

Richtung >ist die Funktion Idendity, <kehrt sie das Argument, vfügt eine neue Zeile zu jedem Zeichen in der Zeichenfolge und fällt die letzten und ^wird vgefolgt von <.

Japt, 9 Bytes

VzUc %B+1

Inspiriert von @ DonMueslis Antwort, obwohl ich gerade bemerkt habe, dass die CJam genau dieselbe Technik verwendet. Online testen!

Wie es funktioniert

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

Die Eingabe ist das Ausrichtungszeichen, gefolgt von der Zeichenfolge, die gedreht werden soll.

Teste es hier.

Erläuterung

Ja, für Modulo-Magie. Wenn Sie die vier Zeichen modulo 11 nehmen, ordnen Sie sie den folgenden Elementen zu:

> 7 
v 8 
< 5
^ 6

Dies sind alle verschieden Modulo 4 und was noch wichtiger sind sie ordentlich zu erhöhen: 3, 0, 1, 2. Das heißt, wir können das Ergebnis von einfach verwenden mod 11, um zu bestimmen, wie oft gedreht werden soll (ohne dass ein expliziter Hinweis erforderlich ist mod 4, da vier Drehungen ohnehin ein No-Op sind). Normalerweise müssten wir diese Zahlen um 1 versetzen, so dass sie >tatsächlich 8ein No-Op ergeben, aber die Art und Weise, wie ich sie drehe, kehrt die Zeichenfolge bei der ersten Anwendung tatsächlich um, sodass wir immer eine Umdrehung kostenlos erhalten.

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

Probieren Sie es hier aus oder starten Sie die Test Suite

2 Bytes gespart dank Jakube!

Alternativ mit Mod-Tricks:

@s_MBjBz)h%Cw11

Probieren Sie es hier aus .

Julia, 51 Bytes

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

Dies ist eine Funktion, die a Charund eine Zeichenfolge akzeptiert und eine Zeichenfolge zurückgibt.

Sei ddas Zeichen für die Richtung und sdie Zeichenfolge. Wenn dlinks oder oben steht, verwenden wir die Umkehrung von s, ansonsten verwenden wir swie angegeben. Wir konstruieren ein Trennzeichen als leere Zeichenfolge d(links oder rechts) oder als neue Zeile d(oben oder unten). Übergeben Sie die Zeichenfolge und das Trennzeichen an join, wodurch das Trennzeichen zwischen den einzelnen Zeichen der Zeichenfolge eingefügt und eine Zeichenfolge zurückgegeben wird.

Überprüfen Sie alle Testfälle online

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>`>`?`
`:``)

Port von @Alex A.'s Julia Antwort. Bearbeiten: 9 Bytes dank @ETHproductions gespeichert. Zwei Bytes getrennt gespeichert dank @ edc65.

Perl, 5451 + 1 = 52 Bytes

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

Benötigt die -nFlagge und die freie -M5.010| -E. Nimmt Eingaben wie folgt vor direction\nline:

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

Ich mag das $/x/[v^]/sieht aus wie ein Ersatz.

Wie es funktioniert:

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

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

Dies wird für Leute, die mit PowerShell nicht vertraut sind, ein völliger Kauderwelsch sein. Lass es uns durchgehen.

Nimmt Eingaben param([char]$a,$b)mit einem expliziten Cast-to-Character für $a. Der Rest des Programms ist eine Aussage. Wir werden mit der ersten Hälfte beginnen, bis zum -join.

Wir erstellen ein neues dynamisches Array (...,...)und indizieren es mit $a%7-eq6. Die ASCII - Werte für vund >sind 116und 62sind, und 116%7 = 62%7 = 6, und das sind die beiden Richtungen , dass „Erhöhung“ nach unten und nach rechts. Wenn dies der Fall -eqist $true, nehmen wir den zweiten Wert $b[0..$c]oder ein Array der Zeichen $bbis zum Ende . Wir erhalten den Wert $cvom ersten Wert, $b[($c=$b.length)..0]der ausgewählt wird, wenn das Eingabezeichen ^oder ist <(dh, die Zeichenfolge wird rückwärts durchlaufen). Es ist wichtig zu beachten, dass der $cWert auch dann berechnet und gespeichert wird, wenn der zweite Wert ausgewählt wird, sodass wir ihn als eine solche Verknüpfung wiederverwenden können.

Wir haben jetzt also eine Reihe von Zeichen, die entweder vorwärts oder rückwärts laufen. Wir haben dann -joindiese Zeichen zusammen mit dem Ergebnis eines anderen dynamischen Array-Index. Dieses Mal wählen wir basierend darauf aus, ob der ASCII-Wert für $adarunter liegt 90(wirklich viele Werte würden funktionieren, ich habe diesen ausgewählt, nur weil). Da >und <beide unten einen Wert haben 90, -ltist das $false, also wählen wir die leere Zeichenfolge aus "", und somit wird das Zeichen-Array einfach verkettet. Andernfalls wählen wir das Zeilenumbruchzeichen aus "`n", um das Zeichen -Array zusammen mit Zeilenumbrüchen zu verbinden.

Diese resultierende Zeichenfolge verbleibt in der Pipeline, und die Ausgabe ist implizit.

Beispiel

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

C 123, 119, 117, 114 Bytes

Golf gespielt:

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

Testprogramm, mit Erklärungen & etwas ungolfed Code:

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

Trinkgelder willkommen!

Netzhaut , 60 Bytes

Braucht Golf ...

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

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

Die Eingabe erfolgt alle als eine Zeichenfolge, z ^ABC.

• Wenn ^oder <, kehren Sie die Zeichenfolge um
• Fügen Sie nach jedem Zeichen neue Zeilen ein
• Wenn <oder >, entfernen Sie die Zeilenumbrüche

Probieren Sie es online aus.

Dyalog APL , 15 Bytes

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

⍪Make - String in 1-Spaltentabelle
⍣(‍... )repeat ( n ) mal die ⍞String - Eingang
⎕UCSUmrechnen in UCS - Codepunkt
11|Teilungs Rest , wenn sie durch 11 geteilt
⌽∘⍉Drehen -90 ° (Flip-transponiert)

Alternative Methode (gleiche Länge):

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

⎕ausgewertete Eingabe erhalten (man muss also zB '^' oder den Namen eines Programms / einer Variablen eingeben, das / die das gewünschte Zeichen zurückgibt)
'<^>v'⍳Index in den String

Jolf, 22 Bytes

Probieren Sie es hier aus! Sie sollten ersetzen ƒmit \x9f. Nimmt den Stich, dann den Richtungscharakter.

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

Konstruiert die erforderlichen Zeichenfolgen und ermittelt den Index, in dem aliegt. Wird indexOfverwendet, weil ^es sich um ein Regex-Token handelt. Danke an ETHproductions für die Fehlerbehebung und die rasierten Bytes!

JavaScript (ES6) 71

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

Prüfung

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 plus eins für -p

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

Die Eingabe ist eine einzelne Zeichenfolge, deren erstes Zeichen die Ausrichtung definiert.

DUP , 48 Bytes

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

Try it here.

Anonymes Lambda, das sowohl Argument- als auch STDIN-Eingaben akzeptiert. Verwendung:

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

Erläuterung

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

Im Ernst, 41 Bytes

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

Nimmt den String als erste Eingabe und die Richtung ( ><v^) als zweite Eingabe.

Probieren Sie es 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

Weniger golfen:

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