कहानी

"2016? Al..right," grumbled खिलौना विक्रेता हिल्बर्ट। उसने अपनी आँखें खोलीं, अपने कानों से सलाद ड्रेसिंग छलनी को मिटाया और सुबह की किक-सेरेमनीटेकिट खाया। छुटपन की छुट्टियां। उसे हालांकि अभी काम करने के लिए जाना है, और साल का लेखा-जोखा खत्म करना है।

क्रिसमस वर्ष की एक बहुत ही उपज अवधि है, विशेष रूप से उसकी बिक्री के लिए। हिल्बर्ट वास्तव में जानता है कि यह कैसे काम करता है: एक व्यक्ति एक दुकान में आता है और उनके द्वारा पेश किए गए पहले उपहार को खरीदता है। वे इसके लिए भुगतान करते हैं और दूसरी दुकान में भाग जाते हैं। व्यवहार में, वास्तव में उपहार क्या है वास्तव में कोई फर्क नहीं पड़ता है। कीमत भी अप्रासंगिक है, बशर्ते यह बहुत अधिक न हो। यह सब क्रिसमस तक शेष समय पर निर्भर करता है - कम समय, ग्राहकों का अधिक से अधिक पछतावा, वे जिस कीमत पर भुगतान करने के लिए तैयार हैं, उतना ही अधिक।

हिल्बर्ट के लिए यह सब अपनी घड़ी को देखना है - और वह तुरंत जानता है कि उसके ग्राहक कितना खर्च कर सकते हैं। वह आसानी से इस तथ्य का लाभ उठा सकता है: वह सिर्फ सबसे महंगा उपहार पाता है जिसे वह किसी दिए गए ग्राहक को बेच सकता है, और उन्हें यह पेशकश कर सकता है। केवल अब उसे एहसास हुआ है कि वह पिछले साल इस चालाक रणनीति को लागू करना भूल गया था। हालांकि यह बदलने वाला है!

फिर भी, हिल्बर्ट जानना चाहेंगे कि उनका व्यवसाय कितना फल-फूल रहा होगा, अगर उन्होंने वास्तव में अपनी भव्य योजना का उपयोग किया होता। वह उन लोगों की एक सूची बनाने में कामयाब रहा, जो उसके स्टोर में आए थे, लेकिन उन्हें यकीन नहीं है कि वह उन पर कितना पैसा कमा सकता था।

आपका कार्य (TL; DR)

इनपुट में उपलब्ध उपहारों की कीमतों की आरोही सूची और ग्राहकों के बजट की एक सूची शामिल है। बजट की सूची उसी क्रम में है जैसे ग्राहक दुकान पर पहुंचे थे - इस शर्त के साथ कि प्रत्येक ग्राहक कम से कम उतना ही भुगतान करने के लिए तैयार है, जितना कि यह भी आरोही है।

प्रत्येक ग्राहक के लिए, सबसे महंगा उपहार पाएं जो वे भुगतान करने के लिए तैयार हैं, और इसका मूल्य है। यदि बजट के भीतर कोई उपहार उपलब्ध नहीं है, तो आउटपुट ए 0।

आप एक प्राप्त -40%करता है, तो अपने एल्गोरिथ्म के asymptotic समय जटिलता है, वर्ण बोनस O(n+m)(बल्कि तुच्छ से O(n*m)) _{कहां n, mइनपुट सूचियों के समान नहीं हैं।}

यह कोड-गोल्फ है , सबसे छोटा बाइट्स जीतता है। मानक कमियां निषिद्ध हैं।

उदाहरण

इनपुट:

1 2 2 2 5 7 10 20
1 1 2 3 6 6 15 21 21 22

आउटपुट:

1 0 2 2 5 2 10 20 7 0

_{यह कार्य एक स्थानीय प्रोग्रामिंग प्रतियोगिता से लिया गया था, और मेरे द्वारा अंग्रेजी में अनुवाद किया गया था। यहाँ मूल असाइनमेंट है: https://www.ksp.sk/ulohy/zadania/1131/}

code-golf

— sammko
स्रोत

9

चुनौतियों को लिखते समय बचने के लिए बोनस एक चीज है । हालांकि, मुझे लगता है कि यह यहां ठीक हो सकता है। यदि आप इसे रखना चाहते हैं, तो मैं इसे प्रतिशत आधारित बोनस में बदलने की सलाह देता हूं। एक 20 कैरेक्टर बोनस का मतलब Java सबमिशन से कोई मतलब नहीं है, लेकिन मूल रूप से गोल्फिंग भाषा में समाधान के लिए अनिवार्य है।

— डेनकर

क्या मैं अकेले बैकस्टोरी के लिए ओपी को इनाम दे सकता हूं? ईमानदारी से, इसने मुझे मुस्कुरा दिया; हर चुनौती में से एक की जरूरत है।

— बिल्ली

@tac धन्यवाद, लेकिन जैसा कि नीचे छोटे पाठ में नोट किया गया है, मैं वास्तव में बैकस्टोरी नहीं बना था - मैंने केवल इसका अनुवाद किया है।

— शामको

@sammko हाँ, मैंने वह देखा, लेकिन मेरी उपरोक्त टिप्पणी अभी भी जारी है :)

