주어진 숫자는 그것이 접는 숫자인지 결정합니다.

접는 숫자는 이진 표현을 가져 와서 반으로 "접는"경우, 숫자의 첫 번째 절반과 두 번째 절반의 숫자를 거꾸로 XNOR 곱한 결과를 얻습니다. 제로.

이진수에 홀수의 자릿수가있는 경우 중간 자릿수는 1이어야하고 접을 때 무시됩니다.

약간 혼란 스러울 수 있으므로 몇 가지 예를 들겠습니다.

178

178의 이진 표현은

10110010

이것을 접으려면 먼저 반으로 나눕니다

1011 0010

후반전 반전

1011
0100

그리고 우리는 두 반쪽을 XNOR :

0000

이것은 0이므로 접는 숫자입니다.

1644

1644의 이진 표현은

11001101100

이것을 접으려면 먼저 반으로 나눕니다

11001 1 01100

중간 비트는 1이므로 버리십시오.

11001 01100

후반전 반전

11001
00110

그리고 우리는 두 반쪽을 XNOR :

00000

이것은 0이므로 접는 숫자입니다.

4254

4254의 이진 표현은

1000010011110

이것을 접으려면 먼저 반으로 나눕니다

100001 0 011110

중간 비트는 0이므로 접는 숫자가 아닙니다.

태스크

당신의 임무는 양수를 취하고 숫자가 접 히면 거짓을 반환하고 그렇지 않으면 거짓을 반환하는 것입니다. 이것은 코드 골프이므로 바이트 카운트를 줄이십시오.

테스트 사례

처음 99 개의 접는 숫자는 다음과 같습니다.

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

젤리 , 9 바이트

Bœs2µḢ^UȦ

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

작동 원리

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 바이트

암호:

bS2ä`R0¸«s^P

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

설명:

먼저을 사용하여 숫자를 이진수로 변환합니다 b. 1644 는 11001101100이 됩니다. 우리는 이것을 두 조각으로 나누었습니다 2ä. 예를 들어 11001101100 은 다음과 같습니다.

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

고르지 않은 비트 수가 있으면 첫 번째 부분에 추가 비트가 수신됩니다. 우리 R는 마지막 문자열을 찾아서를 사용하여 0을 추가합니다 0¸«. 그 이유는 중간 비트가 1 ( 1 XOR 0 = 1 및 0 XOR 0 = 0 ) 일 때만 사실적인 결과를 제공하기위한 것입니다 . 중간 비트가 없으면 05AB1E는 마지막 비트 (추가 된 0) 만 무시합니다.

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

마지막으로해야 할 일은 요소 별 XOR 을 수행하고 결과의 결과를 얻는 것입니다. 하나의 요소가 너무 많으면 프로그램은 마지막 요소 만 남겨 둡니다 ( [1, 0, 0] XOR [0, 1] = [1, 1]). 예를 들면 다음과 같습니다.

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

된다 :

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

그리고 그것의 곱은 1 입니다.

Java 7, 152145142138134 바이트

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

회문에서와 같이 문자열을 반복하여 0을 찾습니다. 반복적으로 곱하여 추적을 유지하므로 마지막에 0이 아닌지 확인하기 만하면됩니다.

스크롤 바가없는 경우 :

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

자바 스크립트 (ES6), 61 57 52 바이트

재귀 적으로 계산 :

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

여기서 N입력에서 설정된 최고 비트의 순위입니다.

입력에 홀수의 비트가있는 경우 중간 비트는 정의되지 않은 ( pop()빈 배열에서 반환 된 값 ) XOR되어 변경되지 않습니다. 따라서 0중간 비트는 출력을 지우고 1중간 비트는 다른 연산의 결과를 변경하지 않습니다. 이는 접는 숫자의 챌린지 정의와 일치합니다.

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

파이썬 2, 57 바이트

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

종료 코드를 통한 출력 : Falsey의 경우 오류, Truthy의 경우 오류 없음.

입력을 이진으로 변환합니다. 첫 문자와 마지막 문자가 다른지 확인하고 해당 문자를 제거한 후 계속 반복합니다.

s[-1]==s[0]<_이름이 지정되지 않은 변수를 평가하여 첫 번째 문자와 마지막 문자가 동일하지 않은 경우 비교 에서 오류가 발생합니다 _. 동일하면 불평등 체인이 대신 단락됩니다. 의 중간 요소에 도달 1하면 while루프가 특수 사례로 종료되어 OK로 바뀝니다.

나는 f=lambda n,r=0:...f(n/2,2*r+~n%2)...뒤집어지고 뒤집힌 끝에서 이진수를 잘라 내고 중심이 될 때 n와 r같은 시간을 감지하는 것과 같은 재귀로 순수한 산술 접근 방식이 더 짧을 것이라고 생각합니다 1. 선행 0과 중심에는 미묘함이 있습니다.

파이썬 2, 94 79 72 67 바이트

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

@xnor 덕분에 12 바이트 절약

두 번째 줄에 이름없는 함수를 정의합니다.

설명 (일부 공백이 추가 된 상태) :

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.

여기 사용해보십시오 !

하스켈, 89 88 86 바이트

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]

비트 표현을 비트 단위를 역수로 합산하고 곱하는 방식으로 작동합니다. 1 또는 2이면 숫자는 접는 숫자입니다 (접는 비트가있는 경우 1, 홀수 비트가있는 경우 2, 중간에 1이있는 경우).

파이썬 2, 100 99 95 94 바이트

이것은 조금 오래 느껴지지만 계속 노력하겠습니다 :) 1숫자를 접을 수 있으면 a를 인쇄합니다 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]))

^{여기에서 테스트 하십시오!}

^{1 바이트 저장을위한 Wheat Wizard 덕분에 :)}

^{5 바이트 절약을위한 Rod에 감사합니다! :)}

> <> , 37 + 3 = 40 바이트

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

프로그램 시작시 스택에 입력이있을 것으로 예상되므로 -v플래그에 +3 바이트가 사용 됩니다.

온라인으로 사용해보십시오!

젤리 , 13 바이트

Bœs2U0¦z0^/€Ạ

TryItOnline
또는 최대 4558 개의 일치하는 용어

어떻게?

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?

펄, 46 바이트

에 +1 포함 -p

STDIN의 숫자로 실행

folding.pl <<< 178

folding.pl:

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

나는 이것이 심지어 작동하는 펄 버그라고 생각합니다. 내부 $_는 일단 수정 된 경기 위치 업데이트를받지 않아야합니다. 이 프로그램에서 경기 위치는 실제로$_

Brachylog , 16 바이트

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

온라인에서 작동하지 않습니다 ...

입력 변수를 통해 입력을 받고 성공 또는 실패를 통해 출력합니다. 이 z₂언어는 4 월 30 일 이후로 언어 에 크게 의존 했지만 TIO를 가져 와서 언어의 로컬 설치에서만 작동하도록 요청했습니다. 어느 쪽이든 그것은 아마도 지나치게 순진한 접근법 일 것입니다.

                    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), 19 바이트

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

온라인으로 사용해보십시오!

lᵛ↖Lz기능적으로 z₂(다른 곳에서 변수 L을 사용하지 않으면) 3 바이트 더 깁니다.

파이썬 2, 76 71 69 바이트

-5 @Dennis 덕분에 (바이트 ''본로되어 '1'있으므로 대체 in('','1')하여 in'1')
-2- (사용 승산 @xnor 덕분 바이트 (...)*대신에 and)

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

이데온

재귀 함수는 처음 호출 n할 때 숫자이므로 빈 문자열보다 작은 것으로 평가 if n<''하고를 사용하여 함수를 다시 호출하지만 n이진 문자열 로 캐스트합니다. 꼬리는 빈 문자열 (비트 길이) 또는 중간 비트이며, 비어 있거나 a에 대해 true를 반환합니다 '1'. 그 과정에서 외부 비트의 불평등 (XOR과 동일)을 테스트하고 내부 비트에서 반복됩니다 n[1:-1].

파이썬 2, 63 바이트

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

인쇄 True또는 False. s첫 번째 문자와 마지막 문자가 동일하지 않은 한 이진 표현을 취하여 반복적으로 제거합니다. 남아있는 것이 빈 문자열인지 아니면 중앙인지 검사합니다 1. 이것은 변환하여 수행됩니다 ''에 '1'그 결과가 동일한 경우 체크 '1'도 빈 문자열에 인덱스 오류를 방지한다.

PowerShell v2 +, 143 바이트

동일한 바이트 수 모두 가능한 두 가지 접근 방식.

방법 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]

입력을 받아, $n그것의 경우 -eq에 연간를 1(이 알고리즘의 특별한 경우)을 증가. $output을 1true 로 설정 한 다음, 이진수 0로 입력 된 입력 번호의 중간 지점으로 반복 [convert]합니다. -!($b%2)홀수 길이 이진수를 설명하려면를 참고하십시오 .

반복 할 때마다 현재 자릿수 $n[$_]를 끝에서 같은 길이의 자릿수 와 비교하고 $n[$b-$_]부울 결과에 $o(본질적 -and으로 모두 수행) 부울 결과를 곱합니다 . 루프가 완료되면 잠재적으로 중간 이진수를 고려할 필요가 있습니다. 이는 마지막에 의사 삼항입니다 (배열은 via를 통해 색인화 됨 $b%2). 그 1또는 0파이프 라인에 남아 있고 출력은 암시 적입니다.

방법 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

입력을 받아서 [convert]이진수로 같은 프로세스를 수행 합니다. 그런 다음 이진 문자열 중 하나가 reater han 인 한 for루프에 있습니다. 우리가 루프에있을 때 첫 번째 경우 와 마지막 숫자는 구약 QUAL, 떨어져 두 자리 숫자를 슬라이스 와에 다시 가게를 . 그렇지 않으면 출력 및 . 우리가 루프 밖으로 들어가면, 우리는 하나가 (의 배열을 , , , , 또는 ), 또는 두 이진 문자열 , 또는 3 . 따라서이 두 가지 가능성을 테스트해야합니다. 첫 번째로, 우리 는 결과와 함께 평가하고 결과가.length-gt2$n[0]$n[-1]-ne$n$n0exit11,00,11,10,01011-join $n+1(배열 1, 1,0및 0,1에는 해당하지만 $false배열 0,0및 1,1/ 또는 문자열에 대해서는 10또는 11)에 해당합니다. 나머지 절반 은 ual (즉, 입력 ) -or인지 테스트합니다 . 해당 부울은 파이프 라인에 남아 있으며 출력은 암시 적입니다.$n-eq102

CJam , 13 바이트

ri2b_W%.+:*3&

온라인으로 사용해보십시오! 또는 주어진 숫자까지 접는 숫자 목록 을 생성합니다 .

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 바이트

tBn2/kW&\hBZ}P=~

Truthy는 모든 것을 가진 배열입니다. 진실 / 거짓 기준을 확인 하십시오 .

온라인으로 사용해보십시오! 또는 처음 20 개의 테스트 사례를 확인하십시오 .

설명

입력 1644을 예로 들어 봅시다 .

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 바이트

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;

또는 로그

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 바이트

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;

참값 <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

줄리아 , 66 바이트

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

내 첫 골프! 같은 길이의 파이썬 솔루션과 같은 방식으로 작동합니다. 언어로 인해 약간의 차이가 있습니다 (하지만 자체적으로 생각해 냈습니다 ...).

설명:

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 바이트

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

무차별 대입 알고리즘. 얼마나 멀리 골프를 칠 수 있는지 봅시다.

더 나은 테스트 설정 버그 수정 ...

 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 바이트

BttP=<~5Ms2<*

Truthy는 모든 것을 가진 배열입니다. 진실 / 거짓 기준을 확인 하십시오 .

온라인으로 사용해보십시오! 또는 처음 20 개의 테스트 사례를 확인하십시오 .

설명

입력 1644을 예로 사용 :

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

자바 스크립트, 71 바이트

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

익명 함수를 정의합니다.

이 방법은 가장 짧지는 않지만 내가 아는 한 고유합니다. 이진수로 된 숫자를 뒤집어 10 진수로 처리 한 다음 정규식을 사용하여 결과가 유효한지 확인합니다.

레티 나, 92 바이트

바이트 수는 ISO 8859-1 인코딩을 가정합니다.

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

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

온라인으로 사용해보십시오

단항으로 변환합니다. 이진으로 변환하십시오. 숫자를 반으로 자르고 중간이 1있으면 제거하십시오 . 전반부를 반전시킵니다. 1과 0을 바꾸십시오. 두 반쪽이 같으면 일치합니다.

망막, 71 70 60 바이트

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

아마 여전히 Retina에 대해 배울 것이 많습니다 (예 : 재귀 정규식?). 설명 : 1 단계는 10 진수를 단항으로 변환합니다. 2 단계는 단항에서 의사 이진으로 변환합니다. 3 단계는 일치하지 않는 한 양 끝에서 숫자를 제거합니다. 4 단계는 필요한 경우 선택적 최종 중앙 1과 일치합니다. 편집 : @ mbomb007 덕분에 1 바이트가 절약되었습니다. 단항을 이진으로 변환하여 10 바이트를 절약했습니다.

파이썬 2, 61 59 바이트

시프트를 곱셈으로 변환하기 위해 2 바이트 저장

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

0접는 숫자와 접히지 않는 다른 값을 반환 합니다. 비트 트위들 링 방식을 사용합니다.

C, 65 63 바이트

시프트를 곱셈으로 변환하기위한 2 바이트

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

공백은 바이트 수에서 이미 제외되어 있으며 접는 숫자의 경우 0을, 접지 않는 경우에는 0을 반환합니다. 비트 트위들 링 방식을 사용합니다.

k, 77 바이트

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

설명으로, 번역 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]
  };