introduzione

Questa sfida richiede di impostare gli zeri finali di una rappresentazione binaria di numeri interi su 010101…, questo è meglio spiegato con un esempio:

Dato il numero intero 400, il primo passo è convertirlo in binario:

110010000

Come possiamo vedere il quinto bit è il bit meno significativo 1, quindi a partire da lì sostituiamo gli zeri inferiori con 0101:

110010101

Alla fine lo riconvertiamo in decimale: 405

Sfida

Dato un ritorno / output intero positivo il corrispondente valore risultante del processo sopra definito.

Regole

• Questa sequenza è definita solo per numeri interi con almeno un 1bit, quindi l'ingresso sarà sempre ≥ 1
• È possibile invece inserire input come stringa, elenco di cifre (decimale)
• Non è necessario gestire input non validi

Casi test

Ecco alcuni altri test con i passaggi intermedi (non è necessario stamparli / restituirli):

In -> … -> … -> Out
1 -> 1 -> 1 -> 1
2 -> 10 -> 10 -> 2
3 -> 11 -> 11 -> 3
4 -> 100 -> 101 -> 5
24 -> 11000 -> 11010 -> 26
29 -> 11101 -> 11101 -> 29
32 -> 100000 -> 101010 -> 42
192 -> 11000000 -> 11010101 -> 213
400 -> 110010000 -> 110010101 -> 405
298 -> 100101010 -> 100101010 -> 298

Python 3 , 20 byte

lambda n:(n&-n)//3+n

Provalo online!

Spiegazione

Prendi 192come esempio. La sua forma binaria è 11000000e dobbiamo convertirla in 11010101.

Notiamo che dobbiamo aggiungere 10101al numero. Questa è una serie geometrica ( 4^0 + 4^1 + 4^2), che ha una forma chiusa come (4^3-1)/(4-1). È lo stesso di 4^3//3dove //indica la divisione intera.

Se lo fosse 101010, allora sarebbe comunque una serie geometrica ( 2×4^0 + 2×4^1 + 2×4^2), che è 2×4^3//3per i motivi sopra.

Comunque, 4^3e 2×4^3sarebbe solo la parte meno significativa, che otteniamo con n&-n:

Notiamo che il complemento di nè 00111111. Se ne aggiungiamo uno, diventa 01000000e si sovrappone solo n=11000000alla cifra meno significativa. Nota che "completalo e aggiungi uno" è solo negazione.

Gelatina , 5 byte

&N:3+

Provalo online!

Questa volta l'approccio di Leaky Nun (almeno l'ho aiutato a giocare a golf un po ': P)

Gelatina , 7 byte

^N+4:6ạ

Provalo online!

Utilizza il fantastico approccio di JungHwan Min , con l'aiuto indiretto di Martin Ender .

Wolfram Language (Mathematica) , 36 28 26 24 byte

^{-8 byte grazie a @MartinEnder e -2 byte grazie a @ Mr.Xcoder}

#+⌊(#~BitAnd~-#)/3⌋&

Provalo online!

Abbiamo solo bisogno di trovare il numero degli zeri finali in ingresso, e trovare il numero con alternanza 0s e 1s con lunghezza inferiore a quella, e aggiungere al ingresso.

Così, 400 -> 11001000 -> 110010000 + 0000 -> 110010101 + 101 -> 405

La formula esplicita per nil numero con 1s e 0s alternati è stata data in A000975 su OEIS. Possiamo usare il nnumero th poiché nessun due numeri diversi possono avere la stessa lunghezza in binario e avere cifre alternate.

J , ₁₉ 18 byte

