introduzione

Sei amico di un curatore di un museo d'arte, che ha avuto la recente delizia di ottenere arte moderna da quattro artisti ( alcuni dei quali potrebbero dare al curatore zero opere d'arte, giovani mascalzoni ). Poiché si tratta di arte moderna, tutti i pezzi di un determinato artista sembrano esattamente uguali. Il tuo amico vuole usare un computer per decidere in quale ordine posizionare questi pezzi.

Requisiti del programma

Il tuo programma deve prendere cinque numeri interi (passati a una funzione o immessi tramite stdin (o in qualche altro modo)). I primi quattro sono il numero di dipinti forniti da ciascuno dei quattro artisti. L'ultimo valore è un indice di permutazione i(contando da 1, non da 0). Il curatore desidera vedere la ipermutazione per ordine lessicografico dei dipinti.

L'output del programma must questa permutazione in qualsiasi formato ragionevole: per esempio abbccdo [0 1 1 2 2 3]. Il tempo di esecuzione dell'input per un totale di meno di dieci dipinti deve richiedere meno di un'ora (si spera che questo non sia un problema).

Non è consentito utilizzare alcuna funzione integrata per elaborare le permutazioni

Esempi

Ingresso: 0 1 2 0 2

Dato che abbiamo un dipinto dell'artista B e due dell'artista C (e sembrano tutti uguali), le permutazioni in ordine lessicografico sono:

['bcc', ' cbc ', 'ccb']

La permutazione evidenziata sarebbe l'output corretto, perché è il secondo in ordine lessicografico.

Ingresso: 1 2 0 1 5

['abbd', 'abdb', 'adbb', 'babd', ' badb ', 'bbad', 'bbda', 'bdab', 'bdba', 'dabb', 'dbab', 'dbba']

analisi

Ecco alcuni test che dovrebbero essere corretti.

1 2 4 1 5    - ABBDCCCC
2 2 3 1 86   - ABBCACDC
4 1 2 0 24   - AACACBA
1 4 3 2 65   - ABBCBBDCDC

Un breve pezzo di codice in Python3 che dovrebbe generare casualmente input e output è disponibile qui (non valido per l'inserimento, utilizza l'importazione di permutazioni Python):

from itertools import permutations
from random import randint
a,b,c,d,n = randint(1,2),randint(1,2),randint(1,3),randint(1,3),randint(1,15)
print(str(a) + " " + str(b) + " " + str(c) + " " + str(d) + " " + str(n) + " - " + str(sorted(set([''.join(p) for p in permutations(a * "a" + b * "b" + c * "c" + d * "d")]))[n-1]))

tabellone segnapunti

Optimizer - CJam       - 39  - Confirmed - Bruteforce
EDC65     - JavaScript - 120 - Confirmed - Bruteforce
Jakube    - Python2    - 175 - Confirmed - Algorithmic

Python 2: 175 163 caratteri

Questa non è una risposta seria al golf. Con un algoritmo diverso ho raggiunto 138 byte. Volevo solo pubblicare questo qui, perché non usa la forza bruta. La complessità è Theta (#pictures).

f=lambda x:0**x or x*f(x-1)
def g(Q,n):
 while sum(Q):
  for j in 0,1,2,3:
   p=f(sum(Q)-1)*Q[j]
   for k in Q:p/=f(k)
   if p<n:n-=p
   else:print j;Q[j]-=1;break

Uso:

g([1, 4, 3, 2], 65)

modificare:

Stesso algoritmo, solo un po 'di golf: non importare il metodo fattoriale e piccoli cambiamenti nell'ordine dei calcoli.

Traduzione Pyth: 61 caratteri

Lu*GhHUb1WsPQV4J*@QNytsPQFZPQ=J/JyZ)I<JeQ XQ4-eQJ)EN XQNt@QNB

Niente di speciale qui, traduzione esatta del mio codice Python. Troppo a lungo però. Ho usato troppo alcune cose brutte (lunghe). Solo la prima lettera 9 è la definizione del fattoriale.

Lu*GhHUb1    def y(b): G=1; for H in range(b): G*= H+1; return G

Anche cose del genere Q[j]-=1sono troppo lunghe: XQNt@QN(1 personaggio in più di Python !!!)

Uso:

Provalo qui: Pyth Compiler / Executor . Disabilita la modalità debug e usa [2, 2, 3, 1, 86]come input.

CJam, 50 43 39 byte

q~(])\{W):Wa*}%s:X{Xm*:s_&}X,(*{$X=},$=

Questo può essere giocato molto a golf.

Riceve input da STDIN nel seguente formato:

4 1 2 0 24

Stampa il dipinto. Ad esempio per l'input sopra:

0020210

Provalo online qui

Si noti che il compilatore online rinuncia a dimensioni di pittura più grandi. Dovrai provare input più grandi sulla versione Java

JavaScript (ES6) 120 138 147

Come funzione con i cinque parametri richiesti, output tramite console.
Usando i simboli 0,1,2,3. Calcolo il totale dei simboli, quindi costruisco e controllo ogni numero di base 4 con il numero richiesto di cifre. I numeri con il numero errato di qualsiasi cifra vengono eliminati.
Nota: con JavaScript a 32 bit intero funziona fino a 15 dipinti.

Modifica più breve (evita .toString) e molto più veloce (condizione di uscita modificata). Tempo per ogni test inferiore a 1 sec.

Modifica2 nessuna modifica dell'algoritmo, maggiore golf (rientro aggiunto per leggibilità)

F=(w,x,y,z,n)=>{
  for(a=0;n;n-=l=='0,0,0,0')
    for(l=[w,x,y,z],t=w+x+y+z,v='',b=a++;t--;b/=4)--l[d=b&3],v=d+v;
  console.log(v)
}

Ungolfed E non è richiesto FireFox

F=function(w,x,y,z,n) {
  for(a=0; n; a++) // exit when solution found (if wrong parameters, run forever)
  {
    l=[w,x,y,z]; // required number of each symbol
    t=w+x+y+z; // total of digits
    v=''; // init output string
    for(b=a;
      t--; // digit count down
      b >>= 2) // shift for next digit
    {
        d = b & 3; //get digit
        --l[d]; // decrement for the current digit
        v = d + v; // add to output string         
    }
    l[0]|l[1]|l[2]|l[3] // if digits ok
    ||--n // decrement counter
  }
  console.log(v) // when found, exit for and print the answer
}

Test nella console FireBug / FireFox

F(1, 2, 4, 1, 5) 
F(2, 2, 3, 1, 86)
F(4, 1, 2, 0, 24)
F(1, 4, 3, 2, 65)

Produzione

01132222
01120232
0020210
0112113232

Pyth , 20

@fqPQm/TdU4^U4sPQteQ

Provalo qui.

L'input è in forma di elenco Python, ad es [1, 2, 4, 1, 5]

L'output è anche in forma di elenco Python, ad esempio [0, 1, 1, 3, 2, 2, 2, 2]per l'input sopra.

La soluzione è la forza bruta e richiede circa 10 secondi, nel peggiore dei casi, sulla mia macchina.

Come funziona:

@fqPQm/TdU4^U4sPQteQ
           ^U4sPQ         All permutations of [0, 1, 2, 3] with length equal to the number
                          of paintings.
     m/TdU4               Find the count (/) of paintings by painter in the input list.
 fqPQ                     Filter the permutations on the counts being the desired counts
                          in the input.
                          This gives all possible orderings of the paintings.
@                teQ      Index into this list at the given location - 1. (0-indexing)