Do I need a win streak?

Question

You have played \$N\$ matches in some game where each match can only result in one of the two outcomes: win or loss. Currently, you have \$W\$ wins. You want to have a win percentage of \$P\$ or more, playing as few matches as possible. Output the minimum win streak that you need. Assume the current win streak is at \$0\$.

For example: If \$N=10, W=2, P=50\$, then you can win \$6\$ matches in a row, bringing your win percentage to \$\frac{2+6}{10+6} = \frac{8}{16} = 50\%\$. You cannot have a win percentage of \$50\$ or more earlier than this. So the answer for this case is \$6\$.

Examples

W, N, P ->
2, 10, 50%      -> 6
3, 15, 50%      -> 9
35, 48, 0.75    -> 4
19, 21, 0.91    -> 2
9, 10, 50%      -> 0
0, 1, 1/100     -> 1
43, 281, 24/100 -> 33
0, 6, 52%       -> 7

Rules

• \$N\$ and \$W\$ will be integers with \$0 \le W < N\$.
• The percentage \$P\$ will be an integer between \$1\$ and \$100\$ inclusive. You can also choose to take a decimal value between \$0\$ and \$1\$ inclusive instead, which will contain no more than \$2\$ decimal places, or take it as a fraction.
• You can take the inputs in any convenient format.
• Standard loopholes are forbidden.
• This is code-golf, so the shortest code in bytes wins.

Answer 1

Python 3, 35 bytes

