पृष्ठभूमि

फ्रांस में, और संभवतः यूरोपीय संघ के बाकी हिस्सों में, बिक्री के लिए उपलब्ध किसी भी भोजन को अपने पैकेजिंग पर तैयार करने वाले अवयवों को वजन प्रतिशत घटते क्रम में सूचीबद्ध करना होगा । हालाँकि, सटीक प्रतिशत को इंगित नहीं करना है, जब तक कि घटक पाठ या हाइलाइटिंग कवर पर प्रकाश डाला गया हो।

उदाहरण के लिए, मेरी तुलसी टमाटर की चटनी, इसकी पैकेजिंग पर केवल कुछ बड़े लाल टमाटर और सुंदर तुलसी के पत्तों को दिखाते हुए, निम्नलिखित संकेत दिए गए हैं:

सामग्री: टमाटर 80%, टुकड़ों में प्याज, तुलसी 1.4%, समुद्री नमक, मसला हुआ लहसुन, कच्चा गन्ना चीनी, अतिरिक्त कुंवारी जैतून का तेल, काली मिर्च।

यह दिलकश लगता है, लेकिन ... मैं कितना प्याज खाऊंगा , बिल्कुल?

चुनौती

अवरोही क्रम में वजन प्रतिशत की सूची को देखते हुए, अंततः अपूर्ण, न्यूनतम और अधिकतम वजन प्रतिशत की पूरी सूची का उत्पादन करता है जो संभवतः नुस्खा में पाया जा सकता है।

आप एक फ़ंक्शन, या एक पूर्ण प्रोग्राम लिख सकते हैं।
इनपुट किसी भी उचित प्रपत्र (संख्या या तार की सूची की सरणी, उदाहरण के लिए) में हो सकता है। आंशिक मानों को कम से कम एक दशमलव स्थान पर समर्थित होना चाहिए। एक लापता वजन प्रतिशत (किसी भी सुसंगत और स्पष्ट तरीके से प्रतिनिधित्व किया जा सकता है 0, '?'या nullउदाहरण के लिए,)। आप मान सकते हैं कि इनपुट हमेशा एक वैध नुस्खा से जुड़ा होगा ( [70]और [∅, ∅, 50]उदाहरण के लिए, अमान्य है)।
उत्पादन किसी भी उचित प्रपत्र (न्यूनतम और अधिकतम वजन प्रतिशत, या दोहरी की एक सूची दोनों के लिए एक सरणी, उदाहरण के लिए) में हो सकता है। न्यूनतम और अधिकतम प्रतिशत किसी भी क्रम में हो सकते हैं ( [min, max]और [max, min]दोनों स्वीकार्य हैं)। सटीक वजन प्रतिशत को अन्य प्रतिशत की तुलना में अलग तरीके से संसाधित करने की आवश्यकता नहीं होती है और इसे न्यूनतम और अधिकतम मान द्वारा दर्शाया जा सकता है।

कोड-गोल्फ के लिए मानक नियम लागू होते हैं: जब आप अपना कोड टाइप कर रहे होते हैं, तो मेरा पास्ता पकवान ठंडा हो जाता है, इसलिए सबसे छोटी सबमिशन जीत जाती है।

उदाहरण

चूंकि यह समस्या पहली नज़र में देखने की तुलना में कठिन है, इसलिए यहां कुछ मामलों का चरण-दर-चरण समाधान है।

`[40, ∅, ∅]`

आइए क्रमशः कॉल करें xऔर yदो लापता प्रतिशत।

क्योंकि यह 40% पर पहले घटक के बाद आता है, 40% xसे अधिक नहीं हो सकता है।
[40, [?, 40], [?, ?]]
दो लापता प्रतिशत का योग हमेशा 60% होता है। इसके फलस्वरूप :
- यदि xइसकी अधिकतम मूल्य yलेता है , तो इसका न्यूनतम मूल्य लेता है , जो इसलिए 60% है - 40% = 20%।
  [40, [?, 40], [20, ?]]
- यदि xइसका न्यूनतम मूल्य yलेता है , तो इसका अधिकतम मूल्य लेता है । लेकिन इससे xकम नहीं हो सकता है y, इसलिए इस मामले में x= y= 60% / 2 = 30%।
  [40, [30, 40], [20, 30]]

`[70, ∅, ∅, 5, ∅]`

चलो क्रमशः कॉल करते हैं x, yऔर zतीन लापता प्रतिशत।

