여기에 접는 숫자를 이미 정의했습니다 .

그러나 이제 우리는 슈퍼 폴딩 번호를 정의 할 것입니다. 수퍼 폴딩 수는 접을 수있는 횟수가 2의 제곱보다 적은 1에 도달하는 숫자입니다. 접는 방법은 접는 숫자 질문과 약간 다릅니다.

폴딩 알고리즘은 다음과 같습니다.

• 이진 표현을

  예 : 5882

  1011011111010
  

• 그것을 3 개의 칸막이에 쏟았습니다. 전반, 마지막 반 및 중간 자릿수 (홀수의 자릿수가있는 경우)

  101101 1 111010
  

• 중간 자릿수가 0이면이 숫자를 접을 수 없습니다

• 후반전 반전 후반전 중첩

  010111
  101101
  

• 자리를 추가하십시오

  111212
  

• 결과에 2가 있으면 숫자를 접을 수 없으며, 그렇지 않으면 새 숫자는 접는 알고리즘의 결과입니다.

연속 된 문자열로 접을 수있는 경우 숫자는 슈퍼 접기 숫자입니다. (모든 접는 숫자는 슈퍼 접는 숫자이기도합니다)

당신의 작업은 숫자를 사용하고 숫자가 슈퍼 폴딩 숫자이면 거짓 값을 출력하고 그렇지 않으면 거짓 값을 출력하는 코드를 작성하는 것입니다. 프로그램 규모에 따라 점수가 매겨집니다.

예

5200

이진으로 변환 :

1010001010000

반으로 나누기 :

101000 1 010000

중간은 하나이므로 우리는 절반을 중첩합니다.

000010
101000

그들을 추가했습니다 :

101010

둘이 없으므로 우리는 계속 반으로 나눕니다.

101 010

겹:

010
101

111

결과는 111(십진수 7)이므로 이것은 슈퍼 폴딩 숫자입니다.

테스트 사례

처음 100 개의 슈퍼 폴딩 번호는 다음과 같습니다.

[1, 2, 3, 6, 7, 8, 10, 12, 15, 20, 22, 28, 31, 34, 38, 42, 48, 52, 56, 63, 74, 78, 90, 104, 108, 120, 127, 128, 130, 132, 142, 150, 160, 170, 178, 192, 204, 212, 232, 240, 255, 272, 274, 276, 286, 310, 336, 346, 370, 400, 412, 436, 472, 496, 511, 516, 518, 524, 542, 558, 580, 598, 614, 640, 642, 648, 666, 682, 704, 722, 738, 772, 796, 812, 852, 868, 896, 920, 936, 976, 992, 1023, 1060, 1062, 1068, 1086, 1134, 1188, 1206, 1254, 1312, 1314, 1320, 1338, 1386, 1440, 1458, 1506, 1572, 1596]

코드 골프에서 처음으로 촬영 한 내용은 다음과 같습니다.

파이썬 3, 167 바이트

들여 쓰기에 탭 또는 단일 공백을 사용하는 경우 167 바이트

def f(n):
 B=bin(n)[2:];L=len(B);M=L//2
 if'1'*L==B:return 1
 S=str(int(B[:M])+int(B[:-M-1:-1]))
 return 0if(~L%2==0and'0'==B[M])or'2'in S else{S}=={'1'}or f(int(S,2))

편집 : 아래의 모든 사람들의 도움 덕분에 위의 코드는 원래 크기 232 바이트에서 줄었습니다!

자바 7, 202 바이트

boolean g(Integer a){byte[]b=a.toString(a,2).getBytes();int i=0,l=b.length,o=0,c,z=(a+1&a)==0?-1:1;for(;i<l/2&z>0;o+=o+c*2,z*=c>1|(l%2>0&b[l/2]<49)?0:1)c=b[i]+b[l-++i]-96;return z<0?1>0:z<1?0>1:g(o/2);}

이전 폴딩 기능을 반복 가능하게 만드는 데 약간의 노력이 필요했지만 여기에 있습니다. 정직한 것은 죄악과 같지 않습니다. 나는 지금 그것을보기 위해 간신히 서있을 수 있기 때문에 더 골프를 칠 수 있는지 아침에 봐야 할 것이다.

