ฉันต้องไปที่ธนาคารและถอนเงิน ฉันต้องถอนเงิน $ 30, $ 22 เพื่อจ่ายค่าเพื่อนร่วมห้องสำหรับอินเทอร์เน็ตและ $ 8 สำหรับค่าซักรีด เนื่องจากสิ่งเหล่านี้ไม่สามารถเปลี่ยนแปลงได้ฉันจึงต้อง $ 30 ของฉันแบ่งออกเป็นสองพาร์ติชันของสองขนาด นั่นหมายความว่าเมื่อผู้เบิกจ่ายถามฉันว่าฉันต้องการเงิน 30 เหรียญฉันจะต้องทำคำขอ ฉันสามารถบอกพวกเขาว่าฉันต้องการมันในยี่สิบ, fiver และห้าคน แต่ฉันต้องการที่จะทำให้คำขอของฉันง่ายที่สุดเท่าที่จะทำได้เพื่อหลีกเลี่ยงการทำซ้ำตัวเอง เพื่อให้การร้องขอของฉันง่ายขึ้นฉันสามารถขอให้เงินสดของฉันมียี่สิบคนและอย่างน้อย 2 คนเพราะ 8 มีนัยโดยนัย แต่ก็ดีกว่า แต่ฉันก็สามารถขอให้หนึ่งในตั๋วเงินที่ฉันได้รับเป็นเงินดอลลาร์หนึ่งใบ (ถ้าคุณ ไม่เชื่อเรื่องนี้แค่ลองทำเงิน 29 ดอลลาร์โดยไม่ทำ 8)

นั่นคือทั้งหมดที่ดีและสวยงาม แต่ฉันต้องทำการคำนวณนี้ทุกครั้งที่ฉันไปที่ธนาคารดังนั้นฉันคิดว่าฉันจะเขียนโปรแกรมเพื่อทำสิ่งนี้ (ให้คุณเขียนโปรแกรมเพื่อทำสิ่งนี้ให้ฉัน)

โปรแกรมหรือฟังก์ชั่นของคุณควรบันทึกรายการจำนวนเต็มซึ่งเป็นตัวแทนของการชำระเงินทั้งหมดที่ฉันต้องทำและชุดจำนวนเต็มที่แสดงถึงการเรียกเก็บเงินที่มีอยู่ในธนาคารและคุณจะต้องส่งออกรายการที่เล็กที่สุด ที่มีรายการของสกุลเงินที่สามารถแบ่งออกเป็นรายการชำระเงินได้อย่างหมดจด

กฎพิเศษ

• คุณอาจสันนิษฐานว่ารายการค่าเงินจะมี1หรือคุณอาจเพิ่มเข้าไปในแต่ละรายการด้วยตนเอง

• อินพุตบางตัวจะมีวิธีแก้ปัญหาขั้นต่ำหลายอย่าง ในกรณีเหล่านี้คุณสามารถส่งออกอย่างใดอย่างหนึ่ง

นี่คือcode-golfดังนั้นคำตอบจะได้คะแนนเป็นไบต์โดยไบต์น้อยจะดีขึ้น

กรณีทดสอบ

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}

JavaScript (ES6), 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])

กรณีทดสอบ

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])

console.log(JSON.stringify(f([22,8], [1,2,5,10,20,50])))
console.log(JSON.stringify(f([2,1,2], [1,5])))
console.log(JSON.stringify(f([20,10], [1,2,5,10,20,50])))
console.log(JSON.stringify(f([1,1,1,1], [1,2])))
console.log(JSON.stringify(f([20,6], [1,4,5])))
console.log(JSON.stringify(f([2,6], [1,2,7])))
console.log(JSON.stringify(f([22,11], [1,3,30,50])))
console.log(JSON.stringify(f([44,22], [1,3,30,50])))

อย่างไร?

หมายเหตุ: นี่ไม่ตรงกับเวอร์ชันปัจจุบันอีกต่อไป แต่อ่านได้ง่ายกว่ามาก

// 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])
)

Python 2 , 456 455 ไบต์

สุดยอดมากช้ามาก !!!! ควรทำงานอย่างถูกต้องกับตัวอย่างอินพุตทั้งหมดที่ให้เวลาเพียงพอ

แก้ไข:บันทึกแล้ว 1 ไบต์ขอบคุณ@Jonathan Frech

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)