이진 표현에 선행 0을 무시하고 1s보다 많은 s가 포함되어 있으면 정수는 이진 중 0입니다. 예를 들어 1은 이진 표현이 단순하기 때문에 이진-무거 우지 1만 4는 이진 표현이이므로 이진 헤비가 아닙니다 100. 동점 (예 : 2, 이진 표현 10)이있는 경우 숫자는 이진으로 간주되지 않습니다.

양의 정수를 입력으로 받으면 이진이 많은 경우 참 값을 출력하고 그렇지 않으면 거짓 값을 출력합니다.

테스트 케이스

체재: input -> binary -> output

1          ->                                1 -> True
2          ->                               10 -> False
4          ->                              100 -> False
5          ->                              101 -> True
60         ->                           111100 -> True
316        ->                        100111100 -> True
632        ->                       1001111000 -> False
2147483647 ->  1111111111111111111111111111111 -> True
2147483648 -> 10000000000000000000000000000000 -> False

채점

이것은 코드 골프 이므로 각 언어에서 가장 적은 바이트 가 승리합니다.

x86 기계 코드, 15 14 바이트

F3 0F B8 C1 0F BD D1 03 C0 42 2B D0 D6 C3

이것은 Microsoft의 __fastcall 호출 규칙 (ecx의 첫 번째 유일한 매개 변수, eax의 반환 값, 수신자가 edx를 클로버 할 수 있음)을 사용하는 함수이지만 레지스터에서 인수를 전달하는 다른 호출 규칙에 대해서는 사소하게 수정할 수 있습니다.

255를 true로, 0을 false로 반환합니다.

문서화되지 않았지만 널리 지원되는 opcode를 사용 salc합니다.

아래 분해 :

;F3 0F B8 C1 
  popcnt eax, ecx ; Sets eax to number of bits set in ecx

;0F BD D1
  bsr edx, ecx    ; Sets edx to the index of the leading 1 bit of ecx

;03 C0
  add eax, eax

;42
  inc edx

;2B D0
  sub edx, eax

  ; At this point, 
  ;   edx = (index of highest bit set) + 1 - 2*(number of bits set)
  ; This is negative if and only if ecx was binary-heavy.

;D6
  salc           ; undocumented opcode. Sets al to 255 if carry flag 
                 ; is set, and to 0 otherwise. 

;C3
  ret

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

덕분에 피터 코르 교체 제안에 lzcnt와 bsr.

젤리 , 5 바이트

Bo-SR

비어 있지 않은 출력 (거친) 또는 빈 출력 (거짓)을 나타냅니다.

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

작동 원리

Bo-SR  Main link. Argument: n

B      Binary; convert n to base 2.
 o-    Compute the logical OR with -1, mapping 1 -> 1 and 0 -> -1.
   S   Take the sum s. We need to check if the sum is strictly positive.
    R  Range; yield [1, ..., s], which is non-empty iff s > 0.

파이썬 2 , 35 바이트

lambda n:max('10',key=bin(n).count)

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

기존 답변, 38 바이트

^{출력 0falsy하고 -2나 -1같은 truthy}

lambda n:~cmp(*map(bin(n).count,'10'))

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

옥타브 , 18 바이트

@(n)mode(de2bi(n))

통신 도구 상자가 포함되어 있지 않으므로 TIO가 작동하지 않습니다. Octave-Online 에서 테스트 할 수 있습니다 .

작동 원리 :

de2bi십진수를 문자열이 아닌 이진 숫자 벡터로 변환합니다 dec2bin.

mode벡터에서 가장 빈번한 숫자를 반환합니다. 동점 인 경우 기본값이 가장 낮습니다.

@(n)                % Anonymous function that takes a decimal number as input 'n'
    mode(        )  % Computes the most frequent digit in the vector inside the parentheses
         de2bi(n)   % Converts the number 'n' to a binary vector

자바 스크립트 (ES6), 36 34 바이트

f=(n,x=0)=>n?f(n>>>1,x+n%2-.5):x>0

MATL , 3 바이트

BXM

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

