Un numero intero è binario pesante se la sua rappresentazione binaria contiene più 1s di 0s ignorando gli zeri iniziali. Ad esempio 1 è binario-pesante, poiché la sua rappresentazione binaria è semplicemente 1, tuttavia 4 non è binario pesante, come lo è la sua rappresentazione binaria 100. In caso di pareggio (ad esempio 2, con una rappresentazione binaria di 10), il numero non è considerato binario-pesante.

Dato un intero positivo come input, emette un valore di verità se è binario pesante e un valore di falsa se non lo è.

Casi test

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

punteggio

Si tratta di code-golf quindi vince il minor numero di byte in ogni lingua

Codice macchina x86, 15 14 byte

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

Questa è una funzione che utilizza la convenzione di chiamata __fastcall di Microsoft (il primo e unico parametro in ecx, il valore restituito in eax, il comando call è autorizzato a bloccare edx), sebbene possa essere banalmente modificato per altre convenzioni di chiamata che passano argomenti nei registri.

Restituisce 255 come verità e 0 come falsità.

Utilizza il codice operativo non documentato (ma ampiamente supportato) salc.

Smontaggio di seguito:

;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

Provalo online!

Grazie a Peter Cordes per aver suggerito di sostituirlo lzcntcon bsr.

Gelatina , 5 byte

Bo-SR

Produce output non vuoto (verità) o output vuoto (falsa).

Provalo online!

Come funziona

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 byte

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

Provalo online!

Vecchia risposta, 38 byte

^{Output 0come falsi e -2o -1come veri}

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

Provalo online!

Ottava , 18 byte

@(n)mode(de2bi(n))

TIO non funziona poiché la casella degli strumenti di comunicazione non è inclusa. Può essere testato su Octave-Online .

Come funziona:

de2biconverte un numero decimale in un vettore numerico binario, non una stringa come dec2binfa.

moderestituisce la cifra più frequente nel vettore. Il valore predefinito è il più basso in caso di pareggio.

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

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

MATL , 3 byte

BXM

Provalo online!

Non conosco davvero MATL, ho appena notato che modepotrebbe funzionare nella risposta Octave di alephalpha e ho pensato che ci fosse un equivalente in MATL.

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

Mathematica, 22 byte

Salvato un byte grazie a @MartinEnder e @JungHwanMin .

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

Brachylog , 6 byte

ḃọtᵐ>₁

Provalo online!

Spiegazione

Example input: 13

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

Poiché ḃnon unificherà mai il suo output con un elenco di cifre con zeri iniziali, sappiamo che le occorrenze di 1saranno sempre le prime e le ricorrenze 0saranno sempre le seconde dopo ọ.

Python 3 ,  44  (grazie @ c-mcavoy) 40 byte

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

Provalo online!

C (gcc) , 51 48 41 40 byte

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

Provalo online!

R , 54 53 51 byte

-1 byte grazie a Max Lawnboy

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

