Целое число является двоичным тяжелым, если его двоичное представление содержит больше 1s, чем 0s, игнорируя при этом ведущие нули. Например, 1 двоично-тяжелый, поскольку его двоичное представление просто 1, однако 4 не двоично-тяжелый, как его двоичное представление 100. В случае связи (например, 2 с двоичным представлением 10) число не считается двоичным.

Учитывая положительное целое число в качестве входных данных, выведите истинное значение, если оно двоично-тяжелое, и ложное значение, если это не так.

Testcases

Формат: 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

счет

Это код-гольф, поэтому побеждает меньше байтов на каждом языке

Машинный код x86, 15 14 байт

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

Это функция, использующая соглашение о вызовах __fastcall от Microsoft (первый и единственный параметр в ecx, возвращаемое значение в eax, вызываемый объект может закрывать edx), хотя ее можно легко изменить для других соглашений о вызовах, которые передают аргументы в регистрах.

Возвращает 255 как правдивую и 0 как ложную.

Он использует недокументированный (но широко поддерживаемый) код операции salc.

Разборка ниже:

;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

Попробуйте онлайн!

Спасибо Питеру Кордесу за предложение заменить lzcntна bsr.

Желе , 5 байт

Bo-SR

Выдает непустой вывод (истинный) или пустой вывод (ложный).

Попробуйте онлайн!

Как это устроено

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 байт

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

Попробуйте онлайн!

Старый ответ, 38 байт

^{Выводы 0как ложные и / -2или -1правдивые}

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

Попробуйте онлайн!

Октава , 18 байт

@(n)mode(de2bi(n))

TIO не работает, так как инструментарий связи не включен. Это можно проверить на Octave-Online .

Как это работает:

de2biпреобразует десятичное число в двоичный числовой вектор, а не в строку, как это dec2binделает.

modeвозвращает наиболее частую цифру в векторе. По умолчанию это самый низкий уровень в случае ничьей.

