10

दिया हुआ:

एक प्राकृतिक संख्या एस ।
N तर्कसंगत वजन की एक सूची W जो कि 1 का योग है।

N गैर-नकारात्मक पूर्णांकों की सूची L , जैसे कि:

(1) sum(L) = S
(2) sum((S⋅W_i - L_i)^2) is minimal

दूसरे शब्दों में, S⋅W_iपूर्णांकों के साथ लगभग संभव के रूप में करीब है।

उदाहरण:

1 [0.4 0.3 0.3] = [1 0 0]
3 [0 1 0] = [0 3 0]
4 [0.3 0.4 0.3] = [1 2 1]
5 [0.3 0.4 0.3] = [2 2 1] or [1 2 2] but not [1 3 1]
21 [0.3 0.2 0.5] = [6 4 11]
5 [0.1 0.2 0.3 0.4] = [1 1 1 2] or [0 1 2 2]
4 [0.11 0.3 0.59] = [1 1 2]
10 [0.47 0.47 0.06] = [5 5 0]
10 [0.43 0.43 0.14] = [4 4 2]
11 [0.43 0.43 0.14] = [5 5 1]

नियम:

आप किसी भी इनपुट प्रारूप का उपयोग कर सकते हैं, या केवल एक फ़ंक्शन प्रदान कर सकते हैं जो इनपुट को तर्क के रूप में स्वीकार करता है।

पृष्ठभूमि:

प्रकारों के संबंध में अलग-अलग अनुपात डब्ल्यू _i में विभिन्न प्रकार की वस्तुओं का एस प्रदर्शित करते समय यह समस्या सामने आती है ।

इस समस्या का एक और उदाहरण आनुपातिक राजनैतिक प्रतिनिधित्व है, अपीलीय विरोधाभास देखें । पिछले दो परीक्षण मामलों को अलबामा विरोधाभास के रूप में जाना जाता है।

एक सांख्यिकीविद् के रूप में, मैंने इस समस्या को एक स्तरीकृत नमूने का संचालन करते समय नमूना आकारों की पहचान करने में आई एक समस्या के बराबर माना। उस स्थिति में, हम नमूने में प्रत्येक स्ट्रैटम के अनुपात को जनसंख्या में प्रत्येक स्ट्रेटम के अनुपात के बराबर बनाना चाहते हैं। - @ तूमी

code-golf number arithmetic

— glebm
स्रोत

आप शब्दों में कह सकते हैं कि कार्य क्या है? मैं कुछ सहज में अभिव्यक्ति decompressing परेशानी हो रही है।

— xnor

दोनों को ≤, निश्चित होना चाहिए। कार्य एक पूर्णांक को वज़न के आधार पर पूर्णांक के योग के रूप में प्रस्तुत करना है। शेष को उच्चतम भार के अनुकूल वितरण करना चाहिए, हालांकि मुझे यकीन नहीं है कि यह आवश्यकता सही ढंग से एन्कोडेड है? यह दिलचस्प है क्योंकि round(A + B) != round(A) + round(B), एक छोटे से समाधान के लिए एक अंतर्दृष्टि की आवश्यकता है कि यहां क्या हो रहा है।

— glebm

1

हो सकता L[i] - S*W[i]है नियम 2 और नियम 3 के बजाय, दूरियों की राशि को कम करने के लिए नियमों को बदल दें । यह लगभग अनुमानित होगा S*W[i]।

— जकुबे

1

इसके [0 1 2 2] लिए एक और संभावित समाधान है5 [0.1 0.2 0.3 0.4]

— जकाबे

1

हो सकता है कि आपको 1 [0.4 0.3 0.3] के लिए एक उदाहरण जोड़ना चाहिए

— एडिट्स ने छोड़ दिया क्योंकि एसई EVIL

6

एपीएल, 21

{{⍵+1=⍋⍋⍵-⍺}⍣⍺/⍺0×⊂⍵}

यह aditsu के 37 बाइट CJam उत्तर से एक अनुवाद है ।

इसे ऑनलाइन टेस्ट करें ।

