26

मैनहट्टन दूरी एक नियमित ग्रिड पर ओर्थोगोनल चरणों एक दूसरे से एक कक्ष तक पहुंचने के लिए लेने की जरूरत की संख्या है। ऑर्थोगोनल चरण वे हैं जो ग्रिड कोशिकाओं के किनारों से गुजरते हैं (जैसा कि कोनों के विपरीत है, जो हमें चेबीशेव दूरी देगा )।

हम अन्य ग्रिड पर समान दूरी को परिभाषित कर सकते हैं, उदाहरण के लिए त्रिकोणीय ग्रिड। हम निम्नलिखित अनुक्रमण योजना के साथ ग्रिड में व्यक्तिगत कोशिकाओं को संबोधित कर सकते हैं, जहां प्रत्येक कोशिका में एक x,yजोड़ी होती है:

    ____________________________________...
   /\      /\      /\      /\      /\
  /  \ 1,0/  \ 3,0/  \ 5,0/  \ 7,0/  \
 / 0,0\  / 2,0\  / 4,0\  / 6,0\  / 8,0\
/______\/______\/______\/______\/______\...
\      /\      /\      /\      /\      /
 \ 0,1/  \ 2,1/  \ 4,1/  \ 6,1/  \ 8,1/
  \  / 1,1\  / 3,1\  / 5,1\  / 7,1\  /
   \/______\/______\/______\/______\/___...
   /\      /\      /\      /\      /\
  /  \ 1,2/  \ 3,2/  \ 5,2/  \ 7,2/  \
 / 0,2\  / 2,2\  / 4,2\  / 6,2\  / 8,2\  
/______\/______\/______\/______\/______\...
\      /\      /\      /\      /\      /
 \ 0,3/  \ 2,3/  \ 4,3/  \ 6,3/  \ 8,3/
  \  / 1,3\  / 3,3\  / 5,3\  / 7,3\  /
   \/______\/______\/______\/______\/___...
   /\      /\      /\      /\      /\
  .  .    .  .    .  .    .  .    .  .
 .    .  .    .  .    .  .    .  .    .

अब इस ग्रिड पर मैनहट्टन की दूरी फिर से एक सेल से दूसरे तक पहुंचने के लिए किनारों पर न्यूनतम कदम है। तो तुम से ले जा सकते हैं 3,1करने के लिए 2,1, 4,1या 3,2, है, लेकिन किसी भी अन्य त्रिकोण के लिए नहीं जाएं, क्योंकि वे नहीं बल्कि किनारों से अंक को पार किया जाएगा।

उदाहरण के लिए, से दूरी 2,1के लिए 5,2है 4। सबसे छोटा रास्ता आम तौर पर अद्वितीय नहीं है, लेकिन 4 चरणों में दूरी बनाने का एक तरीका है:

2,1 --> 3,1 --> 3,2 --> 4,2 --> 5,2

चुनौती

दो समन्वित जोड़ों को देखते हुए और उपरोक्त संबोधित करने वाली योजना से, उनके बीच मैनहट्टन की दूरी वापस करें।x₁,y₁x₂,y₂

आप मान सकते हैं कि सभी चार इनपुट गैर-नकारात्मक पूर्णांक हैं, प्रत्येक 128 से कम है। आप उन्हें किसी भी क्रम में और मनमाने ढंग से समूहीकृत कर सकते हैं (चार अलग-अलग तर्क, चार पूर्णांक की एक सूची, पूर्णांक के दो जोड़े, एक 2x2 मैट्रिक्स,)। ।)।

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

आप किसी भी प्रोग्रामिंग भाषा का उपयोग कर सकते हैं , लेकिन ध्यान दें कि इन खामियों को डिफ़ॉल्ट रूप से मना किया गया है।

यह कोड-गोल्फ है , इसलिए सबसे छोटा वैध उत्तर - बाइट्स में मापा जाता है - जीतता है।

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

