Biorąc pod uwagę liczbę, określ, czy jest to liczba składana.

Liczba składana to liczba taka, że ​​jeśli weźmiesz ją jako reprezentację binarną i „złożysz” na pół, to jest wynik mnożenia przez XNOR pierwszej połowy liczby i drugiej połowy z cyframi w odwrotnej kolejności, otrzymasz zero.

Jeśli liczba ma nieparzystą liczbę cyfr binarnych, jej środkowa cyfra musi wynosić 1 i jest ignorowana podczas składania.

Ponieważ może to być nieco mylące, podam kilka przykładów:

178

Binarna reprezentacja 178 to

10110010

Aby to złożyć, najpierw podzielimy na pół

1011 0010

Cofamy drugą połowę

1011
0100

I XNOR dwie połówki:

0000

Jest to zero, więc jest to liczba składana.

1644

Binarna reprezentacja 1644 to

11001101100

Aby to złożyć, najpierw podzielimy na pół

11001 1 01100

Środkowy bit to 1, więc go wyrzucamy.

11001 01100

Cofamy drugą połowę

11001
00110

I XNOR dwie połówki:

00000

Jest to zero, więc jest to liczba składana.

4254

Binarna reprezentacja 4254 to

1000010011110

Aby to złożyć, najpierw podzielimy na pół

100001 0 011110

Środkowy bit to 0, więc nie jest to liczba składana.

Zadanie

Twoim zadaniem jest przyjęcie liczby dodatniej i zwrócenie prawdy, jeśli liczba się składa, i fałsz, jeśli tak nie jest. To jest kod golfowy, więc staraj się odliczać bajty.

Przypadki testowe

Oto pierwsze 99 liczb składanych:

[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]

Galaretka , 9 bajtów

Bœs2µḢ^UȦ

Wypróbuj online! lub zweryfikuj wszystkie przypadki testowe .

Jak to działa

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 bajtów

Kod:

