सापेक्ष बनाम निरपेक्ष

Question

यदि इस ग्रिड में बिंदु A पर उत्तर का सामना करना पड़ रहा है, तो हरे रंग के मार्ग का अनुसरण करने के लिए दिशा-निर्देश चाहते थे (जैसे कि वे केवल ग्रिडलाइन का अनुसरण कर सकते हैं) B को इंगित करने के लिए आप उन्हें बता सकते हैं:

जाओ North, North, West, East, East, South, East, East।

या समकक्ष

जाओ Forward, Forward, Left, Back, Forward, Right, Left, Forward।
(जहां राइट , लेफ्ट , या बैक के एक कमांड का मतलब है कि उस दिशा में मुड़ें, तो आगे बढ़ें।)

एक तर्क के साथ एक फ़ंक्शन लिखें जो इन पूर्ण और सापेक्ष दिशाओं के बीच एक ही पथ पर अनुवाद करता है , न कि केवल एक ही बिंदु पर। मान लें कि निर्देशित व्यक्ति हमेशा उत्तर की ओर मुंह करने लगता है।

यदि तर्क पत्रों की एक स्ट्रिंग है NSEW, तो समान सापेक्ष दिशाओं को वापस करें।
जैसे f("NNWEESEE")स्ट्रिंग लौटाता है FFLBFRLF।

यदि तर्क अक्षरों की एक स्ट्रिंग है FBLR, तो समतुल्य निरपेक्ष दिशाओं को वापस लौटाएँ।
जैसे f("FFLBFRLF")स्ट्रिंग लौटाता है NNWEESEE।

खाली स्ट्रिंग ही पैदावार देती है। अन्य इनपुट मामलों को न मानें।

यदि आपकी भाषा में फ़ंक्शंस या स्ट्रिंग्स नहीं हैं जो सबसे उपयुक्त लगता है।

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

Comments

क्या हम मान लेते हैं कि एक व्यक्ति हमेशा अपने सिर को उत्तर की ओर करके देखता है? इस तरह, पूर्व की ओर जाने के लिए सापेक्ष शब्दों में, उसे केवल टर्न-फॉरवर्ड कहने की बजाए राइट-टर्न लेने की आवश्यकता होगी

— अनुकूलक

@ ओप्टिमाइज़र हाँ, उत्तर। और अपने दूसरे बिंदु पर हाँ। शुरू में Rबराबर E।

— केल्विन के शौक

वाह! आपने हमेशा जो सोचा था उसकी पुष्टि के लिए आपने अपनी तस्वीर बदल दी!

— जस्टिन

क्या आप पीपीसीजी पर फिर से झुके हैं? ;)

— मार्टिन एंडर

@ MartinBüttner या तो मैं अपने होमवर्क समस्याओं को छिपाने में बहुत अच्छा हूं। ;)

— केल्विन के शौक

Answer 1

सीजाम, 57 53 49