— कैट

5

पायथ, 17 16 बाइट्स

1 बाइट Pietu1998 के लिए धन्यवाद

VE=.-Q]
e|fgNTQ0

प्रदर्शन

स्पष्टीकरण:

VE=.-Q]<\n>e|fgNTQ0
                        Implicit: Q is the list of prices.
VE                      For N in the list of budgets
             f   Q      Filter the list of prices
              gNT       On the current person's budget being >= that price
            |     0     If there aren't any, use 0 instead.
          e             Take the last (most expensive) value.
      <\n>              Print it out.
  =.-Q                  Remove it from the list of prices.

— isaacg
स्रोत

मुझे लगता है कि आप 1 बाइट को VE=.-Q]\ n से बचा सकते हैं e|fgNTQ0। मूल रूप से एक ही बात है, लेकिन एक लूप के साथ।

— पुरकाकूदरी

4

हास्केल, 67 बाइट्स

a#(b:c)|(h,t)<-span(<=b)a=last(0:h):(init(h++[0|h==[]])++t)#c
_#x=x

प्रयोग उदाहरण: [1,2,2,2,5,7,10,20] # [1,1,2,3,6,6,15,21,21,22]-> [1,0,2,2,5,2,10,20,7,0]।

कीमतों को दो भागों में विभाजित करें: (h,t)जहां hसभी मूल्य हैं <= अगले ग्राहक का बजट और tसभी अन्य हैं। की अंतिम कीमत ले लो hऔर सभी के साथ पुनरावृत्ति जारी रखें, लेकिन hप्लस tऔर शेष बजट के अंतिम । खाली है तो last(0:h)मूल्यांकन करता है। समान: एक डमी तत्व को जोड़ता है करने के लिए अगर , रिक्त है ताकि ड्रॉप करने के लिए कुछ है ( खाली सूची पर विफल रहता है)।0hinit (h++[0|h==[]]) ++ t0hhinitinit

— nimi
स्रोत

3

जावा, 154 * 0.6 = 92.4 बाइट्स

-13 बाइट्स क्योंकि लैम्ब्डा वास्तव में उपयोग कर सकते हैं int[], नहीं Integer[](धन्यवाद बन्जिकोबियानको )

इसे O (n + m) समय और O (n + m) अतिरिक्त स्थान लेना चाहिए _{^{(यह मानते हुए कि मैं बड़ा O अंकन समझता हूं)}} ।

g->b->{int l=g.length,L=b.length,G=0,B=0,A=0;int[]a=new int[l],s=new int[L];for(;B<L;){while(G<l&&g[G]<=b[B])a[A++]=g[G++];s[B++]=A>0?a[--A]:0;}return s;}

प्रस्तुत: ( इसे ऑनलाइन आज़माएं! )

static int[] toyStore(int[]g,int[]b) {
    int gl=g.length,bl=b.length,gp=0,bp=0,ap=0;
    int[] a=new int[gl],s=new int[bl];
    for (;bp<bl;) {
        while(gp<gl&&g[gp]<=b[bp])a[ap++]=g[gp++];
        s[bp++]=ap>0?a[--ap]:0;
    }
    return s;
}

public static void main(String[] args)
{
    System.out.println(Arrays.toString(
        toyStore(new int[] {1,2,2,2,5,7,10,20},
                 new int[] {1,1,2,3,6,6,15,21,21,22})
        ));
}

_{^{मैं यहां गैर-लंबा विस्तार दिखाता हूं क्योंकि प्रकार की घोषणा क्लीनर है और यह सटीक तर्क है। लंबोदर आइडोन लिंक पर मौजूद है।}}

स्पष्टीकरण:

प्रयुक्त चर:

gउपहार की कीमतों bकी सूची है, बजट की सूची है।
glकी लंबाई है gऔर blकी लंबाई है b।
aसस्ती उपहार के लिए एक ढेर है, sबेचा उपहार का उत्पादन सरणी है।
gp, bp, और apके लिए संकेत दिए गए हैं g, b, और aक्रमशः। bpके लिए भी सूचक है s।

कलन विधि:

बजट की लंबाई में प्रत्येक बजट के लिए
- जबकि यह बजट उपहार खरीद सकता है g[gp]
  - स्टैक aऔर इंक्रीमेंट पर बजट पुश करेंgp
- के शीर्ष पॉप aमें s[bp]यदि वह मौजूद है, और डाल 0।

— CAD97
स्रोत