zआवश्यक न्यूनतम और अधिकतम प्रतिशत 0% और 5% के बीच है। मान zलेते हैं = एक पल के लिए 0%। दो लापता प्रतिशत का योग हमेशा 25% होता है। इसके फलस्वरूप :
[70, [?, ?], [?, ?], 5, [0, 5]]
- यदि yइसका न्यूनतम मूल्य 5% है, तो xइसका अधिकतम मूल्य लिया जाता है, इसलिए यह 25% है - 5% = 20%।
  [70, [?, 20], [5, ?], 5, [0, 5]]
- यदि yइसका अधिकतम मूल्य xलेता है , तो इसका न्यूनतम मूल्य लेता है । लेकिन इससे xकम नहीं हो सकता है y, इसलिए इस मामले में x= y= 25% / 2 = 12.5%।
  [70, [12.5, 20], [5, 12.5], 5, [0, 5]]
आइए सत्यापित करें कि यदि हम अभी मान लें तो सब कुछ ठीक है z= 5%। दो लापता प्रतिशत का योग हमेशा 20% होता है। इसके फलस्वरूप :
- यदि yइसका न्यूनतम मूल्य 5% है, तो xइसका अधिकतम मूल्य लिया जाता है, जो इसलिए 20% है - 5% = 15%। यह मामला पहले से गणना की गई श्रेणियों में पहले से ही शामिल है।
- यदि yइसकी अधिकतम मूल्य xलेता है , तो इसका न्यूनतम मूल्य लेता है । लेकिन इससे xकम नहीं हो सकता है y, इसलिए इस मामले में x= y= 20% / 2 = 10%। यह मामला पहले से गणना की गई श्रेणी के लिए पहले से ही शामिल है y, लेकिन इसके लिए नहीं x।
  [70, [10, 20], [5, 12.5], 5, [0, 5]]

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

Input:  [∅]
Output: [100]

Input:  [70, 30]
Output: [70, 30]

Input:  [70, ∅, ∅]
Output: [70, [15, 30], [0, 15]]

Input:  [40, ∅, ∅]
Output: [40, [30, 40], [20, 30]]

Input:  [∅, ∅, 10]
Output: [[45, 80], [10, 45], 10]

Input:  [70, ∅, ∅, ∅]
Output: [70, [10, 30], [0, 15], [0, 10]]

Input:  [70, ∅, ∅, 5, ∅]
Output: [70, [10, 20], [5, 12.5], 5, [0, 5]]

Input:  [30, ∅, ∅, ∅, 10, ∅, ∅, 5, ∅, ∅]
Output: [30, [10, 25], [10, 17.5], [10, 15], 10, [5, 10], [5, 10], 5, [0, 5], [0, 5]]

code-golf math

— ब्लैक होल
स्रोत

पूरी तरह से असंबंधित

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

मैं इनपुट-टू-आउटपुट के लिए चरण-दर-चरण स्पष्टीकरण जोड़ूंगा [40, ∅, ∅]और [70, ∅, ∅, 5, ∅]चीजों को थोड़ा और स्पष्ट रूप से बताऊंगा। परीक्षण मामलों को देखे बिना एक चुनौती स्पष्ट होनी चाहिए, जो अभी मामला नहीं है। अगर मैं इसे सही ढंग से समझता हूं [40, ∅, ∅]: इन दोनों में विभाजित 100% के लिए 60 अधिक आवश्यक है ∅। पहले ∅को 30 या अधिक होना चाहिए (अन्यथा दूसरा ∅इसके ऊपर होगा, जो तब संभव नहीं है जब वे क्रम में हों)। इसके अलावा, यह ऊपर नहीं हो सकता है 40, इसलिए पहला ∅बन जाता है [30,40], और दूसरा बन जाता है [(100-40-40=)20, (100-40-30=)30]।

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

लगातार [min,max]/ [max,min]या मिश्रित अनुमति?

— l4m2

@ l4m2 मिक्सिंग [min,max]और [max,min]बॉर्डरलाइन स्वीकार्य है, लेकिन चूंकि यह अस्पष्ट परिणाम नहीं दे सकता है, मैं कहूंगा कि यह ठीक है।

— ब्लैकहोल

शायद मैं कुछ याद कर रहा हूं, लेकिन [70, 12, 11, 5, 2]आपके दूसरे उदाहरण के लिए काम क्यों नहीं करता है ? अगर यह काम करता है, के लिए न्यूनतम xसे कम होगा 12.5।

— DLosc 20

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

