Introdução:

(Fonte: Wikipedia )
Quando olhamos para um arco-íris, ele sempre terá as cores de cima para baixo:
vermelho; laranja; amarelo; verde; azul; índigo; tolet

Se olharmos para esses anéis individuais, é claro que o anel vermelho é maior que o anel violeta.
Além disso, também é possível ter dois ou até três arco-íris ao mesmo tempo.

Tudo isso combinado acima será usado neste desafio:

Desafio:

Dada uma lista de números inteiros exatamente do tamanho 7, em que cada valor indica as partículas de cores disponíveis para formar arco-íris (onde o maior índice indica vermelho e o menor índice indica violeta), produz a quantidade de arco-íris que pode ser formada.

Um único arco-íris inteiro precisa ter pelo menos 3x violeta, 4x índigo, 5x azul, 6x verde, 7x amarelo, 8x laranja, 9x vermelho. Um segundo arco-íris em cima dele será ainda maior que o anel vermelho do primeiro arco-íris (incluindo um espaço entre eles), portanto precisará de pelo menos 11x violeta, 12x índigo, 13x azul, 14x verde, 15x amarelo, 16x laranja , 17x vermelho, além do que o primeiro arco-íris usa. O terceiro arco-íris começará novamente em 19x violeta.

Exemplo:

Lista de entradas: [15,20,18,33,24,29,41]
Saída:2

Por quê? Temos 15x violeta e precisamos de pelo menos 3 + 11 = 14 para dois arco-íris. Temos 20 índigo e precisamos de pelo menos 4 + 12 = 16 para dois arco-íris. Etc. Temos cores suficientes para dois arco-íris, mas não o suficiente para formar três arco-íris, então a saída é 2.

Regras do desafio:

• Os números inteiros na matriz de entrada são garantidos como não negativos ( >= 0).
• A lista de entrada é garantidamente do tamanho 7 exatamente.
• Quando nenhum arco-íris pode ser formado, produzimos 0.
• O formato de entrada e saída é flexível. Pode ser uma lista ou matriz de números inteiros decimais, pode ser obtida em STDIN. A saída pode ser um retorno de uma função em qualquer tipo de saída razoável ou impressa diretamente no STDOUT.

Quantidade mínima de cores necessária para a nquantidade 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...

Regras gerais:

• Isso é código-golfe , então a resposta mais curta em bytes vence.
  Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
• As regras padrão se aplicam à sua resposta, para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
• As brechas padrão são proibidas.
• Se possível, adicione um link com um teste para o seu código.
• Além disso, é altamente recomendável adicionar uma explicação para sua resposta.

Casos de teste:

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

Pitão , 14 bytes

thS.ef<b*+tkyy

Suíte de teste!

Quão?

Algortihm

Primeiro, vamos derivar a fórmula em que esta resposta se baseia. Vamos chamar a função que fornece a quantidade necessária de partículas de cor , onde é o número de camadas e é o índice da cor, com base em 0. Primeiro, observamos que somente para a camada (onde é indexado 1, neste caso), precisamos de partículas de cor . Tendo isso em mente, somamos os resultados de cada para cada camada :$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) = (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)}$$

Portanto, sabemos agora que o número máximo de camadas possíveis, chamado , deve satisfazer a desigualdade , onde é o elemento da lista de entrada.$k$$C(k, i) \le I_i$$I_i$$i^\text{th}$

Implementação

Isso implementa a função e itera ( ) sobre a lista de entrada, com sendo o índice (baseado em 0) sendo o elemento. Para cada valor, o programa pesquisa o primeiro número inteiro positivo pelo qual (a negação lógica de , a condição que deduzimos anteriormente), depois encontra o resultado mínimo e diminui. Desta forma, em vez de procurar o maior número inteiro que faz satisfazer uma condição, buscamos o menor que não e um subtrair para compensar o deslocamento de 1.k b T b < C ( T , i ) C ( T , i ) ≤ $C$.e$k$$b$$T$$b<C(T, i)$$C(T, i)\le b$

Python 2 , 64 61 bytes

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

Experimente online!

---

Cada cor do arco-íris usa (3+i)+n*8para camada ne cor i(0 = violeta etc.)

O total de x camadas é, por conseguinte,: (3*i)*x + 8*x*(x+1).

Simplesmente resolvemos n e assumimos o valor mínimo.

---

Salvou:

• -3 bytes, graças a ovs

05AB1E , 18 17 16 bytes

-1 byte graças a Magic Octopus Urn

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

Experimente online!

A quantidade de cor necessária para n arco-íris é 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)

Experimente online!

Quão?

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

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

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

Mas, para fins de golfe, começamos n === undefinede depois usamos valores negativos n. A primeira iteração sempre é bem-sucedida porque o lado direito da desigualdade é avaliado NaN. Portanto, o primeiro teste significativo é o segundo com n == -1.

Gelatina , 18 bytes

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

Experimente online!

Usa a explicação na resposta 05AB1E da Okx.

Excel VBA, 78 bytes

Função anônima que recebe entradas do intervalo [A1:G1]e saídas para a janela imediata do VBE.

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

Carvão , 21 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação: Calcula diretamente o número de arco-íris possível com cada cor com uma fórmula derivada independentemente, mas é a mesma que a 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

Porto da resposta @TFeld

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

Experimente online!

Gelatina , 14 bytes

^{Isso foi difícil!}

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

Um link monádico que aceita uma lista de sete números inteiros que produz um número inteiro, o número de arco-íris possível.

Experimente online! Ou veja a suíte de testes .

Quão?

Infelizmente, qualquer método ingênuo parece ter 16 bytes, um deles é Ṃɓ_J×¥H÷‘H<¬Ȧð€S, no entanto, o método usado aqui é muito mais eficiente e também mais curto!

Este método constrói pilhas arco-íris mais do que suficientes conforme a contagem de partículas, incluindo faixas ultravioletas , e soma 1 para cada pilha possível.

O teste para que isso seja possível é verificar se existe apenas uma única banda, NÃO é possível, pois precisamos de algumas partículas da banda ultravioleta, mas recebemos zero.

Ṃ+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÷ß

Experimente online!

$n$

Algoritmo de Pyth ⟶ 05AB1E Algoritmo

Existem muitos métodos que se pode tentar resolver esse desafio no 05AB1E, então tentei alguns deles e esse acabou sendo o mais curto. Adaptando a fórmula acima mencionada da minha resposta Pyth, tendo em mente que 05AB1E usou a indexação 1, podemos construir nossa função da seguinte maneira:

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

$I$$i$

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

Observe que essa igualdade não é precisa (mas atualmente não sei como declarar isso formalmente) e que as soluções para essa equação produzirão números de ponto flutuante, mas corrigimos isso usando a divisão do piso em vez da divisão precisa mais tarde. De qualquer forma, para continuar com o nosso argumento, a maioria de vocês provavelmente está muito familiarizada com as soluções de uma equação , então aqui temos:

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

Qual é exatamente a relação que essa resposta implementa.

C ++, 127 125 bytes

Raspou 2 bytes graças 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;}

Experimente online!

A função pega uma matriz de sete polegadas no estilo C e retorna um 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$

Explicação:

#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;
 }