30

3

# How far should I sum?

The harmonic series is the "infinite sum" of all the fractions of the form $$\\frac1n\$$ for $$\n\$$ positive integer. I.e. the harmonic series is

$$\frac11 + \frac12 + \frac13 + \frac14 + \cdots$$

It is well-known that this sum diverges, which means that if you define

$$H_n = \frac11 + \frac12 + \cdots + \frac1n$$

Then the value of $$\H_n\$$ goes to infinity. This can also be stated in a different way: for any positive value $$\x\$$ you pick, there is some value $$\N\$$ such that, to the right of $$\N\$$, the $$\H\$$ values are bigger than $$\x\$$:

$$\forall\ x\ \exists\ N: n > N \implies H_n > x$$

Write a program/function that takes as input a positive number x (not necessarily an integer) and outputs the first integer n for which

$$H_n \geq x$$

In theory your program must work for arbitrary x, even if in practice you are limited by the memory and/or precision of your programming language/computer.

# Test cases

1.5 -> 2
2 -> 4
3 -> 11
3.1415 -> 13
4 -> 31
5 -> 83
7.5 -> 1015
10 -> 12367


This is so shortest solution wins! Standard loopholes are forbidden by default. Happy golfing.

2 – Arnauld – 2020-02-09T23:32:12.137

@Arnauld included for completeness? Or do you think it might help someone in any way? – RGS – 2020-02-09T23:43:35.103

9Your recent challenges have been great! Keep up the good work! – S.S. Anne – 2020-02-10T00:48:11.107

@S.S.Anne thanks :D I'll try to come up with more decent challenges. – RGS – 2020-02-10T07:27:49.817

You ask: "how far should I go". I suggest anywhere between 6 to 8 metres. :P – Lyxal – 2020-02-10T10:26:17.813

@Lyxal not far enough! – RGS – 2020-02-10T13:14:31.037

7

# APL (Dyalog), 13 bytes

-1 bytes thanks to ngn

{⊃⍸⍵≤+\÷⍳⌈*⍵}


Try it online!

A dfn solution that takes a right argument.

### Explanation:

{           }   ⍝ dfn
⊃              ⍝ Take the first of
⍸             ⍝ The indexes of the truthy values of
⍵≤           ⍝ The right argument is smaller than or equal to
\+         ⍝ The cumulative sum
÷        ⍝ The reciprocal of each of
⍳       ⍝ The range 1 to
⌈      ⍝ The ceiling of
*⍵    ⍝ e to the power of the right argument


11⍳⍨ -> ⊃⍸­­ – ngn – 2020-02-10T00:43:11.830

What does dfn stand for? Also, be sure to upvote the challenge if you liked solving it :) – RGS – 2020-02-10T07:19:47.270

2@RGS dfn stands for Direct Function – Jo King – 2020-02-10T07:50:20.727

2Sorry, but the first thing I saw in your answer was this face: {⊃≥⍵≤⊃} – Taazar – 2020-02-10T16:48:02.023

7

# Python 3, 35 bytes

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


Try it online!

Thanks for the submission. When X <= 0 the LHS evaluates to false. How does the lambda return n at that point? Also be sure to upvote if you liked golfing this challenge. – RGS – 2020-02-10T07:29:39.363

I don’t understand why the complement operator makes the and return the number instead of False. What happens there? – Émile Jetzer – 2020-02-10T13:41:45.797

3

@ÉmileJetzer The -~ is basically a shorter variation of +1. Since it's a recursive function that eventually results in False, the -~/+1 will interpret this as 0 in Python and adds the 1 (False+1 = 1 in Python). Here a step-by-step explanation of what happens for f(2).

– Kevin Cruijssen – 2020-02-10T16:49:13.737

1@KevinCruijssen that makes a whole lot'a sense! Thanks for explaining it and going through the effort of explaining it step by step. – RGS – 2020-02-10T22:04:16.157

@KevinCruijssen Thanks for detailed breakdown! The idea of incrementing the recursive output starting from a base case of 0, as a replacement for outputting the final value n, is a pattern that I find to come up a lot. For example, when finding the n'th number meeting a condition p, as in my tip here, we can use f=lambda n,i=1:n and-~f(n-p(i),i+1), which looks very similar to this answer.

