Giriş

Bu zorluk, bir tamsayı ikili gösteriminin sondaki sıfırlarını ayarlamanızı gerektirir 010101…, bu en iyi bir örnekle açıklanır:

Tam sayı göz önüne alındığında, 400ilk adım onu ​​ikiliye dönüştürmektir:

110010000

Beşinci bitin en az anlamlı bit olduğunu görebileceğimiz için 1, oradan başlayarak alt sıfırları şu şekilde değiştiririz 0101:

110010101

Sonunda bunu ondalığa çeviriyoruz: 405

Meydan okuma

Pozitif bir tamsayı dönüşü / çıktısı verildiğinde, yukarıda tanımlanan işlemin karşılık gelen sonuç değeri.

kurallar

• Bu sıra yalnızca en az bir 1bitli tamsayılar için tanımlanır , bu nedenle giriş her zaman ≥ 1 olur
• Girişi dize, rakam listesi (ondalık) olarak alabilirsiniz
• Geçersiz girdileri işlemek zorunda değilsiniz

testcases

İşte aracı adımlarla bazı test senaryoları (bunları yazdırmanız / iade etmeniz gerekmez):

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 bayt

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

Çevrimiçi deneyin!

açıklama

Örnek 192olarak alalım. İkili formu 11000000ve onu dönüştürmemiz gerekiyor 11010101.

10101Numaraya eklememiz gerektiğini not ediyoruz . Bu, 4^0 + 4^1 + 4^2kapalı bir forma sahip geometrik bir seri ( ) (4^3-1)/(4-1). Bu aynı 4^3//3burada //bölme tamsayıdır belirtmektedir.

Eğer öyleyse 101010, yine de yukarıdaki nedenlerden dolayı geometrik bir seri ( 2×4^0 + 2×4^1 + 2×4^2) olurdu 2×4^3//3.

Her neyse 4^3ve 2×4^3şu şekilde elde ettiğimiz en az önemli bit olacaktır n&-n:

Biz tamamlayıcısı olduğunu fark nolduğunu 00111111. Birini eklersek, olur 01000000ve yalnızca n=11000000en az anlamlı basamakla çakışır . "Tamamlayıcı ve bir tane ekleyin" sadece olumsuzlama olduğunu unutmayın.

Jöle , 5 bayt

&N:3+

Çevrimiçi deneyin!

Bu kez Leaky Nun'in yaklaşımının bir limanı (en azından ben onu biraz golf aşağı yardımcı oldu: P)

Jöle , 7 bayt

^N+4:6ạ

Çevrimiçi deneyin!

Martin Ender'in dolaylı yardımı ile JungHwan Min'in fantastik yaklaşımını kullanır .

Wolfram Dili (Mathematica) , 36 28 26 24 bayt

^{@MartinEnder sayesinde -8 bayt ve @ Mr.Xcoder sayesinde -2 bayt}

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

Çevrimiçi deneyin!

Sadece girişteki izleyen sıfırların sayısını bulmamız 0ve 1uzunluğu ve uzunluklarından daha az olan s ve s değişkenlerini bulmamız ve girişe eklememiz gerekir.

Yani, 400 -> 11001000 -> 110010000 + 0000 -> 110010101 + 101 -> 405

nAlternatif 1s ve 0s içeren th sayısı için açık formül OEIS'de A000975'te verilmiştir . Biz kullanabilirsiniz nhiçbir iki farklı numaralar aynı ikilik sistemde uzunluğu ve rakamları alternatif var çünkü inci numarayı.

J , ₁₉ 18 bayt

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

Çevrimiçi deneyin!

Hızlı Açıklama

Bu eski bir cevaptır, ancak doğada mevcut olana çok benzer, sadece takip eden sıfırları farklı şekilde sayar. Nasıl çalıştığını açıklayan bir bağlantı için yorumlara bakın.