bS2ä`R0¸«s^P

Wykorzystuje kodowanie CP-1252 . Wypróbuj online!

Wyjaśnienie:

Najpierw konwertujemy liczbę na binarną za pomocą b. 1644 staje się 11001101100 . Podzieliliśmy to na dwie części za pomocą 2ä. Na przykład 11001101100 stałby się:

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

Jeśli liczba bitów jest nierówna, pierwsza część otrzyma dodatkowy bit. Mamy Reverse ostatni ciąg i dołączania zero użyciu 0¸«. Powodem tego jest podawanie prawdziwych wyników tylko wtedy, gdy środkowy bit ma wartość 1 ( 1 XOR 0 = 1 i 0 XOR 0 = 0 ). Jeśli nie ma bitu środkowego, 05AB1E zignoruje ostatni bit (zero, które zostało dodane):

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

Ostatnią rzeczą, którą musimy zrobić, to zrobić elementarne XOR i wziąć iloczyn wyniku. Jeśli jest o jeden element za dużo, program po prostu pominie ostatni element ( [1, 0, 0] XOR [0, 1] = [1, 1]) Na przykład:

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

Staje się:

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

A wynikiem tego jest 1 , co jest prawdą.

Java 7, 152 145 142 138 134 bajtów

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;}

Pętle nad ciągiem, tak jak w przypadku palindromu, szukają zer. Śledzi przez wielokrotne mnożenie, więc wszystko, co musisz zrobić, to sprawdzić, czy na końcu nie jest zero.

Bez pasków przewijania:

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 bajtów

Rekurencyjnie oblicza:

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

gdzie Njest ranga najwyższego bitu ustawionego na wejściu.

Jeśli wejście ma nieparzystą liczbę bitów, środkowy bit jest XOR'ed z niezdefiniowaną (wartość zwracana przez pop()pustą tablicę), co pozwala mu pozostać niezmienionym. Tak więc 0środkowy bit usuwa wynik, a 1środkowy bit nie zmienia wyniku innych operacji - co jest zgodne z definicją wyzwania liczby składanej.

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 bajtów

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

Dane wyjściowe za pomocą kodu wyjścia : błąd dla Falsey i brak błędu dla Prawdy.

Konwertuje dane wejściowe na binarne. Sprawdza, czy pierwszy i ostatni znak są nierówne, utrzymuje i powtarza to po usunięciu tych znaków.

Porównanie s[-1]==s[0]<_daje błąd, jeśli pierwszy i ostatni znak są nierówne, próbując ocenić nieprzypisaną zmienną o nazwie _. Jeśli są równe, łańcuch nierówności jest zwarty. Kiedy dojdziemy do środkowego elementu 1, whilepętla kończy się, w specjalnym przypadku jest OK.

Podejrzewam, że podejście czysto arytmetyczne będzie krótsze z rekurencją, taką jak f=lambda n,r=0:...f(n/2,2*r+~n%2)...odrywanie cyfr binarnych od końca odwróconych i odwróconych oraz wykrycie, kiedy ni kiedy rsą równe do środka 1. Istnieją jednak subtelności z wiodącymi zerami i środkiem.

Python 2, 94 79 72 67 bajtów

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

Zaoszczędź 12 bajtów dzięki @xnor

Definiuje nienazwaną funkcję w drugim wierszu.

Objaśnienie (z dodaną białą spacją):

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.

Wypróbuj tutaj!

Haskell, 89 88 86 bajtów

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]

Działa poprzez sumowanie bitowej reprezentacji bitów z jej odwrotnością i pobranie produktu. Jeśli jest to 1 lub 2, liczba jest liczbą składaną (1, jeśli są parzyste bity, które pasują, 2, jeśli są nieparzyste bity i jeden na środku).

Python 2, 100 99 95 94 bajtów

To wydaje się trochę długie, ale będę nad tym pracował :) Drukuje, 1jeśli liczba może zostać złożona, w 0przeciwnym razie.

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]))

^{Sprawdź to tutaj!}

^{dzięki Wheat Wizard za 1-bajtowe zapisywanie :)}

^{dzięki Rod za 5-bajtowe oszczędności! :)}

> <> , 37 + 3 = 40 bajtów

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

Dane wejściowe powinny być obecne na stosie przy starcie programu, więc +3 bajty dla -vflagi.

Wypróbuj online!

Galaretka , 13 bajtów

Bœs2U0¦z0^/€Ạ

TryItOnline
Lub pasujące warunki do 4558

W jaki sposób?

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 bajtów

Obejmuje +1 dla -p

Uruchom z numerem na STDIN

folding.pl <<< 178

folding.pl:

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

Uważam za perlowy błąd, który nawet działa. Wewnętrzne $_nie powinny otrzymywać aktualizacji pozycji dopasowania po modyfikacji. W tym programie pozycja dopasowania faktycznie przesuwa się poza koniec$_

Brachylog , 16 bajtów

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

To nie do końca działa online ...

Pobiera dane wejściowe przez zmienną wejściową i dane wyjściowe w wyniku sukcesu lub niepowodzenia. Jest w dużej mierze oparty na tym języku z₂, który jest używany w języku od 30 kwietnia, ale zapomnieliśmy poprosić o włączenie TIO, więc na razie działa to tylko na lokalnej instalacji języka. Tak czy inaczej jest to prawdopodobnie zbyt naiwne podejście.

                    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 (na TIO), 19 bajtów

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

Wypróbuj online!

lᵛ↖Lzjest funkcjonalnie równoważny z₂(jeśli nie używasz zmiennej L nigdzie indziej), ale jest również trzy bajty dłuższy.

Python 2, 76 71 69 bajtów

-5 bajty dzięki @Dennis ( ''występuje w '1'tak wymienić in('','1')z in'1')
-2 bajty dzięki @xnor (Użyj mnożenia (...)*w miejscu and)

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

Ideone

Funkcja rekurencyjna, przy pierwszym wywołaniu njest liczbą, więc ocenia się ją jako mniejszą niż pusty ciąg, z if n<'', i funkcja jest wywoływana ponownie, ale z nrzutowaniem na ciąg binarny; ogon jest pustym łańcuchem (nawet o długości bitu) lub środkowym, który zwraca wartość true dla pustego lub a '1'; Jest to sposób na dół, to sprawdza zewnętrzne bitów dla nierówność (równoważne XOR) i recurses na wewnętrznych bitów n[1:-1].

Python 2, 63 bajty

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

Odbitki Truelub False. Pobiera binarną reprezentację si wielokrotnie usuwa pierwszy i ostatni znak, o ile są one nierówne. Sprawdza, czy pozostaje pusty ciąg lub centrala 1. Odbywa się to poprzez konwersję ''do '1'i sprawdzenie, czy wynik jest równy '1', co również pozwala uniknąć błędu indeksu na pustym ciągu.

PowerShell v2 +, 143 bajty

Dwa możliwe podejścia, oba o tej samej liczbie bajtów.

Metoda 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]

Zajmuje wejście $n, jeśli jest -eqseksualnego do 1(przypadek szczególny dla tego algorytmu), zwiększać ją. Ustaw $output na 1(tzn. Zakładaj prawdę), a następnie zapętl od 0punktu środkowego liczby wejściowej, która została zmieniona [convert]na binarną. Zwróć -!($b%2)uwagę, aby uwzględnić liczby binarne o nieparzystej długości.

Podczas każdej iteracji porównujemy bieżącą cyfrę $n[$_]z cyfrą o tej samej długości od końca $n[$b-$_]i mnożymy wynik boolowski $o(zasadniczo wykonując -andna wszystkich z nich). Po zakończeniu pętli musimy potencjalnie uwzględnić środkową cyfrę binarną, czyli pseudo-trójkę na końcu (tablica indeksowana przez $b%2). To 1lub 0pozostaje w potoku, a dane wyjściowe są niejawne.

Metoda 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

Pobiera dane wejściowe i wykonuje ten sam proces do [convert]liczby binarnej. Następnie jesteśmy w forpętli, dopóki .lengthłańcuch binarny jest -greater than 2. Kiedy jesteśmy w pętli, jeśli pierwsze $n[0]i ostatnie $n[-1]cyfry to -not equal, pokroić te dwie cyfry off $ni ponownie go do sklepu $n. W przeciwnym razie dane wyjściowe 0i exit. Raz jesteśmy z pętli, nie mamy (tablicę 1, 1,0, 0,1, 1,1, lub 0,0) lub ciąg binarny dla dwóch 10lub 3 11. Musimy więc przetestować te dwie możliwości. Po pierwsze, -join $nwraz z +wynikiem oceniamy go i testujemy1(jest to prawdą dla tablic 1, 1,0i 0,1, ale jest $falsedla tablic 0,0i 1,1czy sznurków 10lub 11). Druga połowa -orbadania polega na sprawdzeniu, czy $njest to -eqprzydatne 10(tj. Wejście 2). To, że wartość logiczna jest pozostawiana w potoku, a dane wyjściowe są niejawne.

CJam , 13 bajtów

ri2b_W%.+:*3&

Wypróbuj online! lub wygeneruj listę liczb składanych do podanej liczby.

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 bajtów

tBn2/kW&\hBZ}P=~

Prawda to tablica ze wszystkimi. Sprawdź kryteria prawdy / fałszu tutaj .

Wypróbuj online! Lub Zweryfikuj pierwsze 20 przypadków testowych .

Wyjaśnienie

1644Jako przykład weźmy dane wejściowe .

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 bajtów

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;

lub z logiem

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;

108 bajtów z tablicą

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;

Prawdziwe wartości <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 bajtów

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

Mój pierwszy golf! działa tak samo jak rozwiązanie Pythona o tej samej długości, z niewielkimi różnicami ze względu na język (ja sam to wymyśliłem ...).

Wyjaśnienie:

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 bajtów

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);}

Algorytm siły brutalnej. Zobaczmy, jak daleko można grać w golfa.

Poprawki błędów konfiguracji testowania ...

 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 bajtów

BttP=<~5Ms2<*

Prawda to tablica ze wszystkimi. Sprawdź kryteria prawdy / fałszu tutaj .

Wypróbuj online! Lub sprawdź pierwsze 20 przypadków testowych .

Wyjaśnienie

Wykorzystując dane wejściowe 1644jako przykład:

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 bajtów

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

Definiuje anonimową funkcję.

Ta metoda może nie jest najkrótsza, ale o ile mi wiadomo, jest wyjątkowa. Dodaje liczbę binarną do siebie odwróconą, traktując je jako dziesiętne, a następnie sprawdzając, czy wynik jest poprawny, używając wyrażenia regularnego.

Siatkówka, 92 bajty

Liczba bajtów zakłada kodowanie ISO 8859-1.

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

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

Wypróbuj online

Konwertuj na unary. Konwertuj to na binarne. Wytnij liczbę na pół i usuń środek, 1jeśli istnieje. Odwróć pierwszą połowę. Przełączaj jedynki i zera. Dopasuj, jeśli obie połowy są równe.

Siatkówka, 71 70 60 bajtów

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

Prawdopodobnie wciąż mam wiele do nauczenia się na temat Retiny (np. Rekursywne wyrażenie regularne?). Objaśnienie: Krok 1 przekształca liczbę dziesiętną w unarną. Krok 2 konwertuje z jednoargumentowego na pseudobinarny. Krok 3 usuwa cyfry z obu końców, o ile są one niezgodne. Krok czwarty dopasowuje opcjonalny końcowy centralny 1, jeśli to konieczne. Edycja: Zapisano 1 bajt dzięki @ mbomb007. Zaoszczędziłem 10 bajtów, ulepszając moją jednoargumentową konwersję do binarnej.

Python 2, 61 59 bajtów

Zapisywanie dwóch bajtów w celu konwersji przesunięć na mnożenia

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

Zwraca 0liczbę składaną i cokolwiek innego za brak składania. Wykorzystuje podejście typu „bit-twiddling”.

C, 65 63 bajtów

Dwa bajty do konwersji przesunięć na mnożenia

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

Biała spacja jest już wykluczona z bajtecount, zwraca 0 dla liczby składanej i cokolwiek innego dla braku składania. Korzysta z metody „kręć nieco bit”.

k, 77 bajtów

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

w celu wyjaśnienia tłumaczenie na 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]
  };