Compito: dato un input costituito esattamente da uno dei caratteri <>^v, emette un secondo input costituito dai caratteri ASCII stampabili (dallo spazio alla tilde), orientati con la freccia.

Supponiamo che il secondo input per il programma sia ABC. Questo è ciò che dovrebbe fare:

• Input >: stampa ABC.
• Input <: stampa CBA.
• Input ^: stampa C\nB\nAo input ruotato di -90 °.
• Input v: stampa A\nB\nCo input ruotato di 90 °.

Casi test

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

Questo è un codice-golf , quindi vince il programma più breve in byte.

MATL , 10 6 byte

4 byte salvati grazie a Martin!

19\qX!

Provalo 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

Vecchia versione, senza operazioni modulo: 10 byte

'^<v>'=fX!

Provalo 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 byte

6 byte salvati grazie a xnor.

Salvato 7 byte grazie a Lynn.

Salvato 3 byte grazie a DSM e Morgan da così Python.

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

La funzione accetta uno dei caratteri <>^vcome primo argomento e la stringa che deve essere ruotata come secondo argomento.

Ecco una versione più leggibile:

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

Haskell, 57 byte

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

Esempio di utilizzo: f "v" "ABC"-> "A\nB\nC".

La direzione >è la funzione di identità, <inverte l'argomento, vaggiunge una nuova riga a ciascun carattere nella stringa e rilascia l'ultima e ^viene vseguita da <.

Japt, 9 byte

VzUc %B+1

Ispirato dalla risposta di @ DonMuesli, anche se ho appena notato che CJam utilizza esattamente la stessa tecnica. Provalo online!

Come funziona

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

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

L'input è il carattere di orientamento seguito direttamente dalla stringa da ruotare.

Provalo qui.

Spiegazione

Sì per modulo magico. Prendendo i quattro caratteri modulo 11 li mappano a:

> 7 
v 8 
< 5
^ 6

Questi sono tutti distinti modulo 4 e soprattutto sono ordinatamente aumento: 3, 0, 1, 2. Ciò significa che possiamo semplicemente usare il risultato di mod 11per determinare la frequenza con cui ruotare (senza bisogno di un esplicito mod 4, poiché comunque quattro rotazioni non sono operative). Normalmente dovremmo compensare questi numeri di 1, in modo tale che in >realtà cede 8e diventa un no-op, ma il modo in cui li sto ruotando, in realtà inverte la stringa sulla prima applicazione in modo da ottenere sempre una rotazione gratis.

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

Provalo qui o esegui Test Suite

2 byte salvati grazie a Jakube!

In alternativa, usando i trucchi mod:

@s_MBjBz)h%Cw11

Provalo qui .

Julia, 51 byte

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

Questa è una funzione che accetta ae Charuna stringa e restituisce una stringa.

Sia dil carattere che indica la direzione e ssia la stringa. Se dè lasciato o su, usiamo il contrario di s, altrimenti usiamo scome dato. Costruiamo un separatore come stringa vuota se dè sinistra o destra, o una nuova riga se dè su o giù. Passa la stringa e il separatore a join, che inserirà il separatore tra ogni carattere della stringa e restituirà una stringa.

Verifica tutti i casi di test online

Utilità Bash + GNU, 67

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

JavaScript (ES6), 76 67 65 byte

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

La risposta Julia di Port of @Alex A. Modifica: salvato 9 byte grazie a @ETHproductions. Salvato due byte separatamente grazie a @ edc65.

Perl, 54 51 + 1 = 52 byte

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

Richiede la -nbandiera e il libero -M5.010| -E. Accetta input come segue direction\nline:

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

Mi piace che $/x/[v^]/sembri una sostituzione.

Come funziona:

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

Questo sarà completamente incomprensibile per le persone che non hanno familiarità con PowerShell. Andiamo attraverso.

Riceve input param([char]$a,$b), con un cast esplicito a carattere per $a. Il resto del programma è una frase. Inizieremo con la prima metà, fino al -join.

Stiamo creando un nuovo array dinamico (...,...)e indicizzandolo con $a%7-eq6. I valori ASCII per ve >sono 116e 62, rispettivamente, e 116%7 = 62%7 = 6e quelli e sono le due direzioni che "aumentano" verso il basso e verso destra. Quindi, se -eqè così $true, prenderemo il secondo valore, ovvero $b[0..$c], o un array di caratteri $bfino alla fine . Otteniamo il valore $cdal primo valore, $b[($c=$b.length)..0]che viene selezionato se il carattere di input è ^o <(ovvero, passa attraverso la stringa all'indietro). È importante notare che anche se viene selezionato il secondo valore, il $cvalore viene comunque calcolato e memorizzato, quindi possiamo riutilizzarlo come collegamento come questo.

Quindi ora abbiamo una serie di personaggi che vanno avanti o indietro. Abbiamo quindi -joinquei caratteri insieme al risultato di un altro indice di array dinamico. Questa volta stiamo selezionando in base al fatto che il valore ASCII $asia inferiore 90(davvero molti valori funzionerebbero, ho selezionato questo solo perché). Poiché >ed <entrambi hanno un valore di seguito 90, -ltè $false, quindi selezioniamo la stringa vuota ""e quindi il char-array viene semplicemente concatenato. Altrimenti, selezioniamo il carattere di nuova riga "`n"per unire il char-array con le nuove righe.

Questa stringa risultante viene lasciata sulla pipeline e l'output è implicito.

Esempio

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

C, 123 119 117 114 byte

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

Programma di test, con spiegazioni e codice un po 'non risolto:

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

Suggerimenti benvenuti!

Retina , 60 byte

Ha bisogno di giocare a golf ...

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

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

L'input è tutto come una stringa, ad es ^ABC.

• Se ^o <, invertire la stringa
• Inserisci nuove righe dopo ogni personaggio
• Se <o >, rimuovere le nuove righe

Provalo online.

Dyalog APL , 15 byte

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

⍪trasforma la stringa in una tabella a 1 colonna
⍣(‍... )ripeti ( n ) volte ⍞ottieni l'input della stringa
⎕UCSconverti in
11|riposo punto divisione codice UCS quando diviso per 11
⌽∘⍉ruota -90 ° (flip-transpose)

Metodo alternativo (stessa lunghezza):

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

⎕ottenere input valutati (quindi si deve inserire, ad esempio '^' o il nome di un programma / variabile che restituisce il carattere desiderato)
'<^>v'⍳indice nella stringa

Jolf, 22 byte

Provalo qui! Si dovrebbe sostituire ƒcon \x9f. Prende la puntura, quindi il carattere direzionale.

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

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

Costruisce le stringhe necessarie e ottiene l'indice di cui si atrova. indexOfViene utilizzato perché ^è un token regex. Grazie a ETHproductions per la correzione di bug e byte rasati!

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 byte

66 più uno per -p

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

L'input è una singola stringa il cui primo carattere definisce l'orientamento.

DUP , 48 byte

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

Try it here.

Lambda anonimo che accetta sia argomenti che input STDIN. Uso:

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

Spiegazione

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

Scherzi a parte, 41 byte

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

Prende la stringa come primo input e la direzione ( ><v^) come secondo input.

Provalo online!

D, 198 byte

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

Meno golf:

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