Um número inteiro é pesado de binário se sua representação binária contiver mais 1s que 0s, ignorando os zeros à esquerda. Por exemplo 1 é binário pesado, como sua representação binária é simplesmente 1, no entanto 4 não é binário pesado, como é sua representação binária 100. No caso de um empate (por exemplo 2, com uma representação binária de 10), o número não é considerado pesado como binário.

Dado um número inteiro positivo como entrada, produza um valor de verdade, se for pesado binário, e um valor de falsey, se não for.

Casos de teste

Formato: 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

Pontuação

Isso é código-golfe, e o menor número de bytes em cada idioma ganha

Código da máquina x86, 15 14 bytes

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

Essa é uma função que usa a convenção de chamada __fastcall da Microsoft (o primeiro e único parâmetro em ecx, o valor de retorno em eax, o callee é permitido desobstruir o edx), embora possa ser modificado trivialmente para outras convenções de chamada que transmitem argumentos nos registros.

Retorna 255 como verdade e 0 como falsey.

Ele usa o código de operação não documentado (mas amplamente suportado) salc.

Desmontagem abaixo:

;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

Experimente online!

Agradecemos a Peter Cordes por sugerir a substituição lzcntpor bsr.

Gelatina , 5 bytes

Bo-SR

Produz saída não vazia (verdade) ou saída vazia (falso).

Experimente online!

Como funciona

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 bytes

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

Experimente online!

Resposta antiga, 38 bytes

^{Saídas 0como Falsas e -2ou -1como truthy}

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

Experimente online!

Oitava , 18 bytes

@(n)mode(de2bi(n))

O TIO não funciona, pois a caixa de ferramentas de comunicação não está incluída. Pode ser testado no Octave-Online .

Como isso funciona:

de2biconverte um número decimal em um vetor numérico binário, não uma string como dec2binfaz.

moderetorna o dígito mais frequente no vetor. O padrão é o mais baixo em caso de empate.

