Bạn là cá trong ao cần sống sót bằng cách ăn những con cá khác. Bạn chỉ có thể ăn những con cá có cùng kích cỡ hoặc nhỏ hơn mình. Bạn phải tạo một chương trình lấy một đàn cá làm đầu vào được sắp xếp. Từ đó, bạn phải tìm ra số lượng cá bạn có thể ăn và cuối cùng là kích thước bạn sẽ tăng lên.

Biểu đồ kích thước

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

Quy tắc

1. Kích thước của bạn bắt đầu từ 1
2. Đầu vào shoal sẽ chứa số nguyên cá trong khoảng 0-9
3. 0 = tảo và sẽ không giúp bạn cho ăn.
4. Số nguyên cá đại diện cho kích thước của cá (1-9).
5. Bạn chỉ có thể ăn cá có cùng kích cỡ hoặc ít hơn mình.
6. Bạn có thể ăn cá theo bất kỳ thứ tự nào bạn chọn để tối đa hóa kích thước của bạn.
7. Bạn chỉ có thể ăn mỗi con cá một lần.
8. Bạn càng ăn nhiều cá, bạn càng phát triển nhanh. Một con cá cỡ 2 bằng hai con cá cỡ 1, con cá cỡ 3 bằng ba con cá cỡ 1, v.v.
9. Kích thước của bạn tăng lên một lần mỗi khi bạn đạt được số tiền dưới đây.

Trả về một số nguyên có kích thước tối đa bạn có thể

Ví dụ

"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

Mã ngắn nhất (tính theo byte) để làm như vậy trong bất kỳ ngôn ngữ nào có số thắng.

JavaScript (ES6), 44 byte

Đưa đầu vào như một mảng các số nguyên.

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

Hãy thử trực tuyến!

Làm sao?

$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

Hãy thử trực tuyến!

Ngôn ngữ Wolfram (Mathicala) , 40 39 byte

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

Hãy thử trực tuyến!

Giải trình

f:=Floor@s;s=1;

Lưu trữ floor(s)trong f, tượng trưng. Bắt đầu với s=1(kích thước).

... /@#

Lặp lại qua từng yếu tố trong đầu vào ...

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

Nếu phần tử không lớn hơn s, thì tăng stheo <element> / (4 * floor(s)). Các Or (||)ngắn mạch khác.

f

Quay trở lại floor(s).

Thạch , 17 byte

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

Hãy thử trực tuyến!

Một phương pháp thú vị có thể bị đánh bại bởi một loại vòng lặp hoặc đệ quy.

Làm sao?

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

Thậm chí không phải là gần ngắn nhất ở đây nhưng thật vui khi tìm ra nó: D