इष्टतम स्लाइडिंग दरवाजा चौड़ाई का पता लगाएं

Question

दरवाजों की चौड़ाई के आधार पर स्लाइडिंग दरवाजों की कीमतें अलग-अलग होती हैं। विभिन्न मूल्य इस प्रकार हैं:

• 60 - 80 सेमी: ¤150
• 81 - 100 सेमी: ¤200
• 101 - 120 सेमी: ¤220

एक कोठरी खरीदते समय आप स्पष्ट रूप से लागत को कम करना चाहते हैं, इसलिए आपका काम उन दरवाजों की चौड़ाई का पता लगाना है जो कोठरी की कुल चौड़ाई के आधार पर कुल लागत को कम करता है।

नियम:

• कुल चौड़ाई इनपुट के रूप में ली जाएगी
• सभी दरवाजों की चौड़ाई समान होगी
• सबसे छोटे दरवाजे चुनें यदि दो प्रकार के दरवाजों की कीमत समान है
• चौड़ाई सेंटीमीटर में हैं, पूर्णांक नहीं दशमलव
  • गोल गोल दशमलव
• मूल्य पूर्णांक के रूप में लौटाया जाएगा (मुद्रा चिह्न की कोई आवश्यकता नहीं)
• इनपुट और आउटपुट प्रारूप वैकल्पिक हैं, लेकिन आउटपुट का क्रम होना चाहिए Number of doors, Width, Price:।
• इनपुट रेंज में होगा [120 1000)।

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

उदाहरण:

Input: 156
Output: 2, 78, 300

Input: 331
Output: 3, 111, 660

Input: 420
Output: 4, 105, 880

Comments

चौड़ाई 201एक दिलचस्प परीक्षण मामला है ...

— AdmBorkBork

सरकाने वाला दरवाजा? स्पष्ट रूप से हर दरवाजे को एक @ डॉर्कनब की जरूरत है।

— एलेक्स ए।

Answer 1

05AB1E , 47 बाइट्स

कोड:

D120/ó>DU=/ó>=D101›iX220*=q}D80›iX200*=q}X150*=

सबसे अच्छा प्रस्तुत नहीं है, लेकिन कम से कम कुछ :)

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

Comments

TIO में 333 डालने से [3, 112, 660] का आउटपुट मिलता है जब (afaik) आउटपुट [3, 111, 660] होना चाहिए क्योंकि 3 * 111 पूरी तरह से 333 के बराबर होता है

— Helen

201 [2, 101, 440] के बजाय 201 [2, 101, 400] देने के साथ इसी तरह की समस्या

— Helen

Answer 2

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

t=>[[80,150],[100,200],[120,220]].map(([w,p])=>[n=-~(~-t/w),-~(~-t/n),n*p]).sort((a,b)=>a[2]-b[2])[0]

-~(~-a/b) 31-बिट पूर्णांकों में Math.ceil (a / b) के समान है।

Answer 3

पर्ल, 190 180 154 133 128 117 बाइट्स

के लिए +1 शामिल है -p

use POSIX;$m=1E4;for$q(80,100,120){($m,@z)=($p,$n,ceil$_/$n)if$m>($p=(150,200,220)[$x++]*($n=ceil$_/$q))}$_="@z $m"

टिप्पणी की:

use POSIX;                                  # for ceil()
$m = 1E4;                                   # init min price to 10k
for $q (80,100,120) {                       # iterate widths
    ($m,@z) = ($p,$n, ceil $_/$n)           # update min, output
    if $m > (                               #
       $p = (150,200,220)[$x++]             # grab price
          * ( $n = ceil $_/$q )             # times nr of doors needed
    )
}
$_="@z $m"

---

• हैश को दो ऐरे में विभाजित और विभाजित करके 11 बाइट्स बचाएं

• उपयोग करके 5 बाइट्स बचाएं -p(@ देव-नल को धन्यवाद)

• POSIX का उपयोग करके 18 बाइट्स बचाएं :: हैश के लिए सूची सिंटैक्स का उपयोग करके और अधिक 3 (@ msh210 के लिए धन्यवाद)

Comments

से छोटा sub r{$a=$_[0];~~$a==$a?$a:1+~~$a}है sub r{use POSIX;ceil pop}।

— msh210

से छोटा (80=>150,100=>200,120=>220)है (80,150,100,200,120,220)।

— msh210

क्या यह बहुत विस्तृत दरवाजे के लिए काम करता है (जहां कीमत 10_000 से अधिक है)?

— msh210

@ msh210 सुझावों के लिए धन्यवाद, मैं उन्हें शामिल करूँगा! नहीं, यह केवल प्रश्न में निर्दिष्ट सीमा के लिए काम करता है [120-1000), लेकिन व्यक्ति हमेशा के लिए बदल सकता 1E4है 1E9...

— केनी

ओह, मैंने ध्यान नहीं दिया कि प्रश्न ने एक सीमा निर्दिष्ट की थी।

— msh210

Answer 4

पॉवरशेल, 137 135 बाइट्स

param($a)$j=9e9;60..120|%{if((($c=[math]::ceiling($a/$_))*($p=(220,(200,150)[$_-le80])[$_-le100]))-lt$j){$j=($k=$c)*$p;$i=$_}}
$k;$i;$j

