गोल्फ एक गोल्फ चार्ट
एक पूर्णांक के रूप में मीटर में एक दूरी को देखते हुए \$60\le d \le 260\$, उन क्लबों की संख्या लौटाएं, जिनका उपयोग निम्नलिखित मनमाने चार्ट के अनुसार किया जा सकता है, जहां दोनों \ _$min\$और \$max\$ समावेशी हैं:
club | min | max
----------------+-----+-----
Driver | 200 | 260
3-wood | 180 | 235
5-wood | 170 | 210
3-iron | 160 | 200
4-iron | 150 | 185
5-iron | 140 | 170
6-iron | 130 | 160
7-iron | 120 | 150
8-iron | 110 | 140
9-iron | 95 | 130
Pitching Wedge | 80 | 115
Sand Wedge | 60 | 90
टिप्पणियाँ
क्लब के नाम केवल जानकारी के लिए दिए गए हैं।
बेशक, क्लब का विकल्प कई अन्य मापदंडों पर निर्भर करता है। उदाहरण के लिए सैंड वेज को रेत के बंकर से भागने के लिए डिज़ाइन किया गया है। लेकिन इस चुनौती के प्रयोजनों के लिए, केवल दूरी मायने रखती है।
यह निस्संदेह एक कोड-गोल्फ चुनौती है।
उदाहरण
के लिए \$d=130\$, हम 6-लोहा , 7-लोहा , 8-लोहा या 9-लोहा चुन सकते हैं , इसलिए अपेक्षित उत्तर \ _ है$4\$।
परीक्षण के मामलों
Input Output
60 1
79 1
80 2
93 1
105 2
110 3
116 2
129 3
130 4
200 4
201 3
235 2
260 1
या सूची के रूप में:
Input : 60, 79, 80, 93, 105, 110, 116, 129, 130, 200, 201, 235, 260
Output: 1, 1, 2, 1, 2, 3, 2, 3, 4, 4, 3, 2, 1
जवाब
x86-16 मशीन कोड, 47 42 बाइट्स
00000000: be14 01b3 01b1 0bad 3ad0 7205 3ad4 7701 ........:.r.:.w.
00000010: 43e2 f4c3 505a 5feb 6e73 78d2 8282 8c8c C...PZ_.nsx.....
00000020: 9696 a0a0 aaaa b4b9 c8c8 ..........
लिस्टिंग:
BE 0114 MOV SI, OFFSET CHART ; SI point to distance chart
B3 01 MOV BL, 1 ; start counter at 1
B1 0B MOV CL, 11 ; loop 11 clubs
SCORE_LOOP:
AD LODSW ; load AL = min, AH = max
3A D0 CMP DL, AL ; is d less than min?
72 05 JB DONE ; if so, continue
3A D4 CMP DL, AH ; is d greater than max?
77 01 JA DONE ; if so, continue
43 INC BX ; otherwise increment counter
DONE:
E2 F4 LOOP SCORE_LOOP ; loop through end of chart
C3 RET ; return to caller
CHART DB 80,90,95,235,110,115,120,210,130,130,140,140
DB 150,150,160,160,170,170,180,185,200,200
कॉल करने योग्य फ़ंक्शन, इनपुट dइन DX, आउटपुट इन BL।
कोई संपीड़न (डेटा केवल है 24 वैसे भी बाइनरी में 22 बाइट्स) सिर्फ एक टेबल तुलना।
संपादित करें: @SE को भारी सहारा - सूची को फिर से व्यवस्थित करने और dमूल्य को ऑफसेट करने की आवश्यकता को समाप्त करने के लिए अच्छे लोगों को फायर करना बंद करो , 5 बाइट्स की बचत !
टेस्ट कार्यक्रम चलता है:
वैकल्पिक संस्करण, 50 बाइट्स
BB 0501 MOV BX, 0501H ; init counter to 1 in BL and
BF 556D MOV DI, 0556DH ; magic number to 0x5556D in BH:DI
BE 011C MOV SI, OFFSET CHART ; SI point to transition table
B1 16 MOV CL, 22 ; loop 22 transitions
SCORE_LOOP:
AC LODSB ; load AL = next transition
3A C2 CMP AL, DL ; is d less than?
77 0B JA EXIT ; if not, end
D0 EF SHR BH, 1 ; cascade bit shift high word into CF
D1 DF RCR DI, 1 ; bit shift lsb into CF
43 INC BX ; increment counter
72 02 JC NEXT ; if CF was a 1, continue to next
4B DEC BX ; otherwise subtract 2
4B DEC BX
NEXT:
E2 F0 LOOP SCORE_LOOP ; keep looping
EXIT:
C3 RET
CHART DB 80,91,95,110,116,120,130,131,140,141,150,151,160,161,170,171,180,186,200,201,211,236
यह जोनाथन एलन के जवाब से काफी प्रेरित है । इस के मानों की तालिका का उपयोग करता है dजहां क्लब संक्रमण या तो की संख्या +1या -1, और एक इसी बाइनरी जादुई संख्या के 0x5556dलिए जहां एक 1एक सकारात्मक बदलाव को इंगित करता है और 0एक नकारात्मक परिवर्तन का संकेत है।
दुर्भाग्य से, यह यहाँ बहुत मदद नहीं करता है क्योंकि मूल तालिका एन्कोडिंग है 24 बाइट्स बनाम 22 संक्रमणों के साथ साथ 3 बाइट मैजिक नंबर तो वास्तव में बड़ा है। हालांकि यह मजेदार था!
पायथन 3 , 71 बाइट्स
lambda n:sum(a<=n/5<=b for a,b in zip(b'($" ',b'4/*(%" '))
इसे ऑनलाइन आज़माएं!
बाइट स्ट्रिंग्स में कुछ unprintables होते हैं, उनका बचा हुआ रूप है b'($" \x1e\x1c\x1a\x18\x16\x13\x10\x0c'और b'4/*(%" \x1e\x1c\x1a\x17\x12'।
पायथन 3 , 71 बाइट्स
lambda n:sum(b>n-a*5>-1for a,b in zip(b'($" ',b'=8))$ $$ '))
इसे ऑनलाइन आज़माएं!
पायथन 3.8 , 90 86 बाइट्स
lambda x:-~sum([79<x<91,94<x<236,-1<(a:=x-110)<6,9<a<101,69<a<76,a/10in{2,3,4,5,6,9}])
इसे ऑनलाइन आज़माएं!
अंतिम स्थिति को भी a%10<1<a/10<7,a==90समान लंबाई में लिखा जा सकता है ।
जेली , 25 बाइट्स
“Ḳœẹ“rɓ?’ḃ5×5“ZO‘;"Ä⁸>§I‘
एक पूर्ण कार्यक्रम जो परिणाम को प्रिंट करता है (या एक एकल लिंक जो एकल-तत्व सूची देता है)।
इसे ऑनलाइन आज़माएं! या परीक्षण-सूट देखें ।
कैसे?
किसी भी मान्य इनपुट के लिए, में \$[60,260]\$हम कम से कम एक क्लब का उपयोग करने में सक्षम हैं। किसी भी दिए गए यार्डेज के लिए, में \$[61,260]\$, हम या तो एक ही, एक और, या एक कम क्लब का उपयोग करने में सक्षम हैं, जो हम एक यार्ड कम के लिए कर सकते हैं। नीचे दिए गए कोड में यार्डों को एन्कोड किया गया है, जिस पर उपलब्ध क्लबों की संख्या बढ़ती है, और जिन पर उपलब्ध क्लबों की संख्या नीचे जाती है और परिणाम की गणना करने के लिए इसका उपयोग करता है।
“Ḳœẹ“rɓ?’ḃ5×5“ZO‘;"Ä⁸>§I‘ - Main Link: integer, Y e.g. 129
“Ḳœẹ“rɓ?’ - list of (two) base-250 integers = [11132965,7226564]
ḃ5 - convert to bijective base five -> [[5,3,2,2,2,2,3,3,2,5],[3,3,2,2,2,2,2,2,2,4]]
×5 - multiply by five -> [[25,15,10,10,10,10,15,15,10,25],[15,15,10,10,10,10,10,10,10,20]]
“ZO‘ - list of code-page indices = [90,79]
" - zip with:
; - concatenation -> [[90,25,15,10,10,10,10,15,15,10,25],[79,15,15,10,10,10,10,10,10,10,20]]
Ä - Cumulative values -> [[90,115,130,140,150,160,170,185,200,210,235],[79,94,109,119,129,139,149,159,169,179,199]]
⁸> - is Y greater than (those)? -> [[1,1,0,0,0,0,0,0,0,0,0],[1,1,1,1,0,0,0,0,0,0,0]]
§ - sums -> [2,4]
I - deltas -> [2]
‘ - increment -> [3]
- implicit print -> "3"
जे , 63 58 55 50 बाइट्स
1#.1=(59 90+/\@,|:5*2+4#.inv 2424834 3408207)I."1]
इसे ऑनलाइन आज़माएं!
-5 बाइट्स एक्सश के लिए धन्यवाद
आधार 4 में संख्याओं के रूप में सूचियों को एनकोड करता है, पुनर्निर्माण करता है, फिर अंतराल सूचकांक का उपयोग I.करके गणना करता है कि इनपुट कितने रेंज में आता है।
आर , 77 76 72 बाइट्स
संपादित करें: -4 बाइट्स रॉबिन राइडर को धन्यवाद
sum((d=scan()/10-9)>=c(11,9:2,.5,-1,d)&d<=c(d,14.5,12,11,9.5,8:4,2.5,0))
इसे ऑनलाइन आज़माएं!
बहुत अच्छा समाधान, लेकिन आर के स्वचालित वैश्वीकरण और इसके :अनुक्रम ऑपरेटर से लाभ।
पायथन 3 , 180 155 153 97 88 बाइट्स
lambda n:sum(a<=chr(n)<b for a,b in zip('<P_nx ª´È','[t¡«ºÉÓìą'))
इसे ऑनलाइन आज़माएं!
के (ओके) , 85 82 बाइट्स
समाधान:
{+/z=x|y&z}.(-3 -1 .5 2 3 4 5 6 7 8 9 11;0 2.5 4 5 6 7 8 9.5 11 12 14.5 17),-9+.1*
इसे ऑनलाइन आज़माएं!
स्पष्टीकरण:
निश्चित रूप से भोला; अत्यधिक संभावना है कि यह एक बुरा दृष्टिकोण है। हालांकि तुलना तर्क को आसान बनाने के लिए ngn द्वारा अच्छा गोल्फ! ।
{+/z=x|y&z}.(-3 -1 .5 2 3 4 5 6 7 8 9 11;0 2.5 4 5 6 7 8 9.5 11 12 14.5 17),-9+.1* / the solution
.1* / multiply input by 0.1
-9+ / subtract 9 from input
, / append to
(-3 -1 .5 2 3 4 5 6 7 8 9 11;0 2.5 4 5 6 7 8 9.5 11 12 14.5 17) / club stats
{ }. / call lambda with multiple args
y&z / min of input and min distance
x| / max compared to max distance
z= / is input the same?
+/ / sum up
अतिरिक्त:
- -3 बाइट्स के लिए धन्यवाद
ngn
पायथन 3 , 105 बाइट्स
lambda n,a=[1],b=[2],c=[3],d=[4]:(a*20+b*11+a*4+b*15+c*6+b*4+c+(c*9+d)*6+d*5+c*14+d+c*10+b*25+a*25)[n-60]
इसे ऑनलाइन आज़माएं!
स्पष्टीकरण: उत्तरों की सूची को संग्रहीत करने और आवश्यक सूचकांक को प्रिंट करने के लिए एक सरल जानवर।
चारकोल , 44 बाइट्स
ＮθＩΣＥ¹²⁻›θ⁺⁵⁹×⁵Σ…”)⊞⊟‹Ｇ↔”ι›θ⁺⁹⁰×⁵Σ…”)⊟+.Ｄ↥”ι
इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। पोर्ट ऑफ @ जोनाथन एलेन का जवाब। स्पष्टीकरण:
Ｎθ
इनपुट d।
ＩΣＥ¹²⁻
12 क्लबों में मैप करें और बीच के अंतर को लेने के लिए डाले गए परिणामों का योग प्रिंट करें ...
›θ⁺⁵⁹×⁵Σ…”)⊞⊟‹Ｇ↔”ι
... के dसाथ तुलना में 59जोड़ा गया 5समय के डिजिटल योग के उपसर्ग स्ट्रिंग 43322222224, और ...
›θ⁺⁹⁰×⁵Σ…”)⊟+.Ｄ↥”ι
... dतुलना के साथ 90करने के लिए जोड़ा 5बार संकुचित का प्रीफ़िक्स के डिजिटल राशि 53222233235।
पिछला 48-बाइट उत्तर:
ＮθＩΣＥＩ⪪”)¶∧!✂η}⌊⍘⪫⪫⊕#<e⌊W[qＹ9¤…”²∧›θ⁻×⁵ι﹪κ²⊖⊗﹪κ²
इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण: 12 क्लबों की समाप्ति और आरंभिक दूरी पूर्णांकों के एक संकुचित तार से 12 से 52 तक विभाजित होती हैं, जिन्हें 5. dसे गुणा किया जाता है, उन सभी के खिलाफ तुलना की जाती है, 1विषम स्थितियों में अधिक या समान दूरी के लिए स्कोरिंग और -1यहां तक कि अधिक दूरी के लिए। पदों और अंतिम कुल मुद्रित किया जाता है।
पायथन 3 ,
62
60 बाइट्स
lambda d:sum(b//25<=b%25+23-d/5<=7for b in b'BUNSWYQ+-}')+1
इसे ऑनलाइन आज़माएं!
\x18स्ट्रिंग के अंत में एक अदृश्य (स्टैक एक्सचेंज पर) चरित्र है।
मुझे लगता है कि अधिकांश गैर-esolangs में अधिक आक्रामक संपीड़न अनुपात प्राप्त करना संभव है।
थोड़ा प्रोत्साहन के रूप में, यहां पायथन और नोड में मेरे अपने स्कोर हैं।
मैं दोनों कोड स्निपेट नीचे अनावरण करूंगा जैसे ही एक छोटा या समान रूप से लंबा उत्तर दोनों भाषा में (या अद्यतन) पोस्ट किया जाता है, या 2PM UTC में शुक्रवार 21 अगस्त, 2020 को अप्रत्याशित घटना में होता है कि तब तक ऐसा कोई भी उत्तर प्रकाशित नहीं होता है।
EDIT (2020-08-19): 70 बाइट्स के नीचे पायथन जवाब देने वाले पहले व्यक्ति के रूप में @flornquake को बधाई , एक खदान के समान एक विचार का उपयोग करके, लेकिन कुल 62 बाइट्स के लिए एक कदम आगे बढ़ाते हुए!
पायथन 3.8 (पूर्व-रिलीज़) , 70 बाइट्स
lambda d,n=12:sum((n:=n+x//8-4)<=d/5<=n+x%8+6for x in b' A980001225F')
इसे ऑनलाइन आज़माएं!
जावास्क्रिप्ट (Node.js) , 74 बाइट्स
d=>Buffer(' A980001225F').map(x=>t-=d/5<(n+=x-32>>3)|d/5>n+x%8+6,n=t=12)|t
इसे ऑनलाइन आज़माएं!
पर्ल 5 , 70 बाइट्स
स्ट्रिंग में पहला बाइट \x##आसान परीक्षण के लिए अंकन में जोड़ा गया है, लेकिन एक शाब्दिक बाइट है।
$_=grep"@F">=($k+=(ord>>4)*5)&"@F"<=$k+(15&ord)*5,"\xc6G76&&&'((+L"=~/./g
प्रत्येक क्लब के लिए विवरणों को संग्रहीत करता है (5 से विभाजित) एक बाइट के रूप में जहां पहले चार बिट्स पिछले रेंज की शुरुआत और इस एक की शुरुआत से अंतर होते हैं, और दूसरे चार बिट्स इस रेंज की शुरुआत के बीच का अंतर हैं और समाप्त।
start end => / 5 => binary #
--------------------------------------------
60 90 => 12 6 => 11000110 # counter starts at 0
80 115 => 4 7 => 00100100 # counter is 12 from before so we only need an extra 4
95 130 => 3 7 => 00110111
110 140 => 3 6 => 00110110
इसे ऑनलाइन आज़माएं!
सी (जीसीसी) , 83 75 बाइट्स
(स्टैक एक्सचेंज पर सभी वर्ण सही नहीं दिखते, लेकिन TIO में सही हैं)
*i;c;f(d){c=0;for(i=L"ÈĄ´ëªÒ ȹª xn_Ps<Z";*i;c+=d/ *i++&*i++/d);d=c;}
इसे ऑनलाइन आज़माएं!
आईओ , 89 बाइट्स
method(a," \"$("asList select(i,v,v at(0)<=a/5and a/5<=" \"%(*/4"at(i))size)
इसे ऑनलाइन आज़माएं!
पायथ , 36 बाइट्स
s/RC-QTrV"2FUdnx ª¾""Qjy¡°¿Éâû
इसे ऑनलाइन आज़माएं!
व्याख्या
"... # String literal with end of ranges minus 10 as characters
"..." # String literal with start of ranges minus 10 as characters
rV # Generate the ranges
/R # Count occurrences of
C-QT # input minus 10 converted to a characters (based on ascii value)
# in each of the ranges
s # sum
जावास्क्रिप्ट (V8) , 142 132 117 113 बाइट्स
-10 बाइट्स: -9 रेंज और इनपुट के बाद डिवीजन के बाद लागू किए गए केवल 10 से विभाजित करने के बजाय (अन्य उत्तरों से प्रेरित, समझे कि यह मेरी श्रेणी / 10 संख्याओं को देखने के बाद क्यों लायक था)
-15 बाइट्स अर्नुल्ड के सुधार के लिए धन्यवाद
-5 बाइट्स शैगी के और सुधार के लिए धन्यवाद
d=>[11,17,9,14.5,8,12,7,11,6,9.5,...'58473625',.5,4,-1,2.5,-3,t=0].map((e,i,r)=>t+=++i%2&d>=e&d<=r[i],d=d/10-9)|t
इसे ऑनलाइन आज़माएं!
सुंदर अनुभवहीन समाधान लेकिन मैं अन्य उत्तरों में उपयोग किए गए अधिक जटिल तरीकों का प्रयास करने में सहज नहीं था (उल्लेख नहीं करने के लिए कि मुझे यकीन नहीं है कि वे जेएस में गोल्फिंग के साथ भी संभव हैं!)। मैं खुशी से सलाह / सुधार करूँगा, हालाँकि।
अनमनीकृत और समझाया गया (थोड़ा पुराना है लेकिन फिर भी समग्र प्रक्रिया की व्याख्या करता है):
f = (distance) => {
// divide input by 10 and subtract 9 since the hardcoded ranges are shorter when those operations are done.
distance = distance / 10 - 9
// hardcoded ranges divided by 10 then subtracted 9 to save bytes (probably can be done better).
// Will be used in pairs, only processing even indexes and using i & i+1
//ranges = [20,26,18,23.5,17,21,16,20,15,18.5,14,17,13,16,12,15,11,14,9.5,13,8,11.5,6,9] // /10
//ranges = [14,20,12,17.5,11,15,10,14,9,12.5,8,11,7,10,6,9,5,8,3.5,7,2,5.5,0,3] // /10 -6
ranges = [11,17,9,14.5,8,12,7,11,6,9.5,5,8,4,7,3,6,2,5,0.5,4,-1,2.5,-3,0] // /10 -9 (winner! inspired by other answers)
// .map used as .reduce
ranges.map((e, i)=> { // e: current element, i: current index
totalValidClubs += ( // increment total 'valid' counter if within range
i%2 == 1 ? 0 : // skip odd indexes, will use i & i+1 on even indexes only
distance>=e && distance<=ranges[i+1] ? 1 : 0) // if even index and distance is between ranges[i] & [i+1] (inclusive), increment by 1.
}, totalValidClubs=0); // initialize valid club counter as 0
return totalValidClubs;
}
05AB1E , 38 36 बाइट्स
38 बाइट्स
"ÈĄ´ëªÒ È–¹Œª‚ x–nŒ_‚Ps<Z"Ç2ôε.SOÄ2‹}O
मैं कंप्रेस करने में बुरा हूं :( सबसे अच्छा मैं सोच सकता था कि प्रत्येक संख्या को ASCII वर्ण में परिवर्तित करना है।
स्पष्टीकरण:
"ÈĄ´ëªÒ È–¹Œª‚ x–nŒ_‚Ps<Z"Ç2ôε.SOÄ2‹}O
"ÈĄ´ëªÒ È–¹Œª‚ x–nŒ_‚Ps<Z" Ranges of clubs as ASCII chars
Ç Convert to values
2ô Split into chunks of two
ε } Map on pairs
.S -1 if lower than input, 1 if greater, 0 it equal
O Sum the result of the pair
Ä Absolute value
2‹ Is it lower than 2? (The only cases the absolute value is 2 are when the input is out of range)
O Now we have list of 0 and 1 for each range. Sum it up :)
इसे ऑनलाइन आज़माएं!
36 बाइट्स (@ovs के लिए धन्यवाद)
"ÈĄ´ëªÒ ȹª xn_Ps<Z"Ç2ôε-P(d}O
-P(dअंदर के नक्शे का उपयोग करना , जो इनपुट के साथ जोड़ी को घटाएगा, इसे उत्पाद करें (रेंज मानों में से सकारात्मक होगा), फिर लागू negativeकरें (और जांचें कि क्या मान गैर-नकारात्मक उपयोग कर रहा है d।
इसे ऑनलाइन आज़माएं!
> <> , 51 बाइट्स
"Çɳº©«Ÿ¡•—‹ƒwÓmt^ìO["1&{:})${:}(*&+&55*0l3)?.&n;
(इसमें 7 अप्रतिबंध शामिल हैं)
इसे ऑनलाइन आज़माएं!
चूंकि हर इनपुट के लिए कम से कम 1 क्लब है, इसलिए एक सीमा से छुटकारा पाने के लिए कोई भी श्रेणी को फिर से व्यवस्थित कर सकता है, जिसमें "260" भाग को हटाने का अतिरिक्त लाभ होता है जो कि बाइट की सीमा के बाहर मुश्किल से होता है।
डेसमोस , 106 बाइट्स:
f(d)=total(\left\{join([18...11],[9.5,8,6,20])*10<=d<=[47,42,40,37,34,32,30,28,26,23,18,52]*5:1,0\right\})
ऑनलाइन ग्राफ देखें
f(d)=यदि आप स्लाइडर को इनपुट के रूप में उपयोग कर रहे हैं तो 5 बाइट हटाएं और घटाएं।
APL, 52 45 50 बाइट्स:
{+⌿1=(↓12 2⍴⎕ucs'Èą´ìªÓ ɺ«¡xn_Pt<[')∘.⍸⍵}
इसे ऑनलाइन आज़माएं!