– xnor – 2020-02-11T03:10:19.620

@ÉmileJetzer As Kevin described, I'm using -~ as an idiom for +1 that's shorter in this context, applying numerically to Booleans.

– xnor – 2020-02-11T03:11:58.573

6

# JavaScript (ES6),  32  29 bytes

Saved 3 bytes thanks to @Shaggy

f=(n,k=0)=>n>0?f(n-1/++k,k):k


Try it online!

# Non-recursive version, 35 bytes

n=>eval("for(k=0;(n-=1/++k)>0;);k")


Try it online!

### Approximation (25 bytes, not fully working)

This gives the correct result for all but the first test case.

n=>Math.exp(n-.5772)+.5|0


Try it online!

I have to get used to those solutions with evaluating loop code... why isn't the solution the actual loop? +1 for teaching me smth – RGS – 2020-02-09T22:58:48.467

@RGW Without eval(), it would be n=>{for(k=0;(n-=1/++k)>0;);return k}, which is 1 byte longer. – Arnauld – 2020-02-09T23:01:40.883

ah wow, of course. Thanks for elaborating – RGS – 2020-02-09T23:04:25.053

1

@RGS As a side note, the version with eval() is much, much slower than without eval() because the code never gets a chance to be processed by the JIT compiler.

– Arnauld – 2020-02-09T23:11:23.403

29 bytes – Shaggy – 2020-02-10T14:04:22.540

1n=>Math.exp(n-.5772)+.4|0 will work with all the test cases at least. I wonder how much further it will push out? – Guillermo Phillips – 2020-02-10T19:15:24.577

6

# Perl 6, 27 bytes

{+([\+](1 X/1..*)...*>=$_)}  Try it online! ### Explanation: { } # Anonymous code block taking one argument +( ) # Return the length of [\+]( ) # The cumulative sum 1 X/ # Of the reciprocal of all of 1..* # 1 to infinity ... # Take from this until *>=$_     # It is larger than or equal to the input


I should learn some Perl! +1 Thanks for including an explanation of the code. – RGS – 2020-02-09T23:00:05.210

2@RGS Note that these days Perl 6 is called Raku (TIO still uses Perl 6 hence most submissions use it). It was designed originally as a non-backwards compatible successor to Perl 5, but now both still live on with different names — Perl 5 is just Perl, and Perl 6 is Raku. I'm biased since I do a lot of (non golfing) work in it, but it's really one of the more beautiful and fun languages to write general code in, which sounds weird given the (unfair) image that Perl 5 had. – user0721090601 – 2020-02-12T04:06:16.670

@user0721090601 thank you for your testimonial. Tbh, I heard some "mean" things about Perl but I never programmed in it! Neither Perl <= 5, nor Perl 6 :) – RGS – 2020-02-12T07:12:29.547

2@RGS Perl — moreso than other languages as it regularly beats all but the golfing languages on here — can be extremely code-golfy and line-noisy. Sadly too many people used to write their \$day-job code like that which gave it the bad rap, particularly when others had to read such golfy/noisy code. – user0721090601 – 2020-02-12T23:13:12.400

5

# 05AB1E, 8 bytes

∞.ΔLzOI@


Try it online!

∞.Δ        # first integer y such that:
L       #  range [1..y]
z      #  invert each [1, 1/2, .., 1/y]
O     #  sum
I@   #  >= input


Thanks for your submission +1 Do you think you could include an explanation of the code? – RGS – 2020-02-09T23:00:34.237

2@RGS there you go, done – Grimmy – 2020-02-09T23:51:59.187

5

# Octave / MATLAB, 31 bytes

