Comiendo pescado, creciendo en tamaño


16

Eres un pez en un estanque que necesita sobrevivir comiendo otros peces. Solo puedes comer pescado que sea del mismo tamaño o más pequeño que tú. Debe crear un programa que tome un banco de peces como entrada ordenada. A partir de esto, debe calcular cuántos peces puede comer y, en última instancia, el tamaño al que crecerá.

Carta del tamaño

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

Reglas

  1. Tu talla comienza en 1
  2. La entrada de bajío contendrá enteros de peces entre 0-9
  3. 0 = algas y no te ayudará a alimentarte.
  4. El entero de pez representa el tamaño del pez (1-9).
  5. Solo puedes comer pescado del mismo tamaño o menos que tú.
  6. Puede comer el pescado en el orden que elija para maximizar su tamaño.
  7. Solo puedes comer cada pescado una vez.
  8. Mientras más pescado comas, más rápido crecerás. Un pez de talla 2 equivale a dos peces de talla 1, un pez de talla 3 equivale a tres peces de talla 1, y así sucesivamente.
  9. Su tamaño aumenta en uno cada vez que alcanza las cantidades a continuación.

Devuelve un número entero del tamaño máximo que podría ser

Ejemplos

"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

El código más corto (contando en bytes) para hacerlo en cualquier idioma en el que los números ganen.


1
Bienvenido a PPCG, me tomé la libertad de hacer pequeños cambios de formato en la pregunta, siéntase libre de deshacerlos si cree que no son apropiados.
Rod


55
Más preguntas: (1) ¿podemos tomar una lista de enteros en lugar de una cadena de enteros? (2) ¿podemos suponer que la entrada está ordenada?
JungHwan Min


2
Uno puede eliminar 5,6o 6,6 del último ejemplo de Mark y llegar al tamaño 13; Sin embargo, en su 5,5lugar, elimine y solo se puede alcanzar el tamaño cinco.
Jonathan Allan

Respuestas:


10

JavaScript (ES6), 44 bytes

Toma datos como una matriz de enteros.

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

Pruébalo en línea!

¿Cómo?

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

Pruébalo en línea!

Explicación

f:=Floor@s;s=1;

Almacenar floor(s)en f, simbólicamente. Comience con s=1(tamaño).

... /@#

Iterar a través de cada elemento en la entrada ...

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

Si el elemento no es mayor que s, entonces incremente sen <element> / (4 * floor(s)). Los Or (||)cortocircuitos de lo contrario.

f

Retorno floor(s).


5

Jalea , 17 bytes

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

Pruébalo en línea!

Un método interesante que bien podría ser golpeado por algún tipo de bucle o recursión.

¿Cómo?

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

Alguien dijo que era demasiado pronto para que aceptara esto, ¿estás de acuerdo?
Scath

Sí estoy de acuerdo; algunas personas no otorgan marcas de verificación verdes para el código de golf, otras lo dejan alrededor de una semana; aceptar una respuesta puede significar una caída en la actividad. Como comentario, ¡siento que esto debería ser superable (ya sea en Jelly o como una competencia de idiomas cruzados) de todos modos! ... code-golf es un ajuste extraño para Stack Exchange ya que la competencia real es dentro del idioma, pero la marca de aceptación es entre idiomas.
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

Pruébalo en línea!

Ni siquiera cerca del más corto aquí, pero fue divertido descubrirlo: D

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.