Qualche tempo fa ho acquistato un nuovo portafoglio in grado di contenere 8 carte (4 su entrambi i lati). Tuttavia, mi sembra di avere molte più carte di così e devo fare delle scelte su quali voglio portare con me. Alcune carte che uso più spesso di altre, ma le carte che preferisco portare con me non sono necessariamente quelle che utilizzo di più.

La sfida

Data una pila di carte, restituisci il layout del mio portafoglio nel miglior modo possibile con le mie preferenze e restrizioni. Il layout dovrebbe essere il seguente:

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

Attualmente poso le seguenti carte - le pile saranno sempre costituite da una selezione tra queste:

• 1 carta d'identità ( ID )
• 1 patente di guida ( DL )
• 2 carte di credito ( CC )
• 5 carte di debito ( DC )
• 1 carta di trasporto pubblico ( PC )
• 1 tessera di accesso alla palestra ( GC )
• 9 tessere associative da magazzini e magazzini casuali ( MC )

Ho alcune preferenze e restrizioni:

• Carte ordinate per priorità: ID, DL, CC, DC, PC, GC, MC
• Carte ordinate per frequenza d'uso: CC, DC, PC, GC, MC, ID, DL
• Per motivi di sicurezza, il numero totale di carte di debito e carte di credito nel mio portafoglio può essere al massimo 1 in più rispetto alla somma di tutte le altre carte che andranno nel mio portafoglio ( N _DC + N _CC ≤ N _ID + N _DL + N _PC + N _GC + N _MC +1).
• Se presente, la mia carta d'identità e la patente di guida dovrebbero sempre rientrare nella riga 1. Ciò non significa che le altre carte non possano occupare punti nella riga 1.
• Le carte usate più frequentemente dalla pila devono sempre andare nella riga 4.

Regole

• No 2 carte possono occupare lo stesso posto.
• Le carte con priorità più alta sono sempre preferite rispetto a quelle con priorità più bassa, a meno che la restrizione DC / CC entri in gioco.
• ID / DL nella riga 1 sovrascrive la regola della frequenza: se viene fornito solo l'ID, andrà nella riga 1 e la riga 4 sarà vuota!
• La formattazione dell'input può essere eseguita nel modo che preferisci, purché l'ordine dello stack di input venga mantenuto. eg ID,CC,PC,MC,MC,MC,DLpuò anche essere fornito come eg 1ID 1CC 1PC 3MC 1DL 0DC 0GCo ID CC PC MC MC MC DL.

• La formattazione dell'output presenta alcune restrizioni: le righe devono iniziare tutte da una nuova riga, le colonne devono essere delimitate in qualche modo. I punti vuoti possono essere presentati come preferisci, purché non incasinino il layout 4x2.

• Ci può essere più di una soluzione / ordine, dipende da te quale fornire come output.

• Puoi presumere che le carte dello stesso tipo saranno sempre raggruppate all'ingresso.
• Oltre a quanto sopra, si applicano le regole standard e le scappatoie da golf .

indennità

Ti è permesso rimuovere il 15% del tuo conto aggiuntivo se restituisci anche qualsiasi carta che non è stata inserita nel portafoglio. Stampa "Si adatta!" in caso di nessuna carta rimanente. Questo output aggiuntivo deve essere chiaramente separato dal layout di ritorno.

Esempi

Ingresso:

ID, DL, CC, GC, MC

2 possibili uscite:

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

optional: It fits!

Ingresso:

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

2 possibili uscite:

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

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

Ingresso:

DC, DC, CC, CC, GC, DL

2 possibili uscite:

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

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

Ingresso:

CC, DC, DC, DC

2 possibili uscite:

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

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

Ingresso:

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

2 possibili uscite:

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)

Ingresso:

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

2 possibili uscite:

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

optional: It fits!

Ingresso:

ID, CC

2 possibili uscite:

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

optional: It fits!

Questo è code-golf , quindi vince il codice più breve (in byte).

Java 10, 385 384 382 byte

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

Anche se non è stato troppo difficile, posso vedere perché è stato senza risposta. Soprattutto quella regola riguardante " N _DC + N _CC ≤ N _ID + N _DL + N _PC + N _GC + N _MC +1 " al momento costa un sacco di byte ..
E dato che sono passati circa 2,5 anni da quando questa sfida ha stato pubblicato, OP avrebbe potuto avere un altro portafoglio ormai ormai ..; p

-1 byte grazie a @Jakob .

Provalo online.

Spiegazione:

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

Java 10, 390.15 (459 byte - bonus del 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!");}

Provalo online.