क्या तुम मेमने की सब्जी नहीं खा सकते? (यानी (g,b)->करने के लिए g->b->?

— ASCII-केवल

@ सामान्य तौर पर, हाँ। किसी कारण के लिए यह मेरे लिए पहले कभी काम नहीं किया है, लेकिन अब यह होगा। 0.o (आपने बोनस के बाद 0.6 बाइट्स बचाए।)

— CAD97

यदि इनपुट लंबे माना जाता है आप देशांतर का उपयोग करके कुछ बाइट्स बचा सकता है [] (आप 158bytes पर ले जाता है) - ideone.com/invHlc

— BunjiquoBianco

1

@BunjiquoBianco वास्तव में मैं सिर्फ int [] का उपयोग कर सकता हूं। किसी कारण से मैं इस धारणा के अधीन था कि चूंकि प्रकार के संदर्भ संदर्भ प्रकार लेते हैं (इस प्रकार मूल्य-टाइप किए गए आदिम नहीं int) जो मुझे संदर्भ प्रकारों की एक सरणी का उपयोग करने के लिए आवश्यक था। लेकिन मैं ठीक ठीक int की एक सरणी का उपयोग कर सकते हैं। एक बार मौका मिलने पर अपडेट करूंगा।

— 14:97 पर CAD97

@ CAD97 हा! विश्वास नहीं कर सकता कि मैंने वह लिंक नहीं बनाया ...

— बंजिकियो बियान्को

2

हास्केल, 87 * 0.6 = 52.2 बाइट्स

g s(p:q)d@(b:c)|p<=b=g(p:s)q d
g[]p(b:c)=0:g[]p c
g(s:t)p(b:c)=s:g t p c
g _ _ _=[]
g[]

मेरे अन्य उत्तर से पूरी तरह से अलग है , क्योंकि मैं बोनस के लिए जा रहा हूं।

अंतिम पंक्ति (-> g[]) परिभाषा का हिस्सा नहीं है, लेकिन ओवरहेड कॉलिंग है। प्रयोग उदाहरण: g [] [1,2,2,2,5,7,10,20] [1,1,2,3,6,6,15,21,21,22]-> [1,0,2,2,5,2,10,20,7,0]।

मूल रूप से @ CAD97 के उत्तर के रूप में उसी तरह काम करता है, यानी खरीदने योग्य वस्तुओं पर नज़र रखने के लिए (शुरू में खाली) सहायक स्टैक का उपयोग करता है। विस्तार से: क्रम में जाँच करें:

यदि पहला मूल्य पहले बजट से कम या बराबर है, तो मूल्य को स्टैक पर ले जाएं। दोबारा फोन करें।
यदि स्टैक खाली है, तो एक 0 वापस करें और उसके बाद एक पुनरावर्ती कॉल छोड़ें।
यदि स्टैक और बजट सूची दोनों खाली नहीं हैं, तो स्टैक के शीर्ष पर वापस लौटें और स्टैक और बजट पॉपप के साथ पुनरावर्ती कॉल करें।
अन्यथा खाली सूची लौटाएं।

यह m+nसमय में काम करता है , क्योंकि) सहायक स्टिक पर प्रत्येक में हेल्पर स्टैक पर संचालन निरंतर समय और बी) सूची में से एक सूची को एक तत्व द्वारा छोटा किया जाता है।

— nimi
स्रोत

2

जेली , 15 बाइट्स

ṀṄ;©®œ^
Rf@€ç/Ṁ

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

यह काम किस प्रकार करता है

ṀṄ;©®œ^  Helper link. Arguments: G, H (lists of affordable gifts)

Ṁ        Compute the maximum of G (0 if the list is empty).
 Ṅ       Print it.
  ; ®    Concatenate it with the register (initially 0).
   ©     Save the result in the register.
     œ^  Compute the multiset symmetric difference of the updated register and H.

Rf@€ç/Ṁ  Main link. Arguments: B (budgets), P (prices)

R        Range; replace each t in B with [1, ..., t].
 f@€     Intersect the list of prices with each budget range, obtaining, for each
         customer, the list of all gifts he's willing to pay for.
    ç/   Reduce the array of lists by the helper link.
         In each iteration, this computes and prints the most expensive gift for
         a customer, than removes the selected gift (and all previously
         selected gifts) from the next list.
      Ṁ  Compute the maximum of the resulting list, which corresponds to the last
         customer.

— डेनिस
स्रोत

1

जावास्क्रिप्ट, 85 * 0.6 = 51 बाइट्स

f=(a,b,s=[],[t,...u]=a,[v,...w]=b)=>v?t<=v?f(u,b,[...s,t]):[s.pop()|0,...f(a),w,s)]:[]

@ CAD97 के जवाब का एक और क्लोन।

— नील
स्रोत

खिलौने की दुकान का मुनाफा