Introducción:

(Fuente: Wikipedia )
Cuando miramos un arco iris siempre tendrá los colores de arriba a abajo:
rojo; naranja; amarillo; verde; azul; índigo; Violeta

Si observamos estos anillos individuales, el anillo rojo es, por supuesto, más grande que el anillo violeta.
Además, también es posible tener dos o incluso tres arcoíris al mismo tiempo.

Todo lo anterior combinado se usará en este desafío:

Desafío:

Dada una lista de enteros de exactamente el tamaño 7, donde cada valor indica las partículas de color disponibles para formar arcoíris (donde el índice más grande indica rojo y el índice más pequeño indica violeta), genera la cantidad de arcoíris que se puede formar.

Un solo arco iris entero debe tener al menos 3x violeta, 4x índigo, 5x azul, 6x verde, 7x amarillo, 8x naranja, 9x rojo. Un segundo arco iris encima será aún más grande que el anillo rojo del primer arco iris (incluido un espacio entre ellos), por lo que necesitará al menos 11x violeta, 12x índigo, 13x azul, 14x verde, 15x amarillo, 16x naranja , 17x rojo además de lo que usa el primer arcoíris. El tercer arcoíris comenzará en 19x violeta nuevamente.

Ejemplo:

Lista de entrada: [15,20,18,33,24,29,41]
Salida:2

¿Por qué? Tenemos 15x violeta, y necesitamos al menos 3 + 11 = 14 para dos arcoiris. Tenemos 20 índigo y necesitamos al menos 4 + 12 = 16 para dos arcoíris. Etc. Tenemos suficientes colores para dos arcoíris, pero no suficientes para formar tres arcoíris, por lo que la salida es 2.

Reglas de desafío:

• Se garantiza que los enteros en la matriz de entrada no son negativos ( >= 0).
• Se garantiza que la lista de entrada será de tamaño 7 exactamente.
• Cuando no se pueden formar arcoíris, salimos 0.
• El formato de entrada y salida es flexible. Puede ser una lista o conjunto de enteros de decimales, puede tomarse de STDIN. La salida puede ser un retorno de una función en cualquier tipo de salida razonable, o imprimirse directamente en STDOUT.

Cantidad mínima de colores necesarios para la ncantidad de arcoíris:

Amount of Rainbows    Minimum amount per color
0                     [0,0,0,0,0,0,0]
1                     [3,4,5,6,7,8,9]
2                     [14,16,18,20,22,24,26]
3                     [33,36,39,42,45,48,51]
4                     [60,64,68,72,76,80,84]
5                     [95,100,105,110,115,120,125]
etc...

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de code-golf lo desanimen a publicar respuestas con lenguajes que no sean codegolf. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código.
• Además, se recomienda agregar una explicación para su respuesta.

Casos de prueba:

Input:  [15,20,18,33,24,29,41]
Output: 2

Input:  [3,4,5,6,7,8,9]
Output: 1

Input:  [9,8,7,6,5,4,3]
Output: 0

Input:  [100,100,100,100,100,100,100]
Output: 4

Input:  [53,58,90,42,111,57,66]
Output: 3

Input:  [0,0,0,0,0,0,0]
Output: 0

Input:  [95,100,105,110,115,120,125]
Output: 5

Input:  [39525,41278,39333,44444,39502,39599,39699]
Output: 98

Pyth , 14 bytes

thS.ef<b*+tkyy

¡Banco de pruebas!

¿Cómo?

Algortihm

En primer lugar, derivemos la fórmula en la que se basa esta respuesta. Llamemos a la función que da la cantidad necesaria de partículas de color , donde es el número de capas e es el índice del color, basado en 0. Primero, notamos que solo para la capa (donde está indexada en 1, en este caso), necesitamos partículas de color . Teniendo esto en cuenta, sumamos los resultados de cada para cada capa :$C(n, i)$$n$$i$$n^\text{th}$$n$$L(n, i)=i+3+8(n-1)$$L(k, i)$$k$

