मुझे अपना बटुआ भरने में मदद करें!

9

कुछ समय पहले मैंने एक नया बटुआ खरीदा था जो 8 कार्ड (दोनों तरफ 4) रखने में सक्षम है। हालाँकि, मुझे लगता है कि इससे ज्यादा कार्ड हैं और मुझे उन विकल्पों को चुनने की जरूरत है, जिन पर मैं अपने साथ ले जाना चाहता हूं। कुछ कार्ड मैं दूसरों की तुलना में अधिक बार उपयोग करता हूं, लेकिन जिन कार्डों को मैं अपने साथ ले जाना पसंद करता हूं, जरूरी नहीं कि वे जो मैं सबसे ज्यादा उपयोग करता हूं।

चुनौती

कार्डों के ढेर को देखते हुए, मेरे बटुए के लेआउट को मेरी प्राथमिकताओं और प्रतिबंधों को सर्वोत्तम तरीके से वापस करें। लेआउट निम्नानुसार होना चाहिए:

__ __ (row 1)
__ __ (row 2)
__ __ (row 3)
__ __ (row 4)

वर्तमान में मैं निम्नलिखित कार्ड देता हूं - ढेर हमेशा इनमें से एक चयन से मिलकर बनता है:

  • 1 पहचान पत्र ( आईडी )
  • 1 चालक का लाइसेंस ( DL )
  • 2 क्रेडिट कार्ड ( CC) )
  • 5 डेबिट कार्ड ( डीसी )
  • 1 सार्वजनिक परिवहन कार्ड ( पीसी )
  • 1 जिम एक्सेस कार्ड ( GC )
  • यादृच्छिक दुकानों और गोदामों ( एमसी ) से 9 सदस्यता कार्ड

मेरी कुछ प्राथमिकताएँ और प्रतिबंध हैं:

  • प्राथमिकता के आधार पर छांटे गए कार्ड: आईडी, डीएल, सीसी, डीसी, पीसी, जीसी, एमसी
  • उपयोग आवृत्ति द्वारा सॉर्ट किए गए कार्ड: CC, DC, PC, GC, MC, ID, DL
  • सुरक्षा कारणों से, मेरे बटुए में डेबिट कार्ड और क्रेडिट कार्ड की कुल संख्या अन्य सभी कार्ड की राशि है कि (मेरे बटुए में जाना होगा की तुलना में अधिक से अधिक 1 अधिक हो सकता है एन डीसी + एन सी सी ≤ एन आईडी + एन डीएल + एन पीसी + एन जीसी + एन एमसी +1)।
  • यदि मौजूद है, तो मेरा पहचान पत्र और चालक का लाइसेंस हमेशा पंक्ति 1 में जाना चाहिए। इसका मतलब यह नहीं है कि अन्य कार्ड पंक्ति 1 में स्पॉट पर कब्जा नहीं कर सकते हैं।
  • स्टैक से सबसे अधिक उपयोग किए जाने वाले कार्ड हमेशा पंक्ति 4 में जाने चाहिए।

नियम

  • कोई भी 2 कार्ड एक ही स्थान पर कब्जा नहीं कर सकते हैं।
  • उच्च प्राथमिकता वाले कार्ड हमेशा कम प्राथमिकता वाले लोगों पर पसंद किए जाते हैं, जब तक कि डीसी / सीसी प्रतिबंध में किक न हो।
  • पंक्ति 1 पर आईडी / डीएल आवृत्ति नियम को ओवररूल करता है: यदि केवल आईडी प्रदान की जाती है, तो यह पंक्ति 1 में जाएगी और पंक्ति 4 खाली हो जाएगी!
  • इनपुट फॉर्मेटिंग को आप किसी भी तरह से कर सकते हैं, जब तक इनपुट स्टैक का क्रम बरकरार रहता है। उदाहरण के लिए ID,CC,PC,MC,MC,MC,DLजैसे 1ID 1CC 1PC 3MC 1DL 0DC 0GCया आपूर्ति की जा सकती है ID CC PC MC MC MC DL।

  • आउटपुट स्वरूपण में कुछ प्रतिबंध हैं: पंक्तियों को सभी को एक नई पंक्ति में शुरू करना चाहिए, कॉलम को किसी तरह से सीमांकित किया जाना चाहिए। खाली स्थानों को किसी भी तरह से पेश किया जा सकता है, जब तक कि यह 4x2 लेआउट को गड़बड़ नहीं करता है।

  • एक से अधिक समाधान / आदेश हो सकते हैं, यह आपके ऊपर है कि आप किसे आउटपुट के रूप में प्रदान करते हैं।

  • आप मान सकते हैं कि एक ही प्रकार के कार्ड हमेशा इनपुट पर समूहीकृत किए जाएंगे।
  • उपरोक्त के अलावा, मानक कोड गोल्फ नियम और कमियां लागू होती हैं।

