टॉयलेट पेपर के रहस्य

Question

आज आपको एक बहुत ही व्यावहारिक समस्या को हल करने की आवश्यकता है: आपके टॉयलेट पेपर रोल पर एक निश्चित संख्या में चादरें होने के लिए आपको कितने लूप की आवश्यकता है? आइए कुछ तथ्यों को देखें:

• एक नंगे टॉयलेट पेपर सिलेंडर का व्यास 3.8 सेमी है
• टॉयलेट पेपर की एक शीट की लंबाई 10 सेमी है।
• टॉयलेट पेपर की एक शीट की मोटाई 1 मिमी है।

इससे पहले कि आप पहली बार सिलेंडर के चारों ओर लपेटें, इसमें 3.8 * pi के सेमी की परिधि है। हर बार जब आप सिलेंडर के चारों ओर एक चादर लपेटते हैं, तो इसकी त्रिज्या 1 से बढ़ जाती है, इसलिए इसकी परिधि 2 * PI बढ़ जाती है। इस जानकारी का उपयोग यह जानने के लिए करें कि टॉयलेट पेपर की एन शीट को फिट करने के लिए कितने लूप हैं । (नोट: पाई के एक सन्निकटन का उपयोग करें जो कम से कम 3.14159 के रूप में सटीक है)।

परीक्षण के मामले :

n = 1 :

• 10 / (3.8 * पीआई) = .838 लूप

n = 2 :

• (हम कितने पूर्ण लूप बना सकते हैं?) 1 पूर्ण लूप = 3.8 * पाई = 11.938।
• (1 लूप के बाद हमने कितना छोड़ा है?) 20 - 11.938 = 8.062
• (शेष लूप का कितना हिस्सा शेष है?) 8.062 / (4 * pi) = .642 लूप
• उत्तर: 1.642 छोरों

n = 3 :

• पहला पूर्ण लूप = 3.8 * pi = 11.938, दूसरा पूर्ण लूप = 4 * pi = 12.566
• 30 - 11.938 - 12.566 = 5.496
• ५.४ ९ ६ / (४.२ * पी) = ४१ 4.2
• उत्तर: 2.417 छोरों

n = 100 => 40.874

Comments

ओह! 1 मिमी मोटी? क्या आप वाकई टॉयलेट पेपर का उपयोग कर रहे हैं और कार्डबोर्ड का नहीं?

— डिजिटल ट्रॉमा

@DigitalTrauma स्पष्ट रूप से आप ट्रिपल-प्लाई के बारे में नहीं जानते: p

— geokavel

इस धारणा के तहत कि टॉयलेट पेपर कदम नहीं बनाता है, लेकिन लगातार त्रिज्या बढ़ जाती है, आप अनुरोधित परिणाम के लिए एक बंद प्रपत्र सन्निकटन प्राप्त कर सकते हैं। क्या यह काफी अच्छा है? nloops = sqrt(n+11.34)*0.0564189 - 0.19

— रात १३:०१

प्रस्तावित परीक्षण मामला: 100->40.874

— डेनिस

ट्रिपल-प्लाई कार्डबोर्ड ?! अब यह मोटी है!

— mbomb007

Answer 1

पायथ, 27 23 बाइट्स

+fg0=-QJc*.n0+18T50)cQJ

इसे ऑनलाइन आज़माएं। परीक्षण सूट।

व्याख्या

                            Q = input number (implicit)
 f                 )        increment T from 1, for each T:
             +18T             add 18 to T, get radius
         *.n0                 multiply by pi to, get half the circumference
        c        50           divide by 50, get circumference in sheets
       J                      save it to J
    =-Q                       decrement Q by it
  g0                          use this T if Q is now <= 0
+                           add
                     Q        Q (now <= 0)
                    c J       divided by J (the last circumference)
                            and print (implicit)

Comments

स्पष्टीकरण, कृपया?

— कॉनर ओ'ब्रायन

@ C @O'Bʀɪᴇɴ जोड़ा गया। पाइथ की व्याख्या करना हमेशा इतना मजेदार होता है।

— पुरकाकूदरी

