Bir 16-nokta pusula gül yönlerinden biri olan bir dize verilen

Giriş yönüne hemen bitişik olan iki yönü saat yönünde çevirin.

Özellikle, bu (ve yalnızca bu) giriş / çıkış çiftlerini kullanmanız gerekir:

Input  Output
N      NNW NNE
NNE    N NE
NE     NNE ENE
ENE    NE E
E      ENE ESE
ESE    E SE
SE     ESE SSE
SSE    SE S
S      SSE SSW
SSW    S SW
SW     SSW WSW
WSW    SW W
W      WSW WNW
WNW    W NW
NW     WNW NNW
NNW    NW N

Çıktı, yönler veya iki elemanlı bir liste arasında sınırlayıcı (hiçbir şey değil) bulunan bir dize olabilir. Girişin hemen saat yönünün tersine yönü ilk önce görünmelidir. Yönler için büyük harf yerine küçük harf kullanabilirsiniz, ancak tüm giriş ve çıkışları bir durumda veya diğerinde saklayın.

Örneğin, giriş için N(veya nküçük harf kullanıyorsanız) bazı geçerli çıkışlar:

NNW NNE
NNW-NNE
["NNW", "NNE"]
nnw-nne (if using lowercase)

Bazı geçersiz çıktılar:

NNWNNE
NNE NNW
nnwNNE
NNw NNe

Bayt cinsinden en kısa kod kazanır.

Mathematica, 118 112 bayt

Martin Ender'e 6 byte tasarruf ettiğin için teşekkürler!

