Cho một số xác định nếu nó là một số gấp.

Số gấp là một số sao cho nếu bạn lấy đại diện nhị phân và "gấp" nó thành một nửa, đó là kết quả của phép nhân XNOR của nửa đầu của số và nửa sau với chữ số ngược lại, bạn sẽ nhận được số không.

Nếu số có số lẻ trong các chữ số nhị phân thì chữ số giữa của nó phải là 1 và bị bỏ qua khi gập.

Vì điều đó có thể hơi khó hiểu, tôi sẽ đưa ra một số ví dụ:

178

Đại diện nhị phân của 178 là

10110010

Để gấp nó, trước tiên chúng ta chia nó làm đôi

1011 0010

Chúng tôi đảo ngược nửa thứ hai

1011
0100

Và chúng tôi XUẤT HIỆN hai nửa:

0000

Đây là số không nên đây là một số gấp.

1644

Đại diện nhị phân của 1644 là

11001101100

Để gấp nó, trước tiên chúng ta chia nó làm đôi

11001 1 01100

Bit giữa là 1 vì vậy chúng tôi ném nó ra.

11001 01100

Chúng tôi đảo ngược nửa thứ hai

11001
00110

Và chúng tôi XUẤT HIỆN hai nửa:

00000

Đây là số không nên đây là một số gấp.

4254

Đại diện nhị phân của 4254 là

1000010011110

Để gấp nó, trước tiên chúng ta chia nó làm đôi

100001 0 011110

Bit giữa là 0 nên đây không phải là số gấp.

Bài tập

Nhiệm vụ của bạn là lấy một số dương và trả về một sự thật nếu số đó gấp và sai nếu không. Đây là mã golf, vì vậy hãy cố gắng giữ byte đếm ngược.

Các trường hợp thử nghiệm

Dưới đây là 99 số gấp đầu tiên:

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

Thạch , 9 byte

Bœs2µḢ^UȦ

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

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 byte

Mã số:

bS2ä`R0¸«s^P

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến!

Giải trình:

Đầu tiên, chúng tôi chuyển đổi số thành nhị phân bằng cách sử dụng b. 1644 trở thành 11001101100 . Chúng tôi chia thành hai phần với 2ä. Ví dụ: 11001101100 sẽ trở thành:

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

Nếu có số bit không đồng đều, phần đầu tiên sẽ nhận thêm bit. Chúng tôi Rsử dụng chuỗi cuối cùng và nối số 0 bằng cách sử dụng 0¸«. Lý do cho điều này là chỉ đưa ra kết quả trung thực khi bit giữa là 1 ( 1 XOR 0 = 1 và 0 XOR 0 = 0 ). Nếu không có bit giữa, 05AB1E sẽ bỏ qua bit cuối cùng (số 0 được thêm vào):

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

Điều cuối cùng chúng ta cần làm là thực hiện một XOR phần tử thông minh và lấy sản phẩm của kết quả. Nếu có quá nhiều phần tử, chương trình sẽ bỏ phần tử cuối cùng ra ( [1, 0, 0] XOR [0, 1] = [1, 1]) Ví dụ:

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

Trở thành:

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

Và sản phẩm của nó là 1 , đó là sự thật.

Java 7, 152 145 142 138 134 byte

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

Vòng lặp trên chuỗi như nó sẽ cho một palindrom, tìm kiếm số không. Theo dõi bằng cách nhân lên nhiều lần, vì vậy tất cả những gì bạn phải làm là kiểm tra xem cuối cùng nó không bằng không.

Không có thanh cuộn:

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 byte

Tính toán đệ quy:

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

trong đó Nthứ hạng của bit cao nhất được đặt trong đầu vào.

Nếu đầu vào có số bit lẻ, bit giữa được XOR'ed với không xác định (giá trị được trả pop()về trên một mảng trống), cho phép nó không thay đổi. Vì vậy, một 0bit giữa sẽ xóa đầu ra và một 1bit giữa không làm thay đổi kết quả của các hoạt động khác - phù hợp với định nghĩa thách thức của một số gấp.

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 byte

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

Đầu ra thông qua mã thoát : lỗi cho Falsey và không có lỗi cho Truthy.

Chuyển đổi đầu vào thành nhị phân. Kiểm tra xem ký tự đầu tiên và cuối cùng có bất bình đẳng hay không, giữ và lặp lại điều này sau khi loại bỏ các ký tự đó.

Việc so sánh s[-1]==s[0]<_đưa ra một lỗi nếu ký tự đầu tiên và cuối cùng không bằng nhau bằng cách cố gắng đánh giá biến không được gán có tên _. Nếu chúng bằng nhau, thay vào đó, chuỗi bất đẳng thức sẽ bị ngắn mạch. Khi chúng ta đến phần tử ở giữa 1, whilevòng lặp sẽ kết thúc với trường hợp đặc biệt là OK.

Tôi nghi ngờ một cách tiếp cận số học thuần túy sẽ ngắn hơn với một đệ quy muốn loại f=lambda n,r=0:...f(n/2,2*r+~n%2)...bỏ các chữ số nhị phân từ đầu bị lật và đảo ngược, và phát hiện khi nào nvà rbằng với một trung tâm 1. Có sự tinh tế mặc dù với số không hàng đầu và trung tâm.

Python 2, 94 79 72 67 byte

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

Đã lưu 12 byte nhờ @xnor

Xác định một hàm không tên trên dòng thứ hai.

Giải thích (với một số khoảng trắng được thêm vào):

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.

Hãy thử nó ở đây!

Haskell, 89 88 86 byte

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]

Hoạt động bằng cách tổng hợp bit bit đại diện bit với đảo ngược của nó và lấy sản phẩm. Nếu là 1 hoặc 2, số đó là số gấp (1 nếu có các bit chẵn gấp, 2 nếu có các bit lẻ và một số ở giữa).

Python 2, 100 99 95 94 byte

Điều này cảm thấy hơi dài, nhưng tôi sẽ tiếp tục làm việc với nó :) In 1nếu số có thể được gấp lại, 0nếu không.

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

^{Kiểm tra nó ở đây!}

^{cảm ơn Wheat Wizard vì đã lưu 1 byte :)}

^{cảm ơn Rod vì đã tiết kiệm 5 byte! :)}

> <> , 37 + 3 = 40 byte

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

Đầu vào dự kiến ​​sẽ có mặt trên ngăn xếp khi bắt đầu chương trình, vì vậy +3 byte cho -vcờ.

Hãy thử trực tuyến!

Thạch , 13 byte

Bœs2U0¦z0^/€Ạ

TryItOnline
Hoặc các điều khoản phù hợp lên tới 4558

Làm sao?

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 byte

Bao gồm +1 cho -p

Chạy với số trên STDIN

folding.pl <<< 178

folding.pl:

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

Tôi coi đó là một lỗi perl mà điều này thậm chí hoạt động. Nội bộ $_không nên nhận được cập nhật vị trí phù hợp khi nó được sửa đổi. Trong chương trình này, vị trí trận đấu thực sự vượt quá cuối$_

Brachylog , 16 byte

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

Nó không hoạt động trực tuyến ...

Đưa đầu vào thông qua biến đầu vào và đầu ra thông qua thành công hay thất bại. Nó phụ thuộc rất nhiều vào z₂ngôn ngữ đã có từ ngày 30 tháng 4, nhưng chúng tôi đã quên yêu cầu sử dụng TIO vì vậy hiện tại nó chỉ hoạt động trên bản cài đặt ngôn ngữ địa phương. Dù bằng cách nào, đó có lẽ là một cách tiếp cận quá ngây thơ.

                    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 (trên TIO), 19 byte

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

Hãy thử trực tuyến!

lᵛ↖Lzcó chức năng tương đương với z₂(nếu bạn không sử dụng biến L ở bất kỳ nơi nào khác), nhưng nó cũng dài hơn ba byte.

Python 2, 76 71 69 byte

-5 byte nhờ @Dennis ( ''có mặt trong '1', vì vậy thay thế in('','1')bằng in'1')
-2 byte nhờ @xnor (sử dụng phép nhân, (...)*thay cho and)

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

Ý tưởng

Hàm đệ quy, khi gọi lần đầu tiên nlà một số nên nó đánh giá nhỏ hơn chuỗi rỗng, với if n<''và hàm được gọi lại nhưng được ntruyền thành chuỗi nhị phân; đuôi là một chuỗi rỗng (thậm chí độ dài bit) hoặc bit giữa, trả về true cho rỗng hoặc a '1'; trên đường xuống, nó kiểm tra các bit bên ngoài để tìm bất đẳng thức (tương đương với XOR) và đệ quy trên các bit bên trong , n[1:-1].

Python 2, 63 byte

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

In Truehoặc False. Đưa ra biểu diễn nhị phân svà liên tục loại bỏ các ký tự đầu tiên và cuối cùng miễn là chúng không bằng nhau. Kiểm tra xem những gì còn lại là chuỗi rỗng hoặc trung tâm 1. Điều này được thực hiện bằng cách chuyển đổi ''sang '1'và kiểm tra xem kết quả có bằng không '1', điều này cũng tránh được lỗi chỉ mục trên chuỗi trống.

PowerShell v2 +, 143 byte

Hai cách tiếp cận có thể, cả hai cùng một số byte.

Cách 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]

Đưa đầu vào $n, nếu nó -equal đến 1(trường hợp đặc biệt cho thuật toán này), tăng nó. Đặt $output thành 1(nghĩa là giả sử trung thực), sau đó lặp từ0 điểm giữa của số đầu vào đã được [convert]chuyển thành nhị phân. Lưu ý các -!($b%2)tài khoản cho các số nhị phân có độ dài lẻ.

Mỗi lần lặp, chúng tôi so sánh chữ số hiện tại $n[$_]với chữ số có cùng độ dài từ cuối $n[$b-$_]và nhân kết quả Boolean thành $o(về cơ bản thực hiện một -andtrên tất cả chúng). Khi vòng lặp được thực hiện, chúng ta cần có khả năng tính đến chữ số nhị phân ở giữa, đó là giả thứ ba ở cuối (mảng được lập chỉ mục qua $b%2). Đó 1hay0 được để lại trên đường ống, và đầu ra là ẩn.

Cách 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

Đưa đầu vào và thực hiện cùng một quy trình cho [convert]số thành nhị phân. Sau đó, chúng tôi ở trong một forvòng lặp miễn là .lengthchuỗi nhị phân là -greater than 2. Khi chúng ta đang ở trong vòng lặp, nếu là người đầu tiên $n[0]và cuối cùng $n[-1]chữ số là -not equal, cắt hai chữ số tắt của $nvà tái lưu trữ nó vào $n. Nếu không, đầu ra 0và exit. Khi chúng tôi ra khỏi vòng lặp, chúng ta có thể sở hữu (một mảng 1, 1,0, 0,1, 1,1, hay 0,0), hoặc các chuỗi nhị phân cho hai 10hoặc 3 11. Vì vậy, chúng ta cần kiểm tra hai khả năng đó. Đối với người đầu tiên, chúng tôi-join $n cùng với +và đánh giá kết quả và kiểm tra xem đó là1(điều này đúng với mảng 1, 1,0và 0,1, nhưng là$falsecho mảng 0,0và 1,1hoặc chuỗi 10hoặc 11). Nửa còn lại của -orđang thử nghiệm cho dù $nlà -equal đến 10(ví dụ, đầu vào của 2). Boolean đó được để lại trên đường ống và đầu ra là ẩn.

CJam , 13 byte

ri2b_W%.+:*3&

Hãy thử trực tuyến! hoặc tạo một danh sách các số gấp đến một số đã cho.

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 byte

tBn2/kW&\hBZ}P=~

Truthy là một mảng với tất cả những người. Kiểm tra tiêu chí trung thực / giả mạo ở đây .

Hãy thử trực tuyến! Hoặc Xác minh 20 trường hợp thử nghiệm đầu tiên .

Giải trình

Hãy sử dụng đầu vào 1644làm ví dụ.

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 byte

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;

hoặc với nhật ký

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 byte với mảng

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;

Giá trị thực <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 byte

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

Golf đầu tiên của tôi! hoạt động tương tự như giải pháp Python có cùng độ dài, sự khác biệt nhỏ do ngôn ngữ (mặc dù tôi đã tự mình nghĩ ra nó ...).

Giải trình:

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 byte

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

Thuật toán vũ phu. Chúng ta hãy xem nó có thể được chơi golf bao xa.

Kiểm tra lỗi thiết lập tốt hơn ...

 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 byte

BttP=<~5Ms2<*

Truthy là một mảng với tất cả những người. Kiểm tra tiêu chí trung thực / giả mạo ở đây .

Hãy thử trực tuyến! Hoặc xác minh 20 trường hợp thử nghiệm đầu tiên .

Giải trình

Sử dụng đầu vào 1644làm ví dụ:

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 byte

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

Xác định một hàm ẩn danh.

Phương pháp này có thể không phải là ngắn nhất, nhưng theo tôi biết, nó là duy nhất. Nó thêm số nhị phân vào chính nó đảo ngược, coi chúng là số thập phân, sau đó kiểm tra xem kết quả có hợp lệ hay không bằng cách sử dụng biểu thức chính quy.

Võng mạc, 92 byte

Số lượng byte giả định mã hóa ISO 8859-1.

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

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

Dùng thử trực tuyến

Chuyển đổi sang unary. Chuyển đổi nó thành nhị phân. Cắt số một nửa và loại bỏ một giữa 1nếu có. Đảo ngược nửa đầu. Chuyển đổi số không và số không. Khớp nếu cả hai nửa bằng nhau.

Võng mạc, 71 70 60 byte

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

Tôi có lẽ vẫn còn nhiều điều để tìm hiểu về Retina (ví dụ regex đệ quy?). Giải thích: Bước 1 chuyển đổi từ thập phân sang đơn nguyên. Bước 2 chuyển đổi từ unary sang giả nhị phân. Bước 3 loại bỏ các chữ số từ cả hai đầu miễn là chúng không khớp. Bước bốn phù hợp với một trung tâm cuối cùng tùy chọn 1 nếu cần thiết. Chỉnh sửa: Đã lưu 1 byte nhờ @ mbomb007. Đã lưu 10 byte bằng cách cải thiện chuyển đổi unary sang nhị phân của tôi.

Python 2, 61 59 byte

Lưu hai byte để chuyển đổi ca làm nhân

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

Trả về 0cho một số gấp và bất cứ điều gì khác cho không gấp. Sử dụng cách tiếp cận twiddling.

C, 65 63 byte

Hai byte để chuyển đổi ca sang phép nhân

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

Khoảng trắng đã được loại trừ khỏi bytecount, trả về 0 cho số gấp và bất kỳ thứ gì khác cho không gấp. Sử dụng cách tiếp cận twiddling.

k, 77 byte

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

bằng cách giải thích, một bản dịch cho 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]
  };