Anda adalah ikan di kolam yang perlu untuk bertahan hidup dengan makan ikan lainnya. Anda hanya bisa makan ikan dengan ukuran yang sama atau lebih kecil dari diri Anda sendiri. Anda harus membuat sebuah program yang mengambil kawanan ikan sebagai masukan diurutkan. Dari ini Anda harus bekerja keluar berapa banyak ikan yang Anda bisa makan dan akhirnya ukuran Anda akan tumbuh.

Ukuran grafik

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

Aturan

1. Ukuran Anda dimulai pada 1
2. Input beting akan berisi bilangan bulat ikan antara 0-9
3. 0 = ganggang dan tidak akan membantu Anda memberi makan.
4. Bilangan bulat ikan mewakili ukuran ikan (1-9).
5. Anda hanya bisa makan ikan dengan ukuran yang sama atau kurang dari diri Anda sendiri.
6. Anda dapat makan ikan dalam urutan apapun yang Anda pilih untuk memaksimalkan ukuran Anda.
7. Anda hanya bisa makan setiap ikan satu kali.
8. Ikan yang lebih besar Anda makan, semakin cepat Anda tumbuh. Ikan ukuran 2 sama dengan dua ikan ukuran 1, ikan ukuran 3 sama dengan ikan ukuran tiga, dan seterusnya.
9. Ukuran bertahap dengan satu setiap kali Anda mencapai jumlah di bawah ini.

Mengembalikan integer dari ukuran maksimum yang bisa

Contohnya

"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

Kode terpendek (menghitung dalam byte) untuk melakukannya dalam bahasa apa pun di mana angka menang.

JavaScript (ES6), 44 byte

Mengambil input sebagai array bilangan bulat.

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

Cobalah online!

Bagaimana?

$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

Cobalah online!

Wolfram Bahasa (Mathematica) , 40 39 bytes

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

Cobalah online!

Penjelasan

f:=Floor@s;s=1;

Simpan floor(s)di f, secara simbolis. Mulailah dengan s=1(ukuran).

... /@#

Ulangi setiap elemen dalam input ...

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

Jika elemen tidak lebih besar dari s, maka bertambah soleh <element> / (4 * floor(s)). Hubungan Or (||)arus pendek sebaliknya.

f

Kembali floor(s).

Jelly , 17 bytes

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

Cobalah online!

Metode yang menarik yang bisa dipukuli dengan semacam loop atau rekursi.

Bagaimana?

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

Cobalah 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

Cobalah online!

Bahkan dekat terpendek di sini tapi itu menyenangkan untuk mencari tahu: D