r=StringSplit@"N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW N NNE";<|Array[r[[#]]->r[[#+{-1,1}]]&,16,2]|>

Girdi olarak dize alan ve sıralı dizeler çifti döndüren adlandırılmamış işlev (bir ilişkilendirme, gerçekten). Temelde cevabı sadece kodlar.

Jöle , 37 34 bayt

“¢ ¬9£Hæz¥{çb¤S®!‘ṃ€“¡&¦»
¢iµ’,‘ị¢

Çevrimiçi deneyin!

Küçük harf girişi yapar.

-2 Jonathan Allan'a teşekkürler .
-1 çıktığından beri bu bir fonksiyon olarak geçerlidir :)

Jonathan Allan (ve Dennis) sayesinde şimdi kaldırabilirsiniz €. Ne yazık ki, bu burada rekabet edemez.

Detaylı algoritma açıklaması :

Genellikle aşağıdan (ana) bağlantıdan aşağıya doğru açıklamaya başlarız, ama burada yukarıdan açıklamanın daha uygun olduğunu düşünüyorum.

İlk önce listeyi yüklüyoruz [1, 32, 7, 57, 2, 67, 17, 92, 3, 94, 19, 119, 4, 109, 9, 34]. Bu rasgele sayılar gibi görünüyor, ha? Aslında bu aslında 5 bazında sıkıştırılmış sayıların bir listesi, biz 5 bazında çıkardık. Şimdi benziyor [[1], [1, 1, 2], [1, 2], [2, 1, 2], [2], [2, 3, 2], [3, 2], [3, 3, 2], [3], [3, 3, 4], [3, 4], [4, 3, 4], [4], [4, 1, 4], [1, 4], [1, 1, 4]]. Yine de rastgele görünen şeyler, ama bu aslında NESWon altı koordinatın haritalanmış bir listesi, bu yüzden listeyi tamamlamaktan çok uzakta değiliz (Jelly 1 indeksli). Son eşleştirmeyi [['N'], ['N', 'N', 'E'], ['N', 'E'], ['E', 'N', 'E'], ['E'], ['E', 'S', 'E'], ['S', 'E'], ['S', 'S', 'E'], ['S'], ['S', 'S', 'W'], ['S', 'W'], ['W', 'S', 'W'], ['W'], ['W', 'N', 'W'], ['N', 'W'], ['N', 'N', 'W']]yaparak istediğimiz listenin tamamını elde ederiz (Jelly string'leri formdadır) [char1, char2, char3, ...].

Şimdi koordinat listesini oluşturduğumuzdan beri onunla çalışıyoruz. Ana link devreye giriyor. Öncelikle, oluşturduğumuz listeyi yüklüyoruz, sonra girdi (komut satırı argümanı) koordinatının içinde bulunduğu dizini alıyoruz. Sonra selefini ve halefini bir liste halinde eşleştiriyoruz ve onları modüler olarak kullanıyoruz. sırasıyla koordinatın girişin soluna ve sağına götürülmesi için aynı koordinat listesine Şimdi sonunda bittiğimizi düşünüyorsun, ama aslında bir şey daha var, ayırıcı. Bu bir fonksiyon olarak geçerlidir, çünkü 1) Bunu kullanarak çağırabilirsiniz <integer>Ŀ2) Diğer fonksiyonları da tanımlamanıza izin verilir (alma modülleri gibi). Şimdi bitti. Tam bir program olarak, bunun bir ayırıcıya sahip değildir, ancak bir fonksiyon olarak çalıştığından sorun değil.

Bağlantılı kod kodu açıklaması :

¢iµ’,‘ị¢K Main link. Arguments: z = cmd0
¢         Run the helper link niladically (i.e. load the coordinate list).
 i        Find the index of z in the list.
  µ       Start a new monadic chain. Arguments: z = list_index.
   ’      Decrement z.
     ‘    Increment z.
    ,     Pair x and y into [x, y].
       ¢  Run the helper link niladically.
      ị   Take the elements of y at the indices in x.

“¢ ¬9£Hæz¥{çb¤S®!‘ṃ€“¡&¦» Helper link. Arguments: [1, 32, 7, 57, 2, 67, 17, 92, 3, 94, 19, 119, 4, 109, 9, 34]
“¢ ¬9£Hæz¥{çb¤S®!‘        Generate the integer list (the argument).
                    “¡&¦» Literal "newsy".
                  ṃ€      Base-length(y)-decompress every integer in x, then index into y.

Python 2, 116 115 103 bayt

Neil sayesinde -12 bayt

d='N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW'.split()
n=d.index(input())
print d[n-1],d[n-15]

Çevrimiçi Deneyin!

JavaScript ES6, 106 102 bayt

p=>[(a=`N|NNE|NE|ENE|E|ESE|SE|SSE|S|SSW|SW|WSW|W|WNW|NW|NNW`.split`|`)[i=a.indexOf(p)-1&15],a[i+2&15]]

Çevrimiçi deneyin!

const f = p=>[(a=`N|NNE|NE|ENE|E|ESE|SE|SSE|S|SSW|SW|WSW|W|WNW|NW|NNW`.split`|`)[i=a.indexOf(p)-1&15],a[i+2&15]]

console.log(f('N'))
console.log(f('NNE'))
console.log(f('ENE'))
console.log(f('E'))
console.log(f('ESE'))
console.log(f('SE'))
console.log(f('SSE'))
console.log(f('S'))
console.log(f('SSW'))
console.log(f('SW'))
console.log(f('WSW'))
console.log(f('W'))
console.log(f('WNW'))
console.log(f('NW'))
console.log(f('NNW'))

05AB1E , 44 43 bayt (Adnan sayesinde)

"ESNW4"•2ßU^]>Þ‡¾“¾&é{½‡•5BSè4¡©skD<®ès>®è)

Çevrimiçi deneyin!

"ESNW4"•2ßU^]>Þ‡¾“¾&é{½‡•5BSè # Push N4NNE4NE4ENE4E4ESE4SE4SSE4S4SSW4SW4WSW4W4WNW4NW4NNW
4¡©            # Split on 4's and store.
   sk          # Index of input in direction array.
     D<®è      # Element before index of input.
         s>®è  # Element after index of input.
             ) # Wrap two element to array.

Exmaple çıktı:

N => [NNW,NNE]

N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNWBunun yerine zorlayan sürüm :

•17¿$Mn]6VAÆ—Dªd—•5B4LJ"NSWE"‡0¡©skD<®ès>®è)

Ayrıca 44 bayt, benim refactor için 0 neden ve 4'lü bölmek için 0 neden vardı.

Javascript - 234 154 156 152 120 106 102 bayt

Sadece ikinci kez kod golf yapıyor !!

Son revizyon:

Bu temiz değişken numarası için @ fəˈnɛtɪk'e teşekkür ederiz!

s=>[(a=`NNW N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW`.split` `)[n=a.indexOf(s)-1&15],a[n+2&15]]

Ondan Önce: Tamam, en son revizyon: Girdi bir dize ve çıktı kurallara uygun bir dizedir, bu yüzden bir işleve dönüştürdüm ve indirimlerle daha da küçüldüm (işlev de anonim, şimdi benim ki) her nasılsa diğerlerine girdik js cevap ayy! O (powelles) önce ona sahipti !!):