+(2|-.i.@#.-.)&.#:

Provalo online!

Spiegazione rapida

Questa è una vecchia risposta, ma è molto simile in natura a quella attuale, conta solo gli zero finali in modo diverso. Vedi i commenti per un link che spiega come funziona.

+(2|i.@i.&1@|.)&.#:
                 #:  Convert to binary list
       i.&1@|.       Index of last 1 from right
            |.         Reverse
       i.&1            Index of first 1
    i.               Range [0, index of last 1 from right)
  2|                 That range mod 2
               &.    Convert back to decimal number
+                    Add to the input

Altre risposte:

Risposta precedente (19 byte).

+(2|i.@i.&1@|.)&.#:

Più a lungo di quanto dovrebbe essere perché \va da destra a sinistra.

+(2|#*-.#.-.)\&.(|.@#:)

Julia 0.6 , 12 byte

!n=n|n&-n÷3

Provalo online!

JavaScript (ES6), 40 39 byte

Accetta l'input come numero intero a 32 bit.

n=>n|((n&=-n)&(m=0xAAAAAAAA)?m:m/2)&--n

Casi test

let f =

n=>n|((n&=-n)&(m=0xAAAAAAAA)?m:m/2)&--n

console.log(f(1))   // 1 -> 1 -> 1
console.log(f(2))   // 10 -> 10 -> 2
console.log(f(3))   // 11 -> 11 -> 3
console.log(f(4))   // 100 -> 101 -> 5
console.log(f(24))  // 11000 -> 11010 -> 26
console.log(f(29))  // 11101 -> 11101 -> 29
console.log(f(32))  // 100000 -> 101010 -> 42
console.log(f(192)) // 11000000 -> 11010101 -> 213
console.log(f(400)) // 110010000 -> 110010101 -> 405
console.log(f(298)) // 100101010 -> 100101010 -> 298

05AB1E , 13 8 5 byte

Risparmiato 5 byte grazie a Mr. Xcoder e alla formula accurata di JungHwan Min
Risparmiato altri 3 grazie a Mr. Xcoder

(&3÷+

Provalo online!

Spiegazione

(      # negate input
 &     # AND with input
  3÷   # integer divide by 3
    +  # add to input

R , 71 58 byte

grazie a NofP per -6 byte

function(n){n=n%/%(x=2^(0:31))%%2
n[!cumsum(n)]=1:0
n%*%x}

Provalo online!

Presuppone che l'input sia un numero intero a 32 bit. R ha solo numeri interi con segno a 32 bit (casting verso doublequando un numero intero trabocca comunque) e nessun 64 bit o ints senza segno.

Brainfuck , 120 byte

>+<[[>-]++>[[>]>]<[>+>]<[<]>-]>[-<+>[-<[<]<]>]>[>]<[>+<[->+<]<[->+<]<]>>[<]+>[-[-<[->+<<+>]>[-<+>]]<[->++<]<[->+<]>>>]<<

Provalo online!

Inizia con il valore nella cella corrente e termina sulla cella con il valore di output. Ovviamente non funzionerà su numeri superiori a 255 poiché questo è il limite di cella per il tipico infarto, ma funzionerà se si assume una dimensione di cella infinita.

PowerShell , 168 byte

param($n)$a=($c=[convert])::ToString($n,2);if(($x=[regex]::Match($a,'0+$').index)-gt0){$c::ToInt32(-join($a[0..($x-1)]+($a[$x..$a.length]|%{(0,1)[$i++%2]})),2)}else{$n}

Provalo online!

Ahia. La conversione da / verso il binario e lo slicing dell'array non sono proprio i punti di forza di PowerShell.

Accetta input $ncome numero. Noi immediatamenteconvert quello di base binaria 2e archiviarlo in $a. Successivamente abbiamo un costrutto if / else. La clausola if verifica se a regex Matchcontro 1 o più 0s alla fine della stringa ( '0+$') ha la sua indexposizione maggiore di 0(ovvero l'inizio della stringa binaria). In tal caso, abbiamo qualcosa con cui lavorare, elseabbiamo appena emesso il numero.

All'interno di if, suddividiamo le xprime cifre e concateniamo +gli array con le cifre rimanenti. Tuttavia, per le cifre rimanenti, le attraversiamo e selezioniamo a0 o 1da emettere, usando $i++%2per scegliere. Questo ci 010101...dà lo schema invece di 0s alla fine. Quindi lo -joinricolleghiamo in una stringa e lo $cinvertiamo in una Int32base 2.

In entrambe le situazioni, il numero viene lasciato sulla pipeline e l'output è implicito.

APL + WIN, 43 byte

p←+/^\⌽~n←((⌊1+2⍟n)⍴2)⊤n←⎕⋄2⊥((-p)↓n),p⍴0 1

Richiede l'inserimento dello schermo

PowerShell , 41 36 byte

param($n)$n+(($x=$n-band-$n)-$x%3)/3

Provalo online!o Verifica tutti i casi di test

Port of Leaky Nun's risposta di Python .

Salvato 5 byte grazie a Leaky Nun

PHP , 47 byte

<?php function b($a){echo(int)(($a&-$a)/3)+$a;}

Provalo online!

Davvero solo un'altra porta della soluzione di @Leaky Nun

Perl 5 , 54 byte

$_=sprintf'%b',<>;1while s/00(0*)$/01$1/;say oct"0b$_"

Provalo online!

Python 3 , 56 byte

lambda n:eval((bin(n).rstrip("0")+"01"*n)[:len(bin(n))])

Provalo online!

Non sono ancora molto contento di questo, ma non ho voluto usare la formula ... -2 grazie a Rod . -1 grazie a Jonathan Frech .

Rubino , 15 byte

Un altro porto dell'approccio di Leaky Nun.

->k{(k&-k)/3+k}

Provalo online!

Ruggine , 18 byte

Una porta dell'approccio di Leaky Nun

|n:i32|(n&-n)/3+n;

Provalo online!

AWK , 24 byte

Un porto della risposta Mathmatica di JungHwan Min

$0=int(and($0,-$0)/3+$0)

Provalo online!

JavaScript ES6, 13 byte

n=>(n&-n)/3|n

f = 
n=>(n&-n)/3|n
;
console.log (f(8));
console.log (f(243));
console.log (f(1048576));
console.log (f(33554432));

C, 56 byte

i,k;f(n){for(k=i=1;n>>i<<i==n;k+=++i&1)k*=2;return n|k;}

Provalo online!

C (gcc), 50 byte

i,k;f(n){for(k=i=1;n>>i<<i==n;k+=++i&1)k*=2;k|=n;}

Provalo online!

 51  48 byte usando la soluzione di Arnauld :

Grazie a @ l4m2 per aver salvato tre byte!

m;f(n){return n|((n&-n)&(m=-1u/3*2)?m:m/2)&n-1;}

Provalo online!

43 con gcc:

m;f(n){m=n|((n&-n)&(m=-1u/3*2)?m:m/2)&n-1;}

Provalo online!

Pari / GP , 19 byte

Una porta dell'approccio di Leaky Nun.

n->n+bitand(n,-n)\3

Provalo online!

Gelatina , 13 byte

BŒgṪµ2Ḷṁ×CḄ+³

Provalo online!

Spiegazione

Prendi 24 come input di esempio.

BŒgṪµ2Ḷṁ×CḄ+³
B                Binary representation of the input → 11000
 Œg              Group runs of equal length → [[1,1],[0,0,0]]
   Ṫ             Tail → [0,0,0]
    µ            New monadic link
     2Ḷ          [0,1] constant
       ṁ         Mold [0,1] to the shape of [0,0,0] → [0,1,0]
        ×        Multiply [0,1,0] by...
         C       1-[0,0,0]. If last bit(s) of the original input are 1 this will add nothing to the original input
          Ḅ      Convert to decimal from binary → 2
           +³    Add this with the original input → 26