lambda w,n,p:-min(0,(w-p*n)//(1-p))

Try it online!

-4 bytes thanks to pajonk

Some simple math: if \$X\$ is the number of wins we need, then we have:

\$\frac{W+X}{N+X}\geq P\$

\$W+X\geq PN+PX\$

\$X-PX\geq PN-W\$

\$X(1-P)\geq PN-W\$

Since \$P<1\$, then \$1-P>0\$, so we can divide from both sides without division by zero or flipping the sign.

\$X\geq\frac{PN-W}{1-P}\$

Answer 2

05AB1E, 13 15 11 bytes

∞<.Δ¹+.«/²@

Try it online!

Why aren't I using Vyxal? Because I'm leaving the chance for others so they can claim the bounty.

+2 due to bug fix :(

but -4 thanks to @ovs

Explained (old)

∞0š.ΔD²+s¹+s/³@
∞0š.Δ            # get the first integer n where:
     D²+s¹+s/    #     (wins + n) / (matches + n)
             ³@  #     >= percentage 

Answer 3

Jelly, 10 bytes

Ḣ_Ḣ×$÷’Ċ»0

Try it online!

Explanation

This uses the same formula as my Python answer: \$X\geq\frac{W-PN}{P-1}\$

Takes the input as a list of three numbers, \$W,N,P\$.

Ḣ_Ḣ×$÷’Ċ»0  Main Link
Ḣ           W (pops from the list)
 _          minus
  Ḣ×$       N (pops from the list) times the list (now only has P)
     ÷’     divided by (P - 1)
       Ċ    ceiling
        »0  maximum of that and 0

In-depth explanation

This is an even more in-depth explanation of this answer. If you are familiar with Jelly, you should probably skip this. I won't do these often.

Since this link is called with one argument each time, it is a monadic chain. Hence, as we walk down the chain, the following patterns are matched in this order: dyad-monad, dyad-nilad, nilad-dyad, dyad, and monad (nilads take 0 arguments; you can think of them as constants) (monads take 1 argument) (dyads take 2 arguments).

Since the link doesn't start with a nilad, the evaluation value starts equal to the argument, [W, N, P].

First, we see Ḣ, a monad meaning "pop and return the first element". This matches the last rule, so it applies as a monad to the current value, which is [W, N, P]. Thus, the current value is now W, and this also modifies the left argument object itself to [N, P].

Here, it is important to note the function of $ - it takes the last two links and groups them into a monadic link. Here, the two links are Ḣ and ×. We'll get back to this.

Next, we see _, a dyad (subtraction). It is followed by a monad, namely the one formed by the $ grouping two links, thus matching the first pattern. The dyad-monad pattern, if we have some dyad + and some monad F, computes v + F(a) where v is the current value and a is the right argument. Thus, this computes W - F([N, P]). Here, F(a) computes Ḣ× as a monadic chain whose argument is a = [N, P]. The value starts at v = [N, P] as well.

The first link is a monad and thus the value becomes N. Also, since "pop" mutates, the argument (to both the sub-link and the main link) is now [P]. Then, the second link is a dyad and nothing else follows, so the value becomes N × [P] which is [NP]. This is a singleton list, not a value, but that's fine because everything else vectorizes.

Now, the value is W - [NP] which vectorizes to [W - NP], and the argumnt is [P] since it was mutated within the sub-link.

÷’ is a dyad-monad chain, which computes [W - NP] ÷ P÷’. ’ decrements, so this computes [W - NP] ÷ (P - 1), which vectorizes to [(W - NP) / (P - 1)].

Penultimately, Ċ is a monad meaning "ceiling", which just rounds all of these values up. Finally, »0 is a dyad-nilad chain which takes the maximum of this value and 0, thus preventing negative outputs.

Here's a shitty hand-drawn visualization of how chaining works out here:

Answer 4

R, 45 43 42 38 bytes

Edit: simultaneous discovery of -1 byte by Kirill L., and then -4 bytes thanks to pajonk

function(W,N,P)-min((W-P*N)%/%(1-P),0)

Try it online!

Answer 5

PowerShell, 44 bytes

Every answer of Wasif inspires me to make the right one. Thanks.

param($w,$n,$p)for(;$w++/$n++-lt$p){$k++}+$k

Try it online!

Answer 6

Clojure, 39 bytes

#(max(Math/ceil(/(-(* %2%)%3)(- 1%)))0)

Try it online!

Takes arguments in reverse order compared to the provided test cases (\$P, N, W\$).

Answer 7

Jelly, 9 bytes

0+÷/:⁴ʋ1#

Try it online!

Full program that takes [w, n] on the left and P on the right.

How it works

0+÷/:⁴ʋ1# - Main link. Takes [w, n] on the left and P on the right
      ʋ   - Previous 4 links as a dyad f(x, [w, n]):
 +        -   Yield [w+x, n+x]
  ÷/      -   Yield (w+x)÷(n+x)
     ⁴    -   Yield P
    :     -   Floor divide (w+x)÷(n+x) by P,
               returning 0 if P < (w+x)÷(n+x), and 1 otherwise
0      1# - Count up x = 0, 1, 2, ..., and find the first x such that f(x, [w, n]) is 1

Answer 8

PowerShell, 51 bytes

param($w,$n,$p)while(($w+$k)/($n+$k)-lt$p){$k+=1}$k

Try it online!

What? It beat my python answer? oO

Answer 9

Ruby, 34 bytes

->w,n,p{[0,-(w-p*n).div(1-p)].max}

Try it online!

Answer 10

Retina 0.8.2, 68 bytes

\d+
$*
\G1
100$*
1(?=1*,(1*)%)
$1
+`^(1*,)(1+\1(1+))
100$*1$1$3$2_
_

Try it online! Link includes test cases. Takes P as a percentage (including % sign). Explanation:

\d+
$*

Convert W, N and P to unary.

\G1
100$*

Multiply W by 100.

1(?=1*,(1*)%)
$1

Multiply N by P.

+`^(1*,)(1+\1(1+))

While 100W<NP...

100$*1$1$3$2_

increment W and N, i.e. add 100 to 100W and P to NP.

_

Count the number of increments made.

Answer 11

JavaScript, 44 40 34 bytes

f=(w,n,p)=>w/n>=p?0:f(w+1,n+1,p)+1

Takes all three parameters as integers except p which is a decimal.

-4 bytes, thanks to @DominicvanEssen -6 bytes, thanks to @Arnauld

Try it online

Answer 12

Haskell, 37 bytes

(n,w)#p|100*w<p*n=1+(n+1,w+1)#p|1>0=0

Try it online!

Answer 13

Pari/GP, 31 bytes

f(W,N,P)=-min(-(P*N-W)\(1-P),0)

Try it online!

Answer 14

Python 3, 55 bytes

f=lambda w,n,p,c=0:(w+c)/(n+c)>=p and c or f(w,n,p,c+1)

Try it online!

Simple recursion, I am beaten by few minutes....

Answer 15

Charcoal, 24 bytes

ＮθＮηＮζ≔⁰εＷ‹⁺θε×ζ⁺ηε≦⊕εＩε

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

ＮθＮηＮζ

Input W, N and P.

≔⁰ε

Start with X=0.

Ｗ‹⁺θε×ζ⁺ηε

Until we reach the desired win percentage...

≦⊕ε

... increment X.

Ｉε

Output X.

A port of @hyper-neutrino's solutions is of course much shorter at 13 bytes:

Ｉ⌈⟦⁰±÷⁻×ＮＮＮ⊖θ

Try it online! Link is to verbose version of code. Takes input in the order P, N, W. Explanation:

        Ｎ       `P` as a number
       ×        Multiplied by
         Ｎ      `N` as a number
      ⁻         Subtract
          Ｎ     `W` as a number
     ÷          Floor divided by
           ⊖θ   `P` decremented
    ±           Negated
 ⌈⟦⁰            Maximum of that and 0
Ｉ               Cast to string
                Implicitly print

Answer 16

Japt, 11 bytes

@°*L¨V°*W}a

Try it

Answer 17

CSASM v2.4.0.1, 123 bytes

A function which pops three values from the stack ([N, W, P]) and pushes the result as an f64.
The function expects the types of all three values to be f64.

.include <stdmath>
func a:
pop $3
pop $2
pop $1
push $3
dup
push $2
swap
push $1
mul
sub
neg
swap
push 1.0
sub
div
neg
push 0.0
call max
ret
end

Explanation + Full Program:

.include <stdmath>

func main:
    ; Get the three inputs
    in "N: "
    conv f64

    in "W: "
    conv f64

    in "P: "
    conv f64

    call a

    ; Truncate the result and print it
    conv i32
    push "Wins needed: "
    swap
    add
    print.n

    ret
end

func a:
    pop $3 ; P
    pop $2 ; W
    pop $1 ; N

    push $3
    ; [ P ]
    dup
    ; [ P, P ]

    push $2
    ; [ P, P, W ]
    swap
    ; [ P, W, P ]
    push $1
    ; [ P, W, P, N ]
    mul
    ; [ P, W, P*N ]
    sub
    ; [ P, W-P*N ]
    neg
    ; [ P, P*N-W ]
    swap
    ; [ P*N-W, P ]
    push 1.0
    ; [ P*N-W, P, 1 ]
    sub
    ; [ P*N-W, P-1 ]
    div
    ; [ (P*N-W)/(P-1) ]
    neg
    ; [ -(P*N-W)/(P-1) ]
    push 0.0
    call max

    ret
end
```

Answer 18

Wolfram Language (Mathematica), 25 bytes

0//.x_/;x+#-##2<x#3:>x+1&

Try it online!

We can also directly compute the number of needed wins:

Wolfram Language (Mathematica), 25 bytes

⌈Min[#-##2,0]/--+#3⌉&

Try it online!

Answer 19

Japt, 9 bytes

Takes P as a decimal.

@°/V°<W}f

Try it

Answer 20

JavaScript, 28 bytes

Takes P as a decimal and outputs false for 0.

w=>n=>g=p=>w++/n++<p&&g(p)+1

Try it online!

Answer 21

Vyxal 2.4.1, 8 bytes

λ¹+ɖ⁰≥;ṅ

Try it Online! Here's what I managed to come up with. It doesn't seem like anyone else is going to give this a go using Vyxal, so here's my solution.

Explained

λ¹+ɖ⁰≥;ṅ
λ        # start a lambda that, given a single argument "n":
 ¹+      #     adds n to the list [wins, matches]
   ɖ     #     reduces that list by division
    ⁰≥;  #    and returns whether that number is greater than the percentage
       ṅ # take that lambda, and find the first integer (starting at 0) where it evaluates as truthy