Per posta di ladri, macchina Cheapo Enigma (ladri)

L'invio di un poliziotto consisterà in un programma / funzione che accetta un singolo byte di dati e restituisce un singolo byte di dati. Ogni possibile input deve produrre un output unico. (In altre parole, la tua funzione deve essere biiettiva)

I ladri tenteranno di creare la tua funzione inversa usando un codice il più breve possibile. Quindi il tuo obiettivo è rendere la tua funzione difficile da invertire.

Non è possibile utilizzare i componenti integrati che hanno il solo scopo di eseguire l'hashing o la crittografia.

Il conteggio dei byte non può superare i 64 byte. Le soluzioni a 0 byte non sono idonee alla vincita.

Formato di input / output

8 bit (0 o 1) o un numero intero di base 10 nell'intervallo 1-256, 0-255 o da -128 a 127. Può utilizzare I / O standard o I / O di file. La funzione può anche restituire un valore come output. Ingresso e uscita devono appartenere allo stesso intervallo (binario, 1-256, 0-255 o da -128 a 127). Il ladro dovrà inoltre utilizzare questo intervallo per l'input e l'output.

punteggio

Il rapporto del tuo byte conta con quello del miglior tentativo di ladro contro di te. Il punteggio più basso vince.

Hai diritto a vincere (come poliziotto) solo se un ladro ha tentato di sconfiggerti. (Questo ladro potresti essere tu)

Esempio

C ++, utilizza l'intervallo 0-255, 31 byte

int x;
cin>>x;
cout<<(x+1)%256;

Possibile invio di ladri in C ++, 32 byte

int f(int x)
{return x?x-1:255;}

L'uso della stessa lingua o di un algoritmo simile non è un requisito

Questo dà un punteggio di 31/32 = 0,97 sia al poliziotto che al ladro.

Javascript, 11 8 byte, Punteggio: 8/5

x=>x^x/2

Semplice implementazione del codice grigio. La decodifica richiede generalmente un intero ciclo. Vediamo chi esce con il più piccolo o anche senza un loop!

C, 64 byte, punteggio 64/71 = 0,901

T[256];f(x){srand(x&&f(x-1));for(;T[x=rand()%256]++;);return x;}

Accetta input nell'intervallo [0 255].

Provalo online! - su TIO (usando GCC), questo produce:

103,198,105,115,081,255,074,236,041,205,186,171,242,251,227,070,
124,194,084,248,027,232,231,141,118,090,046,099,051,159,201,154,
102,050,013,183,049,088,163,037,093,005,023,233,094,212,178,155,
180,017,014,130,116,065,033,061,220,135,112,062,161,225,252,001,
126,151,234,107,150,143,056,092,042,176,059,175,060,024,219,002,
026,254,067,250,170,058,209,230,148,117,216,190,097,137,249,187,
168,153,015,149,177,235,241,179,239,247,000,229,202,011,203,208,
072,071,100,189,031,035,030,028,123,197,020,075,121,036,158,009,
172,016,080,021,111,034,025,125,245,127,164,019,181,078,152,224,
077,052,188,095,119,108,134,043,085,162,004,211,054,226,240,228,
079,073,253,169,008,138,010,213,068,091,243,142,076,215,045,066,
006,196,132,173,222,048,246,032,133,007,244,185,195,217,160,120,
218,106,083,144,087,238,207,096,210,053,101,063,098,128,165,089,
140,012,192,131,047,039,022,147,184,109,182,193,199,237,018,069,
057,157,174,104,122,166,055,110,003,040,139,086,145,114,129,113,
206,167,191,214,146,221,136,038,156,082,200,029,044,204,223,064

Si noti che su altri sistemi, può produrre output diversi (ma comunque validi), poiché C non impone randun'implementazione specifica . La mia presentazione è specificamente la versione in esecuzione su TIO (come collegata).

Sono piuttosto deluso dal fatto che non sono riuscito a far funzionare una versione come la mia originale ( f(x){return rand(srand(x*229))/229%256;}) su TIO, dal momento che penso che sia molto più elegante. Dal momento che funziona solo su Clang su OS X, non è giusto per la concorrenza. Questo è ancora piuttosto imbarazzante da invertire, quindi credo sia abbastanza.

Gelatina , 2/5

^H

Provalo online per vedere l'intero tavolo.

JavaScript, 44 byte 22/3

x=>a.sort()[x]
for(a=[],i=0;i<256;)a[i]=i++;

Utilizza l'ordinamento lessicografico (Javascript predefinito) per riorganizzare tutti i numeri da 0 a 255

Provalo online!

C (gcc) , 32 27/30 byte

Grazie a christoph per il golf 5 byte.

f(x){x=x?f(x*5+1&255)+1:0;}

Provalo online!

Javascript, 11/8 byte

x=>x**5%257

Il dominio / intervallo è compreso tra 1 e 256.

JavaScript, 13 byte 13/12

x=>(x<<9)%257

Ingresso e uscita sono entrambi nell'intervallo 1-> 256

Provalo online!

Javascript, 27/29 byte

x=>x-6?x*95%127+x*98%131:65

Modifica: intervallo / dominio è 1..256. Generato tramite forza bruta, più o meno.

Ottava , 16/6

@(x)mod(x*3,256)

Provalo online!

Java, 35 byte

int a(int v){return (v*v+v)%512/2;}

Dominio / intervallo sono 0-255

Rubino, 23 byte

->x{('228'*x).to_i%257}

L'intervallo e il dominio sono 0..255. Concatena 228 a se stesso x volte, quindi prendi il risultato modulo 257 (da 0 mappe a 0). 228 è il primo numero magico dopo 9 che funziona per questo intervallo (fornisce valori distinti che non includono 256).

Python 3, 55 byte

y=lambda x,i=3:x if i==0 else pow(3,y(5*x,i-1),257)-1

Il dominio / intervallo è 0-255.

Python 3, 32 byte 32/23

V=lambda x:((3+x)%16)*16+x//16

Il dominio / intervallo è 0-255.

Capovolge i primi quattro byte con gli ultimi quattro e aggiunge tre ai primi byte.

Mathematica, 13 byte

Mod[#^7,257]&

Utilizza l'intervallo [1..256], sebbene sia ugualmente valido nell'intervallo [0..255]. Per visualizzare l'intera tabella, copia / incolla una delle seguenti righe di codice nella sandbox di Wolfram :

Array[ Mod[#^7,257]&, 256]   (for a list of values in order)
Array[ Rule[#,Mod[#^7,257]]&, 256]   (for a list of input-output rules)

Brainfuck , 37/11

,+++++[>+++++++<-]>++[<+++++++++>-]<.

Provalo online!

Non molto buono ma intervallo di 0-255