0लापता प्रतिशत की उम्मीद है । सभी प्रविष्टियों के लिए न्यूनतम और अधिकतम मानों की एक जोड़ी देता है।

a=>(g=a=>(h=(M,I,J=I^1)=>a.some((x,i)=>a.map((y,j)=>s-=j-i?M(j,i)-i?y[I]:M(w=y[I],z=x[J])-z||w==z?w:++k&&z:y[J],s=100,k=1,X=x)&&(I?-s:s)<0)?X[J]=M(X[I],X[J]+s/k):0)(Math.max,0)+h(Math.min,1)?g(a):a)(a.map((n,i)=>[n?p=n:a.find(n=>i--<0&&n)||0,p],p=100))

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

कैसे?

प्रारंभ

हम इनपुट ऐरे में प्रत्येक मान को सबसे बड़ी श्रेणी के साथ [] बदल देते हैं ।

a.map((n, i) =>       // for each value n at position i in a[]:
  [                   //   generate a [min, max] array:
    n ?               //     if n is not 0:
      p = n           //       use n as the minimum and save it in p
    :                 //     else:
      a.find(n =>     //       find the first value n
        i-- < 0 &&    //         which is beyond the current value
        n             //         and is not equal to 0
      ) || 0,         //       or use 0 as a default value
    p                 //     use p as the maximum
  ],                  //   end of array declaration
  p = 100             //   start with p = 100
)                     // end of map()

उदाहरण:

[ 0 ] --> [ [ 0, 100 ] ]
[ 30, 0, 5, 0 ] --> [ [ 30, 30 ], [ 5, 30 ], [ 5, 5 ], [ 0, 5 ] ]

मुख्य कार्य

मुख्य कार्य h () है । यह पहली प्रविष्टि के लिए दिखता है जो असंगत प्रतीत होता है जब हम या तो इसे कम करने या अधिकतम करने की कोशिश करते हैं। यदि यह एक को पाता है, तो यह इसे एक मान के लिए अद्यतन करता है जो अन्य श्रेणियों को देखते हुए कम से कम अस्थायी रूप से स्वीकार्य है।

यह इनपुट के रूप में M = Math.max / I = 0 या M = Math.min / I = 1 लेता है और J को I X 1 1 के रूप में परिभाषित करता है ।

चूँकि h () कम से कम पास करने और अधिकतम करने दोनों का समर्थन करने के लिए लिखा गया था, कोड टिप्पणी करने के लिए थोड़ा मुश्किल है। इसलिए हम केवल उस अधिकतम पास पर ध्यान केंद्रित करेंगे, जिसके लिए हमारे पास M = Math.max , I = 0 और J = 1 है । इन मापदंडों के साथ, कोड निम्नानुसार पढ़ता है:

a.some((x, i) =>              // for each range x at position i in a[] (tested range):
  a.map((y, j) =>             //   for each range y at position j in a[] (reference range):
    s -=                      //     update s:
      j - i ?                 //       if i is not equal to j:
        Math.max(j, i) - i ?  //         if j > i:
          y[0]                //           the reference range is beyond the tested range
                              //           so we just use the minimum value of the y range
        :                     //         else:
          Math.max(           //           take the maximum of:
            w = y[0],         //             w = minimum value of the y range
            z = x[1]          //             z = maximum value of the x range
          ) - z ||            //           if it's not equal to z
          w == z ?            //           or they are equal (i.e. if w <= z):
            w                 //             use w
          :                   //           else:
            ++k && z          //             increment the counter k and use z
      :                       //       else:
        y[1],                 //         use the maximum value of the y range
    s = 100,                  //     start with s = 100
    k = 1,                    //     start with k = 1
    X = x                     //     save the range x in X
  ) &&                        //   end of map()
  (0 ? -s : s) < 0            //   abort if s < 0 (i.e. if we've subtracted more than 100)
) ?                           // end of some(); if truthy:
  X[1] = Math.max(            //   update the maximum value of the faulty range to:
    X[0],                     //     either the minimum value
    X[1] + s / k              //     or the maximum value, less the correction
  )                           //   whichever is greater
:                             // else:
  0                           //   do nothing

प्रत्यावर्तन

पुनरावर्ती फ़ंक्शन जी () कॉलिंग एच () को तब तक रखता है जब तक कि न तो न्यूनतम या अधिकतम पास एक नए सुधार की ओर जाता है, और अंततः अंतिम परिणाम देता है।

g = a => h(Math.max, 0) + h(Math.min, 1) ? g(a) : a

— Arnauld
स्रोत

अच्छी तरह से किया :-) !