Python 3, 76 bytes

F=lambda x:x<2or x*F(x-1)

f=lambda x,n=1:x<2or n*(F(x)>F(x-n)**2)or f(x,n+1)

Try it online!

Relies on the fact that for eating $n$ candies to still win and the total number of candies being $x$, $frac{x!}{(x-n)!}>(x-n)!$ must be true, which means $x!>((x-n)!)^2$.

-1 from Skidsdev

-3 -6 from BMO

-3 from Sparr

+6 to fix x = 1

Haskell, 52 51 bytes

Using the straightforward approach: We check whether the product of the last $n$ numbers, which is $frac{x!}{(x-n)!}$ is less than the product of the first $n$ numbers, namely $(x-n)!$ and takes the least $n$ for which this is true.

g b=product[1..b]

f x=[n|n<-[1..],g(x-n)^2<=g x]!!0

Try it online!

Clean, 57 bytes

import StdEnv

$x=while(e=prod[1..x-e]^2>prod[1..x])inc 1

Try it online!

A straight-forward solution.

Jelly, 9 bytes

ḊPÐƤ<!€TL

Try it online! Or see the test-suite.

How?

ḊPÐƤ<!€TL - Link: integer, x                   e.g. 7

Ḋ         - dequeue (implicit range of x)           [   2,   3,   4,   5,   6,   7]

  ÐƤ      - for postfixes [all, allButFirst, ...]:

 P        -   product                               [5040,2520, 840, 210,  42,   7]

      €   - for each (in implicit range of x):

     !    -   factorial                             [   1,   2,   6,  24, 120, 720, 5040]

    <     - (left) less than (right)?               [   0,   0,   0,   0,   1,   1, 5040]

          -   -- note right always 1 longer than left giving trailing x! like the 5040 ^

       T  - truthy indices                          [                       5,   6, 7   ]

        L - length                                  3

Python 3, 183 176 bytes

R=reversed

L=list

def M(I):

 r=1

 for i in I:

  r*=i

  yield r

def f(x):

 S=L(range(1,x+1))

 for(n,a,b)in zip([0]+S,R(L(M(S))),[0]+L(M(R(S)))):

  if(b>a):

   return n

 return x

Try it online!

It's is a lot faster than some other solutions - 0(N) multiplications instead of O(N²) - but I can't manage to reduce code size.

Jelly, 14 bytes

ạ‘rP>ạ!¥

1ç1#«

Try it online!

Handles 1 correctly.

JavaScript (ES6), 53 bytes

n=>(g=p=>x<n?g(p*++x):q<p&&1+g(p/n,q*=n--))(q=x=1)||n

Try it online!

Works up to $a(170)$. Beyond that, we'd need BigInts (+1 byte).

How?

We start with $p=n!$ and $q=1$.

You can think of $q$ as the product of our candies and of $p$ as the product of the candies of the other kid. (So at the beginning of the process, the other kid has all the candies and we have none.)

Then we repeat the following operations:

• divide $p$ by $n$
  


• multiply $q$ by $n$
  


• decrement $n$
  

until $qge p$.

The result is the number of required iterations. (At each iteration, we 'take the next highest candy from the other kid'.)

Commented

This is implemented as a single recursive function which first compute $n!$ and then enters the loop described above.

n => (           // main function taking n

  g = p =>       // g = recursive function taking p

    x < n ?      //   if x is less than n:

      g(         //     this is the first part of the recursion:

        p * ++x  //     we're computing p = n! by multiplying p

      )          //     by x = 1 .. n

    :            //   else (second part):

      q < p &&   //     while q is less than p:

      1 + g(     //       add 1 to the final result

        p / n,   //       divide p by n

        q *= n-- //       multiply q by n; decrement n

      )          //

)(q = x = 1)     // initial call to g with p = q = x = 1

|| n             // edge cases: return n for n < 2

05AB1E, 15 bytes

EI!IN-!n›Ði–#]1

Try it online!

EI!IN-!n›Ði–#]1



E                For loop with N from [1 ... input]

 I!              Push factorial of input    

   IN-           Push input - N (x - n)

      !          Factorial

       n         Square

        ›        Push input! > (input - N)^2 or x! > (x - n)^2

         Ð       Triplicate, used for three upcoming operations (if, print, end)

          i      If, run code after if top of stack is 1 (found minimum number of candies)

           –     Print N if top of stack is 1

            #]   Ends for loop and program is top of stack is 1

              1  Pushes 1 so that if the input is 1 and we leave the for loop without

                     printing anything 1 is printed

Uses the same approach as my Python submission. Very new to 05AB1E so any tips on code or explaination greatly appreciated.