บทนำ

คุณมีเพื่อนที่คอยขอสินเชื่อและคุณเบื่อมัน วันนี้เขามาเพื่อขอสินเชื่ออีกครั้ง แทนที่จะเปลี่ยนข้อเสนอของเขาคุณจะได้รับความคิดที่ดี: หมุนรอบเพื่อนของคุณโดยให้เหรียญ / ธนบัตรให้มากที่สุด

ท้าทาย

คุณจะใช้เป็นอินพุต: จำนวนเงินที่เพื่อนของคุณต้องการเงินกู้และจำนวนเหรียญ / ตั๋วเงินที่คุณมี สำหรับความท้าทายนี้สกุลเงินที่เป็นไปได้คือ $ 20.00, $ 10.00, $ 5.00, $ 2.00, $ 1.00, $ 0.25, $ 0.10, $ 0.05, และ $ 0.01 ตัวอย่างของการป้อนข้อมูลคือ5.67, [5, 3, 4, 5, 5, 9, 8, 1, 2]ถ้าเพื่อนของคุณต้องการ $ 5.67 และคุณมีตั๋ว 5 $ 20, ตั๋วเงิน 3 $ 10 ฯลฯ ผลผลิตของคุณจะเป็นจำนวนเหรียญ / ตั๋วที่ให้เพื่อนของคุณเป็นโลหะ / กระดาษ / พลาสติกมากที่สุด

หากเป็นไปไม่ได้ที่จะให้เงินตามจำนวนที่เขาต้องการกับเพื่อนของคุณให้เขาให้จำนวนเงินที่ใกล้เคียงที่สุดที่คุณสามารถจ่ายที่มากกว่าที่เขาต้องการ ตัวอย่างเช่นหากเพื่อนของคุณต้องการ $ 0.07 แต่คุณมีเพียง[0, 0, 0, 0, 0, 2, 4, 2, 0]ให้เขา 2 เหรียญ 0.05 เหรียญ (ไม่ใช่ 1 $ 0.10 เพราะนั่นจะไม่ให้เหรียญเขามากเท่าที่จะเป็นไปได้!)

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

กรณีทดสอบ

Input:  6.54, [9, 8, 7, 6, 5, 4, 3, 2, 4]
Output: [0, 0, 0, 1, 4, 1, 2, 1, 4]

Input:  2, [0, 1, 0, 0, 0, 0, 0, 0, 0]
Output: [0, 1, 0, 0, 0, 0, 0, 0, 0]

Input:  9999, [0, 0, 0, 0, 0, 0, 0, 0, 1]
Output: [0, 0, 0, 0, 0, 0, 0, 0, 1]

Input:  0, [99, 99, 99, 99, 99, 99, 99, 99, 99]
Output: [0, 0, 0, 0, 0, 0, 0, 0, 0]

นี่คือรหัส - กอล์ฟเพื่อให้ได้รหัสที่สั้นที่สุด

ทำความสะอาด , 167 ไบต์

import StdEnv
@n l#m=[p\\p<-[[if(y==u)(x-1)x\\x<-l&y<-[0..]]\\u<-[0..]&v<-l|v>0]|sum[a*b\\a<-[2000,1000,500,200,100,25,10,5,1]&b<-p]>=toInt(n*100.0)]
|m>[]= @n(hd m)=l

กำหนดฟังก์ชั่น@, การถ่ายและReal[Int]

ลองออนไลน์!

JavaScript, 213 ไบต์

x=>y=>(F=(x,y,z,u=9)=>u--?[...Array(y[0]+1)].map((_,i)=>F(x-i*[1,5,10,25,100,200,500,1e3,2e3][u],y.slice(1),[...z,i],u))&&G:x>0||G.push([z,x-1/eval(z.join`+1+`)]),F(x*100,y,G=[]).sort((a,b)=>b[1]-a[1])[0]||[y])[0]

มันค่อนข้างช้าและเสียค่าใช้จ่ายดังนั้นลองใช้เคสเล็ก ๆ

Kotlin , 298 ไบต์

{t,c->with(c.fold(listOf(listOf<Int>())){o,x->o.flatMap{a->(0..x).map{a+it}}}.groupBy{it.zip(C).map{(a,b)->a*b}.sum()}.mapValues{(_,b)->b.maxBy{it.sum()}!!}.toSortedMap().asSequence()){firstOrNull{it.key==t}?:firstOrNull{it.key>t}?:last()}.value}
val C=listOf(20.0,10.0,5.0,2.0,1.0,0.25,.1,.05,.01)

เชิดชู

        { t, c ->
            with(c.fold(listOf(listOf<Int>())) { o, x ->
                o.flatMap { a -> (0..x).map { a + it } } /* Get all of the options. */
            }.groupBy { it.zip(C).map { (a, b) -> a * b }.sum() }
                .mapValues { (_,b)->b.maxBy { it.sum() }!! }
                .toSortedMap().asSequence()) {
                firstOrNull { it.key == t } ?:
                        firstOrNull { it.key > t } ?:
                        last()
            }.value
        }
val C = listOf(20.0, 10.0, 5.0, 2.0, 1.0, 0.25, .1, .05, .01)

ทดสอบ

val calc: (target: Double, coins: List<Int>) -> List<Int> =
{t,c->with(c.fold(listOf(listOf<Int>())){o,x->o.flatMap{a->(0..x).map{a+it}}}.groupBy{it.zip(C).map{(a,b)->a*b}.sum()}.mapValues{(_,b)->b.maxBy{it.sum()}!!}.toSortedMap().asSequence()){firstOrNull{it.key==t}?:firstOrNull{it.key>t}?:last()}.value}
val C=listOf(20.0,10.0,5.0,2.0,1.0,0.25,.1,.05,.01)

data class Test(val target: Double, val input: List<Int>, val output: List<Int>)

val tests = listOf(
        Test(2.0, listOf(0, 1, 0, 0, 0, 0, 0, 0, 0), listOf(0, 1, 0, 0, 0, 0, 0, 0, 0)),
        Test(9999.0, listOf(0, 0, 0, 0, 0, 0, 0, 0, 1), listOf(0, 0, 0, 0, 0, 0, 0, 0, 1)),
        Test(6.54, listOf(9, 8, 7, 6, 5, 4, 3, 2, 4), listOf(0, 0, 0, 1, 4, 1, 2, 1, 4)),
        Test(0.0, listOf(99, 99, 99, 99, 99, 99, 99, 99, 99), listOf(0, 0, 0, 0, 0, 0, 0, 0, 0))
)

fun main(args: Array<String>) {
    for (t in tests) {
        if (t.output != calc(t.target, t.input)) {
            throw AssertionError()
        } else {
            println("Passed")
        }
    }
}

ตัวอย่างที่ 4 ทำให้ OutOfMemory แต่อีก 3 ตัวทำงานได้ดี