Başka bir balık yiyerek hayatta kalması gereken bir havuzda balıksınız. Yalnızca kendinizden aynı boyutta veya daha küçük balıklar yiyebilirsiniz. Sıralı girdi olarak bir balık sürüsü alan bir program oluşturmalısınız. Bundan kaç balık yiyebileceğinizi ve nihayetinde büyüyeceğiniz boyutu hesaplamanız gerekir.

Beden tablosu

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

kurallar

1. Bedeniniz 1'den başlıyor
2. Shoal girişi 0-9 arasında balık tamsayıları içerecektir
3. 0 = yosun ve beslenmenize yardımcı olmaz.
4. Balık tamsayısı balığın büyüklüğünü temsil eder (1-9).
5. Sadece kendinizden aynı boyutta veya daha küçük balık yiyebilirsiniz.
6. Balığınızı en üst düzeye çıkarmak için istediğiniz sırayla yiyebilirsiniz.
7. Her balığı sadece bir kez yiyebilirsiniz.
8. Ne kadar büyük balık yerseniz, o kadar hızlı büyürsünüz. Boyut 2 balık iki boyut 1 balık, boyut 3 balık üç boyut 1 balık ve benzeri anlamına gelir.
9. Aşağıdaki miktarlara her ulaştığınızda bedeniniz birer birer artar.

Olabileceğiniz maksimum boyutta bir tam sayı döndürür

Örnekler

"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

Sayıların kazandığı herhangi bir dilde yapılacak en kısa kod (bayt cinsinden sayma).

JavaScript (ES6), 44 bayt

Girdiyi tamsayılar dizisi olarak alır.

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

Çevrimiçi deneyin!

Nasıl?

$T_s$$s+1$

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

$x$

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

Python 2 , 60 bayt

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

Çevrimiçi deneyin!

Wolfram Dili (Mathematica) , 40 39 bayt

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

Çevrimiçi deneyin!

açıklama

f:=Floor@s;s=1;

Mağaza floor(s)içinde fsembolik olarak. s=1(Size) ile başlayın .

... /@#

Girdideki her öğeyi yineleyin ...

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

Elemanı daha büyük ise s, o zaman artırmak sgöre <element> / (4 * floor(s)). Or (||)Aksi kısa devreler.

f

Dönüş floor(s).

Jöle , 17 bayt

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

Çevrimiçi deneyin!

Bir çeşit döngü veya özyineleme ile iyi dövülebilecek ilginç bir yöntem.

Nasıl?

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 bayt

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

Çevrimiçi deneyin!

Lua , 214 bayt

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

Çevrimiçi deneyin!

Burada en kısa olana bile değil, ama bunu anlamak eğlenceliydi: D