나는 MATL을 모른다 mode. alephalpha의 Octave 답변 에서 작동 할 수 있다는 것을 알았고 MATL에는 동등한 것이 있다고 생각했다.

B   ' binary array from input
 XM ' value appearing most.  On ties, 0 wins

매스 매 티카, 22 바이트

@MartinEnder 및 @JungHwanMin 덕분에 1 바이트를 절약 했습니다 .

#>#2&@@#~DigitCount~2&

Brachylog , 6 바이트

ḃọtᵐ>₁

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

설명

Example input: 13

ḃ        Base (default: binary): [1,1,0,1]
 ọ       Occurences:             [[1,3],[0,1]]
  tᵐ     Map Tail:               [3,1]
    >₁   Strictly decreasing list

때문에 ḃ선행 0와 숫자의 목록이 출력을 통합하지 않습니다, 우리는의 발행 수는 것을 알고 1항상 먼저하고의 발행 수는 0항상 초 후가 될 것입니다 ọ.

파이썬 3 ,  44  (감사 @ c-mcavoy) 40 바이트

lambda n:bin(n).count('0')<len(bin(n))/2

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

C (gcc) , 51 48 41 40 바이트

i;f(n){for(i=0;n;n/=2)i+=n%2*2-1;n=i>0;}

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

R , 54 53 51 바이트

Max Lawnboy 덕분에 -1 바이트

n=scan();d=floor(log2(n))+1;sum(n%/%2^(0:d)%%2)*2>d