+(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

Diğer Cevaplar:

Önceki yanıt (19 bayt).

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

Olması gerekenden daha uzun çünkü \sağdan sola gidiyor.

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

Julia 0.6 , 12 bayt

!n=n|n&-n÷3

Çevrimiçi deneyin!

JavaScript (ES6), 40 39 bayt

Girişi 32 bit tam sayı olarak alır.

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

Test senaryoları

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 bayt

Kaydedilen 5 sayesinde bayt Sn Xcoder ve Junghwan Min'in düzgün formüle
Kayıtlı başka 3 sayesinde Sn Xcoder

(&3÷+

Çevrimiçi deneyin!

açıklama

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

R , 71 58 bayt

-6 bayt için NofP sayesinde

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

Çevrimiçi deneyin!

Girişin 32 bitlik bir tam sayı olduğunu varsayar. R zaten yalnızca 32 bit tamsayılar ( doublebir tamsayı taştığında yayınlanıyor) ve 64 bit veya imzalanmamış girişler içermiyor.

brainfuck , 120 bayt

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

Çevrimiçi Deneyin!

Geçerli hücredeki değerle başlar ve çıktı değeri olan hücrede biter. Açıkçası 255'in üzerindeki sayılar üzerinde çalışmaz, çünkü tipik beyin fırtınası için hücre sınırı budur, ancak sonsuz hücre boyutunu varsayarsanız çalışacaktır.

PowerShell , 168 bayt

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}

Çevrimiçi deneyin!

Ahh. İkili ve dizi dilimlemeye / dilimlemeye dönüştürme gerçekten PowerShell'in güçlü giysileri değildir.

Girişi $nsayı olarak alır. Bunu convertikili tabana derhal 2ve içine saklarız $a. Sonra bir if / else yapımız var. İf cümlesi , string ( ) öğesinin sonundaki a regex Matchveya 1 0s'nin '0+$'kendisinden indexdaha büyük bir konumda olup olmadığını test eder 0(yani, ikili dizenin başlangıcı). Eğer öyleyse, çalışacak bir şeyimiz var, elsesadece sayı çıktısı veriyoruz.

İçinde if, biz dilim xinci birinci basamağı ve dizi concatenate +kalan rakam ile. Ancak, kalan basamaklar için, bunlar arasında dolaşırız ve bunun yerine seçmek için a 0ya 1da çıktı olarak seçilir $i++%2. Bu bize sonunda s 010101...yerine desen verir 0. Sonra -joinbunu tekrar bir dizgiye dönüştürüyoruz ve $conu bir Int32tabandan geri çeviriyoruz 2.

Her iki durumda da, sayı boru hattında bırakılır ve çıktı örtüktür.

APL + WIN, 43 bayt

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

Ekran girişi istemleri

PowerShell , 41 36 bayt

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

Çevrimiçi deneyin! veya Tüm test senaryolarını doğrulayın

Leaky Nun Limanı'nın Python cevabı .

Leaky Nun sayesinde 5 bayt kurtardı

PHP , 47 bayt

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

Çevrimiçi deneyin!

@Leaky Nun'in çözümünün başka bir limanı

Perl 5 , 54 bayt

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

Çevrimiçi deneyin!

Python 3 , 56 bayt

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

Çevrimiçi deneyin!

Bundan henüz memnun değilim, ama formülü kullanmak istemedim ... -2 Rod sayesinde . -1 Jonathan Frech sayesinde .

Yakut , 15 bayt

Leaky Nun'in başka bir limanı.

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

Çevrimiçi deneyin!

Pas , 18 bayt

Leaky Nun'in yaklaştığı bir liman

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

Çevrimiçi deneyin!

AWK , 24 bayt

JungHwan Min'in Mathmatica'nın bir limanı

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

Çevrimiçi deneyin!

JavaScript ES6, 13 bayt

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 bayt

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

Çevrimiçi deneyin!

C (gcc), 50 bayt

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

Çevrimiçi deneyin!

Arnauld çözeltisini kullanarak  51  48 bayt :

Üç bayt tasarrufu için @ l4m2'ye teşekkürler!

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

Çevrimiçi deneyin!

Gcc ile 43:

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

Çevrimiçi deneyin!

Pari / GP , 19 bayt

Leaky Nun'in yaklaştığı bir liman.

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

Çevrimiçi deneyin!

Jöle , 13 bayt

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

Çevrimiçi deneyin!

açıklama

Örnek bir giriş olarak 24 değerini ele alalım.

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