Programming Puzzles & Code Golf Stack Exchange is a question and answer site for programming puzzle enthusiasts and code golfers. It's 100% free, no registration required.

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top

Today you need to solve a very practical problem: How many loops do you need to have a certain number of sheets on your toilet paper roll? Let's look at some facts:

  • The diameter of a bare toilet paper cylinder is 3.8cm
  • The length of one sheet of toilet paper is 10cm.
  • The thickness of one sheet of toilet paper is 1mm.

Before you wrap around the cylinder the first time, it has a circumference in cm of 3.8*pi. Every time you wrap a sheet around the cylinder its radius increases by .1, therefore its circumference increases by .2*PI. Use this information to find out how many loops it takes to fit n sheets of toilet paper. (Note: Use an approximation of Pi that is at least as accurate as 3.14159).

Test Cases:

n=1:

  • 10/(3.8*pi) = .838 loops

n=2:

  • (How many full loops can we make?) 1 full loop = 3.8*pi = 11.938.
  • (How much do we have left after the 1st loop?) 20 - 11.938 = 8.062
  • (How much of a 2nd loop does the remaining piece make?) 8.062/(4*pi) = .642 loops
  • Answer: 1.642 loops

n=3:

  • 1st full loop = 3.8*pi = 11.938, 2nd full loop = 4*pi = 12.566
  • 30 - 11.938 - 12.566 = 5.496
  • 5.496/(4.2*pi) = .417
  • Answer: 2.417 loops

n=100 => 40.874

share|improve this question
35  
Phew! 1mm thick? Are you sure you're using toilet paper and not cardboard? – Digital Trauma Jan 13 at 19:01
11  
@DigitalTrauma Clearly you don't know about triple-ply :p – geokavel Jan 13 at 19:40
2  
Under the assumption that the toilet paper does not make steps but continuously increases the radius, you can get a closed form approximation to requested result. Is this good enough? nloops = sqrt(n+11.34)*0.0564189 - 0.19 – flawr Jan 13 at 20:01
2  
Proposed test case: 100 -> 40.874 – Dennis Jan 13 at 22:45
1  
Triple-ply cardboard?! Now that's thick! – mbomb007 Jan 13 at 22:59

14 Answers 14

up vote 12 down vote accepted

Pyth, 27 23 bytes

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

Try it online. Test suite.

Explanation

                            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)
share|improve this answer
    
explanation, please? – Cᴏɴᴏʀ O'Bʀɪᴇɴ Jan 13 at 19:52
    
@CᴏɴᴏʀO'Bʀɪᴇɴ Added. Explaining Pyth is always so much fun. – Pietu1998 Jan 13 at 20:11
2  
Your explanation looks like a potential output for Surfin' Word – geokavel Jan 13 at 21:24

Haskell, 59 46 44 bytes

A scale factor of 5/pi is applied, so that a paper cylinder has a circumference of 19,20,21... cm and a sheet is 50/pi cm.

Saved 2 bytes thanks to xnor, by using an unnamed function.

x!s|s>x=1+(x+1)!(s-x)|1>0=s/x
(19!).(50/pi*)
share|improve this answer
    
A pretty recursive method. Note that unnamed functions are allowed even when you have other lines (despite Haskell not supporting it), so the last line can be pointfree as (19!).(50/pi*). – xnor Jan 14 at 0:23
    
Wow, blows my approach out of the water! – CR Drost Jan 14 at 2:32

Jelly, 29 27 26 bytes

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

Try it online!

share|improve this answer
6  
Ahem? The short python ate jelly. – Cᴏɴᴏʀ O'Bʀɪᴇɴ Jan 13 at 21:05
    
@CᴏɴᴏʀO'Bʀɪᴇɴ that was one of those things that is so not funny that it was kinda funny. – Ashwin Gupta Jan 15 at 3:20

Haskell, 97 bytes

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..]))

Might be able to golf it further by moving the filtering from the & operator into a takeWhile statement, but given that it's not a golfing language this seems relatively competitive.

Explanation

