Görev: Karakterlerden tam olarak birinden oluşan bir giriş verildiğinde <>^v, okla yönlendirilmiş, yazdırılabilir ASCII karakterlerinden (uzaydan tilde) oluşan ikinci bir giriş çıkar.

Programa ikinci giriş olduğunu varsayalım ABC. Yapması gereken bu:

• Giriş >: yazdır ABC.
• Giriş <: yazdır CBA.
• Giriş ^: yazdır C\nB\nAveya giriş -90 ° döndürülmüş.
• Giriş v: yazdırın A\nB\nCveya giriş 90 ° döndürüldü.

Test durumları

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

Bu bir kod golf , yani bayt cinsinden en kısa program kazanır.

MATL , 10 6 bayt

Martin sayesinde 4 bayt kurtarıldı!

19\qX!

Çevrimiçi deneyin!

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

Eski versiyon, modulo işlemleri olmadan: 10 bayt

'^<v>'=fX!

Çevrimiçi deneyin!

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

Xnor sayesinde 6 bayt kurtardı.

Lynn sayesinde 7 byte kurtarıldı.

Çok python dan DSM ve Morgan sayesinde 3 bayt kurtardı.

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

İşlev, karakterlerden birini <>^vilk argüman ve ikinci argüman olarak döndürülmesi gereken dize olarak kabul eder .

İşte daha okunaklı bir sürüm:

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

Haskell, 57 bayt

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

Kullanım örneği: f "v" "ABC"->"A\nB\nC" .

Yön >, iddialı işlevdir, <argümanını tersine çevirir v, dizedeki her karaktere yeni bir satır ekler ve sonuncuyu bırakır.^ edilir vizledi <.

Japt, 9 bayt

VzUc %B+1

@ DonMuesli'nin cevabından ilham aldım, ancak CJam'ın tamamen aynı tekniği kullandığını fark ettim. Çevrimiçi test edin!

Nasıl çalışır

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

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

Giriş, doğrudan döndürülecek dize tarafından takip edilen yönlendirme karakteridir.

Burada test et.

açıklama

Modulo sihir için yay. Modulo 11 dört karakter alarak bunları eşleştirir:

> 7 
v 8 
< 5
^ 6

Bunların hepsi ayrı modülo 4 ve daha da önemlisi düzgün artmaktadır: 3, 0, 1, 2. Bunun anlamı, mod 11ne sıklıkta döneceğini belirlemek için sadece sonucunu kullanabiliriz (açık bir şekilde gerekmeksizin mod 4, çünkü dört döndürme zaten çalışmaz). Normalde bu sayıları 1 ile dengelememiz gerekirdi, öyle ki >gerçekte verimsiz 8ve no-op olur, ancak onları döndürme biçimim ilk uygulamadaki dizgiyi tersine çevirir, böylece her zaman ücretsiz bir döndürme elde ederiz.

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

Burada deneyin veya Test Suite'i çalıştırın

Jakube sayesinde 2 bayt kurtarıldı!

Alternatif olarak mod hileleri kullanarak:

@s_MBjBz)h%Cw11

Burada dene .

Julia, 51 bayt

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

Bu bir Charve bir dizgeyi kabul eden ve bir dize döndüren bir işlevdir .

dYönü belirten karakter ve sdize olalım . Eğer dsola veya yukarı, biz tersini kullanmak saksi takdirde biz kullanmak, solarak verilir. Boş dize d, sol veya sağ ise bir ayırıcı veya dyukarı veya aşağı ise yeni bir satır oluştururuz. Dizeyi ve dizeyi, dizenin joinher karakteri arasına dizeyi ayıracak ve dizeyi döndürecek olan ileticiyi iletin.

Tüm test durumlarını çevrimiçi olarak doğrulayın

Bash + GNU Yardımcı Programları, 67

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

JavaScript (ES6), 76 67 65 bayt

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

@Alex A.'nın limanı Julia'nın cevabı. Düzenleme: @ETHproductions sayesinde 9 bayt kaydedildi. @ Edc65 sayesinde iki byte ayrı kaydedildi.

Perl, 54 51 + 1 = 52 bayt

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

