मदद, मैं एक Sierpinski त्रिकोण में फंस गया हूँ!

Sierpinski त्रिकोण को आकर्षित करने के लिए मौत के लिए किया गया है । हालांकि अन्य दिलचस्प चीजें हैं जो हम इसके साथ कर सकते हैं। यदि हम त्रिभुज पर काफी कठोर हैं, तो हम उल्टे त्रिकोणों को भग्न ग्राफ के नोड्स के रूप में देख सकते हैं। चलो उस ग्राफ के चारों ओर अपना रास्ता खोजें!

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

^{बड़े संस्करण के लिए क्लिक करें जहां छोटी संख्या थोड़ी कम धुंधली है।}

(बेशक, इस पद्धति नीला त्रिकोण के अंदर अनंत तक जारी है।) नंबरिंग परिभाषित करने के लिए एक और तरीका है केंद्र नोड सूचकांक है कि 0, और नोड के बच्चों i(अगली छोटे पैमाने के आसन्न त्रिकोण) सूचकांक होते हैं 3i+1, 3i+2और 3i+3।

हम इस ग्राफ में कैसे घूमेंगे? छह प्राकृतिक कदम हैं जो किसी भी त्रिकोण से ले सकते हैं:

एक हमेशा वर्तमान नोड के तीन बच्चों में से एक के किनारों के मध्य बिंदु के माध्यम से आगे बढ़ सकता है। हम इन चालों को निर्दिष्ट करेंगे N, SWऔर SE। उदाहरण के लिए अगर हम नोड पर वर्तमान में कर रहे हैं 2, इन नोड्स तक ले जाएगा 7, 8, 9, क्रमशः। किनारों के माध्यम से अन्य चालें (अप्रत्यक्ष वंशजों के लिए) अस्वीकृत हैं।
कोई भी तीन कोनों में से एक के माध्यम से आगे बढ़ सकता है, बशर्ते कि वह सीधे माता-पिता या दो अप्रत्यक्ष पूर्वजों में से एक, त्रिकोण के किनारे को न छुए। हम इन चालों को निर्दिष्ट करेंगे S, NEऔर NW। उदाहरण के लिए अगर हम नोड पर वर्तमान में कर रहे हैं 31, Sनेतृत्व करने के लिए होता है 10, NEअमान्य हो सकता है और NWकरने के लिए नेतृत्व करेंगे 0।

चुनौती

दो गैर नकारात्मक पूर्णांक को देखते हुए xऔर y, से कम से कम पथ को खोजने xके लिए yकेवल छह चाल ऊपर वर्णित का उपयोग कर,। यदि कई छोटे रास्ते हैं, तो उनमें से किसी एक को आउटपुट करें।

ध्यान दें कि आपका कोड उपरोक्त आरेख में दर्शाए गए केवल 5 स्तरों से अधिक के लिए काम करना चाहिए। आप ऐसा मान सकते हैं x, y < 1743392200। यह सुनिश्चित करता है कि वे 32-बिट हस्ताक्षरित पूर्णांक के अंदर फिट हों। ध्यान दें कि यह पेड़ के 20 स्तरों से मेल खाती है।

आपके कोड को 5 सेकंड से कम समय में किसी भी मान्य इनपुट को संसाधित करना होगा । हालांकि यह एक क्रूर बल चौड़ाई-प्रथम खोज का नियम है, यह एक काफी ढीली बाधा होनी चाहिए - मेरा संदर्भ कार्यान्वयन गहराई 1000 के लिए मनमाने ढंग से इनपुट को सेकंड में संभालता है (यह नोड्स के लिए ~ 480-अंकीय संख्या है)।

आप STDIN (या निकटतम विकल्प), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट लेने और STDOUT (या निकटतम वैकल्पिक), फ़ंक्शन रिटर्न मान या फ़ंक्शन (आउट) पैरामीटर के माध्यम से परिणाम आउटपुट कर सकते हैं, एक प्रोग्राम या फ़ंक्शन लिख सकते हैं।

