介绍：

（来源：Wikipedia）
当我们看着彩虹时，它将始终具有从上到下的颜色
。橙子; 黄色; 绿色; 蓝色; 靛青; 紫色

如果我们看这些单独的环，红色环当然要比紫色环大。
另外，也可以同时有两个甚至三个彩虹。

以上所有这些结合将用于此挑战：

挑战：

给定一列大小为7的整数，其中每个值表示可用于形成彩虹的颜色粒子（其中最大的索引表示红色，最小的索引表示紫色），输出可以形成的彩虹数量。

单个整数彩虹必须至少具有3x紫色，4x靛蓝，5x蓝色，6x绿色，7x黄色，8x橙色，9x红色。它上方的第二条彩虹甚至比第一条彩虹的红色环大（包括它们之间的一个空格），因此它将至少需要11x紫色，12x靛蓝，13x蓝色，14x绿色，15x黄色，16x橙色，除了第一个彩虹使用的颜色外，还有17x红色。第三条彩虹将再次以19倍紫罗兰色开始。

例：

输入列表：[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，具有正确参数的函数/方法和返回类型的完整程序。你的来电。
默认漏洞是禁止的。
如果可能的话，请添加一个带有测试代码的链接。
另外，强烈建议为您的答案添加说明。

测试用例：

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

code-golf number integer

— 凯文·克鲁伊森
source

的0,0,0,0,0,0,0边缘的情况下，虽然:(（它不适合与1间隙逻辑）

— 乔纳森艾伦

8

Pyth，14个字节

thS.ef<b*+tkyy

测试套件！

怎么样？

阿尔戈蒂姆

首先，让我们得出该答案所基于的公式。让我们调用给出必要数量的颜色粒子的函数，其中是层数，而是基于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) = \underset{1^{st} layer}{\underset{⏟}{(i + 3)}} + \underset{2^{nd} layer}{\underset{⏟}{(i + 3 + 8)}} + \dots + \underset{n^{th} layer}{\underset{⏟}{[i + 3 + 8 (n - 1)]}}

$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 (0 + 1 + \dots + n - 1)

$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 + 4 n (n - 1)

$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 + 4 n - 4) ⟹ C (n, i) = n (4 n + i - 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}$

实作

这实现了函数，并在输入列表上进行迭代（），其中为索引（从0开始），为元素。对于每一个值时，程序搜索所述第一正整数针对（的逻辑非，我们先前推断的条件），然后查找最小结果和减少它。通过这种方式，而不是搜索的最大整数确实满足一个条件，我们寻找最低的是不并从中减去一个弥补的1偏移。 $C$ .e $k$ $b$ $T$ $b<C(T, i)$ $C(T, i)\le b$

— Xcoder先生
source

3

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 =紫色等）

因此，x层的总数为：(3*i)*x + 8*x*(x+1)。

我们简单地求解n，取最小值。

已保存：

-3个字节，多亏了ovs

— 场
source

2

啊，现在我得到了回应……

— 乔纳森·弗雷希

1

61个字节

— ovs，

@ovs，谢谢:)

— TF

3

05AB1E，18 17 16字节

-1字节归功于Magic Octopus Urn

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

在线尝试！

n个彩虹所需的颜色量为n（4n + [-1，0，1，2，2，3，4，5]）。

— 奥克斯
source

[ND4*6Ý<+*¹›1å#N可以，但是我不知道为什么。-1个字节。

— 魔术章鱼缸

@MagicOctopusUrn谢谢！那只是使用循环索引而不是计数器变量。

— Okx

似乎我不需要做奇怪的事情N>-因为您以前曾经做过¾>。

— 魔术章鱼缸

@MagicOctopusUrn增加计数器变量的命令不会推送计数器变量。

— Okx

2

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 (4 n + (k - 1)) = 4 n^{2} + (k - 1) n

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

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

但出于打高尔夫球的目的，我们从此开始n === undefined并使用负值nafter。第一次迭代总是成功的，因为不等式的右边为NaN。因此，第一个有意义的测试是带有的第二个测试n == -1。

— Arnauld
source

1

果冻，18字节

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

在线尝试！

使用Okx的05AB1E答案中的解释。

— 暴民埃里克
source

1

Excel VBA，78个字节

匿名函数，用于接收范围内的输入[A1:G1]并输出到VBE立即窗口。

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

— 泰勒·斯科特
source

1

木炭，21字节

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

在线尝试！链接是详细版本的代码。说明：使用我独立导出的公式直接计算每种颜色可能产生的彩虹数量，但结果与@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

— 尼尔
source

1

JavaScript（Node.js），54字节

@TFeld答案的端口

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

在线尝试！

— 路易斯·费利佩·德·耶稣·穆诺兹
source

1

果冻，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!)

— 乔纳森·艾伦
source

我觉得你，对我来说很难将Okx的算法压缩为18个字节...

— Egg the Outgolfer

另外，用§ỊS！

— 暴民埃里克（Erik the Outgolfer）'18年

1

05AB1E，14个字节

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

在线尝试！

$n$

Pyth算法⟶05AB1E算法

有很多方法可以尝试解决05AB1E这一挑战，所以我尝试了他们夫妇，这竟然是最短的。根据我的Pyth答案改编上述公式，并牢记05AB1E使用1索引，我们可以按以下方式构造函数：

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

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

$I$ $i$

4 n^{2} + n (i - 2) - I_{i} = 0

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

请注意，此等式并不精确（但我目前尚不知道一种更正式地表述的方式），并且该方程的解将产生浮点数，但我们使用底数除法而不是精确除法来解决此问题。稍后的。无论如何，要继续我们的论点，你们中的大多数人可能都非常熟悉这样一个方程式的解，因此在这里我们有了它：

n_{1, 2} = \frac{2 - i \pm \sqrt{(i - 2)^{2} + 16 I_{i}}}{8}

$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 = ⌊ \frac{2 + \sqrt{(i - 2)^{2} + 16 I_{i}} - i}{8} ⌋

$n=\left \lfloor\frac{2+\sqrt{(i-2)^2+16I_i}-i}{8}\right \rfloor$

正是这个答案实现的关系。

— Xcoder先生
source

1

C ++，127125字节

多亏了Kevin Cruijssen，削减了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 \leq \frac{- (c - 1) + \sqrt{(c - 1)^{2} + 16 x_{c}}}{8}

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

— 马克斯·叶赫拉科夫
source

嗨，欢迎来到PPCG！我不知道C ++太清楚，但我敢肯定，你可以打高尔夫球这一部分：for(int c=0;c<7;c++){int q=c-1;q=(std::sqrt(q*q+16*x[c])-q)/8;o=o>q?q:o;}本：for(int c=0,q;c<7;c++,o=o>q?q:o)q=(std::sqrt(--c*c-c+16*x[++c]))/8;。另外，您能否提供带有测试代码的TIO链接？

— 凯文·克鲁伊森

@KevinCruijssen谢谢！

— Max Yekhlakov

Codegolf Rainbow：整数数组的乐趣

介绍：

挑战：

挑战规则：

n彩虹数量所需的最小颜色数量：

通用规则：

测试用例：

Pyth，14个字节

怎么样？

Python 2中，64 61个字节

05AB1E，18 17 16字节

JavaScript（ES6），49个字节

怎么样？

果冻，18字节

Excel VBA，78个字节

木炭，21字节

JavaScript（Node.js），54字节

果冻，14 字节

怎么样？

05AB1E，14个字节

Pyth算法⟶05AB1E算法

C ++，127125字节

`n`彩虹数量所需的最小颜色数量：