줄 바꿈으로 :

boolean g(Integer a){
    byte[]b=a.toString(a,2).getBytes();
    int i=0,l=b.length,o=0,c,z=(a+1&a)==0?-1:1;
    for(;i<l/2&z>0;o+=o+c*2,z*=c>1|(l%2>0&b[l/2]<49)?0:1)
        c=b[i]+b[l-++i]-96;
    return z<0?1>0:z<1?0>1:g(o/2);
}

CJam , 47 44 바이트

ri2b{_W%.+__0e=)\_,1>\0-X+:*3<*&}{_,2/<}w2-!

온라인으로 사용해보십시오! 또는 주어진 숫자까지 슈퍼 폴딩 숫자 의 목록 을 생성합니다 .
골프 시도는 여기에서 볼 수 있습니다 .

코드는 다음 단계로 분류됩니다.

ri2b                e# get input in binary
{                   e# While fold is legal
 _W%.+_             e#   "fold" the whole number onto itself
 _0e=)\             e#   count zeros and add 1 (I)
 _,1>\              e#   size check, leave 0 if singleton (II)*
 0-X+:*3<           e#   product of 2s, leave 0 if too many (III)
 *&                 e#   (II AND III) AND parity of I
}{                  e# Do
 _,2/<              e#   slice opposite to the actual fold**
}w                  e# End while
2-!                 e# return 1 if "fold" ended in all 2s

편집 : 이 버전은 다소 이전 버전에 De Morgan 's Law 접근 방식을 취합니다 .

* 싱글 톤에서 실행하는 문제는 슬라이스 후 빈 문자열로 고정된다는 것입니다.

** 이진수가 슈퍼 폴딩 인 경우 미러 이미지 (필요한 경우 앞에 0이 있음)입니다. 이것은 오른쪽 절반을 차지하는 것보다 바이트를 절약합니다.

자바 스크립트, 149 바이트

f=(i,n=i.toString(2),l=n.length,m=l/2|0)=>/^1*$/.test(n)?1:/[^01]/.test(n)|!+n[m]&l?0:f(0,+n.slice(0,m)+ +n.slice(m+l%2).split``.reverse().join``+"")

재귀 함수를 정의합니다.

설명:

f=(i                       //Defines the function: i is input
,n=i.toString(2)           //n is the current number
,l=n.length                //l is the length of the number,
,m=l/2|0)=>                //m is the index of the center character
/^1*$/.test(n)?1:          //returns 1 if the number is all ones
/[^01]/.test(n)            //returns 0 if the number has any chars other than 0 or 1
|!+n[m]&l?0:               //or if the middle char is 0
f(0,+n.slice(0,m)+ +n.slice(m+l%2).split``.reverse().join``+"")
                           //otherwise recurses using the first half of the number plus the second half

자바 스크립트 (ES6) 113 109 108 바이트

f=(n,[h,...r]=n.toString(2),b='')=>++n&-n-n?h?f(2,r,r[0]?b+(h- -r.pop()):+h?b:2):!isNaN(n=+('0b'+b))&&f(n):1

형식화 및 의견

f = (                               // given:
  n,                                // - n = integer to process
  [h, ...r] = n.toString(2),        // - h = highest bit, r = remaining low bits
  b = ''                            // - b = folded binary string
) =>                                //
  ++n & -n - n ?                    // if n is not of the form 2^N - 1:
    h ?                             //   if there's still at least one bit to process:
      f(                            //     do a recursive call with:
        2,                          //     - n = 2 to make the 2^N - 1 test fail
        r,                          //     - r = remaining bits
        r[0] ?                      //     - if there's at least one remaining low bit:
          b + (h - -r.pop())        //       append sum of highest bit + lowest bit to b
        : +h ? b : 2                //       else, h is the middle bit: let b unchanged
      )                             //       if it is set or force error if it's not
    : !isNaN(n = +('0b' + b)) &&    //   else, if b is a valid binary string:
      f(n)                          //     relaunch the entire process on it
  : 1                               // else: n is a super folding number -> success

데모

