Verilen bir sayı olup olmadığını bir sayı verilir.

Bir katlama numarası, ikili gösterimi alırsanız ve ikiye katlarsanız, bu rakamın ilk yarısının XNOR çarpımı ve ikinci yarısını da tersi sayılarla alır. sıfır.

Sayının ikilide tek sayı hanesi varsa, orta hane 1 olmalıdır ve katlanırken dikkate alınmaz.

Bu biraz kafa karıştırıcı olabileceğinden, bazı örnekler vereceğim:

178

178'in ikili gösterimi

10110010

Bunu katlamak için önce ikiye bölüyoruz

1011 0010

İkinci yarıyı tersine çeviririz

1011
0100

Ve biz iki yarıyı XNOR:

0000

Bu sıfırdır, bu bir katlama numarasıdır.

1644

1644'ün ikili gösterimi

11001101100

Bunu katlamak için önce ikiye bölüyoruz

11001 1 01100

Ortadaki bit 1, bu yüzden atıyoruz.

11001 01100

İkinci yarıyı tersine çeviririz

11001
00110

Ve biz iki yarıyı XNOR:

00000

Bu sıfırdır, bu bir katlama numarasıdır.

4254

4254'ün ikili gösterimi

1000010011110

Bunu katlamak için önce ikiye bölüyoruz

100001 0 011110

Orta bit 0, bu yüzden bu bir katlama numarası değildir.

Görev

Göreviniz, pozitif bir sayı almak ve eğer sayı katlanmıyorsa bir aldatmaca döndürmek ve eğer değilse katlanmamaksa bir aldatmaca döndürmektir. Bu kod golf, bayt'ı geri saymaya çalışın.

Test Kılıfları

İşte ilk 99 katlama sayıları:

[1, 2, 6, 10, 12, 22, 28, 38, 42, 52, 56, 78, 90, 108, 120, 142, 150, 170, 178, 204, 212, 232, 240, 286, 310, 346, 370, 412, 436, 472, 496, 542, 558, 598, 614, 666, 682, 722, 738, 796, 812, 852, 868, 920, 936, 976, 992, 1086, 1134, 1206, 1254, 1338, 1386, 1458, 1506, 1596, 1644, 1716, 1764, 1848, 1896, 1968, 2016, 2110, 2142, 2222, 2254, 2358, 2390, 2470, 2502, 2618, 2650, 2730, 2762, 2866, 2898, 2978, 3010, 3132, 3164, 3244, 3276, 3380, 3412, 3492, 3524, 3640, 3672, 3752, 3784, 3888, 3920, 4000, 4032, 4222, 4318, 4462, 4558]

Jöle , 9 bayt

Bœs2µḢ^UȦ

Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Nasıl çalışır

Bœs2µḢ^UȦ  Main link. Argument: n

B          Binary; convert n to base 2.
 œs2       Evenly split 2; split the base 2 array into chunks of equal-ish length.
           For an odd amount of digits, the middle digit will form part of the
           first chunk.
    µ      Begin a new, monadic chain. Argument: [A, B] (first and second half)
     Ḣ     Head; remove and yield A.
       U   Upend; reverse the digits in [B].
      ^    Perform vectorized bitwise XOR of the results to both sides.
           If A is longer than B, the last digit will remain untouched.
           n is a folding number iff the result contains only 1's.
        Ȧ  Octave-style all; yield 1 iff the result does not contain a 0.

05AB1E , 13 12 bayt

Kod:

bS2ä`R0¸«s^P

CP-1252 kodlamasını kullanır . Çevrimiçi deneyin!

Açıklama:

İlk olarak, sayıyı kullanarak ikiliyi dönüştürürüz b. 1644 , 11001101100 olur . Bunu iki parçaya ayırdık 2ä. Örneğin, 11001101100 şöyle olurdu:

[1, 1, 0, 0, 1, 1]
[0, 1, 1, 0, 0]

Eşit olmayan sayıda bit varsa, ilk kısım ekstra bit alır. Biz Rgeçen dize everse ve kullanan bir sıfır eklemek 0¸«. Bunun nedeni, yalnızca orta bit bir 1 olduğunda ( 1 XOR 0 = 1 ve 0 XOR 0 = 0 ) , truthy sonuçları vermektir . Ortadaki bit yoksa, 05AB1E yalnızca son biti (eklenen sıfır) yok sayar:

[1, 1, 0, 0, 1, 1]
[0, 0, 1, 1, 0, 0]

Yapmamız gereken son şey, bir element bilgisiyle XOR yapmak ve sonucun sonucunu almak. Çok fazla bir eleman varsa, program son elemanı dışarıda bırakacaktır ( [1, 0, 0] XOR [0, 1] = [1, 1]) Örneğin:

[1, 1, 0, 0, 1, 1]
[0, 0, 1, 1, 0, 0] XOR

Oluyor:

[1, 1, 1, 1, 1, 1]

Ve bunun ürünü 1'dir , ki bu truthy'dir.

Java 7, 152 145 142 138 134 bayt

boolean f(Long a){byte[]b=a.toString(a,2).getBytes();int i=0,l=b.length,z=l%2<1?1:b[l/2]-48;for(;i<l/2;)z*=b[i]-b[l-++i];return z!=0;}

İpin üzerinde dönerek bir palindrom için olduğu gibi sıfir arar. Art arda çarparak izleri tutar, böylece yapmanız gereken tek şey sonunda sıfır olmadığını kontrol etmektir.

Kaydırma çubukları olmadan:

boolean f(Long a){
    byte[]b=a.toString(a,2).getBytes();
    int i=0,l=b.length,z=l%2<1?1:b[l/2]-48;
    for(;i<l/2;)
        z*=b[i]-b[l-++i];
    return z!=0;
}

JavaScript (ES6), 61 57 52 bayt

Özyinelemeli hesaplar:

(bit(N) XOR bit(0)) AND (bit(N-1) XOR bit(1)) AND (bit(N-2) XOR bit(2)) etc.

nerede Ngirişi en yüksek bit kümesinin sıralamasıdır.

Girdide tek bit sayısı varsa, orta bit tanımsız ( pop()boş bir dizide döndürülen değer) XOR'ed olur; Böylece, 0orta bir bit çıktıyı temizler ve 1orta bir bit diğer işlemlerin sonucunu değiştirmez - bu da katlama sayısının zorluk tanımıyla tutarlıdır.

f=(n,[a,...b]=n.toString(2))=>a?(a^b.pop())&f(n,b):1

// testing integers in [1 .. 99]
for(var i = 1; i < 100; i++) {
  f(i) && console.log(i);
}

Python 2, 57 bayt

s=bin(input())[2:]
while''<s!='1':s[-1]==s[0]<_;s=s[1:-1]

Çıkış kodu üzerinden çıkış : Falsey için hata ve Truthy için hata yok.

Girişi ikiliye dönüştürür. İlk ve son karakterin eşit olup olmadığını kontrol eder, bu karakterleri çıkardıktan sonra bunu tutar ve tekrar eder.

s[-1]==s[0]<_Eğer isimsiz atanmamış değişkeni değerlendirmeye çalışarak ilk ve son karakter eşit değilse, karşılaştırma bir hata verir _. Eşitse, eşitsizlik zinciri bunun yerine kısa devre yapıyor. Biz orta elemana olsun 1, whiledöngü Tamam olarak özel durum onu hiç sonlandırmak olduğunu.

Tamamen aritmetik bir yaklaşımın f=lambda n,r=0:...f(n/2,2*r+~n%2)...ters çevrilip ters çevrilmiş olan ikili sayıları kesmek nve rbir merkeze ne zaman ve eşit olduğunu saptamak gibi bir özyineleme ile daha kısa olacağını düşünüyorum 1. Önde gelen sıfırlar ve merkez ile birlikte incelikler var.

Python 2, 94 79 72 67 bayt

F=lambda s:s in'1'or(s[0]!=s[-1])*F(s[1:-1])
lambda n:F(bin(n)[2:])

@Xnor sayesinde 12 bayt kaydedildi

İkinci satırdaki adsız bir işlevi tanımlar.

Açıklama (biraz boşluk eklenmiş olarak):

F = lambda s:                                        # We define a function, F, which takes one argument, the string s, which returns the following:
             s in'1'                                 # Gives true if s is '' or s is '1', the first case is a base case and the second is for the middle bit case.
                     or(s[0] != s[-1])               # Or the first and last are different
                                      * F(s[1:-1])   # And check if s, without the first and last element is also foldable.
lambda n: F(bin(n)[:-2])                             # The main function, which calls F with the argument in binary form.

Burada dene !

Haskell, 89 88 86 bayt

f n|n<2=[n]|1>0=mod n 2:f(div n 2)
g n=elem(product$zipWith(+)(f n)$reverse$f n)[1,2]

Bit yönünde bit gösterimini tersine toplayarak ve ürünü alarak çalışır. 1 veya 2 ise, sayı bir katlama numarasıdır (katlanan bitler varsa 1, ortada tek ve bitler varsa 2).

Python 2, 100 99 95 94 Bayt

Bu biraz uzun sürüyor, ama üzerinde çalışmaya devam edeceğim :) 1Eğer sayı katlanabilirse, a basar 0.

a=bin(input())[2:]
b=len(a)
print(a[b/2]>=`b%2`)*all(c!=d for c,d in zip(a[:b/2],a[:~b/2:-1]))

^{Burada test et !}

^{Buğday Sihirbazı sayesinde 1 bayt tasarruf :)}

^{5 bayt tasarruf için Rod'a teşekkürler! :)}

> <> , 37 + 3 = 40 bayt

<,2-@:%2:v!?:
=2lrv?=1l<+={$r0?
0=n;>

Girdi, program başlangıcında yığında bulunur, bu nedenle -vbayrak için +3 bayt bulunur .

Çevrimiçi deneyin!

Jöle , 13 bayt

Bœs2U0¦z0^/€Ạ

TryItOnline
Veya 4558’e kadar eşleşen terimler

Nasıl?

Bœs2U0¦z0^/€Ạ - Main link: n
B             - binary
 œs2          - split into 2 slices (odd length will have first longer than second)
     0¦       - apply to index 0 (the right hand one)
    U         - reverse
       z0     - zip together with filler 0 (thus central 1 or 0 will pair with 0)
          /€  - reduce with for each
         ^    -     XOR
            Ạ - All truthy?

Perl, 46 bayt

İçin +1 içerir -p

STDIN'deki sayı ile koş

folding.pl <<< 178

folding.pl:

#!/usr/bin/perl -p
$_=($_=sprintf"%b",$_)<s%.%!/\G1$/^$&^chop%eg

Bunun işe yaradığını bile perl böceği olarak görüyorum. Dahili $_, değiştirildikten sonra eşleşme konumu güncellemeleri almamalıdır. Bu programda maç pozisyonu aslında sonun ötesine geçer$_

Brachylog , 16 bayt

ḃḍ{↔|h1&b↔}ᵗz₂≠ᵐ

Online olarak işe yaramıyor ...

Giriş değişkeninden girdi alır ve başarı veya başarısızlık sonucu çıkılır. z₂30 Nisan'dan bu yana dilde olan yoğun bir şekilde dayanıyor , ancak TIO’dan çekilmesini istemeyi unuttuk, şu an için sadece dilin yerel kurulumunda çalışıyor. Her iki durumda da muhtemelen aşırı saf bir yaklaşım.

                    The input
ḃ                   's binary representation
 ḍ                  split in half
  {       }ᵗ        with its second half
   ↔|               either reversed, or
     h1             if it starts with 1
       &b           relieved of its first element
         ↔          and then reversed
              ≠     has no duplicate elements
            z  ᵐ    in any pair of elements zipped from the two halves
             ₂      which are equal in length.

Brachylog ( TIO'da ), 19 bayt

ḃḍ{↔|h1&b↔}ᵗlᵛ↖Lz≠ᵐ

Çevrimiçi deneyin!

lᵛ↖LzFonksiyonel olarak eşittir z₂(eğer L değişkenini başka bir yerde kullanmazsanız), fakat aynı zamanda üç byte daha uzundur.

Python 2, 76 71 69 bayt

-5 @Dennis sayesinde (bayt ''içinde bulunan bir '1'çok yerine in('','1')ile in'1')
-2 (kullanımı çarpma @xnor sayesinde bayt (...)*yerine and)

f=lambda n:f(bin(n)[2:])if n<''else n in'1'or(n[0]!=n[-1])*f(n[1:-1])

Ideone

Özyinelemeli işlev, ilk çağrı üzerine nbir sayıdır, bu nedenle boş dizgiden daha az olarak değerlendirilir if n<''ve işlev tekrar çağırılır, ancak nikili dizgeye dönüştürülür; kuyruk, boş bir dize (hatta bit uzunluğu) ya da boş için doğru dönen orta bittir '1'; aşağı inerken dış bitleri eşitsizlik için test eder (XOR'a eşdeğer) ve iç bitler üzerinde tekrarlar n[1:-1].

Python 2,63 bayt

s=bin(input())[2:]
while s[0]!=s[-1]:s=s[1:-1]or'1'
print'1'==s

TrueVeya yazdırır False. sEşit olmadıkları sürece ilk ve son karakterlerin ikili gösterimini alır ve tekrar tekrar kaldırır. Kalan boş dize mi, yoksa merkezi mi olduğunu kontrol eder 1. Bu, boş dizgede indeks hatası ''oluşmasını da engelleyen '1', sonucun eşit olup olmadığına dönüştürülerek kontrol edilerek yapılır '1'.

PowerShell v2 +, 143 bayt

Her ikisi de aynı bayt sayısı olan iki olası yaklaşım.

Yöntem 1:

param($n)if($n-eq1){$n++}$o=1;0..(($b=($n=[convert]::ToString($n,2)).length-1)/2-!($b%2))|%{$o*=$n[$_]-ne$n[$b-$_]};$o*(+"$($n[$b/2])",1)[$b%2]

$nGerekirse, giriş -eqyapar 1(bu algoritma için özel bir durum), artırın. $oUtput değerini ayarlayın 1(yani, truthy'yi varsayalım), daha sonra ikili 0olarak girilen giriş numarasının orta noktasına kadar döngü yapın [convert]. -!($b%2)Tek uzunluktaki ikili sayıları hesaba katarak not alın .

Her yinelemede, geçerli basamağı $n[$_], sondan itibaren aynı uzunluktaki basamağa göre karşılaştırırız ve $n[$b-$_]Boolean sonucunu çarpın $o(aslında -andhepsinde bir tane yaparak). Döngü bittiğinde, ortadaki ikili basamağın potansiyelini hesaba katmamız gerekir, sonunda sözde üçlü (dizi indekslenmiş $b%2). Bu 1ya 0da boru hattında bırakılmış ve çıktı kapalı.

Yöntem 2:

param($n)for($n=[convert]::ToString($n,2);$n.Length-gt2){if($n[0]-ne$n[-1]){$n=$n[1..($n.Length-2)]}else{0;exit}}($n-join'+'|iex)-eq1-or$n-eq10

Girdiyi alır ve aynı işlemi [convert]ikili sayıya yapar. O zaman ikili dizginin reater han olduğu forsürece bir döngü içerisindeyiz . Biz döngüde olduğunuzda ilk eğer, ve son basamak olan ot qual, kapalı bu iki basamak dilim ve içine yeniden mağaza it . Aksi takdirde, çıktı ve . Biz olayın dışında olduğunuzda, ya var (bir dizi , , , , veya ) ya da iki ikili dize , veya 3 . Bu yüzden, bu iki olasılığı test etmemiz gerekiyor. Birincisi, sonucu birlikte değerlendirip değerlendiririz ve test edilir..length-gt2$n[0]$n[-1]-ne$n$n0exit11,00,11,10,01011-join $n+1(Bu diziler için de geçerlidir 1, 1,0ve 0,1, ama $falsediziler için 0,0ve 1,1ya dizeleri 10ya 11). Diğer yarısı -orolup olmadığını test edilir $nolduğu -equal için 10(yani, giriş 2). Bu Boolean boru hattında bırakıldı ve çıktı kapalı.

CJam , 13 bayt

ri2b_W%.+:*3&

Çevrimiçi deneyin! veya belirli bir sayıya kadar olan katlama numaralarının bir listesini oluşturun .

ri2b   e# convert input to binary
_W%.+  e# flip and sum (if folding all bits are 1 except middle)
:*     e# product is 0 or power of 2 (2 if middle folds)
3&     e# keep only 1 or 2, everything else becomes 0 (false)

MATL , 16 bayt

tBn2/kW&\hBZ}P=~

Truthy, herkesin olduğu bir dizi. Burada truthy / falsy kriterlerini kontrol edin .

Çevrimiçi deneyin! Veya İlk 20 test vakasını doğrulayın .

açıklama

Girdiyi 1644örnek olarak kullanalım .

t     % Imolicitly take input. Duplicate
      %   STACK: 1644, 1644
Bn    % Number of digits of binary expansion
      %   STACK: 1644, 11
2/k   % Divide by 2 and round down
      %   STACK: 1644, 5
W     % 2 raised to that
      %   STACK: 1644, 32
&\    % Divmod
      %   STACK: 12, 51
h     % Concatenate horizontally
      %   STACK: [12 51]
B     % Binary expansion. Each numnber gives a row, left-padded with zeros if needed
      %   STACK: [0 0 1 1 0 0; 1 1 0 0 1 1]
Z}    % Split into rows
      %   STACK: [0 0 1 1 0 0], [1 1 0 0 1 1]
P     % Reverse
      %   STACK: [0 0 1 1 0 0], [1 1 0 0 1 1]
=~    % True for entries that have different elements
      %   STACK: [1 1 1 1 1 1]
      % Implicitly display

PHP, 101 Bayt

for($r=1;$i<($l=strlen($b=decbin($argv[1])))>>1;)$r*=$b[$i]^1^$b[$l-++$i]^1;$r*=$l%2?$b[$i]:1;echo$r;

veya log ile

for($r=1,$s=log($n=$argv[1],2)^0;2*$i<$s;)$r*=($n>>$i)%2^($n>>$s-$i++)%2;$s%2?:$r*=($n>>$i)%2;echo$r;

Dizili 108 Bayt

for($r=1,$a=str_split(decbin($argv[1]));$a;)$r*=array_pop($a)!=($a?array_shift($a):0);$r*=$a?$a[0]:1;echo$r;

Gerçek değerler <10000

1,2,6,10,12,22,28,38,42,52,56,78,90,108,120,142,150,170,178,204,212,232,240,286,310,346,370,412,436,472,496,542,558,598,614,666,682,722,738,796,812,852,868,920,936,976,992,1086,1134,1206,1254,1338,1386,1458,1506,1596,1644,1716,1764,1848,1896,1968,2016,2110,2142,2222,2254,2358,2390,2470,2502,2618,2650,2730,2762,2866,2898,2978,3010,3132,3164,3244,3276,3380,3412,3492,3524,3640,3672,3752,3784,3888,3920,4000,4032,4222,4318,4462,4558,4726,4822,4966,5062,5242,5338,5482,5578,5746,5842,5986,6082,6268,6364,6508,6604,6772,6868,7012,7108,7288,7384,7528,7624,7792,7888,8032,8128,8318,8382,8542,8606,8814,8878,9038,9102,9334,9398,9558,9622,9830,9894

Julia , 66 bayt

c(s)=s==""||s=="1"||(s[1]!=s[end]&&c(s[2:end-1]))
f(x)=c(bin(x))

Benim ilk golf! aynı uzunluktaki Python çözümü ile aynı şekilde çalışır, dilden kaynaklanan küçük farklılıklar (kendi başıma bile yaptım ...).

Açıklama:

c(s) = s == "" || # Base case, we compared all the digits from 
                  # both halves.
       s == "1" || # We compared everything but left a 1 in the middle
       (s[1] != s[end] &&  # First digit neq last digit (XNOR gives 0).
        c(s[2:end-1]))     # AND the XNOR condition is satisfied for the  
                           # 2nd to 2nd to last digit substring.
f(x) = c(bin(x))  # Instead of a string f takes an integer now.

C, 223 201 189 194 178 Bayt

i,j,m,l,r;f(n){for(m=j=1,i=n;i/=2;++j);for(l=r=i=0;i<j/2;i++)r|=n&m?1<<j/2-i-1:0,m*=2;i=(j&1&&n&m)?i+1:(j&1)?l=r:i;n>>=i;for(m=1;i<j;i++)l|=n&m,m*=2;return !(~(l^r)&(1<<j/2)-1);}

Kaba kuvvet algoritması. Bakalım ne kadar golf oynanabiliyor.

Daha iyi test kurulum hata düzeltmeleri ...

 main()
 {
    int t, s, u, testSet[] = 
    {
    1, 2, 6, 10, 12, 22, 28, 38, 42, 52, 56, 78, 90, 108, 120,
    142, 150, 170, 178, 204, 212, 232, 240, 286, 310, 346, 370,
    412, 436, 472, 496, 542, 558, 598, 614, 666, 682, 722, 738,
    796, 812, 852, 868, 920, 936, 976, 992, 1086, 1134, 1206,
    1254, 1338, 1386, 1458, 1506, 1596, 1644, 1716, 1764, 1848,
    1896, 1968, 2016, 2110, 2142, 2222, 2254, 2358, 2390, 2470,
    2502, 2618, 2650, 2730, 2762, 2866, 2898, 2978, 3010, 3132,
    3164, 3244, 3276, 3380, 3412, 3492, 3524, 3640, 3672, 3752,
    3784, 3888, 3920, 4000, 4032, 4222, 4318, 4462, 4558
    };


    for (u=s=0,t=1;t<=4558;t++)
    {
        if (f(t))
        {
          u++;            
          if (testSet[s++]!=t)
              printf("BAD VALUE %d %d\n", testSet[s-1], t);
        }
    }

    printf("%d == %d Success\n", u,
           sizeof(testSet)/sizeof(testSet[0]));

}

MATL , 13 bayt

BttP=<~5Ms2<*

Truthy, herkesin olduğu bir dizi. Burada truthy / falsy kriterlerini kontrol edin .

Çevrimiçi deneyin! Veya ilk 20 test vakasını doğrulayın .

açıklama

Girdiyi 1644örnek olarak kullanmak :

B     % Implicit input. Convert to binary
      %   STACK: [1 1 0 0 1 1 0 1 1 0 0]
t     % Duplicate
      %   STACK: [1 1 0 0 1 1 0 1 1 0 0], [1 1 0 0 1 1 0 1 1 0 0]
tP=   % Element-wise compare each entry with that of the reversed array
      %   STACK: [1 1 0 0 1 1 0 1 1 0 0], [0 0 0 0 0 1 0 0 0 0 0]
<~    % True (1) if matching entries are equal or greater
      %   STACK: [1 1 1 1 1 1 1 1 1 1 1]
5M    % Push array of equality comparisons again
      %   STACK: [1 1 1 1 1 1 1 1 1 1 1], [0 0 0 0 0 1 0 0 0 0 0]
s     % Sum of array
      %   STACK: [1 1 1 1 1 1 1 1 1 1 1], 1
2<    % True (1) if less than 2
      %   STACK: [1 1 1 1 1 1 1 1 1 1 1], 1
*     % Multiply
      %   STACK: [1 1 1 1 1 1 1 1 1 1 1]
      % Implicitly display

JavaScript, 71 bayt

(i,n=i.toString(2))=>/^(1*)2?\1$/.test(+n+ +n.split``.reverse().join``)

Anonim bir işlev tanımlar.

Bu yöntem en kısa olmayabilir, ancak bildiğim kadarıyla benzersizdir. İkilikteki sayıyı tersine çevirir, ondalık sayılır, sonra sonucun bir regex kullanarak geçerli olup olmadığını kontrol eder.

Retina, 92 bayt

Bayt sayısı, ISO 8859-1 kodlamasını varsayar.

.+
$*
+`(1+)\1
${1}0
01
1
^((.)*?)1??((?<-2>.)*$.*)
$1¶$3
O$^`.(?=.*¶)

T`01`10`^.*
^(.*)¶\1