आपका स्पष्टीकरण सर्फिन वर्ड के

— जियोकॉवेल

Answer 2

हास्केल, 59 46 44 बाइट्स

5 / पीआई का एक स्केल फैक्टर लागू किया जाता है, ताकि एक पेपर सिलेंडर में 19,20,21 ... सेमी की परिधि हो और एक शीट 50 / पीआई सेमी हो।

अनाम फ़ंक्शन का उपयोग करके, xnor के लिए 2 बाइट्स सहेजे गए।

x!s|s>x=1+(x+1)!(s-x)|1>0=s/x
(19!).(50/pi*)

Comments

एक सुंदर पुनरावर्ती विधि। ध्यान दें कि अनाम पंक्तियों को तब भी अनुमति दी जाती है जब आपके पास अन्य लाइनें हों (हास्केल इसका समर्थन नहीं कर रही है), इसलिए अंतिम पंक्ति को बिंदुवार कहा जा सकता है (19!).(50/pi*)।

— xnor

वाह, मेरे दृष्टिकोण को पानी से निकाल दिया!

— CR Drost

Answer 3

जेली , 29 27 26 बाइट्स

R+18×3.6°µ0;+\³_÷µḞi0©ị+®’

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

Answer 4

हास्केल, 97 बाइट्स

p&((m,x):(n,y):z)|y<p=p&((n,y):z)|1>0=m+(p-x)/(y-x)
t=(&zip[0..](scanl(+)0$map(*pi)[0.38,0.4..]))

हो सकता है कि &ऑपरेटर से फ़िल्टरिंग को एक takeWhileबयान में स्थानांतरित करके इसे और आगे बढ़ाया जा सके , लेकिन यह देखते हुए कि यह एक गोल्फिंग भाषा नहीं है, यह अपेक्षाकृत प्रतिस्पर्धी लगता है।

व्याख्या

टॉयलेट पेपर की लंबाई की धारा जिसमें पूर्ण लूप शामिल हैं, की गणना पहले की जाती है scanl (+) 0 (map (* pi) [0.38, 0.4 ..]] । हम पूर्ण क्रांतियों की संख्या के साथ इन्हें ज़िप करते हैं, जो कि Doubleनिहित रूप से भी उठाएगा। हम इसे &वर्तमान संख्या के साथ पास करते हैं जिसे हम गणना करना चाहते हैं, इसे कॉल करें p।

& की सूची संसाधित करता है (Double, Double) द्वारा (क) अपने अधिकार पर जोड़े आगे लंघन जब तक snd . head . tailसे अधिक है p, जिस बिंदु पर snd . headसे भी कम हैp ।

इस पंक्ति के अनुपात को भरने के लिए, यह तब गणना करता है (p - x)/(y - x),और इसे समग्र रूप से लूप में जोड़ता है जो अब तक बनाए गए हैं।

Answer 5

सी ++, 72 बाइट्स

float f(float k,int d=19){auto c=d/15.9155;return k<c?k/c:1+f(k-c,d+1);}

मैंने यहां C ++ का उपयोग किया है क्योंकि यह डिफ़ॉल्ट फ़ंक्शन तर्कों का समर्थन करता है, यहां त्रिज्या को आरम्भ करने के लिए आवश्यक है।

पुनरावृत्ति एक- forलूप का उपयोग करने की तुलना में छोटे कोड का उत्पादन करने के लिए लगता है । इसके अलावा, autoइसके बजाय float- 1 बाइट कम!

Comments

आपने मुझे लगभग बेवकूफ बना दिया, विज्ञापन के लिए इस्तेमाल dकिया r...

— टोबी स्पाइट

Answer 6

लूआ, 82 बाइट्स

n=... l,c,p=10*n,11.938042,0 while l>c do l,c,p=l-c,c+.628318,p+1 end print(p+l/c)

सामान्य उद्देश्य वाली भाषा के लिए बुरा नहीं है, लेकिन निश्चित रूप से समर्पित गोल्फिंग भाषाओं के खिलाफ बहुत प्रतिस्पर्धी नहीं है। स्थिरांक को pi के साथ उल्लिखित माना जाता है।

