Вступление:

(Источник: Википедия )
Когда мы смотрим на радугу, она всегда будет иметь цвета сверху вниз:
красный; апельсин; желтый; зеленый; синий; индиго; Фиолетовый

Если мы посмотрим на эти отдельные кольца, красное кольцо, конечно, больше, чем фиолетовое кольцо.
Кроме того, также возможно иметь две или даже три радуги одновременно.

Все это, вместе взятые, будет использовано в этой задаче:

Вызов:

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

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

Пример:

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

Почему? У нас есть 15x фиолетовый, и нам нужно по крайней мере 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, функции / метод с правильными параметрами и типом возврата, полные программы. Ваш звонок.
• По умолчанию лазейки запрещены.
• Если возможно, добавьте ссылку с тестом для вашего кода.
• Кроме того, добавление объяснения для вашего ответа настоятельно рекомендуется.

Тестовые случаи:

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

thS.ef<b*+tkyy

Тестирование!

Как?

Algortihm

Прежде всего, давайте выведем формулу, на которой основан этот ответ. Давайте назовем функцию, которая дает необходимое количество цветных частиц , где - количество слоев, а - индекс цвета на основе 0. Во-первых, отметим, что только для слоя (где индексируется 1, в данном случае) нам нужны цветных частиц , Имея это в виду, мы суммируем результаты каждого для каждого слоя :$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)}$$

Поэтому теперь мы знаем, что максимальное число возможных слоев, называемое его , должно удовлетворять неравенству , где - входного списка.$k$$C(k, i) \le I_i$$I_i$$i^\text{th}$

Реализация

Это реализует функцию и iterates ( ) по списку ввода, где - индекс (на основе 0), а - элемент. Для каждого значения программа ищет первое положительное целое число для которого (логическое отрицание , условие, которое мы вывели ранее), затем находит минимальный результат и уменьшает это. Таким образом, вместо того , чтобы искать для целого числа , что делает удовлетворяет условие, мы ищем самое низкое , что не и вычитать один из него , чтобы компенсировать смещение 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 байт

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)

Попробуйте онлайн!

Как?

Число цветных частиц, необходимое для создания раз цвета: n $P_{(n,k)}$$n$$k$

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

Мы рекурсивно пробуем все значения пока хотя бы одна запись во входном массиве не станет меньше .v k P ( n , k $n$$v_k$$P_{(n,k)}$

Но для целей игры в гольф мы начинаем с n === undefinedи используем отрицательные значения nвпоследствии. Первая итерация всегда успешна, потому что правая часть неравенства оценивается как NaN. Поэтому первый значимый тест - это второй с n == -1.

Желе , 18 байт

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

Попробуйте онлайн!

Использует объяснение в ответе 05x1E от Okx.

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 th 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 из семи int и возвращает 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;
 }