उत्पादन एक फ्लैट, तार की स्पष्ट सूची होना चाहिए N, S, NE, NW, SE, SW, (रिक्त स्थान, linefeeds, अल्पविराम, किसी भी उचित विभाजक का उपयोग कर ","...)।

मानक कोड-गोल्फ नियम लागू होते हैं।

परीक्षण के मामलों

पहले कुछ परीक्षण मामलों को ऊपर दिए गए आरेख का उपयोग करके हाथ से किया जा सकता है। दूसरे सुनिश्चित करते हैं कि उत्तर पर्याप्त रूप से कुशल हों। उन लोगों के लिए, समान लंबाई के अन्य समाधान हो सकते हैं जो सूचीबद्ध नहीं हैं।

0 40                    => N N N N
66 67                   => S SW N N N
30 2                    => NW NW -or- NE SW
93 2                    => NE SW
120 61                  => NW NW NW NW N SE SW N
1493682877 0            => S S NW NW
0 368460408             => SW SW N N SW SW SE SW SW N SE N N SW SW N SE SE
1371432130 1242824      => NW NW NE NW N SE SW SW SW SE SE SW N N N N SW
520174 1675046339       => NE NW NE NE SE SE SW SW N SE N SW N SW SE N N N N SE SE SW SW
312602548 940907702     => NE NW S SW N N SW SE SE SE SW SE N N SW SE SE SE SW
1238153746 1371016873   => NE NE NE SE N N SW N N SW N SE SE SW N SW N N SE N SE N
547211529 1386725128    => S S S NE NW N N SE N SW N SE SW SE SW N SE SE N SE SW SW N
1162261466 1743392199   => NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE

— मार्टिन एंडर
स्रोत

जवाबों:

रूबी, 195 194 190 184 बाइट्स

मूल: ऐल के लिए क्षमायाचना के साथ , क्योंकि यह अनिवार्य रूप से उनके उत्तर का एक बंदरगाह है और इस उत्तर को डीबग करने में उनकी मदद के लिए Doorknob के लिए बहुत धन्यवाद के साथ । इस समस्या के लिए शायद एक और एल्गोरिथ्म है - कुछ करने के लिए *f[x[0,**however far x matches with y**],y]- लेकिन मैं इसे एक और समय के लिए बचाऊंगा।

a=->n{n<1?[]:a[~-n/3]+[-n%3]}
f=->x,y{j=x.size
(Array===x)?x==y[0,j]?y[j..-1].map{|m|%w[SE SW N][m]}:x.uniq.map{|m|[%w[NW NE S][m],*f[x[0,x.rindex(m)],y]]}.min_by(&:size):f[a[x],a[y]]}

संपादित करें: लालची एल्गोरिथ्म के लिए काम नहीं करता है h[299792458, 1000000]। मैंने बाइट की गिनती 195 में वापस कर दी है, जबकि मैं अपने एल्गोरिथ्म को एक बार फिर से मरम्मत करता हूं। यह केवल बाइट गिनती के लिए फिक्स्ड 203 करने के लिए वृद्धि करने के लिए साई

निर्माणाधीन: यह कार्यक्रम आम पूर्वजों को खोजने के लिए एक लालची एल्गोरिथ्म का उपयोग करता है x[0,j]==y[0,j](ध्यान दें: कई सामान्य पूर्वजों हो सकते हैं)। एल्गोरिथ्म एल के पुनरावर्ती पूर्वज खोज पर बहुत शिथिल आधारित है । परिणामी निर्देशों का पहला आधा हिस्सा इस सामान्य पूर्वज को कैसे प्राप्त किया जा सकता है, और दूसरा आधा भाग y के आधार पर मिल रहा है y[j..-1]।