(s,a=`NNW N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW`.split` `,n=a.indexOf(s))=>[a[n-1&15],a[n+1&15]]

Tarafından kullanılabilir:

f=(s,a=`NNW N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW`.split` `,n=a.indexOf(s))=>[a[n-1&15],a[n+1&15]]
alert(f(prompt()))

Çıkış - 120 ile yeniden ödeme (işlev değil):

a="NNW N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW".split(' ');n=a.indexOf(prompt());alert(a[n-1&15]+' '+a[n+1&15]);

• Başlangıçta, ilk dizin için a.length-1 yerine a.length değerine eşit bir hata yaptığımı unutmayın. NNW için işe yaramadığını belirttiğiniz için NeNe teşekkürler.

• Not 2: Kodu kısaltmama yardım ettiğin için @Neil ve @ETHProductions'a teşekkür ederim!

originial:

a="NNWN  NNENE ENEE  ESESE SSES  SSWSW WSWW  WNWNW ";l=prompt("","");n=l.length<3?l.length<2?l+'  ':l+' ':l;f=a.indexOf(n);i=f-3;j=f+3;i=i<0?a.length+--i:i;j=j+3>=a.length?j-a.length:j;alert(a.substring(i,i+3)+' '+a.substring(j,j+3));

Toplu iş, 196 bayt

@set s=N
@if %1==N echo NNW
@for %%r in (NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW)do @call:c %1 %%r
@if %1==NNW echo N
@exit/b
:c
@if %1==%2 echo %s%
@if %1==%s% echo %2
@set s=%2

Her bir pergel noktası boyunca dolaşır, diğeri eşleştiğinde yazdırır. Örneğin, bir ENEdöngünün ulaştığı bir parametre ENEiçin değişken, basılanı siçerir NE, sonra döngü ilerlediğinde E, değişken siçerir ENEve böylece Eyazdırılır. Pusula noktalarının yanlış sırayla yazdırılmasını önlemek için bir çiftin özel kasaya sahip olması gerekir.

Haskell , 100 99 bayt

s=words"N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW"++s
(a:b:c:r)#x|x==b=(a,c)|1<3=r#x
(s#)

Çevrimiçi deneyin! Çağrı (s#) "N"döner ("NNW","NNE").

syön listesinin sonsuz bir tekrarıdır, bu nedenle listenin kenarlarını doğru bir şekilde işlemek için fazladan Nve NNEbazı diğer cevaplar gibi eklememiz gerekmez .

Bir bayt tasarrufu için @nimi teşekkürler!

Jöle ,  40 38 bayt

“NSWE”“dḍ.ƈ€ḶƘfƥ’ṃṁ
“¢)`)’ḃ3RÇṙi¥µṖṪ,Ḣ

Çevrimiçi deneyin! (çıktının iki öğenin bir listesi olduğunu göstermek için altbilgi eklendi) ... veya tüm durumları görün .

( 1323DRẋ4Yerine “¢)`)’ḃ3Rşu anda neden işe yaramadığından emin değilim .)

Nasıl?

“NSWE”“dḍ.ƈ€ḶƘfƥ’ṃṁ - Link 1, rose list helper: shape array
“NSWE”              - "NSWE"
      “dḍ.ƈ€ḶƘfƥ’   - base 250 number: 1554210846733274963415
                 ṃ  - base decompress: "NNNENEENEEESESESSESSSWSWWSWWWNWNWNNW"
                  ṁ - mould like shape array

“¢)`)’ḃ3RÇṙi¥µṖṪ,Ḣ - Main link: direction string
“¢)`)’             - base 250 number: 33899292
      ḃ3           - to base 3: [1,3,2,3,1,3,2,3,1,3,2,3,1,3,2,3]
        R          - range (vectorises) [[1],[1,2,3],[1,2],[1,2,3],[1],[1,2,3],[1,2],[1,2,3],[1],[1,2,3],[1,2],[1,2,3],[1],[1,2,3],[1,2],[1,2,3]]
         Ç         - call the last link (1) as a monad: ["N","NNE","NE","ENE","E","ESE","SE","SSE","S","SSW","SW","WSW","W","WNW","NW","NNW"]
            ¥      - last two links as a dyad
          ṙ        -     rotate the list by:
           i       -         index of the direction string in the list
             µ     - monadic chain separation (call the rotated list x)
              Ṗ    - pop (x[:-1]) (removes the direction string)
               Ṫ   - tail that (i.e. x[-2])
                 Ḣ - head x (i.e. x[0])
                ,  - pair

