Sie sind Fische in einem Teich, der überleben muss, indem Sie andere Fische essen. Sie können nur Fisch essen, der gleich groß oder kleiner ist als Sie. Sie müssen ein Programm erstellen, das einen Fischschwarm als sortierte Eingabe verwendet. Daraus müssen Sie herausfinden, wie viele Fische Sie essen können und wie groß Sie letztendlich werden.

Größentabelle

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

Regeln

1. Deine Größe beginnt bei 1
2. Die Schwärmeingabe enthält ganze Fischzahlen zwischen 0 und 9
3. 0 = Algen und helfen nicht beim Füttern.
4. Die Fisch-Ganzzahl repräsentiert die Größe des Fisches (1-9).
5. Sie können nur Fisch essen, der nicht größer als Sie selbst ist.
6. Sie können den Fisch in beliebiger Reihenfolge essen, um Ihre Größe zu maximieren.
7. Sie können jeden Fisch nur einmal essen.
8. Je größer der Fisch, den Sie essen, desto schneller wachsen Sie. Ein Fisch der Größe 2 entspricht zwei Fischen der Größe 1, ein Fisch der Größe 3 entspricht drei Fischen der Größe 1 und so weiter.
9. Ihre Größe wird jedes Mal um eins erhöht, wenn Sie die unten angegebenen Beträge erreichen.

Gibt eine Ganzzahl der maximalen Größe zurück, die Sie haben könnten

Beispiele

"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

Der kürzeste Code (in Bytes), der in einer beliebigen Sprache, in der Zahlen gewinnen, verwendet werden kann.

JavaScript (ES6), 44 Byte

Nimmt die Eingabe als Array von Ganzzahlen.

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

Probieren Sie es online!

Wie?

Die Schwelle zum Erreichen der Größe ist gegeben durch: s + $T_s$$s+1$

Wir verfolgen unsere aktuelle Größe in und was wir bisher in gegessen haben (wir beginnen mit , dies ist also tatsächlich um ).t t = 1 $s$$t$$t=1$$1$

Für jeden Fisch im Schwarm wird angenommen, dass er vom kleinsten zum größten sortiert ist:$x$

• Wir addieren zu (dh wir essen den Fisch), wenn wirt s ≥ $x$$t$$s\ge x$
• wir inkrementieren (dh wir wachsen an Größe), wennt > T $s$$t > T_s$

Python 2 , 60 Bytes

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

Probieren Sie es online!

Wolfram Language (Mathematica) , 40 39 Bytes

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

Probieren Sie es online!

Erläuterung

f:=Floor@s;s=1;

Symbolisch speichern floor(s)in f. Beginnen Sie mit s=1(Größe).

... /@#

Iteriere durch jedes Element in der Eingabe ...

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

Wenn das Element nicht größer als ist s, erhöhen Sie es sum <element> / (4 * floor(s)). Die Or (||)Kurzschlüsse sonst.

f

Rückkehr floor(s).

Gelee , 17 Bytes

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

Probieren Sie es online!

Eine interessante Methode, die durch eine Art Schleife oder Rekursion geschlagen werden könnte.

Wie?

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 Bytes

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

Probieren Sie es online!

Lua , 214 Bytes

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

Probieren Sie es online!

Nicht einmal die kürzeste hier, aber es hat Spaß gemacht, es herauszufinden: D