legge dallo stdin; ritorna TRUEper numeri binari pesanti. dè il numero di cifre binarie; sum(n%/%2^(0:d)%%2calcola la somma delle cifre (cioè il numero di quelle).

Provalo online!

codice macchina x86_64, 23 22 21 byte

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

Disassembled:

  # 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

Grazie @Ruslan, @PeterCordes per -1byte!

Provalo online!

Perl 6 ,  32  30 byte

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

Provalo

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

Provalo

Allargato:

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

Saggio , 40 39 byte

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

Provalo online!

Spiegazione

::^?                                      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 nè dispari, prendi a -1se è pari, prendi a 1. Aggiungi una chiamata ricorsiva con n/2e interrompi se n = 0. Se il risultato è inferiore 0al numero è binario pesante.

Provalo online!

Modifica: @ Ørjan Johansen ha trovato alcune scorciatoie e salvato 7 byte. Grazie!

Retina , 37 34 byte

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

1+

Provalo online! Il collegamento include casi di test più piccoli (quelli più grandi probabilmente esaurirebbero la memoria). Modifica: 3 byte salvati grazie a @MartinEnder. Spiegazione: Il primo stadio si converte da decimale a unario e i successivi due si convertono da unario a binario (questo è quasi uscito dalla pagina aritmetica unaria sul wiki Retina, tranne che sto usando @invece di 0). Il terzo livello cerca coppie di personaggi diversi, che potrebbero essere o @1o 1@, e li elimina fino a quando non ne rimangono. L'ultima fase controlla quindi i restanti 1s.

R , 43 byte

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

Provalo 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 byte

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

Lambda di tipo implicito (Int) -> Boolean. Versione 1.1 e successive solo a causa dell'uso di Int.toString(radix: Int).

Sfortunatamente il runtime di Kotlin di TIO sembra essere 1.0.x, quindi ecco un cane triste invece di un collegamento TIO:

Pyth, 9 7 byte

ehc2S.B

Provalo qui.

-2 grazie a FryAmTheEggman .

R, 39 37 byte

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

Questa è una combinazione dei metodi utilizzati da @MickyT e @Giuseppe, salvando altri pochi byte.

sum(intToBits(x) > 0)conta la quantità di 1bit ed 2+log2(x)/2è la metà della quantità totale di bit, quando arrotondato per difetto. Non è necessario arrotondare per eccesso a causa del comportamento quando i due valori sono uguali.

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

Senza LINQ.

EDIT: dana con un golf di -13 byte che cambia il tempo in ricorsivo e restituisce un valore bool anziché intero.

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

Provalo online!

Regex (ECMAScript), 85 73 71 byte

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

Provalo online!

_{^{spiegazione di Deadcode}}

La versione precedente di 73 byte è spiegata di seguito.

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

A causa delle limitazioni della regex di ECMAScript, una tattica efficace è spesso quella di trasformare il numero uno passo alla volta mantenendo invariata la proprietà richiesta ad ogni passo. Ad esempio, per verificare un quadrato perfetto o una potenza di 2, riduci il numero in dimensioni mantenendo un quadrato o una potenza di 2 (rispettivamente) ad ogni passo.

Ecco cosa fa questa soluzione in ogni fase:

111100101$ones>zeroes$$1$

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

Quando questi passaggi ripetuti non possono andare oltre, il risultato finale sarà una stringa contigua di 1bit, che è pesante, e indica che anche il numero originale era pesante, o una potenza di 2, indicando che il numero originale non era pesante.

E ovviamente, sebbene questi passaggi siano descritti sopra in termini di manipolazioni tipografiche sulla rappresentazione binaria del numero, in realtà sono implementati come aritmetica 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 byte

Questo era un altro problema interessante da risolvere con regex ECMA. Il modo "ovvio" di gestirlo è contare il numero di 1bit e confrontarlo con il numero totale di bit. Ma non puoi contare direttamente le cose nella regex di ECMAScript: la mancanza di backreferences persistenti significa che è possibile modificare un solo numero in un ciclo e ad ogni passo può essere solo ridotto.

Questo algoritmo unario funziona come segue:

1. Prendi la radice quadrata della potenza maggiore di 2 che si adatta a N e prendi nota se la radice quadrata era perfetta o doveva essere arrotondata per difetto. Questo sarà usato in seguito.
2. In un ciclo, sposta ciascun 1bit più significativo nella posizione meno significativa in cui è presente un 0bit. Ognuno di questi passaggi è una sottrazione. Alla fine del ciclo, il numero rimanente (come sarebbe rappresentato in binario) è una stringa di 1s senza 0s. Queste operazioni vengono effettivamente eseguite in modo unario; è concettualmente solo che vengono eseguiti in binario.
3. Confronta questa "stringa binaria di 1s" con la radice quadrata ottenuta in precedenza. Se è necessario arrotondare per difetto la radice quadrata, utilizzare una versione raddoppiata. Ciò garantisce che la "stringa binaria di 1s" debba contenere più della metà delle cifre binarie di N per consentire una corrispondenza finale.

Per ottenere la radice quadrata, viene utilizzata una variante dell'algoritmo di moltiplicazione brevemente descritto nel mio post regex dei miei numeri di Rocco . Per identificare il 0bit meno significativo , viene utilizzato l'algoritmo di divisione brevemente descritto nei miei numeri fattoriali regex post . Questi sono spoiler . Quindi non leggere oltre se non vuoi che qualche magia regex unaria avanzata venga viziata per te . Se vuoi provare a capire da solo questa magia, ti consiglio vivamente di risolvere alcuni problemi nell'elenco di problemi consecutivamente contrassegnati con spoiler in questo post precedente e di provare a elaborare le intuizioni matematiche in modo indipendente.

Senza ulteriori indugi, 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)

Provalo 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 byte

Bµċ0<S

Provalo online!

J , 12 byte

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

J esegue i verbi da destra a sinistra, quindi cominciamo alla fine e procediamo verso l'inizio.

Spiegazione

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

Julia, 22 byte

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

Ottava , 26 byte

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

Provalo online!

PHP , 44 byte

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

Provalo online!

PHP , 48 byte

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

Provalo online!

Python 2 , 44 byte

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

Provalo online!

Vecchia risposta, 47 byte

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

Questa è semplicemente una porta della risposta C di @ cleblanc . È più lungo delle altre risposte di Python, ma ho pensato che valesse la pena pubblicare perché è un metodo completamente diverso per trovare la risposta.

Provalo online!

C #, 82 byte

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