नोट: a[n]यहां अंकों के उपयोग से आधार -3 बायजेक्टिव अंक दिया 2,1,0जाता है 1,2,3।

एक उदाहरण के रूप में, चलो f[59,17]या के माध्यम से चलाते हैं f[[2,0,2,1],[2,1,1]]। इधर, j == 1। करने के लिए x[0,j], हम जाते हैं 0या NW। फिर, पाने के लिए y, जाने के लिए [1,1]याSW SW

a=->n{n<1?[]:a[~-n/3]+[-n%3]}
h=->m,n{x=a[m];y=a[n];c=[];j=x.size
(j=x.uniq.map{|m|k=x.rindex(m);x[0..k]==y[0..k]?j:k}.min
c<<%w[NW NE S][x[j]];x=x[0,j])until x==y[0,j]
c+y[j..-1].map{|m|%w[SE SW N][m]}}

— Sherlock9
स्रोत

अजगर 2, 208 205 200 बाइट्स

A=lambda n:n and A(~-n/3)+[-n%3]or[]
f=lambda x,y:f(A(x),A(y))if x<[]else["SSNEW"[m::3]for m in
y[len(x):]]if x==y[:len(x)]else min([["NNSWE"[m::3]]+f(x[:~x[::-1].index(m)],y)for
m in set(x)],key=len)

एक फ़ंक्शन, fनोड संख्याओं की एक जोड़ी ले रहा है, और तार की सूची के रूप में सबसे छोटा रास्ता वापस कर रहा है।

व्याख्या

हम त्रिकोण के लिए एक अलग पते की योजना को लागू करके शुरू करते हैं; प्रत्येक त्रिकोण का पता एक स्ट्रिंग है, जिसे निम्नानुसार परिभाषित किया गया है:

केंद्रीय त्रिकोण का पता खाली स्ट्रिंग है।
उत्तर, दक्षिण पश्चिम, और प्रत्येक त्रिकोण के दक्षिण-पूर्व बच्चों के पते जोड़कर गठन कर रहे हैं 0, 1और 2त्रिकोण का पता करने के लिए क्रमश:।

अनिवार्य रूप से, प्रत्येक त्रिभुज का पता केंद्रीय त्रिभुज से छोटा (सबसे छोटा) पथ होता है। पहली बात यह है कि हमारा कार्यक्रम इनपुट त्रिभुज संख्याओं को संबंधित पतों पर अनुवादित कर रहा है।

^{एक बड़े संस्करण के लिए छवि पर क्लिक करें।}

प्रत्येक त्रिभुज की संभावित चालें पते से आसानी से निर्धारित होती हैं:

उत्तर, दक्षिण पश्चिम, और दक्षिण-पूर्व बच्चों को ले जाने के लिए हम बस संलग्न, 0, 1, और 2, क्रमश: पता करने के लिए।
दक्षिण में जाने के लिए, उत्तर-पूर्व में और उत्तर पश्चिम पूर्वजों, हम के अंतिम (दायीं) घटना को खोजने 0, 1और 2इसके बारे में छोड़ दिया करने के लिए, क्रमशः, और ट्रिम पता। यदि कोई पता नहीं है 0, 1या 2पते में है, तो संबंधित पूर्वज मौजूद नहीं है। उदाहरण के लिए, के उत्तर पश्चिम पूर्वज को स्थानांतरित करने के लिए 112(यानी, इसके जनक), हम में से अंतिम बार होने लगता है 2में 112, जो पिछले चरित्र है, और ट्रिम इसके बारे में छोड़ दिया है, हमें देने के लिए पता 11; पूर्वोत्तर पूर्वज को स्थानांतरित करने के लिए, हम में से अंतिम बार होने लगता है 1में 112है, जो दूसरे चरित्र है, और यह के छोड़ दिया है, हमें देने के लिए पता ट्रिम 1; हालाँकि, 112कोई दक्षिण पूर्वज नहीं है, क्योंकि वहाँ कोई नहीं है0 इसके पते में।

