Tâche: étant donné une entrée composée exactement d'un des caractères <>^v, sortez une deuxième entrée composée des caractères ASCII imprimables (de l'espace au tilde), orientée avec la flèche.

Supposons que la deuxième entrée du programme soit ABC. Voici ce qu'il devrait faire:

• Entrée >: impression ABC.
• Entrée <: impression CBA.
• Entrée ^: impression C\nB\nAou entrée pivotée de -90 °.
• Entrée v: impression A\nB\nCou entrée pivotée de 90 °.

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

Il s'agit d'un code-golf , donc le programme le plus court en octets l'emporte.

MATL , 10 6 octets

4 octets économisés grâce à Martin!

19\qX!

Essayez-le en ligne!

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

Ancienne version, sans opérations modulo: 10 octets

'^<v>'=fX!

Essayez-le en ligne!

'^<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 octets

6 octets enregistrés grâce à xnor.

Enregistré 7 octets grâce à Lynn.

Enregistré 3 octets grâce à DSM et Morgan de so python.

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

La fonction accepte l'un des caractères de <>^vcomme premier argument et la chaîne qui doit être tournée comme deuxième argument.

Voici une version plus lisible:

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

Haskell, 57 octets

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

Exemple d'utilisation: f "v" "ABC"-> "A\nB\nC".

Direction > est la fonction d'idendité, <inverse son argument, vajoute une nouvelle ligne à chaque caractère de la chaîne et supprime le dernier et^ est vsuivi de <.

Japt, 9 octets

VzUc %B+1

Inspiré par la réponse de @ DonMuesli, même si je viens de remarquer que le CJam utilise exactement la même technique. Testez-le en ligne!

Comment ça marche

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

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

L'entrée est le caractère d'orientation suivi directement par la chaîne à faire pivoter.

Testez-le ici.

Explication

Ouais pour la magie modulo. Prendre les quatre caractères modulo 11 les mappe à:

> 7 
v 8 
< 5
^ 6

Ce sont tous distincts modulo 4 et plus important encore, ils augmentent nettement: 3, 0, 1, 2. Cela signifie que nous pouvons simplement utiliser le résultat de la mod 11pour déterminer la fréquence de rotation (sans avoir besoin d'un explicite mod 4, car quatre rotations sont de toute façon un non-op). Nous devrions normalement compenser ces nombres par 1, de sorte que cela >donne 8et devient un no-op, mais la façon dont je les tourne, inverse en fait la chaîne sur la première application de sorte que nous obtenons toujours une rotation gratuitement.

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

Essayez-le ici ou exécutez la suite de tests

2 octets économisés grâce à Jakube!

Vous pouvez également utiliser des astuces de mod:

@s_MBjBz)h%Cw11

Essayez-le ici .

Julia, 51 octets

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

Il s'agit d'une fonction qui accepte un Charet une chaîne et renvoie une chaîne.

Soit dle caractère indiquant la direction et sla chaîne. Si dest laissé ou haut, nous utilisons l'inverse de s, sinon nous utilisons stel que donné. Nous construisons un séparateur comme la chaîne vide si dest à gauche ou à droite, ou une nouvelle ligne si dest vers le haut ou vers le bas. Le passe la chaîne et le séparateur à join, qui insérera le séparateur entre chaque caractère de la chaîne et retournera une chaîne.

Vérifiez tous les cas de test en ligne

Utilitaires Bash + GNU, 67

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

JavaScript (ES6), 76 67 65 octets

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

Port de réponse Julia @Alex A.. Edit: 9 octets enregistrés grâce à @ETHproductions. Enregistré deux octets séparément grâce à @ edc65.

Perl, 54 51 + 1 = 52 octets

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

Nécessite le -ndrapeau et la gratuité -M5.010| -E. Prend la saisie comme suit direction\nline::

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

J'aime que ça $/x/[v^]/ressemble à une substitution.

Comment ça marche:

                                                    # -n read first line into $_