Comments

OP किस प्रकार के इनपुट को स्वीकार करने के बारे में विशिष्ट नहीं था, इसलिए मैंने इसके आरंभ को छोड़ दिया n, लेकिन बाकी के रूप में (जैसा कि था) चलेगा। किसी भी मामले में, अब यह nकमांड लाइन से लेता है; उदाहरण के लिए 3 शीट के रूप में इसे चलाते हैं lua tp.lua 3।

— criptych मोनिका

यह वास्तव में इस सवाल का एक नियम नहीं है, बल्कि एक सामान्य नीति है। जब तक सवाल अन्यथा नहीं कहता, इनपुट को हार्डकोड करने से सबमिशन एक स्निपेट बन जाता है, जिसे डिफ़ॉल्ट रूप से अनुमति नहीं है । साइट-व्यापी चूक के बारे में अधिक जानकारी कोड गोल्फ टैग विकी में पाई जा सकती है ।

— डेनिस

मैं "पूरे कार्यक्रम या फ़ंक्शन" भाग के बारे में जानता था, लेकिन यह नहीं जानता था कि "हार्डकॉडिंग इनपुट प्रस्तुत स्निपेट बनाता है"। स्पष्टीकरण देने के लिए धन्यवाद। मुझे लगता है कि यह वास्तव में एक समारोह के रूप में लंबा होगा!

— criptych मोनिका

Answer 7

जावास्क्रिप्ट, 77 बाइट्स

function w(s,d,c){d=d||3.8;c=d*3.14159;return c>s*10?s*10/c:1+w(s-c/10,d+.2)}

function w(s,d,c){d=d||3.8;c=d*3.14159;return c>s*10?s*10/c:1+w(s-c/10,d+.2)}

function wraps(sheets, diameter, circumference) {
    // Default the value of diameter
    diameter = diameter || 3.8;
    circumference = diameter * 3.14159;
    if (circumference > sheets * 10)
        return sheets * 10 / circumference;
    return 1 + wraps(sheets - circumference / 10, diameter + .2);
}

document.getElementById('text').innerHTML = "0 => " + w(0)
+ "\n1 => " + w(1)
+ "\n2 => " + w(2)
+ "\n3 => " + w(3)
+ "\n100 => " + w(100)

+ "\n\n0 => " + wraps(0)
+ "\n1 => " + wraps(1)
+ "\n2 => " + wraps(2)
+ "\n3 => " + wraps(3)
+ "\n100 => " + wraps(100);

<pre id="text"></pre>

Comments

PPCG में आपका स्वागत है! यदि आप चाहें, तो आप जावास्क्रिप्ट w=(s,d=3.8,c=d*3.14159)=>c>s*10?s*10/c:1+w(s-c/10,d+.2)

— ईएस

Answer 8

सी, 87 बाइट्स

float d(k){float f=31.831*k,n=round(sqrt(f+342.25)-19);return n+(f-n*(37+n))/(38+2*n);}

पूरे छोरों की संख्या के लिए एक स्पष्ट सूत्र का उपयोग करता है:

floor(sqrt(100 * k / pi + (37/2)^2) - 37/2)

मेरे 100 / piद्वारा प्रतिस्थापित किया गया 31.831और बदल दिया floorगया round, जिससे कष्टप्रद संख्या -18.5साफ हो गई-19 ।

इन छोरों की लंबाई है

pi * n * (3.7 + 0.1 * n)

इस लंबाई को पूरी लंबाई से घटाने के बाद, कोड शेष को उचित परिधि द्वारा विभाजित करता है।

---

बस इसे स्पष्ट करने के लिए - इस समाधान में O(1)कई (सभी?) अन्य समाधानों के विपरीत जटिलता है । तो यह एक लूप या पुनरावृत्ति की तुलना में थोड़ा लंबा है।

Answer 9

सी #, 113 बाइट्स

double s(int n){double c=0,s=0,t=3.8*3.14159;while(n*10>s+t){s+=t;c++;t=(3.8+c*.2)*3.14159;}return c+(n*10-s)/t;}