f=(n,[h,...r]=n.toString(2),b='')=>++n&-n-n?h?f(2,r,r[0]?b+(h- -r.pop()):+h?b:2):!isNaN(n=+('0b'+b))&&f(n):1

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

// testing integers in [1500 .. 1599]
for(var i = 1500; i < 1600; i++) {
  f(i) && console.log(i);
}

펄, 71 70 바이트

에 +1 포함 -p

STDIN에 번호를주십시오

superfolding.pl:

#!/usr/bin/perl -p
$_=sprintf"%b",$_;s%.%/\G0$/?2:/.\B/g&&$&+chop%eg while/0/>/2/;$_=!$&

파이썬 2, 151 바이트

f=lambda n,r=0:f(bin(n)[2:],'')if r<''else(r==''and{'1'}==set(n)or(n in'1'and f(r,'')+2)or n!='0'and'11'!=n[0]+n[-1]and f(n[1:-1],r+max(n[0],n[-1])))%2

이데온

정수, 걸리는 이중 재귀 함수 n, 반환 0또는 1.

r접는 결과와 현재 우리가 알고 있는지 알 수 있도록 변수 가 유지됩니다. 접을 수있는 새로운 이진 문자열이 있습니다 (외부). 접거나 (내부)

첫 번째 패스 에서는 파이썬 2에 n있는 정수와 정수 <''이므로 이진 문자열로 캐스팅하여 재귀가 시작됩니다.

다음 실행은 s 의 연속 문자열을 확인하기 위해 r=''테스트 {'1'}==set(n)가 실행됩니다 1(RSS는 {n}나중에이 지점을 통과해야 할 수도 없으므로 r=''빈 세트는 n같지 않은 사전 일 때 비워 둘 수 없습니다 {'1'}).

이것이 충족되지 않으면 내부 테일 기준이 테스트됩니다 (필요한 경우에도) : 비어있는 문자열이거나 단일 인 n in'1'경우 True로 평가되는 경우 , 접힌 이진 문자열을 삽입하여 새 외부 재귀를 시작 합니다. 과 에 . 리터럴 은이 함수 호출 결과에 추가되어 나중에 수정 되는 다음 부분 (논리 오른쪽)으로 넘어 가지 않도록 합니다.n1rn''r2or

그는 truthy 값 ( '0'이 아닌 정수는 파이썬에서 truthy 있습니다) 외부 꼬리 재귀 기준이 테스트되어 있지 않은 경우 n!=0제외 중간의 경우 0와 외부 두 글자들이에 합산하지 않는 테스트 2문자열 연결로는 '11'!=n[0]+n[-1]; 이들 모두가 성립하는 경우, 외부로부터 비트 폐기 n와 n[1:-1], 다음이 1추가되고 r, 그렇지 않으면 외부에 존재하는 경우 0해당 사실을 이용하여 인 '1'>'0'으로 파이썬 max(n[0],n[-1]).

마지막으로 2각 내부 재귀 의 추가 는로 수정됩니다 %2.

PHP, 113 바이트

for($n=$argv[1];$n!=$c;$n=($a=$n>>.5+$e)|($b=$n&$c=(1<<$e/=2)-1))if($a&$b||($e=1+log($n,2))&!(1&$n>>$e/2))die(1);

1인수가 슈퍼 폴딩이 아닌 경우 오류 (code )로 종료하고 0다른 코드를 작성하십시오 . 로 실행하십시오 -r.
입력 0은 true (code 0)를 반환합니다 .

고장

for($n=$argv[1];            
    $n!=$c;                 // loop while $n is != mask
                            // (first iteration: $c is null)
    $n=                     // add left half and right half to new number
        ($a=$n>>.5+$e)      // 7. $a=left half
        |
        ($b=$n&             // 6. $b=right half
            $c=(1<<$e/=2)-1 // 5. $c=mask for right half
        )
)
    if($a&$b                // 1. if any bit is set in both halves
                            // (first iteration: $a and $b are null -> no bits set)
        ||                  // or
        ($e=1+log($n,2))    // 2. get length of number
        &
        !(1&$n>>$e/2)       // 3. if the middle bit is not set -> 1
                            // 4. tests bit 0 in length --> and if length is odd
    )
    die(1);                 // -- exit with error

