Дано рядок, що є одним із напрямків на 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

Виграє найкоротший код у байтах.

Математика, 118 112 байт

Дякуємо Мартіну Ендеру за збереження 6 байт!

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µ’,‘ị¢

Спробуйте в Інтернеті!

Займає малі літери.

-2 завдяки Джонатану Аллану .
-1 оскільки виявляється, це дійсно як функція :)

Завдяки Джонатану Аллану (та Деннісу) тепер ви можете видалити це €. На жаль, це було б неконкурентом.

Детальне пояснення алгоритму :

Ми зазвичай починаємо пояснювати з нижнього (головного) посилання, спускаючись вниз, але тут я відчуваю, що доцільніше пояснити зверху.

По-перше, ми просто завантажуємо список [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]]. Все ще виглядають випадкові речі, але це насправді - NESWзафіксований список з шістнадцяти координат, тому ми не за горами від заповнення списку (Jelly є 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.

Python 2, 116 115 103 байт

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

Спробуйте в Інтернеті!

JavaScript 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 байт (спасибі Аднану)

"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 причин, і є 0 причин для розщеплення на 4-х.

Javascript - 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 answer oops! У нього (powelles) було це перше !!):

(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 замість a.length-1 для першого індексу. Дякуємо @Neil за те, що вказали, що це не працює для NNW.

• Примітка 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друкується. Тоді одна пара повинна бути спеціально оброблена, щоб уникнути друкування точок компаса в неправильному порядку.

Haskell , 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як і деякі інші відповіді, щоб правильно обробити краї списку.

Дякуємо @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 байти

Риф на відповідь Синій 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]}

Japt , 66 52 байт

Збережено 14 байт завдяки @ETHproductions

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

-2 байти, використовуючи застарілу функцію splitзамість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 байт

Збережено 1 байт завдяки Йоргу Гюльсерману .

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 байт

Я ґрунтувався на цьому на своїй відповіді на 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]);}

Спробуйте в Інтернеті

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

Просто бере дані, шукає його і повертає.

JavaScript (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" ]. Ми могли б, можливо, зупинитися на цьому і повернутись саме так. Але виклик полягає в тому, щоб задати або обмежений рядок, або двоелементний масив. Отже, витягуємо рядок за допомогою[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❤ ❤

де ❤зображено недруковані букви.

Спробуйте в Інтернеті!

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