मैं बैंक में पैसे के लिए टेलर से कैसे पूछ सकता हूं?

35

मुझे बैंक जाने और कुछ पैसे निकालने की जरूरत है। मुझे इंटरनेट के लिए अपने रूममेट और कपड़े धोने के लिए $ 8 का भुगतान करने के लिए $ 30, $ 22 वापस लेने की आवश्यकता है। चूंकि इनमें से कोई भी परिवर्तन नहीं कर सकता है, मुझे अपने $ 30 की आवश्यकता है ताकि दो आकारों के दो भागों में विभाजित किया जा सके। इसका मतलब है कि जब टेलर मुझसे पूछता है कि मैं अपना $ 30 कैसे चाहता हूं तो मुझे एक अनुरोध करना होगा। मैं उन्हें बता सकता था कि मैं इसे एक बीस, एक दाढ़ और पांच लोगों में चाहता हूं। लेकिन मैं अपने अनुरोध को यथासंभव सरल बनाना चाहता हूं ताकि खुद को दोहराने से बचा जा सके। मेरे अनुरोध को सरल बनाने के लिए मैं पूछ सकता हूं कि मेरी नकदी में एक बीस और कम से कम 2 वाले हैं क्योंकि 8 कुल द्वारा निहित हैं, लेकिन बेहतर अभी तक मैं बस अनुरोध कर सकता हूं कि मुझे प्राप्त होने वाले बिलों में से एक एक डॉलर का बिल हो (यदि आप इसके बारे में आश्वस्त नहीं हैं बस 8 बनाने के बिना 29 डॉलर बनाने की कोशिश करें)।

तो यह सब ठीक है और बांका है, लेकिन मुझे यह गणना हर बार बैंक में करने की आवश्यकता है इसलिए मैंने सोचा कि मैं ऐसा करने के लिए एक कार्यक्रम लिखूंगा (क्या आप मेरे लिए ऐसा करने के लिए एक कार्यक्रम लिखते हैं)।

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

अतिरिक्त नियम

  • आप मान सकते हैं कि मूल्यवर्ग सूची में हमेशा एक 1या आप इसे प्रत्येक सूची में जोड़ सकते हैं।

  • कुछ इनपुट में कई न्यूनतम समाधान होंगे। इन मामलों में आप किसी एक का उत्पादन कर सकते हैं।

यह कोड-गोल्फ है इसलिए उत्तर बाइट में कम बाइट के साथ बेहतर स्कोर किए जाएंगे।

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

Payments, denominations    -> requests
{22,8}    {1,2,5,10,20,50} -> {1} or {2}
{2,1,2}   {1,5}            -> {1}
{20,10}   {1,2,5,10,20,50} -> {}
{1,1,1,1} {1,2}            -> {1,1,1}
{20,6}    {1,4,5}          -> {1}
{2,6}     {1,2,7}          -> {2}
{22, 11}  {1, 3, 30, 50}   -> {1, 3}
{44, 22}  {1, 3, 30, 50}   -> {1, 3, 3, 30}
code-golf  math 
— गेहूं का जादूगर
स्रोत
22
पहले मुझे लगा कि यह स्पैम या ऑफ-टॉपिक या कुछ और है ...
— एरिक आउट द आउटफेलर
1
@EriktheOutgolfer पैराग्राफों ने चुनौतियों को बहुत चोट पहुंचाई> _ <
— मैजिक ऑक्टोपस Urn
2
मुझे लगता है कि आपको कम से कम एक परीक्षण मामले को शामिल करना चाहिए जहां अनुरोध एक-डॉलर के बिलों के अलावा कुछ और होना चाहिए {2,6} {1,2,7} -> {2}।
— अरनुलद
@Arnauld मैंने आपका केस जोड़ा है
— गेहूं जादूगर
1
(If you are not convinced of this just try to make 29 dollars without making 9)आप 8 बनाने के बिना मतलब है? या मुझे गलत समझ में आया
— भूमिगत

जवाबों:

5

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

