Jesteś rybą w stawie, który musi przetrwać, jedząc inne ryby. Możesz jeść tylko te ryby, które są tego samego rozmiaru lub mniejsze od ciebie. Musisz stworzyć program, który pobiera ławicę ryb jako posortowane dane wejściowe. Na tej podstawie musisz obliczyć, ile ryb możesz zjeść i ostatecznie osiągnąć rozmiar.

Tabela rozmiarów

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

Zasady

1. Twój rozmiar zaczyna się od 1
2. Dane wejściowe do ławicy będą zawierać liczby całkowite ryb od 0 do 9
3. 0 = glony i nie pomogą ci karmić.
4. Liczba całkowita ryby reprezentuje rozmiar ryby (1-9).
5. Możesz jeść tylko ryby o tym samym rozmiarze lub mniejszym od siebie.
6. Możesz jeść ryby w dowolnej kolejności, aby zwiększyć swój rozmiar.
7. Każdą rybę możesz zjeść tylko raz.
8. Im większe ryby jesz, tym szybciej rośniesz. Ryba w rozmiarze 2 to dwie ryby w rozmiarze 1, ryba w rozmiarze 3 to trzy ryby w rozmiarze 1 i tak dalej.
9. Twój rozmiar zwiększa się o jeden za każdym razem, gdy osiągniesz poniższe kwoty.

Zwraca liczbę całkowitą maksymalnego rozmiaru, jaki możesz być

Przykłady

"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

Najkrótszy kod (liczony w bajtach) do wykonania w dowolnym języku, w którym liczby wygrywają.

JavaScript (ES6), 44 bajty

Pobiera dane wejściowe jako tablicę liczb całkowitych.

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

Wypróbuj online!

W jaki sposób?

$T_s$$s+1$

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

$x$

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

Python 2 , 60 bajtów

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

Wypróbuj online!

Wolfram Language (Mathematica) , 40 39 bajtów

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

Wypróbuj online!

Wyjaśnienie

f:=Floor@s;s=1;

Przechowywać floor(s)w fsymbolicznie. Zacznij od s=1(rozmiar).

... /@#

Iteruj przez każdy element na wejściu ...

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

Jeśli element nie jest większy niż s, zwiększ so <element> / (4 * floor(s)). W Or (||)przeciwnym razie zwarcia.

f

Return floor(s).

Galaretka , 17 bajtów

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

Wypróbuj online!

Interesująca metoda, która mogłaby zostać pokonana przez jakąś pętlę lub rekurencję.

W jaki sposób?

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 bajtów

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

Wypróbuj online!

Lua , 214 bajtów

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

Wypróbuj online!

Nawet nie najkrótszy tutaj, ale fajnie było to rozgryźć: D