Giriş

Sizden kredi talep eden bir arkadaşınız var ve bundan sıkılıyorsunuz. Bugün yine kredi almaya geldi. Teklifini geri çevirmek yerine harika bir fikir elde edersiniz: ona mümkün olduğunca çok para / fatura vererek arkadaşınızı troll edin.

Meydan okuma

Girdi olarak alacaksınız: arkadaşınızın borç istediği para miktarı ve sahip olduğunuz para / fatura miktarı. Bu meydan okuma için olası mezhepler 20,00 $, 10,00 $, 5,00 $, 2,00 $, 1,00 $, 0,25 $, 0,10 $, 0,05 $ ve 0,01 $ 'dır. Girdi örneği, 5.67, [5, 3, 4, 5, 5, 9, 8, 1, 2]arkadaşınız 5.67 $ istiyorsa ve 5 $ 20 fatura, 3 $ 10 fatura vb. Varsa. Çıktınız, arkadaşınıza mümkün olduğunca fazla metal / kağıt / plastik veren madeni para / fatura miktarı olacaktır.

Arkadaşınıza istediği parayı tam olarak vermek mümkün değilse, ona ödeyebileceğiniz en yakın parayı istediği miktardan daha fazla verin. Örneğin, arkadaşınız 0,07 $ istiyorsa [0, 0, 0, 0, 0, 2, 4, 2, 0], ancak sadece 2 $ 0,05 jeton verin (1 $ 0,10 değil, çünkü bu ona mümkün olduğunca fazla jeton vermeyecektir!).

Arkadaşınız sizden daha fazla para istiyorsa, ona tüm paranızı verin (ve dua etmek için bir şey almanıza gerek kalmayacak).

Test senaryoları

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]

Bu kod golf çok kısa kod kazanır.

Temiz , 167 bayt

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

Fonksiyon tanımlar @, alma Realve [Int].

Çevrimiçi deneyin!

JavaScript, 213 Bayt

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]

Oldukça yavaş ve düşük maliyetli bir bellek, bu yüzden sadece küçük vakaları deneyin

Kotlin , 298 bayt

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

Beautified

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

Ölçek

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

Örnek 4, OutOfMemory'ye neden olur, ancak diğer 3'ü iyi çalışır.