@(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 байта

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

MATL , 3 байта

BXM

Попробуйте онлайн!

Я действительно не знаю MATL, я только заметил, что это modeможет сработать в ответе Octave от alephalpha, и решил, что в MATL есть какой-то эквивалент.

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

Mathematica, 22 байта

Сохранено один байт благодаря @MartinEnder и @JungHwanMin .

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

Брахилог , 6 байт

ḃọtᵐ>₁

Попробуйте онлайн!

объяснение

Example input: 13

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

Поскольку ḃникогда не объединять свой вывод со списком цифр с ведущими нулями, мы знаем, что вхождения 1всегда будут первыми, а вхождения 0всегда будут вторыми после ọ.

Python 3 ,  44  (спасибо @ c-mcavoy) 40 байт

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

Попробуйте онлайн!

C (gcc) , 51 48 41 40 байт

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

Попробуйте онлайн!

R , 54 53 51 байт

-1 байт благодаря Max Lawnboy

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

читает со стандартного ввода; возвращает TRUEдвоичные тяжелые числа. dколичество двоичных цифр; sum(n%/%2^(0:d)%%2вычисляет сумму цифр (т. е. количество единиц).

Попробуйте онлайн!

машинный код x86_64, 23 22 21 байт

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

Разобрал:

  # 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

Спасибо @Ruslan, @PeterCordes за -1байт!

Попробуйте онлайн!

Perl 6 ,  32  30 байт

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

Проверь это

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

Проверь это

Expanded:

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

Мудрый , 40 39 байт

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

Попробуйте онлайн!

объяснение

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

Хаскелл, 41 34

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

Если nэто нечетно, возьмите, -1если это четное, возьмите 1. Добавить рекурсивный вызов с помощью n/2и прекратить, если n = 0. Если результат меньше, чем 0число является двоичным тяжелым.

Попробуйте онлайн!

Редактировать: @ Ørjan Йохансен нашел несколько ярлыков и сохранил 7 байтов. Спасибо!

Сетчатка , 37 34 байта

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

1+

Попробуйте онлайн! Ссылка включает в себя меньшие тестовые случаи (более крупные, вероятно, не хватило бы памяти). Редактировать: 3 байта сохранены благодаря @MartinEnder. Объяснение: Первый этап преобразуется из десятичного в унарный, а следующие два этапа преобразуются из унарного в двоичный (это почти прямо из унарной арифметической страницы в вики Retina, за исключением того, что я использую @вместо 0). Третий этап ищет пары разнородных символов, которые могут быть как @1или 1@, так и удаляет их, пока не останется ни одного. Последний этап затем проверяет оставшиеся 1 с.

R , 43 байта

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

Попробуйте онлайн!

             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

Котлин , 50 байтов

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

Лямбда неявного типа (Int) -> Boolean. Версия 1.1 и выше только за счет использования Int.toString(radix: Int).

К сожалению, среда выполнения Kotlin в TIO выглядит как 1.0.x, так что вместо ссылки TIO здесь есть грустная собака:

Pyth, 9 7 байт

ehc2S.B

Попробуй это здесь.

-2 благодаря FryAmTheEggman .

R, 39 37 байт

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

Это комбинация методов, используемых @MickyT и @Giuseppe, сохраняя еще несколько байтов.

sum(intToBits(x) > 0)подсчитывает количество 1бит и 2+log2(x)/2составляет половину от общего количества бит при округлении в меньшую сторону. Нам не нужно округлять из-за поведения, когда два значения равны.

C # (.NET Core) , 62 , 49 байтов

Без LINQ.

РЕДАКТИРОВАТЬ: дана с -13 байтовым гольфом, изменяющим время на рекурсивный для и возвращающим бул вместо целого числа.

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

Попробуйте онлайн!

Регулярное выражение (ECMAScript), 85 73 71 байт

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

Попробуйте онлайн!

_{^{объяснение по Deadcode}}

Более ранняя 73-байтовая версия описана ниже.

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

Из-за ограничений регулярного выражения ECMAScript эффективная тактика часто заключается в преобразовании числа на один шаг за раз, сохраняя при этом обязательное свойство неизменным на каждом этапе. Например, чтобы проверить идеальный квадрат или степень 2, уменьшите число в размерах, сохраняя при этом квадрат или степень 2 (соответственно) на каждом шаге.

Вот что делает это решение на каждом этапе:

111100101$ones>zeroes$$1$

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

Когда эти повторяющиеся шаги не могут идти дальше, конечным результатом будет либо непрерывная цепочка 1битов, которая является тяжелой и указывает, что исходное число также было тяжелым, либо степень 2, что указывает на то, что исходное число не было тяжелым.

И конечно, хотя эти шаги описаны выше в терминах типографских манипуляций над двоичным представлением числа, они фактически реализованы как унарная арифметика.

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

Регулярное выражение (ECMAScript), 183 байта

Это была еще одна интересная проблема, которую нужно решить с помощью регулярного выражения ECMA. «Очевидный» способ справиться с этим - подсчитать количество 1битов и сравнить их с общим количеством битов. Но вы не можете напрямую сосчитать вещи в регулярном выражении ECMAScript - отсутствие постоянных обратных ссылок означает, что в цикле можно изменить только одно число, и на каждом шаге его можно только уменьшить.

Этот унарный алгоритм работает следующим образом:

1. Возьмите квадратный корень из наибольшей степени 2, который вписывается в N, и обратите внимание на то, был ли квадратный корень идеальным или его нужно было округлить в меньшую сторону. Это будет использовано позже.
2. В цикле переместите каждый старший значащий 1бит в наименее значимое положение, где есть 0бит. Каждый из этих шагов является вычитанием. В конце цикла оставшееся число (как оно будет представлено в двоичном виде) представляет собой строку 1s без 0s. Эти операции фактически выполняются в унарном порядке; это только концептуально, что они делаются в двоичном формате.
3. Сравните эту "двоичную строку 1s" с квадратным корнем, полученным ранее. Если квадратный корень нужно было округлить в меньшую сторону, используйте двойную версию. Это гарантирует, что «двоичная строка 1s» должна иметь более половины числа двоичных цифр, чем N, чтобы иметь место окончательное совпадение.

Чтобы получить квадратный корень, используется вариант алгоритма умножения, кратко описанного в моем посте регулярных выражений чисел Рокко . Чтобы идентифицировать младший значащий 0бит, используется алгоритм деления, кратко описанный в моем посте регулярных выражений факторных чисел . Это спойлеры . Так что не читайте дальше, если вы не хотите, чтобы какая-то продвинутая магия унарных регулярных выражений была испорчена для вас . Если вы действительно хотите сами разобраться в этой магии, я настоятельно рекомендую начать с решения некоторых проблем в списке последовательно рекомендованных проблем с помеченными спойлерами в этом предыдущем посте и попытаться найти математическое понимание самостоятельно.

Без дальнейших церемоний, регулярное выражение:

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

Попробуйте онлайн!

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

Желе , 6 байт

Bµċ0<S

Попробуйте онлайн!

J , 12 байт

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

J выполняет глаголы справа налево, поэтому давайте начнем с конца и продолжим путь к началу.

объяснение

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

Юлия, 22 байта

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

Октава , 26 байт

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

Попробуйте онлайн!

PHP , 44 байта

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

Попробуйте онлайн!

PHP , 48 байт

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

Попробуйте онлайн!

Python 2 , 44 байта

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

Попробуйте онлайн!

Старый ответ, 47 байт

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

Это просто порт ответа C cleblanc . Это длиннее, чем другие ответы Python, но я решил, что это стоит опубликовать, поскольку это совершенно другой метод поиска ответа.

Попробуйте онлайн!

C #, 82 байта

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