PHP, 197 바이트

function f($b){if(!$b)return;if(!strpos($b,"0"))return 1;for($n="",$i=0;$i<($l=strlen($b))>>1;)$n.=$b[$i]+$b[$l-++$i];if($l%2&&!$b[$i]||strstr($n,"2"))return;return f($n);}echo f(decbin($argv[1]));

넓히는

function f($b){
    if(!$b)return; # remove 0
    if(!strpos($b,"0"))return 1; # say okay alternative preg_match("#^1+$#",$b)
    for($n="",$i=0;$i<($l=strlen($b))>>1;)$n.=$b[$i]+$b[$l-++$i]; #add first half and second reverse
    if($l%2&&!$b[$i]||strstr($n,"2"))return; #if middle == zero or in new string is a 2 then it's not a number that we search
    return f($n); #recursive beginning
}
echo f(decbin($argv[1]));

참값 <10000

1, 2, 3, 6, 7, 8, 10, 12, 15, 20, 22, 28, 31, 34, 38, 42, 48, 52, 56, 63, 74, 78, 90, 104, 108, 120, 127, 128, 130, 132, 142, 150, 160, 170, 178, 192, 204, 212, 232, 240, 255, 272, 274, 276, 286, 310, 336, 346, 370, 400, 412, 436, 472, 496, 511, 516, 518, 524, 542, 558, 580, 598, 614, 640, 642, 648, 666, 682, 704, 722, 738, 772, 796, 812, 852, 868, 896, 920, 936, 976, 992, 1023, 1060, 1062, 1068, 1086, 1134, 1188, 1206, 1254, 1312, 1314, 1320, 1338, 1386, 1440, 1458, 1506, 1572, 1596, 1644, 1716, 1764, 1824, 1848, 1896, 1968, 2016, 2047, 2050, 2054, 2058, 2064, 2068, 2072, 2110, 2142, 2176, 2180, 2184, 2222, 2254, 2306, 2320, 2358, 2390, 2432, 2470, 2502, 2562, 2576, 2618, 2650, 2688, 2730, 2762, 2866, 2898, 2978, 3010, 3072, 3076, 3080, 3132, 3164, 3244, 3276, 3328, 3380, 3412, 3492, 3524, 3584, 3640, 3672, 3752, 3784, 3888, 3920, 4000, 4032,4095, 4162, 4166, 4170, 4176, 4180, 4184, 4222, 4318, 4416, 4420, 4424, 4462, 4558, 4674, 4688, 4726, 4822, 4928, 4966, 5062, 5186, 5200, 5242, 5338, 5440, 5482, 5578, 5746, 5842, 5986, 6082, 6208, 6212, 6216, 6268, 6364, 6508, 6604, 6720, 6772, 6868, 7012, 7108, 7232, 7288, 7384, 7528, 7624, 7792, 7888, 8032, 8128, 8191, 8202, 8206, 8218, 8232, 8236, 8248, 8318, 8382, 8456, 8460, 8472, 8542, 8606, 8714, 8744, 8814, 8878, 8968, 9038, 9102, 9218, 9222, 9234, 9248, 9252, 9264, 9334, 9398, 9472, 9476, 9488, 9558, 9622, 9730, 9760, 9830, 9894, 99848128, 8191, 8202, 8206, 8218, 8232, 8236, 8248, 8318, 8382, 8456, 8460, 8472, 8542, 8606, 8714, 8744, 8814, 8878, 8968, 9038, 9102, 9218, 9222, 9234, 9248, 9252, 9264, 9334, 9398, 9472, 9476, 9488, 9558, 9622, 9730, 9760, 9830, 9894, 99848128, 8191, 8202, 8206, 8218, 8232, 8236, 8248, 8318, 8382, 8456, 8460, 8472, 8542, 8606, 8714, 8744, 8814, 8878, 8968, 9038, 9102, 9218, 9222, 9234, 9248, 9252, 9264, 9334, 9398, 9472, 9476, 9488, 9558, 9622, 9730, 9760, 9830, 9894, 9984