这个想法归功于TNB中的Geobits

最近，一篇没有足够详细信息的帖子提出了一个有趣的游戏：

2个孩子坐在一系列糖果前。每块糖果的编号为1到x，代表x存在的糖果总量。每个数字恰好出现1次。

游戏的目标是让孩子们吃糖果并乘以他们所吃糖果的价值，以获得最终分数，并获得更高的分数。

但是，原始帖子错过了关键信息（例如糖果的选择方式），因此我们故事中的孩子们决定大一点的孩子可以先吃，最多可以吃一半的糖果，但是一旦他宣布转身结束，他不能改变主意。

这个游戏中的一个孩子不喜欢糖果，所以他想尽可能少吃东西，而且他曾经看着父亲一次写过一些代码，并且他可以利用从中获得的技能来算出多少糖果他需要吃东西以确保胜利，同时仍然尽可能少吃东西。

挑战

给定糖果总数，即使对手将所有剩余的糖果都吃掉了x，您的程序或函数也应该输出为保证胜利而必须吃的最少n的糖果。

自然地，数字越大，数字越大，所以无论您给他多少，他都会吃掉 n最多的数字。

规则

• x在您的语言的数字处理能力的上限范围内，将始终是一个正整数0 < x! <= ll
• 确保孩子总是吃n最多的，例如x = 5和n = 2，他将吃4和5

测试用例

x = 1
n = 1
(1 > 0)

x = 2
n = 1
(2 > 1)

x = 4
n = 2
(3 * 4 == 12 > 1 * 2 == 2)

x = 5
n = 2
(4 * 5 == 20 > 1 * 2 * 3 == 6)

x = 100
n = 42
(product([59..100]) > product([1..58]))

x = 500
n = 220
(product([281..500]) > product([1..280]))

计分

不幸的是，我们勇敢的参赛者没有什么可编写的代码，因此他必须将糖果拼凑成代码的字符，因此，您的代码需要尽可能小，以字节为单位的最小代码才是成功的！

Python 3，76个字节

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)

在线尝试！

依靠这样的事实：吃$n$糖果仍然可以获胜，并且糖果总数为$x$，$\frac{x!}{(x-n)!}>(x-n)!$必须为true，这意味着$x!>((x-n)!)^2$。

来自Skidsdev的-1

BMO的-3 -6

-3来自Sparr

+6修复 x = 1

JavaScript（ES6），53个字节

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

在线尝试！

工作范围

有趣的是，孩子们的产品之间的差异总是足够大，以至于IEEE 754编码固有的精度损失不是问题。

其结果是，它为$0 \le n \le 170$。除此之外，尾数和指数溢出（产生+ Infinity）都需要BigInts（+1字节）。

怎么样？

设$p$为另一个孩子的糖果产品，设$q$为我们自己的糖果产品。

1. 我们从$p=n!$开始！（所有给另一个孩子的糖果）和$q=1$（对我们来说没有）。

2. 我们重复以下操作，直到$q\ge p$：

   • 将$p$除以$n$
   • 乘$q$由$n$
   • 递减$n$

结果是所需的迭代次数。（在每次迭代中，我们“从另一个孩子那里拿走第二高的糖果”。）

已评论

这被实现为单个递归函数，该递归函数首先计算$n!$然后进入上述循环。

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

果冻，9 字节

ḊPÐƤ<!€TL

在线尝试！或查看测试套件。

怎么样？

Ḋ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

R，70 41 38字节

-29因为丹尼斯知道所有内部功能

-3切换到scan（）输入

sum(prod(x<-scan():1)<=cumprod(1:x)^2)

在线尝试！

nedla2004的Python3 Answer的相当简单的R实现。

我觉得1-处理的实现更干净，并且我想丢失花括号。

我很生气，我没有回到使用哪种方法，更疯狂地使用我的严格小于，但是甚至更疯狂地我都不知道有一个cumprod()功能。丹尼斯的出色优化。

APL（Dyalog Unicode），10个字节

+/!≤2*⍨!∘⍳

在线尝试！

丹尼斯港的答案。感谢Dennis。

怎么样：

+/!≤2*⍨!∘⍳ ⍝ Tacit function, takes 1 argument (E.g. 5)
         ⍳ ⍝ Range 1 2 3 4 5
       !∘  ⍝ Factorials. Yields 1 2 6 24 120
    2*⍨    ⍝ Squared. Yields 1 4 36 576 14400
  !        ⍝ Factorial of the argument. Yields 120.
   ≤       ⍝ Less than or equal to. Yields 0 0 0 1 1
+/         ⍝ Sum the results, yielding 2.

由于此答案并非我严格执行，因此我将原始答案保留在下面。

APL（Dyalog Unicode），14 12 11字节

(+/!>×\)⌽∘⍳

在线尝试！

前缀默认功能。基本上是Dyalog端口乔纳森答案。

感谢ngn和H.PWiz提供的聊天帮助。也感谢ngn为我节省了一个字节。

感谢Dennis指出我的原始代码是错误的。原来，它为我节省了2个字节。

用途⎕IO←0。

怎么样：

+/(!>×\)∘⌽∘⍳ ⍝ Tacit function, taking 1 argument (E.g. 5).
           ⍳ ⍝ Range 0 1 2 3 4
         ⌽∘  ⍝ Then reverse, yielding 4 3 2 1 0
  (    )∘    ⍝ Compose with (or: "use as argument for")
   !         ⍝ Factorial (of each element in the vector), yielding 24 6 2 1 1
     ×\      ⍝ Multiply scan. Yields 4 12 24 24 0
    >        ⍝ Is greater than. Yields 1 0 0 0 1