Çevrimiçi deneyin

Birliğe dönüştür. Bunu ikiliye dönüştür. Numarayı ikiye bölün ve 1varsa bir orta işareti kaldırın . İlk yarıyı ters çevirin. Bunları ve sıfırları değiştirin. Her iki yarı da eşit ise maç.

Retina, 71 70 60 bayt

.+
$*
+`^(1*)\1(1?)\b
$1 $.2
+`^ (.)(.*) (?!\1).$
$2
^( 1)?$

Muhtemelen hala Retina hakkında öğrenecek çok şeyim var (örneğin özyinelemeli regex?). Açıklama: Adım 1, ondalıktan birime dönüşür. Adım 2, unary'den sözde binary'e dönüşür. 3. Adım, basamakları uyuşmadıkları sürece her iki uçtan da kaldırır. Dördüncü adım, gerekirse isteğe bağlı bir son merkezi 1 ile eşleşir. Düzenleme: @ mbomb007 sayesinde 1 bayt kaydedildi. Unary - ikili dönüşümümü geliştirerek 10 bayt kurtardı.

Python 2, 61 59 bayt

Vardiyaları çarpımlara dönüştürmek için iki bayt kaydetme

m=n=input()
i=0
while m:i*=2;i+=m&1;m/=2
print(n+i+1)&(n+i)

0Katlama sayısı ve katlanmayan başka herhangi bir şey için döndürür . Bit bükme yaklaşımını kullanır.

C, 65 63 bayt

Vardiyaları çarpımlara dönüştürmek için iki bayt

i,m;
f(n){
 m=n;i=0;
 while(m)i*=2,i+=m&1,m/=2;
 return(n+i+1)&(n+i);
}

Boşluk alanı zaten bayt sayısından çıkarıldı, katlama sayısı için 0, katlanmayan için başka bir şey döndürdü. Bit bükme yaklaşımını kullanır.

k, 77 bayt

{X:2 0N#X@&:|\X:0b\:x;c:#:'X;$[(~*X 1)|(=). c;~|/(=).(::;|:)@'(-&/ c)#'X;0b]}

açıklama yoluyla bir çeviri yoluyla q

{X:2 0N#X where maxs X:0b vs x;
  c:count each X;
  $[(not first last X)or(=). c;
    not any(=).(::;reverse)@'(neg min c)#'X;0b]
  };