पतों की एक जोड़ी के बारे में कुछ बातें नोट करें, xऔर y:

अगर xकी एक आरंभिक सबस्ट्रिंग है y, तो yका वंशज है x, और इसलिए से कम से कम पथ xके लिए yबस के बीच प्रत्येक त्रिकोण के इसी बालक इस प्रकार है xऔर y; दूसरे शब्दों में, हम एक जगह ले सकता है 0, 1और 2में y[len(x):]साथ N, SW, और SEक्रमशः,।
अन्यथा, के iबीच xऔर पहले बेमेल का सूचकांक हो y। वहाँ से कोई रास्ता नहीं xहै yकि x[:i](जो के रूप में एक ही है y[:i]) से गुजरता नहीं है , यानी, के पहले आम पूर्वज xऔर y। इसलिए, से किसी भी पथ xके लिए yपहुँच जाना चाहिए x[:i]अपने पूर्वजों में से एक, या, चलो इस त्रिकोण कॉल z, और उसके बाद करने के लिए जारी y। से आने के xलिए z, हम पूर्वजों का अनुसरण करते हैं जैसा कि ऊपर वर्णित है। से कम से कम पथ zको yपिछले बुलेट बात द्वारा दिया जाता है।

अगर xकी एक प्रारंभिक-स्ट्रिंग है y, तो कम से कम से पथ xको yआसानी से ऊपर पहली बुलेट बिंदु द्वारा दिया जाता है। अन्यथा, हम आपको यह बताने jके अंतिम घटनाओं के सूचकांकों में सबसे छोटी हो 0, 1और 2में x। अगर jसे अधिक है, या इसके बराबर के बीच पहली बेमेल के सूचकांक xऔर y, i, हम बस इसी चाल (जोड़ने S, NEया NWपथ के लिए, क्रमशः), ट्रिम xकी बाईं करने के लिए j, और जारी रखें। अगर jइससे कम हो तो चीजें मुश्किल हो जाती हैं i, क्योंकि हम yआम पूर्वज से x[:j]सीधे उतरकर सबसे तेजी से उतर सकते हैं और सभी तरह से उतर सकते हैंy, या हम के एक अलग आम पूर्वज के लिए प्राप्त करने में सक्षम हो सकता है xऔर yयह कि के दाईं ओर के yएक अलग पूर्वज के आरोही द्वारा करीब है , और वहाँ से तेजी से मिलता है । उदाहरण के लिए, से प्राप्त करने के लिए , सबसे छोटा रास्ता पहले केंद्रीय त्रिकोण (जिसका पता खाली स्ट्रिंग है) पर चढ़ना है, और फिर उतरना है , यानी, पहला कदम हमें बेमेल बिंदु के बाईं ओर ले जाता है। हालाँकि, से प्राप्त करने के लिए , सबसे छोटा रास्ता चढ़ना है , और फिर , यानी, पहली चाल हमें बेमेल बिंदु के दाईं ओर रखती है।xiy12221112221212212

तो, हम सबसे छोटा रास्ता कैसे खोजें? "आधिकारिक" कार्यक्रम एक जानवर-बल-ईश दृष्टिकोण का उपयोग करता है, जब भी xप्रारंभिक प्रतिस्थापन नहीं होता है, तो किसी भी पूर्वजों के लिए हर संभव कदम उठाने की कोशिश करता है y। यह उतना बुरा नहीं है जितना लगता है! यह एक या दो सेकंड के भीतर, सभी परीक्षण मामलों को हल करता है।

