任务：给定一个正好由一个字符<>^v组成的输入，输出第二个输入，该第二个输入由可打印的ASCII字符（从空格到波浪号）组成，并以箭头定向。

假设该程序的第二个输入是ABC。这是应该做的：

• 输入>：打印ABC。
• 输入<：打印CBA。
• 输入^：打印C\nB\nA，或输入旋转-90°。
• 输入v：打印A\nB\nC，或输入旋转90°。

测试用例

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

这是一个代码高尔夫球，因此以字节为单位的最短程序获胜。

MATL，10 6字节

感谢马丁，节省了4个字节！

19\qX!

在线尝试！

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

旧版本，无模运算：10字节

'^<v>'=fX!

在线尝试！

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

多亏了xnor，节省了6个字节。

感谢Lynn，节省了7个字节。

保存3字节从由于DSM和摩根所以蟒蛇。

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

该函数接受from <>^v中的一个字符作为第一个参数，而需要旋转的字符串作为第二个参数。

这是一个更具可读性的版本：

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

Haskell，57个字节

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

用法示例：f "v" "ABC"-> "A\nB\nC"。

方向>是idendity功能，<逆转它的说法，v追加一个换行符的字符串中的每个字符和丢弃最后一个^是v其次<。

Japt，9个字节

VzUc %B+1

受@DonMuesli的答案启发，尽管我刚刚注意到CJam使用了完全相同的技术。在线测试！

怎么运行的

           // 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个字节

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

输入是方向字符，后跟要旋转的字符串。

在这里测试。

说明

是的，用于模魔术。将四个字符取模11将它们映射到：

> 7 
v 8 
< 5
^ 6

这些都是模4的截然不同，更重要的是，它们整齐地增加了：3, 0, 1, 2。这意味着我们可以使用的结果mod 11来确定旋转的频率（不需要显式mod 4，因为无论如何都不能进行四次旋转）。通常，我们必须将这些数字偏移1，这样才能>实际产生8并变为无操作，但是我旋转它们的方式实际上是在第一个应用程序上反转了字符串，因此我们总是免费旋转一次。

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

在这里尝试或运行测试套件

感谢Jakube，节省了2个字节！

或者使用mod技巧：

@s_MBjBz)h%Cw11

在这里尝试。

朱莉娅51字节

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

此函数接受a Char和一个字符串并返回一个字符串。

让d是字符表示的方向s是字符串。如果d向左或向上，则使用的反方向s，否则s按给定的方式使用。如果d是left或right，则将分隔符构造为空字符串；如果d是up或down，则将换行符构造为。将字符串和分隔符传递给join，它将在字符串的每个字符之间插入分隔符并返回一个字符串。

在线验证所有测试用例

Bash + GNU实用工具，67

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

JavaScript（ES6），76 67 65字节

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

@Alex A.Julia答案的端口。编辑：由于@ETHproductions，节省了9个字节。感谢@ edc65，分别保存了两个字节。

Perl，54 51 +1 = 52字节

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

需要-n标志和免费-M5.010| -E。输入如下direction\nline：

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

我喜欢那$/x/[v^]/看起来像是替代品。

怎么运行的：

                                                    # -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字节

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

对于不熟悉PowerShell的人来说，这将是完全的废话。让我们经历一下。

接受输入param([char]$a,$b)，并明确转换为角色$a。该程序的其余部分是一个语句。我们将从上半年开始，一直到-join。

我们正在创建一个新的动态数组，(...,...)并使用建立索引$a%7-eq6。该ASCII值v和>的116和62，分别与116%7 = 62%7 = 6，而这些都是在两个方向上“增加”向下和向右。因此，如果-eq是$true，我们将采用第二个值，即$b[0..$c]，或者是$b直到end 的字符数组。我们$c从第一个值$b[($c=$b.length)..0]中获取值，如果输入char为^or ，则该值将被选择<（即，它向后经过字符串）。需要注意的重要一点是，即使选择了第二个值，该$c值仍然会被计算和存储，因此我们可以像这样将其重新用作快捷方式。

因此，我们现在有了向前或向后的字符数组。然后，我们将-join这些字符与另一个动态数组索引的结果一起使用。这次，我们根据的ASCII值$a是否低于ASCII码来选择90（确实有很多值可以使用，我之所以选择了该值）。由于>和<都在下面90，是-ltis $false，因此我们选择了空字符串""，因此简单地将char数组连接起来。否则，我们选择换行符"`n"以将char数组与换行符连接在一起。

此结果字符串留在管道上，并且输出是隐式的。

例

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

C，123个 119 117 114字节

打高尔夫球：

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

测试程序，并附有解释和有些古怪的代码：

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

温馨提示！

视网膜，60字节

需要打高尔夫球...

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

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

输入全部为一个字符串，例如^ABC。

• 如果^或<，则反转字符串
• 在每个字符后插入换行符
• 如果<或>，请删除换行符

在线尝试。

Dyalog APL，15字节

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

⍪将字符串放入1列表中
⍣(‍… )重复（n）次， ⍞将字符串输入除以11并旋转-90°（翻转转置），
⎕UCS将其转换为UCS代码点
11|除法休息
⌽∘⍉

替代方法（相同长度）：

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

⎕获得评估的输入（因此必须输入，例如“ ^”或返回所需字符的程序/变量的名称）
'<^>v'⍳索引到字符串中

Jolf，22个字节

在这里尝试！您应该替换ƒ为\x9f。先取the，然后取方向字符。

.‘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字节

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

构造必要的字符串并获取其所a在的索引。indexOf由于^是正则表达式标记，因此使用它。感谢ETHproductions的错误修复和节省的字节数！

JavaScript（ES6）71

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

测试

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位元组

66加一 -p

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

输入是单个字符串，其第一个字符定义方向。

DUP，48个字节

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

Try it here.

同时接受参数和STDIN输入的匿名lambda。用法：

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

说明

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

严重的是41个字节

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

将字符串作为第一个输入和方向（><v^）作为第二个输入。

在线尝试！

D，198字节

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

少打高尔夫球：

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