+/           ⍝ Finally, sum the result, yielding 2.

哈斯克尔（52） 51字节

使用简单的方法：我们检查最后一个产品是否 $n$ 数字，这是 $\frac{x!}{(x-n)!}$ 小于第一个的乘积 $n$ 数字，即 $(x-n)!$ 最少 $n$ 为此，这是真的。

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

在线尝试！

果冻，7个字节

R!²<!ċ0

在线尝试！

怎么运行的

R!²<!ċ0  Main link. Argument: n

R        Range; yield [1, ..., n].
 !       Map factorial over the range.
  ²      Take the squares of the factorials.
    !    Compute the factorial of n.
   <     Compare the squares with the factorial of n.
     ċ0  Count the number of zeroes.

Python 3中，183个 176 149字节

R=reversed
def M(I,r=1):
 for i in I:r*=i;yield r
def f(x):S=[*range(1,x+1)];return([n for n,a,b in zip([0]+S,R([*M(S)]),[0,*M(R(S))])if b>a]+[x])[0]

在线尝试！

它比其他一些解决方案快很多-0（N）乘法而不是O（N²）-但我无法设法减少代码大小。

-27来自Jo King

干净，57字节

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

在线尝试！

直接解决方案。

05AB1E，15 11字节

E!IN-!n›iNq

在线尝试！

E!IN-!n›iNq

E                For loop with N from [1 ... input]
 !               Push factorial of input    
  IN-            Push input - N (x - n)
     !           Factorial
      n          Square
       ›         Push input! > (input - N)^2 or x! > (x - n)^2
        i        If, run code after if top of stack is 1 (found minimum number of candies)
         N       Push N
          q      Quit, and as nothing has been printed, N is implicitly printed

使用与我的Python相同的方法提交。对于05AB1E非常新，因此非常感谢任何有关代码或解释的提示。

-4个字节，感谢Kevin Cruijssen

果冻，14字节

ạ‘rP>ạ!¥
1ç1#«

在线尝试！

正确处理1。

木炭，20字节

ＮθＩ⊕ΣＥθ‹Π⊕…ιθ∨Π…¹⊕ι¹

在线尝试！链接是详细版本的代码。说明：

Ｎθ                      Input `n`
    Σ                   Sum of
      θ                 `n`
     Ｅ                  Mapped over implicit range
        Π               Product of
           ι            Current value
          …             Range to
            θ           `n`
         ⊕              Incremented
       ‹                Less than
              Π         Product of
                ¹       Literal 1
               …        Range to
                  ι     Current value
                 ⊕      Incremented
             ∨          Logical Or
                   ¹    Literal 1
   ⊕                    Incremented
  Ｉ                     Cast to string
                        Implicitly print

Product在木炭的空列表上返回None而不是1，因此我必须从逻辑上讲Or。

的PHP，107字节

<?php $x=fgets(STDIN);function f($i){return $i==0?:$i*f($i-1);}$n=1;while(f($x)<f($x-$n)**2){$n++;}echo $n;

在线尝试！

使用相同 $x^2>((x-1)!)^2$ 其他人使用的方法。

使用PHP提交中的阶乘函数来应对这一挑战（感谢@ donutdan4114）

Wolfram语言（Mathematica），43个字节

Min[n/.Solve[#!>(#-n)!^2, Integers]]/.n->1&

在线尝试！

05AB1E，7 个字节

L!ns!@O

丹尼斯港♦ '果冻的答案，因此，如果您喜欢此答案，请确保对他进行投票！

在线尝试或验证所有测试用例。

说明：

L          # List in the range [1, (implicit) input]
 !         # Take the factorial of each
  n        # Then square each
   s!      # Take the factorial of the input
     @     # Check for each value in the list if they are larger than or equal to the
           # input-faculty (1 if truthy; 0 if falsey)
      O    # Sum, so determine the amount of truthy checks (and output implicitly)

杰普特 -x，7个字节

Dennis的Jelly解决方案端口。

仅在实践中有效，直到n=4我们进入高于此的科学计数法为止。

õÊ®²¨U²

尝试一下

õ           :Range [1,input]
 Ê          :Factorial of each
  ®         :Map
   ²        :  Square
    ¨       :  Greater than or equal to
     U²     :  Input squared
            :Implicitly reduce by addition

C＃（.NET Core），93字节

n=>{int d(int k)=>k<2?1:k*d(k-1);int a=1,b=d(n),c=n;for(;;){a*=n;b/=n--;if(a>=b)return c-n;}}

在线尝试！

基于@Arnauld的javascript答案。

C（gcc），68个字节

n;f(x){int i=2,j=x,b=1,g=x;while(i<j)b*i>g?g*=--j:(b*=i++);n=x-j+1;}

在线尝试！

Edit: trading bytes against mults, no doing 2*x mults instead of x+n

Edit: moving back to int instead of long through macro. Would fail at 34 with long.

Well I have this in C. Fails at 21.

There is a possible ambiguity as to whether the good kid wants to always win or never lose... what do you think?

Python 3, 75 bytes

f=lambda n:n<1or f(n-1)*n
n=lambda x:x-sum(f(n)**2<f(x)for n in range(1,x))

Try it online!

74 bytes version

f=lambda n:n<1or f(n-1)*n
n=lambda x:1+sum(f(n)>f(x)**.5for n in range(x))

but this version overflowed for 500...