लेकिन फिर, हम फिर से बेहतर कर सकते हैं: यदि बेमेल बिंदु के बाईं ओर एक से अधिक सीधे पहुंच वाले पूर्वज हैं, तो हमें केवल सबसे सही एक का परीक्षण करने की आवश्यकता है, और अगर एक से अधिक सीधे पहुंच वाले पूर्वज हैं बेमेल के बिंदु के दाईं ओर, हमें केवल सबसे बाईं ओर का परीक्षण करना होगा। यह एक रेखीय समय एल्गोरिथ्म की पैदावार करता है, x(यानी स्रोत त्रिकोण की गहराई, या स्रोत त्रिकोण संख्या के लघुगणक के लिए आनुपातिक) की लंबाई , जो बहुत बड़े परीक्षण मामलों के माध्यम से ज़ूम करता है। निम्न कार्यक्रम इस एल्गोरिथ्म को लागू करता है, कम से कम संक्षेप में - गोल्फिंग के कारण, इसकी जटिलता वास्तव में, रैखिक से भी बदतर है, लेकिन यह अभी भी बहुत तेज है।

अजगर 2, ~~271~~ ~~266~~ 261 बाइट्स

def f(x,y):
 exec"g=f;f=[]\nwhile y:f=[-y%3]+f;y=~-y/3\ny=x;"*2;G=["SSNEW"[n::3]for
n in g];P=G+f;p=[];s=0
 while f[s:]:
    i=len(f)+~max(map(f[::-1].index,f[s:]));m=["NNSWE"[f[i]::3]]
    if f[:i]==g[:i]:P=min(p+m+G[i:],P,key=len);s=i+1
    else:p+=m;f=f[:i]
 return P

ध्यान दें कि, छोटे संस्करण के विपरीत, यह संस्करण विशेष रूप से इनपुट मानों के रूपांतरण में उनके संबंधित पतों पर पुनरावृत्ति का उपयोग नहीं करने के लिए लिखा गया है, ताकि यह स्टैक को ओवरफ्लो किए बिना बहुत बड़े मूल्यों को संभाल सके।

परिणाम

निम्नलिखित स्निपेट का उपयोग परीक्षणों को चलाने के लिए किया जा सकता है, या तो संस्करण के लिए, और परिणाम उत्पन्न करने के लिए:

def test(x, y, length):
    path = f(x, y)
    print "%10d %10d  =>  %2d: %s" % (x, y, len(path), " ".join(path))
    assert len(path) == length

#         x           y        Length
test(          0,          40,    4   )
test(         66,          67,    5   )
test(         30,           2,    2   )
test(         93,           2,    2   )
test(        120,          61,    8   )
test( 1493682877,           0,    4   )
test(          0,   368460408,   18   )
test( 1371432130,     1242824,   17   )
test(     520174,  1675046339,   23   )
test(  312602548,   940907702,   19   )
test( 1238153746,  1371016873,   22   )
test(  547211529,  1386725128,   23   )
test( 1162261466,  1743392199,   38   )

गोल्फ संस्करण

         0         40  =>   4: N N N N
        66         67  =>   5: S SW N N N
        30          2  =>   2: NE SW
        93          2  =>   2: NE SW
       120         61  =>   8: NW NW NW NW N SE SW N
1493682877          0  =>   4: S S NW NW
         0  368460408  =>  18: SW SW N N SW SW SE SW SW N SE N N SW SW N SE SE
1371432130    1242824  =>  17: NW NW NE NW N SE SW SW SW SE SE SW N N N N SW
    520174 1675046339  =>  23: NE NE NE NE SE SE SW SW N SE N SW N SW SE N N N N SE SE SW SW
 312602548  940907702  =>  19: NE NW S SW N N SW SE SE SE SW SE N N SW SE SE SE SW
1238153746 1371016873  =>  22: NE NE NE SE N N SW N N SW N SE SE SW N SW N N SE N SE N
 547211529 1386725128  =>  23: S S S S NW N N SE N SW N SE SW SE SW N SE SE N SE SW SW N
1162261466 1743392199  =>  38: NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE

कुशल संस्करण

         0         40  =>   4: N N N N
        66         67  =>   5: S SW N N N
        30          2  =>   2: NW NW
        93          2  =>   2: NE SW
       120         61  =>   8: NW NW NW NW N SE SW N