बक्शीश

यदि आप किसी भी कार्ड को वापस करते हैं जो वॉलेट में नहीं गया था, तो आपको 15% अपने बायटेकाउंट को निकालने की अनुमति है । प्रिंट "यह फिट बैठता है!" शेष कार्ड के मामले में नहीं। यह अतिरिक्त आउटपुट रेटुरेंड लेआउट से स्पष्ट रूप से अलग होना चाहिए।

उदाहरण

इनपुट:

ID, DL, CC, GC, MC

2 संभावित आउटपुट:

ID DL      DL ID
__ __  or  __ MC
MC __      __ __
CC GC      GC CC

optional: It fits!

इनपुट:

ID, CC, DC, PC, GC, MC, MC, MC, MC, MC

2 संभावित आउटपुट:

ID MC      GC ID
MC MC  or  MC PC
PC GC      MC MC
CC DC      DC CC

optional: e.g. (MC, MC)  or  (2MC)

इनपुट:

DC, DC, CC, CC, GC, DL

2 संभावित आउटपुट:

DL __      GC DL
__ __  or  DC __
GC DC      __ __
CC CC      CC CC

optional: e.g. (DC)  or  (1DC)

इनपुट:

CC, DC, DC, DC

2 संभावित आउटपुट:

__ __      __ __
__ __  or  __ __
__ __      __ __
CC __      __ CC

optional: e.g. (DC, DC, DC)  or  (3DC)

इनपुट:

CC, CC, MC, MC, MC, MC, MC, MC, PC, DC, DC, DC, DC, DC, GC

2 संभावित आउटपुट:

MC MC      MC DC
PC GC  or  DC GC
DC DC      PC MC
CC CC      CC CC

optional: e.g. (DC, DC, DC, MC, MC, MC, MC)  or  (3DC, 4MC)

इनपुट:

MC, MC, MC, MC, MC, MC, MC

2 संभावित आउटपुट:

__ MC      MC MC
MC MC  or  MC MC
MC MC      MC __
MC MC      MC MC

optional: It fits!

इनपुट:

ID, CC

2 संभावित आउटपुट:

ID __      __ ID
__ __  or  __ __
__ __      __ __
CC __      CC __

optional: It fits!

ये है कोड गोल्फ, इसलिए सबसे छोटा कोड (बाइट्स में) जीतता है।

code-golf  string  sequence  sorting 
— slvrbld
स्रोत
— स्लेफ़र

जवाबों:

3

जावा 10, 385 384 382 बाइट्स

C->{String[]R=new String[8],F={"CC","DC","PC","GC","MC"};int c=C.size(),i=1,s=0;c=c>8?8:c;for(var q:C)if("DCC".contains(q))s++;for(;s>c- --s;c=(c=C.size())>8?8:c)i=C.remove(F[i])?i:0;for(c=0,i=8;i>0&c<5;c++)for(;i>0&C.remove(F[c]);)R[--i]=F[c];if(C.remove("ID"))R[c=0]="ID";if(C.remove("DL"))R[c<1?1:0]="DL";for(i=0;i<8;)System.out.print((R[i]!=null?R[i]:"__")+(i++%2>0?"\n":" "));}

