मुझे गुलाब के साथ 22.5 मोड़ दें


38

एक स्ट्रिंग को देखते हुए जो 16-बिंदु कम्पास गुलाब पर दिशाओं में से एक है

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

बाइट्स में सबसे छोटा कोड जीतता है।

जवाबों:


11

गणितज्ञ, ११hem ११२ बाइट्स

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

फ़ंक्शन (एक एसोसिएशन, वास्तव में) जो एक स्ट्रिंग को इनपुट के रूप में लेता है और स्ट्रिंग्स की एक ऑर्डर की गई जोड़ी देता है। मूल रूप से सिर्फ उत्तर को हार्डकोड करता है।


11

जेली , 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में सोलह निर्देशांक की एक- मैप की गई सूची है, इसलिए हम सूची को पूरा करने से बहुत दूर नहीं हैं (जेली 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.


8

पायथन 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]

इसे ऑनलाइन आज़माएं!


2
d[n-15]हालत से बचने के लिए उपयोग करें ।
नील

1
वैसे, आपके उत्तर में कोड सेगमेंट के अंत में एक विलक्षण उद्धरण है। मैं खुद एक संपादन अनुरोध करूंगा, लेकिन संपादन में कम से कम छह अक्षर होने चाहिए और यह केवल एक ही होगा।
नॉटजगन

1
@ नील धन्यवाद! बहुत सारे बाइट्स बचाए :)
मैथ जंकी

1
@notjagan कि बाहर इशारा करने के लिए धन्यवाद। इसे तय किया
गणित जंकी

8

जावास्क्रिप्ट ईएस 6, 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'))


के letबजाय के साथ 2 बाइट्स सहेजें const
HonoredMule

1
-4 बाइट्स को चर घोषणाओं में स्थानांतरित करने के लिए जहां वे पहली बार उपयोग किए जाते हैं, इसे ऑनलाइन आज़माएं
fɛn byt 14k

7

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 कारण था और 4 के बंटवारे का 0 कारण है।



1
4एस पर विभाजित करने का कोई विशेष कारण ?
ग्रेग मार्टिन

@GregMartin ने •17¿$Mn]6VAÆ—Dªd—•5B4LJ"NSWE"‡0¡©skD<®ès>®è)कहा कि, नहीं, इसका कोई कारण नहीं है। सीमांकक के रूप में 0 का उपयोग करना एक ही संपीड़न अनुपात है, क्योंकि यह आधार -5 रूपांतरण में बेस -214 में संख्या की लंबाई को नहीं गिराता है। कैना ने ऐसा करते हुए शपथ ली कि मुझे एक बाइट ने बचा लिया।
मैजिक ऑक्टोपस Urn

आप „ €Ã¦•174SÝ©l2ÎG¦˜fÐ98•5BSè#ÐIk©<ès®>è)4 बाइट बचाने के लिए कर सकते हैं ।
एमिगा

7

जावास्क्रिप्ट - 234 154 156 152 120 106 102 बाइट्स

केवल मेरे दूसरी बार कोड गोल्फ कर रहा हूँ !!

नवीनतम संशोधन:

इस स्वच्छ चर चाल के लिए @ f younɛ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]]

इससे पहले: ठीक है तो नवीनतम संशोधन: इनपुट एक स्ट्रिंग है और आउटपुट एक स्ट्रिंग है जो नियमों में है, इसलिए मैंने इसे एक फ़ंक्शन में बनाया, और कटौती के साथ मैं और भी छोटा हो गया (फ़ंक्शन भी अनाम है, जिसका अर्थ है कि मेरा है किसी भी तरह से अन्य जेएस उत्तर उफ़ में जाल डाला! वह (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-1 के बजाय समान है। यह इंगित करने के लिए @Neil धन्यवाद कि यह NNW के लिए काम नहीं किया।

  • नोट 2: कोड को छोटा करने में मेरी मदद करने के लिए @Neil और @ETHProductions को धन्यवाद!

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

1
गोल्फवर्ल्ड में आपका स्वागत है!
ग्रेग मार्टिन

1
यह काम नहीं करता है NNW
नील

@ नील तुम सही हो। मैं इसे ठीक कर दूंगा!
ब्लू ओकिरिस

1
मैं अपने स्वयं के समाधान की दिशा में काम कर रहा था इससे पहले कि मुझे एहसास हुआ कि यह आपके समान था। आपके लिए कुछ सुझाव: 1) बेनामी फ़ंक्शंस मान्य हैं, 2) आपको अपने सबमिशन में इनपुट के लिए अनुरोध करने की आवश्यकता नहीं है, इसे बस एक प्राप्त करने में सक्षम होने की आवश्यकता है, 3) आपको आउटपुट लॉग इन करने की आवश्यकता नहीं है आपका सबमिशन, बस वापस। उस सब को ध्यान में रखते हुए, यहाँ पर आपके द्वारा अपने समाधान को बेहतर बनाने के लिए 106 अक्षर नीचे दिए गए हैं: p => (a = "N, NNE, NE, ENE, E, ESE, SE, SSE, S, SSW, SW , डब्ल्यूएसडब्ल्यू, डब्ल्यू, डब्ल्यूएनडब्ल्यू, एनडब्ल्यू, ,एनएनडब्ल्यू "। एसपीएलआईटी, i = a.indexOf (पी), [एक [i-1 और 15], एक [i + 1 और 15]])
शगुन