आउटपुट न्यूलाइन-सेपरेटेड है।

हम इनपुट लेते हैं $a, अपनी लागत $jको निर्धारित करते हैं 9000000000(एक बड़ी संख्या जो कि कभी भी हमारी आवश्यकता से अधिक है)। अगला, हम 60..120साथ से लूप करते हैं |%{...}। प्रत्येक पुनरावृत्ति हम छद्म-तिर्यक कथन के$p साथ वर्तमान वस्तु की कीमत की गणना करते हैं, फिर छत की गणना करते हैं । यदि वर्तमान कुल हमारे द्वारा देखे गए सबसे छोटे से छोटा है ( ), इन सभी चर को बचाएं: (कुल), (आवश्यक दरवाजों की संख्या), और (दरवाजे की चौड़ाई), और लूप जारी रखें। एक बार लूप समाप्त हो जाने के बाद, बस सबसे अच्छे मूल्यों का उत्पादन करें।$c$a/$_$j$j$k$i

_{संपादित करें - सशर्त में $cऔर $pअसाइनमेंट को स्थानांतरित करके दो बाइट्स सहेजे गएif}

Answer 5

पायथ, 65 बाइट्स

ho+eNcehNTm[d*hd?>81ed150?<101ed220 200)f}eTr60 121m[d.EcQd)r2 17

यहाँ यह कोशिश करो!

व्याख्या

सबसे पहले यह सभी संभावित डोर काउंट / डोर चौड़ाई संयोजनों की सूची तैयार करता है और उन सभी संयोजनों की कीमत की गणना करता है। फिर हमें केवल कीमत और दरवाजे की चौड़ाई के आधार पर ऑर्डर करना होगा और परिणामी सूची का पहला तत्व लेना होगा।

कोड स्पष्टीकरण निम्नानुसार है क्योंकि मैंने इसे नीचे गिरा दिया है कृपया मुझे गोल्फ में मदद करें, यह बहुत लंबा है।

हो + eNcehNTm [d * hd?> 81ed150; <101ed220 200) f} eTr60 121m [d.EcQd) r2 17 # Q = इनपुट

                                                   m r2 17 # मैप रेंज (2,17) से
                                                    [डी) # सूची पहले दरवाजे की गिनती के साथ
                                                      .EcQd # और चौड़ाई दूसरी
                                        एफ # टी के साथ फिल्टर नक्शा परिणाम
                                         } r60 121 # रेंज में (60,121)
                                          ईटी # दरवाजा चौड़ाई
          एम # मानचित्र फ़िल्टर परिणाम d के साथ
           [डी) # पहले सूची और चौड़ाई के साथ एक सूची के लिए
             * HD # मल्टी डोर काउंट के साथ
                ?> 81ed150? <101ed220 200 # मूल्य प्रति दरवाजा, टर्नरीज़ के साथ सरल लुक
 ओ # क्रम मानचित्र एन के साथ परिणाम
  + eNcehNT # आदेश कुंजी = मूल्य + चौड़ाई / 10
h # पहला तत्व सबसे अच्छा है

Answer 6

जावास्क्रिप्ट (ईएस 6) 96

n=>[80,100,120].map((d,i)=>[d=-~(~-n/d),-~(~-n/d),d*[150,200,220][i]]).sort((a,b)=>a[2]-b[2])[0]

जैसा कि @Neil ने नोट किया है, =-~(~-n/d)32 बिट या उससे कम के पूर्णांक के लिए राउंडिंग के साथ विभाजन के बराबर है।

Answer 7

आर , 135 104 बाइट्स

"!"=utf8ToInt;cbind(n<-16:1,w<-ceiling(scan()/n),p<-n*approx(!"<Qex",!"–ÈÜÜ",w,"c")$y)[order(p)[1],]

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

31 बाइट्स से बचाता है

• डिकम्प्रेसिंग संख्या
• का उपयोग करते हुए utf8ToInt
• "!" फ़ंक्शन कॉल को छोटा करने के लिए
• सदिश कार्यों का उपयोग करना
• कुल लंबाई को परिभाषित नहीं करना
• cbindचर को परिभाषित करने के बजाय सीधे उपयोग करना

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

1. approxअपनी लंबाई के आधार पर एकल दरवाजे की कीमत देता है। यह NAसीमा के बाहर लौटता है [60,120]।
2. कल्पना के आधार पर, दरवाजों की कुल संख्या 16 (कुल लंबाई 1000) से अधिक नहीं हो सकती है। 16 से 1 तक सभी दरवाजों की जांच की जाती है, और ट्रिपलेट (number of doors, door width, total price)को लौटा दिया जाता है।
3. orderसमारोह न्यूनतम मूल्य का पता लगाने का प्रयोग किया जाता है; इसके आधार पर सही ट्रिपल निकाला जाता है। संबंधों के मामले में, order पहले आने वाली प्रविष्टि को वापस कर देगा, और चूंकि हमने 16 से 1 तक दरवाजे की सबसे बड़ी संख्या (छोटे दरवाजे की चौड़ाई) को लूप किया है।

Comments

का उपयोग करना stepfunअधिक लंबा है - क्योंकि किसी को बाहर की चौड़ाई को हटाने की आवश्यकता होती है [60,120]।

— JayCe