The stream of lengths of toilet paper that comprise full loops are first calculated as scanl (+) 0 (map (* pi) [0.38, 0.4 ..]]. We zip these with the number of full revolutions, which will also pick up the type Double implicitly. We pass this to & with the current number that we want to calculate, call it p.

& processes the list of (Double, Double) pairs on its right by (a) skipping forward until snd . head . tail is greater than p, at which point snd . head is less than p.

To get the proportion of this row that is filled, it then computes (p - x)/(y - x), and adds it to the overall amount of loops that have been made so far.

share|improve this answer

C++, 72 bytes

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

I used C++ here because it supports default function arguments, needed here to initialize the radius.

Recursion seems to produce shorter code than using a for-loop. Also, auto instead of float - 1 byte less!

share|improve this answer
1  
You almost fooled me, using d for the radius... – Toby Speight Jan 15 at 12:24

Lua, 82 bytes

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)

Not bad for a general-purpose language, but not very competitive against dedicated golfing languages of course. The constants are premultiplied with pi, to the stated precision.

share|improve this answer
    
OP wasn't specific about what kind of input to accept, so I left out the initialization of n, but the rest would've run as-is (as-was?). In any case, now it takes n from the command line; e.g. for 3 sheets run it as lua tp.lua 3. – criptych Jan 14 at 14:01
    
It's not precisely a rule of this question, but a general policy. Unless the question says otherwise, hardcoding the input makes the submission a snippet, which are not allowed by default. More information about site-wide defaults can be found in the code golf tag wiki. – Dennis Jan 14 at 14:47
    
I knew about the "whole program or function" part but didn't know that "hardcoding the input makes the submission a snippet". Thanks for clarifying. I think this would actually be longer as a function! – criptych Jan 14 at 18:15

JavaScript, 77 bytes

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>

share|improve this answer
3  
Welcome to PPCG! If you'd like, you can use JavaScript ES6, and get this to 55 bytes: w=(s,d=3.8,c=d*3.14159)=>c>s*10?s*10/c:1+w(s-c/10,d+.2) – Upgoat Jan 15 at 4:22

C, 87 bytes

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

Uses an explicit formula for the number of whole loops:

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

I replaced 100 / pi by 31.831, and replaced floor with round, turning the annoying number -18.5 to a clean -19.

The length of these loops is

pi * n * (3.7 + 0.1 * n)

After subtracting this length from the whole length, the code divides the remainder by the proper circumference.


Just to make it clear - this solution has complexity O(1), unlike many (all?) other solutions. So it's a bit longer than a loop or recursion.

share|improve this answer

C#, 113 bytes

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); 
    }

Results:

for 1 sheet

0,837658302760201

for 2 sheets

1,64155077524438

for 3 sheets

2,41650110749198

for 100 sheets

40,8737419532946

share|improve this answer

PHP, 101 bytes

<?$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 );

I feel like this could be done a little shorter, but I ran out of ideas.

share|improve this answer

Python 3, 114 109 99 bytes

This function tracks the circumference of each layer until the sum of the circumferences is greater than the length of the number of sheets. Once this happens the answer is:

  • One less than the number of calculated layers + length of leftover sheets / circumference of most recent layer

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]

Update

  • -10 [16-05-09] Optimized my math-ing
  • -5 [16-05-04] Minimized number of lines
share|improve this answer

JavaScript, 44 bytes

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

I used anatolyg's idea and translated the code into JavaScript.

share|improve this answer

><>, 46 44 bytes

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

Expects the number of sheets to be present on the stack at program start.

This uses an approximation of pi of 355/113 = 3.14159292..., storing pi/5 in the register. The current iteration's circumference lives on the stack, and pi/5 is added on each iteration.

Edit: Refactored to store the circumference directly - previous version stored pi/10 and started the diameter as 38, which was 2 bytes longer.

share|improve this answer

PHP, 79 bytes

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

Run code in Sandbox

I have pretty much only translated Ross Bradbury's answer for JavaScript into a PHP function, which is also recursive.

share|improve this answer
    
Please don't just copy another answer into another language. – Eᴀsᴛᴇʀʟʏ Iʀᴋ May 10 at 20:37

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.