Вступ

У вас є друг, який продовжує просити у вас позики, і вам це набридає. Сьогодні він знову прийшов на позику. Замість того, щоб відхиляти його пропозицію, ви отримуєте прекрасну ідею: троліть свого друга, даючи йому якомога більше монет / купюр.

Виклик

Ви будете брати до уваги: ​​суму грошей, яку ваш друг хоче отримати, і кількість монет / рахунків у вас є. Для цього виклику можливі номінали - 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,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]

Це досить повільно і витрачає пам’ять, тому спробуйте лише невеликі випадки

Котлін , 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 працюють добре.