Sei un pesce in uno stagno che deve sopravvivere mangiando altri pesci. Puoi mangiare solo pesci della stessa taglia o più piccoli di te. È necessario creare un programma che accetta un branco di pesci come input ordinato. Da questo devi capire quanti pesci puoi mangiare e, in definitiva, le dimensioni che crescerai.

Tabella di formato

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

Regole

1. La tua taglia inizia da 1
2. L'ingresso del banco conterrà numeri interi di pesce tra 0-9
3. 0 = alghe e non ti aiuteranno a nutrirti.
4. Il numero intero di pesce rappresenta la dimensione del pesce (1-9).
5. Puoi mangiare solo pesci della stessa taglia o meno di te stesso.
6. Puoi mangiare il pesce in qualsiasi ordine tu scelga per massimizzare la tua taglia.
7. Puoi mangiare ogni pesce solo una volta.
8. Più pesce mangi, più velocemente cresci. Un pesce di taglia 2 equivale a due pesci di taglia 1, un pesce di taglia 3 equivale a tre pesci di taglia 1 e così via.
9. Le dimensioni aumentano di una ogni volta che raggiungi gli importi seguenti.

Restituisce un numero intero della dimensione massima che potresti essere

Esempi

"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

Il codice più breve (conteggio in byte) per farlo in qualsiasi lingua in cui i numeri vincono.

JavaScript (ES6), 44 byte

Accetta l'input come una matrice di numeri interi.

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

Provalo online!

Come?

$T_s$$s+1$

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

$x$

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

Python 2 , 60 byte

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

Provalo online!

Wolfram Language (Mathematica) , 40 39 byte

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

Provalo online!

Spiegazione

f:=Floor@s;s=1;

Conservare floor(s)in f, simbolicamente. Inizia con s=1(dimensione).

... /@#

Scorrere tutti gli elementi nell'input ...

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

Se l'elemento non è maggiore di s, incrementa sdi <element> / (4 * floor(s)). I Or (||)cortocircuiti altrimenti.

f

Ritorno floor(s).

Gelatina , 17 byte

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

Provalo online!

Un metodo interessante che potrebbe essere battuto da una sorta di loop o ricorsione.

Come?

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 byte

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

Provalo online!

Lua , 214 byte

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

Provalo online!

Nemmeno il più breve qui, ma è stato divertente capirlo: D