Introduzione:

(Fonte: Wikipedia )
Quando guardiamo un arcobaleno avrà sempre i colori dall'alto verso il basso:
rosso; arancia; giallo; verde; blu; indaco; viola

Se guardiamo questi singoli anelli, l'anello rosso è ovviamente più grande dell'anello viola.
Inoltre, è anche possibile avere due o anche tre arcobaleno contemporaneamente.

Tutto questo sopra combinato verrà utilizzato in questa sfida:

Sfida:

Dato un elenco di numeri interi di dimensione esattamente 7, in cui ciascun valore indica le particelle di colore disponibili per formare gli arcobaleni (dove l'indice più grande indica il rosso e l'indice più piccolo indica il viola), genera la quantità di arcobaleni che possono essere formati.

Un singolo arcobaleno intero deve avere almeno 3x viola, 4x indaco, 5x blu, 6x verde, 7x giallo, 8x arancio, 9x rosso. Un secondo arcobaleno sopra di esso sarà persino più grande dell'anello rosso del primo arcobaleno (compreso uno spazio tra loro), quindi avrà bisogno di almeno 11x viola, 12x indaco, 13x blu, 14x verde, 15x giallo, 16x arancione , 17x rosso oltre a quello utilizzato dal primo arcobaleno. Il terzo arcobaleno inizierà nuovamente con il viola 19x.

Esempio:

Elenco di input: [15,20,18,33,24,29,41]
output:2

Perché? Abbiamo 15x viola e abbiamo bisogno di almeno 3 + 11 = 14 per due arcobaleni. Abbiamo 20 indaco e abbiamo bisogno di almeno 4 + 12 = 16 per due arcobaleni. Ecc. Abbiamo abbastanza colori per due arcobaleni, ma non abbastanza per formare tre arcobaleni, quindi l'output è 2.

Regole della sfida:

• I numeri interi nell'array di input sono garantiti come non negativi ( >= 0).
• L'elenco di input è garantito per essere esattamente della dimensione 7.
• Quando non è possibile formare arcobaleni, produciamo 0.
• Il formato di input e output è flessibile. Può essere un elenco o un array di numeri interi di decimali, può essere preso da STDIN. L'output può essere un ritorno da una funzione in qualsiasi tipo di output ragionevole o stampato direttamente su STDOUT.

Quantità minima di colori richiesta per la nquantità di arcobaleni:

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

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
• Le scappatoie predefinite sono vietate.
• Se possibile, aggiungi un link con un test per il tuo codice.
• Inoltre, si consiglia vivamente di aggiungere una spiegazione per la risposta.

Casi 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 byte

thS.ef<b*+tkyy

Suite di test!

Come?

algoritmo desiderato

Prima di tutto, ricaviamo la formula su cui si basa questa risposta. Chiamiamo la funzione che fornisce la quantità necessaria di particelle di colore , dove n è il numero di strati e i è l'indice del colore, basato su 0. In primo luogo, si nota che per il n ° strato alone (in cui n è 1-indicizzati, in questo caso), dobbiamo particelle di colore. Tenendo presente questo, sommiamo i risultati di ogni per ogni strato :$C(n, i)$$n$$i$$n^\text{th}$$n$L ( k , i ) $L(n, i)=i+3+8(n-1)$$L(k, i)$$k$

C ( n , i ) = ( i + 3 )

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

Pertanto, ora sappiamo che il numero massimo di livelli possibili, chiamato , deve soddisfare la disuguaglianza , dove è l' elemento dell'elenco di input.$k$$C(k, i) \le I_i$$I_i$$i^\text{th}$

Implementazione

Questo implementa la funzione e scorre ( ) sull'elenco di input, con come indice (basato su 0) e come elemento. Per ogni valore, il programma cerca il primo intero positivo per cui (la negazione logica di , la condizione che abbiamo dedotto in precedenza), quindi trova il risultato minimo e lo decrementa. In questo modo, invece di cercare il numero intero più alto che fa soddisfare una condizione, cerchiamo il più basso che non e uno sottrarre da esso per compensare l'offset di 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 byte

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

Provalo online!

---

Ogni colore dell'arcobaleno utilizza (3+i)+n*8per livello ne colore i(0 = viola, ecc.)

Il totale per strati x è quindi: (3*i)*x + 8*x*(x+1).

Risolviamo semplicemente per n e prendiamo il valore minimo.

---

Salvato:

• -3 byte, grazie agli ovs

05AB1E , 18 17 16 byte

-1 byte grazie a Magic Octopus Urn

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

Provalo online!

La quantità di colore necessaria per n arcobaleni è n (4n + [-1, 0, 1, 2, 3, 4, 5]) .

JavaScript (ES6), 49 byte

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

Provalo online!

Come?

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

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

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

Ma ai fini del golf, iniziamo con n === undefinede usiamo valori negativi di ndopo. La prima iterazione ha sempre successo perché valuta il lato destro della disuguaglianza NaN. Pertanto, il primo test significativo è il secondo con n == -1.

Gelatina , 18 byte

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

Provalo online!

Usa la spiegazione nella risposta 05AB1E di Okx.

Excel VBA, 78 byte

Funzione anonima che accetta input dalla gamma di [A1:G1]e output alla finestra immediata di VBE.

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

Carbone , 21 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione: Calcola direttamente il numero di arcobaleni possibili con ogni colore con una formula che ho derivato in modo indipendente ma risulta essere lo stesso della formula di @ 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 byte

Porta della risposta @TFeld

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

Provalo online!

Gelatina , 14 byte

^{Questo è stato difficile!}

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

Un collegamento monadico che accetta un elenco di sette numeri interi che produce un numero intero, il numero di arcobaleni possibili.

Provalo online! Oppure vedi la suite di test .

Come?

Sfortunatamente qualsiasi metodo ingenuo sembra richiedere 16 byte, uno di questi è Ṃɓ_J×¥H÷‘H<¬Ȧð€S, tuttavia si scopre che il metodo usato qui è molto più efficiente e più breve!

Questo metodo costruisce pile arcobaleno più che sufficienti quando il conteggio delle particelle, comprese le bande ultraviolette , e aggiunge 1 per ogni pila che è possibile.

Il test per essere possibile è verificare che sia presente una sola banda NON possibile dato che abbiamo bisogno di alcune particelle di banda ultravioletta ma che ci hanno fornito 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 byte

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

Provalo online!

$n$

Algoritmo Pyth ⟶ 05AB1E

Esistono molti metodi per provare a risolvere questa sfida in 05AB1E, quindi ne ho provati un paio e questo si è rivelato il più breve. Adattando la formula di cui sopra dalla mia risposta Pyth, tenendo presente che 05AB1E utilizzava l'indicizzazione 1, possiamo costruire la nostra funzione come segue:

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

$I$$i$

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

Nota che questa uguaglianza non è precisa (ma al momento non conosco un modo per dirlo in modo più formale) e che le soluzioni a questa equazione produrranno numeri in virgola mobile, ma risolviamo usando la divisione del pavimento piuttosto che la divisione precisa più tardi. Ad ogni modo, per continuare con il nostro argomento, molti di voi probabilmente conoscono molto bene le soluzioni di tale equazione , quindi eccoci qui:

$$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 è esattamente la relazione che questa risposta implementa.

C ++, 127 125 byte

Rasato di 2 byte grazie 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;}

Provalo online!

La funzione accetta un array in stile C di sette ints e restituisce 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$

Spiegazione:

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