@(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 bytes

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

MATL , 3 bytes

BXM

Experimente online!

Eu realmente não conheço o MATL, apenas notei que isso modepoderia funcionar na resposta Octave do alephalpha e achei que havia algum equivalente no MATL.

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

Mathematica, 22 bytes

Salvo um byte graças a @MartinEnder e @JungHwanMin .

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

Braquilog , 6 bytes

ḃọtᵐ>₁

Experimente online!

Explicação

Example input: 13

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

Como ḃnunca unificará sua saída com uma lista de dígitos com zeros à esquerda, sabemos que as ocorrências de 1sempre serão as primeiras e as ocorrências de 0sempre serão as seguintes ọ.

Python 3 ,  44  (obrigado @ c-mcavoy) 40 bytes

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

Experimente online!

C (gcc) , 51 48 41 40 bytes

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

Experimente online!

R , 54 53 51 bytes

-1 byte graças a Max Lawnboy

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

lê de stdin; retorna TRUEpara números pesados ​​binários. dé o número de dígitos binários; sum(n%/%2^(0:d)%%2calcula a soma dos dígitos (ou seja, número de unidades).

Experimente online!

código de máquina x86_64, 23 22 21 bytes

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

Desmontado:

  # 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

Obrigado @Ruslan, @PeterCordes pelo -1byte!

Experimente online!

Perl 6 ,  32  30 bytes

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

Teste-o

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

Teste-o

Expandido:

{      # 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)
}

Sábio , 40 39 bytes

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

Experimente online!

Explicação

::^?                                      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

Haskell, 41 34

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

Se nfor ímpar, pegue um -1se for par, pegue um 1. Adicione uma chamada recursiva com n/2e pare se n = 0. Se o resultado for menor que 0o número, será muito pesado.

Experimente online!

Edit: @ Ørjan Johansen encontrou alguns atalhos e salvou 7 bytes. Obrigado!

Retina , 37 34 bytes

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

1+

Experimente online! O link inclui casos de teste menores (os maiores provavelmente ficarão sem memória). Editar: salvou 3 bytes graças a @MartinEnder. Explicação: O primeiro estágio é convertido de decimal em unário, e os próximos dois estágios são convertidos de unário em binário (isso é quase direto na página aritmética unária no wiki da Retina, exceto pelo uso em @vez de 0). O terceiro estágio procura pares de caracteres diferentes, que podem ser um @1ou 1@, e os exclui até que não restem mais. O último estágio verifica os 1s restantes.

R , 43 bytes

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

Experimente online!

             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 bytes

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

Lambda do tipo implícito (Int) -> Boolean. Versão 1.1 e superior apenas devido ao uso de Int.toString(radix: Int).

Infelizmente, o tempo de execução Kotlin do TIO parece ser 1.0.x, então aqui está um cachorro triste em vez de um link do TIO:

Pitão, 9 7 bytes

ehc2S.B

Experimente aqui.

-2 graças a FryAmTheEggman .

R, 39 37 bytes

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

Essa é uma combinação dos métodos usados ​​pelo @MickyT e pelo @ Giuseppe, economizando mais alguns bytes.

sum(intToBits(x) > 0)conta a quantidade de 1bits e 2+log2(x)/2é metade da quantidade total de bits, quando arredondado para baixo. Não precisamos arredondar para baixo por causa do comportamento quando os dois valores são iguais.

C # (.NET Core) , 62 , 49 bytes

Sem LINQ.

EDIT: dana com um golf de -13 bytes alterando o tempo para um recursivo e retornando um bool ao invés de inteiro.

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

Experimente online!

Regex (ECMAScript), 85 73 71 bytes

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

Experimente online!

_{^{explicação por Deadcode}}

A versão anterior de 73 bytes é explicada abaixo.

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

Devido às limitações da expressão regular ECMAScript, uma tática eficaz é frequentemente transformar a etapa número um de cada vez, mantendo a propriedade requerida invariável a cada etapa. Por exemplo, para testar um quadrado perfeito ou uma potência de 2, reduza o número em tamanho, mantendo um quadrado ou uma potência de 2 (respectivamente) a cada etapa.

Aqui está o que essa solução faz a cada etapa:

111100101$ones>zeroes$$1$

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

Quando essas etapas repetidas não puderem avançar, o resultado final será uma sequência de 1bits contígua , que é pesada, e indica que o número original também era pesado, ou uma potência de 2, indicando que o número original não era pesado.

E, é claro, embora essas etapas sejam descritas acima em termos de manipulações tipográficas na representação binária do número, elas são realmente implementadas como aritmética unária.

# 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.

Regex (ECMAScript), 183 bytes

Esse foi outro problema interessante a ser resolvido com o regex ECMA. A maneira "óbvia" de lidar com isso é contar o número de 1bits e compará-lo ao número total de bits. Mas você não pode contar diretamente as coisas na expressão regular ECMAScript - a falta de referências persistentes significa que apenas um número pode ser modificado em um loop e, a cada passo, só pode ser diminuído.

Esse algoritmo unário funciona da seguinte maneira:

1. Pegue a raiz quadrada da maior potência de 2 que se encaixa em N e anote se a raiz quadrada era perfeita ou tinha que ser arredondada para baixo. Isso será usado mais tarde.
2. Em um loop, mova cada 1bit mais significativo para a posição menos significativa onde houver um 0pouco. Cada uma dessas etapas é uma subtração. No final do loop, o número restante (como seria representado em binário) é uma sequência de 1s sem 0s. Essas operações são realmente feitas em unário; é apenas conceitualmente que eles estão sendo feitos em binário.
3. Compare essa "seqüência binária de 1s" com a raiz quadrada obtida anteriormente. Se a raiz quadrada tiver que ser arredondada para baixo, use uma versão duplicada. Isso garante que a "sequência binária de 1s" seja necessária para ter mais da metade dos dígitos binários que N para que haja uma correspondência final.

Para obter a raiz quadrada, é usada uma variante do algoritmo de multiplicação descrita brevemente no meu post de regex de números Rocco . Para identificar o 0bit menos significativo , é usado o algoritmo de divisão descrito brevemente no meu número de fatorial regex post . Estes são spoilers . Portanto , não leia mais se não quiser que você estrague uma mágica avançada de expressões regulares unárias . Se você quiser tentar descobrir essa mágica, eu recomendo começar resolvendo alguns problemas na lista de problemas recomendados consecutivamente identificados por spoilers neste post anterior e tentando apresentar os insights matemáticos de forma independente.

Sem mais delongas, a regex:

^(?=.*?(?!(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)

Experimente online!

# 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.
)

Gelatina , 6 bytes

Bµċ0<S

Experimente online!

J , 12 bytes

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

J executa verbos da direita para a esquerda, então vamos começar no final e trabalhar para o começo.

Explicação

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

Julia, 22 bytes

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

Oitava , 26 bytes

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

Experimente online!

PHP , 44 bytes

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

Experimente online!

PHP , 48 bytes

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

Experimente online!

Python 2 , 44 bytes

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

Experimente online!

Resposta antiga, 47 bytes

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

Esta é simplesmente uma porta da resposta C do @ cleblanc . É mais longo que as outras respostas do Python, mas achei que valia a pena postar, pois é um método completamente diferente de encontrar a resposta.

Experimente online!

C #, 82 bytes

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