Vous êtes un poisson dans un étang qui doit survivre en mangeant d'autres poissons. Vous ne pouvez manger que des poissons de la même taille ou plus petits que vous. Vous devez créer un programme qui prend un banc de poissons comme entrée triée. À partir de cela, vous devez déterminer le nombre de poissons que vous pouvez manger et, finalement, la taille de votre croissance.

Tableau des tailles

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

Règles

1. Votre taille commence à 1
2. L'entrée du haut-fond contiendra des nombres entiers de poissons entre 0 et 9
3. 0 = algues et ne vous aidera pas à vous nourrir.
4. L'entier poisson représente la taille du poisson (1-9).
5. Vous ne pouvez manger que du poisson de la même taille ou moins que vous.
6. Vous pouvez manger le poisson dans l'ordre de votre choix pour maximiser votre taille.
7. Vous ne pouvez manger chaque poisson qu'une seule fois.
8. Plus vous mangez de gros poissons, plus vous grandissez vite. Un poisson de taille 2 équivaut à deux poissons de taille 1, un poisson de taille 3 équivaut à trois poissons de taille 1, etc.
9. Votre taille augmente d'une unité chaque fois que vous atteignez les montants ci-dessous.

Renvoie un entier de la taille maximale que vous pourriez être

Exemples

"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

Le code le plus court (en comptant en octets) pour le faire dans n'importe quelle langue dans laquelle les nombres gagnent.

JavaScript (ES6), 44 octets

Prend l'entrée comme un tableau d'entiers.

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

Essayez-le en ligne!

Comment?

$T_s$$s+1$

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

$x$

• $x$$t$$s\ge x$
• nous incrémentons $s$$t > T_s$

Python 2 , 60 octets

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

Essayez-le en ligne!

Wolfram Language (Mathematica) , 40 39 octets

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

Essayez-le en ligne!

Explication

f:=Floor@s;s=1;

Conserver floor(s)dans f, symboliquement. Commencez par s=1(taille).

... /@#

Itérer à travers chaque élément en entrée ...

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

Si l'élément n'est pas supérieur à s, incrémentez sde <element> / (4 * floor(s)). Les Or (||)courts-circuits sinon.

f

Retour floor(s).

Gelée , 17 octets

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

Essayez-le en ligne!

Une méthode intéressante qui pourrait bien être battue par une sorte de boucle ou de récursivité.

Comment?

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 octets

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

Essayez-le en ligne!

Lua , 214 octets

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

Essayez-le en ligne!

Pas même le plus court ici, mais c'était amusant de le comprendre: D