SOGL , 33 bayt

≠┐πΜ]ρ½d⁹V¹-┐*╔╤¹Ψæ;¶‘θ,W:AHwOaIw

İlk bölüm ≠┐πΜ]ρ½d⁹V¹-┐*╔╤¹Ψæ;¶‘, sıkıştırılmış bir dizedir.

N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW

ile özel bir sözlükle sıkıştırılmış ENSW

Programın geri kalanı:

...‘θ,W:AHwOaIw  example input: NNW
...‘             push the compressed string        ["N NNE NE ... NNW"]
    θ            split on spaces                   [["N","NNE",...,"NNW"]]
     ,W          get the index of input            [["N","NNE",...,"NNW"], 16]
       :A        save the index on variable A      [["N","NNE",...,"NNW"], 16]
         H       decrease [the index]              [["N","NNE",...,"NNW"], 15]
          wO     output that'th item of the array  [["N","NNE",...,"NNW"]]
            a    load variable A                   [["N","NNE",...,"NNW"], 16]
             I   increase [the index]              [["N","NNE",...,"NNW"], 17]
              w  get that item in the array        [["N","NNE",...,"NNW"], "N"]

PHP, 122 bayt

preg_match("/([^ ]+ )$argv[1] ([^ ]+)/",'N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW N NNE',$m);
echo $m[1].$m[2];

Yakut - 94 Bayt

Blue Okiris'in cevabına bir riff , sadece bazı güzel Ruby stenolarından ( %w[]sözdizimi ve pözellikle) faydalanmak için :

->(s,d=%w[N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW],n=d.index(s)){p d[n-1],d[n-15]}

Japt , 66 52 bayt

@ETHproductions sayesinde 14 bayt kurtarıldı

V=`ã@JaÀTeaÀÄsÁÁss°s°ws°°wn°n°nnw`qa [J1]£VgX+VaU

Çevrimiçi deneyin!

Açıklama:

V=(`...`qa) [J1]£Vg(X+VaU)
V=(       )                // Set V to:
   `...`                   //   "nanneaneaeneaeaeseaseasseasasswaswawswawawnwanwannw" (de-)compressed
        qa                 //    Split on "a", creating [n...nnw]
            [J1]           // [-1,1]
                £          // Iterate through ^, X becomes the iterative item
                 Vg(     ) //   V.Item at index:
                    X+VaU  //     X + V.indexOf(input)

CJam, 41

"NeSWN"2ew{_1<\_La*\$f+~}%:eu_ra#(m<2%2<p

Çevrimiçi deneyin

PHP, 115 Bayt

for($r=explode(_,($w=N_NNE_NE_ENE_E_ESE_SE_SSE_).strtr($w,SWNE,NESW).$w);$r[++$i]!=$argn;);echo$r[$i-1]._.$r[$i+1];

Kullanımdan kaldırılmış işlevi kullanarak -2 Bayt split yerineexplode

PHP, 128 Bayt

for($i=2;$i--;print$i?end($e)._:$e[2])$e=explode(_,strstr(($w=N_NNE_NE_ENE_E_ESE_SE_SSE_).strtr($w,SWNE,NESW).$w,_.$argn._,$i));

PHP, 134 Bayt

echo($r=explode(_,N_NNE_NE_ENE_E_ESE_SE_SSE_S_SSW_SW_WSW_W_WNW_NW_NNW))[($k=array_search($argn,$r))-1<0?15:$k-1]._.$r[$k+1>15?0:$k+1];

PHP, 110 109 bayt

Jörg Hülsermann sayesinde 1 bayt kaydedildi .

echo@preg_filter("/.*?(\w+) $argn( \w+).*/",'$1$2',($s='N NNE NE ENE E ESE SE SSE ').strtr($s,NESW,SWNE).$s);

Python 3 - 112 107 bayt

Bunu Javascript cevabımdan aldım:

remade:

lambda i,s="N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW".split():[s[s.index(i)-1],s[s.index(i)-15]]

Söyleneni kullan

f = lambda i,s="N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW".split():[s[s.index(i)-1],s[s.index(i)-15]]
print(f(input()));