1493682877          0  =>   4: NE S NW NW
         0  368460408  =>  18: SW SW N N SW SW SE SW SW N SE N N SW SW N SE SE
1371432130    1242824  =>  17: NW NW NE NW N SE SW SW SW SE SE SW N N N N SW
    520174 1675046339  =>  23: NE NW NE NE SE SE SW SW N SE N SW N SW SE N N N N SE SE SW SW
 312602548  940907702  =>  19: NE NW S SW N N SW SE SE SE SW SE N N SW SE SE SE SW
1238153746 1371016873  =>  22: NE NE NE SE N N SW N N SW N SE SE SW N SW N N SE N SE N
 547211529 1386725128  =>  23: S S S S NW N N SE N SW N SE SW SE SW N SE SE N SE SW SW N
1162261466 1743392199  =>  38: NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE

— पक्ष
स्रोत

धिक्कार है कि तेज था। मैं आपको यह नहीं बता सकता कि मुझे मेरी चुनौतियों में से एक का जवाब देने के लिए हर बार यह कितना खुश करता है। :)

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

@ मार्टिनबटनर धन्यवाद, यह बहुत बड़ी प्रशंसा है! एफडब्ल्यूआईडब्ल्यू, मैं आपकी चुनौतियों को हल करने का आनंद लेता हूं। मैं कर सकता हूँ या नहीं, इस पर काम करना शुरू कर दिया है, जबकि यह अभी भी सैंडबॉक्स में था ... :)

— ऐल

संबोधन योजना शानदार है। यह कमाल का है।

— ब्रेनसटेल

@BrainSteel ने मुझे संबोधित करने वाली पहली योजना उस संबोधन योजना को आजमाने की कोशिश की थी, लेकिन एक घंटे से कम समय में पूरी तरह से परिकल्पित, कार्यान्वित और लिखी गई पूरी चीज़ को देखना भयानक है। +1

— लेवल रिवर सेंट

@Zymus मुझे यकीन नहीं है कि मैं अनुसरण करता हूं, लेकिन अगर आप तस्वीर का जिक्र कर रहे हैं, तो यह ओपी से मेल नहीं खाता है - यह एक अलग संबोधित करने वाली योजना है, जैसा कि पोस्ट में वर्णित है।

— एल डे

एपीएल (Dyalog यूनिकोड) , 144 132 129 118 133 132 130 124 117 बाइट्स ^SBCS

वेन को बहुत धन्यवाद और एपीएल ऑर्चर्ड में गोल्फिंग में उनकी मदद के लिए धन्यवाद, एपीपी भाषा सीखने के लिए एक शानदार जगह। ⎕IO←0। गोल्फ सुझाव का स्वागत करते हैं।

संपादित करें: -12 बाइट्स शुक्र और ngn के लिए धन्यवाद कि कैसे nपरिभाषित किया गया है और 1-इंडेक्सिंग से 0-इंडेक्सिंग में बदल रहा है। -3 एक बग को ठीक करने के कारण जहां सब कुछ 0-इंडेक्सिंग पर स्विच नहीं किया गया था। -11 बाइट्स बदलने के कारण Pऔर कैसे Qपरिभाषित हैं। +15 बाइट्स एक समस्या को ठीक करने के कारण जहां मेरे एल्गोरिथ्म को गलत करने के लिए बहुत धन्यवाद के साथ ngn करने में मदद मिली थी s[⊃⍋|M-s]। बग फिक्सिंग के लिए पीछे के मार्ग और +1 बाइट खोजने की विधि को पुन: व्यवस्थित करने से -2 बाइट्स। -2 बाइट्स की परिभाषा को पुनः व्यवस्थित करने से Adám को धन्यवाद I। -6 बाइट्स ngn के लिए धन्यवाद की परिभाषा को 'S' 'NE' 'NW' 'N' 'SW' 'SE'पुन: व्यवस्थित करने से और कैसे फिर tपरिभाषित करने से (यह अब एक अलग चर नहीं है)। -7 बाइट्स गोल्फ से ngn के लिए धन्यवाद कैसे sपरिभाषित किया गया है।