Ungolfed:

double MysteryToiletPaper(int sheetNumber) 
    { 
        double fullLoops = 0, sum = 0, nextLoop = 3.8 * 3.14159; 

        while (sheetNumber * 10 > sum + nextLoop) 
        { 
            sum += nextLoop; 
            fullLoops++; 
            nextLoop = (3.8 + fullLoops * .2) * 3.14159; 
        } 

        return fullLoops + ((sheetNumber * 10 - sum) / nextLoop); 
    }

परिणाम:

1 शीट के लिए

0,837658302760201

2 शीट के लिए

1,64155077524438

3 शीट के लिए

2,41650110749198

100 शीट के लिए

40,8737419532946

Answer 10

PHP, 101 बाइट्स

<?$p=pi();$r=3.8;$l=$argv[1]*10;$t=0;while($r*$p<$l){$t+=($l-=$r*$p)>0?1:0;$r+=.2;}echo$t+$l/($r*$p);

Ungolfed

<?
$pi = pi();
$radius = 3.8;
$length_left = $argv[1]*10;
$total_rounds = 0;
while ($radius * $pi < $length_left) {
    $total_rounds += ($length_left -= $radius * $pi) > 0 ? 1 : 0;
    $radius += .2;
}
echo $total_rounds + $length_left/( $radius * $pi );

मुझे लगता है कि यह थोड़ा कम किया जा सकता है, लेकिन मैं विचारों से बाहर भाग गया।

Answer 11

पायथन 3, 114 109 99 बाइट्स

यह फ़ंक्शन प्रत्येक परत की परिधि को ट्रैक करता है जब तक कि परिधि का योग शीट्स की संख्या से अधिक नहीं हो जाता। एक बार ऐसा होने पर उत्तर है:

• परिकलित परतों की संख्या से कम एक + बचे हुए चादरों की लंबाई / सबसे हाल की परत की परिधि

---

def f(n):
    l,s=0,[]
    while sum(s)<n:s+=[.062832*(l+19)];l+=1
    return len(s)-1+(n-sum(s[:-1]))/s[-1]

अद्यतन करें

• -10 [16-05-09] ने मेरी गणित-आईएनजी को अनुकूलित किया
• -5 [16-05-04] लाइनों की न्यूनतम संख्या

Answer 12

जावास्क्रिप्ट, 44 बाइट्स

w=(i,d=19,c=d/15.9155)=>i<c?i/c:1+w(i-c,d+1)

मैंने अनातोलीग के विचार का उपयोग किया और जावास्क्रिप्ट में कोड का अनुवाद किया।

Answer 13

> <>, 46 44 बाइट्स

a*0"Gq",:&a9+*\
?\:{$-{1+{&:&+>:{:})
;>{$,+n

कार्यक्रम शुरू होने पर स्टैक पर उपस्थित होने के लिए शीट की संख्या की अपेक्षा करता है।

यह रजिस्टर में 355/113 = 3.14159292...संग्रहीत करने के लिए pi of का एक सन्निकटन का उपयोग करता है pi/5। वर्तमान पुनरावृत्ति की परिधि स्टैक पर रहती है, और pi/5प्रत्येक पुनरावृत्ति पर जोड़ा जाता है।

संपादित करें: परिधि को सीधे स्टोर करने के लिए संदर्भित - पिछला संस्करण संग्रहीत pi/10और व्यास के रूप में शुरू किया 38, जो 2 बाइट्स लंबा था।

Answer 14

PHP, 79 बाइट्स

function p($s,$d=3.8){$c=$d*pi();return $c>$s*10?$s*10/$c:1+p($s-$c/10,$d+.2);}

सैंडबॉक्स में कोड चलाएँ

मैंने जावास्क्रिप्ट में जावास्क्रिप्ट के लिए रॉस ब्रैडबरी के उत्तर का बहुत अधिक अनुवाद किया है, जो पुनरावर्ती भी है।

Comments

कृपया किसी अन्य उत्तर को किसी अन्य भाषा में कॉपी न करें।

— R