प्रत्येक परीक्षण मामले के रूप में दिया जाता है ।x₁,y₁ x₂,y₂ => result

1,2 1,2 => 0
0,1 1,1 => 1
1,0 1,1 => 3
2,1 5,2 => 4
0,0 0,127 => 253
0,0 127,0 => 127
0,0 127,127 => 254
0,127 127,0 => 254
0,127 127,127 => 127
127,0 127,127 => 255
75,7 69,2 => 11
47,58 36,79 => 42
77,9 111,23 => 48
123,100 111,60 => 80
120,23 55,41 => 83
28,20 91,68 => 111
85,107 69,46 => 123
16,25 100,100 => 159
62,85 22,5 => 160
92,26 59,113 => 174
62,22 35,125 => 206

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

क्या कमियां हैं जिन्हें आधिकारिक नकारात्मक खामियों के बीच शुद्ध नकारात्मक रेटिंग मिली है?

— डेविडक्र्स

@DavidC सं। लूपहोल प्रश्न से: "[...] किसी भी उत्तर में वर्णित लूपहोल जो कि +5 या उससे ऊपर है और कम से कम दो बार के रूप में कई चढ़ाव के रूप में माना जा सकता है समुदाय के लिए अस्वीकार्य माना जा सकता है "

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

क्या हमें पाँचवाँ इनपुट लेने की अनुमति है, जो कि डिफ़ॉल्ट रूप से 0 पर शुरू होता है (परिणाम)? फिर मुझे अपने उत्तर में चार तर्कों के साथ (a,b,x,y)->c(a,b,x,y,0)( पांचवें तर्क के रूप में) अलग विधि को जोड़ने की आवश्यकता नहीं होगी । c0

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

3

@KevinCruijssen कोई खेद नहीं है। अतिरिक्त, निश्चित तर्क थोड़ी आसानी से अपमानजनक हैं (और केवल 0 को एक विशेष मामले के रूप में अजीब लगता है)।

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

@MartinEnder ओके, ऐसा सोचा, लेकिन पूछने पर कभी चोट नहीं पहुंच सकती। उस स्थिति में मेरा 190 बाइट का उत्तर शेष है। हालांकि मैंने एक साल पहले आधा जवाब दिया था, एक भी परीक्षण का मामला विफल रहा था। अभी-अभी प्रश्न आया, और मेरे उत्तर में बग को ठीक करने में सक्षम था।

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

7

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

नील को धन्यवाद देकर 6 बाइट्स बचाए

(a,b,c,d,x=a>c?a-c:c-a,y=b>d?b-d:d-b,z=x>y?x:y)=>y+z+(x+z&1?a+b+(b>d)&1||-1:0)

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

कोड स्निपेट दिखाएं

let f =

(a,b,c,d,x=a>c?a-c:c-a,y=b>d?b-d:d-b,z=x>y?x:y)=>y+z+(x+z&1?a+b+(b>d)&1||-1:0)

console.log(f(  1,  2,  1,  2)); // => 0
console.log(f(  0,  1,  1,  1)); // => 1
console.log(f(  1,  0,  1,  1)); // => 3
console.log(f(  2,  1,  5,  2)); // => 4
console.log(f(  0,  0,  0,127)); // => 253
console.log(f(  0,  0,127,  0)); // => 127
console.log(f(  0,  0,127,127)); // => 254
console.log(f(  0,127,127,  0)); // => 254
console.log(f(  0,127,127,127)); // => 127
console.log(f(127,  0,127,127)); // => 255
console.log(f( 75,  7, 69,  2)); // => 11
console.log(f( 47, 58, 36, 79)); // => 42
console.log(f( 77,  9,111, 23)); // => 48
console.log(f(123,100,111, 60)); // => 80
console.log(f(120, 23, 55, 41)); // => 83
console.log(f( 28, 20, 91, 68)); // => 111
console.log(f( 85,107, 69, 46)); // => 123
console.log(f( 16, 25,100,100)); // => 159
console.log(f( 62, 85, 22,  5)); // => 160
console.log(f( 92, 26, 59,113)); // => 174
console.log(f( 62, 22, 35,125)); // => 206

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

