Un entero es pesado en binario si su representación binaria contiene más 1s que 0s mientras ignora los ceros a la izquierda. Por ejemplo, 1 es pesado en binario, ya que su representación binaria es simple 1, sin embargo, 4 no es pesado en binario, como lo es su representación binaria 100. En caso de empate (por ejemplo 2, con una representación binaria de 10), el número no se considera pesado en binario.

Dado un entero positivo como entrada, genera un valor verdadero si es pesado en binario, y un valor falso si no lo es.

Casos de prueba

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

Puntuación

Este es el código de golf, por lo que gana menos bytes en cada idioma

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

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

Esta es una función que utiliza la convención de llamadas __fastcall de Microsoft (primer y único parámetro en ecx, valor de retorno en eax, callee puede clobber edx), aunque puede modificarse trivialmente para otras convenciones de llamadas que pasan argumentos en los registros.

Devuelve 255 como verdadero y 0 como falsey.

Utiliza el código de operación no documentado (pero ampliamente compatible) salc.

Desmontaje a continuación:

;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

Pruébalo en línea!

Gracias a Peter Cordes por sugerir reemplazarlo lzcntcon bsr.

Jalea , 5 bytes

Bo-SR

Produce resultados no vacíos (verdad) o resultados vacíos (falsos).

Pruébalo en línea!

Cómo 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)

Pruébalo en línea!

Antigua respuesta, 38 bytes

^{Salidas 0como falsas y / -2o -1verdaderas}

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

Pruébalo en línea!

Octava , 18 bytes

@(n)mode(de2bi(n))

TIO no funciona ya que la caja de herramientas de comunicaciones no está incluida. Se puede probar en Octave-Online .

Cómo funciona esto:

de2biconvierte un número decimal en un vector numérico binario, no una cadena como lo dec2binhace.

modedevuelve el dígito más frecuente en el vector. El valor predeterminado es el más bajo en 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

Pruébalo en línea!

Realmente no conozco MATL, solo noté que modepodría funcionar en la respuesta Octave de alephalpha y pensé que había algo equivalente en MATL.

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

Mathematica, 22 bytes

Guardado un byte gracias a @MartinEnder y @JungHwanMin .

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

Brachylog , 6 bytes

ḃọtᵐ>₁

Pruébalo en línea!

Explicación

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á su salida con una lista de dígitos con ceros a la izquierda, sabemos que las ocurrencias de 1siempre serán las primeras y las de 0siempre serán las segundas ọ.

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

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

Pruébalo en línea!

C (gcc) , 51 48 41 40 bytes

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

Pruébalo en línea!

R , 54 53 51 bytes

-1 byte gracias a Max Lawnboy

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