{M←⊃⍸≠⌿↑1+P Q←⍵{(⍵/3)⊤⍺-+/3*⍳⍵}¨⌊3⍟1+⍵×2⋄(∪¨↓6 2⍴'SSNENWNNSWSE')[P[I],3+Q↓⍨⊃⌽I←⍬{M≥≢⍵:⍺⋄(⍺∘,∇↑∘⍵)s[⊃⍋|M-s←⌽⊢.⊢⌸⍵]}P]}

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

एल्गोरिथ्म में बग का स्पष्टीकरण

मूल समस्या यह है कि मुझे लगा कि सबसे छोटा रास्ता सीधे आम पूर्वजों के माध्यम से चला गया, और वास्तव में, सामान्य पूर्वजों के पूर्वज के माध्यम से नहीं जा सकता है। यह गलत है क्योंकि निम्नलिखित उदाहरण प्रदर्शित होंगे।

66 से 5 तक

66 → 0 2 2 2 → 0 2 2 2
5  → 0 1     → 0 1
      ↑ common ancestor

The two ancestors of 0 2 2 2 are:
0 2 2
(empty)

(empty) has the shorter path back to 0 1 as it only needs two forward moves,
while 0 2 2 requires two more backtracks and one more forward move.

299792458 से 45687 तक

299792458 → 0 2 1 1 0 1 1 2 1 1 1 2 1 0 2 2 2 0
45687     → 0 2 1 1 0 1 1 1 2 2
                         ↑ common ancestor

The three ancestors of 299792458 are:
0 2 1 1 0 1 1 2 1 1 1 2 1 0 2 2 2
0 2 1 1 0 1 1 2 1 1 1 2            ← choose this one
0 2 1 1 0 1 1 2 1 1 1 2 1 0 2 2

And the three ancestors of 0 2 1 1 0 1 1 2 1 1 1 2 are:
0 2 1 1
0 2 1 1 0 1 1 2 1 1
0 2 1 1 0 1 1 2 1 1 1

0 2 1 1 0 1 1 1 2 2    ← 45687 for reference
             ↑ common ancestor

While it seems like `0 2 1 1` is the shorter path,
it actually results in a path that is 8 steps long
(2 backtracks, 6 forward steps to 45687).

Meanwhile, `0 2 1 1 0 1 1 2 1 1` is at an equal distance
to the common ancestor and has the following ancestors:
0 2 1 1
0 2 1 1 0 1 1 2 1
0 2 1 1 0 1 1

0 2 1 1 0 1 1 1 2 2    ← 45687 for reference
             ↑ common ancestor

Clearly, this is the superior path, as with three backtracks, we have reached
the point of the common ancestor. With 3 backtracks and 3 forward moves,
we have a path that is 6 steps long.

कोड की व्याख्या

                       ⍝ ⍵ should be an array of 2 integers, x y