प्रारंभिक पुनरावर्ती समाधान, 100 88 81

बच गए 12 बाइट्स ETHproductions की बदौलत नील की बदौलत 7 बाइट्स बचाए
गए

f=(a,b,c,d,e=b==d|a+b+(b>d)&1)=>a-c|b-d&&f(e?a+1-2*(a>c):a,e?b:b+1-2*(b>d),c,d)+1

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

यद्यपि यह अभी भी वर्तमान संस्करण पर अनिवार्य रूप से लागू होता है, निम्नलिखित स्पष्टीकरण अधिक विशेष रूप से प्रारंभिक संस्करण को संदर्भित करता है:

f=(a,b,c,d)=>b-d?a+b+(b>d)&1?f(a+1-2*(a>c),b,c,d)+1:f(a,b+1-2*(b>d),c,d)+1:Math.abs(a-c)

से जा रहे हैं (x0, वाई) के लिए (x1, वाई) तुच्छ क्योंकि हम लक्ष्य से एक के लिए स्रोत त्रिकोण से पार्श्व किनारों भर में सभी तरह से जा सकते हैं। इस मामले में मैनहट्टन की दूरी | x0 - X1 | ।

मुश्किल हिस्सा ऊर्ध्वाधर कदम है। पंक्ति y0 से पंक्ति y1 तक जाने के लिए, हमें इन दो मापदंडों को ध्यान में रखना होगा:

वर्तमान त्रिकोण का अभिविन्यास
चाहे y0 , y1 से कम या अधिक हो

त्रिकोण का अभिविन्यास x + y की समता द्वारा दिया जाता है :

अगर यह भी है, तो त्रिकोण ऊपर-इशारा कर रहा है
यदि यह विषम है, तो त्रिकोण नीचे की ओर इंगित करता है

हम एक अप-पॉइंटिंग ट्राइएंगल से नीचे की ओर जा सकते हैं (उपयोगी जब y0 <y1 ) और ऊपर से एक डाउन-पॉइंटिंग ट्राइएंगल (उपयोगी जब y0> y1 )।

Y0 और y1 के बीच तुलना के साथ त्रिभुज के अभिविन्यास को मिलाकर , हमें सूत्र x + y0 + (y>> y1? 1: 0) मिलता है, जिसका परिणाम तब भी होता है जब हम वांछित दिशा में जा सकते हैं और यदि नहीं तो विषम।

यदि हम सीधे अगली पंक्ति तक नहीं पहुंच सकते हैं, तो हमें पहले x को अपडेट करके एक सही संरेखण प्राप्त करने की आवश्यकता है :

यदि x अभी तक X1 के बराबर नहीं है , तो हम निश्चित रूप से सही दिशा में बढ़ना चाहते हैं, इसलिए हम इसे बढ़ाते हैं यदि x X1 से कम है और हम इसे x से अधिक x होने पर घटाते हैं।
यदि x पहले से ही X1 के बराबर है , तो हम इसे बढ़ा सकते हैं या इसे घटा सकते हैं

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

कोड स्निपेट दिखाएं

f=(a,b,c,d)=>b-d?a+b+(b>d)&1?f(a+1-2*(a>c),b,c,d)+1:f(a,b+1-2*(b>d),c,d)+1:Math.abs(a-c)

