Một số nguyên nặng nhị phân nếu biểu diễn nhị phân của nó chứa nhiều 1s hơn 0s trong khi bỏ qua các số 0 đứng đầu. Ví dụ 1 là nặng nhị phân, vì biểu diễn nhị phân của nó đơn giản 1, tuy nhiên 4 không phải là nhị phân nặng, vì biểu diễn nhị phân của nó là 100. Trong trường hợp hòa (ví dụ 2, với biểu diễn nhị phân là 10), số này không được coi là nhị phân nặng.

Cho một số nguyên dương làm đầu vào, xuất giá trị trung thực nếu nó nặng nhị phân và giá trị falsey nếu không.

Tủ thử

Định dạng: 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

Chấm điểm

Đây là môn đánh gôn nên ít byte nhất trong mỗi ngôn ngữ sẽ thắng

Mã máy x86, 15 14 byte

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

Đây là một hàm sử dụng quy ước gọi __fastcall của Microsoft (tham số đầu tiên và duy nhất trong ecx, giá trị trả về trong eax, callee được phép ghi đè edx), mặc dù nó có thể được sửa đổi một cách tầm thường cho các quy ước gọi khác chuyển các đối số trong các thanh ghi.

Nó trả về 255 là trung thực và 0 là falsey.

Nó sử dụng opcode không có giấy tờ (nhưng được hỗ trợ rộng rãi) salc.

Tháo gỡ dưới đây:

;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

Hãy thử trực tuyến!

Cảm ơn Peter Cordes đã đề nghị thay thế lzcntbằng bsr.

Thạch , 5 byte

Bo-SR

Mang lại đầu ra không trống (trung thực) hoặc đầu ra trống (giả).

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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)

Hãy thử trực tuyến!

Câu trả lời cũ, 38 byte

^{Đầu ra 0là giả và -2hoặc -1là sự thật}

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

Hãy thử trực tuyến!

Octave , 18 byte

@(n)mode(de2bi(n))

TIO không hoạt động vì không bao gồm hộp công cụ truyền thông. Nó có thể được thử nghiệm trên Octave-Online .

Cách thức hoạt động:

de2bichuyển đổi một số thập phân thành một vectơ số nhị phân, không phải là một chuỗi như dec2bin.

modetrả về chữ số thường xuyên nhất trong vector. Nó mặc định ở mức thấp nhất trong trường hợp hòa.

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

Hãy thử trực tuyến!

Tôi thực sự không biết MATL, tôi chỉ nhận thấy rằng modecó thể hoạt động trong câu trả lời Octave của alephalpha và hình dung có một số tương đương trong MATL.

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

Toán học, 22 byte

Đã lưu một byte nhờ @MartinEnder và @JungHwanMin .

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

Brachylog , 6 byte

ḃọtᵐ>₁

Hãy thử trực tuyến!

Giải trình

Example input: 13

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

Vì ḃsẽ không bao giờ thống nhất đầu ra của nó với một danh sách các chữ số có các số 0 đứng đầu, chúng tôi biết rằng các lần xuất hiện 1sẽ luôn là đầu tiên và các lần xuất hiện 0sẽ luôn là thứ hai sau ọ.

Python 3 ,  44  (cảm ơn @ c-mcavoy) 40 byte

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

Hãy thử trực tuyến!

C (gcc) , 51 48 41 40 byte

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

Hãy thử trực tuyến!

R , 54 53 51 byte

-1 byte nhờ Max Lawnboy

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