1
-4 बाइट्स को वेरिएबल डिक्लेरेशन में ले जाया जाता है जहाँ वे उपयोग किए जाते हैं, इसे ऑनलाइन आज़माएँ
fɛnɪtɪk

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मुद्रित होता है। गलत क्रम में मुद्रित होने से कम्पास बिंदुओं से बचने के लिए एक जोड़ी को फिर से विशेष आवरण की आवश्यकता होती है।


3

हास्केल , 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 को धन्यवाद!


1
एक इन्फिक्स फ़ंक्शन बाइट बचाता है (a:b:c:r)!x| ... =r!x;(s!):।
nimi

2

जेली ,  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

2

एसओजीएल , 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"]

क्या कोड पेज?
जोशुआ

@ bytes
जोशुआ

@ जोशुआ दरअसल, जो निशान के कारण कुछ पात्रों को याद कर रहा था, लेकिन अब यह तय हो गया है
dzaima

2

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

1
आप असमय व्हाट्सएप को हटाकर 2 बाइट बचा सकते हैं। -R विकल्प के $argv[1]साथ $argnऔर उपयोग करने के लिए -3 बाइट्स । यदि आप पदावनत कार्यों का उपयोग करते हैं यदि समाप्त हो सकता हैereg("([^_]+)_{$argn}(_[^_]+)",N_NNE_NE_ENE_E_ESE_SE_SSE_S_SSW_SW_WSW_W_WNW_NW_NNW_N_NNE,$t);echo$t[1].$t[2];
Jörg Hülsermann

1

रूबी - 94 बाइट्स

ब्लू ओकिरिस के उत्तर पर एक रिफ़ , बस कुछ अच्छे रूबी शॉर्टहैंड ( %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]}

1

जाप , 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)

बहुत अच्छा। कुछ सुधार: 1) आप एरेप को अपरकेस में परिवर्तित करने के बजाय लोअरकेस में इनपुट ले सकते हैं। 2) आप वास्तव में निकाल सकते हैं 'में q'oहै और यह बिल्कुल वैसा ही :-) काम करेंगे
ETHproductions

इसके अलावा, आप [J1]£VgX+VaUकुछ बाइट्स बचाने के लिए अंत में सरणी निर्माण को कम कर सकते हैं
ETHproductions

@ETHproductions यह शानदार है, धन्यवाद!
ओलिवर


1

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

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

2
आप बदल सकते preg_replaceके साथ preg_filterकरने के लिए सेव 1 बाइट
Jörg Hülsermann

0

पायथन 3 - 112 107 बाइट्स

मैंने अपने जावास्क्रिप्ट उत्तर के आधार पर यह उत्तर दिया:

पुनर्निर्माण:

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

0

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


0

जावास्क्रिप्ट (ईएस 6), 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]

बस इनपुट लेता है, इसे देखता है, और इसे वापस करता है।


0

जावास्क्रिप्ट (ईएस 6), 94 बाइट्स

अपरकेस में एक स्ट्रिंग की उम्मीद है जैसे "ENE"। एक अल्पविराम से अलग स्ट्रिंग लौटाता है जैसे कि "NE,E"

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

यह काम किस प्रकार करता है

अभिव्यक्ति 0+s+0को स्ट्रिंग के लिए मजबूर किया split()जाता है जब कहा जाता है। उदाहरण के लिए, यदि इनपुट है "ENE", तो स्ट्रिंग को विभाजित किया जाएगा "0ENE0":

"NNW0N0NNE0NE0ENE0E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N"
             ^^^^^

यह निम्न सरणी की ओर जाता है:

[ "NNW0N0NNE0NE", "E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N" ]

फिर से, यह सरणी एक स्ट्रिंग के लिए coerced है जब exec()कहा जाता है। इसलिए, नियमित अभिव्यक्ति वास्तव में इस पर लागू होती है:

"NNW0N0NNE0NE,E0ESE0SE0SSE0S0SSW0SW0WSW0W0WNW0NW0NNW0N"

हम लगातार गैर-संख्यात्मक वर्णों की तलाश करते हैं ( \D+) एक अल्पविराम द्वारा पीछा करते हैं, इसके बाद लगातार गैर-संख्यात्मक वर्ण। यह सरणी देता है [ "NE,E" ]। हम यकीनन वहां रुक सकते थे और वापस लौट सकते थे। लेकिन चुनौती या तो एक सीमांकित स्ट्रिंग या दो-तत्व सरणी के लिए पूछ रही है। तो, हम साथ स्ट्रिंग निकालते हैं [0]

डेमो


0

पायथ , 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. .
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.