16 점 나침반 장미의 방향 중 하나 인 끈이 주어지면

입력 방향에 바로 인접한 두 방향을 시계 방향으로 출력합니다.

특히 다음과 같은 입력 / 출력 쌍을 처리해야합니다.

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

출력은 방향 또는 두 요소 목록 사이에 구분 기호가있는 문자열 일 수 있습니다 (아무것도 아님). 입력에 반 시계 방향으로 즉시 방향이 먼저 나타납니다. 대문자 대신 길 찾기에 소문자를 사용할 수 있지만 모든 입력 및 출력을 한 가지 또는 다른 방식으로 유지하십시오.

예를 들어, 입력 N(또는 n소문자를 사용하는 경우)의 일부 유효한 출력은 다음과 같습니다.

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

일부 유효하지 않은 출력은 다음과 같습니다.

NNWNNE
NNE NNW
nnwNNE
NNw NNe

바이트 단위의 가장 짧은 코드가 이깁니다.

Mathematica, 118112 바이트

6 바이트를 절약 한 Martin Ender에게 감사합니다!

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

문자열을 입력으로 사용하고 정렬 된 문자열 쌍을 반환하는 이름이없는 함수 (정말 연관)입니다. 기본적으로 답변을 하드 코딩합니다.

젤리 , 37 34 바이트

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

온라인으로 사용해보십시오!

소문자 입력을받습니다.

Jonathan Allan 에게 -2 감사합니다 .
-1 이것은 함수로 유효하다는 것이 밝혀졌습니다. :)

Jonathan Allan (및 Dennis) 덕분에 이제를 제거 할 수 있습니다 €. 불행히도 여기서는 경쟁이 아닙니다.

자세한 알고리즘 설명 :

우리는 일반적으로 아래쪽 (주) 링크에서 설명을 시작하여 아래로 내려갑니다. 그러나 여기서는 위에서 설명하는 것이 더 적절하다고 생각합니다.

먼저 단순히 목록을로드합니다 [1, 32, 7, 57, 2, 67, 17, 92, 3, 94, 19, 119, 4, 109, 9, 34]. 이것은 임의의 숫자처럼 보입니까? 자, 이것은 실제로 기본 5 압축 숫자 목록이므로 기본 5 압축 해제합니다. 이제는 다음과 같습니다 [[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]]. 여전히 무작위로 보이는 물건이지만 실제로는 NESW16 개의 좌표 가 매핑 된 목록이므로 목록을 완성하는 데 그리 멀지 않습니다 (젤리는 1 인덱싱 됨). 최종 매핑을 수행하면 [['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']]원하는 전체 목록 인을 얻을 수 있습니다 (젤리 문자열은 형식 [char1, char2, char3, ...]입니다).

좌표 목록을 만들었으므로 함께 작업합니다. 메인 링크가 작동합니다. 먼저 빌드 한 목록을로드 한 다음 입력 (명령 줄 인수로) 좌표가있는 인덱스를 가져옵니다. 그런 다음 선행 작업과 후속 작업을 목록으로 쌍을 이루고이를 모듈로 사용합니다. 동일한 좌표 목록에 인덱스를 사용하여 입력의 왼쪽과 오른쪽으로 각각 좌표를 가져옵니다. 이제 우리는 마침내 끝났다고 생각할 것입니다. 그러나 실제로 한 가지 더 구분자가 있습니다. 1) 다음을 사용하여 호출 할 수 있기 때문에 함수로 유효합니다. <integer>Ŀ2) 모듈 가져 오기와 같은 다른 함수도 정의 할 수 있습니다. 이제 끝났습니다. 전체 프로그램으로서, 이것은 분리자를 갖지 않지만 함수로서 작동하기 때문에 괜찮습니다.

링크 별 코드 설명 :

¢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.

파이썬 2 116 115 103 바이트

Neil 덕분에 -12 바이트

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]

온라인으로 사용해보십시오!

자바 스크립트 ES6, 106 102 바이트

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

온라인으로 사용해보십시오!

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 바이트 (Adnan에게 감사)

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

온라인으로 사용해보십시오!

"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.

탁월한 출력 :

N => [NNW,NNE]

N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW대신 푸시 버전 :

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

또한 44 바이트이며, 리 팩터에는 0 가지 이유가 있었고 4에서 나눌 이유는 없습니다.

자바 - 234 154 156 152 120 106 102 바이트

코드 골프를하는 두 번째 시간!

최신 개정 :

이 깔끔한 변수 트릭에 대해 @ fəˈnɛtɪk에게 감사합니다!

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