SierpinskiPath←{⎕IO←0  ⍝ 0-indexing
        ⍝ P Q←{...}¨⍵  ⍝ First, the bijective base-3 numeration of x and y
    P Q←{
        n←⌊3⍟1+⍵×2  ⍝ The number of digits in the numeration
        z←+/3*⍳⍵    ⍝ The number of numerations with ≤ n digits
        (n/3)⊤⍵-z   ⍝ And a simple decode ⊤ (base conversion) of ⍵-z
    }¨⍵             ⍝ gets us our numerations, our paths

    A←↑1+P Q      ⍝ We turn (1+P Q) into an 2-by-longest-path-length array 
                  ⍝ ↑ pads with 0s and our alphabet also uses 0s
                  ⍝ So we add 1 first to avoid erroneous common ancestor matches
    Common←⊃⍸≠⌿A  ⍝ We find the length of the common ancestor, Common

        ⍝ I←⍬{...}P  ⍝ Now we get the shortest backtracking path from P
    I←⍬{
        Common=≢⍵:⍺       ⍝ If P is shorter than Common, return our backtrack path
        s←⌽⊢.⊢⌸⍵          ⍝ Get the indices of the most recent N SW SE
        t←s[⊃⍋|Common-s]  ⍝ and keep the index that is closest to Common
                          ⍝ and favoring the ancestors to the right of
                          ⍝ Common in a tiebreaker (which is why we reverse ⊢.⊢⌸⍵)
        (⍺,t)∇t↑⍵         ⍝ Then repeat this with each new index to backtrack
    }P                    ⍝ and the path left to backtrack through

    Backtrack←P[I]   ⍝ We get our backtrack directions
    Forward←(⊃⌽I)↓Q  ⍝ and our forward moves to Q
                     ⍝ starting from the appropriate ancestor
    (∪¨↓6 2⍴'SSNENWNNSWSE')[Backtrack,Forward]    ⍝ 'S' 'NE' 'NW' 'N' 'SW' 'SE'
}                    ⍝ and return those directions

Dyalog विस्तारित और dfns का उपयोग करके वैकल्पिक समाधान

अगर हम का उपयोग ⎕CY 'dfns'के adicसमारोह, यह हमारे द्विभाजित आधार-एन संख्यान अब तक कम बाइट्स के लिए (जो संस्करण मैं उपयोग के लिए प्रेरणा थी) लागू करता है। Dyalog विस्तारित पर स्विच करने से काफी संख्या में बाइट्स भी बच जाते हैं और इसलिए यहां हम हैं। इस गोल्फिंग में उनकी मदद के लिए बहुत धन्यवाद। गोल्फ सुझाव आपका स्वागत है!

संपादित करें: -8 बाइट्स को बदलने के कारण Pऔर कैसे Qपरिभाषित हैं। -दिल्लोग विस्तारित पर स्विच करने के कारण 14 बाइट्स। -2 dfn कोष्ठक को हटाने के लिए एक पूर्ण कार्यक्रम का उपयोग करने के कारण {}। +17 बाइट्स एक समस्या को ठीक करने के कारण जहां मेरे एल्गोरिथ्म को गलत करने के लिए कई धन्यवाद के साथ s[⊃⍋|M-s]अनुभाग में मदद करने के लिए धन्यवाद था । बग फिक्सिंग के लिए +1 बाइट। -2 बाइट्स के साथ एडेअम की परिभाषा को I याद करते हुए और -1 बाइट को याद करने से लेकर दोनों घोलों में मेरे गोल्‍फ डालने के लिए । -3 बाइट्स कार्डिनल दिशाओं की पीढ़ी को पुन: व्यवस्थित करके ngn के लिए धन्यवाद, एक बग्गी गोल्फ को सही करने से +1 बाइट, और -3 बाइट्स ngn को धन्यवाद देता है कि कैसे tपरिभाषित किया गया है (यह अब एक अलग चर नहीं है)। -7 बाइट्स sको परिभाषित करने के द्वारा ngn के लिए धन्यवाद कि कैसे परिभाषित किया गया है।

एपीएल (डायलॉग एक्सटेंडेड) , 123 115 101 99 116 117 114 109 102 बाइट्स

M←⊃⍸≠⌿↑1+P Q←(⍳3)∘⌂adic¨⎕⋄(∪¨↓6 2⍴'SSNENWNNSWSE')[P[I],3+Q↓⍨⊃⌽I←⍬{M≥≢⍵:⍺⋄(⍺∘,∇↑∘⍵){⍵[⊃⍋|M-⍵]}⌽⊢.⊢⌸⍵}P]