console.log(f(  1,  2,  1,  2)); // => 0
console.log(f(  0,  1,  1,  1)); // => 1
console.log(f(  1,  0,  1,  1)); // => 3
console.log(f(  2,  1,  5,  2)); // => 4
console.log(f(  0,  0,  0,127)); // => 253
console.log(f(  0,  0,127,  0)); // => 127
console.log(f(  0,  0,127,127)); // => 254
console.log(f(  0,127,127,  0)); // => 254
console.log(f(  0,127,127,127)); // => 127
console.log(f(127,  0,127,127)); // => 255
console.log(f( 75,  7, 69,  2)); // => 11
console.log(f( 47, 58, 36, 79)); // => 42
console.log(f( 77,  9,111, 23)); // => 48
console.log(f(123,100,111, 60)); // => 80
console.log(f(120, 23, 55, 41)); // => 83
console.log(f( 28, 20, 91, 68)); // => 111
console.log(f( 85,107, 69, 46)); // => 123
console.log(f( 16, 25,100,100)); // => 159
console.log(f( 62, 85, 22,  5)); // => 160
console.log(f( 92, 26, 59,113)); // => 174
console.log(f( 62, 22, 35,125)); // => 206

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

— Arnauld
स्रोत

यह ... बहुत छोटे गणित संचालन का एक बहुत ... लेकिन क्या आप nचर को पूरी तरह से छोड़ नहीं सकते हैं और प्रत्येक पुनरावृत्ति के परिणाम में केवल 1 जोड़ सकते हैं? ( 90 वर्ण मुझे लगता है)

— ETHproductions

@ETHproductions ईमानदार होने के लिए, मैंने इसे बिना किसी गंभीर गोल्फ के पोस्ट किया। लेकिन यह निश्चित रूप से पहली बात है। धन्यवाद!

— अरनौलद

1

इसके अलावा, मुझे लगता है &कि आप a+b+(b>d)&12 बाइट्स बचाने के लिए कर सकते हैं मतलब के ऑपरेटर पूर्वता

— ETHproductions

यह 81 तक गया, मुझे लगता है:f=(a,b,c,d,e=b==d|a+b+(b>d)&1)=>a-c|b-d&&f(e?a+1-2*(a>c):a,e?b:b+1-2*(b>d),c,d)+1

— नील

मुझे लगता है कि कुछ चतुर करी का उपयोग करके एक अन्य बाइट को बचाने के लिए संभव हो सकता है।

— नील

5

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

lambda x,y,X,Y:abs(y-Y)+max(x-X,X-x,abs(y-Y)+((x+y+X+Y)%-2)**(x^y^(Y>=y)))

— feersum
स्रोत

1

क्या आप कृपया इस भाग को समझा सकते हैं **(x^y^(Y>=y)):?

— मृत पोस्सम

1

@ डिडपॉसम 1 की दूरी से बढ़ने पर 1 या 3 चालें खड़ी हो सकती हैं; केवल समानताएं देखकर बताने का कोई तरीका नहीं है, इसलिए आपको y मानों की तुलना करनी होगी।

— feersum

2

बैच, 99 बाइट्स

@cmd/cset/a"x=%3-%1,x*=x>>31|1,y=%4-%2,w=y>>31,y*=w|1,z=x+(y+x&1)*(-(%1+%2+w&1)|1)-y,z*=z>>31,x+y+z

स्पष्टीकरण: एक क्षितिज-केवल गति बस निरपेक्ष एक्स-समन्वय अंतर लेता है। बड़े पर्याप्त x के लिए, ऊर्ध्वाधर गति केवल पूर्ण y-निर्देशांक अंतर के प्रति एक अतिरिक्त कदम उठाती है, लेकिन छोटे x के लिए, यह चार अतिरिक्त चरण प्रति दो y-निर्देशांक अंतर, प्लस एक या तीन चरणों में एक विषम अंतर के लिए लेता है। इसे दो चरणों के अंतर के रूप में और एक सुधार कारक के रूप में शांत किया जाता है। सही दो चरणों में से बड़ा और पूर्ण अंतर का योग तब परिणाम होता है, हालांकि यह अपने आप में सही निरपेक्ष y- समन्वय अंतर के बड़े के रूप में गणना की जाती है और पूर्ण x-निर्देशांक दूरी बिना सोचे-समझे पूर्ण y- समन्वय अंतर में जोड़ दी जाती है ।

