您是池塘中的鱼，需要吃其他鱼才能生存。您只能吃比自己大或小的鱼。您必须创建一个程序，将鱼群作为已排序的输入。由此，您必须算出可以吃多少鱼，最终算出鱼的大小。

尺寸表

+--------------+--------------+--------------+--------------+
|              | Amount extra | Total size 1 | Increase to  |
| Current size |  needed for  |     fish     |    size      |
|              |  next size   |              |              |
+--------------+--------------+--------------+--------------+
|      1       |      4       |      4       |      2       |
+--------------+--------------+--------------+--------------+
|      2       |      8       |      12      |      3       |
+--------------+--------------+--------------+--------------+
|      3       |      12      |      24      |      4       |
+--------------+--------------+--------------+--------------+
|      4       |      16      |      40      |      5       |
+--------------+--------------+--------------+--------------+
|      5       |      20      |      60      |      6       |
+--------------+--------------+--------------+--------------+
|      6       |      24      |      84      |      7       |
+--------------+--------------+--------------+--------------+

规则

1. 您的尺码从1开始
2. 浅滩输入将包含0-9之间的鱼整数
3. 0 =藻类，不会帮助您进食。
4. 鱼整数表示鱼的大小（1-9）。
5. 您只能吃大小不等的鱼。
6. 您可以选择任何顺序吃鱼，以最大化鱼的大小。
7. 每条鱼只能吃一次。
8. 您吃的鱼越大，生长速度就越快。大小为2的鱼等于两个大小为1的鱼，大小为3的鱼等于三个大小为1的鱼，依此类推。
9. 每次达到以下数量时，尺寸都会增加一。

返回最大大小的整数

例子

"11112222" => 3  
4 fish size 1 increases to 2, 4 size 2 makes you 3

"111111111111" => 3
4 fish size 1 increases to 2, 8 size 1 makes you 3

用数字获胜的任何语言的最短代码（以字节为单位）。

JavaScript（ES6），44个字节

将输入作为整数数组。

a=>a.map(x=>s+=(t+=s>=x&&x)>s*-~s*2,t=s=1)|s

在线尝试！

怎么样？

达到大小s + 1的阈值由下式给出：$T_s$$s+1$

我们跟踪当前大小（以以及到目前为止所吃的t（我们以t = 1开头，因此实际上偏离了1）。$s$$t$$t=1$$1$

对于浅滩中的每条鱼，假定其从最小到最大排序：$x$

• 我们增加到牛逼（即我们吃的鱼），每当我们有小号≥ $x$$t$$s\ge x$
• $s$$t > T_s$

Python 2，60个字节

f=lambda l,n=1,c=1:c>n*~-n*2and f(l,n+1,c+l.count(n)*n)or~-n

在线尝试！

Wolfram语言（Mathematica），40 39字节

(f:=Floor@s;s=1;s<#||(s+=#/4/f)&/@#;f)&

在线尝试！

说明

f:=Floor@s;s=1;

象征性地存储floor(s)在中f。从s=1（大小）开始。

... /@#

遍历输入中的每个元素...

s<#||(s+=#/4/f)

如果元素不大于s，然后增加s的<element> / (4 * floor(s))。该Or (||)短路，否则。

f

返回floor(s)。

果冻，17 个字节

J×4ÄfSR$ịx`>JTḢȯ1

在线尝试！

一个有趣的方法很可能会被某种循环或递归所击败。

怎么样？

J×4ÄfSR$ịx`>JTḢȯ1 - Link: list A (ascending digits) e.g. [1,1,1,1,1,1,1,2,2,3]
J                 - range of length                      [1,2,3,4,5,6,7,8,9,10]
 ×4               - multiply all by 4                    [4,8,12,16,20,24,28,32,36,40]
   Ä              - cumulative sums                      [4,12,24,40,60,84,112,144,180,220]
       $          - last two links as a monad (of A):
     S            -   sum                                14
      R           -   range                              [1,2,3,4,5,6,7,8,9,10,11,12,13,14]
   f              - filter keep                          [4,12]
          `       - use left argument as right with:
         x        -   repeat elements                    [1,1,1,1,1,1,1,2,2,2,2,3,3,3]
        ị         - index into                           [      1,              3    ]
                  -                                    = [1,3]
            J     - range of length (of A)               [1,2,3,4,5,6,7,8,9,10]
           >      - greater than?                        [0,1,3,4,5,6,7,8,9,10]
                  -                1 not greater than 1---^ ^---3 is greater than 2
                  -   (note keeps values of longer - i.e. the 3,4,... here)
             T    - truthy indices                       [  2,3,4,5,6,7,8,9,10]
              Ḣ   - head                                 2
                1 - literal one                          1
               ȯ  - logical OR                           2
                  -   (edge-case handling when the head of an empty list yields 0)
                  -   (note that when the shoal is fully consumed the final size will
                  -    still be less than the length of that shoal, so TḢ will still give
                  -    this size due to >J keeping values of the longer argument.)

Haskell，46个字节

(!0)
a!b|sum[y|y<-a,y<=b]/2<b*b+b=b|q<-b+1=a!q

在线尝试！

Lua 214字节

l,f=1,{}for j=1,9 do s,f[j]=(...):gsub(j,0)end::z::a,n=0,l*4 for i=1,l do a=a+i*f[i]end if a>=n then e=l while n>0 do if 0<f[e]and e<=n then n=n-e f[e]=-1+f[e]else e=e-1 end end l=l+1 else print(l)return end goto z

在线尝试！

甚至不是最短的一个，但是很有趣找出它：D