Thanks to @Giuseppe (based on @John's answer) for making a correction and saving 1 byte at the same time.

@(n)sum(cumsum(1./(1:3^n))<n)+1


Try it online!

### Explanation

The code uses the fact that 1+1/2+···+1/m is lower-bounded by log(m). Therefore, given n the solution to the challenge is less than exp(n), or less than 3^n (to save bytes).

So the code computes the cumulative sum of the vector [1, 1/2, 1/3, ..., 1/(3^n)], and the solution is 1 plus the number of entries that are less than n.

2+1 Clever solution, to use the lower bound so that you don't have to recurse or anything like that – RGS – 2020-02-10T13:14:04.940

@Giuseppe Thank you! Edited – Luis Mendo – 2020-02-10T22:35:53.937

5

# R, 39 33 bytes

x=scan();sum(cumsum(1/1:x^x)<x)+1


Try it online!

For a more limited x:

# 29 bytes

sum(cumsum(1/1:9^8)<scan())+1


Try it online!

36 bytes -- you need the +T at the end to prevent small x from returning TRUE. – Giuseppe – 2020-02-10T15:56:15.513

@Giuseppe I changed the core functionality in this edit. Any feedback? – John – 2020-02-10T16:03:35.957

I'd probably just use scan() in place of x but your edit now fails the requirement to work in theory for arbitrary x. – Giuseppe – 2020-02-10T16:32:00.340

3@Giuseppe good point. I made it arbitrary, but it won't work for all test cases due to memory limits – John – 2020-02-10T16:48:36.840

good R submission, +1. Unfortunately, the shorter solution doesn't meet the requirements, as Giuseppe pointed out :/ – RGS – 2020-02-10T17:30:58.520

4

# C (gcc), 45 bytes

Some inspiration taken from @Noodle9; go upvote their answer!

i;g(x,s)float x,s;{for(s=i=0;s<x;s+=1./++i);}

• i;g(x,s)float x,s;: Old-style function definition. Abuses the fact that old-style function definition don't require all the arguments to be passed (so old-style variadic functions would work) to declare an extra local variable. Having the i as a global variable causes the exploit below to work.

• for(s=i=0;s<x;s+=1./++i);: same old stuff as before, harmonic function, yada yada. Note that s=i=0 is allowed; the i=0 is an integer that is converted to a float and assigned to s.

• The i variable is stored in the %eax (return) register, so nothing is required to initialize it. (thanks @Cody Gray!)

Try it online!

# C (gcc), 72 bytes

Recursive solution.

i;float h(n){return n?h(n-1)+1./n:0;}g(float x){for(i=0;h(i++)<x;);--i;}


Explanation:

• i;: counter for finding the first integer n where h(n) >= x.

• float h(n): recursive function taking an int parameter and returning the term of the Harmonic series for n.

• return n?h(n-1)+1./n:0; - recursive function calculating the Harmonic series and stopping at 0.

• g(float x): function finding the first i where h(i) >= x.

• for(i=0;: start loop and initialize i to 0 (functions must be reusable).

• h(i++)<x: loop while h(i) < x.

• --i; returns i-1 by exploiting GCC's behavior when compiling without optimization; intermediate results are all stored in the eax/rax register.

Try it online!

# C (gcc), 83 bytes

Non-recursive solution.

i;float h(n){float r=0;for(;n;)r+=1./n--;r=r++;}g(float x){for(i=0;h(i++)<x;);--i;}


Explaining the part that's different from the previous solution:

• float r=0;: this is our result. Initialize it to 0.

• for(;n;): Loop until n is 0.

• r+=1./n--;: Add the next iteration of the Harmonic series. Also decrement n so we don't have to do that in the last part of the for loop.

• r=r++; is like return n; but shorter. It's similar to the fake return in the previous solution but does it with the floating-point return register instead of the integer return register. We have to have the ++ just so GCC doesn't optimize it out as redundant (and yes, some optimizations are enabled without a flag).

Try it online!

Thanks for your submission. +1 I see you are fond of exploiting that GCC bug you mention. Be sure to upvote my challenge if you liked solving it :) – RGS – 2020-02-10T00:02:44.257

1@RGS Definitely, there you go. return is a big space-killer so removing it is high on my list. I'm only sad I couldn't do it with h. – S.S. Anne – 2020-02-10T00:04:05.203

1

For the first solution, you don't need x=i; at all on GCC with -O0. It works because the loop counter (i) is already getting put in the eax register by the code-gen, which is where x86 expects the return value to be. Look at the disassembly. That saves you 4 more bytes. And seriously risks nasal demons. In fact, my nose is starting to itch...

– Cody Gray – 2020-02-11T01:05:30.097

@Cody This is code golf. Get over it. – S.S. Anne – 2020-02-11T01:07:13.330

4

# C (gcc), 52 51 49 bytes

Saved a bytes thanks to @ceilingcat!!!
Saved 2 bytes thanks to @S.S.Anne!!!

i;f(n,s)float n,s;{for(s=i=0;s<n;s+=1./++i);n=i;}


Try it online!

Wow! This is almost identical to the solution I came up with. High-five! – S.S. Anne – 2020-02-10T00:32:44.270

Is it? haven't looked at yours just noticed mine was shorter so posted. – Noodle9 – 2020-02-10T00:34:26.187

I think yours was first. 49, and some aesthetic fixes to the testcases.

– S.S. Anne – 2020-02-10T00:35:00.583

@S.S.Anne That's so weird that f takes two floats but you can call it with one - thanks! :-) – Noodle9 – 2020-02-10T00:42:42.183

See my answer for the reasoning. – S.S. Anne – 2020-02-10T00:44:00.437

Good job on this one. Defining functions this way is really weird! +1 – RGS – 2020-02-10T07:20:51.560

I think you can do even better by replacing your for with a while. I might be wrong though (haven't tested): float s=1,n=1;while(s<x){s+=1/++n;} . – magnus – 2020-02-10T08:45:29.740

3@magnus for and while will always be the same number of bytes in the worst case -- that's why we always use for. Also, your code has some other serious issues, including trying to initialize a parameter and using an undefined variable x. – S.S. Anne – 2020-02-10T12:05:58.710

@S.S.Anne, I see. Learned something new then. Thanks! – magnus – 2020-02-10T13:16:26.513

4

# Python 3, 49 40 bytes

Saved 9 bytes thanks to @JoKing!!!

lambda n,s=0,i=1:s<n and-~f(n,s+1/i,i+1)


Try it online!

Cool submission +1 it is just a shame that the recursion depth doesn't allow us to check for larger test cases. Also be sure to upvote the challenge if you liked golfing it :) – RGS – 2020-02-10T07:22:35.777

4

# Ruby, 31 30 bytes

->x{b=0;x-=1r/b+=1while x>0;b}


Try it online!

Clean solution, +1. Can you save 1 byte if you write b=.0? – RGS – 2020-02-10T08:50:09.063

1Not really, but I can achieve something similar with rational numbers (1r). – G B – 2020-02-10T08:59:09.590

3

# Jelly, 9 bytes

1İ€S<¬ʋ1#


A monadic Link accepting a number which yields a list containing one integer; as a full program it prints that integer.

Try it online!

### How?

1İ€S<¬ʋ1# - Link: number, x
1         - set left to one
1# - count up (from n=left) finding the first (1) n such that:
İ€       -     inverse each (of [1..n])
S      -     sum
<     -     less than (x)?
¬    -     logical NOT


‘!İ€Ä<⁸S‘


Is another 9 but it's much less efficient as $$\x\$$ gets bigger since it builds a list of the first $$$$x+1)!\$$ harmonic numbers. +1 for some jelly. For some reason the code feels long D: is it just me being a jerk? – RGS – 2020-02-09T23:19:37.070 3 # K (Kona), 21 20 bytes {1+*&~x>+\1.%1+!3^x}  Try it online! Inspired by Jo King's APL solution Switched from oK to Kona, as it has power 2+1 for the answer in a language I have never seen! – RGS – 2020-02-10T13:11:19.627 3 # Haskell, 34 bytes (#1) x#n|x>0=(x-1/n)#(n+1)|1>0=n-1  Try it online! +1 really cool solution with the infix operator. The cpp flag is just for the purposes of writing f=\ in the header? – RGS – 2020-02-10T13:12:47.203 3 # Java 8, 71 43 bytes x->{int n=0;for(;(x-=1d/++n)>0;);return n;}  -28 bytes by porting @Arnauld's non-recursive JavaScript answer. Try it online. Explanation: x->{ // Method with double as both parameter and integer as return-type int n=0; // Result-integer n, starting at 0 for(;(x-=1d/++n) // Decrease x by 1/(n+1), by first increasing n by 1 with ++n >0;); // And continue doing this until x is 0 return n;} // Then return n as result  Seeing such short solutions in "normal" programming languages fills me with joy – RGS – 2020-02-10T13:17:35.043 3 # Pyth, 1110 9 bytes fgZ=-Qc1T  Try it online! Explaination:  # Implicit Q=eval(input()) f # The first element T of [1,2,3,...] where gZ # 0 >= =-Qc1T # Q = Q - (1/T) # Implicit print  -1 -2 bytes thanks to @issacg cool submission! can you explain it, please? +1 :) – RGS – 2020-02-10T17:29:29.790 @RGS I'm not great at writing explainations but here goes nothing. – famous1622 – 2020-02-10T17:36:04.273 If you remove the first Q, it'll be filled in implicitly. Also, g is the greater than or equal to function. – isaacg – 2020-02-10T18:52:00.173 @isaacg g gets me wrong output for 1.5 for some reason, but the Q being implicitly filled is interesting, thanks! – famous1622 – 2020-02-10T19:03:42.757 @famous1622 g works fine for me, once I move the Z to the front: Try it online! – isaacg – 2020-02-10T19:05:19.833 @isaacg forgot to flip it, I'mma go get more coffee :P – famous1622 – 2020-02-10T19:06:57.220 3 # GolfScript, 21 20 [bytes] The new solution takes our input and recursively subtracts the inverses from it until we get the solution. Very messy stack management, could probably be done cleaner. ### New Solution (20) 0{).-1?@\-.@\0>}do\;  ### New Solution Explanation 0{).-1?@\-.@\0>}do\; #Take in a number c as input, and output the lowest n s.t. Hn<x 0 # The stack is now [c n=0]. We're just using n here for clarity. { }do # Until we pop a TRUE, loop the following {) }do # Increment n by 1 { . }do # Then duplicate it { -1? }do # Raise the dupe to the power of 1 (inverse) { @\ }do # Move our c to the second element of the stack, between n and 1/n { - }do # Subtract. Stack is now [n c-(1/n)] { . }do # Duplicate c-(1/n) { @\ }do # Move n back to the second element of the stack { 0>}do # Check if our c-(1/n) is less than zero. If so, leave the loop. { }do # If not, repeat, but with c-(1/n) as our new c. \; # Remove c once it's below 0, leaving our tally. This gets outputted.  ### Old Solution (21) :c;0.{$$.-1?@+.c<}do;


### Old Solution Explanation

:c;0.{\).-1?@+.c<}do; # Take in a number c and find the lowest n s.t. Hn>c
:c;                   # Set c to our goal number, then pop it from our stack.
0.                 # Make our stack [0 0]. Let will be our n, right will be our running sum.
{           }do  # At the end of each loop, if the top of the stack isn't 0, repeat.
{\)         }do  # Move the n to the top of the stack and increment it by 1.
{  .-1?     }do  # Duplicate it, then inverse it.
{      @    }do  # Bring our running total to the top (now third in the stack behind 1/n and n)
{       +   }do  # Add the top two elements (running total + 1/n)
{        .  }do  # Duplicate the running total
{         c<}do  # If it's less than c, print 1 (repeat do), else 0 (stop do)
; # Pop our running total, leaving behind just our n.


