Você é peixe em um lago que precisa sobreviver comendo outros peixes. Você só pode comer peixe do mesmo tamanho ou menor que você. Você deve criar um programa que leve um cardume de peixes como entrada classificada. A partir disso, você deve descobrir quantos peixes você pode comer e, finalmente, o tamanho em que crescerá.

Carta do tamanho

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

Regras

1. Seu tamanho começa em 1
2. A entrada do cardume conterá números inteiros de peixes entre 0 e 9
3. 0 = algas e não ajudará você a se alimentar.
4. O número inteiro do peixe representa o tamanho do peixe (1-9).
5. Você só pode comer peixe do mesmo tamanho ou menos que você.
6. Você pode comer o peixe em qualquer ordem que você escolher para maximizar seu tamanho.
7. Você só pode comer cada peixe uma vez.
8. Quanto maior o peixe que você come, mais rápido você cresce. Um peixe tamanho 2 é igual a dois peixes tamanho 1, tamanho 3 é igual a três peixes tamanho 1 e assim por diante.
9. Seu tamanho é incrementado em um cada vez que você atinge os valores abaixo.

Retorna um número inteiro do tamanho máximo que você poderia ter

Exemplos

"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

O código mais curto (contando em bytes) para fazê-lo em qualquer idioma em que os números vencem.

JavaScript (ES6), 44 bytes

Recebe a entrada como uma matriz de números inteiros.

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

Experimente online!

Quão?

$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

Experimente online!

Wolfram Language (Mathematica) , 40 39 bytes

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

Experimente online!

Explicação

f:=Floor@s;s=1;

Armazenar floor(s)em f, simbolicamente. Comece com s=1(tamanho).

... /@#

Iterar através de cada elemento na entrada ...

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

Se o elemento não for maior que s, aumente sem <element> / (4 * floor(s)). Os Or (||)curto-circuitos de outra forma.

f

Retorno floor(s).

Geléia , 17 bytes

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

Experimente online!

Um método interessante que pode muito bem ser derrotado por algum tipo de loop ou recursão.

Quão?

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

Experimente online!

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

Experimente online!

Nem mesmo o mais curto aqui, mas foi divertido descobrir: D