Задача: Учитывая вход, состоящий ровно из одного из символов <>^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 байт

Сохранено 6 байтов благодаря xnor.

Сэкономили 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*

Ввод - это символ ориентации, за которым непосредственно следует повернутая строка.

Проверьте это здесь.

объяснение

Yay для модуля магии. Взятие четырех символов по модулю 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

Попробуйте здесь или запустите Test Suite

2 байта сохранены благодаря Jakube!

Альтернативно используя мод трюки:

@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, чтобы вставить разделитель между каждым символом строки и вернуть строку.

Проверьте все тестовые примеры онлайн

Bash + GNU Utilities, 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.'s Julia. Изменить: Сохранено 9 байт благодаря @ETHproductions. Сохранено два байта отдельно благодаря @ 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до конца . Мы получаем значение $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 байтов

Golfed:

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.

• Если ^или <, переверните строку
• Вставить новые строки после каждого символа
• Если <или >, удалите новые строки

Попробуйте онлайн.

Дьялог АПЛ , 15 байт

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

⍪преобразовать строку в таблицу из 1 столбца
⍣(‍… )repeat ( n ) раза ⍞получить входные данные строки,
⎕UCSпреобразованные в
11|деление кодовой точки 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

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. Использование:

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