lee de stdin; devuelve TRUEpara números pesados ​​binarios. des el número de dígitos binarios; sum(n%/%2^(0:d)%%2calcula la suma de dígitos (es decir, número de unidades).

Pruébalo en línea!

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

¡Gracias @Ruslan, @PeterCordes por el -1byte!

Pruébalo en línea!

Perl 6 ,  32  30 bytes

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

Pruébalo

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

Pruébalo

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

Sabio , 40 39 bytes

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

Pruébalo en línea!

Explicación

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

Si nes extraño, tome un -1si es par, tome un 1. Agregue una llamada recursiva con n/2y pare si n = 0. Si el resultado es menor que 0el número es binario pesado.

Pruébalo en línea!

Editar: @ Ørjan Johansen encontró algunos accesos directos y guardó 7 bytes. ¡Gracias!

Retina , 37 34 bytes

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

1+

Pruébalo en línea! El enlace incluye casos de prueba más pequeños (los más grandes probablemente se quedarían sin memoria). Editar: Guardado 3 bytes gracias a @MartinEnder. Explicación: La primera etapa se convierte de decimal a unario, y las siguientes dos etapas se convierten de unario a binario (esto es casi directamente de la página aritmética unaria en la wiki de Retina, excepto que estoy usando en @lugar de 0). La tercera etapa busca pares de caracteres diferentes, que podrían ser uno @1o otro 1@, y los elimina hasta que no quede ninguno. La última etapa luego verifica los 1s restantes.

R , 43 bytes

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

Pruébalo en línea!

             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 de tipo implícito (Int) -> Boolean. Versión 1.1 y superior solo debido al uso de Int.toString(radix: Int).

Desafortunadamente, el tiempo de ejecución Kotlin de TIO parece ser 1.0.x, así que aquí hay un perro triste en lugar de un enlace TIO:

Pyth, 9 7 bytes

ehc2S.B

Pruébalo aquí

-2 gracias a FryAmTheEggman .

R, 39 37 bytes

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

Esta es una combinación de los métodos utilizados por @MickyT y @Giuseppe, ahorrando otros pocos bytes.

sum(intToBits(x) > 0)cuenta la cantidad de 1bits y 2+log2(x)/2es la mitad de la cantidad total de bits cuando se redondea hacia abajo. No tenemos que redondear hacia abajo debido al comportamiento cuando los dos valores son iguales.

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

Sin LINQ

EDITAR: dana con un golf de -13 bytes que cambia el tiempo a un recursivo y devuelve un bool en lugar de un entero.

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

Pruébalo en línea!

Regex (ECMAScript), 85 73 71 bytes

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

Pruébalo en línea!

_{^{explicación por Deadcode}}

La versión anterior de 73 bytes se explica a continuación.

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

Debido a las limitaciones de la expresión regular ECMAScript, una táctica efectiva es a menudo transformar el paso número uno a la vez mientras se mantiene invariable la propiedad requerida en cada paso. Por ejemplo, para probar un cuadrado perfecto o una potencia de 2, reduzca el número en tamaño mientras mantiene un cuadrado o una potencia de 2 (respectivamente) en cada paso.

Esto es lo que hace esta solución en cada paso:

111100101$ones>zeroes$$1$

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

Cuando estos pasos repetidos no pueden ir más allá, el resultado final será una cadena contigua de 1bits, que es pesada, e indica que el número original también era pesado, o una potencia de 2, lo que indica que el número original no era pesado.

Y, por supuesto, aunque estos pasos se describen anteriormente en términos de manipulaciones tipográficas en la representación binaria del número, en realidad se implementan como aritmética unaria.

# 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

Este fue otro problema interesante para resolver con la expresión regular de ECMA. La forma "obvia" de manejar esto es contar el número de 1bits y compararlo con el número total de bits. Pero no puede contar directamente las cosas en la expresión regular ECMAScript: la falta de referencias persistentes significa que solo se puede modificar un número en un bucle y en cada paso solo se puede disminuir.

Este algoritmo unario funciona de la siguiente manera:

1. Tome la raíz cuadrada de la mayor potencia de 2 que encaje en N y tome nota de si la raíz cuadrada era perfecta o si tenía que redondearse hacia abajo. Esto se usará más tarde.
2. En un bucle, mueva cada 1bit más significativo a la posición menos significativa donde haya un 0bit. Cada uno de estos pasos es una resta. Al final del ciclo, el número restante (como se representaría en binario) es una cadena de 1s sin 0s. Estas operaciones se realizan realmente en unario; es solo conceptualmente que se están haciendo en binario.
3. Compare esta "cadena binaria de 1s" con la raíz cuadrada obtenida anteriormente. Si la raíz cuadrada tuvo que redondearse hacia abajo, use una versión duplicada. Esto asegura que la "cadena binaria de 1s" debe tener más de la mitad de dígitos binarios que N para que haya una coincidencia final.

Para obtener la raíz cuadrada, se usa una variante del algoritmo de multiplicación brevemente descrito en mi publicación de expresiones regulares de números Rocco . Para identificar el 0bit menos significativo , se utiliza el algoritmo de división brevemente descrito en mi publicación de expresiones regulares de números factoriales . Estos son spoilers . Así que no sigas leyendo si no quieres que se te estropee un poco de magia regex unaria avanzada . Si desea intentar descubrir esta magia usted mismo, le recomiendo comenzar resolviendo algunos problemas en la lista de problemas recomendados etiquetados consecutivamente con spoilers en esta publicación anterior , e intentando encontrar las ideas matemáticas de forma independiente.

Sin más preámbulos, la expresión regular:

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

Pruébalo en línea!

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

Jalea , 6 bytes

Bµċ0<S

Pruébalo en línea!

J , 12 bytes

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

J ejecuta verbos de derecha a izquierda, así que comencemos por el final y avancemos hacia el principio.

Explicación

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

Octava , 26 bytes

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

Pruébalo en línea!

PHP , 44 bytes

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

Pruébalo en línea!

PHP , 48 bytes

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

Pruébalo en línea!

Python 2 , 44 bytes

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

Pruébalo en línea!

Respuesta anterior, 47 bytes

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

Esto es simplemente un puerto de la respuesta C de @ cleblanc . Es más largo que otras respuestas de Python, pero pensé que valía la pena publicarlo, ya que es un método completamente diferente para encontrar la respuesta.

Pruébalo en línea!

C #, 82 bytes

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