@.=<>=~/./g;                                        # Read next line and split
            @[email protected]/[<^]/;                   # 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 octets

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

Cela va être du charabia complet pour les personnes qui ne connaissent pas PowerShell. Passons en revue.

Prend une entrée param([char]$a,$b), avec une conversion explicite en caractère pour $a. Le reste du programme est une instruction. Nous allons commencer par la première moitié, jusqu'à la -join.

Nous créons un nouveau tableau dynamique (...,...)et nous y indexons avec $a%7-eq6. Les valeurs ASCII pour vet >sont 116et 62, respectivement, et 116%7 = 62%7 = 6, et ce sont les deux directions qui "augmentent" vers le bas et vers la droite. Donc, si tel -eqest le cas $true, nous prendrons la deuxième valeur, qui est $b[0..$c], ou un tableau de caractères $bjusqu'à la fin . Nous obtenons la valeur $cde la première valeur, $b[($c=$b.length)..0]qui est sélectionnée si le caractère d'entrée est ^ou <(c'est-à-dire qu'il passe par la chaîne en arrière). Il est important de noter que même si la deuxième valeur est sélectionnée, la $cvaleur est toujours calculée et stockée, nous pouvons donc la réutiliser comme raccourci comme celui-ci.

Donc, nous avons maintenant un tableau de caractères allant vers l'avant ou vers l'arrière. Nous avons ensuite -joinces caractères avec le résultat d'un autre index de tableau dynamique. Cette fois, nous sélectionnons en fonction de si la valeur ASCII pour $aest inférieure 90(vraiment beaucoup de valeurs fonctionneraient, j'ai choisi celle-ci juste parce que). Puisque >et les <deux ont une valeur en dessous 90, le -ltest $false, donc nous sélectionnons la chaîne vide "", et donc le tableau de caractères est simplement concaténé. Sinon, nous sélectionnons le caractère de nouvelle ligne "`n"pour joindre le tableau de caractères avec les nouvelles lignes.

Cette chaîne résultante est laissée sur le pipeline et la sortie est implicite.

Exemple

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

C, 123 119 117 117 114 octets

Golfé:

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

Programme de test, avec explications et code quelque peu inchangé:

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

Conseils bienvenus!

Rétine , 60 octets

A besoin de jouer au golf ...

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

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

L'entrée est tout comme une chaîne, par exemple ^ABC.

• Si ^ou <, inversez la chaîne
• Insérer des retours à la ligne après chaque caractère
• Si <ou >, supprimez les retours à la ligne

Essayez-le en ligne.

Dyalog APL , 15 octets

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

⍪faire une chaîne dans un tableau à 1 colonne
⍣(‍… )répéter ( n ) fois ⍞obtenir l'entrée de chaîne
⎕UCSconvertir en point de code UCS
11| reste la division du lorsqu'elle est divisée par 11
⌽∘⍉tournez -90 ° (flip-transpose)

Méthode alternative (même longueur):

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

⎕obtenir une entrée évaluée (donc il faut entrer, par exemple '^' ou le nom d'un programme / variable qui retourne le caractère souhaité)
'<^>v'⍳index dans la chaîne

Jolf, 22 octets

Essayez-le ici! Vous devez remplacer ƒpar \x9f. Prend la piqûre, puis le caractère directionnel.

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

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

Construit les chaînes nécessaires et obtient l'index duquel ase trouve. indexOfEst utilisé car ^est un jeton d'expression régulière. Merci à ETHproductions pour la correction de bogue et les octets rasés!

JavaScript (ES6) 71

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

Tester

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 octets

66 plus un pour -p

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

L'entrée est une chaîne unique dont le premier caractère définit l'orientation.

DUP , 48 octets

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

Try it here.

Lambda anonyme qui prend à la fois l'argument et l'entrée STDIN. Usage:

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

Explication

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

Sérieusement, 41 octets

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

Prend la chaîne comme première entrée et la direction ( ><v^) comme deuxième entrée.

Essayez-le en ligne!

D, 198 octets

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

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