परिचय

एरन निमज़ोविस्च एक अग्रणी शतरंज गुरु और एक प्रभावशाली शतरंज लेखक थे।

उनकी पुस्तक 'माई सिस्टम' में, पहला अध्याय केंद्र के महत्व के बारे में बताता है कि आपको इस पर क्यों हावी होना चाहिए। सरल कारण यह है कि आपके टुकड़े केंद्र में होने पर अधिक संभव सीधी अगली चालें होते हैं जो फिर से खिलाड़ी को अधिक शक्ति प्रदान करते हैं।

यह बहुत स्पष्ट हो जाता है जब एक खाली बोर्ड पर एक नाइट के विभिन्न पदों और इसकी संभावित अगली चाल (गुलाबी में दिखाया गया है) को देखते हुए:

उद्देश्य

अपनी स्थिति के आधार पर एक खाली बोर्ड पर एक नाइट के संभावित प्रत्यक्ष अगले चालों की संख्या का मूल्यांकन करें।

इनपुट चश्मा

शूरवीर की स्थिति।

पहले x (स्तंभ) और फिर y (पंक्ति)। 0 0बाएँ कोने में है।

सादगी के लिए, मैंने एक शतरंज बोर्ड के लेबल को केवल संख्याओं में बदल दिया। हमारे उदाहरण और परीक्षण मामलों के लिए हम एक 0-आधारित इंडेक्स का उपयोग करते हैं, हालांकि आप 1-आधारित इंडेक्स का उपयोग करने के लिए स्वतंत्र हैं।

आप किसी भी प्रकार के संभावित इनपुट फॉर्मेट, ऐरे, फंक्शन आर्ग्युमेंट्स आदि का उपयोग कर सकते हैं।

आउटपुट स्पेक्स

एक खाली बोर्ड पर नाइट के लिए संभावित प्रत्यक्ष अगली चाल।

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

3 4 => 8
4 6 => 6
7 7 => 2
1 0 => 3

टेस्ट केस 0-आधारित इंडेक्स को नियोजित कर रहे हैं। मूल्यों की पूरी ग्रिड है:

2 3 4 4 4 4 3 2
3 4 6 6 6 6 4 3
4 6 8 8 8 8 6 4
4 6 8 8 8 8 6 4
4 6 8 8 8 8 6 4
4 6 8 8 8 8 6 4
3 4 6 6 6 6 4 3
2 3 4 4 4 4 3 2

code-golf math chess

— starcorder
स्रोत

9

अच्छी पहली चुनौती! :-)

— लुइस मेंडो

14

"नाइट ऑन द रिम गंभीर है"

2

@stacey आपकी टिप्पणी इस पहेली के लिए एक महान शीर्षक रही होगी :)

— स्टारबोर्ड

6

अब वास्तव में कठिन प्रश्न के लिए: क्या उपरोक्त छवियों में लाल शूरवीर सभी समान रंग हैं?

— mbomb007

25

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

lambda x,y:50/(8+x*x/7-x+y*y/7-y)-4

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

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

lambda x,y:50/(8-x*(7-x)/5-y*(7-y)/5)-4

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

इनपुट 0-अनुक्रमित लेता है।

अभिव्यक्ति x*(7-x)/5समन्वय मूल्यों 0..7को ले जाती है

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

( min(x,7-x,2)ऐसा ही करता है, लेकिन अधिक लंबा है।) इसके लिए सारांशित करना xऔर yसही पैटर्न देता है लेकिन गलत संख्याओं के साथ

0 1 2 2 2 2 1 0
1 2 3 3 3 3 2 1
2 3 4 4 4 4 3 2
2 3 4 4 4 4 3 2
2 3 4 4 4 4 3 2
2 3 4 4 4 4 3 2
1 2 3 3 3 3 2 1
0 1 2 2 2 2 1 0

( बेहतर तर्क के लिए नील का समाधान देखें कि यह सही पैटर्न के बारे में क्यों बताता है।)

अंत में, a -> 50/(8-a)-4फर्श-विभाजन के साथ मानचित्रण सही मान देता है