-nBayrak ve ücretsiz gerektirir -M5.010| -E. Giriş olarak aşağıdakileri alır direction\nline:

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

bunu sevdim $/x/[v^]/ bir değişiklik gibi görünüyor.

Nasıl çalışır:

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

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

Bu PowerShell'e aşina olmayan insanlara tamamen saçma gelecek. Hadi geçelim şunu.

Girdi param([char]$a,$b), karakterine açık bir alçı ile $a. Programın geri kalanı bir ifadedir. İlk yarıya kadar başlayacağız-join .

Yeni bir dinamik dizi yaratıyoruz (...,...)ve içine indeksliyoruz $a%7-eq6. ASCII değerleri için vve >olduğu 116ve 62sırasıyla ve 116%7 = 62%7 = 6ve bu aşağı ve sağa "artırmak" diye iki yön vardır. O Yani, -eqolduğunu $true, biz olan ikinci değer alacağım$b[0..$c] , ya karakter dizisi $bsona kadar . Biz değeri elde $cilk değerinden, $b[($c=$b.length)..0]giriş Char ise seçilmiş olur, ^ya da <(o dize geriye doğru geçer, yani böylece). Unutulmaması gereken, ikinci değer seçilse bile$c değerin hala hesaplanıp saklandığından, bu şekilde böyle bir kısayol olarak yeniden kullanılabileceğimizi unutmayın.

Yani şimdi ileri ya da geri giden bir dizi karakterimiz var. Daha sonra -joinbu karakterleri başka bir dinamik dizi indeksinin sonucu ile birlikte kullanıyoruz. Bu sefer, ASCII değerinin $aaltında olup olmadığına bağlı olarak seçiyoruz.90 (gerçekten çok sayıda değer işe yarayacak, bunu sadece ben seçtim). O zaman >ve <her ikisinin de değeri var90 , -ltolduğu $falsebiz boş bir dize seçmek, böylece ""ve böylece odun kömüründe dizisi basitçe birleştirilmiş. Aksi takdirde, karakter "`n"dizisine yeni satırlarla birlikte katılmak için yeni satır karakterini seçeriz.

Bu sonuç dizesi boru hattında bırakılır ve çıktı gizlidir.

Örnek

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

C, 123 119 117 114 bayt

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

Test programı, açıklama ve biraz kodlanmamış olarak:

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

İpuçları hoş geldiniz!

Retina , 60 bayt

Golfe ihtiyaç var ...

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

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

Girdilerin tümü tek bir dizedir, örn ^ABC.

• Eğer ^veya <, ipi tersten
• Her karakterden sonra yeni satırlar ekleyin
• Varsa <veya >yeni satırları kaldırın

Çevrimiçi deneyin.

Dyalog APL , 15 bayt

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

⍪1-sütun tablosuna dize yapmak
⍣(‍… )tekrar ( n ) kez ⍞dize olsun olsun
⎕UCSUCS kod noktası
11|bölme 11 dönüştürmek
⌽∘⍉ dönün döndürerek -90 ° döndürün (flip-transpose)

Alternatif yöntem (aynı uzunluk):

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

⎕Değerlendirilen girdiyi almak (bu nedenle biri girilmelidir, örneğin '^' veya istenen karakteri döndüren programın / değişkenin adı)
'<^>v'⍳dizin

Jolf, 22 bayt

Burada dene! Sen değiştirmelisiniz ƒile \x9f. İğneyi ve ardından yön karakterini alır.

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

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

Gerekli dizeleri oluşturur ve bu dizini elde ayatmaktadır. indexOfİçin kullanılan ^bir normal ifade belirtisidir. Hata düzeltme ve traş bayt ETHproductions için teşekkürler!

JavaScript (ES6) 71

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

Ölçek

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 bayt

66 artı bir -p

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

Giriş, ilk karakteri yönlendirmeyi tanımlayan tek bir dizedir.

DUP , 48 bayt

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

Try it here.

Hem argümanı hem de STDIN girişini alan adsız lambda. Kullanımı:

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

açıklama

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

Cidden, 41 bayt

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

Dizeyi ilk giriş, yönünü ( ><v^) ikinci giriş olarak alır.

Çevrimiçi deneyin!

D, 198 bayt

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

Daha az golf oynadı:

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