{"NESW""FRBL"_3$&!!:Q$:R^^f#0\{{+0\}Q*_@-R=\}%);}

पुराना वर्जन

{"NESW""FRBL"_3$0=#W>:Q{\}*:R;f#0\{{+0\}Q*_@-R=\}%);}

उदाहरण:

{"NESW""FRBL"_3$0=#W>:Q{\}*:R;f#0\{{+0\}Q*_@-R=\}%);}:T;
"NNWEESEE"T
N
"FFLBFRLF"T

आउटपुट:

FFLBFRLF
NNWEESEE

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

{
  "NESW""FRBL"             " Push the two strings. ";
  _3$0=#W>                 " Check if the first character is in FRBL. ";
  :Q                       " Assign the result to Q. ";
  {\}*                     " Swap the two strings if true. ";
  :R;                      " Assign the top string to R and discard it. ";
  f#                       " Find each character of the input in the string. ";
  0\                       " Push a 0 under the top of the stack. ";
  {                        " For each item (index of character): ";
    {                      " If Q: ";
      +0\                  " A B -> 0 (A+B) ";
    }Q*
    _@-                    " C D -> D (D-C) ";
    R=                     " E -> E-th character in R ";
    \                      " Swap the top two items. ";
  }%
  );                       " Discard the last item in the list. ";
}

Answer 2

सी ++, 99 97

निम्नलिखित को लंबोदर अभिव्यक्ति के रूप में स्वरूपित किया गया है। यह एक char*तर्क लेता है और इसे अधिलेखित कर देता है।

[](char*s){for(int d=0,n=0,c=*s*9%37&4;*s;d+=n)c?n=*s%11/3-d:n+=*s%73%10,*s++="NESWFRBL"[c|n&3];}

जो लोग इस सुविधा से परिचित नहीं हैं (जैसे कि 1 घंटे पहले), इसका उपयोग इस प्रकार करें:

#include <iostream>

int main()
{
    char s[] = "NNWEESEE";
    auto x = [](char*s){for(int d=0,n=0,c=*s*9%37&4;*s;d+=n)c?n=*s%11/3-d:n+=*s%73%10,*s++="NESWFRBL"[c|n&3];};

    x(s); // transform from absolute to relative
    std::cout << s << '\n';

    x(s); // transform from relative to absolute
    std::cout << s << '\n';
}

कुछ स्पष्टीकरण:

• जैसे कोड का उपयोग करते समय flag ? (x = y) : (x += z), सी में कोष्ठक की दूसरी जोड़ी की आवश्यकता होती है, इसलिए मैंने इसके बजाय C ++ का उपयोग किया!
• C ++ को फ़ंक्शन के लिए रिटर्न प्रकार निर्दिष्ट करने की आवश्यकता होती है। जब तक मैं एक लंबोदर अभिव्यक्ति का उपयोग नहीं करता, वह है! एक अतिरिक्त बोनस है मुझे फ़ंक्शन के नाम पर 1 वर्ण को बर्बाद करने की आवश्यकता नहीं है।
• कोड *s*9%37&4पहले बाइट का परीक्षण करता है; परिणाम 4 है अगर यह एक है NESW; 0 अन्यथा
• कोड *s%11/3बाइट्स NESWको 0, 1, 2, 3 में कनवर्ट करता है
• कोड *s%73%10बाइट्स FRBLको 0, 9, 6, 3 (जो कि 0, 1, 2, 3 मॉडुलो 4 है) में कनवर्ट करता है
• जब सापेक्ष दिशाओं को निरपेक्ष रूप से परिवर्तित करना, मुझे dचर की आवश्यकता नहीं है । मैंने इसे पूरी तरह से समाप्त करने के लिए कोड को पुन: व्यवस्थित करने की कोशिश की, लेकिन यह असंभव लगता है ...

Comments

मुझे पसंद है कि आपके अक्षरों को संख्याओं में परिवर्तित करें। :)

— एमिल

Answer 3

जावास्क्रिप्ट (E6) 84 86 88 92 104

संपादित करें: का उपयोग कर और%, अलग ऑपरेटर पूर्वता (कम कोष्ठक) के बजाय और नकारात्मक संख्या के साथ बेहतर कार्य
EDIT2: | + के बजाय, op पूर्वता फिर से, -2। धन्यवाद DocMax
Edit3: सरणी समझ स्ट्रिंग्स के लिए मानचित्र () की तुलना में 2 चार्ट छोटा है

F=p=>[o+=c[d=n,n=c.search(i),n<4?4|n-d&3:n=n+d&3]for(i of n=o='',c='NESWFRBL',p)]&&o

FireFox / FireBug कंसोल में टेस्ट करें

console.log(F('NNWEESEE'),F('FFLBFRLF'))

उत्पादन

FFLBFRLF NNWEESEE

Comments

@ कोई और नहीं। और इससे भी ज्यादा सिकुड़ने की उम्मीद है।

— edc65

&& oअंत में क्या मतलब है?

— bebe

@bebe नक्शा फ़ंक्शन एक सरणी देता है, इसके अंदर, एक साइड इफेक्ट के रूप में, मैं ओ स्ट्रिंग को भरता हूं जो मुझे वापस करने की आवश्यकता है। किसी भी सरणी के रूप में array && valueइसका valueमूल्यांकनtruthy

— edc65

आखिरकार! मैं इसे एक बार से देख रहा हूँ जब से यह 88 हिट हुआ है। जब तक मैं कुछ याद नहीं कर रहा हूँ, आप इसे 2 वर्णों के 4+(n-d&3)साथ बदल सकते हैं 4|n-d&3और सहेज सकते हैं ।

— डॉकमैक्स

Answer 4

एपीएल, 72

{^/⍵∊A←'NESW':'FRBL'[1+4|-2-/4,3+A⍳⍵]⋄A[1+4|+\'RBLF'⍳⍵]}

दुभाषिया विन्यास दंड के बिना बदला जा सकता है, तो स्कोर है 66 , बदलकर ⎕IOकरने के लिए 0:

{^/⍵∊A←'NESW':'FRBL'[4|-2-/0,A⍳⍵]⋄A[4|+\'FRBL'⍳⍵]}

Answer 5

पायथन, 171 139

अन्य समाधानों जितना छोटा नहीं है, लेकिन मुझे लगता है कि यह अजगर के साथ किया जा सकता है के लिए अपेक्षाकृत अच्छा होना चाहिए:

def f(i):a,b='NWSE','FLBR';I=map(a.find,'N'+i);return''.join((b[I[k+1]-I[k]],a[sum(map(b.find,i)[:k+1])%4])[-1in I]for k in range(len(i)))

थोड़ा बेहतर पठनीयता के लिए विस्तारित संस्करण:

def f(i):
    a, b = 'NWSE', 'FLBR'
    I = map(a.find,'N'+i)     # translate to numbers assuming abs. directions
    J = map(b.index,i)        # translate to numbers assuming rel. directions
    if not -1 in I:
        o = [b[I[k+1]-I[k]] for k in range(len(i))]    # rel. dir. is differences of abs. dir.
    else:
        o = [a[sum(J[:k+1])%4] for k in range(len(i))] # abs. dir. is sum of all rel. dir. so far
    return ''.join(o)

Answer 6

जाओ, 201

type q string;func F(s q)q{d,z:=byte(0),make([]byte,len(s));for i,c:=range[]byte(s){if(c^4)*167%3<2{c=c*156%5;z[i],d="LBRF"[(d-c)%4],c-1;}else{c=(c^43)*3%7-1;d=(d+c)%4;z[i]="NESW"[d];};};return q(z);}

पठनीय संस्करण:

func F(s string) string {
    d, z, R, A := 0, make([]byte, len(s)), "LBRFLBR", "NESW"
    for i, c := range []byte(s) {
        switch c {
        case 'N': c = R[d+3]; d = 0
        case 'E': c = R[d+2]; d = 1
        case 'S': c = R[d+1]; d = 2
        case 'W': c = R[d]; d = 3
        case 'F': c = A[d]
        case 'R': d = (d + 1) % 4; c = A[d]
        case 'B': d = (d + 2) % 4; c = A[d]
        case 'L': d = (d + 3) % 4; c = A[d]
        }
        z[i] = c
    }
    return string(z)
}

Answer 7

GNU सेड, 356 बाइट्स

चुनौती पात्रों की एक धारा पर एक सरल परिवर्तन के लिए कहता है। sedधारा संपादक भाषा का स्पष्ट विकल्प है ;-)