đọc từ stdin; trả về TRUEcho số nặng nhị phân. dlà số chữ số nhị phân; sum(n%/%2^(0:d)%%2tính tổng các chữ số (nghĩa là số lượng).

Hãy thử trực tuyến!

mã máy 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

Đã tháo rời:

  # 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

Cảm ơn @Ruslan, @PeterCordes cho -1byte!

Hãy thử trực tuyến!

Perl 6 ,  32  30 byte

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

Kiểm tra nó

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

Kiểm tra nó

Mở rộng:

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

Khôn ngoan , 40 39 byte

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

Hãy thử trực tuyến!

Giải trình

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

Nếu nlà số lẻ, hãy lấy -1số chẵn, lấy một 1. Thêm một cuộc gọi đệ quy với n/2và dừng nếu n = 0. Nếu kết quả nhỏ hơn 0số nhị phân nặng.

Hãy thử trực tuyến!

Chỉnh sửa: @ rjan Johansen tìm thấy một số phím tắt và lưu 7 byte. Cảm ơn!

Võng mạc , 37 34 byte

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

1+

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm nhỏ hơn (những trường hợp lớn hơn có thể sẽ hết bộ nhớ). Chỉnh sửa: Đã lưu 3 byte nhờ @MartinEnder. Giải thích: Giai đoạn đầu tiên chuyển đổi từ thập phân sang đơn nguyên và hai giai đoạn tiếp theo chuyển đổi từ đơn phương sang nhị phân (điều này gần như thoát khỏi trang số học đơn nhất trên wiki Retina, ngoại trừ việc tôi đang sử dụng @thay vì 0). Giai đoạn thứ ba tìm kiếm các cặp nhân vật không giống nhau, có thể là @1hoặc 1@, và xóa chúng cho đến khi không còn lại. Giai đoạn cuối cùng sau đó kiểm tra 1s còn lại.

R , 43 byte

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

Hãy thử trực tuyến!

             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 của loại ngầm (Int) -> Boolean. Phiên bản 1.1 trở lên chỉ do sử dụng Int.toString(radix: Int).

Thật không may, thời gian chạy Kotlin của TIO dường như là 1.0.x, vì vậy đây là một con chó buồn thay vì liên kết TIO:

Bình thường, 9 7 byte

ehc2S.B

Hãy thử nó ở đây.

-2 cảm ơn FryAmTheEggman .

R, 39 37 byte

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

Đây là sự kết hợp của các phương thức được sử dụng bởi @MickyT và @Giuseppe, tiết kiệm một vài byte khác.

sum(intToBits(x) > 0)đếm số lượng 1bit và 2+log2(x)/2bằng một nửa tổng số bit, khi làm tròn xuống. Chúng ta không phải làm tròn vì hành vi khi hai giá trị bằng nhau.

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

Không có LINQ.

EDIT: dana với một golf -13 byte thay đổi thời gian thành đệ quy cho và trả về một bool thay vì số nguyên.

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

Hãy thử trực tuyến!

Regex (ECMAScript), 85 73 71 byte

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

Hãy thử trực tuyến!

_{^{giải thích bởi Deadcode}}

Phiên bản 73 byte trước đó được giải thích bên dưới.

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

Do những hạn chế của biểu thức chính của ECMAScript, một chiến thuật hiệu quả thường là biến đổi bước số một tại một thời điểm trong khi vẫn giữ bất động sản cần thiết ở mọi bước. Ví dụ, để kiểm tra một hình vuông hoàn hảo hoặc công suất là 2, hãy giảm số lượng kích thước trong khi vẫn giữ cho hình vuông hoặc công suất là 2 (tương ứng) ở mỗi bước.

Đây là những gì giải pháp này làm ở mỗi bước:

111100101$ones>zeroes$$1$

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

Khi các bước lặp lại này không thể tiến xa hơn, kết quả cuối cùng sẽ là một chuỗi 1bit liền kề , rất nặng và chỉ ra rằng số ban đầu cũng nặng, hoặc lũy thừa bằng 2, cho thấy số ban đầu không nặng.

Và tất nhiên, mặc dù các bước này được mô tả ở trên về mặt thao tác chính tả trên biểu diễn nhị phân của số, chúng thực sự được thực hiện dưới dạng số học đơn phương.

# 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

Đây là một vấn đề thú vị khác để giải quyết với regex ECMA. Cách "rõ ràng" để xử lý việc này là đếm số 1bit và so sánh với tổng số bit. Nhưng bạn không thể đếm trực tiếp mọi thứ trong biểu thức ECMAScript - việc thiếu các phản hồi liên tục có nghĩa là chỉ một số có thể được sửa đổi trong một vòng lặp và ở mỗi bước chỉ có thể giảm đi.

Thuật toán đơn nguyên này hoạt động như sau:

1. Lấy căn bậc hai có công suất lớn nhất bằng 2 phù hợp với N và lưu ý xem căn bậc hai là hoàn hảo hay phải làm tròn xuống. Điều này sẽ được sử dụng sau.
2. Trong một vòng lặp, di chuyển từng 1bit có ý nghĩa nhất đến vị trí ít quan trọng nhất trong đó có một 0bit. Mỗi bước này là một phép trừ. Ở cuối vòng lặp, số còn lại (như được biểu thị dưới dạng nhị phân) là một chuỗi 1s không có 0s. Các hoạt động này thực sự được thực hiện trong unary; Về mặt khái niệm, chúng chỉ được thực hiện ở dạng nhị phân.
3. So sánh "chuỗi nhị phân 1s" này với căn bậc hai thu được trước đó. Nếu căn bậc hai phải được làm tròn xuống, hãy sử dụng phiên bản nhân đôi của nó. Điều này đảm bảo rằng "chuỗi nhị phân của 1s" được yêu cầu phải có hơn một nửa số chữ số nhị phân như N để có kết quả khớp cuối cùng.

Để có được căn bậc hai, một biến thể của thuật toán nhân được mô tả ngắn gọn trong bài đăng regex số Rocco của tôi được sử dụng. Để xác định 0bit có ý nghĩa nhỏ nhất, thuật toán phân chia được mô tả ngắn gọn trong bài regex số giai thừa của tôi được sử dụng. Đây là những kẻ phá hoại . Vì vậy, đừng đọc thêm nữa nếu bạn không muốn một số phép thuật regex unary tiên tiến được làm hỏng cho bạn . Nếu bạn thực sự muốn tự mình tìm ra phép thuật này, tôi khuyên bạn nên bắt đầu bằng cách giải quyết một số vấn đề trong danh sách các vấn đề được đề xuất liên quan đến spoiler trong bài đăng trước đó và cố gắng đưa ra những hiểu biết toán học một cách độc lập.

Không có thêm rắc rối, 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)

Hãy thử trực tuyến!

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

Thạch , 6 byte

Bµċ0<S

Hãy thử trực tuyến!

J , 12 byte

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

J thực hiện các động từ từ phải sang trái, vì vậy chúng ta hãy bắt đầu ở cuối và làm theo cách của chúng ta về đầu.

Giải trình

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

Octave , 26 byte

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

Hãy thử trực tuyến!

PHP , 44 byte

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

Hãy thử trực tuyến!

PHP , 48 byte

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

Hãy thử trực tuyến!

Python 2 , 44 byte

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

Hãy thử trực tuyến!

Câu trả lời cũ, 47 byte

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

Đây chỉ đơn giản là một cổng của câu trả lời C của @ cleblanc . Nó dài hơn các câu trả lời Python khác nhưng tôi cho rằng nó đáng để đăng vì đây là một phương pháp hoàn toàn khác để tìm câu trả lời.

Hãy thử trực tuyến!

C #, 82 byte

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