Manger du poisson, de plus en plus grand

16

Vous êtes un poisson dans un étang qui doit survivre en mangeant d'autres poissons. Vous ne pouvez manger que des poissons de la même taille ou plus petits que vous. Vous devez créer un programme qui prend un banc de poissons comme entrée triée. À partir de cela, vous devez déterminer le nombre de poissons que vous pouvez manger et, finalement, la taille de votre croissance.

Tableau des tailles

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

Règles

  1. Votre taille commence à 1
  2. L'entrée du haut-fond contiendra des nombres entiers de poissons entre 0 et 9
  3. 0 = algues et ne vous aidera pas à vous nourrir.
  4. L'entier poisson représente la taille du poisson (1-9).
  5. Vous ne pouvez manger que du poisson de la même taille ou moins que vous.
  6. Vous pouvez manger le poisson dans l'ordre de votre choix pour maximiser votre taille.
  7. Vous ne pouvez manger chaque poisson qu'une seule fois.
  8. Plus vous mangez de gros poissons, plus vous grandissez vite. Un poisson de taille 2 équivaut à deux poissons de taille 1, un poisson de taille 3 équivaut à trois poissons de taille 1, etc.
  9. Votre taille augmente d'une unité chaque fois que vous atteignez les montants ci-dessous.

Renvoie un entier de la taille maximale que vous pourriez être

Exemples

"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

Le code le plus court (en comptant en octets) pour le faire dans n'importe quelle langue dans laquelle les nombres gagnent.

Critiquer de façon cinglante
la source
1
Bienvenue sur PPCG, j'ai pris la liberté de faire des changements de mise en forme mineurs dans la question, n'hésitez pas à les annuler si vous pensez qu'ils ne sont pas appropriés.
Rod
1
Connexes :-)
Arnauld
5
Plus de questions: (1) pouvons-nous prendre une liste d'entiers au lieu d'une chaîne entière? (2) peut-on supposer que l'entrée est triée?
JungHwan Min
1
J'ai ajouté qu'il sera trié et peut prendre n'importe quelle entrée
Scath
2
On peut retirer 5,6ou 6,6 du dernier exemple de Mark et atteindre la taille 13; mais retirez-le à la 5,5place et on ne peut atteindre que la taille cinq.
Jonathan Allan

Réponses:

10

JavaScript (ES6), 44 octets

Prend l'entrée comme un tableau d'entiers.

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

Essayez-le en ligne!

Comment?

Tss+1

Ts=2s(s+1)

stt=11

X

  • XtsX
  • nous incrémentons st>Ts
Arnauld
la source
5

Wolfram Language (Mathematica) , 40 39 octets

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

Essayez-le en ligne!

Explication

f:=Floor@s;s=1;

Conserver floor(s)dans f, symboliquement. Commencez par s=1(taille).

... /@#

Itérer à travers chaque élément en entrée ...

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

Si l'élément n'est pas supérieur à s, incrémentez sde <element> / (4 * floor(s)). Les Or (||)courts-circuits sinon.

f

Retour floor(s).

JungHwan Min
la source
5

Gelée , 17 octets

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

Essayez-le en ligne!

Une méthode intéressante qui pourrait bien être battue par une sorte de boucle ou de récursivité.

Comment?

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.)
Jonathan Allan
la source
Quelqu'un a dit qu'il était trop tôt pour moi d'accepter cela, êtes-vous d'accord?
Scath
Oui je suis d'accord; certaines personnes n'accordent pas de coche verte pour le golf de code, d'autres la laissent environ une semaine - accepter une réponse peut signifier une baisse d'activité. En aparté, je pense que cela devrait être battable (que ce soit dans Jelly lui-même ou en tant que compétition multilingue) de toute façon! ... le code-golf convient étrangement à Stack Exchange puisque la vraie compétition est intra-langue mais la marque d'acceptation est inter-langue.
Jonathan Allan
1

Lua , 214 octets

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

Essayez-le en ligne!

Pas même le plus court ici, mais c'était amusant de le comprendre: D

Lycea
la source