व्याख्या

 {      ⍵-⍺}            ⍝ Right argument - left argument.
 {  1=⍋⍋⍵-⍺}            ⍝ Make one of the smallest number 1, others 0.
 {⍵+1=⍋⍋⍵-⍺}            ⍝ Add the result and the right argument together.
 {⍵+1=⍋⍋⍵-⍺}⍣⍺          ⍝ Repeat that S times. The result of each iteration is the new right argument.
                  ⊂⍵    ⍝ Return enclosed W, which is taken as one unit in APL.
               ⍺0×⊂⍵    ⍝ Return S*W and 0*W.
{{⍵+1=⍋⍋⍵-⍺}⍣⍺/⍺0×⊂⍵}   ⍝ Make S*W the left argument, 0*W the right argument in the first iteration.

— jimmy23013
स्रोत

7

अजगर 2, 95 83 132 125 143

मेरे पहले (और दूसरे) (और तीसरे) एल्गोरिदम में एक (दूसरे!) को फिर से लिखने और अधिक परीक्षण करने के बाद समस्याएं थीं, यहां (मैं वास्तव में आशा करता हूं) एक सही और तेज़ समाधान है:

def a(b,h):
 g=h;c=[];d=[]
 for w in b:f=int(w*h);d+=[f];c+=[h*w-f];g-=f
 if g:
  for e in sorted(c)[-g:]:i=c.index(e);c[i]=2;d[i]+=1
 return d

मिनीफ़ायर से पहले का स्रोत अब दिखता है:

# minified 143 bytes
def golfalloc(weights, num):
    # Tiny seq alloc for golfing
    gap = num;
    errors = [];
    counts = []
    for w in weights :
        count = int(w*num);
        counts += [count];
        errors += [num*w - count];
        gap -= count
    if gap:
        for e in sorted(errors)[-gap:] :
            i = errors.index(e);
            errors[i] = 2;
            counts[i] += 1
    return counts

परीक्षण वापस:

Pass                    Shape    N               Result Error                        AbsErrSum
ok            [0.4, 0.3, 0.3]    1            [1, 0, 0] -0.60,+0.30,+0.30                 1.20
ok                  [0, 1, 0]    3            [0, 3, 0] +0.00,+0.00,+0.00                 0.00
ok            [0.3, 0.4, 0.3]    4            [1, 2, 1] +0.20,-0.40,+0.20                 0.80
ok            [0.3, 0.4, 0.3]    5            [2, 2, 1] -0.50,+0.00,+0.50                 1.00
ok            [0.3, 0.2, 0.5]   21           [6, 4, 11] +0.30,+0.20,-0.50                 1.00
ok       [0.1, 0.2, 0.3, 0.4]    5         [1, 1, 1, 2] -0.50,+0.00,+0.50,+0.00           1.00
ok          [0.11, 0.3, 0.59]    4            [1, 1, 2] -0.56,+0.20,+0.36                 1.12
ok         [0.47, 0.47, 0.06]   10            [5, 5, 0] -0.30,-0.30,+0.60                 1.20
ok         [0.43, 0.43, 0.14]   10            [4, 4, 2] +0.30,+0.30,-0.60                 1.20
ok         [0.43, 0.43, 0.14]   11            [5, 5, 1] -0.27,-0.27,+0.54                 1.08

यह एल्गोरिदम यहां अन्य उत्तरों के समान है। यह संख्या के लिए O (1) है, इसलिए इसका पूर्णांक 10 और 1000000 के लिए समान है। यह सैद्धांतिक रूप से O (nlogn) की संख्या के लिए (क्योंकि क्रमबद्ध) है। यदि यह अन्य सभी ट्रिकी इनपुट मामलों को रोक देता है, तो यह मेरे प्रोग्रामिंग टूलबॉक्स में नीचे दिए गए एल्गोरिथम को बदल देगा।

कृपया उस एल्गोरिथ्म का उपयोग न करें जो कि कुछ भी नहीं है। मैंने स्रोत आकार को कम करने के लिए गति में समझौता किया। निम्न कोड समान तर्क का उपयोग करता है लेकिन बहुत तेज़ और अधिक उपयोगी है:

