बिल का विभाजन

Question

कार्य

मान लीजिए कि pपेपोल को एक बिल को विभाजित करना है; उनमें से प्रत्येक एक ट्रिपल से (Name, n, k)बना है:

• Name: नाम ;
• n: वह राशि जिसे उसे भुगतान करना है ;
• k: वह राशि / जो उसने वास्तव में चुकाई थी ।

यहां चुनौती यह पता लगाने की है कि किसका कितना बकाया है।

मान्यताओं

• इनपुट और आउटपुट किसी भी सुविधाजनक प्रारूप में हो सकते हैं।

• p $\in \mathbb{N}, \,\;\;$n $\in \mathbb{N}^{+},\;$ k $\in \mathbb{N}.$

• p $\gt 1.$

• नाम मनमाने ढंग से लंबाई के अनूठे तार होते हैं, जो निचली स्थिति के वर्णों से बने होते हैं।

उपाय

समाधान pलोगों के बीच लेनदेन के न्यूनतम सेट द्वारा दर्शाया गया है ; विशेष रूप से वे त्रिक हैं(from, to, amount)

• from: nameपैसा देने वाले व्यक्ति का;
• to: nameधन प्राप्त करने वाले व्यक्ति का;
• amount: लेन-देन का धन।

नोट : सभी ऋणों nका योग ( k) पहले से भुगतान की गई सभी राशियों के योग से अलग हो सकता है ( )। इस मामले में, आपको आउटपुट ('owner', Name, amount)या (Name, 'owner', amount)आपके द्वारा चुने गए प्रारूप में जोड़ना होगा । कोई भी नाम कभी नहीं होगा owner। स्ट्रिंग 'स्वामी' लचीला है।

यदि कई मिमिएस्ट सेट मौजूद हैं, तो सभी लेनदेन राशियों (पूर्ण मान) की न्यूनतम राशि के साथ एक का चयन करें; एक टाई के मामले में, उनमें से एक चुनें।

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

inputs(Name,n,k):
[('a',30,40),('b',40,50),('c',30,15)]
[('a',30,30),('b',20,20)]
[('a',30,100),('b',30,2),('c',40,0)]
[('a',344,333),('b',344,200),('c',2,2)]
[('a',450,400),('b',300,300),('c',35,55)]

outputs(from, to, amount):
[('c','a',10),('c','b',5),('owner','b',5)] or [('c','b',10),('c','a',5),('owner','a',5)]
[]
[('owner','a',2),('b','a',28),('c','a',40)] PS: [('owner','a',2),('b','a',68),('c','b',40)] has the same number of transactions, but it is not a valid answer, because the total amount of its transaction is greater than that of the proposed solution.
[('a','owner',11),('b','owner',144)]
[('a','owner',30),('a','c',20)]

यह कोड-गोल्फ है: सबसे छोटा कोड जीतता है ।

Comments

मुझे लगता है कि आपको बदलना चाहिए "आपको सबसे सरल परिदृश्य का उत्पादन करना होगा जिसमें कम से कम लेनदेन की आवश्यकता होती है।" "आपको उस परिदृश्य को आउटपुट करना होगा जिसके लिए कम से कम संख्या में लेनदेन की आवश्यकता होती है। यदि ऐसे कई परिदृश्य मौजूद हैं, तो लेन-देन की कुल कुल धारणा में से एक का चयन करें।" चूंकि मेरा मानना ​​है कि यह स्पष्ट है।

— जोनाथन एलन

अच्छी चुनौती है। लेकिन शायद यह सुनिश्चित करने के लिए अधिक जटिल परीक्षण मामलों की आवश्यकता होगी कि समाधान वास्तव में हमेशा इष्टतम हैं।

— अरनुलड

"कम से कम कुल धारणा" क्या है?

— ग्रिटोसिस्ट

@JonathanAllan अभी भी शब्द "कुख्यात" से भ्रमित है। वह कहा से आ रहा है टेस्ट केस 3 के आधार पर ऐसा लगता है कि एक व्यक्ति को ऐसे जवाब देना चाहिए जहां एक ही व्यक्ति दोनों को नहीं देता है और प्राप्त नहीं करता है? क्या वो सही है? यह भी बताया गया है कि ऐसा क्यों माना जाता है?

— जोनाह

@ जोना मैंने लेन-देन के निर्देशों के बाद से "कुल धारणा" का इस्तेमाल नहीं किया (केवल उनके पूर्ण आकार) पर विचार नहीं किया जाना चाहिए, हालांकि अब मुझे एहसास हुआ कि यह कुछ हद तक बेमानी है (दो लेनदेन होने के नाते, जो एक-दूसरे को काउंटर-ब्रेकिंग के रूप में नहीं माना जाएगा। !)। [नोटियन सिर्फ वित्त में प्रयुक्त शब्द है।]

— जोनाथन एलन

Answer 1

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

के रूप में इनपुट लेता है [[n0, k0, name0], [n1, k1, name1], ...]।

समाधान में लेन-देन सकारात्मक या नकारात्मक हो सकता है। मालिक को अपरिभाषित कहा जाता है ।

a=>(m=g=(B,t,s)=>B.some(x=>x)?B.map((b,x)=>B.map((c,y)=>b*c<0&b*b<=c*c&&g(C=[...B],[...t,[a[x][2],b,a[y][2]]],s+a.length-1/b/b,C[C[y]+=b,x]=0))):m<s||(r=t,m=s))([...a.map(([x,y])=>t-(t+=y-x),t=0),t],[],a.push(g))&&r

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

टिप्पणी की गई

a => (                              // a[] = input array
  m =                               // initialize m to a non-numeric value
  g = (B, t, s) =>                  // g = function taking: B = balances, t = transactions,
                                    //     s = score of the current solution
    B.some(x => x) ?                // if at least one balance is not equal to 0:
      B.map((b, x) =>               //   for each balance b at position x:
        B.map((c, y) =>             //     for each balance c at position y:
          b * c < 0 &               //       if b and c are of opposite sign
          b * b <= c * c &&         //       and |b| <= |c|,
          g(                        //       do a recursive call to g:
            C = [...B],             //         - with a copy C of B
            [ ...t,                 //         - append the new transaction to t[]
              [a[x][2], b, a[y][2]] //           in [from_name, amount, to_name] format
            ],                      //
            s + a.length - 1/b/b,   //         - add (a.length - 1/b²) to s
            C[C[y] += b, x] = 0     //         - update C[y] and clear C[x]
          )                         //       end of recursive call
        )                           //     end of inner map()
      )                             //   end of outer map()
    :                               // else:
      m < s ||                      //   if the score of this solution is lower than m,
      (r = t, m = s)                //   update r to t and m to s
)(                                  // initial call to g:
  [                                 //   build the list of balances:
    ...a.map(([x, y]) =>            //     each balance is equal to:
      t - (t += y - x),             //     due_value - paid_value
      t = 0                         //     keep track of the total t ...
    ),                              //
    t                               //   ... which is appended at the end of this array
  ],                                //   (this is the balance of the owner)
  [],                               //   start with t = []
  a.push(g)                         //   append a dummy owner to a[]; start with s = 1
) && r                              // return r