परिचय:

(स्रोत: विकिपीडिया )
जब हम एक इंद्रधनुष को देखते हैं तो उसमें हमेशा ऊपर से नीचे तक रंग होंगे:
लाल; संतरा; पीला; हरा; नीला; इंडिगो; बैंगनी

अगर हम इन अलग-अलग रिंगों को देखें, तो लाल रिंग वायलेट रिंग से बड़ी होती है।
इसके अलावा, एक ही समय में दो या तीन इंद्रधनुष होना भी संभव है।

इस चुनौती में उपरोक्त सभी का उपयोग किया जाएगा:

चुनौती:

बिल्कुल 7 आकार के पूर्णांक की एक सूची को देखते हुए, जहां प्रत्येक मान इंद्रधनुष-बनाने के लिए उपलब्ध रंग-कणों को इंगित करता है (जहां सबसे बड़ा सूचकांक लाल इंगित करता है और सबसे छोटा सूचकांक वायलेट इंगित करता है), जो इंद्रधनुष का गठन कर सकता है।

एक पूर्णांक-इंद्रधनुष में कम से कम 3x वायलेट, 4x इंडिगो, 5x नीला, 6x हरा, 7x पीला, 8x नारंगी, 9x लाल होना आवश्यक है। इसके ऊपर एक दूसरा इंद्रधनुष पहले इंद्रधनुष की लाल रिंग (उनके बीच एक स्थान सहित) से भी बड़ा होगा, इसलिए इसे कम से कम 11x बैंगनी, 12x इंडिगो, 13x नीला, 14x हरा, 15x पीला, 16x नारंगी , 17x लाल इसके अलावा जो पहले इंद्रधनुष का उपयोग करता है। तीसरा इंद्रधनुष 19x वायलेट पर फिर से शुरू होगा।

उदाहरण:

इनपुट-सूची: [15,20,18,33,24,29,41]
आउटपुट: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

code-golf number integer

— केविन क्रूज़सेन
स्रोत

0,0,0,0,0,0,0बढ़त दर-मामला हालांकि :( (यह 1-खाई तर्क के साथ फिट नहीं करता है)

— जोनाथन एलन

8

अजगर , 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) = \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)$

सी (n, मैं) = (मैं + 3) n + 8 \cdot \frac{(n - 1) n}{2} = (मैं + 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)$

सी (n, मैं) = n (मैं + 3 + 4 n - 4) ⟹ सी (n, मैं) = n (4 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}$

कार्यान्वयन

$C$ .e $k$ $b$ $T$ $b<C(T, i)$ $C(T, i)\le b$ और 1 से ऑफसेट करने के लिए इसे एक से घटाएं।

— मिस्टर एक्सकोडर
स्रोत

3

पायथन 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):।

हम बस एन के लिए हल करते हैं, और न्यूनतम मूल्य लेते हैं।

बचाया:

-3 बाइट्स, ओव्स के लिए धन्यवाद

— TFeld
स्रोत

2

आह, अब मुझे वह प्रतिक्रिया मिल गई है ...

— जोनाथन फ्रीच

1

61 बाइट्स

— ओव्स

@ नोव्स, थैंक्स :)

— टीफ़ल्ड

3

05AB1E , 18 17 16 बाइट्स

मैजिक ऑक्टोपस Urn के लिए -1 बाइट धन्यवाद

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

इसे ऑनलाइन आज़माएं!

एन इंद्रधनुष के लिए आवश्यक रंग की मात्रा n (4n + [-1, 0, 1, 2, 3, 4, 5]) है ।

— Okx
स्रोत

[ND4*6Ý<+*¹›1å#Nकाम करता है लेकिन मुझे पता नहीं क्यों। -1 बाइट हालांकि

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn धन्यवाद! यह काउंटर काउंटर के बजाय लूप इंडेक्स का उपयोग करता है।

— 17

अजीब लगता है, N>हालांकि मुझे ऐसा नहीं करना है - क्योंकि आपके पास ¾>पहले था ।

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn काउंटर वैरिएबल को बढ़ाने का कमांड काउंटर वैरिएबल को पुश नहीं करता है।

— 19

2

जावास्क्रिप्ट (ईएस 6), 49 बाइट्स

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

इसे ऑनलाइन आज़माएं!

कैसे?

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

{पी}_{(n, क)} = n (4 n + (क - 1)) = 4 n^{2} + (क - 1) n

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

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

लेकिन गोल्फ उद्देश्यों के लिए, हम बाद के n === undefinedनकारात्मक मूल्यों के साथ शुरू करते हैं और उपयोग करते हैं n। पहली पुनरावृत्ति हमेशा सफल होती है क्योंकि असमानता का सही पक्ष इसका मूल्यांकन करता है NaN। इसलिए, पहला सार्थक परीक्षण दूसरा है n == -1।

— Arnauld
स्रोत

1

जेली , 18 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Okx के 05AB1E उत्तर में स्पष्टीकरण का उपयोग करता है।

— आउटगोल्फ को एरिक करें
स्रोत

1

एक्सेल VBA, 78 बाइट्स

बेनामी फ़ंक्शन जो [A1:G1]VBE तत्काल विंडो के लिए और आउटपुट की सीमा से इनपुट लेता है ।

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

— टेलर स्कॉट
स्रोत

1

चारकोल , 21 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण: प्रत्यक्ष रूप से प्राप्त किए गए एक सूत्र के साथ प्रत्येक रंग के साथ संभव इंद्रधनुष की संख्या की सीधे गणना करता है, लेकिन @ टीफ़िल्ड के सूत्र के समान है।

   Ａ                   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

— नील
स्रोत

1

जावास्क्रिप्ट (Node.js) , 54 बाइट्स

@TFeld जवाब का पोर्ट

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

इसे ऑनलाइन आज़माएं!

— लुइस फेलिप डी जीसस मुनोज
स्रोत

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!)