$$C(n, i)=\color{red}{\underbrace{(i+3)}_{1^\text{st} \text{ layer}}} + \color{blue}{\underbrace{(i+3+8)}_{2^\text{nd} \text{ layer}}}+\cdots + \color{green}{\underbrace{[i+3+8(n-1)]}_{n^\text{th} \text{ layer}}}$$ $$C(n, i)=(i+3)n+8\left(0+1+\cdots +n-1\right)$$ C(n,i)=n(i+3+4n-4 $$C(n, i) = (i+3)n+8\cdot\frac{(n-1)n}{2}=(i+3)n+4n(n-1)$$ $$C(n, i)=n(i+3+4n-4)\implies \boxed{C(n,i)=n(4n+i-1)}$$

Por lo tanto, ahora sabemos que el número máximo de capas posibles, , debe satisfacer la desigualdad , donde es el elemento de la lista de entrada.C ( k , i ) ≤ I i I i i $k$$C(k, i) \le I_i$$I_i$$i^\text{th}$

Implementación

$C$.e$k$$b$$T$$b<C(T, i)$$C(T, i)\le b$ y reste uno para compensar el desplazamiento de 1.

Python 2 , 64 61 bytes

lambda l:min(((16*v+i*i)**.5-i)//8for i,v in enumerate(l,-1))

Pruébalo en línea!

---

Cada color del arco iris se usa (3+i)+n*8para la capa ny el color i(0 = violeta, etc.)

Por consiguiente, el total de capas x es: (3*i)*x + 8*x*(x+1).

Simplemente resolvemos para n, y tomamos el valor mínimo.

---

Salvado:

• -3 bytes, gracias a los ovs

05AB1E , 18 17 16 bytes

-1 byte gracias a Magic Octopus Urn

[ND4*6Ý<+*¹›1å#N

Pruébalo en línea!

La cantidad de color necesaria para n arcoiris es n (4n + [-1, 0, 1, 2, 3, 4, 5]) .

JavaScript (ES6), 49 bytes

f=(a,n)=>a.some((v,k)=>v<4*n*n-~-k*n)?~n:f(a,~-n)

Pruébalo en línea!

¿Cómo?

$P_{(n,k)}$$n$$k$

$$P_{(n,k)}=n(4n+(k-1))=4n^2+(k-1)n$$

$n$$v_k$$P_{(n,k)}$

Pero para propósitos de golf, comenzamos con n === undefinedy usamos valores negativos de ndespués. La primera iteración siempre es exitosa porque el lado derecho de la desigualdad se evalúa como NaN. Por lo tanto, la primera prueba significativa es la segunda con n == -1.

Jalea , 18 bytes

Ṁµ×4+-r5¤×)⁸<Ẹ€¬TṪ

Pruébalo en línea!

Utiliza la explicación en la respuesta 05AB1E de Okx.

Excel VBA, 78 bytes

Función anónima que toma entrada del rango de [A1:G1]y salidas a la ventana inmediata de VBE.

[A2:G999]="=A1-(COLUMN()+8*ROW()-14)":[H:H]="=-(MIN(A1:G1)<0)":?998+[Sum(H:H)]

Carbón de leña , 21 bytes

Ｉ⌊ＥＡ÷⁻Ｘ⁺Ｘ⊖κ²×¹⁶ι·⁵⊖κ⁸

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación: Calcula directamente el número de arcoíris posibles con cada color con una fórmula que obtuve de forma independiente, pero resulta ser la misma que la fórmula de @ TField.

   Ａ                   Input array
  Ｅ                     Map over values
          κ             Current index
         ⊖              Decrement
        Ｘ  ²            Square
               ι        Current index
            ×¹⁶         Multiply by 16
       ⁺                Add
      Ｘ         ·⁵      Square root
                   κ    Current index
                  ⊖     Decrement
     ⁻                  Subtract
    ÷               ⁸   Integer divide by 8
 ⌊                      Take the maximum
Ｉ                       Cast to string
                        Implicitly print

JavaScript (Node.js) , 54 bytes

Puerto de respuesta @TFeld

_=>Math.min(..._.map((a,i)=>((16*a+--i*i)**.5-i)/8))|0

Pruébalo en línea!

Jalea , 14 bytes

^{Esto fue dificil!}

Ṃ+9s8Ṗ‘+\>Ż§ỊS

Un enlace monádico que acepta una lista de siete enteros que produce un número entero, el número de arcoíris posibles.

Pruébalo en línea! O vea el conjunto de pruebas .

¿Cómo?

Desafortunadamente, cualquier método ingenuo parece tomar 16 bytes, uno de esos métodos es Ṃɓ_J×¥H÷‘H<¬Ȧð€S, sin embargo, resulta que el método utilizado aquí es mucho más eficiente y más corto.

Este método crea más que suficientes pilas de arcoíris como recuento de partículas, incluidas las bandas ultravioleta , y suma 1 para cada pila que sea posible.

La prueba para que sea posible es verificar que solo haya una sola banda NO posible dado que necesitamos algunas partículas de banda ultravioleta pero se nos proporcionó cero.

Ṃ+9s8Ṗ‘+\>Ż§ỊS - Link list of integers    e.g. [0,0,0,0,0,0,0]        or [17,20,18,33,24,29,41]
Ṃ              - minimum                       0                         17
 +9            - add nine                      9                         26
   s8          - split into eights             [[1,2,3,4,5,6,7,8],[9]]   [[1,2,3,4,5,6,7,8],[9,10,11,12,13,14,15,16],[17,18,19,20,21,22,23,24],[25,26]]
     Ṗ         - discard the rightmost         [[1,2,3,4,5,6,7,8]]       [[1,2,3,4,5,6,7,8],[9,10,11,12,13,14,15,16],[17,18,19,20,21,22,23,24]]
      ‘        - increment (vectorises)        [[2,3,4,5,6,7,8,9]]       [[2,3,4,5,6,7,8,9],[10,11,12,13,14,15,16,17],[18,19,20,21,22,23,24,25]]
               -   (single rainbow counts, including ultra-violet bands, ready to stack)
       +\      - cumulative addition           [[2,3,4,5,6,7,8,9]]       [[2,3,4,5,6,7,8,9],[12,14,16,18,20,22,24,26],[30,33,36,39,42,45,48,51]]
               -   (stacked rainbow counts, including ultra-violet bands)
          Ż    - zero concatenate              [0,0,0,0,0,0,0,0]         [0,17,20,18,33,24,29,41]
               -   (we got given zero ultra-violet band particles!)
         >     - greater than? (vectorises)    [[1,1,1,1,1,1,1,1]]       [[1,0,0,0,0,0,0,0],[1,0,0,0,0,0,0,0],[1,1,1,1,1,1,1,1]]
               -   (always a leading 1 - never enough particles for the ultra-violet band)
           §   - sum each                      [8]                       [1,1,8]
               -   (how many bands we failed to build for each sacked rainbow?)
            Ị  - insignificant? (abs(X)<=1?)   [0]                       [1,1,0]
               -   (1 if we only failed to build an ultra-violet band for each sacked rainbow, 0 otherwise)
             S - sum                           0                         2
               -   (the number of rainbows we can stack, given we don't see ultra-violet!)

05AB1E , 14 bytes

žv*āÍn+tā-Ì8÷ß

Pruébalo en línea!

$n$

Algoritmo de Pyth ⟶ 05AB1E Algoritmo

Hay muchos métodos que uno puede probar para resolver este desafío en 05AB1E, así que probé un par de ellos y resultó ser el más corto. Adaptando la fórmula mencionada anteriormente de mi respuesta de Pyth, teniendo en cuenta que 05AB1E usó la indexación 1, podemos construir nuestra función de la siguiente manera:

$$C(n,i)=n(i+2)+4n(n-1)$$

$I$$i$

$$4n^2+n(i-2)-I_i=0$$

Tenga en cuenta que esta igualdad no es precisa (pero actualmente no conozco una manera de establecer esto más formalmente) y que las soluciones a esta ecuación producirán números de punto flotante, pero lo arreglamos usando la división de piso en lugar de la división precisa mas tarde. De todos modos, para continuar con nuestro argumento, la mayoría de ustedes probablemente estén muy familiarizados con las soluciones de tal ecuación , así que aquí lo tenemos:

$$n_{1, 2}=\frac{2-i\pm\sqrt{(i-2)^2+16I_i}}{8}$$

$I_i$$\sqrt{(i-2)^2+16I_i}\ge i-2$$-$$2-i-i+2=4-2i$$i\ge 2$$2-i-2+i=4$$n$

$$n=\left \lfloor\frac{2+\sqrt{(i-2)^2+16I_i}-i}{8}\right \rfloor$$

Cuál es exactamente la relación que implementa esta respuesta.

C ++, 127125 bytes

Afeitado 2 bytes gracias a Kevin Cruijssen.

#include<cmath>
int f(int x[7]){size_t o=-1;for(int c=0,q;c<7;c++,o=o>q?q:o)q=(std::sqrt(--c*c-c+16*x[++c])-c+1)/8;return o;}

Pruébalo en línea!

La función toma una matriz de estilo de C de siete entradas y devuelve un int.

$c$$0\le c\le6$$n$$(n\ge1)$$y_c(n)=(c+3)+8(n-1)$$n$$Y_c(n)=\sum_{k=1}^{n}y_c(k)=n(c+3)+\frac{8n(n-1)}{2}$$x_c\ge Y_c(n)$$x_c$$n:$

$$n\le\frac{-(c-1) + \sqrt{(c-1)^2 + 16x_c}}{8}$$

$x_c$

Explicación:

#include <cmath> // for sqrt

int f (int x[7])
{
     // Note that o is unsigned so it will initially compare greater than any int
     size_t o = -1;
     // Iterate over the array
     for (int c = 0; c < 7; c++)
     {
         // calculate the bound
         int q = c - 1;
         q = (std::sqrt (q * q + 16 * x[c]) - q) / 8;

         // if it is less than previously found - store it
         o = o > q ? q : o;
     }
     return o;
 }