Вступ:

(Джерело: Вікіпедія )
Коли ми дивимось на веселку, у неї завжди будуть кольори зверху вниз:
Червоний; помаранчевий; жовтий; зелений; синій; індиго; фіолетовий

Якщо ми подивимось на ці окремі кільця, червоне кільце, звичайно, більше, ніж кільце фіолетового.
Крім того, також можна одночасно мати дві або навіть три веселки.

Все це вище у поєднанні буде використано в цьому виклику:

Виклик:

Давши список цілих чисел точно розміром 7, де кожне значення вказує на кольорові частинки, доступні для формування веселок (де найбільший індекс вказує на червоний, а найменший показник - на фіолетовий), виведіть кількість веселок, які можна сформувати.

На одній цілій цілі-веселці повинно бути не менше 3-красного фіолетового, 4х-індиго, 5-красного синього, 6x зеленого, 7x жовтого, 8-красного помаранчевого, 9-красного. Друга веселка зверху буде ще більшою, ніж червоне кільце першої веселки (включаючи один проміжок між ними), тож їй знадобиться принаймні 11x фіолетовий, 12x індиго, 13x синій, 14x зелений, 15x жовтий, 16x помаранчевий , 17x червоний на додаток до того, що використовує перша веселка. Третя веселка знову розпочнеться в 19x фіолетову.

Приклад:

Список вводу: [15,20,18,33,24,29,41]
Вихід:2

Чому? У нас фіалка 15-кратна, і нам потрібно щонайменше 3 + 11 = 14 для двох веселок. У нас 20 індиго, і нам потрібно щонайменше 4 + 12 = 16 для двох веселок. І т. Д. У нас є достатньо кольорів для двох веселок, але недостатньо для формування трьох веселок, тому результат є 2.

Правила виклику:

• Цілі числа у вхідному масиві гарантуються як негативні ( >= 0).
• Гарантовано, що список введення буде точно розміром 7.
• Коли не може бути сформовано веселок, ми виводимо 0.
• Формат введення та виведення є гнучким. Може бути список або масив цілих чисел десяткових знаків, можна взяти з STDIN. Вихід може бути поверненням функції в будь-якому розумному типі виводу або надрукований безпосередньо в STDOUT.

Мінімальна кількість кольорів, необхідна для nкількості веселок:

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

Загальні правила:

• Це код-гольф , тому найкоротша відповідь у байтах виграє.
  Не дозволяйте мовам з кодовим гольфом відштовхувати вас від публікації відповідей з мов, що не кодують гольф. Спробуйте придумати якомога коротшу відповідь на "будь-яку" мову програмування.
• Стандартні правила застосовуються до вашої відповіді, тому вам дозволяється використовувати STDIN / STDOUT, функції / метод із відповідними параметрами та повним програмами типу return. Твій дзвінок.
• Лазівки за замовчуванням заборонені.
• Якщо можливо, додайте посилання з тестом для вашого коду.
• Також настійно рекомендується додавати пояснення до своєї відповіді.

Тестові приклади:

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

Піт , 14 байт

thS.ef<b*+tkyy

Тестовий набір!

Як?

Алгортих

Для початку виведемо формулу, на якій ґрунтується ця відповідь. Назвемо функцію, яка дає необхідну кількість кольорових частинок , де n - кількість шарів, а i - показник кольору, заснований на 0. Спочатку зазначимо, що лише для n- го шару (де n є 1-індексованим, в даному випадку) нам потрібні кольорові частинки L ( n , i ) = i + 3 + 8 ( n - 1 ) . Маючи це на увазі, ми підсумовуємо результати кожного$C(n, i)$$n$$i$$n^\text{th}$$n$$L(n, i)=i+3+8(n-1)$ для кожного шару k :$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 ⋅ ( n - 1 ) $$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)}$$

Отже, тепер ми знаємо, що максимальна кількість можливих шарів, називаючи його , повинна задовольняти нерівності C ( k , i ) ≤ I i , де I i - i- й елемент вхідного списку.$k$$C(k, i) \le I_i$$I_i$$i^\text{th}$

Впровадження