def seqalloc(anyweights, num):
    # Distribute integer num depending on weights.
    # weights may be non-negative integers, longs, or floats.
    totalbias = float(sum(anyweights))
    weights = [bias/totalbias for bias in anyweights]
    counts = [int(w*num) for w in weights]
    gap = num - sum(counts)
    if gap:
        errors = [num*w - q for w,q in zip(weights, counts)]
        ordered = sorted(range(len(errors)), key=errors.__getitem__)
        for i in ordered[-gap:]:
            counts[i] += 1
    return counts

संख्या का मान गति को प्रभावित नहीं करता है। मैंने 1 से 10 ^ 19 तक के मूल्यों के साथ इसका परीक्षण किया है। निष्पादन समय भार की संख्या के साथ रैखिक रूप से भिन्न होता है। मेरे कंप्यूटर पर 10 ^ 5 वेट के साथ 0.15 सेकंड और 10 ^ 7 वेट के साथ 15 सेकंड लगते हैं। ध्यान दें कि वजन एक अंश तक सीमित नहीं है। यहां जिस तरह की तकनीक का इस्तेमाल किया जाता है वह पारंपरिक sorted((v,i) for i,v in enumerate...)शैली से भी लगभग दोगुनी है।

मूल एल्गोरिथम

यह मेरे टूलबॉक्स में एक फ़ंक्शन था, गोल्फ के लिए थोड़ा संशोधित। यह मूल रूप से SO उत्तर से था । और यह गलत है।

def seqalloc(seq, num):
    outseq = []
    totalw = float(sum(seq))
    for weight in seq:
        share = int(round(num * weight / totalw)) if weight else 0
        outseq.append(share)
        totalw -= weight
        num -= share
    return outseq

यह एक सन्निकटन देता है, लेकिन हमेशा सही नहीं होता है, हालांकि योग (आउटसेक) == संख्या को बनाए रखा जाता है। फास्ट लेकिन अनुशंसित नहीं।

त्रुटियों को दर्शाने के लिए @alephalpha और @ user23013 को धन्यवाद।

संपादित करें: कुल सेट (डी) को 1 होना चाहिए क्योंकि ओपी निर्दिष्ट करता है कि वजन का योग हमेशा 1 होगा। अब 83 बाइट्स।

EDIT2: फिक्स्ड बग [0.4, 0.3, 0.3], 1 के लिए मिला।

EDIT3: त्रुटिपूर्ण एल्गोरिथम को छोड़ दिया गया। बेहतर एक जोड़ा।

EDIT4: यह हास्यास्पद है। सही के साथ प्रतिस्थापित (मैं वास्तव में आशा करता हूं) एल्गोरिथ्म।

EDIT5: इस एल्गोरिथ्म का उपयोग करना पसंद कर सकते हैं कि दूसरों के लिए नहीं जोड़ा गया गोल्फ कोड।

— तर्क नाइट
स्रोत

4

a([0.4, 0.3, 0.3], 1)रिटर्न [0, 1, 0], जबकि सही उत्तर है [1, 0, 0]।

— एलेफाल्फा

1

अभी भी गलत। a([0.11,0.3,0.59],4)लौट आया [0, 1, 3]। होना चाहिए [1, 1, 2]।

— jimmy23013

1

f([0.47,0.47,0.06],10)लौट आया [5, 4, 1]। होना चाहिए [5, 5, 0]।

— jimmy23013

2

मुझे लगता है कि अब यह सही है।

— jimmy23013

2

@CarpetPython मैं इस एल्गोरिथ्म के साथ एक समान प्रक्रिया से गुजरा, और इस तरह से मैं इस समस्या के साथ आया। यदि वे आपका लाइसेंस

— छीन

4

गणितज्ञ, 67 50 46 45 वर्ण

