^{Dichiarazione di non responsabilità: la codifica di Levenshtein non è completamente correlata alla metrica di modifica della distanza di Levenshtein .}

<Inserisci una lunga storia sul perché i codici Levenshtein devono essere calcolati qui.>

Il codice

La codifica di Levenshtein è un sistema di assegnazione di codici binari a numeri interi non negativi che mantiene in probabilità alcune strane proprietà che non sono rilevanti per questa sfida. Indicheremo questo codice come L ( n ). Wikipedia lo descrive come un processo in cinque fasi:

1. Inizializza la variabile conteggio dei passi da C a 1.
2. Scrivi la rappresentazione binaria del numero senza che porti 1all'inizio del codice.
3. Sia M il numero di bit scritti nel passaggio 2.
4. Se M non è 0, incrementare C , ripetere dal passaggio 2 con M come nuovo numero.
5. Scrivi C 1 bit e 0a all'inizio del codice.

Tuttavia, il codice può anche essere descritto in modo ricorsivo:

1. Se il numero è 0, il suo codice è 0.
2. Scrivi la rappresentazione binaria del numero senza che porti 1all'inizio del codice.
3. Sia M il numero di bit scritti nel passaggio 2.
4. Scrivi L ( M ) all'inizio del codice.
5. Scrivi un 1po 'all'inizio del codice.

Per coloro che preferiscono gli esempi, ecco il processo ricorsivo per L (87654321), con denotazione di concatenazione:

La sfida

Scrivi un programma o una funzione che, dato un numero n , emetta la stringa di bit L ( n ) in qualsiasi formato ragionevole (questo include la restituzione di un numero con detti bit). Le scappatoie standard sono, come sempre, vietate.

Esempi

Ingresso: 5

Produzione: 1110001

Ingresso: 30

Produzione: 111100001110

Ingresso: 87654321

Produzione: 111110000101001001110010111111110110001

Ingresso: 0

Produzione: 0

Gelatina , 13 11 byte

Ḣ;LÑ$;
BÇṀ¡

Provalo online! o verifica tutti i casi di test .

Come funziona

L'invio consiste in una coppia di collegamenti reciprocamente ricorsivi.

BÇṀ¡    Main link. Argument: n

B       Convert n to binary.
   ¡    Execute...
 Ç        the helper link...
  Ṁ       m times, where m is the maximum of n's binary digits.

Ḣ;LÑ$;  Helper link. Argument: A (array of binary digits)

Ḣ       Head; remove and return the first element of A.
    $   Combine the two links to the left into a monadic chain.
  L       Yield the length (l) of A without its first element.
   Ñ      Call the main link with argument l.
 ;      Concatenate the results to both sides.
     ;  Append the tail of A.

Haskell, 70 byte

b 0=[]
b n=b(div n 2)++[mod n 2]
f 0=[0]
f n|1:t<-b n=1:f(length t)++t

Definisce una funzione f : Int -> [Int]. Ad esempio f 5 == [1,1,1,0,0,0,1],.

Python, 49 byte

f=lambda n:n and'1%s'%f(len(bin(n))-3)+bin(n)[3:]

Provalo su Ideone .

Mathematica, 61 byte

f@0={0};f@n_:=Join[{1},f@Length@#,#]&@Rest@IntegerDigits[n,2]

JavaScript (ES6), 54 52 byte

f=n=>(s=n.toString(2)).replace(1,_=>1+f(s.length-1))

<input type=number oninput=o.textContent=f(+this.value)><pre id=o>

Modifica: salvato 2 byte grazie a @Arnauld.

Pyth, 12 byte

L&bX1.Bbyslb

Dimostrazione

(Alla yfine è eseguire la funzione risultante sull'input)

Spiegazione:

L&bX1.Bbyslb
L               def y(b):
 &b             If b is 0, return 0. This is returned as an int, but will be cast
                to a string later.
          lb    Take the log of b
         s      Floor
        y       Call y recursively
   X1           Insert at position 1 into
     .Bb        Convert b to binary.

MQ, 110

Funzione ricorsiva:

f={params[["i",0],["l",[]]];if(i<1)exitWith{[0]};while{i>1}do{l=[i%2]+l;i=floor(i/2)};[1]+([count l]call f)+l}

Chiama come: [NUMBER] call f

Nota che in realtà non funziona per 87654321 o altri numeri di grandi dimensioni a causa di un bug nel motore ArmA. Anche se probabilmente verrà risolto presto e dovrebbe funzionare secondo le specifiche.

( Questo biglietto qui )

PHP, 116 114 byte

<?$f=function($i)use(&$f){$b=decbin($i);return!$b?0:preg_replace('/^1/',1 .$f(~~log10($b)),$b);};echo$f($argv[1]);

Fornire il numero come primo argomento.

Aggiornare:

• Ho salvato un byte sostituendolo strlen($b)-1con ~~log10($b)(finalmente capito perché tutti gli altri stavano usando il logaritmo) e un altro concatenando diversamente.

Rubino, 38 byte

Molto simile alla risposta JavaScript di Neil .

f=->n{("%b"%n).sub(/1\K/){f[$'.size]}}

Guardalo su repl.it: https://repl.it/CnhQ

Java 8 (programma completo), 257 249 byte

interface M{static void main(String[]a)throws Exception{int i=0,j;while((j=System.in.read())>10)i=i*10+j-48;System.out.print(L(i));}static String L(int i){if(i==0)return "0";String s=Integer.toString(i,2);return "1"+L(s.length()-1)+s.substring(1);}}

Versione leggibile con spiegazione (Per lo più è solo ricorsione):

interface M {
    static void main(String[]a) throws Exception { // Using Exception is unadvised in real coding, but this is Code Gold
        int i = 0, j; // i stores the input; j is a temporary variable
        while ((j = System.in.read()) > 10) // Read the input to j and stop if it is a newline. Technically this stops for tabulators as well, but we shouldn't encounter any of those...
            i = i * 10 + j - 48; // Looping this step eventually reads the whole number in from System.in without using a reader (those take up a lot of bytes)
        System.out.print(L(i)); // Make a method call
    }

    static String L(int i) { // This gets the actual Levenshtein Code
        if (i == 0)
            return "0"; // The program gets a StackOverflowException without this part
        String s = Integer.toString(i, 2); // Shorter than toBinaryString
        return "1" + L(s.length() - 1) + s.substring(1); // Write in the first character (which is always a one), followed by the next L-code, followed by the rest of the binary string
    }
}

EDIT 1 : 8 byte salvati : il primo carattere della stringa binaria è sempre 1; pertanto, anziché utilizzare s.charAt(0), un'opzione migliore è semplicemente "1".