हालांकि यह बहुत मुश्किल नहीं था, मैं देख सकता हूं कि यह अनुत्तरित क्यों था। विशेष रूप से के बारे में "उस नियम एन डीसी + N सीसी ≤ एन आईडी + N डीएल + N पीसी + N जीसी + N एम सी +1 " लागत काफी समय बाइट्स का एक बहुत ..
और चूंकि के बाद से इस चुनौती है यह 2.5 साल के बारे में किया गया है पोस्ट किया गया है, ओपी को अब तक एक और बटुआ मिल सकता है ..; पी

-1 बाइट @ जकोब को धन्यवाद ।

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

स्पष्टीकरण:

C->{                       // Method with String-List parameter and String return-type
  String[]R=new String[8], //  String-array of size 8
          F={"CC","DC","PC","GC","MC"};
                           //  Frequency-order String-array
  int c=C.size(),          //  Size of the input-List
      i=1,                 //  Index integer, starting at 1
      s=0;                 //  Count-integer, starting at 0
  c=c>8?8:c;               //  If the size is larger than 8, set it to 8
  for(var q:C)             //  Loop over the cards of the input-List
    if("DCC".contains(q))  //   If the card is a DC or CC:
      s++;                 //    Increase the counter by 1
  for(;s>                  //  Loop as long as the amount of DC/CC is larger 
         c- --s;           //  than the other amount of cards + 1
      c=(c=C.size())>8?8:c)//    Recalculate the size after every iteration
    i=C.remove(F[i])?i:0;  //   If the List still contains a DC, remove it
                           //   Else: remove a CC instead
  for(c=0,                 //  Reset `c` to 0
      i=8;i>0              //  Loop as long as there is still room in the wallet,
      &c<5;                //  and we still have cards left
      c++)                 //    Go to the next card-type after every iteration
    for(;i>0               //   Inner loop as long as there is still room in the wallet,
        &C.remove(F[c]);)  //   and we still have a card of the current type left
      R[i--]=F[c];         //    Put a card of the current type in the wallet
  if(C.remove("ID"))R[c=0]="ID";
                           //  Add the 'ID' card to the first row if present
  if(C.remove("DL"))R[c<1?1:0]="DL";
                           //  Add the 'DL' card to the first row if present
  for(i=0;i<8;)            //  Loop over the wallet
    System.out.print(      //   Print:
      (R[i]!=null?         //    If the current slot contains a card:
        R[i]               //     Append this card
       :                   //    Else:
        "__")              //     Append an empty slot ("__")
      +(i++%2>0?"\n":" "));//    Append the correct delimiter (space or new-line)
  return r;}               //  And finally return the result

जावा 10, 390.15 (459 बाइट्स - 15% बोनस)

C->{String r="",R[]=new String[8],F[]={"CC","DC","PC","GC","MC"},t=r;int c=C.size(),i=1,s=0;for(var q:C)if("DCC".contains(q))s++;for(;s>(c>8?8:c)- --s;c=C.size())if(C.remove(F[i]))t+=F[i]+",";else i=0;for(c=0,i=8;i>0&c<5;c++)for(;i>0&&C.remove(F[c]);)R[--i]=F[c];if(C.remove("ID")){t+=R[0]+",";R[c=0]="ID";};if(C.remove("DL")){t+=R[c=c<1?1:0]+",";R[c]="DL";}for(i=0;i<8;)r+=(R[i]!=null?R[i]:"__")+(i++%2>0?"\n":" ");return r+"\n"+(C.size()>0?t+C:"It fits!");}

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

— केविन क्रूज़सेन
स्रोत
1
आप आरंभ करने से एक बाइट बचा सकता है Fके साथ {"CC","DC","PC","GC","MC"}।
— जैकब
@ जाकोब आह, एहसास नहीं था कि कम था। धन्यवाद!
— केविन क्रूज़सेन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.