เรื่องราว

ดังนั้นฉันจึงมีหนังสือเล่มหนึ่งที่ฉันต้องการแยกออกจากโต๊ะโดยไม่มีอะไรเลยนอกจากหนังสือเล่มอื่น ฉันต้องการทราบว่าฉันต้องใช้หนังสือกี่เล่มเพื่อให้บรรลุสิ่งนี้ด้วยความยาวหนังสือ$n$

นี่คือการสร้างภาพข้อมูลที่เพื่อนของฉันที่ Wolfram ดึงมาให้ฉัน:

ข้อมูลเพิ่มเติมเกี่ยวกับหัวข้อในวุลแฟรมและวิกิพีเดีย

ท้าทาย

ได้รับการป้อนข้อมูลจำนวนเต็ม , เอาท์พุทว่าหนังสือหลายเล่มที่จำเป็นสำหรับหนังสือด้านบนจะเป็นระยะเวลาในหนังสือเล่มนี้ออกไปจากตารางในแนวนอน หรือ ค้นหาค่าจำนวนเต็มน้อยที่สุดของสำหรับอินพุตในความไม่เท่าเทียมกันดังต่อไปนี้ n m n m ∑ i = 1$n$$n$

$m$$n$

แก้ไข:สำหรับเศษส่วนใช้อย่างน้อยหนึ่งจุดลอยตัวที่มีความแม่นยำเดียวของ IEEE _{ขอโทษที่แก้ไขความท้าทายหลังจากโพสต์}

_{( OEIS A014537 )}

กรณีทดสอบ

 1          4
 2         31
 3        227
 5      12367
10  272400600

คู่ , 41 40 33 ไบต์

บันทึก 1 ไบต์ด้วย @Dennis

@(n)find(cumsum(.5./(1:9^n))>n,1)

ลองออนไลน์!

คำอธิบาย

สิ่งนี้ใช้ความจริงที่ว่าตัวเลขฮาร์มอนิกสามารถถูก จำกัด ขอบเขตด้วยฟังก์ชันลอการิทึม

นอกจากนี้การ>=เปรียบเทียบสามารถถูกแทนที่ด้วย>เพราะตัวเลขฮาร์มอนิกไม่สามารถเป็นจำนวนเต็มได้ (ขอบคุณ @Dennis!)

@(n)                                   % Anonymous function of n
                     1:9^n             % Range [1 2 ... 9^n]
                .5./(     )            % Divide .5 by each entry
         cumsum(           )           % Cumulative sum
                            >n         % Is each entry greater than n?
    find(                     ,1)      % Index of first true entry

Python 3 , 35 ไบต์

f=lambda n,k=2:n>0and-~f(n-1/k,k+2)

ลองออนไลน์!

Husk , 8 ไบต์

V≥⁰∫m\İ0

ลองออนไลน์!

เนื่องจาก Husk ใช้หมายเลขที่มีเหตุผลเมื่อเป็นเช่นนี้จึงไม่มีปัญหาจุดลอยตัว

คำอธิบาย

      İ0    The infinite list of positive even numbers
    m\      Reciprocate each
   ∫        Get the cumulative sum
V           Find the index of the first element
 ≥⁰         that is greater than or equal to the input

JavaScript ขนาด 30 ไบต์

ฟังก์ชั่นวนซ้ำดังนั้นมันจึงน่าสนใจมาก

f=(n,x=0)=>n>0?f(n-.5/++x,x):x

ลองออนไลน์

Haskell, 38 ไบต์

k!n|n<=0=0|x<-n-1/(2*k)=1+(k+1)!x
(1!)

Swift , 65 ไบต์

func f(n:Double){var i=0.0,s=i;while s<n{i+=1;s+=0.5/i};print(i)}

ลองออนไลน์!

Ungolfed

func f(n:Double) {
  var i = 0.0, s = 0.0
  while s < n {
    i += 1;
    s += 0.5 / i
  }
  print(i)
}

R , 39 ไบต์

function(n){while((F=F+.5/T)<n)T=T+1;T}

ลองออนไลน์!

กำลังดุร้าย!

Javascript (ES6), 34 ไบต์

n=>eval("for(i=0;n>0;n-=.5/i)++i")

Ungolfed

n => {
    for(i = 0; n > 0; ++i)
        n -= .5 / i
    return i;
}

กรณีทดสอบ

f=n=>eval("for(i=0;n>0;n-=.5/i)++i")

<button onclick="console.log(f(1))">Run for n = 1</button>
<button onclick="console.log(f(2))">Run for n = 2</button>
<button onclick="console.log(f(3))">Run for n = 3</button>
<button onclick="console.log(f(5))">Run for n = 5</button>
<button onclick="console.log(f(10))">Run for n = 10</button>

เยลลี่ขนาด 8 ไบต์

RİSH:ð1#

นี้เป็นมากช้า

ลองออนไลน์!

Haskell, 71 49 48 ไบต์

f x=length.fst.span(<x).scanl(+)0$(0.5/)<$>[1..]

@BMO ช่วยฉันด้วยขนาด 22 ไบต์!

Julia 0.6 , 30 27 bytes

<(n,i=1)=n>0?n-.5/i<i+1:i-1

ลองออนไลน์!

ใช้งานได้เพียงn = 6เพราะ Julia ไม่มีการเพิ่มประสิทธิภาพการโทรหาง

-3 ไบต์ขอบคุณที่เดนนิส

TI-BASIC ขนาด 27 ไบต์