2 3 4 4 4 4 3 2
3 4 6 6 6 6 4 3
4 6 8 8 8 8 6 4
4 6 8 8 8 8 6 4
4 6 8 8 8 8 6 4
4 6 8 8 8 8 6 4
3 4 6 6 6 6 4 3
2 3 4 4 4 4 3 2

1-अनुक्रमित आदानों के साथ एक समान रूप से लंबा समाधान:

lambda x,y:(x*(9-x)/6+y*(9-y)/6)**2/6+2

— XNOR
स्रोत

(7-a)*a/53 बाइट्स से छोटा है min(a,7-a,2)।

— नील

1

*lवास्तव में आपकी कुल लागत बाइट है, lambda a,b:"23468"[(7-a)*a/5+(7-b)*b/5]केवल 41 बाइट है।

— नील

@ नील मुझे बस एक ही चीज़ मिली थी x*(9-x)/6, एक-अनुक्रमित।

— xnor

1

क्यों आप <strike>गोल्फ की प्रगति दिखाने के लिए बाकी सब की तरह उपयोग नहीं करते हैं ?

— पागल

4

@ मुझे लगता है कि यह बदसूरत लग रहा है और वास्तव में मदद नहीं करता है। कोड महत्वपूर्ण बात है, और जो कोई भी इसके विकास को देखना चाहता है, उसे अभी भी संपादित इतिहास में देखने की आवश्यकता है। जब मेरा पुराना कोड दिखने लायक हो, तो मैं यहाँ जैसे संस्करण दिखाऊंगा । लेकिन इस सवाल पर, यह एक ही रणनीति के लिए सभी छोटे सुधार हैं, इसलिए मैंने विभिन्न संभावनाओं का उल्लेख करने के लिए इसे क्लीनर पाया।

— xnor

17

MATL , 17 14 13 12 बाइट्स

1 बाइट के लिए @Neil को धन्यवाद!

8:HZ^ZP5X^=s

इनपुट 1-आधारित है।

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

व्याख्या

यह यूक्लिडियन इनपुट से शतरंजबोर्ड में 64 पदों में से प्रत्येक की दूरी की गणना करता है, और पाता है कि उन मानों में से कितने 5 के वर्गमूल के बराबर हैं।

चूंकि निर्देशांक पूर्णांक मान हैं, इसलिए हम यह सुनिश्चित कर सकते हैं कि 5 के वर्गमूल (जो निर्देशांक से गणना की गई है और सीधे गणना की गई है) का प्रतिनिधित्व करने वाले दो फ़्लोटिंग-पॉइंट मूल्य वास्तव में समान हैं।

8:      % Push array [1 2 ... 8]
H       % Push 2
Z^      % Cartesian power. Gives 2D array [1 1; 1 2; ... 1 8; 2 1; ... 8 8]     
ZP      % Implicit input. Compute Euclidean distances, considering each row as a point
5X^     % Square root of 5
=s      % Compute how many squared distances equal sqrt(5). Implicit display

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

1

प्रभावशाली और स्पष्टीकरण के लिए धन्यवाद

— स्टारबोर्ड

1

यदि राउंडिंग त्रुटियों के कारण 5 से 5 के वर्गमूल के वर्ग की तुलना विफल हो जाती है, तो क्या आप कम से कम 5 के वर्गमूल की तुलना 5 के वर्गमूल से नहीं कर सकते?

— नील

@ नील इस विचार के लिए धन्यवाद! हां, चूंकि गणना पूर्णांक के साथ होती है, इसलिए मुझे यकीन है कि दो "5 की जड़ें" समान doubleसंख्या हैं। चींटी इसे बाइट बचाती है

— लुइस मेंडो

15

गणितज्ञ 63 43 बाइट्स

मार्टिन बायर के सुझावों के लिए धन्यवाद 20 बाइट्स बचाया!