f=(b=⌊1##⌋;b[[#~Ordering~-Tr@#&[b-##]]]++;b)&

Ungolfed:

f[s_, w_] := Module[{a = s*w, b, c, d},
  b = Floor[a];
  c = b - a;
  d = Ordering[c, -Total[c]];
  b[[d]] += 1;
  b]

उदाहरण:

f[5,{0.1,0.2,0.3,0.4}]

{, 1, 1, 1, 2}

— alephalpha
स्रोत

मेरी अच्छाई, यह छोटा है, इसे देखते हुए गणितज्ञ!

— डेविड एफएक्स

3

CJam - 37

q~:W,0a*\:S{[_SWf*]z::-_:e<#_2$=)t}*p

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

स्पष्टीकरण:

q~             read and evaluate the input
               (pushing the number and the array on the stack)
:W,            save the array in variable W and calculate its length (N)
0a*            make an array of N zeros (the initial "L")
\:S            swap it with the number and save the number in S
{…}*           execute the block S times
    [_SWf*]    make a matrix with 2 rows: "L" and S*W
    z          transpose the matrix, obtaining rows of [L_i S*W_i]
    ::-_       convert to array of L_i-S*W_i and duplicate
    :e<        get the smallest element
    #          find its index in the unsorted array,
               i.e. the "i" with the largest S*W_i-L_i
    _2$=)t     increment L_i
p              print the result nicely

टिप्पणियाँ:

जटिलता ओ (एस * एन) के बारे में है, इसलिए यह बड़े एस के लिए वास्तव में धीमा हो जाता है
CJam में 2 सरणियों के लिए अंकगणितीय संचालकों की कमी है, कुछ मैं बाद में लागू करने की योजना बना रहा हूं

अलग विचार - 46

q~:Sf*_:m[_:+S\-@[1f%_,,]z{0=W*}$<{1=_2$=)t}/p

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

यह बहुत अधिक सीधा और कुशल है, लेकिन अफसोस, थोड़ा लंबा है। यहाँ विचार L_i = मंजिल (S * W_i) के साथ शुरू करना है, S और उनकी राशि के बीच अंतर (D कहना) निर्धारित करते हैं, S * W_i के सबसे बड़े अंश वाले भाग के साथ D सूचकांक पाते हैं (छँटाई करके और ऊपर D उठाकर) और उन सूचकांकों के लिए वेतन वृद्धि L_i। जटिलता ओ (एन * लॉग (एन))।

— aditsu छोड़ दिया क्योंकि SE EVIL है
स्रोत

अब ओ (एन) है :e<।

— jimmy23013

@ user23013 ओह, हाँ, पहले कार्यक्रम के लिए, धन्यवाद

— aditsu छोड़ दिया क्योंकि एसई EVIL

यह जल्दी था! बधाई

— glebm

सोच रहे लोगों के लिए, एक रैखिक समय चयन एल्गोरिथ्म के साथ सॉर्ट की जगह ओ (एन) के बजाय ओ (एनएलएलएन) के कारण उत्पन्न होगा: डी-वें सबसे बड़ा तत्व, पी, ओ (एन) में खोजें, फिर वेतन वृद्धि। तत्व जो =PD बार (O (N) D <= N) के बाद से हैं।

— glebm

@glebm बहुत अच्छा है, लेकिन मुझे लगता है कि एक समस्या है अगर कई तत्वों का समान मूल्य (P) है। शायद आप इसे 2 पास में हल कर सकते हैं: पहले वेतन वृद्धि और तत्वों की गणना करें> पी, फिर आप जानते हैं कि कितने तत्वों = पी की आवश्यकता है। या यदि आप चयन एल्गोरिदम से वह जानकारी प्राप्त कर सकते हैं, तो और भी बेहतर।

— एडित्सू ने छोड़ दिया क्योंकि एसई ईवीआईएल

3

जावास्क्रिप्ट (ईएस 6) 126 130 104 115 156 162 194

@ CarpetPython के उत्तर में सभी टिप्पणियों और परीक्षण मामलों के बाद, अपने पहले एल्गोरिथ्म पर वापस जाएं। काश, स्मार्ट समाधान काम नहीं करता। कार्यान्वयन थोड़ा छोटा हो गया, यह अभी भी सभी संभव समाधानों की कोशिश करता है, चुकता दूरी को शांत करता है और न्यूनतम रखता है।

संपादित करें वजन w के प्रत्येक आउटपुट तत्व के लिए, 'सभी' संभव मान सिर्फ 2 हैं: ट्रंक (डब्ल्यू * एस) और ट्रंक (डब्ल्यू * एस) +1, इसलिए कोशिश करने के लिए बस (2 ** एलमेनस्ट्स) संभव समाधान हैं।

Q=(s,w)=>
  (n=>{
    for(i=0;
        r=q=s,(y=i++)<1<<w.length;
        q|r>n||(n=r,o=t))
      t=w.map(w=>(f=w*s,q-=d=0|f+(y&1),y/=2,f-=d,r+=f*f,d));
  })()||o

फ़ायरफ़ॉक्स / फायरबग कंसोल में टेस्ट करें

;[[ 1,  [0.4, 0.3, 0.3]      ]
, [ 3,  [0, 1, 0]            ]
, [ 4,  [0.3, 0.4, 0.3]      ]
, [ 5,  [0.3, 0.4, 0.3]      ]
, [ 21, [0.3, 0.2, 0.5]      ]
, [ 5,  [0.1, 0.2, 0.3, 0.4] ]
, [ 4,  [0.11, 0.3, 0.59]    ]
, [ 10, [0.47, 0.47, 0.06]   ]
, [ 10, [0.43, 0.43, 0.14]   ]
, [ 11, [0.43, 0.43, 0.14]   ]]
.forEach(v=>console.log(v[0],v[1],Q(v[0],v[1])))

उत्पादन

1 [0.4, 0.3, 0.3] [1, 0, 0]
3 [0, 1, 0] [0, 3, 0]
4 [0.3, 0.4, 0.3] [1, 2, 1]
5 [0.3, 0.4, 0.3] [1, 2, 2]
21 [0.3, 0.2, 0.5] [6, 4, 11]
5 [0.1, 0.2, 0.3, 0.4] [0, 1, 2, 2]
4 [0.11, 0.3, 0.59] [1, 1, 2]
10 [0.47, 0.47, 0.06] [5, 5, 0]
10 [0.43, 0.43, 0.14] [4, 4, 2]
11 [0.43, 0.43, 0.14] [5, 5, 1]

यह एक बेहतर उपाय है। Weigth सरणी पर एकल पास।
प्रत्येक पास के लिए मुझे w में वर्तमान अधिकतम मूल्य लगता है। मैं इस मान को भारित पूर्णांक मान (राउंड अप) के साथ बदल देता हूं, इसलिए यदि s == 21 और w = 0.4, हमें 0.5 * 21 -> 10.5 -> 11. मिल गया, तो मैं इस मान को नकारात्मक रूप से संग्रहीत करता हूं, इसलिए यह नहीं हो सकता अगले लूप में अधिकतम के रूप में पाया जा सकता है। तब मैं कुल योग को तदनुसार घटाता हूं (s = s-11) और चर चर में कुल योगों को भी कम करता हूं।
लूप तब समाप्त होता है जब चिकित्सा 0 से अधिक नहीं होती है (सभी मान! = 0 को प्रबंधित किया गया है)।
अंत में मैं उन मानों को फिर से सकारात्मक में बदल देता हूँ। चेतावनी यह कोड जगह में वज़न सरणी को संशोधित करता है, इसलिए इसे मूल सरणी की एक प्रति के साथ कहा जाना चाहिए

~~F=(s,w)=> (f=>{ for(;j=w.indexOf(z=Math.max(...w)),z>0;f-=z) s+=w[j]=-Math.ceil(z*s/f); })(1)||w.map(x=>0-x)~~

मेरी पहली कोशिश

इतना स्मार्ट समाधान नहीं। हर संभव परिणाम के लिए, यह अंतर का मूल्यांकन करता है, और न्यूनतम रखता है।

F=(s,w,t=w.map(_=>0),n=NaN)=>
  (p=>{
    for(;p<w.length;)
      ++t[p]>s?t[p++]=0
      :t.map(b=>r+=b,r=p=0)&&r-s||
        t.map((b,i)=>r+=(z=s*w[i]-b)*z)&&r>n||(n=r,o=[...t])
  })(0)||o

अनगुल्ड एंड समझाया

F=(s, w) =>
{
  var t=w.map(_ => 0), // 0 filled array, same size as w
      n=NaN, // initial minumum NaN, as "NaN > value"  is false for any value
      p, r
  // For loop enumerating from [1,0,0,...0] to [s,s,s...s]
  for(p=0; p<w.length;)
  {
    ++t[p]; // increment current cell
    if (t[p] > s)
    {
      // overflow, restart at 0 and point to next cell
      t[p] = 0;
      ++p;
    }
    else
    {
      // increment ok, current cell is the firts one
      p = 0;
      r = 0;
      t.map(b => r += b) // evaluate the cells sum (must be s)
      if (r==s)
      {
        // if sum of cells is s
        // evaluate the total squared distance (always offset by s, that does not matter)
        t.map((b,i) => r += (z=s*w[i]-b)*z) 
        if (!(r > n))
        {
          // if less than current mininum, keep this result
          n=r
          o=[...t] // copy of t goes in o
        }
      }
    }
  }
  return o
}

— edc65
स्रोत

2

सीजेएम, 48 बाइट्स

समस्या का सीधा आगे समाधान।

q~:Sf*:L,S),a*{m*{(+}%}*{1bS=},{L]z::-Yf#:+}$0=p

इनपुट पसंद आता है

[0.3 0.4 0.3] 4

स्पष्टीकरण:

q~:S                                 "Read and parse the input, store sum in S";
    f*:L                             "Do S.W, store the dot product in L";
         S),                         "Get array of 0 to S";
        ,   a*                       "Create an array with N copies of the above array";
              {m*{(+}%}*             "Get all possible N length combinations of 0 to S ints";
                        {1bS=},      "Filter to get only those which sum up to S";
{L]z::-Yf#:+}$                       "Sort them based on (S.W_i - L_i)^2 value";
 L                                   "Put the dot product after the sum combination";
  ]z                                 "Wrap in an array and transpose";
    ::-                              "For each row, get difference, i.e. S.W_i - L_i";
       Yf#                           "Square every element";
          :+                         "Take sum";
              0=p                    "After sorting on sum((S.W_i - L_i)^2), take the";
                                     "first element, i.e. smallest sum and print it";

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत

