ऋण "उदार" धन की राशि

परिचय

आपके पास एक दोस्त है जो आपसे ऋण मांगता रहता है और आप इससे थक जाते हैं। आज, वह फिर से ऋण के लिए आया था। उसके प्रस्ताव को ठुकराने के बजाय, आप एक महान विचार प्राप्त करते हैं: अपने दोस्त को उसे अधिक से अधिक सिक्के / बिल देकर ट्रोल करें।

चुनौती

आप इनपुट के रूप में लेंगे: आपके मित्र को जितना पैसा चाहिए उतना पैसा और आपके पास मौजूद सिक्कों / बिलों की राशि। इस चुनौती के लिए, संभव मूल्यवर्ग $ 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]

यह कोड-गोल्फ है इसलिए सबसे छोटा कोड जीतता है।

code-golf math

— ericw31415
स्रोत

आपके पास है 2.00और 20.00लेकिन नहीं 0.2या 0.02:(

— श्री एक्सकोडर

@ Mr.Xcoder कई चुनौतियां बहुत ही मनमाने ढंग से चुनी गई मुद्रा प्रणालियों का उपयोग करता है। हम यह तय करने के लिए एक मेटा बनाना चाहते हैं कि क्या करेंसी संबंधी चुनौतियाँ अपनी प्रणाली का निर्धारण करें, एक ही सार्वभौमिक प्रणाली पर सहमत हों, कई प्रणालियों के उपयोग की अनुमति दें या यहाँ तक कि यह सब चुनौतियाँ भी इनपुट के रूप में सिस्टम का समर्थन करें, हालाँकि कुछ भाषाओं के लिए इनपुट सत्यापन लक्षण में परिणाम

— ऊरीएल

@ Mr.Xcoder शायद आप दो-डॉलर के बिल के बारे में सोच रहे हैं ? मैं टोनीज़ सोच रहा था।

— ericw31415

क्या हमारे उत्तरों को सभी इनपुटों के लिए चलाने की आवश्यकता है, बस पोस्ट किए गए लोगों के लिए, या वे छोटे इनपुट्स के लिए काम कर सकते हैं, लेकिन 4 वें के लिए असफल हो सकते हैं?

— jrtapsell

@jrtapsell Input 4 में समस्याएँ नहीं होनी चाहिए? 99 आम तौर पर एक छोटी पर्याप्त संख्या है।

— ericw31415

जवाबों:

स्वच्छ , 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]।

इसे ऑनलाइन आज़माएं!

— Οurous
स्रोत

जावास्क्रिप्ट, 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]

यह बहुत धीमा है और मेमोरी कम है, इसलिए केवल छोटे मामलों का प्रयास करें

— l4m2
स्रोत

कोटलिन , 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 आउटऑफमेरी का कारण बनता है, लेकिन अन्य 3 अच्छी तरह से काम करते हैं।

— jrtapsell
स्रोत