introduzione

Hai un amico che continua a chiederti prestiti e te ne stai stancando. Oggi è venuto di nuovo in prestito. Invece di rifiutare la sua offerta, hai una grande idea: troll il tuo amico dandogli il maggior numero possibile di monete / banconote.

Sfida

Prenderai come input: la quantità di denaro per cui il tuo amico desidera un prestito e la quantità di monete / banconote che hai. Per questa sfida, le possibili denominazioni sono $ 20,00, $ 10,00, $ 5,00, $ 2,00, $ 1,00, $ 0,25, $ 0,10, $ 0,05 e $ 0,01. Un esempio di input è 5.67, [5, 3, 4, 5, 5, 9, 8, 1, 2]se il tuo amico vuole $ 5,67 e hai 5 $ 20 banconote, 3 $ 10 banconote, ecc. Il tuo output sarà la quantità di monete / banconote che darà al tuo amico più metallo / carta / plastica possibile.

Se non è possibile dare al tuo amico l'esatta quantità di denaro che desidera, dagli la quantità di denaro che puoi pagare più grande di quella che vuole. Ad esempio, se il tuo amico vuole $ 0,07 ma hai solo [0, 0, 0, 0, 0, 2, 4, 2, 0], dagli 2 monete da $ 0,05 (non 1 $ 0,10 perché non gli darebbe il maggior numero possibile di monete!).

Se il tuo amico vuole più soldi di quelli che hai, dagli tutti i tuoi soldi (e prega che non dovrai comprare nulla).

Casi test

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]

Questo è code-golf, quindi vince il codice più corto.

Pulito , 167 byte

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

Definisce la funzione @, prendendo Reale [Int].

Provalo online!

JavaScript, 213 byte

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]

È una memoria piuttosto lenta e costosa, quindi prova solo piccoli casi

Kotlin , 298 byte

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

Abbellire

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

Test

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")
        }
    }
}

L'esempio 4 causa OutOfMemory, ma gli altri 3 funzionano bene.