작업 : 정확히 하나의 문자로 구성된 입력이 주어지면 <>^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
---
"<", ">>>" =>
>>>

이것은 code-golf 이므로 바이트 단위의 가장 짧은 프로그램이 승리합니다.

MATL , 10 6 바이트

Martin 덕분에 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

파이썬 3, 64 51 48 바이트

xnor 덕분에 6 바이트를 절약했습니다.

Lynn 덕분에 7 바이트가 절약되었습니다.

저장된 3에서 DSM 모건 덕분 바이트 정도 파이썬.

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

이 함수는 다음 문자 중 하나를 허용합니다. <>^v 첫 번째 인수로 를, 두 번째 인수로 회전해야하는 문자열을 허용합니다.

더 읽기 쉬운 버전은 다음과 같습니다.

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

하스켈, 57 바이트

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

사용 예 : f "v" "ABC" -> "A\nB\nC".

방향 >의 idendity 기능입니다 <그것의 인수를 반전 v문자열의 각 문자에 줄 바꿈을 추가하고 마지막을 삭제하고 ^있다 v다음 <.

apt, 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*

입력은 회전 할 문자열 바로 뒤에 오는 방향 문자입니다.

여기에서 테스트하십시오.

설명

모듈로 마술을 위해 예. 4 개의 문자 modulo 11을 취하면 다음과 같이 매핑됩니다.

> 7 
v 8 
< 5
^ 6

이들은 모두 별개의 모듈로 4이며 더 중요하게는 깔끔하게 증가하고 3, 0, 1, 2있습니다. 즉, 우리는 mod 11회전 결과를 사용하여 얼마나 자주 회전해야하는지 결정할 수 있습니다 ( mod 4어쨌든 네 번의 회전이 작동하지 않기 때문에 명시적인 필요 없음). 우리는 일반적으로 이러한 숫자를 1만큼 오프셋해야합니다. >실제로 산출 8하고 no-op가됩니다. 그러나 숫자를 회전시키는 방식은 실제로 첫 번째 응용 프로그램의 문자열을 뒤집어 항상 하나의 회전을 무료로 얻습니다.

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.

피스, 17 15

jWgz\^_W}z"<^"w

여기에서 시도 하거나 Test Suite를 실행하십시오.

Jakube 덕분에 2 바이트가 절약되었습니다!

또는 모드 트릭을 사용하십시오.

@s_MBjBz)h%Cw11

여기서 사용해보십시오 .

줄리아, 51 바이트

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

이것은 a Char와 문자열 을 받아들이고 문자열을 반환 하는 함수입니다 .

하자 d방향을 나타내는 문자를하고 s문자열합니다. 경우 d왼쪽 또는까지, 우리는의 반대를 사용 s그렇지 않으면 우리가 사용하기 s로 주어진. d왼쪽이나 오른쪽 이면 구분 기호를 빈 문자열로, d위쪽이나 아래쪽 이면 줄 바꾸기 를 구성합니다. 문자열과 구분 기호를로 전달하면 문자열의 join각 문자 사이에 구분 기호가 삽입되고 문자열이 반환됩니다.

모든 테스트 사례를 온라인으로 확인

배쉬 + GNU 유틸리티, 67

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

자바 스크립트 (ES6), 76 67 65 바이트

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

@Alex A.의 Julia 답변 포트. 편집 : @ETHproductions 덕분에 9 바이트가 절약되었습니다. @ edc65 덕분에 2 바이트를 별도로 저장했습니다.

펄, 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끝 부분까지를 . 우리는 값을 얻을 $c첫 번째 값에서 $b[($c=$b.length)..0]입력 문자 인 경우 선택됩니다, ^또는< (가 문자열 뒤쪽으로 통과 즉, 정도). 두 번째 값을 선택하더라도 $c값이 계속 계산되어 저장되므로 바로 가기로 다시 사용할 수 있습니다.

이제 앞뒤로 문자 배열이 생겼습니다. 우리는 그때-join 해당 문자를 다른 동적 배열 인덱스의 결과와 함께 사용합니다. 이번에는 ASCII 값 $a이 아래 에 있는지 여부를 기준으로 선택하고 있습니다 90(실제로 많은 값이 작동 할 것이므로이 값을 선택했기 때문에). 이후 >와 <모두 이하의 값을 가질 수 90는 -lt있다 $false우리는 빈 문자열을 선택하므로 "", 따라서 문자 배열은 단순히 연결됩니다. 그렇지 않으면, 개행 문자 "`n"를 선택하여 문자 배열을 개행과 함께 결합합니다.

이 결과 문자열은 파이프 라인에 남아 있으며 출력은 암시 적입니다.

예

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 열 테이블로 만들기
⍣(‍… 11 번으로 나눌 때 문자열 입력 을 UCS 코드 포인트 나누기 나머지 로 변환 )( n ) 회 반복 ( n ) ⍞
⎕UCS
11|
⌽∘⍉ 회전 -90 (플립 - 트랜스)

다른 방법 (같은 길이) :

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

⎕
'<^>v'⍳문자열로 평가 입력 (따라서 입력해야합니다 (예 : '^'또는 원하는 문자를 반환하는 프로그램 / 변수 이름)) 인덱스

줄프, 22 바이트

여기 사용해보십시오! 당신은 교체해야합니다 ƒ함께 \x9f. 쏘인 다음 방향성 문자를 취합니다.

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

자바 스크립트 ES6, 91 83 84 바이트

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

필요한 스트링을 구축하고있는 취득 인덱스 a에 놓여있다. indexOf때문에 사용할 ^정규식 토큰이다. 버그 수정 및 면도 된 바이트에 대한 ETHproductions 덕분에!

자바 스크립트 (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>

펄 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 입력을 모두받는 익명 람다. 용법:

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

:기음

덜 골프 :

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