Panoramica

In questa sfida, il tuo compito è generare casualmente una funzione matematica monotonica tra due insiemi.

Ingresso

I tuoi input sono due numeri interi positivi se n.

Dopo aver ottenuto questi input, il tuo programma deve generare una funzione matematica casualef dal set a . In altre parole, è una "regola" che accetta una -tupla di numeri interi tra e e restituisce un numero intero. Inoltre, dovrebbe essere monotonico nel senso seguente. Se e sono due tuple tali che valgono per ogni coordinata , allora .{0,1,...,s-1}n{0,1,...,s-1}fn0s-1fABnA[i] ≥ B[i]if(A) ≥ f(B)

L'esatta distribuzione delle funzioni monotoniche fnon ha importanza, purché ciascuna di tali funzioni abbia una probabilità positiva di essere generata (assumendo un RNG perfetto).

Produzione

L'output deve essere un elenco degli input e degli output di f. Deve contenere tutte le ntuple di numeri interi compresi tra 0e s-1in un certo ordine, ciascuno seguito dal corrispondente output di f. Il formato di output esatto è flessibile (entro limiti ragionevoli).

Esempi

Gli input s = 3e n = 2potrebbero produrre l'output

(0, 0) 0
(0, 1) 1
(0, 2) 2
(1, 0) 0
(1, 1) 1
(1, 2) 2
(2, 0) 1
(2, 1) 1
(2, 2) 2

Contiene tutte le coppie sull'insieme {0, 1, 2}esattamente una volta e ognuna è seguita dal suo fvalore. Anche la condizione di monotonicità è soddisfatta. Le tuple sono date qui in ordine lessicografico, ma questo non è necessario.

Come altro esempio, s = 2e n = 4potrebbe produrre

(0, 0, 0, 0) 0
(0, 0, 0, 1) 0
(0, 0, 1, 0) 0
(0, 0, 1, 1) 0
(0, 1, 0, 0) 1
(0, 1, 0, 1) 1
(0, 1, 1, 0) 1
(0, 1, 1, 1) 1
(1, 0, 0, 0) 0
(1, 0, 0, 1) 1
(1, 0, 1, 0) 0
(1, 0, 1, 1) 1
(1, 1, 0, 0) 1
(1, 1, 0, 1) 1
(1, 1, 1, 0) 1
(1, 1, 1, 1) 1

Di seguito sono riportate tutte le possibili uscite per s = 2e n = 2(fino al riordino delle tuple); il tuo programma dovrebbe generare casualmente uno di questi:

(0,0) 0
(0,1) 0
(1,0) 0
(1,1) 0
-------
(0,0) 0
(0,1) 0
(1,0) 0
(1,1) 1
-------
(0,0) 0
(0,1) 0
(1,0) 1
(1,1) 1
-------
(0,0) 0
(0,1) 1
(1,0) 0
(1,1) 1
-------
(0,0) 0
(0,1) 1
(1,0) 1
(1,1) 1
-------
(0,0) 1
(0,1) 1
(1,0) 1
(1,1) 1

Regole e punteggio

È possibile scrivere un programma completo o una funzione. Vince il conteggio di byte più basso e non sono consentite scappatoie standard . Il codice con spiegazione è preferito.

Non ci sono restrizioni sulla complessità temporale, ma darò un bonus del -15% se la tua soluzione è sempre garantita per terminare in un certo lasso di tempo (a seconda degli input e ipotizzando un RNG perfetto che funzioni a tempo costante) .

Pyth, 35 byte (38-15% = 31,45 più in basso)

#I!sm><FhMds<MCeMd^JC,mOQK^UQvzK2JB

Dimostrazione

L'input è nel formato:

n
s

L'output è nel formato:

[[value, tuple], [value, tuple], ...]

Genera semplicemente possibilità casuali e le verifica.

Versione alternativa a 37 byte che credo si qualifichi per il bonus:

Of!sm><FhMds<MCeMd^T2mC,d^UQvz^UQ^Qvz

Dimostrazione

Questo inizia generando tutte le possibili funzioni monotoniche, quindi ne emette una a caso. È molto più lento e supera 2,2.

CJam, 40 byte - 15% = 34 byte

q~1$\m*\1$,m*{W$\.+2m*{:.<2b}%1&!},mR]zp

Questo approccio genera tutte le funzioni valide e quindi seleziona casualmente. Il tempo di esecuzione è almeno O (s ^{2s n} ) , ma costante per un dato input.

Dubito che questo sia ciò che l'OP aveva in mente, ma è garantito che finirà in un certo lasso di tempo (a seconda degli input [...]) e quindi si qualifica per il bonus.

Provalo online nell'interprete CJam .

Julia, 64 byte (-15% = 54,4)

g(s,n)=(K=rand(0:s-1,ntuple(n,i->s));for i=1:n K=sort(K,i)end;K)

Ungolfed:

function g(s,n)
  # Generates a random n-dimensional array with s per dimension
  # and all values being integers between 0 and s-1
  K=rand(0:s-1,ntuple(n,i->s))
  # Loop over the various dimensions
  for i=1:n
    # Sort in the current dimension
    K=sort(K,i)
  end
  return K
end

Questo funzionerà rapidamente, con l'unico problema possibile con la memoria per abbastanza grande s e n (g (10,10) deve produrre un array 10 ^ 10, quindi ovviamente esaurirà la memoria, anche se ogni numero è un byte, ovvero 10 gigabyte di dati).

L'output è indicizzato in base 1, quindi per determinare il risultato per un determinato input, è necessario aggiungerne uno a ciascun valore di input. Ad esempio, per trovare f (1,2,6,0,3), è necessario esaminare K[2,3,7,1,4].