Eres un pez en un estanque que necesita sobrevivir comiendo otros peces. Solo puedes comer pescado que sea del mismo tamaño o más pequeño que tú. Debe crear un programa que tome un banco de peces como entrada ordenada. A partir de esto, debe calcular cuántos peces puede comer y, en última instancia, el tamaño al que crecerá.

Carta del tamaño

+--------------+--------------+--------------+--------------+
|              | 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       |
+--------------+--------------+--------------+--------------+

Reglas

1. Tu talla comienza en 1
2. La entrada de bajío contendrá enteros de peces entre 0-9
3. 0 = algas y no te ayudará a alimentarte.
4. El entero de pez representa el tamaño del pez (1-9).
5. Solo puedes comer pescado del mismo tamaño o menos que tú.
6. Puede comer el pescado en el orden que elija para maximizar su tamaño.
7. Solo puedes comer cada pescado una vez.
8. Mientras más pescado comas, más rápido crecerás. Un pez de talla 2 equivale a dos peces de talla 1, un pez de talla 3 equivale a tres peces de talla 1, y así sucesivamente.
9. Su tamaño aumenta en uno cada vez que alcanza las cantidades a continuación.

Devuelve un número entero del tamaño máximo que podría ser

Ejemplos

"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

El código más corto (contando en bytes) para hacerlo en cualquier idioma en el que los números ganen.

JavaScript (ES6), 44 bytes

Toma datos como una matriz de enteros.

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

Pruébalo en línea!

¿Cómo?

$T_s$$s+1$

$s$$t$$t=1$$1$

$x$

• $x$$t$$s\ge x$
• $s$$t > T_s$

Python 2 , 60 bytes

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

Pruébalo en línea!

Wolfram Language (Mathematica) , 40 39 bytes

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

Pruébalo en línea!

Explicación

f:=Floor@s;s=1;

Almacenar floor(s)en f, simbólicamente. Comience con s=1(tamaño).

... /@#

Iterar a través de cada elemento en la entrada ...

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

Si el elemento no es mayor que s, entonces incremente sen <element> / (4 * floor(s)). Los Or (||)cortocircuitos de lo contrario.

f

Retorno floor(s).

Jalea , 17 bytes

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

Pruébalo en línea!

Un método interesante que bien podría ser golpeado por algún tipo de bucle o recursión.

¿Cómo?

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 bytes

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

Pruébalo en línea!

Lua , 214 bytes

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

Pruébalo en línea!

Ni siquiera cerca del más corto aquí, pero fue divertido descubrirlo: D