Un entier est lourd en binaire si sa représentation binaire contient plus de 1s que 0s tout en ignorant les zéros de tête. Par exemple, 1 est lourd en binaire, tout comme sa représentation en binaire 1, mais 4 n'est pas lourd en binaire, au contraire de sa représentation en binaire 100. En cas d'égalité (par exemple 2, avec une représentation binaire de 10), le nombre n'est pas considéré comme lourd.

Si vous entrez un nombre entier positif, indiquez une valeur de vérité si elle est lourde comme un binaire et une valeur de falsey si ce n'est pas le cas.

Testcases

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

Notation

C'est le code-golf, donc le moins d'octets dans chaque langue gagne

Code machine x86, 15 à 14 octets

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

Il s'agit d'une fonction utilisant la convention d'appel __fastcall de Microsoft (premier et unique paramètre dans ecx, valeur de retour dans eax, l'appelant est autorisé à masquer edx), bien qu'il puisse être modifié de manière triviale pour d'autres conventions d'appel transmettant des arguments dans des registres.

Il renvoie 255 en tant que vérité et 0 en tant que falsey.

Il utilise l'opcode non documenté (mais largement pris en charge) salc.

Démontage ci-dessous:

;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

Essayez-le en ligne!

Merci à Peter Cordes d’ avoir suggéré de remplacer lzcntpar bsr.

Gelée , 5 octets

Bo-SR

Donne une sortie non vide (vérité) ou vide (falsy).

Essayez-le en ligne!

Comment ça fonctionne

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 octets

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

Essayez-le en ligne!

Ancienne réponse, 38 octets

^{Sorties 0sous forme de fausseté et / -2ou -1de vérité}

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

Essayez-le en ligne!

Octave , 18 octets

@(n)mode(de2bi(n))

TIO ne fonctionne pas car la boîte à outils de communication n'est pas incluse. Il peut être testé sur Octave-Online .

Comment ça marche:

de2biconvertit un nombre décimal en un vecteur numérique binaire, pas une chaîne comme le dec2binfait le.

moderenvoie le chiffre le plus fréquent dans le vecteur. La valeur par défaut est la plus basse en cas d'égalité.

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

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

MATL , 3 octets

BXM

Essayez-le en ligne!

Je ne connais pas vraiment MATL, je viens de remarquer que cela modepourrait fonctionner dans la réponse d’Octave d’alphalpha et j’ai pensé qu’il existait un équivalent dans MATL.

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

Mathematica, 22 octets

Enregistré un octet grâce à @MartinEnder et à @JungHwanMin .

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

Brachylog , 6 octets

ḃọtᵐ>₁

Essayez-le en ligne!

Explication

Example input: 13

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

Puisqu'il ḃne sera jamais unifier sa sortie avec une liste de chiffres avec des zéros au début, nous savons que les occurrences de 1seront toujours en premier et les occurrences de 0seront toujours deuxièmes après ọ.

Python 3 ,  44  (merci @ c-mcavoy) 40 octets

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

Essayez-le en ligne!

C (gcc) , 51 48 41 40 octets

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

Essayez-le en ligne!

R , 54 53 51 octets

-1 octet grâce à Max Lawnboy

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

