Introduction:

(Source: Wikipedia )
Quand on regarde un arc-en-ciel, il aura toujours les couleurs de haut en bas:
rouge; Orange; Jaune; vert; bleu; indigo; violet

Si nous regardons ces anneaux individuels, l'anneau rouge est bien sûr plus grand que l'anneau violet.
De plus, il est également possible d'avoir deux voire trois arc-en-ciel en même temps.

Tout cela combiné ci-dessus sera utilisé dans ce défi:

Défi:

Étant donné une liste d'entiers de taille exactement 7, où chaque valeur indique les particules de couleur disponibles pour former des arcs-en-ciel (où le plus grand indice indique le rouge et le plus petit indice indique le violet), affichez la quantité d'arcs-en-ciel qui peuvent être formés.

Un seul arc-en-ciel entier doit avoir au moins 3x violet, 4x indigo, 5x bleu, 6x vert, 7x jaune, 8x orange, 9x rouge. Un deuxième arc-en-ciel au-dessus sera encore plus grand que l'anneau rouge du premier arc-en-ciel (y compris un espace entre eux), il aura donc besoin d'au moins 11x violet, 12x indigo, 13x bleu, 14x vert, 15x jaune, 16x orange , 17x rouge en plus de ce que le premier arc-en-ciel utilise. Le troisième arc-en-ciel recommencera à 19x violet.

Exemple:

Liste d'entrées: [15,20,18,33,24,29,41]
Sortie:2

Pourquoi? Nous avons 15x violet, et nous avons besoin d'au moins 3 + 11 = 14 pour deux arcs-en-ciel. Nous avons 20 indigo et nous avons besoin d'au moins 4 + 12 = 16 pour deux arcs-en-ciel. Etc. Nous avons assez de couleurs pour deux arcs-en-ciel, mais pas assez pour former trois arcs-en-ciel, donc la sortie est 2.

Règles du défi:

• Les entiers du tableau d'entrée sont garantis non négatifs ( >= 0).
• La liste d'entrées est garantie de taille 7 exactement.
• Quand aucun arc-en-ciel ne peut se former, nous sortons 0.
• Le format d'entrée et de sortie est flexible. Peut être une liste ou un tableau d'entiers de décimales, peut être extrait de STDIN. La sortie peut être un retour d'une fonction dans n'importe quel type de sortie raisonnable, ou imprimée directement sur STDOUT.

Quantité minimale de couleurs requise pour la nquantité d'arcs-en-ciel:

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

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues non-golfeur de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code.
• De plus, l'ajout d'une explication à votre réponse est fortement recommandé.

Cas de test:

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 octets

thS.ef<b*+tkyy

Suite de tests!

Comment?

Algortihm

Tout d'abord, dérivons la formule sur laquelle cette réponse est basée. Appelons la fonction qui donne la quantité nécessaire de particules de couleur , où est le nombre de couches et est l'indice de la couleur, basé sur 0. Tout d'abord, nous notons que pour la seule couche (où est indexé 1, dans ce cas), nous avons besoin de particules de couleur . En gardant cela à l'esprit, nous additionnons les résultats de chaque pour chaque couche :$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)}$$

Par conséquent, nous savons maintenant que le nombre maximum de couches possibles, appelons-le , doit satisfaire l'inégalité$k$$C(k, i) \le I_i$$I_i$$i^\text{th}$

la mise en oeuvre

$C$.e$k$$b$$T$$b<C(T, i)$$C(T, i)\le b$ et soustrayez-en un pour compenser le décalage de 1.

Python 2 , 64 61 octets

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

Essayez-le en ligne!

---

Chaque couleur de l'arc-en-ciel utilise (3+i)+n*8pour la couche net la couleur i(0 = violet, etc.)

Le total des couches x est donc: (3*i)*x + 8*x*(x+1).

Nous résolvons simplement n et prenons la valeur minimale.

---

Enregistré:

• -3 octets, grâce aux ovs

05AB1E , 18 17 16 octets

-1 octet grâce à Magic Octopus Urn

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

Essayez-le en ligne!

La quantité de couleur nécessaire pour n arcs-en-ciel est n (4n + [-1, 0, 1, 2, 3, 4, 5]) .

JavaScript (ES6), 49 octets

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

Essayez-le en ligne!

Comment?

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

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

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

Mais à des fins de golf, nous commençons par n === undefinedet utilisons des valeurs négatives naprès. La première itération est toujours réussie car le côté droit de l'inégalité est évalué NaN. Par conséquent, le premier test significatif est le deuxième avec n == -1.

Gelée , 18 octets

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

Essayez-le en ligne!

Utilise l'explication de la réponse 05AB1E d'Okx.

Excel VBA, 78 octets

Fonction anonyme qui prend les entrées de la plage [A1:G1]et les sorties vers la fenêtre immédiate du VBE.

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

Fusain , 21 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication: calcule directement le nombre d'arcs-en-ciel possibles avec chaque couleur avec une formule I dérivée indépendamment mais s'avère être la même que la formule 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 octets

Port de réponse @TFeld

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

Essayez-le en ligne!

Gelée , 14 octets

^{C'était dur!}

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

Un lien monadique acceptant une liste de sept entiers qui donne un entier, le nombre d'arc-en-ciel possible.

Essayez-le en ligne! Ou consultez la suite de tests .

Comment?

Malheureusement, toute méthode naïve semble prendre 16 octets, une telle méthode l'est Ṃɓ_J×¥H÷‘H<¬Ȧð€S, mais il s'avère que la méthode utilisée ici est beaucoup plus efficace et plus courte!

Cette méthode crée plus que suffisamment de piles arc-en-ciel en tant que nombre de particules, y compris les bandes ultra-violettes , et ajoute 1 pour chaque pile, ce qui est possible.

Le test pour cela est de vérifier qu'il n'y a qu'une seule bande NON possible étant donné que nous avons besoin de quelques particules de bande ultra-violette mais que nous avons fourni zéro.

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

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

Essayez-le en ligne!

$n$

Algorithme Pyth ⟶ 05AB1E Algorithme

Il existe de nombreuses méthodes que l'on peut essayer pour résoudre ce défi dans 05AB1E, j'ai donc essayé quelques-unes d'entre elles et cela s'est avéré être le plus court. En adaptant la formule susmentionnée de ma réponse Pyth, en gardant à l'esprit que 05AB1E utilisait l'indexation 1, nous pouvons construire notre fonction comme suit:

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

$I$$i$

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

Notez que cette égalité n'est pas précise (mais je ne connais actuellement aucun moyen de l'énoncer plus formellement) et que les solutions à cette équation produiront des nombres à virgule flottante, mais nous corrigeons cela en utilisant la division du sol plutôt que la division précise plus tard. Quoi qu'il en soit, pour continuer avec notre argument, la plupart d'entre vous connaissent probablement très bien les solutions d' une telle équation , alors nous l'avons ici:

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

Quelle est exactement la relation que cette réponse met en œuvre.

C ++, 127 125 octets

Rasé de 2 octets grâce à 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;}

Essayez-le en ligne!

La fonction prend un tableau de style C de sept ints et retourne 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$

Explication:

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