@cmd/cset/a" - अल्पविराम से अलग किए गए भावों का मूल्यांकन करता है और अंतिम को प्रिंट करता है
x=%3-%1,x*=x>>31|1गणना करता है $x=|x_2-x_1|$
y=%4-%2,w=y>>31,y*=w|1गणना करता है और $w=y_1>y_2$ $y=|y_2-y_1|$
z=x+(y+x&1)*(-(%1+%2+w&1)|1)-yसुधार कारक $c=(y+(x\bmod2))(1-2((x_1+y_1+w)\bmod2)), z=x+c-y$
z*=z>>31,x+y+z गणना करता है $max(x,y-c)+y = x+y-min(0,x+c-y)$

— नील
स्रोत

2

जेली , 24 बाइट्स

⁴<³¬Ḋ;³S
SḂN*¢+ḊḤ$
ạµS»Ç

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

आइए इनपुट कॉल करें । मैंने समरसता के सूत्र से काम लिया: $(x,y),(X,Y)$

\begin{aligned} d & = | y - Y | + max (| x - X |, | y - Y | + ((x + y + X + Y) mod - 2)^{x \oplus y \oplus (Y \geq y)}) \\ = | y - Y | + max (| x - X |, | y - Y | + [- (| x - X | + | y - Y | mod 2)]^{x + y + (Y ≮ y)}) \\ = max (| x - X | + | y - Y |, 2 | y - Y | + [- (| x - X | + | y - Y | mod 2)]^{(Y ≮ y) + x + y}) . \end{aligned}

$\begin{align*} d &= |y-Y|+\max(|x-X|,|y-Y|+((x+y+X+Y)\bmod -2)^{x \oplus y \oplus (Y \geq y)}) \\ &= |y-Y|+\max(|x-X|,|y-Y|+[-(|x-X|+|y-Y| \bmod 2)]^{x + y + (Y \not< y)}) \\ &= \max(|x-X|+|y-Y|,2|y-Y|+[-(|x-X|+|y-Y| \bmod 2)]^{(Y \not< y) + x + y}). \end{align*}$

पहली पंक्ति , सूत्र में घातांक की गणना करती है। $¢ = (Y \not< y)+x+y$

अंतिम पंक्ति पहले गणना करती है और फिर अधिकतम और गणना करती है , जहाँ मध्य रेखा पर कार्य करता है। $L=[|x-X|, |y-Y|]$ $\text{sum}(L)$ $f(L)$ $f$

मध्य लाइन, यह देखते हुए , computes , लेता है कि करने के लिए 'वें शक्ति है, तो कहते हैं । $L=[a, b]$ $-((a+b)\bmod 2)$ $¢$ $2b$

— लिन
स्रोत

2

रैकेट / योजना, 214 बाइट्स

(define(f x y X Y)(let m((p x)(q y)(c 0))
(let((k(+ c 1))(d(- Y q)))
(cond((= 0(- X p)d)c)
((and(> d 0)(even?(+ p q)))(m p(+ q 1)k))
((and(< d 0)(odd?(+ p q)))(m p(- q 1)k))
((< p X)(m(+ p 1)q k))
(else(m(- p 1)q k))))))

— केविन
स्रोत

2

05AB1E , 24 बाइट्स

पोर्ट ऑफ़ माय पाइथ उत्तर , जो बदले में लगभग उसी दृष्टिकोण का उपयोग करता है, जैसा कि फ़र्सम का पाइथन उत्तर । निर्देशांक के जोड़े की सूची के रूप में इनपुट लेता है, । +1 बाइट के लिए एक बग फिक्स्ड, फिर +1 के लिए एक और गलती तय की, लेकिन जिसने सभी परीक्षण मामलों के लिए सही परिणाम प्राप्त किया ... $(x_1, x_2), (y_1, y_2)$

