मैं अब कहां हूं?

एक स्ट्रिंग को देखते हुए d, केवल अक्षरों से युक्त NSWE, मेरे द्वारा यात्रा की गई निर्देशांक निर्धारित करें (बाएं से दाएं, लालची खपत करते हुए) और अंतिम समन्वय जहां मैं रहता हूं।

पढ़ने के लिए नियम बाएं से दाएं को निर्देशांक:

यदि अगला चरित्र है NयाS :
- यदि बाद चरित्र Nया Sएक और है NयाS :
  - केवल पहले का उपभोग करें Nया S।
  - आउटपुट [0,1] के लिएN
  - आउटपुट [0,-1]के लिएS
- यदि बाद चरित्र Nया Sहै WयाE :
  - उपभोग दोनों Nया Sऔर Wया E।
  - क्रमशः आउटपुट [1,1]और के [-1,1]लिए NEऔर NW।
  - क्रमशः आउटपुट [1,-1]और के [-1,-1]लिए SEऔर SW।
चरित्र एक है Eया Wएक से पहले नहीं SयाN :
- भस्म Eया W।
- आउटपुट [1,0]के लिए E।
- आउटपुट [-1,0]के लिए W।

काम किया उदाहरण

NSWE

[0,1]   (North      N)
[-1,-1] (South-west SW)
[1,0]   (East       E)
[0,0]   (N+SW+E = Didn't actually move)

ध्यान दें कि यह किसी भी प्रारूप में हो सकता है, यहाँ मान्य आउटपुट के अन्य उदाहरण हैं:

[[0,1],[-1,-1],[1,0],[0,0]]


[[[0,1],[-1,-1],[1,0]],[0,0]]


"0,1\n0,-1\n-1,0\n1,0\n0,0"

आदि...

और ज्यादा उदाहरण

SWSENNESWNE

[-1,-1]
[1,-1]
[0,1]
[1,1]
[-1,-1]
[1,1]
[1,0]

NNEESESSWWNW

[0,1]
[1,1]
[1,0]
[1,-1]
[0,-1]
[-1,-1]
[-1,0]
[-1,1]
[0,0]

NENENEE

[1,1]
[1,1]
[1,1]
[1,0]
[4,3]

NEN

[1,1]
[0,1]
[1,2]

EEE

[1,0]
[1,0]
[1,0]
[3,0]

नियम

आप किसी भी सुविधाजनक प्रारूप में आउटपुट कर सकते हैं जो खामियों का उल्लंघन नहीं करता है।
आपको लालच का सेवन करना चाहिए, NWEऐसा कभी नहीं होता N,W,E, यह हमेशा होता है NW,E।
- इस पर लागू होता है: SW*, SE*, NW*, NE*।
- आप बाएं से दाएं, लालच से उपभोग कर रहे हैं।
है कोड गोल्फ , सबसे कम बाइट गिनती जीत।

code-golf

— जादू ऑक्टोपस Urn
स्रोत

"मेरे द्वारा यात्रा की गई निर्देशांक निर्धारित करें" : मुझे यकीन नहीं है कि क्या यह वास्तव में मेल खाता है जो बाद में वर्णित है। यह अधिक पसंद है "मेरी सभी चालों के वैक्टर को निर्धारित करें" । केवल अंतिम आउटपुट वास्तविक निर्देशांक है।

— अरनौलद

1

एक परीक्षण मामला जो चलता है [4, 3]या तो यह देखना थोड़ा आसान है कि परीक्षण आउटपुट में क्या हो रहा है।

— लिन

3

जटिल संख्या के रूप में स्वरूपित हैं 1, -1j, (-1+1j)आदि एक वैध उत्पादन प्रारूप?

— लिन

2

इस मामले की अनुपस्थिति के आधार पर दोनों नियम और उदाहरण दिए गए हैं जो मुझे लगता है कि इनपुट-स्ट्रिंग एक 'एन' या 'एस' में कभी खत्म नहीं होगी?

— केविन क्रूज़सेन

1

क्या लालची का सेवन वास्तव में अलग नहीं है? चूँकि NEबस N+Eयह बात नहीं होनी चाहिए?

— गेहूं जादूगर

7

पायथन 2 , 116 बाइट्स

import re
a=[(int(s,35)%5-3,('N'in s)-('S'in s))for s in re.findall('[NS][EW]?|.',input())]
print a,map(sum,zip(*a))

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

आउटपुट के साथ `[(3+4j), 1, -1j, …]`, 91 बाइट्स

lambda x:[sum(1j**(ord(c)%8%5)for c in s)for s in[x]+re.findall('[NS][EW]?|.',x)]
import re

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

यह लंबा गॉसियन पूर्णांक की एक सूची देता है : पहला अंतिम समन्वय है, और अन्य सभी वहां पहुंचने के लिए आवश्यक कदम हैं।

— लिन
स्रोत

5

अटैची , 80 बाइट्स

V#Sum##{Chop[1-ToBase[22260446188,3],2][Sum@Ords=>MatchAll[_,/"[NS][WE]|."]%11]}

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

यह एक अनाम फ़ंक्शन है जो एक स्ट्रिंग तर्क लेता है।

व्याख्या

पहला काम इस सवाल के पार्सिंग चरण को लागू करना है। मैंने इनपुट को पार्स करने के लिए एक साधारण रेगेक्स का उपयोग करना सबसे कम पाया _: ( )

MatchAll[_,/"[NS][WE]|."]

यह रेगेक्स की सभी घटनाओं से मेल खाता है [NS][WE]|., जैसा कि कई अन्य उत्तरों में देखा गया है। यह लालची अनुरोधित दिशाओं में पैदावार देता है।

अब, हम प्रत्येक direciton को हैश फ़ंक्शन लागू करने जा रहे हैं। हम प्रत्येक दिशा के कोडपाइंट लेते हैं और उन्हें योग करते हैं। यह निम्नलिखित मानचित्रण देता है:

Direction       Ord-sum
E               69
N               78
S               83
W               87
NE              147
SE              152
NW              165
SW              170

हम इन मूल्यों को एक छोटे से डोमेन पर मैप करने की कोशिश करेंगे; modulo इसके लिए उपयोगी है, और हम प्रदर्शित कर सकते हैं कि सबसे छोटा modulo जिसके परिणामस्वरूप सभी दिए गए इनपुट के लिए अद्वितीय मान है। 11. अवशेषों के आधार पर छंटनी, यह हमें निम्न तालिका प्रदान करता है:

Direction       Ord-sum         % 11
NW              165             0
N               78              1
E               69              3
NE              147             4
SW              170             5
S               83              6
SE              152             9
W               87              10

अब, हमारे पास एक इनपुट पत्राचार है, जो एन्कोडिंग द्वारा है Sum@Ords=>[...]%11। अगला, हमें इन अवशेषों को बिंदुओं में बदलना होगा। हम एक और मानचित्रण प्राप्त करने की कोशिश करेंगे, जिसका अर्थ है "हैश-फिलिंग वैल्यूज" को हैश में डालना जो निर्देशों के अनुरूप नहीं हैं, उपयोगी होगा:

Direction       Hash        Coordinates
NW              0           [-1, 1]
N               1           [0, 1]
--             (2)          [0, 0]
E               3           [1, 0]
NE              4           [1, 1]
SW              5           [-1, -1]
S               6           [0, -1]
--             (7)          [0, 0]
--             (8)          [0, 0]
SE              9           [1, -1]
W               10          [-1, 0]

वर्तमान में हमारे पास अंकों की एक श्रृंखला है, जो हैश द्वारा सूची को अनुक्रमित कर सकता है:

[-1, 1] [0, 1] [0, 0] [1, 0] [1, 1] [-1, -1] [0, -1] [0, 0] [0, 0] [1, -1] [-1, 0]

अब, हम इसे संपीड़ित करेंगे, यह देखते हुए कि इसका केवल -1s, 0s और 1s से बना कैसे है । चूंकि सूची जोड़े का प्रतिनिधित्व करती है, इसलिए हम डेटा खोए बिना सूची को समतल कर सकते हैं। फिर, यदि हम प्रत्येक संख्या लेते हैं xऔर गणना करते हैं 1-x, तो हमें निम्नलिखित सूची मिलती है:

2 0 1 0 1 1 0 1 0 0 2 2 1 2 1 1 1 1 0 2 2 1

हम इसे आधार नंबर 3 में बदल सकते हैं:

2010110100221211110221₃

आधार 10 में परिवर्तित:

2010110100221211110221₃ ≡ 22260446188₁₀

संक्षेप में, हमने अपने अंक ले लिए हैं, उन्हें अन-युग्मित किया है, प्रत्येक तत्व को घटाया है 1, और 3हमें प्रदान करते हुए आधार से परिवर्तित किया है 22260446188। हम इस तरह से विघटित कर सकते हैं:

आधार 3 में बदलें: ToBase[22260446188,3]
प्रत्येक संख्या को एक (स्व-व्युत्क्रम) से घटाएं: 1-ToBase[22260446188,3]
सूची को पुन: पेयर करें: Chop[1-ToBase[22260446188,3],2]

यह हमें हमारे जोड़े का मूल सेट देता है। फिर, हम उपर्युक्त अनुक्रमण को इस तरह कर सकते हैं:

(chopped value)[hashes]

चूंकि, अटैची में, एक सरणी द्वारा अनुक्रमण उन सूचकांकों के अनुरूप सभी तत्वों को लौटाता है। (तो [1,2,3,4][ [0,0,-1,1] ] = [1,1,4,2]।) अब, हमारे पास उस मार्ग की दिशाएं हैं जो ओपी चला गया था। योग की गणना के लिए जो बचा है वह है।

इसलिए हम इस परिणाम को एक लंबोदर में कैप्चर करते हैं {...}और दूसरे फ़ंक्शन के साथ इसे फंक्शन कंपोजिशन ( a##b) में पहले फ़ंक्शन के रूप में डालते हैं V#Sum। यह एक कांटा है, जिसे इनपुट दिया जाता है, जो xविस्तारित होता है:

V[x, Sum[x]]

Sum, जब 2 डी सरणी दी जाती है, तो सरणी के प्रत्येक कॉलम को (सदिश योग के परिणामस्वरूप) जोड़ दिया जाता है। इसलिए, यह अंतिम गंतव्य के साथ दिशाओं को जोड़ता है, और हमारा अंतिम परिणाम है।

— कोनोर ओ ब्रायन
स्रोत

4

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

एक स्ट्रिंग लौटाता है।

s=>s.replace(/[NS][EW]|./g,s=>(D=d=>!!s.match(d),x+=h=D`E`-D`W`,y+=v=D`N`-D`S`,[h,v]+`
`),x=y=0)+[x,y]

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

— Arnauld
स्रोत

मुझे टेम्पलेट फ़ंक्शंस का उपयोग पसंद है! : डी

— कॉनर ओ'ब्रायन

@ ConorO'Brien हाँ, वे यहाँ बहुत काम कर रहे हैं। सभी हैशिंग टोनी मंत्र है कि मैं अब तक बुलाया है कम से कम थोड़ा लंबा कर रहे हैं।

— अरनौलद

4

MATL , 45 बाइट्स

'NS' 'WE'Z*Z{2MhX{h'eklihfmj'X{YX9\3_2&YAqts

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण (उदाहरण के साथ)

'NSWE'उदाहरण के रूप में इनपुट पर विचार करें ।

'NS' 'WE'  % Push these two strings
           % STACK: 'NS', 'WE'
Z*         % Cartesian product. Gives a 4×2 char matrix
           % STACK: ['NW'; 'NE'; 'SW'; 'SE']
Z{         % Cell array of rows (strings)
           % STACK: {'NW', 'NE', 'SW', 'SE'}
2M         % Push again the inputs of the second-last function call
           % STACK: {'NW', 'NE', 'SW', 'SE'}, 'NS', 'WE'
h          % Concatenate horizontally
           % STACK: {'NW', 'NE', 'SW', 'SE'}, 'NSWE'
X{         % Cell array of individual elements (chars)
           % STACK: {'NW', 'NE', 'SW', 'SE'}, {'N', 'S', 'W', 'E'}
h          % Concatenate horizontally
           % STACK: {'NW', 'NE', 'SW', 'SE', 'N', 'S', 'W', 'E'}
'eklihfmj' % Push this string
           % STACK: {'NW', 'NE', 'SW', 'SE', 'N', 'S', 'W', 'E'}, 'eklihfmj'
X{         % Cell array of individual elements (chars)
           % STACK: {'NW','NE','SW','SE','N','S','W','E'},{'e','k','l','i','h','f','m','j'}
YX         % Implicit input. Regexp replace: replaces 'NW' by 'e', then 'NE' by 'k', etc.
           % Note that the two-letter combinations are replaced first, which implements
           % the greediness; and the target letters do not appear in the source, which
           % avoids unwanted interactions between replacements
           % STACK: 'hlj'
9\         % Modulo 9 (of codepoints), element-wise
           % STACK: [5, 0, 7]
3_2&YA     % Convert to base 3 with 2 digits. Gives a 2-column matrix
           % STACK: [1, 2; 0, 0; 2, 1]
q          % Subtract 1, element-wise
           % STACK: [0, -1; -1, -1; 1, 0]
tXs        % Duplicate. Sum of each column
           % STACK: [0, -1; -1, -1; 1, 0], [0, 0]
           % Implicit display

— लुइस मेंडो
स्रोत

4

जावा (JDK 10) , 171 बाइट्स

s->{var r="";int i=0,l=s.length,c,x=0,y=0,Y,X;for(;i<l;X=c>1||i<l&&(c=~-s[i]/6%4)>1&&++i>0?c*2-5:0,r+=X+","+Y+" ",x+=X,y+=Y)Y=(c=~-s[i++]/6%4)<2?1-c*2:0;return r+x+","+y;}

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

स्पष्टीकरण

c=~-s[i]/6%4निम्न मानचित्रण के लिए धन्यवाद :

'N' -> ascii: 78 -> -1 = 77 -> /6 = 12 -> %4 = 0
'S' -> ascii: 83 -> -1 = 83 -> /6 = 13 -> %4 = 1
'W' -> ascii: 87 -> -1 = 86 -> /6 = 14 -> %4 = 2
'E' -> ascii: 69 -> -1 = 68 -> /6 = 11 -> %4 = 3

NSके साथ जाँच की c<2और +1/ -1का उपयोग करने के लिए मैप किया गया 1-c*2;
EWके साथ जाँच की c>1और मैप +1/ -1का उपयोग कर रहा है c*2-5।

क्रेडिट

केविन क्रूज़सेन की बदौलत बहुत कम से कम 9 बाइट बच गए ।

— ओलिवियर ग्रेजायर
स्रोत

जब आप मेरा विवरण टाइप कर रहे थे, तब आपने अपना जावा उत्तर पोस्ट किया था। :) चूंकि हम दोनों एक पूरी तरह से अलग दृष्टिकोण का उपयोग करते हैं, मैं अब के लिए मेरा छोड़ दूंगा। लैम्ब्डा में उपयोग किए जाने वाले बहुत खराब चर को प्रभावी रूप से अंतिम रूप देने की आवश्यकता होती है, अन्यथा आप बाइट्स को बचाने के लिए सूची के बजाय एक स्ट्रिंग वापस कर सकते थे।

— केविन क्रूज़सेन

धन्यवाद, यह केवल कुछ बाइट्स (4) को बचाता है, लेकिन यह कुछ भी नहीं से बेहतर है;)

— ओलिवियर ग्रेजायर

@KevinCruijssen धन्यवाद, यह पहली बार में स्पष्ट लग रहा था, लेकिन मैं एक और दृष्टिकोण पर काम कर रहा था, जिसने मेरी बाइट-गिनती को 30 से अधिक घटा दिया। एक "पार्सिंग", एक "मिलान" एक नहीं।

— ओलिवियर ग्रेजायर

1

Sigh .. 172 बाइट्स

— केविन क्रूज़सेन

1

@KevinCruijssen क्षमा करें, यह आपके परिवर्तनों को एकीकृत करने वाली एक गड़बड़ है ... मुझे काम पर लिया गया है और मैं इस पृष्ठ को रीफ़्रेश करना भूल जाता हूं ... वैसे भी सभी के लिए धन्यवाद ^ ^ 'क्रेडिट गणना आपके वास्तविक क्रेडिट से बहुत कम है। इसके लिए भी खेद है: s

— ओलिवियर ग्रेजायर

3

रेटिना 0.8.2 , 93 बाइट्स

.+
$&¶$&
\G[NS]?[EW]?
$&¶
G`.
W
J
%O`.
+`EJ|NS

m`^((J)?[EJ]*)((S)?[NS]*)
$#2$*-$.1,$#4$*-$.3

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

.+
$&¶$&

इनपुट डुप्लिकेट करें।

\G[NS]?[EW]?
$&¶

पहली प्रति को दिशाओं में विभाजित करें।

G`.

उपरोक्त प्रक्रिया द्वारा बनाई गई बाहरी खाली लाइनों को हटा दें।

W
J

बदलें Wमें Jइतना है कि यह बीच सॉर्ट करता Eऔर N। ( Eके बीच में जाना Sऔर Wभी काम करेगा।)

%O`.

प्रत्येक पंक्ति को क्रम में क्रमबद्ध करें।

+`EJ|NS

विपरीत दिशाओं के जोड़े हटाएं (यह केवल पाठ्यक्रम की अंतिम पंक्ति को प्रभावित करता है)।

m`^((J)?[EJ]*)((S)?[NS]*)
$#2$*-$.1,$#4$*-$.3

जहाँ आवश्यक हो, संकेतों को जोड़ते हुए, क्षैतिज और ऊर्ध्वाधर आंदोलनों की संख्या की गणना करें।

आप में से जो रेटिना 0.8.2 और रेटिना 1 के बीच के अंतर को जानते हैं, वे यह बताना चाहेंगे कि मैं रेटिना 1 में 2 बाइट्स बचा सकता हूं क्योंकि यह *इसके बजाय उपयोग करता है $*। जब मैं वहां था, मैंने बंटवारे की प्रक्रिया को आसान बनाने की कोशिश की, लेकिन मैं बाइट की गिनती को कम करने में असमर्थ था, मैं केवल इसके साथ बराबर करने में सक्षम था:

L$`$(?<=(.*))|[NS]?[EW]?
$&$1

— नील
स्रोत

3

जावा 10, 269 265 243 बाइट्स

s->{var r="";int x=0,y=0,t,X,Y,a;for(;!s.isEmpty();r+=X+"|"+Y+" ",s=s.substring(++t),x+=X,y+=Y){a=s.charAt(t=0);if(s.matches("[SN][WE].*")){X=s.charAt(1)<70?1:-1;Y=1-a%2*2;t++;}else{X=a<70?1:a>86?-1:0;Y=a>69&a<87?1-a%2*2:0;}}return r+x+"|"+y;}

निश्चित रूप से इस चुनौती के लिए सही भाषा नहीं है ।।

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

स्पष्टीकरण:

s->{                  // Method with String as both parameter and return-type
  var r="";           //  Result-String, starting empty
  int x=0,            //  Ending `x`-coordinate, starting at 0
      y=0,            //  Ending `y`-coordinate, starting at 0
      t,X,Y,a;        //  Temp-integers
  for(;!s.isEmpty()   //  Loop as long as the input-String is not empty yet
      ;               //    After every iteration:
       r+=X+"|"+Y+" ",//     Append the current steps to the result-String
       s=s.substring(t),
                      //     Remove the first `t` characters from the input-String
       x+=X,y+=Y){   //      Append the ending `x`,`y` coordinates with the steps
    a=s.charAt(0);   //    Set `a` to the first character of the input-String to save bytes
    t=1;             //    Set `t` to 1
    if(s.matches("[SN][WE].*")){
                     //   Else-if the input-String starts with N/S followed by E/W:
      X=s.charAt(1)<70?1:-1;
                     //    Set `X` to 1 if 'E', -1 if 'W'
      Y=1-a%2*2;     //    Set `Y` to 1 if 'N', -1 if 'S'
      t++;}          //    Increase `t` by 1
    else{            //   Else:
      X=a<70?1:a>86?-1:0;
                     //    Set `X` to 1 if 'E', -1 if 'W', 0 if 'N' or 'S'
      Y=a>69&a<87?1-a%2*2:0;}}
                     //    Set `Y` 1 if 'N', -1 if 'S', 0 if 'E' or 'W'
  return r+x+"|"+y;} //  Append the ending coordinates, and return the result-String

— केविन क्रूज़सेन
स्रोत

1

जावा के उत्तर में अंक मिलते हैं, हालांकि सभी को उनका कारण बनता है :)।

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn सच है। :) और मैं अभी भी जावा में गोल्फ का आनंद लेता हूं, भले ही आप कभी भी कम से कम नहीं होंगे .. जब तक कि आप उत्तर देने के लिए केवल एक ही हो (दो स्वीकार किए गए जावा उत्तर .. XD)। हालांकि इस चुनौती के लिए, ओलिवियरग्रेयर द्वारा जावा जवाब लगभग 70 बाइट्स छोटा है, इसलिए अधिकांश अपवोट्स को उसके पास जाना चाहिए।

— केविन क्रूज़सेन

2

पर्ल 5 `-n` , 94 बाइट्स

$x=$y=0;%X=qw/E ++ W --/;%Y=qw/N ++ S --/;s%(N|S)?(E|W)?%"say $X{$2}\$x.','.$Y{$1}\$y"if$&%gee

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

— Xcali
स्रोत

2

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

f=
s=>s.replace(/((N)|(S))?((E)|(W))?/g,(m,v,n,s,h,e,w)=>(x+=h=!w-!e,y+=v=!s-!n,m?[h,v]+`
`:[x,y]),x=y=0)

<input oninput=o.textContent=/[^NSEW]/.test(this.value)?``:f(this.value)><pre id=o>0,0

स्निपेट का विस्तार करें

एक स्ट्रिंग लौटाता है।

— नील
स्रोत

1

रूबी , 75 71 बाइट्स

->x{[*x.scan(/[NS][EW]?|./),x].map{|s|s.chars.sum{|c|1i**(c.ord%8%5)}}}

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

-4 बाइट्स benj2240 के लिए धन्यवाद।

चूँकि कॉम्प्लेक्स नंबरों की वापसी एक स्वीकार्य आउटपुट स्वरूप है, इसलिए मुझे लगता है कि यह बहुत अच्छा लिन के उत्तर का एक बंदरगाह बनाने की तुलना में बहुत अधिक गोल्फर नहीं मिलेगा ।

— किरिल एल।
स्रोत

बहुत अच्छा। आप कुछ बाइट्स को इनर स्किप करके map, इसके ब्लॉक को सीधे पास करके बचा सकते हैं sum: इसे ऑनलाइन आज़माएं!

— बेंजीन 40

1

एफ # (मोनो) , 269 बाइट्स

let f s=
 let l,h=(string s).Replace("NW","A").Replace("NE","B").Replace("SW","C").Replace("SE","D")|>Seq.map(function 'N'->0,1|'S'->0,-1|'W'-> -1,0|'E'->1,0|'A'-> -1,1|'B'->1,1|'C'-> -1,-1|'D'->1,-1)|>Seq.mapFold(fun(x,y) (s,t)->(s,t),(x+s,y+t))(0,0)
 Seq.append l [h]

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

— हेनरिक हैनसेन
स्रोत

नमस्ते, PPCG में आपका स्वागत है। दुर्भाग्य से आप अपने आउटपुट के अंतिम आइटम को याद नहीं कर रहे हैं, जो कि वह स्थान होना चाहिए जहां आपने समाप्त किया था। तो के लिए NSWEआप वर्तमान में outputting रहे हैं (0,1), (-1,-1), (1,0), लेकिन एक चौथाई उत्पादन यही निर्देशांक का योग है, तो होना चाहिए (0,0)(क्योंकि 0+-1+1 = 0और 1+-1+0 = 0)।

— केविन क्रूज़सेन

@ केविनक्रूजसेन ओके, मैंने ऐसा नहीं किया। अपडेट किया गया।

— हेनरिक हैनसेन

1

अब महान काम करने लगता है, इसलिए मुझ से +1। यहां रहने का आनंद! :) और अगर आपने इसे अभी तक नहीं देखा है, तो एफ # में गोल्फिंग के लिए टिप्स और गोल्फिंग के लिए टिप्स <सभी भाषाओं> के माध्यम से पढ़ने के लिए दिलचस्प हो सकता है।

— केविन क्रूज़सेन

1

सेड, १२५

उत्पादन प्रारूप के साथ स्वतंत्रता लेने संस्करण:

-rपैरामीटर में sed के लिए स्कोर में +1 शामिल है ।

s/(N|S)(E|W)/\L\2,\1 /g
s/N|S/,& /g
s/E|W/&, /g
s/N|E/A/gi
s/S|W/a/gi
p
:
s/(\S*),(\S*) (\S*),(\S*)/\1\3,\2\4/
t
s/Aa|aA//
t

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

आउटपुट इस प्रकार है:

निर्देशांक तत्व अल्पविराम से अलग होते हैं
निर्देशांक के प्रत्येक सेट को TAB- अलग किया जाता है
अंतिम समन्वय एक नई लाइन पर है
सभी नंबर numbers-unary में हैं:
- Aवर्णों की एक स्ट्रिंग + पूर्णांक का प्रतिनिधित्व करती हैlen(string)
- aवर्णों की एक स्ट्रिंग -ve पूर्णांक का प्रतिनिधित्व करती है-len(string)
- खाली स्ट्रिंग का प्रतिनिधित्व करता है 0

उदाहरण के लिए:

, [0,0] है
,AA [0,2] है
aaa, [-3,0] है

GNU निष्पादन विस्तार सहित sed 4.2.2 , 147

समझदार उत्पादन प्रारूप संस्करण:

-rपैरामीटर में sed के लिए स्कोर में +1 शामिल है ।

s/(N|S)(E|W)/\L\2 \1\n/g
s/N|S/0 &\n/g
s/E|W/& 0\n/g
s/N|E/1/gi
s/S|W/-1/gi
p
:
s/(\S+) (\S+)\n(\S+) (\S+)/\1+\3 \2+\4/
t
s/\S+/$[&]/g
s/^/echo /e

आउटपुट को अंतरिक्ष-पृथक निर्देशांक, प्रति पंक्ति एक के रूप में दिया जाता है। निर्देशांक के पारमार्थिक और अंतिम सेट के बीच एक अतिरिक्त न्यूलाइन है - सुनिश्चित नहीं है कि यह समस्याग्रस्त है या नहीं।

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

— डिजिटल आघात
स्रोत

0

PHP, 153 बाइट्स

रेगेक्स को विभाजित करने दें; मैचों के माध्यम से लूप, मध्यवर्ती परिणाम प्रिंट और योग करें:

preg_match_all("/[NS][EW]?|E|W/",$argn,$m);foreach($m[0]as$s){$x+=$p=strtr($s[-1],NEWS,1201)-1;$y+=$q=strtr($s[0],NEWS,2110)-1;echo"$p,$q
";}echo"$x,$y";

ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया इसे आज़माएं ।

— टाइटस
स्रोत

0

सी (जीसीसी) , 173 बाइट्स

यह दिलचस्प है कि कोई भी भाषा में रेगेक्स समर्थन के साथ ऐसा कर रहा है!

f(char*s){char*t="[%d,%d]\n";int x[4]={0},i;for(;*s;*x=x[1]=!printf(t,x[1],*x))for(i=-1;i<5;)if(*s=="S NW E"[++i]){x[i/3+2]+=x[i/3]=i%3-1;i+=2-i%3;s++;}printf(t,x[3],x[2]);}

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

— ErikF
स्रोत

164 बाइट्स

— छत

मैं अब कहां हूं?

मैं अब कहां हूं?

काम किया उदाहरण

और ज्यादा उदाहरण

नियम

पायथन 2 , 116 बाइट्स

आउटपुट के साथ [(3+4j), 1, -1j, …], 91 बाइट्स

अटैची , 80 बाइट्स

व्याख्या

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

MATL , 45 बाइट्स

स्पष्टीकरण (उदाहरण के साथ)

जावा (JDK 10) , 171 बाइट्स

स्पष्टीकरण

क्रेडिट

रेटिना 0.8.2 , 93 बाइट्स

जावा 10, 269 265 243 बाइट्स

पर्ल 5 -n , 94 बाइट्स

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

रूबी , 75 71 बाइट्स

एफ # (मोनो) , 269 बाइट्स

सेड, १२५

GNU निष्पादन विस्तार सहित sed 4.2.2 , 147

PHP, 153 बाइट्स

सी (जीसीसी) , 173 बाइट्स

आउटपुट के साथ `[(3+4j), 1, -1j, …]`, 91 बाइट्स

पर्ल 5 `-n` , 94 बाइट्स