Shouldn't be too hard to shave a char off somewhere.

Got one.

+1 for this GS submission! if you liked the challenge, consider upvoting it :) – RGS – 2020-02-10T17:24:49.937

2

# Burlesque, 27 bytes

rds1@1moiT{1j?/g1++cm0>=}fi


Try it online!

For some reason save/load seems to be working a bit funny with this one on TIO. To test the code, use the following:

# Burlesque, 28 bytes

rd@1moiT{1j?/++cm0>=}x/4iafi


Try it online!

rd    # Read input as double
[s1]  # Save slot 1
@1    # 1.0
mo    # Infinite multiples of {1.0, 2.0, 3.0...}
iT    # All tails of {{}, {1.0}, {1.0,2.0}, {1.0,2.0,3.0},...}}
{
1j?/ # Reciprocal
++   # Sum
[g1] # Get slot 1 (not working)
cm   # UFO operator (-1 on <, 0 on ==, 1 on >)
-1.> # 0 or 1
}
x/   # Reorder stack
3ia  # Insert input at position 3 of array (before compare)
fi   # Find first index


+1 thanks for your suggestion. I made an edit suggestion to your answer and it gave me the impression that you may have used a templating tool to create the skeleton for your answer. Does what I am saying make any sense? – RGS – 2020-02-09T23:42:48.600