พร้อมต์ให้ผู้ใช้ป้อนข้อมูลและแสดงเอาต์พุตเมื่อมีการยกเลิก หมายเหตุ: ⁻¹เป็นโทเค็น^-1 (ผกผัน)

Input N
1
Repeat 2N≤Σ(I⁻¹,I,1,Ans
Ans+1
End
Ans

05AB1E , 11 ไบต์

XµN·zODI›}N

ลองออนไลน์!

คำอธิบาย

Xµ       }    # loop until counter is 1
  N·z         # push 1/(2*N)
     O        # sum the stack
      DI›     # break if the sum is greater than the input
          N   # push N

Pyth , 10 ไบต์

f!>Qsmc1yh

ลองออนไลน์!

ช้ามาก

Pyth , 10 ไบต์

fgscL1STyQ

ลองออนไลน์!

Japt , 12 ไบต์

ความยาวเดียวกันกับ แต่มีประสิทธิภาพมากกว่าตัวเลือกแบบเรียกซ้ำ

@T¨(Uµ½÷X}a1

ลองมัน

คำอธิบาย

@T¨(Uµ½÷X}a1
                 :Implicit input of integer U
@        }a1     :Return the first number X >=1 that returns truthy when passed through the following function
 T               :Zero
  ¨              :Greater than or equal to
    Uµ           :Decrement U by...
      ½÷X        :0.5 divided by X

J, 22 ไบต์

-6 ไบต์ขอบคุณ frownyfrog

I.~0+/\@,1%2*1+[:i.9&^

ลองออนไลน์!

คำตอบเดิม

คำตอบของ Luis ใน J:

1+]i.~[:<.[:+/\1%2*1+[:i.9&^

Ungolfed

1 + ] i.~ [: <. [: +/\ 1 % 2 * 1 + [: i. 9&^

ส่วนใหญ่อยากรู้อยากเห็นเพื่อดูว่ามันสามารถปรับปรุงอย่างมาก ( ไมล์ไอเพจจิ้ง)

คำอธิบาย

1 +      NB. 1 plus... 
] i.~    NB. find the index of the arg in...
[: <.    NB. the floor of...
[: +/\   NB. the sumscan of...
1 %      NB. the reciprical of...
2 *      NB. two times...
1 +      NB. 1 plus...
[: i.    NB.  the integers up to 
9&^      NB. 9 raised to the power of the arg

ลองออนไลน์!

PHP, 35 ไบต์

while($argv[1]>$s+=.5/++$i);echo$i;

รันโดยใช้ CLI:

$ php -d error_reporting=0 -r 'while($argv[1]>$s+=.5/++$i);echo$i;' 5

ภาษา Wolfram (Mathematica)ขนาด 40 ไบต์

⌈x/.NSolve[HarmonicNumber@x==2#,x]⌉&

ลองออนไลน์!

Java 8, 49 ไบต์

n->{float r=0,s=0;for(;s<n;)s+=.5f/++r;return r;}

คำอธิบาย:

ลองออนไลน์ (หมดเวลาสำหรับกรณีทดสอบด้านบนn=7)

n->{             // Method with integer parameter and float return-type
  float r=0,     //  Result-float, starting at 0
        s=0;     //  Sum-float, starting at 0
  for(;s<n;)     //  Loop as long as the sum is smaller than the input
    s+=.5f/++r;  //   Increase the sum by `0.5/(r+1)`,
                 //   by first increasing `r` by 1 with `r++`
  return r;}     //  Return the result-float

tinylisp , 98 ไบต์

(load library
(d _(q((k # N D)(i(l N(* D # 2))(_(inc k)#(+(* N k)D)(* D k))(dec k
(q((#)(_ 1 # 0 1

บรรทัดสุดท้ายคือฟังก์ชั่นแลมบ์ดาที่ไม่มีชื่อที่ใช้จำนวนความยาวหนังสือและส่งคืนจำนวนหนังสือที่ต้องการ ลองออนไลน์!

คำอธิบาย

เฉพาะชนิดข้อมูลตัวเลข tinylisp มีจำนวนเต็มดังนั้นเราจึงคำนวณอนุกรมฮาร์โมนิกเป็นเศษส่วนโดยการติดตามตัวเศษและส่วน ในแต่ละขั้นตอนNคือตัวเศษDเป็นตัวส่วนและkเป็นดัชนีผลรวม เราต้องการผลรวมบางส่วนใหม่ที่จะหรือN/D + 1/k (N*k + D)/(D*k)ดังนั้นเราจึง recurse กับเศษใหม่ของการN*K + Dเป็นส่วนใหม่และดัชนีใหม่ของD*kk+1

การเรียกซ้ำควรหยุดลงเมื่อผลรวมบางส่วนมากกว่าหรือเท่ากับ#จำนวนหนังสือที่ต้องการ ณ k-1จุดนี้เราได้หนังสือเล่มหนึ่งไปไกลเกินไปดังนั้นเราจึงกลับมา เงื่อนไขคือ1/2 * N/D < #; เราจะได้ตัวคูณหารด้วยN < D*#*2ซึ่งเป็นวิธีที่ง่ายที่สุดในการเขียน

ฟังก์ชันตัวช่วยแบบเรียกซ้ำทำหน้าที่_คำนวณเหล่านี้ทั้งหมด หน้าที่หลักเป็นเพียงเสื้อคลุมหนึ่งโต้แย้งว่าสาย_มีค่าเริ่มต้นที่ถูกต้องสำหรับk, และND