그 전에 : 좋아, 최신 개정판 : 입력은 문자열이고 출력은 규칙에있는 문자열이므로 함수로 만들고 축소하면 더 작아졌습니다 (함수는 익명이므로 이제는 내 것을 의미합니다) 어떻게 든 다른 js 응답 죄송합니다! 그 (가장자리)가 먼저했습니다!) :

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

다음에 의해 사용될 수 있습니다 :

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()))

출력-120으로 재생성 (기능 아님) :

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

• 원래 첫 번째 색인에 대해 a.length-1 대신 a.length와 동일한 오류가 발생했습니다. NNW에서 작동하지 않는다고 지적한 @Neil에게 감사합니다.

• 참고 2 : 코드 단축에 도움을 주신 @Neil 및 @ETHProductions에게 감사합니다!

원산지 :

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

배치, 196 바이트

@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

각 나침반 지점 쌍을 반복하여 서로 일치 할 때 하나씩 인쇄합니다. 예를 들어, 매개 변수의 ENE루프 도달이 ENE변수가 s포함 된 NE인쇄 된 다음에 루프 전진 할 때 E변수가 s포함 ENE되도록이 E인쇄된다. 나침반 포인트가 잘못된 순서로 인쇄되지 않도록 한 쌍을 특수 케이스로 만들어야합니다.

하스켈 , 100 99 바이트

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

온라인으로 사용해보십시오! 호출하면을 (s#) "N"반환합니다 ("NNW","NNE").

s는 길 찾기 목록을 무한 반복하므로 목록의 가장자리를 올바르게 처리하기 위해 다른 답변 N과 NNE마찬가지로 추가 할 필요가 없습니다 .

1 바이트를 저장해 준 @nimi에게 감사합니다!

젤리 ,  40 38 바이트

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

온라인으로 사용해보십시오! (출력이 두 항목의 목록임을 표시하기 위해 바닥 글 추가) ... 또는 모든 사례를 참조하십시오.

( 1323DRẋ4현재 대신 왜 “¢)`)’ḃ3R작동하지 않는지 잘 모르겠습니다 .)

어떻게?

“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 바이트

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

첫 번째 부분 ≠┐πΜ]ρ½d⁹V¹-┐*╔╤¹Ψæ;¶‘은 압축 된 문자열입니다.

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

사용자 지정 사전으로 압축 ENSW

프로그램의 나머지 부분 :

...‘θ,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 바이트

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

루비-94 바이트

Blue Okiris의 답변 에 대한 리프는 멋진 Ruby 속기 ( %w[]구문 및 p구체적)를 활용합니다.

->(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]}

apt , 66 52 바이트

@ETHproductions 덕분에 14 바이트 절약

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

온라인으로 사용해보십시오!

설명:

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

온라인으로 사용해보십시오

PHP, 115 바이트

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

더 이상 사용되지 않는 함수 split를 사용하는 -2 바이트explode

PHP, 128 바이트

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 바이트

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 바이트

Jörg Hülsermann 덕분에 1 바이트를 절약했습니다 .

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

파이썬 3 - 112 107 바이트

나는 이것을 Javascript 답변을 기반으로했습니다.

리메이크 :

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

말 그대로 사용

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

기발한:

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 바이트

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

온라인으로 사용해보십시오!

설명

';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 바이트

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

온라인으로 사용해보십시오

자바 스크립트 (ES6), 189 바이트

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]

입력을 가져 와서 찾아서 반환합니다.

자바 스크립트 (ES6), 94 바이트

대문자와 같은 문자열을 기대합니다 "ENE". 와 같이 쉼표로 구분 된 문자열을 반환합니다 "NE,E".

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

작동 원리

호출 0+s+0되면 표현식 이 문자열로 강제 변환됩니다 split(). 예를 들어 입력이 "ENE"인 경우 문자열은 다음과 같이 분할됩니다 "0ENE0".

"NNW0N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N"
             ^^^^^

이것은 다음 배열로 이어집니다.

[ "NNW0N0NNE0NE", "E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N" ]

이 배열은 다시 exec()호출 될 때 문자열로 강제 변환됩니다 . 따라서 정규 표현식은 실제로 다음에 적용됩니다.

"NNW0N0NNE0NE,E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N"

연속적인 숫자가 아닌 문자 ( \D+), 쉼표, 연속적인 숫자가 아닌 문자를 찾습니다 . 이것은 배열을 반환합니다 [ "NE,E" ]. 우리는 논란의 여지없이 그만두고 돌아올 수 있습니다. 그러나 과제는 구분 된 문자열 또는 2 요소 배열을 요구하는 것입니다. 따라서 문자열을로 추출합니다 [0].

데모

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 바이트 :

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

여기서 ❤인쇄 할 수없는 문자를 나타냅니다.

온라인으로 사용해보십시오!

16 진 덤프 :

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