Giới thiệu:

(Nguồn: Wikipedia )
Khi chúng ta nhìn vào cầu vồng, nó sẽ luôn có các màu từ trên xuống dưới:
Đỏ; trái cam; màu vàng; màu xanh lá; màu xanh da trời; xanh đậm; màu tím

Nếu chúng ta nhìn vào những chiếc nhẫn riêng lẻ này, chiếc nhẫn màu đỏ dĩ nhiên lớn hơn chiếc nhẫn màu tím.
Ngoài ra, cũng có thể có hai hoặc thậm chí ba cầu vồng cùng một lúc.

Tất cả điều này kết hợp ở trên sẽ được sử dụng trong thử thách này:

Thử thách:

Đưa ra một danh sách các số nguyên có kích thước chính xác 7, trong đó mỗi giá trị biểu thị các hạt màu có sẵn để tạo thành cầu vồng (trong đó chỉ số lớn nhất biểu thị màu đỏ và chỉ số nhỏ nhất biểu thị màu tím), xuất ra lượng cầu vồng có thể được hình thành.

Một cầu vồng nguyên duy nhất phải có ít nhất 3x tím, 4x chàm, xanh 5x, xanh lục 6x, vàng 7x, cam 8x, đỏ 9x. Cầu vồng thứ hai trên đỉnh của nó sẽ còn lớn hơn vòng đỏ của cầu vồng thứ nhất (bao gồm một khoảng trống giữa chúng), do đó, nó sẽ cần ít nhất 11x tím, 12x chàm, xanh 13x, xanh 14x, vàng 15x, cam 16x , 17x màu đỏ ngoài những gì cầu vồng đầu tiên sử dụng. Cầu vồng thứ ba sẽ bắt đầu ở màu tím 19x một lần nữa.

Thí dụ:

Danh sách đầu vào: [15,20,18,33,24,29,41]
Đầu ra:2

Tại sao? Chúng ta có màu tím 15x và chúng ta cần ít nhất 3 + 11 = 14 cho hai cầu vồng. Chúng ta có 20 chàm và chúng ta cần ít nhất 4 + 12 = 16 cho hai cầu vồng. V.v. Chúng tôi có đủ màu sắc cho hai cầu vồng, nhưng không đủ để tạo thành ba cầu vồng, vì vậy đầu ra là 2.

Quy tắc thử thách:

• Các số nguyên trong mảng đầu vào được đảm bảo là không âm ( >= 0).
• Danh sách đầu vào được đảm bảo có kích thước 7 chính xác.
• Khi không có cầu vồng có thể được hình thành, chúng tôi đầu ra 0.
• Định dạng đầu vào và đầu ra là linh hoạt. Có thể là một danh sách hoặc mảng các số nguyên của số thập phân, có thể được lấy từ STDIN. Đầu ra có thể là một trả về từ một hàm trong bất kỳ loại đầu ra hợp lý nào, hoặc được in trực tiếp lên STDOUT.

Lượng màu tối thiểu cần thiết cho nsố lượng cầu vồng:

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

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Các quy tắc chuẩn áp dụng cho câu trả lời của bạn, vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp và kiểu trả về, các chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn.
• Ngoài ra, thêm một lời giải thích cho câu trả lời của bạn rất được khuyến khích.

Các trường hợp thử nghiệm:

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

Bình thường , 14 byte

thS.ef<b*+tkyy

Bộ thử nghiệm!

Làm sao?

Đại số

Trước hết, hãy rút ra công thức câu trả lời này dựa trên. Chúng ta hãy gọi hàm cung cấp số lượng hạt màu , trong đó là số lớp và là chỉ số của màu, dựa trên 0. Đầu tiên, chúng tôi lưu ý rằng chỉ riêng lớp (trong đó là 1 chỉ mục, trong trường hợp này), chúng ta cần các hạt màu . Hãy ghi nhớ điều này, chúng tôi tổng hợp kết quả của mỗi cho mỗi lớp :n i n th n L ( n , i ) = i + 3 + 8 ( n - 1 ) L ( k , i ) $C(n, i)$$n$$i$$n^\text{th}$$n$$L(n, i)=i+3+8(n-1)$$L(k, i)$$k$

C ( n , tô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) = (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)}$$

Do đó, bây giờ chúng ta biết rằng số lớp tối đa có thể, gọi là , phải thỏa mãn bất đẳng thức , trong đó là phần tử của danh sách đầu vào.$k$$C(k, i) \le I_i$$I_i$$i^\text{th}$

Thực hiện

Điều này thực hiện hàm và lặp ( ) trên danh sách đầu vào, với là chỉ mục (dựa trên 0) và là phần tử. Đối với mỗi giá trị, chương trình tìm kiếm số nguyên dương đầu tiên mà (phủ định logic của , điều kiện chúng tôi đã suy ra trước đó), sau đó tìm kết quả tối thiểu và giảm nó Bằng cách này, thay vì tìm kiếm số nguyên lớn nhất mà không đáp ứng một điều kiện, chúng tôi tìm kiếm thấp nhất mà không và một trừ khỏi nó để bù đắp cho sự bù đắp của 1.$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))

Hãy thử trực tuyến!

---