lit de stdin; retourne TRUEpour les nombres lourds binaires. dest le nombre de chiffres binaires; sum(n%/%2^(0:d)%%2calcule la somme des chiffres (c.-à-d. le nombre de uns).

Essayez-le en ligne!

x86_64 code machine, 23 22 21 octets

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

Démonté:

  # 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

Merci @Ruslan, @PeterCordes pour -1byte!

Essayez-le en ligne!

Perl 6 ,  32  30 octets

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

Essaye-le

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

Essaye-le

Étendu:

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

Sage , 40 39 octets

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

Essayez-le en ligne!

Explication

::^?                                      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 nc'est étrange, prenez un -1si c'est pair, prenez un 1. Ajouter un appel récursif avec n/2et arrêter si n = 0. Si le résultat est inférieur, 0le nombre est binaire.

Essayez-le en ligne!

Edit: @ Ørjan Johansen a trouvé des raccourcis et a sauvegardé 7 octets. Merci!

Retina , 37 34 bytes

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

1+

Essayez-le en ligne! Link inclut des cas de test plus petits (les plus gros manquent probablement de mémoire). Edit: 3 octets enregistrés grâce à @MartinEnder. Explication: La première étape est convertie du nombre décimal au unaire, et les deux étapes suivantes sont converties du unaire au binaire (ceci sort presque directement de la page arithmétique unaire du wiki Retina, sauf que j'utilise @plutôt que 0). La troisième étape recherche des paires de caractères différents, qui peuvent être l'un @1ou l' autre 1@, et les supprime jusqu'à ce qu'il n'en reste plus. La dernière étape vérifie ensuite les 1 restants.

R , 43 octets

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

Essayez-le en ligne!

             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 octets

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

Lambda de type implicite (Int) -> Boolean. Version 1.1 et ultérieure uniquement en raison de l'utilisation de Int.toString(radix: Int).

Malheureusement, le runtime Kotlin de TIO semble être 1.0.x, alors voici un chien triste au lieu d'un lien TIO:

Pyth, 9 à 7 octets

ehc2S.B

Essayez ici.

-2 grâce à FryAmTheEggman .

R, 39 37 octets

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

Ceci est une combinaison des méthodes utilisées par @MickyT et @Giuseppe, en économisant quelques octets supplémentaires.

sum(intToBits(x) > 0)compte le nombre de 1bits et 2+log2(x)/2correspond à la moitié du nombre total de bits arrondis. Nous n'avons pas à arrondir à cause du comportement lorsque les deux valeurs sont égales.

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

Sans LINQ.

EDIT: dana avec un golf de -13 octets changeant le temps en un récursif pour et retournant un booléen au lieu d’entier.

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

Essayez-le en ligne!

Regex (ECMAScript), 85 73 71 octets

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

Essayez-le en ligne!

_{^{explication par Deadcode}}

La version antérieure de 73 octets est expliquée ci-dessous.

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

En raison des limitations de la regex ECMAScript, une tactique efficace consiste souvent à transformer l’étape numéro un à la fois tout en maintenant l’invariant de propriété requis à chaque étape. Par exemple, pour tester un carré parfait ou une puissance de 2, réduisez le nombre en conservant un carré ou une puissance de 2 (respectivement) à chaque étape.

Voici ce que cette solution fait à chaque étape:

111100101$ones>zeroes$$1$

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

Lorsque ces étapes répétées ne peuvent plus aller plus loin, le résultat final sera soit une chaîne de 1bits contigus , ce qui est lourd et indique que le nombre d'origine était également lourd, ou une puissance de 2 indiquant que le nombre d'origine n'était pas lourd.

Et bien sûr, bien que ces étapes soient décrites ci-dessus en termes de manipulations typographiques sur la représentation binaire du nombre, elles sont en réalité implémentées sous forme d'arithmétique unaire.

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

C’était un autre problème intéressant à résoudre avec la regex ECMA. La manière "évidente" de gérer cela consiste à compter le nombre de 1bits et à le comparer au nombre total de bits. Mais vous ne pouvez pas compter directement dans ECMAScript regex - l'absence de références arrières persistantes signifie qu'un seul nombre peut être modifié dans une boucle et qu'il ne peut être que réduit à chaque étape.

Cet algorithme unaire fonctionne comme suit:

1. Prenez la racine carrée de la plus grande puissance de 2 qui rentre dans N et notez si la racine carrée était parfaite ou devait être arrondie. Ce sera utilisé plus tard.
2. Dans une boucle, déplacez chaque 1bit le plus significatif vers la position la moins significative où il y a un 0bit. Chacune de ces étapes est une soustraction. À la fin de la boucle, le nombre restant (comme il serait représenté en binaire) est une chaîne de 1s sans 0s. Ces opérations sont en réalité effectuées à l’unisson; ce n'est que conceptuellement qu'ils se font en binaire.
3. Comparez cette "chaîne binaire de 1s" à la racine carrée obtenue précédemment. Si la racine carrée doit être arrondie, utilisez-en une version doublée. Cela garantit que la "chaîne binaire de 1s" doit avoir plus de la moitié de chiffres binaires comme N pour qu'il y ait une correspondance finale.

Pour obtenir la racine carrée, on utilise une variante de l'algorithme de multiplication brièvement décrit dans mon numéro Rocco regex post . Pour identifier le 0bit le moins significatif , on utilise l'algorithme de division décrit brièvement dans mon numéro factoriel regex post . Ce sont des spoilers . Donc , ne lisez pas plus loin si vous ne voulez pas que la magie avancée des regex unaires soit gâtée . Si vous voulez essayer vous-même de découvrir cette magie, je vous recommande vivement de commencer par résoudre certains problèmes de la liste des problèmes recommandés consécutivement marqués par des spoilers dans cet article précédent , puis d'essayer de fournir des informations mathématiques indépendantes.

Sans plus tarder, la 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)

Essayez-le en ligne!

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

Gelée , 6 octets

Bµċ0<S

Essayez-le en ligne!

J , 12 octets

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

J exécute les verbes de droite à gauche, alors commençons par la fin et poursuivons notre chemin vers le début.

Explication

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

Julia, 22 octets

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

Octave , 26 octets

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

Essayez-le en ligne!

PHP , 44 octets

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

Essayez-le en ligne!

PHP , 48 octets

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

Essayez-le en ligne!

Python 2 , 44 octets

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

Essayez-le en ligne!

Réponse ancienne, 47 octets

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

Ceci est simplement un port de la réponse C de @ cleblanc . C'est plus long que les autres réponses Python mais je me suis dit que ça valait le coup de poster car c'est une méthode complètement différente pour trouver la réponse.

Essayez-le en ligne!

C #, 82 octets

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