/[FRBL]/bx                                     # Jump to label x if relative
:y                                             # label y (start of abs->rel loop)
/[FRBL]$/q                                     # quit if string ends in rel char
s/(^|[FRBL])N/\1F/;ty                          # Substitute next abs char with
s/(^|[FRBL])E/\1R/;tr                          #     rel char, then jump to
s/(^|[FRBL])S/\1B/;tb                          #     relevant rotation label if
s/(^|[FRBL])W/\1L/;tl                          #     a match was found
by                                             # loop back to y
:r;y/NESW/WNES/;by                             # Rotation labels: transform then
:b;y/NESW/SWNE/;by                             #     loop back to y
:l;y/NESW/ESWN/;by
:x                                             # label x (start of rel->abs loop)
/^[NESW]/q                                     # quit if string starts w/ abs char
/F([NESW]|$)/s/F([NESW]|$)/N\1/                # Matches for each direction:
/R([NESW]|$)/y/NESW/ESWN/;s/R([NESW]|$)/E\1/   #     rotate, then substitute
/B([NESW]|$)/y/NESW/SWNE/;s/B([NESW]|$)/S\1/
/L([NESW]|$)/y/NESW/WNES/;s/L([NESW]|$)/W\1/
bx                                             # loop back to x

(टिप्पणियाँ और रिक्त स्थान गोल्फ स्कोर गणना के प्रयोजनों के लिए छीन लिया गया)

आउटपुट:

$ sed -rf absrel.sed <<< NNWEESEE
FFLBFRLF
$ sed -rf absrel.sed <<< FFLBFRLF
NNWEESEE
$ 

स्पष्टीकरण:

यहां विचार यह है कि जब हम संदर्भ के फ्रेम को बदलते हैं, तो हमेशा {N, E, S, W}और के बीच एक सीधा मानचित्रण होता है {F, R, B, L}।

पूर्ण सापेक्ष के मामले में, हम स्ट्रिंग के माध्यम से फ़ॉवर्ड काम करते हैं। हमारे द्वारा मैप किए {N, E, S, W}गए प्रत्येक वर्ण के लिए {F, R, B, L}, उसके बाद शेष [NESW]पात्रों को घुमाएं, जिस चरित्र को हमने अभी मैप किया है, उसके बाद अगले चरित्र पर जाएँ।

सापेक्ष के मामले में हम उल्टा करते हैं। हम स्ट्रिंग के माध्यम से पीछे की ओर काम करते हैं, [NESW]सामने वाले पात्र के अनुसार सभी निम्नलिखित पात्रों को घुमाते हुए । तब हम उस चरित्र {N, E, S, W}को मैप करते हैं {F, R, B, L}, जब तक हम स्ट्रिंग की शुरुआत तक नहीं पहुंच जाते।

Answer 8

हास्केल, 224

import Data.Function
i=flip(\x->length.takeWhile(/=x))
r=['F','R','B','L']
a=['N','E','S','W']
f s@(x:_)|elem x a=map((r!!).(`mod`4).(4-))$zipWith((-)`on`(i a))('N':s)(s)|True=tail$map((a!!).(`mod`4)).scanl(+)(0)$map(i r) s

यह सापेक्ष दिशाओं के लिए रोटेशन संख्या और निरपेक्ष दिशाओं के लिए अभिविन्यास संख्या प्रदान करता है, फिर या तो लगातार झुकाव के बाद झुकाव या अभिविन्यास के बीच घुमाव का पता लगाता है। iसमारोह दो दिग्गजों के भीतर सूचकांक पाता है।