Tugas: Diberikan input yang terdiri dari tepat satu karakter <>^v, mengeluarkan input kedua yang terdiri dari karakter ASCII yang dapat dicetak (dari angkasa hingga tilde), diorientasikan dengan panah.

Mari kita asumsikan input kedua untuk program ini ABC. Inilah yang harus dilakukan:

• Input >: cetak ABC.
• Input <: cetak CBA.
• Input ^: cetak C\nB\nA, atau input diputar -90 °.
• Input v: cetak A\nB\nC, atau input diputar 90 °.

Uji kasus

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

Ini adalah kode-golf , jadi program terpendek dalam byte menang.

MATL , 10 6 byte

4 byte disimpan berkat Martin!

19\qX!

Cobalah 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

Versi lama, tanpa operasi modulo: 10 byte

'^<v>'=fX!

Cobalah 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

Disimpan 6 byte berkat xnor.

Disimpan 7 byte berkat Lynn.

Disimpan 3 byte berkat DSM dan Morgan dari begitu python.

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

Fungsi menerima salah satu karakter dari <>^vsebagai argumen pertama dan string yang perlu diputar sebagai argumen kedua.

Ini versi yang lebih mudah dibaca:

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"

Contoh penggunaan: f "v" "ABC"-> "A\nB\nC".

Arah >adalah fungsi idendity, <membalikkan argumen itu, vmenambahkan baris baru untuk masing-masing karakter dalam string dan tetes yang terakhir dan ^yang vdiikuti oleh <.

Japt, 9 byte

VzUc %B+1

Terinspirasi oleh jawaban @ DonMuesli, meskipun saya baru memperhatikan bahwa CJam menggunakan teknik yang persis sama. Uji secara online!

Bagaimana itu bekerja

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

Input adalah karakter orientasi yang diikuti secara langsung oleh string yang akan diputar.

Uji di sini.

Penjelasan

Yay untuk sihir modulo. Mengambil empat karakter modulo 11 memetakannya ke:

> 7 
v 8 
< 5
^ 6

Ini semua berbeda modulo 4 dan yang lebih penting mereka rapi meningkat: 3, 0, 1, 2. Itu berarti kita bisa menggunakan hasil dari mod 11untuk menentukan seberapa sering memutar (tanpa perlu eksplisit mod 4, karena empat rotasi adalah no-op pula). Kami biasanya harus mengimbangi angka-angka ini dengan 1, sehingga >benar - benar menghasilkan 8dan menjadi no-op, tetapi cara saya memutarnya, sebenarnya membalikkan string pada aplikasi pertama sehingga kami selalu mendapatkan satu putaran 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

Cobalah di sini atau jalankan Test Suite

2 byte disimpan berkat Jakube!

Cara lainnya menggunakan trik mod:

@s_MBjBz)h%Cw11

Coba di sini .

Julia, 51 byte

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

Ini adalah fungsi yang menerima a Chardan string dan mengembalikan string.

Membiarkan dmenjadi karakter yang menunjukkan arah dan smenjadi string. Jika ddibiarkan atau naik, kita menggunakan kebalikan dari s, jika tidak kita gunakan sseperti yang diberikan. Kami membangun pemisah sebagai string kosong jika dkiri atau kanan, atau baris baru jika dnaik atau turun. Lewati string dan pemisah kejoin , yang akan menyisipkan pemisah antara setiap karakter string dan mengembalikan string.

Verifikasi semua kasus uji online

Bash + GNU Utilities, 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>`>`?`
`:``)

Port dari jawaban Julia @Alex A. Sunting: Disimpan 9 bytes berkat @ETHproductions. Menyimpan dua byte secara terpisah berkat @ edc65.

Perl, 54 51 + 1 = 52 byte

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

Membutuhkan -n bendera dan gratis -M5.010| -E. Mengambil input sebagai berikut direction\nline::

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

Saya suka itu $/x/[v^]/terlihat seperti substitusi.