Orijinal:

lambda i,s="N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW".split():[s[s.index(i)-1&15],s[s.index(i)+1&15]]

MATL , 43 bayt

';evl(Z?&fWElf`gvhM'F' NESW'ZaYbtjY=fFTEq+)

Çevrimiçi deneyin!

açıklama

';evl(Z?&fWElf`gvhM' % Push this string
F                    % Push false
' NESW'              % Push this string
Za                   % Base conversion. This decompresses the first string from alphabet
                     % given by all printable ASCII except single quote to the alphabet
                     % ' NESW'. The result is the following string, which is pushed:
                     % 'N NNE NE ENE E ESE SE SSE S SSW SW WSW W WNW NW NNW'
Yb                   % Split at spaces. Gives a cell array of strings
t                    % Duplicate
j                    % Input string
Y=                   % String comparison. Gives an array containing true at the index
                     % of the matching string
f                    % Find: index of the entry that equals true
FTEq                 % Push [-1 1] (obtained as [false true], times 2, minus 1)
+                    % Add, element-wise
)                    % Index modularly into the cell array of strings
                     % Implicitly display. Each cell is displayed on a different line

c, 222 216 211 bayt

main(c,v)char**v;{char r[]="NXNNEXNEXENEXEXESEXSEXSSEXSXSSWXSWXWSWXWXWNWXNWXNNWX",*p=r,*s=r,*a[16],i=0,n;for(;*p++;)*p==88?*p=0,n=strcmp(a[i++]=s,v[1])?n:i-1,s=++p:0;printf("%s %s\n",a[n?n-1:15],a[n<15?n+1:0]);}

Çevrimiçi deneyin

Javascript (ES6), 189 bayt

d="N.NNW NNE.NNE.N NE.NE.NNE ENE.ENE.NE E.E.ENE ESE.ESE.E SE.SE.ESE SSE.SSE.SE S.S.SSE SSW.SSW.S SW.SW.SSW WSW.WSW.SW W.W.WSW WNW.WNW.W NW.NW.WNW NNW.NNW.NW N".split`.`,f=>d[d.indexOf(f)+1]

Sadece girdiyi alır, arar ve geri döndürür.

JavaScript (ES6), 94 bayt

Büyük bir dizge gibi bir dize bekler "ENE". Gibi virgülle ayrılmış bir dize döndürür "NE,E".

s=>/\D+,\D+/.exec('NNW0N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N'.split(0+s+0))[0]

Nasıl çalışır

İfade çağrıldığında 0+s+0bir dizeye zorlanır split(). Örneğin, eğer girdi ise "ENE", dizge bölünecek "0ENE0":

"NNW0N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N"
             ^^^^^

Bu, aşağıdaki diziye yol açar:

[ "NNW0N0NNE0NE", "E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N" ]

Yine, bu dizi exec()çağrıldığında bir dizeye zorlanır . Bu nedenle, düzenli ifade aslında şu noktalara uygulanır:

"NNW0N0NNE0NE,E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N"

Ardışık sayısal olmayan karakterleri ( \D+) ve ardından virgül, ardışık olmayan sayısal olmayan karakterleri ararız. Bu diziyi döndürür [ "NE,E" ]. Muhtemelen orada durabilir ve tam olarak geri dönebiliriz. Ancak zorluk, sınırlandırılmış bir dize ya da iki elemanlı bir dizi istiyor. Böylece ipi ile çıkartıyoruz [0].

gösteri

let f =

s=>/\D+,\D+/.exec('NNW0N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N'.split(0+s+0))[0]

;
["N","NNE","NE","ENE","E","ESE","SE","SSE","S","SSW","SW","WSW","W","WNW","NW","NNW"]
.map(
  s => console.log(s, '=>', f(s))
)

Pyth , 39 bayt:

.rL]z_Bms@L"ESWN"jCd5"\"❤m❤w❤^❤\❤C❤9❤ ❤

nerede ❤basılamaz harfleri temsil eder.

Çevrimiçi deneyin!

HexDump:

0000000: 2e 72 4c 5d 51 5f 42 6d 73 40 4c 22 45 53 57 4e .rL]Q_Bms@L"ESWN
0000010: 22 6a 43 64 35 22 5c 22 09 6d 04 77 13 5e 03 5c "jCd5"\".m.w.^.\
0000020: 11 43 02 39 07 20 01                            .C.9. .