2

पायथ: 40 बाइट्स

Mhosm^-*Ghded2C,HNfqsTGmms+*G@Hb}bklHyUH

यह g2 मापदंडों के साथ एक फ़ंक्शन को परिभाषित करता है । आप इसे पसंद कर सकते हैं Mhosm^-*Ghded2C,HNfqsTGmms+*G@Hb}bklHyUHg5 [0.1 0.2 0.3 0.4।

इसे ऑनलाइन आज़माएं: पायथ कंपाइलर / एक्ज़ीक्यूटर

स्पष्टीकरण:

mms+*G@Hb}bklHyUH     (G is S, H is the list of weights)
m             yUH    map each subset k of [0, 1, ..., len(H)-1] to:
 m          lH          map each element b of [0, 1, ..., len(H)-1] to: 
    *G@Hb                  G*H[b]
   +     }bk               + b in k
  s                       floor(_)

यह सभी संभव समाधान बनाता है L, जहां L[i] = floor(S*W[i])या L[i] = floor(S*W[i]+1)। उदाहरण के लिए, इनपुट 4 [0.3 0.4 0.3बनाता है [[1, 1, 1], [2, 1, 1], [1, 2, 1], [1, 1, 2], [2, 2, 1], [2, 1, 2], [1, 2, 2], [2, 2, 2]]।

fqsTG...  
f    ... only use the solutions, where
 qsTG       sum(solution) == G

ही [[2, 1, 1], [1, 2, 1], [1, 1, 2]]रह गए।

Mhosm^-*Ghded2C,HN
  o                  order the solutions by
   s                   the sum of 
    m         C,HN       map each element d of zip(H, solution) to
     ^-*Ghded2           (G*d[0] - d[1])^2
 h                   use the first element (minimum)
M                    define a function g(G,H): return _

— Jakube
स्रोत

2

गणितज्ञ १०hem

s_~f~w_:=Sort[{Tr[(s*w-#)^2],#}&/@ 
Flatten[Permutations/@IntegerPartitions[s,{Length@w},0~Range~s],1]][[1,2]]

f[3, {0, 1, 0}]
f[4, {0.3, 0.4, 0.3}]
f[5, {0.3, 0.4, 0.3}]
f[21, {0.3, 0.2, 0.5}]
f[5, {0.1, 0.2, 0.3, 0.4}]

{, 3, 0}
{1, 2, 1}
{1, 2, 2}
{6, 4, 11}
{0, 1, 2, 2}

व्याख्या

Ungolfed

f[s_,w_]:=
Module[{partitions},
partitions=Flatten[Permutations/@IntegerPartitions[s,{Length[w]},Range[0,s]],1];
Sort[{Tr[(s *w-#)^2],#}&/@partitions][[1,2]]]

IntegerPartitions[s,{Length@w},0~Range~s]रिटर्न सब के पूर्णांक विभाजन s, सेट से लिया तत्वों का उपयोग कर {0, 1, 2, ...s}बाधा है कि उत्पादन वजन के सेट में के रूप में तत्वों की एक ही नंबर शामिल करना चाहिए साथ, w।

Permutations प्रत्येक पूर्णांक विभाजन के आदेशित व्यवस्था के सभी देता है।

{Tr[(s *w-#)^2],#}{error, permutation} प्रत्येक क्रमपरिवर्तन के लिए , आदेशित जोड़े की सूची देता है ।

Sort[...] की सूची क्रमबद्ध करें {{error1, permutation1},{error2, permutation2}...according to the size of the error.

[[1,2]]]या Part[<list>,{1,2}]सॉर्ट की गई सूची में पहले तत्व का दूसरा आइटम लौटाता है {{error, permutation}...}। दूसरे शब्दों में, यह सबसे छोटी त्रुटि के साथ क्रमचय लौटाता है।

— DavidC
स्रोत

2

आर, 85 80 76

हरे कोटा विधि का उपयोग करता है।

एक जोड़ी को देखकर कल्पना को हटा दिया कि डब्ल्यू 1 का योग करेगा

function(a,b){s=floor(d<-b*a);s[o]=s[o<-rev(order(d%%1))[0:(a-sum(s))]]+1;s}

परीक्षण चालन

> (function(a,b){s=floor(d<-b/(sum(b)/a));s[o]=s[o<-rev(order(d%%1))[0:(a-sum(s))]]+1;s})(3,c(0,1,0))
[1] 0 3 0
> (function(a,b){s=floor(d<-b/(sum(b)/a));s[o]=s[o<-rev(order(d%%1))[0:(a-sum(s))]]+1;s})(1,c(0.4,0.3,0.3))
[1] 1 0 0
> (function(a,b){s=floor(d<-b/(sum(b)/a));s[o]=s[o<-rev(order(d%%1))[0:(a-sum(s))]]+1;s})(4,c(0.3, 0.4, 0.3))
[1] 1 2 1
> (function(a,b){s=floor(d<-b/(sum(b)/a));s[o]=s[o<-rev(order(d%%1))[0:(a-sum(s))]]+1;s})(5,c(0.3, 0.4, 0.3))
[1] 1 2 2
> (function(a,b){s=floor(d<-b/(sum(b)/a));s[o]=s[o<-rev(order(d%%1))[0:(a-sum(s))]]+1;s})(21,c(0.3, 0.2, 0.5))
[1]  6  4 11
> (function(a,b){s=floor(d<-b/(sum(b)/a));s[o]=s[o<-rev(order(d%%1))[0:(a-sum(s))]]+1;s})(5,c(0.1,0.2,0.3,0.4))
[1] 1 1 1 2
>

— MickyT
स्रोत

2

पायथन, 139 128 117 बाइट्स

def f(S,W):
 L=(S+1,0,[]),
 for n in W:L=[(x-i,y+(S*n-i)**2,z+[i])for x,y,z in L for i in range(x)]
 return min(L)[2]

पिछले itertools समाधान, 139 बाइट्स

from itertools import*
f=lambda S,W:min((sum(x)!=S,sum((S*a-b)**2for a,b in zip(W,x)),list(x))for x in product(*tee(range(S+1),len(W))))[2]

— Sp3000
स्रोत

मैं सोच रहा था कि क्या एक itertools समाधान संभव होगा। अच्छा काम +1। क्या मैं यह सोचने में सही हूं कि इसमें O (n ^ 4) समय की जटिलता है?

— लॉजिक नाइट

Itertools समाधान O(S^len(W))वास्तव में था : पी। नए समाधान बहुत तेज है, लेकिन अभी भी धीमा है

— Sp3000

2

ऑक्टेव, 87 76

golfed:

function r=w(s,w)r=0*w;for(i=1:s)[m,x]=max(s*w-r);r(x)+=1;endfor endfunction

Ungolfed:

function r=w(s,w)
  r=0*w;   # will be the output
  for(i=1:s)
    [m,x]=max(s*w-r);
    r(x)+=1;
  endfor
endfunction

(ब्लास्ट "एंडफोर्म" और "एंडफंक्शन"! मैं कभी नहीं जीत पाऊंगा लेकिन मैं "वास्तविक" भाषा के साथ गोल्फ का आनंद लेता हूं।)

— dcsohl
स्रोत

अच्छा एल्गोरिथ्म। आप बदल सकते हैं zeros(size(w))के साथ 0*w।

— एलेफ़लफा

अच्छा! मैंने ऐसा क्यों नहीं सोचा?

— dcsohl

1

टी-एसक्यूएल, 167 265

क्योंकि मैं इन चुनौतियों को एक क्वेरी में भी आजमाना चाहता हूं।

ऐनक को बेहतर ढंग से फिट करने के लिए इसे इनलाइन फ़ंक्शन में बदल दिया और टेबल डेटा के लिए एक प्रकार बनाया। इसकी कीमत थोड़ी थी, लेकिन यह कभी भी दावेदार नहीं था। प्रत्येक कथन को अलग से चलाने की आवश्यकता है।

CREATE TYPE T AS TABLE(A INT IDENTITY, W NUMERIC(9,8))
CREATE FUNCTION W(@ int,@T T READONLY)RETURNS TABLE RETURN SELECT CASE WHEN i<=@-SUM(g)OVER(ORDER BY(SELECT\))THEN g+1 ELSE g END R,A FROM(SELECT A,ROW_NUMBER()OVER(ORDER BY (W*@)%1 DESC)i,FLOOR(W*@)g FROM @T)a

उपयोग में

DECLARE @ INT = 21
DECLARE @T T
INSERT INTO @T(W)VALUES(0.3),(0.2),(0.5)
SELECT R FROM dbo.W(@,@T) ORDER BY A

R
---------------------------------------
6
4
11

— MickyT
स्रोत

अपभ्रंश विरोधाभास

एपीएल, 21

व्याख्या

अजगर 2, 95 83 132 125 143

मूल एल्गोरिथम

गणितज्ञ, 67 50 46 45 वर्ण

CJam - 37

जावास्क्रिप्ट (ईएस 6) 126 130 104 115 156 162 194

सीजेएम, 48 बाइट्स

पायथ: 40 बाइट्स

स्पष्टीकरण:

गणितज्ञ १०hem

व्याख्या

आर, 85 80 76

पायथन, 139 128 117 बाइट्स

पिछले itertools समाधान, 139 बाइट्स

ऑक्टेव, 87 76

टी-एसक्यूएल, 167 265