Hôm nay bạn cần phải giải quyết một vấn đề rất thực tế: Bạn cần bao nhiêu vòng để có một số tờ nhất định trên cuộn giấy vệ sinh của bạn? Hãy xem xét một số sự thật:

• Đường kính của một xi lanh giấy vệ sinh trần là 3,8cm
• Chiều dài của một tờ giấy vệ sinh là 10cm.
• Độ dày của một tờ giấy vệ sinh là 1mm.

Trước khi bạn quấn quanh hình trụ lần đầu tiên, nó có chu vi tính bằng cm là 3,8 * pi. Mỗi khi bạn quấn một tấm quanh hình trụ thì bán kính của nó tăng thêm 1, do đó chu vi của nó tăng thêm .2 * PI. Sử dụng thông tin này để tìm hiểu cần bao nhiêu vòng để lắp n tờ giấy vệ sinh. (Lưu ý: Sử dụng xấp xỉ Pi ít nhất là chính xác như 3.14159).

Các trường hợp thử nghiệm :

n = 1 :

• 10 / (3,8 * pi) = .838 vòng

n = 2 :

• (Chúng ta có thể tạo bao nhiêu vòng đầy đủ?) 1 vòng lặp đầy đủ = 3,8 * pi = 11.938.
• (Chúng ta còn lại bao nhiêu sau vòng 1?) 20 - 11.938 = 8.062
• (Phần còn lại của vòng 2 tạo ra bao nhiêu?) 8.062 / (4 * pi) = .642 vòng
• Trả lời: 1.642 vòng

n = 3 :

• Vòng lặp đầy đủ thứ 1 = 3,8 * pi = 11,938, vòng lặp đầy đủ thứ 2 = 4 * pi = 12,566
• 30 - 11.938 - 12.566 = 5.496
• 5.496 / (4.2 * pi) = .417
• Trả lời: 2.417 vòng

n = 100 => 40.874

Bình thường, 27 23 byte

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

Hãy thử trực tuyến. Bộ thử nghiệm.

Giải trình

                            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)

Haskell, 59 46 44 byte

Một hệ số tỷ lệ 5 / pi được áp dụng, sao cho một hình trụ giấy có chu vi 19,20,21 ... cm và một tờ là 50 / pi cm.

Đã lưu 2 byte nhờ xnor, bằng cách sử dụng hàm không tên.

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

Thạch , 29 27 26 byte

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

Hãy thử trực tuyến!

Haskell, 97 byte

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

Có thể đánh golf nó xa hơn bằng cách chuyển bộ lọc từ người &vận hành thành một takeWhiletuyên bố, nhưng cho rằng đó không phải là một ngôn ngữ chơi golf, điều này có vẻ tương đối cạnh tranh.

Giải trình

Luồng chiều dài của giấy vệ sinh bao gồm các vòng đầy đủ được tính toán đầu tiên là scanl (+) 0 (map (* pi) [0.38, 0.4 ..]]. Chúng tôi nén chúng với số vòng quay đầy đủ, cũng sẽ chọn loại Doublengầm. Chúng tôi chuyển số này đến &với số hiện tại mà chúng tôi muốn tính toán, gọi nó p.

&xử lý danh sách các (Double, Double)cặp bên phải của nó bằng cách (a) bỏ qua về phía trước cho đến khi snd . head . taillớn hơn p, tại điểm snd . headnhỏ hơn p.

Để có được tỷ lệ của hàng này được lấp đầy, sau đó nó sẽ tính toán (p - x)/(y - x),và thêm nó vào tổng số vòng lặp đã được thực hiện cho đến nay.

C ++, 72 byte

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

Tôi đã sử dụng C ++ ở đây vì nó hỗ trợ các đối số chức năng mặc định, cần ở đây để khởi tạo bán kính.

Đệ quy dường như tạo ra mã ngắn hơn so với sử dụng for-loop. Ngoài ra, autothay vì float- ít hơn 1 byte!

Lua, 82 byte

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)

Không tệ cho một ngôn ngữ có mục đích chung, nhưng tất nhiên là không cạnh tranh với các ngôn ngữ golf chuyên dụng. Các hằng số được sắp xếp sẵn với pi, với độ chính xác đã nêu.

JavaScript, 77 byte

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>

C, 87 byte

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

Sử dụng một công thức rõ ràng cho số lượng toàn bộ vòng lặp:

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

Tôi thay thế 100 / pibằng 31.831, và thay thế floorbằng round, biến số khó chịu -18.5thành sạch sẽ -19.

Độ dài của các vòng này là

pi * n * (3.7 + 0.1 * n)

Sau khi trừ chiều dài này khỏi toàn bộ chiều dài, mã chia phần còn lại cho chu vi thích hợp.

Chỉ cần làm cho nó rõ ràng - giải pháp này có độ phức tạp O(1), không giống như nhiều giải pháp khác (tất cả?). Vì vậy, nó dài hơn một vòng lặp hoặc đệ quy.

C #, 113 byte

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

Ung dung:

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

Các kết quả:

cho 1 tờ

0,837658302760201

cho 2 tờ

1.64155077524438

cho 3 tờ

2,41650110749198

cho 100 tờ

40,8737419532946

PHP, 101 byte

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

Ung dung

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

Tôi cảm thấy như điều này có thể được thực hiện ngắn hơn một chút, nhưng tôi đã hết ý tưởng.

Python 3, 114 109 99 byte

Hàm này theo dõi chu vi của mỗi lớp cho đến khi tổng chu vi lớn hơn chiều dài của số tờ. Một khi điều này xảy ra, câu trả lời là:

• Ít hơn một số lượng các lớp được tính toán + chiều dài của các trang tính / chu vi còn lại của lớp gần đây nhất

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]

Cập nhật

• -10 [16-05-09] Tối ưu hóa toán học của tôi
• -5 [16-05-04] Số dòng tối thiểu

JavaScript, 44 byte

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

Tôi đã sử dụng ý tưởng của anatolyg và dịch mã sang JavaScript.

> <>, 46 44 byte

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

Dự kiến ​​số lượng tờ sẽ có mặt trên ngăn xếp khi bắt đầu chương trình.

Điều này sử dụng một xấp xỉ pi của 355/113 = 3.14159292..., lưu trữ pi/5trong thanh ghi. Chu vi của vòng lặp hiện tại sống trên ngăn xếp và pi/5được thêm vào mỗi lần lặp.

Chỉnh sửa: Được cấu trúc lại để lưu trữ chu vi trực tiếp - phiên bản trước được lưu trữ pi/10và bắt đầu đường kính như 38, dài hơn 2 byte.

PHP, 79 byte

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

Chạy mã trong Sandbox

Tôi đã dịch khá nhiều câu trả lời của Ross Bradbury cho JavaScript sang hàm PHP, cũng là đệ quy.