Bagaimana itu bekerja:

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

Ini akan menjadi omong kosong lengkap untuk orang-orang yang tidak terbiasa dengan PowerShell. Mari kita lalui.

Mengambil input param([char]$a,$b), dengan karakter pemeran eksplisit untuk $a. Sisa dari program ini adalah satu pernyataan. Kami akan mulai dengan babak pertama, hingga -join.

Kami sedang membuat array dinamis baru (...,...)dan mengindeks ke dalamnya $a%7-eq6. Nilai-nilai ASCII untuk vdan >adalah 116dan 62, masing-masing, dan 116%7 = 62%7 = 6, dan mereka adalah dua arah yang "naik" ke bawah dan ke kanan. Jadi, jika itu -eqadalah $true, kami akan mengambil nilai kedua, yang $b[0..$c], atau sebuah array dari karakter $bhingga akhir . Kami mendapatkan nilai $cdari nilai pertama $b[($c=$b.length)..0],, yang dipilih jika karakter inputnya adalah^ atau< (yaitu, sehingga melewati string ke belakang). Penting untuk dicatat adalah bahwa bahkan jika nilai kedua dipilih, $cnilai tersebut masih dihitung dan disimpan, sehingga kami dapat menggunakannya kembali sebagai jalan pintas seperti ini.

Jadi, kita sekarang punya berbagai karakter baik maju atau mundur. Kami kemudian -joinkarakter-karakter tersebut bersama-sama dengan hasil indeks array dinamis lain. Kali ini kami memilih berdasarkan pada apakah nilai ASCII di $abawah 90(benar-benar banyak nilai akan berfungsi, saya memilih ini hanya karena). Karena >dan <keduanya memiliki nilai di bawah ini 90, -ltis $false, jadi kami memilih string kosong "", dan dengan demikian char-array digabungkan. Jika tidak, kami memilih karakter baris baru "`n"untuk bergabung dengan char-array bersama dengan baris baru.

String yang dihasilkan ini ditinggalkan di jalur pipa, dan outputnya implisit.

Contoh

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

C, 123 119 117 114 byte

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

Program pengujian, dengan penjelasan & kode yang agak tidak digubah:

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

Tips diterima!

Retina , 60 byte

Membutuhkan golf ...

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

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

Input adalah semua sebagai satu string, mis ^ABC.

• Jika ^atau <, balikkan string
• Sisipkan baris baru setelah setiap karakter
• Jika <atau >, hapus baris baru

Cobalah online.

Dyalog APL , 15 byte

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

⍪buat string menjadi tabel 1-kolom
⍣(‍... )ulangi ( n ) kali ⍞dapatkan input string
⎕UCSdikonversi ke
11|istirahat pembagian kode kode UCS ketika dibagi dengan 11
⌽∘⍉ rotate -90 ° (flip-transpose)

Metode alternatif (panjang yang sama):

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

⎕mendapatkan input yang dievaluasi (jadi seseorang harus memasukkan, misalnya '^' atau nama program / variabel yang mengembalikan karakter yang diinginkan)
'<^>v'⍳indeks ke dalam string

Jolf, 22 byte

Coba di sini! Anda harus menggantinya ƒdengan \x9f. Mengambil sengatan, lalu karakter arah.

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

Membangun string yang diperlukan dan mendapatkan indeks yang aterletak di. indexOfDigunakan karena ^merupakan token regex. Berkat produk ETH untuk perbaikan bug dan byte yang dicukur!

JavaScript (ES6) 71

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

Uji

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 plus satu untuk -p

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

Input adalah string tunggal yang karakter pertamanya menentukan orientasi.

DUP , 48 byte

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

Try it here.

Lambda anonim yang mengambil argumen dan input STDIN. Pemakaian:

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

Penjelasan

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

Serius, 41 byte

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

Mengambil string sebagai input pertama dan arah (><v^ ) sebagai input kedua.

Cobalah 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

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