1Sure, not sure it makes much difference though. No templating tool. Just me being lazy in typing. – DeathIncarnate – 2020-02-09T23:52:14.387

2

# Japt, 12 11 bytes

@TwUµ1/X}f1


Try it

1Thanks for the solution! Is there any way you could include an explanation? Also, are you using such a specific version for some reason? – RGS – 2020-02-09T23:44:14.663

2

# Red, 53 bytes

f: func[n][i: 0 until[0 >= n: n -(1.0 /(i: i + 1))]i]


Try it online!

Simple iterative solution.

# Red, 78 bytes

f: func[n /a i][either a[either n > 0[f/a n -(1.0 / i)i + 1][i - 1]][f/a n 1]]


Try it online!

I know this is way longer than other recursive solutions, but I wanted to post it because of the fact that Red functions have fixed arity. In order to simulate default values for the additional parameters, we need to use a refinement - here it's /a- whenever we need the value of the i parameter.

It makes me sad that you have to use all those spaces around the operators :( – RGS – 2020-02-10T09:31:52.380

1@RGS Yes, it's true. This is a deliberate design decision taken by the creator of Rebol (the precursor of Red) – Galen Ivanov – 2020-02-10T09:35:02.657

2

# J, 29 28 bytes

-1 byte thanks to RGS

Shameless translation of Jo King's APL answer.

3 :'>:1 i.~y&<:+/\%}.i.<.^y'


Probably a lot of room for improvement, but I couldn't find a shorter tacit way.

Try it online!

hey, you can save 1 byte. +1 for your J submission. Upvote the challenge if you liked it :)

