O número é binário pesado?


58

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 é e o menor número de bytes em cada idioma ganha


E se meu idioma não puder lidar com o último caso de teste, porque está fora dos limites do que é considerado um número inteiro positivo?
musicman523

11
@ musicman523 afaik As regras de E / S padrão declaram que você só precisa aceitar números representáveis ​​pelo formato de número do seu idioma. Observe que "jogar" isso usando algo como o boolfuck é considerado uma
brecha

Algum valor de verdade / falsidade conta ou precisamos de dois valores distintos?
Erik the Outgolfer

@EriktheOutgolfer qualquer valor #
Skidsdev

6
Aka A072600 , se isso ajudar alguém.
dcsohl

Respostas:


28

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.


Agradável. Eu cheguei ao óbvio popcntantes de rolar para baixo para procurar respostas, mas não tinha pensado lzcntem lidar apenas com os dígitos significativos, conforme exigido pela pergunta.
Peter Cordes

Existe alguma maneira de obter uma economia líquida usando em bsrvez de lzcnt(aka rep bsr)? Você precisaria usar subem leavez disso, já que fornece 32-lzcnt. (Ou deixa o dst não modificada para src = 0, em todo o hardware Intel e AMD existente AMD mesmo documentos este comportamento, mas a Intel diz indefinido ... Enfim, OP disse. Positiva , o que exclui 0.)
Peter Cordes

11
Definitivamente, eu estava pensando da mesma maneira que o @Peter, já que o desafio limita explicitamente as entradas a números positivos. Na verdade, eu tinha uma solução elaborada usando popcnte bsr, mas tinha 17 bytes. Eu estava pensando que era muito bom em comparação com a primeira resposta asm que eu vi , mas esse leatruque inteligente supera isso. Eu também olhei para comparar bsfe popcnt. Mas não estou vendo nenhuma maneira de superar essa solução, mesmo levando em consideração o byte de 1 byte que você poderia salvar ao soltar o repprefixo.
Cody Gray

11
salcnão é equivalente a setc al: os últimos conjuntos alpara 1 se CF definidos, não a 255.
Ruslan

11
O equivalente real de salcé sbb al, al, mas você obtém uma economia de 1 byte para codificá-lo. A propósito, ele é documentado pela AMD e é amplamente suportado pela Intel, com o mnemônico vindo do mapa de códigos op6 P6 da Intel. Portanto, este é realmente bastante seguro de usar. Além disso, uma boa melhoria aqui para pensar em usar essa instrução! Isso é basicamente o que meu rascunho original fez, exceto que (1) eu usei o código x86-64, então inctinha o dobro do tempo para codificar e (2) eu não tinha pensado nisso salc, então estava fazendo o mesmo trabalho em um caminho mais longo. Pena que só posso votar uma vez.
Cody Grey

17

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.

Agradável. Eu tinha Bo-S, mas eu não poderia encontrar um átomo de 1 byte que converteria positiva / não-positiva em truthy / Falsas ...
ETHproductions

Lógico ou com -1, certo?
21417 Lynn

@ Lynn Sim, de fato. Obrigado.
Dennis


@cairdcoinheringaahing Obrigado, mas Æṃnão existia naquela época.
Dennis

14

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!


2
O 0 inicial no retorno de bincausa esta solução problemas?
Shadow

3
@ shadow Não há nenhum problema, por causa da maneira como maxfunciona. No caso de um empate, max retornará o primeiro valor no iterável que possui o valor máximo. Esse código usa esse fato para garantir que 1 seja retornado no caso de um empate, o que realmente significa que há mais do que zeros, pois um zero extra foi adicionado por bin. Na verdade, seria incorreto quando escrito dessa maneira, se não fosse o zero extra.
FryAmTheEggman

@FryAmTheEggman isso também é verdadeiro sobre a velha resposta, onde os cmpretornos 0quando ambos são iguais
Rod

11

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

A caixa de ferramentas de comunicação é parte padrão do Octave ou é mais parecida com uma biblioteca em outros idiomas?
Dcsohl

É um pacote que acompanha a instalação. Você precisa carregá-lo especificamente em algumas instalações, e ele é carregado automaticamente como padrão em outras. É parte do padrão no Octave-Online.net, então estou usando isso como referência. (O código deve funcionar em pelo menos um intérprete que existia antes do desafio).
Stewie Griffin

9

JavaScript (ES6), 36 34 bytes

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

f=(n,x=0)=>n?f(n>>>1,x+=n%2-.5):x>0por 35 bytes.
ovs 13/07/19

Use em n>>1vez de n>>>1para salvar um byte, pois a entrada nunca é negativa.
kamoroso94

@ kamoroso94 Obrigado, mas então seria falhar em 2147483648.
ETHproductions

@ETHproductions Porra, e n/2|0não é melhor: /
kamoroso94