Mỗi màu của cầu vồng sử dụng (3+i)+n*8cho lớp nvà màu i(0 = violet, v.v.)

Do đó, tổng số cho các lớp x là : (3*i)*x + 8*x*(x+1).

Chúng tôi chỉ đơn giản là giải quyết cho n, và lấy giá trị tối thiểu.

---

Đã lưu:

• -3 byte, nhờ có lò nướng

05AB1E , 18 17 16 byte

-1 byte nhờ Magic Octopus Urn

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

Hãy thử trực tuyến!

Lượng màu cần thiết cho n cầu vồng là 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)

Hãy thử trực tuyến!

Làm sao?

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

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

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

Nhưng đối với mục đích chơi gôn, chúng tôi bắt đầu n === undefinedvà sử dụng các giá trị âm nsau đó. Lặp lại đầu tiên luôn luôn thành công bởi vì bên phải của bất đẳng thức đánh giá NaN. Do đó, bài kiểm tra ý nghĩa đầu tiên là bài kiểm tra thứ 2 với n == -1.

Thạch , 18 byte

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

Hãy thử trực tuyến!

Sử dụng lời giải thích trong câu trả lời 05AB1E của Okx.

VBA Excel, 78 byte

Hàm ẩn danh nhận đầu vào từ phạm vi [A1:G1]và đầu ra cho cửa sổ ngay lập tức VBE.

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

Than , 21 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải thích: Tính trực tiếp số lượng cầu vồng có thể có với mỗi màu với công thức tôi xuất phát độc lập nhưng hóa ra lại giống với công thức của @ 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

Cổng @TFeld trả lời

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

Hãy thử trực tuyến!

Thạch , 14 byte

^{Điều này thật khó!}

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

Liên kết đơn thể chấp nhận danh sách bảy số nguyên mang lại một số nguyên, số lượng cầu vồng có thể.

Hãy thử trực tuyến! Hoặc xem bộ thử nghiệm .

Làm sao?

Thật không may, bất kỳ phương thức ngây thơ nào dường như mất 16 byte, một phương thức như vậy Ṃɓ_J×¥H÷‘H<¬Ȧð€S, tuy nhiên hóa ra phương thức được sử dụng ở đây hiệu quả hơn cũng như ngắn hơn!

Phương pháp này xây dựng quá nhiều ngăn xếp cầu vồng khi đếm hạt, bao gồm các dải cực tím và cộng thêm 1 cho mỗi ngăn xếp có thể.

Thử nghiệm cho điều đó là có thể là kiểm tra xem chỉ có một dải duy nhất KHÔNG thể có nếu chúng ta cần một số hạt dải cực tím nhưng được cung cấp bằng không.

Ṃ+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÷ß

Hãy thử trực tuyến!

$n$

Thuật toán Pyth ⟶ Thuật toán 05AB1E

Có nhiều phương pháp người ta có thể thử để giải quyết thử thách này trong 05AB1E, vì vậy tôi đã thử một vài trong số chúng và điều này hóa ra là ngắn nhất. Điều chỉnh công thức đã nói ở trên từ câu trả lời Pyth của tôi, hãy nhớ rằng 05AB1E đã sử dụng lập chỉ mục 1, chúng ta có thể xây dựng chức năng của mình như sau:

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

$I$$i$

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

Lưu ý rằng đẳng thức này không chính xác (nhưng hiện tại tôi không biết cách nào để nêu chính thức hơn) và các giải pháp cho phương trình này sẽ mang lại các số có dấu phẩy động, nhưng chúng tôi khắc phục điều này bằng cách sử dụng phép chia sàn thay vì chia chính xác sau này Dù sao, để tiếp tục với lập luận của chúng tôi, hầu hết các bạn có lẽ rất quen thuộc với các giải pháp của phương trình như vậy, vì vậy ở đây chúng tôi có nó:

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

Đó chính xác là mối quan hệ mà câu trả lời này thực hiện.

C ++, 127 125 byte

Cạo sạch 2 byte nhờ 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;}

Hãy thử trực tuyến!

Hàm lấy một mảng kiểu C gồm bảy int và trả về một int.

Thuật toán này khá đơn giản (và đã được mô tả một số lần trước đây, vì vậy đây là một mô tả nữa, chủ yếu là cho niềm vui xem của riêng tôi). Để cho$c$ là chỉ số màu ($0\le c\le6$), do đó số lượng hạt cần thiết để hình thành $n$-thứ tự $(n\ge1)$ phần cầu vồng của màu đó là $y_c(n)=(c+3)+8(n-1)$và tổng số hạt tạo thành $n$ phần cầu vồng là màu $Y_c(n)=\sum_{k=1}^{n}y_c(k)=n(c+3)+\frac{8n(n-1)}{2}$. Bây giờ chúng ta có một hệ thống bất bình đẳng$x_c\ge Y_c(n)$ (Ở đâu $x_c$ là các phần tử của mảng đầu vào), cung cấp cho chúng ta một tập hợp các giới hạn trên $n:$

$$n\le\frac{-(c-1) + \sqrt{(c-1)^2 + 16x_c}}{8}$$ .

Những gì còn lại chỉ là lặp đi lặp lại $x_c$ và tìm mức tối thiểu.

Giải trình:

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