ÆÄ`©I˜OÉ(IøнOIθD{Q+m+M®+

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

टूट - फूट

ÆÄ` © IÆÄOÉ (IøнOI {D {Q + m + M® + Full program। मैं मूल्यांकन इनपुट का प्रतिनिधित्व करता है।
, जोड़ घटाकर घटाएँ, पूर्ण मान लें।
  `© उन्हें स्टैक पर अलग से डंप करें और दूसरे को स्टोर करें
                            एक, | y1-y2 | रजिस्टर में सी।
    OfO स्टैक पर चपटा इनपुट के योग को धक्का देता है।
       Par (इसकी समता लो और इसे नकार दो।
         Iøн पुश [X1, y1]।
            O X1 + y1 लें (उन्हें योग करें)।
             I checkD {Q फिर जांचें कि क्या दूसरी जोड़ी को सॉर्ट किया गया है (y1) y2)।
                  + और योग जो कि X1 + y1 के साथ हो।
                   मीटर एक्सप्रेशन। परिणाम के ऊपर समानता को धक्का दें।
                    + और दूसरे पूर्ण अंतर को उसमें जोड़ें।
                     एम® + परिणामस्वरूप, स्टैक पर सबसे बड़ी संख्या को धक्का दें
                            प्लस रजिस्टर सी में संग्रहीत मूल्य।

— श्री एक्सकोडर
स्रोत

मैं% नहीं 100 यकीन है, लेकिन आप नहीं बदल सकते हैं ©करने के लिए Dऔर हटाने ®? यह आपके TIO में वर्तमान में मामले के लिए काम करता है, लेकिन मुझे यकीन नहीं है कि यह हर मामले के लिए समान मार्ग का अनुसरण करता है।

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

1

@KevinCruijssen EDIT : नहीं, क्योंकि इसका Mव्यवहार इससे प्रभावित होगा। के लिए विफल रहता है [[0, 127], [0, 0]]।

— श्री Xcoder

2

पायथन 2 , 74 72 71 बाइट्स

lambda c,a,d,b:abs(a-b)+abs(a+(-c-a)/2-b-(-d-b)/2)+abs((c+a)/2-(d+b)/2)

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। संपादित करें: @JoKing के लिए 2 बाइट्स सहेजे गए। @ Mr.Xcoder को एक और बाइट धन्यवाद दिया। निम्नलिखित सूत्र के आधार पर मैंने इस प्रश्न में पाया :

| a_{i} - b_{i} | + | (a_{i} - ⌊ \frac{a_{j}}{2} ⌋) - (b_{i} - ⌊ \frac{b_{j}}{2} ⌋) | + | ⌊ \frac{a_{j} + 1}{2} ⌋ - ⌊ \frac{b_{j} + 1}{2} ⌋ |

$\left|a_i-b_i\right|\;+\;\left|\left(a_i-\left\lfloor\frac{a_j}2\right\rfloor\right)-\left(b_i-\left\lfloor\frac{b_j}2\right\rfloor\right)\right|\;+\;\left|\left\lfloor\frac{a_j+1}2\right\rfloor-\left\lfloor\frac{b_j+1}2\right\rfloor\right|$

समन्वय प्रणाली तीन तरीकों से भिन्न होती है; निर्देशांक का आदान-प्रदान किया जाता है (जो मेरे कुछ अजीब पैरामीटर नाम क्रम को समझाता है), निर्देशांक (जो कि दो जोड़ बताते हैं) के बजाय होते हैं और लिंक किए गए प्रश्न में निर्देशांक अवर 1-इंडेक्सिंग का उपयोग करते हैं। चूंकि हम मतभेदों को दूर कर रहे हैं और अधिकांश समय रद्द कर दिया जाता है और हम साथ रह जाते हैं: $120^\circ$ $90^\circ$

| a_{i} - b_{i} | + | (a_{i} - ⌊ \frac{a_{j} + 1}{2} ⌋) - (b_{i} - ⌊ \frac{b_{j} + 1}{2} ⌋) | + | ⌊ \frac{a_{j}}{2} ⌋ - ⌊ \frac{b_{j}}{2} ⌋ |

$\left|a_i-b_i\right|\;+\;\left|\left(a_i-\left\lfloor\frac{a_j+1}2\right\rfloor\right)-\left(b_i-\left\lfloor\frac{b_j+1}2\right\rfloor\right)\right|\;+\;\left|\left\lfloor\frac{a_j}2\right\rfloor-\left\lfloor\frac{b_j}2\right\rfloor\right|$

इसके बाद यह ध्यान दिया जा सकता है कि । $-\lfloor\frac{a_j+1}2\rfloor = \lfloor\frac{-a_j}2\rfloor$

— नील
स्रोत

आप नई लाइन को हटाकर इसे वन-लाइनर बना सकते हैं

— जो किंग

1

lambda c,a,d,b:abs(a-b)+abs(a+-(c+a)/2-b--(d+b)/2)+abs((c+a)/2-(d+b)/2)3 बाइट्स बचाना चाहिए।

— श्री एक्सकोडर

1

पायथ , 31 28 बाइट्स

Feersum के पाइथन उत्तर के रूप में लगभग उसी दृष्टिकोण का उपयोग करता है । निर्देशांक के जोड़े की सूची के रूप में इनपुट लेता है, । -1 बाइट के लिए एक बग फिक्स्ड। $(x_1, x_2), (y_1, y_2)$

+eKaMQg#hK+eK^%ssQ_2+shCQSIe

यहाँ कोशिश करो! या परीक्षण सूट की कोशिश करो!

टूट - फूट

+ eKaMQg # hK + eK ^% ssQ_2xxFhCQSIe पूर्ण कार्यक्रम। क्यू = eval (इनपुट ())।
  केएमक्यू स्टोर मतभेदों को [| X1-x2 |; | y1-y2 |] में के।
 e बाद में प्राप्त करें (| y1-y2 |)।
+ g # और इसे इसके बीच के सबसे बड़े मूल्य में जोड़ें:
        HK - K का सिर (| X1-x2 |
          + - और जोड़ने का परिणाम:
           eK K का अंत (| y1-y2 |)।
             ^ - घातांक के परिणाम के साथ:
              % ssQ_2 चपटा क्यू, modulo -2 का योग।
                                        उपज -1 यदि X1 + x2 + y1 + y2 विषम है, तो 0 अन्यथा।
                    xxFhCQSIe - इस अभिव्यक्ति के परिणाम से:
                       hCQ ट्रांस्पोज़ Q और हेड (X1, y1) प्राप्त करें।
                     xF बिटवाइस XOR से कम करें।
                          SIe और जांचें कि क्या सूची [y1, y2] क्रमबद्ध है।
                    x जिसके बाद, बूल द्वारा परिणाम (0/1)।

— श्री एक्सकोडर
स्रोत

1

05AB1E , 16 बाइट्स

नील के उत्तर के संशोधित संस्करण का उपयोग करता है , जो स्टैक-आधारित भाषाओं के लिए 05AB1E के लिए अनुकूलित है। निर्देशांक के दो जोड़े के रूप में इनपुट लेता है, , जिसे STDIN की एक नई द्वारा अलग किया जाता है। प्रारंभ में मैंने अपने अन्य 05AB1E उत्तर के साथ विलय कर दिया, लेकिन फिर इसे अलग से पोस्ट करने का निर्णय लिया क्योंकि यह बहुत अलग है। $(x_1, x_2), (y_1, y_2)$

+D(‚2÷Æ`²Æ©+®)ÄO

इसे ऑनलाइन आज़माएं! या परीक्षण सूट की कोशिश करो! _{^{(कोड के थोड़ा संशोधित संस्करण का उपयोग करता है (के ®बजाय ²), केविन क्रूज़सेन के सौजन्य से )}}

— श्री एक्सकोडर
स्रोत

अच्छा जवाब! गोल्फ के लिए कुछ नहीं है, लेकिन जब आप इसे बदलते ©+®हैं DŠ+तो टेस्ट सूट स्थापित करना आसान होता है। ;) यहाँ है कि परीक्षण सूट, और सभी परीक्षण के मामले वास्तव में सफल हो रहे हैं (गन्दा हेडर को अनदेखा करें; पी)।

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

@KevinCruijssen मेरे पास एक वैकल्पिक संस्करण के रूप में था, लेकिन मेरे साथ ऐसा नहीं हुआ कि मैं एक टेस्ट सूट लिख

— सकूं

1

@ केविनक्रूजसेन I ने दो और (बहुत स्पष्ट ...!) बाइट्स से गुदगुदाया, और टेस्ट सूट की अनुकूलता को और भी अधिक तोड़ने में सफल रहा, इसलिए मैंने इसे इस प्रकार रखा: संपादित करने के लिए धन्यवाद।

— श्री एक्सकोडर

1

जेली , 22 .. 16 15 बाइट्स

ṭH,‘H_ɗɗ@+¥ḞIAS

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

सभी परीक्षण मामलों की कोशिश करो।

इस उत्तर में @ नील की विधि का उपयोग करता है जो इस गणित से संशोधित सूत्र का उपयोग करता है । प्रश्न।

समन्वय को तर्क के रूप में लेता है y1, y2और x1, x2।

— dylnan
स्रोत

1

जावा 8, 157 190 188 144 142 141 127 बाइट्स

(a,b,x,y)->{int r=0,c=1,z=1;for(;(c|z)!=0;r--){c=x-a;z=y-b;if((z<0?-z:z)<(c<0?-c:c)|a%2!=b%2?z<0:z>0)b+=z<0?-1:1;else a+=c<0?-1:1;}return~r;}

बग फिक्स के कारण +33 बाइट्स (157 → 190)।
-44 बाइट्स (188 → 144) पुनरावर्ती विधि को एकल लूपिंग विधि में परिवर्तित करना।
-14 बाइट्स @ceilingcat की बदौलत ।

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

(a,b,x,y)->{          // Method with four integers as parameter and integer return-type
                      // (a=x1; b=y1; x=x2; y=y2)
  int r=0,            //  Result-integer `r`, starting at 0
      c=1,z=1;        //  Temp integers for the differences, starting at 1 for now
  for(;(c|z)!=0;      //  Loop until both differences are 0
      r--){           //    After every iteration: decrease the result `r` by 1
    c=x-a;            //   Set `c` to x2 minus x1
    z=y-b;            //   Set `z` to y2 minus y1
    if(z*Z            //   If the absolute difference between y2 and y1
       <c*c)          //   is smaller than the absolute difference between x2 and x1
       |a%2!=b%2?     //   OR if the triangle at the current location is facing downwards
         z<0          //       and we have to go upwards,
        :z>0)         //      or it's facing upwards and we have to go downwards
      b+=z<0?-1:1;    //    In/decrease y1 by 1 depending on where we have to go
    else              //   Else:
     a+=c<0?-1:1;}    //    In/decrease x1 by 1 depending on where we have to go
  return~r;           //  Return `-r-1` as result

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

1

के z*z<c*cबजाय सुझाव(z<0?-z:z)<(c<0?-c:c)

— छत

@ceilingcat आह, अच्छा है। धन्यवाद!

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

त्रिकोणीय मैनहट्टन दूरी

चुनौती

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

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

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

प्रारंभिक पुनरावर्ती समाधान, 100 88 81

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

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

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

बैच, 99 बाइट्स

जेली , 24 बाइट्स

रैकेट / योजना, 214 बाइट्स

05AB1E , 24 बाइट्स

टूट - फूट

पायथन 2 , 74 72 71 बाइट्स

पायथ , 31 28 बाइट्स

टूट - फूट

05AB1E , 16 बाइट्स

जेली , 22 .. 16 15 बाइट्स

जावा 8, 157 190 188 144 142 141 127 बाइट्स