বিল বিভক্ত করা

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সমস্ত debtsণের যোগফল ( k) ইতিমধ্যে প্রদত্ত সমস্ত পরিমাণের ( ) এর যোগফল থেকে পৃথক হতে পারে । এই ক্ষেত্রে, আপনার অবশ্যই আউটপুট ('owner', Name, amount)বা (Name, 'owner', amount)আপনার চয়ন করা বিন্যাসে যুক্ত করতে হবে। কোনও নাম কখনই থাকবে না ownerstring স্ট্রিংয়ের 'মালিক' নমনীয়।

বেশ কয়েকটি ন্যূনতম সেট উপস্থিত থাকলে, সমস্ত লেনদেনের পরিমাণের (সর্বমোট মান) সর্বনিম্ন যোগফলের সাথে একটি নির্বাচন করুন; টাই করার ক্ষেত্রে, তাদের মধ্যে একটি চয়ন করুন।

পরীক্ষার কেস:

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

আমি মনে করি আপনার পরিবর্তন করা উচিত "আপনাকে সর্বাধিক সরলীকৃত দৃশ্যের আউটপুট দিতে হবে যার জন্য কমপক্ষে লেনদেনের প্রয়োজন requires" "আপনাকে এমন দৃশ্যের আউটপুট দিতে হবে যার জন্য কমপক্ষে সংখ্যক লেনদেনের প্রয়োজন requires যেহেতু আমি বিশ্বাস করি এটি পরিষ্কার।

— জোনাথন অ্যালান

দুর্দান্ত চ্যালেঞ্জ। তবে সমাধানগুলি সম্ভবত সর্বদা অনুকূল থাকে তা নিশ্চিত করার জন্য সম্ভবত আরও জটিল পরীক্ষার ক্ষেত্রে প্রয়োজন হবে।

— আর্নাউল্ড

"সর্বনিম্ন মোট ধারণা" কি?

— lirtosiast

@ জোনাথান অ্যালান এখনও "ধারণা" শব্দটি দ্বারা বিভ্রান্ত হয়েছেন। কোথায় যে থেকে আসছে? পরীক্ষার কেস 3 এর উপর ভিত্তি করে দেখে মনে হচ্ছে যে উত্তরগুলি পছন্দ করা উচিত যেখানে একই ব্যক্তি উভয়ই দেয় এবং গ্রহণ করে না? এটা কি ঠিক? এছাড়াও কেন এটি কল্পিত হিসাবে বর্ণনা করা হয়?

— জোনা

@ জোনাহ আমি "সামগ্রিক ধারণা" ব্যবহার করেছি যেহেতু লেনদেনের দিকনির্দেশগুলি বিবেচনা করা উচিত নয় (কেবল তাদের নিখুঁত আকার), যদিও আমি এখন বুঝতে পারি যে এটি কিছুটা অপ্রয়োজনীয় (একে অপরের প্রতিবাদ করার মতো দুটি লেনদেন থাকার পরেও টাই-ব্রেকিং হিসাবে বিবেচিত হবে না) !)। [কল্পনা শুধুমাত্র অর্থায়নে ব্যবহৃত শব্দটি]]

— জোনাথন অ্যালান

Answer 1

জাভাস্ক্রিপ্ট (ES6),  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