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

З урахуванням додатного цілого числа як вхідного даних, виведіть коефіцієнт truthy, якщо він є бінарним важким, а значення фальси, якщо це не так.

Тестові шафи

Формат: 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, callee дозволено clobber edx), хоча він може тривільно змінюватися для інших конвенцій викликів, які передають аргументи в регістри.

Він повертає 255 як truthy, а 0 як falsey.

Він використовує незадокументований (але широко підтримуваний) опкод 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

Врожайність не порожній вихід (truthy) або порожній вихід (ложно).

Спробуйте в Інтернеті!

Як це працює

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може працювати у відповіді Октави алефальфи і зрозумів, що в MATL є якийсь еквівалент.

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

Математика, 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 байт завдяки Максу Лаунбою

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

Перевірте це

Розширено:

{      # 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 Johansen знайшов кілька ярликів і врятував 7 байт. Дякую!

Сітківка , 37 34 байт

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

1+

Спробуйте в Інтернеті! Посилання включає в себе менші тестові випадки (у більших, можливо, не вистачить пам'яті). Редагувати: збережено 3 байти завдяки @MartinEnder. Пояснення: Перший етап перетворюється з десяткового в одинарний, а наступні два етапи перетворюються з одинарного на двійковий (це майже прямо з одинарної сторінки арифметики на Вікі сітці, за винятком того, що я використовую @замість цього 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).

На жаль, час роботи TIO у Kotlin здається 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 байт, що змінює час на рекурсивний для та повертає bool замість цілого.

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

Спробуйте в Інтернеті!

Regex (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.

Regex (ECMAScript), 183 байт

Це було ще однією цікавою проблемою, яку слід вирішити за допомогою регулярного виразу ECMA. "Очевидний" спосіб вирішити це - підрахувати кількість 1бітів і порівняти їх із загальною кількістю бітів. Але ви не можете безпосередньо рахувати речі в регулярному вираженні ECMAScript - відсутність стійких зворотних посилань означає, що в циклі може бути змінено лише одне число, і на кожному кроці його можна лише зменшити.

Цей одинарний алгоритм працює наступним чином:

1. Візьміть квадратний корінь з найбільшою потужністю 2, який вписується в N, і зверніть увагу на те, чи був квадратний корінь ідеальним чи його треба було округлити вниз. Це буде використано пізніше.
2. У циклі перемістіть кожен найзначніший 1біт до найменш значущої позиції, де є 0біт. Кожен з цих кроків є відніманням. В кінці циклу, що залишилося число (як це було б представлено у двійковому) - це рядок 1s без 0s. Ці операції фактично робляться унітарно; це лише концептуально, що вони робляться у двійковій формі.
3. Порівняйте цю "двійкову рядок 1s" з квадратним коренем, отриманим раніше. Якщо квадратний корінь довелося закруглити вниз, скористайтеся його подвоєною версією. Це гарантує, що "двійковий рядок 1s" повинен мати більше половини більшої кількості двійкових цифр, ніж N, щоб відбувся фінальний збіг.

Для отримання квадратного кореня використовується варіант алгоритму множення, коротко описаний у моєму регекс-пості про номери Rocco . Для ідентифікації найменш значущого 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

Це просто відповідь на відповідь С @ cleblanc . Це довше, ніж інші відповіді Python, але я подумав, що варто розміщувати повідомлення, оскільки це абсолютно інший метод пошуку відповіді.

Спробуйте в Інтернеті!

C #, 82 байти

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