– RGS – 2020-02-10T17:28:11.337

2

# bc, 52 bytes

define f(x){
scale=999
for(s=i=0;s<x;s=s+1/i)i=i+1
}


Try it online!

If you need more precision, change the 999 to 9E3 or 9E9. Expect memory usage to skyrocket and performance to plummet.

I'm testing a variant that prints as it passes integers. It matches OEIS A004080 so far (23 -> 5471312310). With scale=9, it is correct to 11 -> 33617 but is off by 4 for 12. With scale=99, it is so far accurate to 25 -> 40427833596. Since scale=99 can't be extended without adding another byte, I'm not going to claim it.

bc and dc solutions don't require functions AFAIK. You can put it in the header and footer. You could at least change the variable names. – S.S. Anne – 2020-02-11T02:44:12.037

– David G. – 2020-02-11T02:55:57.130

Interesting solution in a language that hasn't been used in this thread :) +1 – RGS – 2020-02-11T07:03:14.543

2

# Wolfram Language (Mathematica), 29 bytes

(i=0;#//.x_/;x>0:>x-1/++i;i)&


Try it online!

Really simple solution in mathematics :D +1 – RGS – 2020-02-11T07:04:01.920

While it's not as short (40 bytes), it's amusing to note that Mathematica basically has a builtin for this problem: Ceiling@*InverseFunction[HarmonicNumber] – Greg Martin – 2020-02-11T16:30:21.847

1@GregMartin I think everybody knows that by now ;-) Unfortunately, once again the name is pretty big... – J42161217 – 2020-02-11T16:34:25.853

30 bytes – Roman – 2020-02-22T20:31:56.863

1@Roman that was long ago hahah. I posted a different approach which is even shorter! – J42161217 – 2020-02-22T22:15:05.017

2

## Wd, 11 9 bytes

The latest commit is a bugfix - I assume that doesn't make this non-competing?

╪ª4PÄ½┌∙×


Uncompressed:

i1ak/+rb<!W


## Explanation

i         W % Find the first number from 1 to positive infinity
% That satisfies this condition
ak        % Generate a range from 1 to the number
1  /       % Find the reciprocal of every item (automatically vectorises)
b<!  % Is this number greater than or equal to the input?


What happened when you tried to compress the program? – Lyxal – 2020-02-11T11:01:32.980