7

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 .



6

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!


Baseado no esclarecimento do OP, você pode removerunsigned
musicman523

Como nnn é positivo, você pode mudar n>>=1para n/=2. Eu também acho que você pode usar ~nem vez de n^-1, que também deve permitir que você mude &&para&
musicman523

Coisas estranhas acontecem quando eu edito comentários - "nnn" significa n, e não se preocupe em mudar &&para &, acho que não funcionaria. Mas alterá-lo para *parece funcionar
musicman523

@ musicman523 O &&foi apenas para lidar com o caso não assinado, mas como eu só preciso lidar com números inteiros positivos, posso removê-lo todos juntos. Bom pouint sobre /=ser mais curto que >>=, porém, obrigado!
Cleblanc

Você pode salvar um byte mudando n&1?++i:--1para i+=n%2*2-1. Você também pode ser capaz de se livrar de >0, afirmando que irá imprimir zero para pesado e diferente de zero para não pesado
musicman523

6

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!


Só vi a sua resposta depois de postar meu ... De qualquer forma, você pode usar log2(n)em vez de log(n,2)salvar 1 byte
Maxim Mikhaylov

@ MaxLawnboy ah, é claro. Obrigado!
Giuseppe


6

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!


Existe alguma razão específica para você usar em 8d 1fvez de 89 fb?
Ruslan

2
A verdadeira questão é: existe alguma razão específica para você usar essa abominável sintaxe da AT&T?!? Além disso, a desmontagem e sua desmontagem concordam que você tem add eax, 2+ dec eax, mas seus comentários sugerem que você deseja incrementar ebx, não eax.
Cody Gray

11
Você pode substituir jnz Next/ add/ dec(7 bytes) por lea -1(%rax, %rbx, 2), %eax(4 bytes) a ser executado eax += 2*ebx - 1(como na outra resposta do código de máquina x86 ). Depois, fora do loop, neg %eax(2 bytes) antes de mudar o bit de sinal para o fundo. Economia líquida de 1 byte. Ou test %eax,%eax/ setge %altambém funcionaria, se o seu valor de retorno for um boolou int8_t.
Peter Cordes

11
@ PeterCordes Acho que sei o que aconteceu, mas não tenho certeza: talvez eu não tenha tentado lea -1(%rax,rbx,2)apenas lea -1(%eax,%eax,2)e desperdiçado bytes dessa maneira. Enfim, vocês dois estavam certos, posso salvar um byte como esse. Muito obrigado (em troca, vou mudar isso leapor um movtempo)!
ბიმო

11
@ moonheart08: Eu não sabia disso naquela época, mas alguém postou uma resposta que salvou 7 bytes.
ბიმო 7/02

5

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

5

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

5

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!


mod n 2pode ser justo ne é um byte mais curto sem um acumulador. Experimente online!
Ørjan Johansen

5

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.


${1}pode ser $+. Ou você pode usar em !vez de 0e encurtar 01|10para .\b..
Martin Ender

@MartinEnder Huh, faz $+a coisa certa quando o padrão contém um |? Gostaria de saber se eu poderia ter usado isso antes ...
Neil

2
não, $+é super estúpido e simplesmente usa o grupo com o maior número, tenha sido usado ou não. Só é útil para jogar golfe quando você tem mais de nove grupos ou em uma situação como a daqui, e não sei por que o usaria em um regex de produção.
Martin Ender


5

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:



4

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.


4

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!


4

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:

111100101ones>zeroes1 1

ones>zeroesones-1 1>zeroes-1 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.

2
Embora isso seja inspirado na resposta do Deadcode , o algoritmo é diferente o suficiente para que eu merecesse uma resposta separada em vez de um comentário.
Grimmy

2
Isso é fenomenal e exatamente o que eu queria ver (alguém soprando meu regex fora da água com um algoritmo muito mais conciso). Mas seus comentários realmente não explicam nada, e a versão comentada de 73 bytes da regex nem funciona (as referências \5posteriores são desativadas uma a uma). Estudei isso, expliquei e comentei na minha resposta (porque o StackExchange não permite respostas de várias linhas).
Deadcode

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



3

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 (/)

11
(#<2*+/)@#:deve salvar 1, a menos que esteja faltando alguma coisa.
FrownyFrog

3

Julia, 22 bytes

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




2

C #, 82 bytes

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

Você pode aparar um pouco mais tratando a string como um IEnumerable <char>. n=>{var s=Convert.ToString(n,2);return s.Count(c=>c=='1')>s.Length/2;}
GalacticCowboy

@GalacticCowboy Isso adiciona 11 bytes porque você precisa se qualificar Converte incluir totalmente using System.Linq;(escrito mais curto como namespace System.Linq{}). A boa ideia simplesmente não raspa o suficiente para justificar a economia nesse caso.
TheLethalCoder
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.