introduzione
Supponi di ricevere una permutazione casuale di n
oggetti. La permutazione è sigillata in una scatola, quindi non hai idea di quale delle n!
possibili sia. Se sei riuscito ad applicare la permutazione a n
oggetti distinti, potresti immediatamente dedurne l'identità. Tuttavia, puoi applicare la permutazione solo ai n
vettori binari di lunghezza , il che significa che dovrai applicarla più volte per riconoscerla. Chiaramente, applicandolo ai n
vettori con solo uno 1
fa il lavoro, ma se sei intelligente, puoi farlo con le log(n)
applicazioni. Il codice per quel metodo sarà più lungo, sebbene ...
Questa è una sfida sperimentale in cui il tuo punteggio è una combinazione di lunghezza del codice e complessità della query , ovvero il numero di chiamate a una procedura ausiliaria. Le specifiche sono un po 'lunghe, quindi abbi pazienza.
L'obiettivo
Il tuo compito è scrivere una funzione denominata (o l'equivalente più vicino) f
che accetta come input un numero intero positivo n
e una permutazione p
dei primi n
numeri interi, utilizzando l'indicizzazione basata su 0 o 1. Il suo output è la permutazione p
. Tuttavia, non ti è consentito accedere p
direttamente alla permutazione . L'unica cosa che puoi fare con esso è applicarlo a qualsiasi vettore di n
bit. A tale scopo, è necessario utilizzare una funzione ausiliaria P
che accetta una permutazione p
e un vettore di bit v
e restituisce il vettore permutato la cui p[i]
coordinata th contiene il bit v[i]
. Per esempio:
P([1,2,3,4,0], [1,1,0,0,0]) == [0,1,1,0,0]
È possibile sostituire i "bit" con due valori distinti, come 3
e -4
, oe 'a'
e 'b'
, e non è necessario correggerli, quindi è possibile chiamare P
con entrambi [-4,3,3,-4]
e [2,2,2,1]
nella stessa chiamata a f
. La definizione di P
non viene conteggiata ai fini del punteggio.
punteggio
La complessità della query della soluzione su un determinato input è il numero di chiamate effettuate alla funzione ausiliaria P
. Per rendere inequivocabile questa misura, la soluzione deve essere deterministica. Puoi usare numeri generati in modo pseudo-casuale, ma poi devi anche correggere un seme iniziale per il generatore.
In questo repository troverai un file chiamato permutations.txt
che contiene 505 permutazioni, 5 di ogni lunghezza tra 50 e 150 inclusi, usando l'indicizzazione basata su 0 (incrementa ogni numero nel caso basato su 1). Ogni permutazione è sulla sua linea e i suoi numeri sono separati da spazi. Il tuo punteggio è il conteggio dei byte di f
+ complessità media delle query su questi input . Il punteggio più basso vince.
Regole extra
Il codice con spiegazioni è preferito e le scappatoie standard sono vietate. In particolare, i singoli bit sono indistinguibili (quindi non è possibile assegnare un vettore di Integer
oggetti P
e confrontare le loro identità) e la funzione P
restituisce sempre un nuovo vettore invece di riorganizzarne l'input. È possibile modificare liberamente i nomi di f
e P
, e l'ordine in cui si prendono i loro argomenti.
Se sei la prima persona a rispondere nel tuo linguaggio di programmazione, sei fortemente incoraggiato a includere un cablaggio di prova, inclusa un'implementazione della funzione P
che conti anche il numero di volte in cui è stata chiamata. Ad esempio, ecco il cablaggio per Python 3.
def f(n,p):
pass # Your submission goes here
num_calls = 0
def P(permutation, bit_vector):
global num_calls
num_calls += 1
permuted_vector = [0]*len(bit_vector)
for i in range(len(bit_vector)):
permuted_vector[permutation[i]] = bit_vector[i]
return permuted_vector
num_lines = 0
file_stream = open("permutations.txt")
for line in file_stream:
num_lines += 1
perm = [int(n) for n in line.split()]
guess = f(len(perm), perm)
if guess != perm:
print("Wrong output\n %s\n given for input\n %s"%(str(guess), str(perm)))
break
else:
print("Done. Average query complexity: %g"%(num_calls/num_lines,))
file_stream.close()
In alcune lingue, è impossibile scrivere una tale imbracatura. In particolare, Haskell non consente alla funzione pura P
di registrare il numero di volte in cui viene chiamata. Per questo motivo, è possibile implementare nuovamente la soluzione in modo tale da calcolare anche la complessità della query e utilizzarla nel cablaggio.
abaaabababaa
e-4 3 3 3 -4 3
sarebbe un vettore di bit.