stdin에서 읽습니다. TRUE이진수로 된 숫자를 반환 합니다. d이진수의 수입니다. sum(n%/%2^(0:d)%%2숫자 합계 (즉, 1의 수)를 계산합니다.

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

x86_64 기계 코드, 23 22 21 바이트

31 c0 89 fa 83 e2 01 8d 44 50 ff d1 ef 75 f3 f7 d8 c1 e8 1f c3

분해 :

  # zero out eax
  xor  %eax, %eax
Loop:
  # copy input to edx
  mov  %edi, %edx
  # extract LSB(edx)
  and  $0x1, %edx
  # increment(1)/decrement(0) eax depending on that bit
  lea -1(%rax,%rdx,2), %eax
  # input >>= 1
  shr  %edi
  # if input != 0: repeat from Loop
  jnz  Loop

  # now `eax < 0` iff the input was not binary heavy,
  neg %eax
  # now `eax < 0` iff the input was binary heavy (which means the MSB is `1`)
  # set return value to MSB(eax)
  shr  $31, %eax
  ret

-1바이트에 대한 @Ruslan, @PeterCordes에게 감사합니다 !

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

펄 6 ,  32  30 바이트

{[>] .base(2).comb.Bag{qw<1 0>}}

그것을 테스트

{[>] .polymod(2 xx*).Bag{1,0}}

그것을 테스트

넓히는:

{      # bare block lambda with implicit parameter ｢$_｣

  [>]  # reduce the following with &infix:« > »

    .polymod(2 xx *) # turn into base 2 (reversed) (implicit method call on ｢$_｣)
    .Bag\            # put into a weighted Set
    { 1, 0 }         # key into that with 1 and 0
                     # (returns 2 element list that [>] will reduce)
}

와이즈 , 40 39 바이트

::^?[:::^~-&[-~!-~-~?]!~-?|>]|:[>-?>?]|

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

설명

::^?                                      Put a zero on the bottom
    [                                     While
     :::^~-&                              Get the last bit
            [-~!-~-~?]!~-?|               Increment counter if 0 decrement if 1
                           >              Remove the last bit
                            ]|            End while
                              :[>-?>?]|   Get the sign

하스켈, 41 34

g 0=0
g n=g(div n 2)+(-1)^n
(<0).g

경우 n홀수하는을 -1그것도의 경우를 취할 1. 로 재귀 호출을 추가하고 n/2if를 중지하십시오 n = 0. 결과가 0숫자 보다 작 으면 이진 중입니다.

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

편집 : @ Ørjan Johansen은 일부 단축키를 발견하고 7 바이트를 저장했습니다. 감사!

망막 , 37 34 바이트

.+
$*
+`(1+)\1
$1@
@1
1
+`.\b.

1+

온라인으로 사용해보십시오! 링크에는 작은 테스트 사례가 포함됩니다 (더 큰 테스트 사례에는 메모리가 부족할 수 있음). 편집 : @MartinEnder 덕분에 3 바이트가 절약되었습니다. 설명 : 첫 번째 단계는 십진수에서 단항으로 변환하고 다음 두 단계는 단항에서 이진으로 변환합니다 (이것은 내가 @대신 사용 하는 것을 제외하고 Retina 위키의 단항 산술 페이지에서 거의 직선 입니다 0). 세 번째 단계는 @1또는 이 중 하나 1@일 수있는 서로 다른 문자 쌍을 찾아서 남아있을 때까지 삭제합니다. 마지막 단계는 남은 1을 확인합니다.

R , 43 바이트

max(which(B<-intToBits(scan())>0))/2<sum(B)

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

             intToBits(scan())              # converts to bits
          B<-                 >0            # make logical and assign to B
max(which(                      ))/2        # get the length of the trimmed binary and halve
                                    <sum(B) # test against the sum of bits

코 틀린 , 50 바이트

{i:Int->i.toString(2).run{count{it>'0'}>length/2}}

암시 적 유형의 람다 (Int) -> Boolean. 의 사용으로 인해 버전 1.1 이상 Int.toString(radix: Int).

불행히도 TIO의 Kotlin 런타임은 1.0.x 인 것처럼 보이므로 TIO 링크 대신 슬픈 개가 있습니다.

Pyth, 9 7 바이트

ehc2S.B

여기에서 시도하십시오.

FryAmTheEggman 에게 -2 감사합니다 .

R, 39 37 바이트

sum(intToBits(x<-scan())>0)>2+log2(x)

이것은 @MickyT와 @Giuseppe가 사용하는 여러 방법을 조합하여 몇 바이트를 절약합니다.

sum(intToBits(x) > 0)1비트 수를 세고 2+log2(x)/2반올림 할 때 총 비트 수의 절반입니다. 두 값이 같은 동작 때문에 반올림 할 필요가 없습니다.

C # (. NET 코어) , 62 , 49 바이트

LINQ없이.

편집 : -13 바이트 골프가있는 dana는 재귀 적으로 변경하고 정수 대신 부울을 반환합니다.

x=>{int j=0;for(;x>0;x/=2)j+=x%2*2-1;return j>0;}

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

정규식 (ECMAScript), 85 73 71 바이트

^((?=(x*?)\2(\2{4})+$|(x*?)(\4\4xx)*$)(\2\4|(x*)\5\7\7(?=\4\7$\2)\B))*$

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

_{^{Deadcode의 설명}}

이전 73 바이트 버전이 아래에 설명되어 있습니다.

^((?=(x*?)\2(\2{4})+$)\2|(?=(x*?)(\4\4xx)*$)(\4|\5(x*)\7\7(?=\4\7$)\B))+$

ECMAScript 정규식의 한계로 인해 효과적인 전술은 종종 필요한 속성을 모든 단계에서 변하지 않고 유지하면서 한 번에 한 단계 씩 변환하는 것입니다. 예를 들어, 완벽한 제곱 또는 2의 거듭 제곱을 테스트하려면 모든 단계에서 제곱 또는 2의 거듭 제곱 (각각)을 유지하면서 크기를 줄이십시오.

이 솔루션이 모든 단계에서 수행하는 작업은 다음과 같습니다.

111100101$ones>zeroes$$1$

$ones>zeroes⇔ones-1>zeroes-1$

이러한 반복 된 단계가 더 이상 진행되지 않으면, 최종 결과는 연속적인 1비트 열이 될 것이며 , 이는 원래 숫자도 무거웠 음을 나타내거나 2의 거듭 제곱은 원래 숫자가 무겁지 않다는 것을 나타냅니다.

물론, 이러한 단계는 숫자의 이진 표현에 대한 인쇄상의 조작의 관점에서 위에서 설명되었지만 실제로는 단항 산술로 구현됩니다.

# For these comments, N = the number to the right of the "cursor", a.k.a. "tail",
# and "rightmost" refers to the big-endian binary representation of N.
^
(                          # if N is even and not a power of 2:
    (?=(x*?)\2(\2{4})+$)   # \2 = smallest divisor of N/2 such that the quotient is
                           # odd and greater than 1; as such, it is guaranteed to be
                           # the largest power of 2 that divides N/2, iff N is not
                           # itself a power of 2 (using "+" instead of "*" is what
                           # prevents a match if N is a power of 2).
    \2                     # N = N - \2. This changes the rightmost "10" to a "01".
|                          # else (N is odd or a power of 2)
    (?=(x*?)(\4\4xx)*$)    # \4+1 = smallest divisor of N+1 such that the quotient is
                           # odd; as such, \4+1 is guaranteed to be the largest power
                           # of 2 that divides N+1. So, iff N is even, \4 will be 0.
                           # Another way of saying this: \4 = the string of
                           # contiguous 1 bits from the rightmost part of N.
                           # \5 = (\4+1) * 2 iff N+1 is not a power of 2, else
                           # \5 = unset (NPCG) (iff N+1 is a power of 2), but since
                           #   N==\4 iff this is the case, the loop will exit
                           #   immediately anyway, so an unset \5 will never be used.
    (
        \4                 # N = N - \4. If N==\4 before this, it was all 1 bits and
                           # therefore heavy, so the loop will exit and match. This
                           # would work as "\4$", and leaving out the "$" is a golf
                           # optimization. It still works without the "$" because if
                           # N is no longer heavy after having \4 subtracted from it,
                           # this will eventually result in a non-match which will
                           # then backtrack to a point where N was still heavy, at
                           # which point the following alternative will be tried.
    |
        # N = (N + \4 - 2) / 4. This removes the rightmost "01". As such, it removes
        # an equal number of 0 bits and 1 bits (one of each) and the heaviness of N
        # is invariant before and after. This fails to match if N is a power of 2,
        # and in fact causes the loop to reach a dead end in that case.
        \5                 # N = N - (\4+1)*2
        (x*)\7\7(?=\4\7$)  # N = (N - \4) / 4 + \4
        \B                 # Assert N > 0 (this would be the same as asserting N > 2
                           # before the above N = (N + \4 - 2) / 4 operation).
    )
)+
$       # This can only be a match if the loop was exited due to N==\4.

정규식 (ECMAScript), 183 바이트

이것은 ECMA 정규식으로 해결해야 할 또 다른 흥미로운 문제였습니다. 이것을 처리하는 "명백한"방법은 1비트 수를 세어 총 비트 수와 비교하는 것입니다. 그러나 ECMAScript 정규식에서 직접 계산할 수는 없습니다. 지속적인 역 참조가 없기 때문에 루프에서 하나의 숫자 만 수정할 수 있으며 각 단계에서 숫자 만 줄일 수 있습니다.

이 단항 알고리즘은 다음과 같이 작동합니다.

1. N에 맞는 2의 최대 거듭 제곱의 제곱근을 취하고, 제곱근이 완벽한 지 반올림해야하는지 기록합니다. 이것은 나중에 사용됩니다.
2. 루프에서 각 최상위 1비트를 비트가있는 최하위 위치로 이동 0합니다. 이러한 각 단계는 빼기입니다. 루프의 끝에서 나머지 숫자 (2 진으로 표시됨)는 1s가없는 0s 의 문자열입니다 . 이러한 작업은 실제로 단항식으로 수행됩니다. 그것들은 개념적으로 바이너리로 이루어지고 있습니다.
3. 이 " 1s의 이진 문자열 "을 앞에서 얻은 제곱근과 비교하십시오 . 제곱근을 반올림해야한다면 2 배 버전을 사용하십시오. 이것은 " 1s의 이진 문자열 "이 최종 매치를하기 위해 N보다 이진 자릿수의 절반 이상을 가져야 한다는 것을 보장한다 .

제곱근을 구하기 위해, 로코 번호 정규식 게시물 에 간략하게 설명 된 곱셈 알고리즘의 변형 이 사용됩니다. 최하위 0비트 를 식별하기 위해, 팩터 넘버 정규식 포스트 에 간략하게 설명 된 나눗셈 알고리즘 이 사용됩니다. 이것들은 스포일러 입니다. 따라서 고급 단항 정규식 마술을 원하지 않는다면 더 이상 읽지 마십시오 . 이 마법을 스스로 알아내는 데 총력을 기울이려면 이 이전 게시물 의 연속 스포일러 태그 권장 문제 목록에서 몇 가지 문제를 해결 하고 수학 통찰력을 독립적으로 생각해 보는 것이 좋습니다 .

더 이상 고민하지 말고 정규 표현식 :

^(?=.*?(?!(x(xx)+)\1*$)(x)*?(x(x*))(?=(\4*)\5+$)\4*$\6)(?=(((?=(x(x+)(?=\10$))*(x*))(?!.*$\11)(?=(x*)(?=(x\12)*$)(?=\11+$)\11\12+$)(?=.*?(?!(x(xx)+)\14*$)\13(x*))\16)*))\7\4(.*$\3|\4)

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

# For the purposes of these comments, the input number = N.
^
# Take the floor square root of N
(?=
    .*?
    (?!(x(xx)+)\1*$)    # tail = the largest power of 2 less than tail
    (x)*?               # \3 = nonzero if we will need to round this square root
                        #      up to the next power of two
    (x(x*))             # \4 = potential square root; \5 = \4 - 1
    (?=
        (\4*)\5+$       # Iff \4*\4 == our number, then the first match here must result in \6==0
    )
    \4*$\6              # Test for divisibility by \4 and for \6==0 simultaneously
)
# Move all binary bits to be as least-significant as possible, e.g. 11001001 -> 1111
(?=
    (                                 # \7 = tool for making tail = the result of this move
        (
            (?=
                (x(x+)(?=\10$))*(x*)  # \11 = {divisor for getting the least-significant 0 bit}-1
            )
            (?!.*$\11)                # Exit the loop when \11==0
            (?=
                (x*)                  # \12 = floor((tail+1) / (\11+1)) - 1
                (?=(x\12)*$)          # \13 = \12+1
                (?=\11+$)
                \11\12+$
            )
            (?=
                .*?
                (?!(x(xx)+)\14*$)     # tail = the largest power of 2 less than tail
                \13                   # tail -= \13
                (x*)                  # \16 = tool to move the most-significant 1 bit to the
                                      # least-significant 0 bit available spot for it
            )
            \16
        )*
    )
)
\7                  # tail = the result of the move
\4                  # Assert that \4 is less than or equal to the result of the move
(
    .*$\3
|
    \4              # Double the value of \4 to compare against if \3 is non-empty,
                    # i.e. if we had an even number of total digits.
)

젤리 , 6 바이트

Bµċ0<S

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

J , 12 바이트

(+/>-:@#)@#:

J는 오른쪽에서 왼쪽으로 동사를 실행하므로 끝에서 시작하여 시작을 향해 나아갑니다.

설명

         #:       NB. Convert input to list of bits
       -:@#       NB. Half (-:) the (@) length (#)
          >       NB. Greater than 
         +/       NB. Sum (really plus (+) reduce (/)

줄리아, 22 바이트

x->2*x<4^count_ones(x)

옥타브 , 26 바이트

@(a)sum(2*dec2bin(a)-97)>0

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

PHP , 44 바이트

for(;$a=&$argn;$a>>=1)$r+=$a&1?:-1;echo$r>0;

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

PHP , 48 바이트

<?=($c=count_chars(decbin($argn)))[49]-$c[48]>0;

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

파이썬 2 , 44 바이트

f=lambda n,c=0:f(n/2,c+n%2*2-1)if n else c>0

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

기존 답변, 47 바이트

c,n=0,input()
while n:c+=n%2*2-1;n/=2
print c>0

이것은 단순히 @cleblanc의 C answer 포트입니다 . 다른 Python 답변보다 길지만 답변을 찾는 완전히 다른 방법이므로 게시 할 가치가 있다고 생각했습니다.

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

C #, 82 바이트

n=>{var s=System.Convert.ToString(n,2);return s.Replace("0","").Length>s.Length/2}