Comer peixe, crescendo em tamanho


16

Você é peixe em um lago que precisa sobreviver comendo outros peixes. Você só pode comer peixe do mesmo tamanho ou menor que você. Você deve criar um programa que leve um cardume de peixes como entrada classificada. A partir disso, você deve descobrir quantos peixes você pode comer e, finalmente, o tamanho em que crescerá.

Carta do tamanho

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

Regras

  1. Seu tamanho começa em 1
  2. A entrada do cardume conterá números inteiros de peixes entre 0 e 9
  3. 0 = algas e não ajudará você a se alimentar.
  4. O número inteiro do peixe representa o tamanho do peixe (1-9).
  5. Você só pode comer peixe do mesmo tamanho ou menos que você.
  6. Você pode comer o peixe em qualquer ordem que você escolher para maximizar seu tamanho.
  7. Você só pode comer cada peixe uma vez.
  8. Quanto maior o peixe que você come, mais rápido você cresce. Um peixe tamanho 2 é igual a dois peixes tamanho 1, tamanho 3 é igual a três peixes tamanho 1 e assim por diante.
  9. Seu tamanho é incrementado em um cada vez que você atinge os valores abaixo.

Retorna um número inteiro do tamanho máximo que você poderia ter

Exemplos

"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

O código mais curto (contando em bytes) para fazê-lo em qualquer idioma em que os números vencem.


1
Bem-vindo ao PPCG, tomei a liberdade de fazer pequenas alterações de formatação na pergunta, sinta-se à vontade para revertê-las se você achar que elas não são apropriadas.
Rod


5
Mais perguntas: (1) podemos pegar uma lista de números inteiros em vez de uma sequência inteira? (2) podemos assumir que a entrada está classificada?
JungHwan Min

1
Eu adicionei ele vai ser classificados e pode tomar qualquer entrada
Scath

2
Pode-se remover 5,6ou 6,6 do último exemplo de Mark e chegar ao tamanho 13; no entanto, remova 5,5e só é possível atingir o tamanho cinco.
27675 Jonathan Allan

Respostas:


10

JavaScript (ES6), 44 bytes

Recebe a entrada como uma matriz de números inteiros.

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

Experimente online!

Quão?

Tss+1

Ts=2s(s+1)

stt=11

x

  • xtsx
  • st>Ts


5

Wolfram Language (Mathematica) , 40 39 bytes

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

Experimente online!

Explicação

f:=Floor@s;s=1;

Armazenar floor(s)em f, simbolicamente. Comece com s=1(tamanho).

... /@#

Iterar através de cada elemento na entrada ...

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

Se o elemento não for maior que s, aumente sem <element> / (4 * floor(s)). Os Or (||)curto-circuitos de outra forma.

f

Retorno floor(s).


5

Geléia , 17 bytes

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

Experimente online!

Um método interessante que pode muito bem ser derrotado por algum tipo de loop ou recursão.

Quão?

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.)

Alguém disse que era cedo para eu aceitar isso, você concorda?
Scath

Sim eu concordo; algumas pessoas não atribuem marcas de verificação verdes ao código-golfe, outras o deixam cerca de uma semana - aceitar uma resposta pode significar uma queda na atividade. Como um aparte, acho que isso deve ser superável (seja no próprio Jelly ou como uma competição entre idiomas) de qualquer maneira! ... code-golf é um ajuste estranho ao Stack Exchange, já que a concorrência real é intra-idioma, mas a marca de aceitação é inter-idioma.
Jonathan Allan


1

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

Experimente online!

Nem mesmo o mais curto aqui, mas foi divertido descobrir: D

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.