ठीक है ... यह एक राक्षस है। :-(
लेकिन यह एक बहुत तेज़ राक्षस है जो सभी परीक्षण मामलों को लगभग तुरंत हल करता है।

मैं बाद में कुछ और उन्नत गोल्फिंग का प्रयास कर सकता हूं, लेकिन मैं पहले ही इस पर बहुत अधिक समय बिता चुका हूं।

f=(b,a,L=[...a])=>L.reduce((a,x)=>[...a,...a.map(y=>[x,...y])],[[]]).sort((a,b)=>a[b.length]||-1).find(L=>(Y=G(U(b)-U(L),L.sort((a,b)=>a-b)),Y[0]&&!Y.some(a=>P(b.map(a=>G(a,[]))).every(b=>b+''!=a))),U=a=>~~eval(a.join`+`),P=(e,C=[],R=[])=>e[0].map(v=>R=(c=v.map((x,i)=>x+(C[i]|0)),e[1])?[...P(e.slice(1),c),...R]:[c,...R])&&R,G=(n,l)=>(S=[],g=(n,l)=>n?a.map(x=>x<l[0]|x>n||g(n-x,[x,...l])):S=[l.map(v=>s[a.indexOf(v)]++,s=[...a].fill(0))&&s,...S])(n,l)&&S)||f(b,a,[...a,...L])

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

कोड स्निपेट दिखाएं

कैसे?

NB: यह वर्तमान संस्करण से मेल नहीं खा रहा है, लेकिन इस तरह से पढ़ना बहुत आसान है।

// b = list of payments, a = list of bills,
// L = list from which the requested bills are chosen
f = (b, a, L = [...a]) => (
  // U = helper function that computes the sum of an array
  U = a => ~~eval(a.join`+`),

  // P = function that computes the summed Cartesian products of arrays of integers
  // e.g. P([[[1,2],[3,4]], [[10,20],[30,40]]]) --> [[33,44], [13,24], [31,42], [11,22]]
  P = (e, C = [], R = []) => e[0].map(v => R =
    (c = v.map((x, i) => x + (C[i] | 0)), e[1]) ? [...P(e.slice(1), c), ...R] : [c, ...R]
  ) && R,

  // G = function that takes a target amount and a list of requested bills and returns
  // all combinations that contain the requested bills and add up to this amount;
  // each combination is translated into a list of number of bills such as [2,0,0,1,0]
  G = (n, l) => (
    S = [],
    g = (n, l) => n ?
      a.map(x => x < l[0] | x > n || g(n - x, [x, ...l])) :
      S = [l.map(v => s[a.indexOf(v)]++, s = [...a].fill(0)) && s, ...S]
  )(n, l) && S,

  // compute X = list of possible bill combinations to process all payments
  X = P(b.map(a => G(a, []))),

  // compute the powerset of L and sort it from shortest to longest list
  L.reduce((a, x) => [...a, ...a.map(y => [x, ...y])], [[]])
  .sort((a, b) => a[b.length] || -1)

  .find(L => (
    // compute Y = list of possible combinations to reach the total amount,
    // using the requested bills
    Y = G(U(b) - U(L), L.sort((a, b) => a - b)),

    // exit if Y is not empty and all combinations in Y allow to generate all payments
    Y[0] && !Y.some(a => X.every(b => b + '' != a)))
  )

  // if no solution was found, enlarge the set of requested bills and try again
  || f(b, a, [...a, ...L])
)
— Arnauld
स्रोत
मैं जावास्क्रिप्ट के साथ भी परिचित नहीं हूँ, लेकिन आप कम कर सकते हैं &&करने के लिए &और ||करने के लिए |?
— टेलर स्कॉट
@TaylorScott यह केवल कुछ शर्तों के तहत ही संभव है। उदाहरण के लिए, केवल अगर झूठा है, तो a || bमूल्यांकन करेंगे , जबकि बिना शर्त थोड़ा सा या बीच और । baa | bab
— अरनुलद
4

पायथन 2 , 456 455 बाइट्स

बेहद, बेहद, बेहद धीमी !!!! पर्याप्त समय दिए गए सभी इनपुट उदाहरणों पर सही ढंग से काम करना चाहिए

संपादित करें: @Jonathan Frech के लिए 1 बाइट धन्यवाद सहेजा गया

def F(p,d):v=sum(p);E=enumerate;l=lambda x,y:y[1:]and(x>=y[-1]and[k+[y[-1]]for k in l(x-y[-1],y)]+l(x,y[:-1])or l(x,y[:-1]))or[[1]*x];Q=l(v,d);m=lambda x,y=[0]*len(p):x and max(m(x[1:],[a+x[0]*(i==j)for i,a in E(y)])for j,_ in E(y))or y==p;f=lambda x,h=[]:x and min([S for i,s in E(x)for S in h+[s],f(x[:i]+x[i+1:],h+[s])if all(map(m,filter(lambda k:all(k.count(j)>=S.count(j)for j in S),Q)))],key=len)or[1]*v;print-(all(map(m,Q))-1)*min(map(f,Q),key=len)

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

व्याख्या

p,d=input() # Read input
v=sum(p) # Save a byte by keeping track of the total money withdrawn
E=enumerate # We use enumerate a lot
# Generates the possible combinations of denominators that add up to the withdrawn amount 
l=lambda x,y:y[1:]and(x>=y[-1]and[k+[y[-1]]for k in l(x-y[-1],y)]+l(x,y[:-1])or l(x,y[:-1]))or[[1]*x]
# We use the list generated by l quite a few times
Q=l(v,d)
# Checks if we can divide a list of denominators x in such a way that we get the wished division of the money
m=lambda x,y=[0]*len(p):x and max(m(x[1:],[a+x[0]*(i==j)for i,a in E(y)])for j,_ in E(y))or y==p
# For a list of denominators, it tries all possible combinations of the denominators as input to the teller, selecting the one with minimum length
f=lambda x,h=[]:x and min([S for i,s in E(x)for S in h+[s],f(x[:i]+x[i+1:],h+[s])if all(map(m,filter(lambda k:all(k.count(j)>=S.count(j)for j in S),Q)))],key=len)or[1]*v
# Call f with all possible lists of denominators, and check if saying nothing to the teller will work
print-(all(map(m,Q))-1)*min(map(f,Q),key=len)
— हलवार्ड वुल्म
स्रोत
1
एक समारोह का उपयोग करने के बजाय input()है एक बाइट कम ।
— जोनाथन फ्रैच
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.