I feel that the short code length is worth all the downvotes... (If you can't see the answer, someone downvoted my answer.) – None – 2020-02-11T12:06:44.920

I would say bug fixes to the language don't make the answers in said languages non competing. +1 for your W submission! – RGS – 2020-02-11T14:20:04.367

1

# Charcoal, 19 bytes

⊞υ¹Ｗ‹ΣυＩθ⊞υ∕¹⊕ＬυＩＬυ


Try it online! Link is to verbose version of code. Explanation:

⊞υ¹


Start off with n=1, pushing 1/1 to the predefined list.

Ｗ‹ΣυＩθ


Repeat while the list sums to less than the target...

⊞υ∕¹⊕Ｌυ


... push the next Egyptian fraction to the list.

ＩＬυ


Output the length of the list, i.e. n.

It might be possible to reduce the floating-point inaccuracy slightly by adding a Reverse after the Sum.

Thanks for the submission. I don't want to be rude, but at the end of the day, me not knowing charcoal means I can't say your verbose version of the code matches what you wrote here. Why do you always link the verbose version? :) – RGS – 2020-02-09T23:56:04.393

Ah, is it what the flags in the TIO link are for? They print the golfed code? – RGS – 2020-02-09T23:57:01.283

1@RGS Yes, the -v flag translates the verbose code to succinct code and the -l flag prints that code and its byte length, before the succinct code then gets run as if it was the original code. (So occasionally I trip over bugs in the succinct code translator...) – Neil – 2020-02-10T10:28:46.577

you trip on your own bugs? Did you create charcoal? Or you do just in charcoal's bugs? – RGS – 2020-02-10T13:15:38.603

1@RGS My only contribution to Charcoal was to fix a bug caused by a Python 3 update. – Neil – 2020-02-10T14:00:21.280

still very nice. you did more for charcoal than I did :D – RGS – 2020-02-10T17:27:30.117

1

# Keg, -hr, 12 bytes

0&0{¿⑻>|:⑨⑱⑼


Uses the most recent Keg interpreter, so no TIO thus far.

## Explained

0&


We store 0 in the register as this will be the means of storing the total sum of the series.

0


We then push 0 onto the stack, as this will be what keeps track of the term number (n)

{¿⑻>|


The condition of the while loop is that it will repeat while the input (which is automatically filled if no input is given -- the reason why this doesn't have a TIO link) is greater than the value in the register.

⑨


We then increment the top of the stack to get to the next term. This is done before the reciprocal is taken so that we avoid an "off-by-one" error.

:⑱⑼


We then take the reciprocal of the top of the stack and add it to the register (⑱ = 1/x and ⑼ = register += t.o.s). -hr will automatically print the top of the stack at end of execution as an integer.

Here is a Try it online version that uses a variable to keep track of the input. This is mainly just so that y'all can see that the algorithm works, as the variables can be replaced with the above 12 byter.

1Thanks for you keg submission (+1). Were you the one creating keg? Also be sure to upvote the challenge if you liked it. It keeps me going. – RGS – 2020-02-10T07:25:17.917

@RGS yep, guilty as charged :P. Hard to upvote something I've already up voted! – Lyxal – 2020-02-10T07:27:45.600

1+2 for you then :D did you create keg so that you can golf here? – RGS – 2020-02-10T07:30:20.523

1@RGS indeed I did. Y'all can see right through me! :P ;) – Lyxal – 2020-02-10T07:32:06.817

1

# Scratch 3.0, 15 blocks / 127 bytes

when gf clicked
set[n v]to(0
set[t v]to(0
change[n v]by(1
change[t v]by((1)/(n
end
say(n


Just a port of my Keg answer, so Try it online Scratch!

1I find your scratch submissions amusing +1 I think you want a >= and not a > for the repeat test. – RGS – 2020-02-10T07:27:15.507

@RGS, >=? We don't do that round these parts! Really though... Scratch doesn't have a >= operator, so I'll have to make it different :P – Lyxal – 2020-02-10T07:31:03.493

1

## Wd, 8 bytes

Let's see if I can come tied with 05AB1E ...

♠wⁿ=^φ→§


Uncompressed:

kJrJb<!iX


Explanation

       iX % Foreach in [1 .. +inf],
% find first number that satisfies:
k         % Range of 1 .. number
Jr       % Reciprocal each
J      % Summation of entire list
b<!   % Is that >= the input?


Isn't this very similar to your first W submission? – RGS – 2020-02-22T11:28:05.963