Це реалізує функцію і повторює ( ) над вхідним списком, причому k - індекс (на основі 0), а b - елемент. Для кожного значення програма шукає перше додатне ціле число T, для якого b < C ( T , i ) (логічне заперечення C ( T , i ) ≤ b , умова, яку ми вивели раніше), потім знаходить мінімальний результат і зменшення це. Таким чином, замість пошуку найвищого цілого числа, яке відповідає умові, ми шукаємо найменше, що не відповідає$C$.e$k$$b$$T$$b<C(T, i)$$C(T, i)\le b$ і відняти одне, щоб компенсувати зсув 1.

Python 2 , 64 61 байт

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

Спробуйте в Інтернеті!

---

Кожен колір веселки використовується (3+i)+n*8для шару nта кольору i(0 = фіолетовий тощо)

Загальна для ї шарів, отже: (3*i)*x + 8*x*(x+1).

Ми просто вирішуємо для n і приймаємо мінімальне значення.

---

Збережено:

• -3 байти, завдяки ов

05AB1E , 18 17 16 байт

-1 байт завдяки магічній урній восьминога

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

Спробуйте в Інтернеті!

Кількість кольору, необхідного для n веселок, становить n (4n + [-1, 0, 1, 2, 3, 4, 5]) .

JavaScript (ES6), 49 байт

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

Спробуйте в Інтернеті!

Як?

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

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

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

Але для цілей гольфу ми починаємо n === undefinedі використовуємо негативні значення nзгодом. Перша ітерація завжди є успішною, оскільки права частина нерівності оцінюється на NaN. Тому перший змістовний тест - 2-й с n == -1.

Желе , 18 байт

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

Спробуйте в Інтернеті!

Використовує пояснення у відповіді Okx 05AB1E.

Excel VBA, 78 байт

Анонімна функція, яка приймає вхід з діапазону [A1:G1]та виводить у безпосереднє вікно VBE.

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

Вугілля деревне , 21 байт

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

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Пояснення: Безпосередньо обчислює кількість можливих веселок з кожним кольором за допомогою формули I, отриманої самостійно, але виявляється такою ж, як і формула @ 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 байти

Порт відповіді @TFeld

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

Спробуйте в Інтернеті!

Желе , 14 байт

^{Це було важко!}

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

Монадична посилання, що приймає список із семи цілих чисел, який дає ціле число, кількість можливих веселок.

Спробуйте в Інтернеті! Або подивіться тестовий набір .

Як?

На жаль, будь-який наївний метод, здається, займає 16 байт, один такий метод є Ṃɓ_J×¥H÷‘H<¬Ȧð€S, однак, виявляється, метод, який використовується тут, набагато ефективніший і коротший!

Цей метод створює більш ніж достатню кількість райдужних стеків під час підрахунку частинок, включаючи ультрафіолетові смуги , і додає 1 для кожної групи, що можливо.

Тест на його можливість полягає в тому, щоб перевірити, чи є лише одна смуга НЕ можлива, враховуючи, що нам потрібні частинки ультра-фіолетової смуги, але вони отримали нуль.

Ṃ+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 байт

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

Спробуйте в Інтернеті!

$n$

Алгоритм Pyth ⟶ 05AB1E Алгоритм

Є багато методів, які можна спробувати вирішити цю проблему в 05AB1E, тому я спробував пару з них, і це виявилося найкоротшим. Адаптуючи вищезгадану формулу з моєї відповіді Pyth, маючи на увазі, що 05AB1E використовував 1-індексацію, ми можемо побудувати свою функцію так:

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

$I$$i$

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

Зауважте, що ця рівність не є точною (але в даний час я не знаю способу викласти це більш формально) і що рішення цього рівняння дадуть числа з плаваючою комою, але ми це виправляємо, використовуючи поділ підлоги, а не точний поділ в подальшому. У будь-якому випадку, щоб продовжити наш аргумент, більшість із вас, напевно, дуже добре знайомі з рішеннями такого рівняння , тому ось у нас це є:

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

Яке саме співвідношення реалізує ця відповідь.

C ++, 127 125 байт

Поголив 2 байти завдяки Кевіну Крейсейну.

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

Спробуйте в Інтернеті!

Функція займає масив у стилі C із семи ints та повертає 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$

Пояснення:

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