— जोनाथन एलन
स्रोत

मैं आपको महसूस करता हूं, 18 बाइट्स में ओक्स के एल्गोरिथ्म को निचोड़ना मेरे लिए निश्चित रूप से बहुत कठिन था ...

— एरिक द आउटगलर

इसके अलावा, चतुर विचार के साथ §ỊS!

— आउटगोल्फर

1

05AB1E , 14 बाइट्स

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

इसे ऑनलाइन आज़माएं!

$n$

पायथ एल्गोरिथ्म ⟶ 05AB1E एल्गोरिथ्म

रहे हैं कई तरीकों से एक 05AB1E में इस चुनौती को हल करने के लिए कोशिश कर सकते हैं, तो मैं उनमें से एक जोड़े की कोशिश की और यह कम से कम साबित हुआ। मेरे Pyth उत्तर से उपर्युक्त सूत्र को अपनाना, यह ध्यान में रखते हुए कि 05AB1E ने 1-इंडेक्सिंग का उपयोग किया, हम अपने कार्य का निर्माण इस प्रकार कर सकते हैं:

सी (n, मैं) = n (मैं + 2) + 4 n (n - 1)

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

$I$ $i$

4 n^{2} + n (मैं - 2) - {मैं}_{मैं} = 0

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

ध्यान दें कि यह समानता सटीक नहीं है (लेकिन मुझे वर्तमान में इसे और अधिक औपचारिक रूप से बताने का तरीका नहीं पता है) और इस समीकरण के समाधानों में फ्लोटिंग-पॉइंट नंबर होंगे, लेकिन हम सटीक विभाजन के बजाय फर्श विभाजन का उपयोग करके इसे ठीक करते हैं बाद में। वैसे भी, हमारे तर्क को जारी रखने के लिए, आप में से अधिकांश शायद इस तरह के समीकरण के समाधान से परिचित हैं , इसलिए यहां हमारे पास यह है:

n_{1, 2} = \frac{2 - मैं \pm \sqrt{(मैं - 2)^{2} + 16 {मैं}_{मैं}}}{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{(मैं - 2)^{2} + 16 {मैं}_{मैं}} - मैं}{8} ⌋

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

जो वास्तव में संबंध है कि यह उत्तर लागू होता है।

— मिस्टर एक्सकोडर
स्रोत

1

सी ++, 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;}

इसे ऑनलाइन आज़माएं!

फ़ंक्शन सात-ints के C- शैली सरणी लेता है और एक 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{- (सी - 1) + \sqrt{(सी - 1)^{2} + 16 {एक्स}_{सी}}}{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;
 }

— मैक्स येखलाकोव
स्रोत

नमस्ते वहाँ, PPCG में आपका स्वागत है! मैं सी भी अच्छी तरह से पता नहीं ++, लेकिन मैं बहुत यकीन है कि आप कर सकते हैं गोल्फ इस भाग: 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;। इसके अलावा, क्या आप शायद टेस्ट कोड के साथ एक टीआईओ-लिंक प्रदान कर सकते हैं ?

— केविन क्रूज़सेन

@KevinCruijssen धन्यवाद!

— मैक्स येखलाकोव

कोडगॉल्फ रेनबो: फन विथ इंटेगर-एरेस

परिचय:

चुनौती:

चुनौती नियम:

nइंद्रधनुषों की मात्रा के लिए आवश्यक न्यूनतम रंग :

सामान्य नियम:

परीक्षण के मामलों:

अजगर , 14 बाइट्स

कैसे?

पायथन 2 , 64 61 बाइट्स

05AB1E , 18 17 16 बाइट्स

जावास्क्रिप्ट (ईएस 6), 49 बाइट्स

कैसे?

जेली , 18 बाइट्स

एक्सेल VBA, 78 बाइट्स

चारकोल , 21 बाइट्स

जावास्क्रिप्ट (Node.js) , 54 बाइट्स

जेली , 14 बाइट्स

कैसे?

05AB1E , 14 बाइट्स

पायथ एल्गोरिथ्म ⟶ 05AB1E एल्गोरिथ्म

सी ++, 127 125 बाइट्स

`n`इंद्रधनुषों की मात्रा के लिए आवश्यक न्यूनतम रंग :