整数は、そのバイナリ表現が1sよりも多くのs を含み、0先行ゼロを無視する場合、バイナリが重いです。たとえば、1はバイナリ表現が単純1であるため、バイナリが重いですが、4はバイナリ表現がであるため、バイナリは重くありません100。同数の場合（たとえば、2のバイナリ表現で2 10）、数は2進数とは見なされません。

入力として正の整数を指定すると、バイナリが重い場合は真理値が出力され、そうでない場合は偽値が出力されます。

テストケース

フォーマット： 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、偽として0を返します。

文書化されていない（ただし広くサポートされている）オペコードを使用し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

オンラインでお試しください！

に置き換えることを提案してくれたPeter Cordesに感謝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.

Python 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でテストできます。

仕組み：

de2bi10進数を、文字列で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

JavaScript（ES6）、36 34バイト

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

MATL、3バイト

BXM

オンラインでお試しください！

私は本当にMATLを知りません。alephalphaのOctaveの答えmodeでうまくいくことに気づき、MATLに同等のものがあると考えました。

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

Mathematica、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

ḃ先行ゼロのある数字のリストで出力を統一することは決してないので、の出現1は常に最初であり、の出現0は常に2番目であることを知っていọます。

Pythonの3、 44 （感謝する@ C-マカヴォイ）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バイト

マックス・ローンボーイのおかげで-1バイト

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

stdinから読み取ります。TRUEバイナリの重い数値を返します。d2進数の桁数です。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

@ Ruslan、@ PeterCordesに-1バイトをありがとう！

オンラインでお試しください！

Perl 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数値よりも小さい場合は、2進数が多すぎます。

オンラインでお試しください！

編集：@ØrjanJohansenはいくつかのショートカットを見つけ、7バイトを節約しました。ありがとう！

網膜、37 34バイト

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

1+

オンラインでお試しください！リンクには小さなテストケースが含まれます（大きなテストケースではおそらくメモリ不足になります）。編集：@MartinEnderのおかげで3バイトを保存しました。説明：最初のステージは10進数から単項に変換し、次の2つのステージは単項からバイナリに変換します（これはRetina wikiの単項算術ページからほぼそのままです。ただし、私はの@代わりに使用しています0）。3番目の段階では、異なる文字のペア（@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

Kotlin、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

ここで試してみてください。

-2 FryAmTheEggmanに感謝します。

R、39 37バイト

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

これは、@ MickyTと@Giuseppeで使用されるメソッドの組み合わせで、さらに数バイトを節約します。

sum(intToBits(x) > 0)切り捨てられた場合、1ビット量をカウントし2+log2(x)/2、総ビット量の半分になります。2つの値が等しい場合の動作のため、切り捨てる必要はありません。

C＃（.NET Core）、62、49のバイト

LINQなし。

編集：-13バイトのゴルフを持つdanaは、whileを再帰的に変更し、整数ではなくブール値を返します。

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))*$

オンラインでお試しください！

_{^{デッドコードによる説明}}

以前の73バイトバージョンについては、以下で説明します。

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

ECMAScript正規表現の制限のため、効果的な戦術は、多くの場合、必要なプロパティを不変に保ちながら、一度に1つのステップを変換することです。たとえば、完全な正方形または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つの興味深い問題でした。これを処理する「明らかな」方法は、1ビット数をカウントし、それをビット総数と比較することです。ただし、ECMAScript正規表現で直接数を数えることはできません。永続的な後方参照がないため、ループ内で変更できるのは1つの数値のみであり、各ステップで減らすことしかできません。

この単項アルゴリズムは次のように機能します。

1. Nに収まる最大の2のべき乗の平方根を取り、平方根が完全であったか切り捨てられたかどうかに注意してください。これは後で使用されます。
2. ループ内で、最上位の各1ビットをビットがある最下位の位置に移動し0ます。これらの各ステップは減算です。ループの最後では、残りの数（バイナリで表される）は、1sのない0sの文字列です。これらの操作は実際には単項式で行われます。概念的には、それらがバイナリで行われているだけです。
3. この「1sのバイナリ文字列」を以前に取得した平方根と比較します。平方根を切り捨てる必要がある場合は、その2倍のバージョンを使用します。これにより、「1sのバイナリ文字列」は、最終的な一致が得られるように、Nの半分以上のバイナリ桁を持つ必要があります。

平方根を取得するには、Roccoの数字の正規表現の投稿で簡単に説明した乗算アルゴリズムのバリアントを使用します。最下位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;

オンラインでお試しください！

Python 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回答の単なる移植版ですです。他のPythonの回答よりも長いですが、回答を見つけるためのまったく異なる方法であるため、投稿する価値があると考えました。

オンラインでお試しください！

C＃、82バイト

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