EdgeCount[8~KnightTourGraph~8,#+1+8#2/<->_]&

उपरोक्त उन वर्गों की संख्या का पता लगाता है जो पूर्ण शूरवीर टूर ग्राफ पर दिए गए सेल से 1 हॉप दूर हैं।

g=KnightTourGraph[8,8,VertexLabels->"Name",Axes->True]

शीर्ष नामों और निर्देशांक के साथ पूर्ण नाइट के दौरे के ग्राफ को प्रदर्शित करता है। ध्यान दें कि निर्देशांक के लिए एक-आधारित अनुक्रमण के लिए गणितज्ञ चूक करता है।

#+1+8#2&[r,f]धर्मान्तरित वर्टेक्स को रैंक (पंक्ति) r, और फ़ाइल (कॉलम) में वर्ग के अनुरूप देता है f, इनपुट के रूप में शून्य-आधारित मानों का उपयोग करके।

उदाहरण के लिए #+1+8#2&[2,1]रिटर्न 11।

EdgeCount पड़ोस ग्राफ में किनारों की संख्या देता है।

रैंक 2 के लिए किनारा, फ़ाइल 1 (वर्ग 11):

IncidenceList[8~KnightTourGraph~8, 8 #2 + # + 1] &[2, 1]

(*{1 <-> 11, 5 <-> 11, 11 <-> 17, 11 <-> 21, 11 <-> 26, 11 <-> 28}*)

हाइलाइट किए गए किनारे:

HighlightGraph[g, {1, 5, 11, 17, 21, 26, 28, Style[1 <-> 11, Thick, Blue], Style[5 <-> 11, Thick, Blue], Style[11 <-> 17, Thick, Blue], Style[11 <-> 21, Thick, Blue], Style[11 <-> 26, Thick, Blue], Style[11 <-> 28, Thick, Blue]},GraphHighlightStyle -> "DehighlightFade", PlotRangePadding -> .5]

विधि 2: यूक्लिडियन दूरी

70 बाइट्स

यह विधि लंबी है, लेकिन संभवतः कुछ ब्याज की है। दृष्टिकोण शतरंज के केंद्र और ब्याज की सेल के बीच यूक्लिडियन दूरी की जांच करना है।

Which[(x=Sqrt@Tr[({3.5, 3.5}-#)^2])<2.2,8,x<3,6,x<4,4,x<4.6,3,x>4.6,2]&

दृष्टांत

Which[(x=Sqrt@Tr[({3.5, 3.5}-#)^2])<2.2,8,x<3,6,x<4,4,x<4.6,3,x>4.6,2]&@{0, 0}
Which[(x=Sqrt@Tr[({3.5, 3.5}-#)^2])<2.2,8,x<3,6,x<4,4,x<4.6,3,x>4.6,2]&@{3, 3}

2

8

यह मानने में मदद करने के लिए कि मूल्य निर्धारित करने के लिए शतरंज के केंद्र से दूरी कितनी है।

values={{2,3,4,4,4,4,3,2},{3,4,6,6,6,6,4,3},{4,6,8,8,8,8,6,4},{4,6,8,8,8,8,6,4},{4,6,8,8,8,8,6,4},{4,6,8,8,8,8,6,4},{3,4,6,6,6,6,4,3},{2,3,4,4,4,4,3,2}};
f[x_]:=Text[x,#]&/@Position[values,x]r_~w~p_:=RegionMember[{3.5`,3.5`}~Disk~r,p]
h@y_:=Which[2.2~w~y,8,3~w~y,6,4~w~y,4,4.6~w~y,3,2<3,2]

Graphics[{Circle[{4.5, 4.5}, 2.3], Circle[{4.5, 4.5}, 3],

सर्कल [{4.5, 4.5}, 4],

मंडली [{4.5, 4.5}, 4.6], Flatten [f / @ {2, 3, 4, 6, 8}, 1]}, अक्ष -> सत्य, AxesOrigin -> {-1, -1}]

२.२, ३, ४, और ४.२ वृत्त की त्रिज्या हैं।

— DavidC
स्रोत

1

महान यात्रा का ग्राफ

— स्टारबोर्ड

20

KnightTourGraphMathematica and its buildins ... :-)

— लुइस मेंडो

मुझे लगता है कि #आपके स्रोत कोड के अंत में एक भटका है (ठीक पहले ])। आपको हालांकि IncidenceListइसके बजाय उपयोग करने में सक्षम होना चाहिए EdgeList@NeighborhoodGraph। (वैकल्पिक रूप से, यह भी है EdgeCount, लेकिन मुझे लगता है कि यह लंबे समय तक समाप्त होता है।)

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

1

ओह रुको, यह वास्तव में छोटा है:EdgeCount[8~KnightTourGraph~8,#+1+8#2<->_]&

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

EdgeCountबहुत अच्छा है!

— डेविड

12

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

(x,y)=>+"23468"[((7-x)*x+(7-y)*y)/5|0]

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

24.5 18.5 14.5 12.5 12.5 14.5 18.5 24.5
18.5 12.5  8.5  6.5  6.5  8.5 12.5 18.5
14.5  8.5  4.5  2.5  2.5  4.5  8.5 14.5
12.5  6.5  2.5  0.5  0.5  2.5  6.5 12.5
12.5  6.5  2.5  0.5  0.5  2.5  6.5 12.5
14.5  8.5  4.5  2.5  2.5  4.5  8.5 14.5
18.5 12.5  8.5  6.5  6.5  8.5 12.5 18.5
24.5 18.5 14.5 12.5 12.5 14.5 18.5 24.5

पहुंच योग्य वर्गों की संख्या पांच बैंडों में गिर जाती है:

मैं वास्तव में 24.5 - (3.5 - x) ** 2 - (3.5 - y) ** 2 = (7 - x) * x + (7 - y) * y की गणना करता हूं क्योंकि यह एक छोटी गणना है, लेकिन यह सब उल्टा है। बैंड का क्रम।

— नील
स्रोत

सुपर संक्षिप्त और बहुत अच्छा दृष्टिकोण, इसलिए मुझे अब अपना जेएस समाधान शुरू करने की आवश्यकता नहीं है :)

— स्टारबोर्ड

सूत्र त्रिज्या वर्ग के बराबर होने के बारे में अच्छी बात है। मैंने x*(7-x)केवल एक ऑपरेशन के बारे में सोचा था जो नीचे की ओर चाप की तरह दिखता 0..7है और वक्र फिट होता है, लेकिन यह बताता है कि क्यों यह एक अच्छा पैटर्न पैदा करता है जब इसके लिए सारांशित किया जाता है xऔर y।

— xnor

11

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

8ṗ2_³²S€ċ5

1 अनुक्रमित। प्रपत्र का एकल तर्क लेता है [x,y]। इसे यहाँ आज़माएँ।

8ṗ2          Cartesian square [[1,1],[1,2]…[8,8]]
   _³        Subtract the input
     ²S€     Compute the norm of each vector
        ċ5   Count fives

डेनिस ने बाइट बचाई!

— लिन
स्रोत

बस ग्यारह बाइट्स, वाह!

— स्टारबोर्ड

मैंने सुबह इस प्रश्न को देखा और यह सटीक एल्गोरिथम है जो मैंने सोचा था कि मैं जब जेली में होगा तब मैं इसे लागू करूंगा। : पी

— पुरकाकूदरी

8

गणितज्ञ, ४४ ४० बाइट्स

मुझे वर्तमान में एक ही बाइट गणना में तीन समाधान मिले हैं:

2[3,4,6,8][[Tr@⌊3.2-.8Abs[#-4.5]⌋]]&
Tr@⌈.85(4-Abs[#-4.5])⌉/.{5->6,6->8}&
⌊Tr@⌈.85(4-Abs[#-4.5])⌉^1.1608⌋&

वे सभी अनाम फ़ंक्शन हैं जो निर्देशांक की जोड़ी लेते हैं {3, 4}, जैसे 1-आधारित।

मैंने कुछ स्पष्ट फार्मूले के साथ आने की कोशिश की। पूरे बोर्ड में सामान्य पैटर्न इस तरह दिखता है:

उन रंगों के वास्तविक मूल्य (हल्के से सबसे गहरे तक) हैं 2, 3, 4, 6, 8। अर्थात्:

2 3 4 4 4 4 3 2
3 4 6 6 6 6 4 3
4 6 8 8 8 8 6 4
4 6 8 8 8 8 6 4
4 6 8 8 8 8 6 4
4 6 8 8 8 8 6 4
3 4 6 6 6 6 4 3
2 3 4 4 4 4 3 2

हम पहले मूल को केंद्र में स्थानांतरित करके समरूपता का शोषण करते हैं, निरपेक्ष मूल्य लेते हैं और परिणाम को घटाते हैं 4। यह हमें प्रत्येक कोने से बढ़ने के 0.5लिए निर्देशांक देता है 3.5। आदेश केंद्र बनाने के लिए एक ही हम मैप करने की आवश्यकता का समन्वय करता है 0.5और 1.5विभिन्न मूल्यों के लिए और 2.5और 3.5एक ही मूल्य है। यह परिणाम 0.8( गुणा {0.4, 1.2, 2., 2.8}) से गुणा करके और परिणाम को फर्श से आसानी से किया जाता है । इसलिए अब हमने {0, 1, 2, 2}केंद्र से दूरी बना ली है। यदि हम प्रत्येक कक्ष में निर्देशांक जोड़ते हैं, तो हमें यह तालिका मिलती है:

0 1 2 2 2 2 1 0
1 2 3 3 3 3 2 1
2 3 4 4 4 4 3 2
2 3 4 4 4 4 3 2
2 3 4 4 4 4 3 2
2 3 4 4 4 4 3 2
1 2 3 3 3 3 2 1
0 1 2 2 2 2 1 0

यह सभी विभिन्न संभावित परिणामों के लिए अद्वितीय मान है, इसलिए हम बस इसे एक सूचकांक के रूप में उपयोग करते हैं 2[3,4,6,8]।

दूसरे संस्करण में हम फर्श के बजाय छत का उपयोग करते हैं। इस तरह, 2, 3और 4पहले से ही सही हैं, लेकिन हम मिल 5और 6के बजाय 6और 8, इसलिए हम स्वयं एक प्रतिस्थापन नियम के साथ उन लोगों को सही।

अंत में, तीसरे संस्करण में, हम विस्तार करते हैं 5और प्रतिपादक के माध्यम 6से 6और 8उसके बाद, एक और मंजिल ऑपरेशन के बाद।

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

मुझे बोर्ड के सामान्य पैटर्न का उपयोग करना बहुत पसंद है, बढ़िया!

— स्टारबोर्ड

6

एपीएल, 21 वर्ण

{+/,5=+/¨×⍨(⍳8 8)-⊂⍵}

अंग्रेजी में:

(⍳8 8): सभी कोशिकाओं के निर्देशांक युक्त 8x8 रैंक -2 सरणी;
+/¨×⍨(⍳8 8)-⊂⍵: बोर्ड पर हर सेल के संबंध में दिए गए सेल के यूक्लिडियन दूरी का वर्ग;
5=: 0/1 का मैट्रिक्स, जहां 1s वर्ग 5 के बराबर दूरी पर दिखाई देते हैं;
+/,: चपटे मैट्रिक्स का योग करें

टेस्ट (मूल 1 में):

    f←{+/,5=+/¨×⍨(⍳8 8)-⊂⍵}
    f¨1+(3 4)(4 6)(7 7)(1 0)
8 6 2 3

इस रूप में:

f←{+/,5=+/¨×⍨(⍳⍺)-⊂⍵}

बाएं तर्क बोर्ड के आयामों को निर्दिष्ट कर सकता है। इसलिए 8 8 fमानक वर्ग शतरंज के लिए काम करेगा। लेकिन एक बड़े और आयताकार बोर्ड पर, परीक्षण के मामले अलग परिणाम देंगे। उदाहरण के लिए, एक 12x10 बोर्ड पर:

    g←(10 12)∘f
    g¨1+(3 4)(4 6)(7 7)(1 0)
8 8 8 3

— lstefano
स्रोत

एपीएल शब्दजाल में, मैट्रिक्स 2 रैंक की एक सरणी है, कोशिकाओं की सामग्री के बारे में कुछ भी नहीं कहा गया है। वर्षों के (ab) शब्दों के उपयोग ने मुझे इसके प्रति असंवेदनशील बना दिया। मैं अधिक परंपरागत रूप से इच्छुक पाठकों के लिए विवरण को अपडेट करूंगा। धन्यवाद।

— lstefano

@Istefano "रैंक" का उपयोग "आयामों की संख्या" के रूप में एक ही दुःख से ग्रस्त लगता है :-P

— लुइस मेंडो

बेनाम: मैं हो जाएगा ... तुम सही हो! आप देख सकते हैं कि जब से मैंने रैखिक बीजगणित लिया है, तब तक यह हो गया है। मैं छोड़ देता हूं :-)

— lstefano

1

पूर्ण कार्यक्रम, 27: ≢⍸5=+/¨×⍨-∘⎕¨⍳8 8 इसे ऑनलाइन आज़माएं!

— एडम

@ एडम आप 17 मतलब

— NGN

6

जावा - 160 150 बाइट्स

int m(int r,int c){int m=0,i,j;for(i=0;i<3;i+=2)for(j=0;j<3;j+=2){m+=r+i>0&r+i<9&c+2*j>1&c+2*j<11?1:0;m+=r+2*i>1&r+2*i<11&c+j>0&c+j<9?1:0;}return m;}

Ungolfed:

public static int m(int r, int c) {
    int m=0;
    for(int i=-1;i<2;i+=2)
        for(int j=-1;j<2;j+=2){
            m += r+i>-1 && r+i<8 && c+2*j>0 && c+2*j<8 ? 1:0;
            m += r+2*i>0 && r+2*i<8 && c+j>1 && c+j<8 ? 1:0;
        }
    return m;
}

4 बाइट्स को बचाने के लिए लूप की सीमा को बदलने के अलावा ungolfed कोड समान है। प्रत्येक संभव चाल के माध्यम से पुनरावृत्ति करके और सीमा जाँच (> 0 और <8) करके काम करता है। इस तथ्य का उपयोग करता है कि ऑफ़सेट (1, 2), (2, 1), (-1, 2), (-2, 1), आदि हैं और i और j के प्रत्येक मान के लिए 2 चालों की जाँच करने में सक्षम हैं।

संपादित करें: लीक नून और u902383 द्वारा सुझावों के लिए 10 बाइट्स को बचाया गया।

— ejaszewski
स्रोत

यह भी तेज, अच्छा था!

— फरवरी

इसमें कोई त्रुटि थी, इसे ठीक कर लिया गया है।

— ejaszewski

1

int m=0,i=-1,j;कुछ बाइट्स बचाने के लिए

— Leaky Nun

1

तार्किक और बिटवाइज़ में बदलाव करें और इससे आपको अतिरिक्त 6 अक्षर हटाने होंगे

— user902383

6

सी, 44 बाइट्स

f(x,y){return "23468"[((7-x)*x+(7-y)*y)/5];}

लेकिन यह बेहतर है:

f(x,y){return "2344443234666643468888644688886446888864468888643466664323444432"[x*8+y];}

— जियाकोमो गारबेलो
स्रोत

1

गुम हो रहा है ;। संकलन नहीं होगा।

— 18

@GiacomoGarabello देखें: meta.codegolf.stackexchange.com/a/1146/55729

— जैकजैक

1

यह एक स्निपेट नहीं है, यह एक फ़ंक्शन है और यह पोस्ट कार्यों के लिए मना नहीं है। लापता अर्धविराम के लिए क्षमा करें। फिक्स्ड।

— गियाकोमो गैराबेलो

5

हास्केल, 49 48 बाइट्स

w=[0..7]
x%y=sum[1|a<-w,b<-w,(a-x)^2+(b-y)^2==5]

— डेमियन
स्रोत

1

आप [0..7]1 बाइट के लिए एक चर को बचा सकते हैं ।

— xnor

5

जावा, 81 अक्षर (113 बाइट्स)

int r(int a,int b){return "⍄䐲㑦晃䚈衤䚈衤䚈衤䚈衤㑦晃⍄䐲".codePointAt(a*2+b/4)>>(3-b%4)*4&15;}

पूरे परिणाम तालिका को यूनिकोड तालिका के रूप में एनकोड करें और फिर बिटवाइज़ ऑपरेशन करते हुए उचित बाइट्स प्राप्त करें।

आप इसे यहां ऑनलाइन देख सकते हैं: https://ideone.com/K9BojC

— cliffroot
स्रोत

3

पायथन, 94 बाइट्स

lambda x,y,a=[2,1,-1,-2,-2,-1,1,2]:list((9>x+a[i]>0)&(9>y+a[5-i]>0)for i in range(8)).count(1)

1 आधारित अनुक्रमण का उपयोग करता है।

Https://repl.it/C6gV पर डेमो ।

— चक मॉरिस
स्रोत

2

पायथ - 33 15 बाइट्स

@ आकार को आधे से कम करने के लिए @LeakyNun का धन्यवाद।

नक्शे को फिर से व्यवस्थित करना और Vशायद गोल्फ को थोड़ा दूर करना होगा।

/sM*Fm^R2-Rd8Q5

टेस्ट सूट ।

— Maltysen
स्रोत

1

यह तेज़ था, अच्छा था!

— स्टारबोर्ड

2

15 बाइट्स

— लीक नन

2

एपीएल (Dyalog यूनिकोड) , 15 बाइट्स ^SBCS

≢⍸2=|×.-∘⎕¨⍳8 8

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

— voidhawk
स्रोत

2

जे , 23 बाइट्स

1#.1#.5=[:+&*://]-/i.@8

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

लिन की पद्धति के प्रति श्रद्धांजलि, जे में परिवर्तित

— जोनाह
स्रोत

1

दरअसल, 18 बाइट्स

`;7-2km`MΣ8-:50\¬¬

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

यह उसी सूत्र को लागू करता है जिसका कई अन्य उत्तर उपयोग कर रहे हैं 50/(8-x*(7-x)//5+y*(7-y))//5)-4:। इनपुट को एक सूची के रूप में लिया गया है: [x,y](या जैसे पायथन में कोई पुनरावृत्ति शाब्दिक, (x,y)या x,y)।

स्पष्टीकरण:

`;7-2km`MΣ8-:50\¬¬
`;7-2km`M           for each value in input:
 ;7-                  make a copy, subtract from 7
    2                 push 2
     km               minimum of the three values (x, 7-x, 2)
         Σ          sum
          8-        subtract from 8
            :50\    integer divide 50 by the value
                ¬¬  subtract 2 twice

— मेगो
स्रोत

0

पर्ल 6 , 44 बाइट्स

{+grep {5==[+] $_>>²},((^8 X, ^8)XZ-(@_,))}

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

— bb94
स्रोत

नाइट ऑन द रिम ग्रिम है

परिचय

उद्देश्य

इनपुट चश्मा

आउटपुट स्पेक्स

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

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

MATL , 17 14 13 12 बाइट्स

व्याख्या

गणितज्ञ 63 43 बाइट्स

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

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

गणितज्ञ, ४४ ४० बाइट्स

एपीएल, 21 वर्ण

जावा - 160 150 बाइट्स

सी, 44 बाइट्स

हास्केल, 49 48 बाइट्स

जावा, 81 अक्षर (113 बाइट्स)

पायथन, 94 बाइट्स

पायथ - 33 15 बाइट्स

एपीएल (Dyalog यूनिकोड) , 15 बाइट्स SBCS

जे , 23 बाइट्स

दरअसल, 18 बाइट्स

पर्ल 6 , 44 बाइट्स

एपीएल (Dyalog यूनिकोड) , 15 बाइट्स ^SBCS