Bạn sẽ được cung cấp dưới dạng đầu vào một số nguyên ktrong phạm vi từ -4503599627370496(−2 ⁵² ) đến 4503599627370496(2 ⁵² ). Như đã biết , các số nguyên trong phạm vi này có thể được biểu diễn chính xác dưới dạng các giá trị dấu phẩy động có độ chính xác kép.

Bạn nên đầu ra các trọng lượng Hamming (số người) của mã hóa ktrong định dạng binary64 . Điều này sử dụng 1 bit cho dấu hiệu, 11 bit cho số mũ (được mã hóa với phần bù) và 52 bit cho lớp phủ; xem liên kết trên để biết chi tiết.

Như một ví dụ , số 22được biểu diễn dưới dạng

0 10000000011 0110000000000000000000000000000000000000000000000000

Vì có 5những cái, đầu ra là 5.

Lưu ý rằng độ bền không ảnh hưởng đến kết quả, vì vậy bạn có thể sử dụng một cách an toàn biểu diễn bên trong của các giá trị độ chính xác kép để tính toán đầu ra.

Quy tắc bổ sung

• Chương trình hoặc chức năng được cho phép.
• Bất kỳ ngôn ngữ lập trình có thể được sử dụng.
• Sơ hở tiêu chuẩn bị cấm
• Số đầu vào sẽ ở dạng thập phân. Ngoài ra, định dạng đầu vào / đầu ra và định dạng linh hoạt như bình thường.
• Mã ngắn nhất trong byte thắng.

Các trường hợp thử nghiệm

22                ->   5
714               ->   6
0                 ->   0
1                 ->  10
4503599627370496  ->   5
4503599627370495  ->  55
1024              ->   3
-1024             ->   4
-4096             ->   5
1000000000        ->  16
-12345678         ->  16

MATL , 5 byte

3Z%Bz

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

Phiên âm chính xác câu trả lời MATLAB của tôi. Lưu ý rằng đầu vào và đầu ra là ẩn. -2 byte nhờ Luis Mendo.

3Z%   % Typecast: changes input (implicitly taken and converted to double) to uint64 without changing underlying bits
B     % Convert integer to array of 1s and 0s
z     % Count nonzero entries

ngôn ngữ máy x86_64 (Linux), 16 byte

0:       f2 48 0f 2a c7          cvtsi2sd %rdi,  %xmm0
5:       66 48 0f 7e c0          movq     %xmm0, %rax
a:       f3 48 0f b8 c0          popcnt   %rax,  %rax
f:       c3                      retq

Chấp nhận một tham số nguyên 64 bit duy nhất RDI, chuyển đổi nó thành giá trị dấu phẩy động XMM0, lưu các bit đó trở lại RAXvà sau đó tính trọng số hãm của RAX, để lại kết quả RAXđể có thể trả về cho người gọi.

Yêu cầu bộ xử lý hỗ trợ POPCNThướng dẫn, đó sẽ là Intel Nehalem, AMD Barcelona và các kiến ​​trúc vi mô sau này.

Để thử trực tuyến! , biên dịch và chạy chương trình C sau:

#include<stdio.h>
const char g[]="\xF2\x48\x0F\x2A\xC7\x66\x48\x0F\x7E\xC0\xF3\x48\x0F\xB8\xC0\xC3";
#define f(x) ((int(*)(long))g)(x)

int main(int a){
  printf("%d\n",f(22));
  printf("%d\n",f(714));
  printf("%d\n",f(0));
  printf("%d\n",f(1));
  printf("%d\n",f(4503599627370496L));
  printf("%d\n",f(4503599627370495L));
  printf("%d\n",f(1024));
  printf("%d\n",f(-1024));
  printf("%d\n",f(-4096));
  printf("%d\n",f(1000000000));
  printf("%d\n",f(-12345678));
}

C (gcc) , 82 68 byte

9 byte nhờ Neil.

hack điểm nổi cấp độ ác

s;f(long n){double d=n;n=*(long*)&d;for(s=0;n;n*=2)s+=n<0;return s;}

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

Python 3 , 72 71 byte

1 byte nhờ Lynn.

lambda n:n and(bin(1020+len(bin(abs(n))))+bin(abs(n))).count('1')-(n>0)

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

Giải trình

Định dạng binary64 bao gồm ba thành phần:

• bit đầu tiên là bit dấu, đó là 1nếu số âm
• 11 bit tiếp theo lưu trữ số mũ với 1023 được thêm vào
• 52 bit tiếp theo lưu trữ ý nghĩa hoặc mantissa.

C (gcc) , 47 byte

f(double n){n=__builtin_popcountl(*(long*)&n);}

Đây không phải là di động; nó đã được thử nghiệm với gcc 7.1.1 trên x86_64 chạy Linux, không có cờ biên dịch.

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

Java (OpenJDK 8) , 92 byte

int f(long n){int s=0;for(n=Double.doubleToLongBits((double)n);n!=0;n>>>=1)s+=n&1;return s;}

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

C (gcc), 63 byte

f(double d){long s=0,n=*(long*)&d;for(;n;n*=2)s+=n<0;return s;}

Giải pháp này dựa trên câu trả lời của @ LeakyNun, nhưng vì anh ấy không muốn cải thiện câu trả lời của chính mình, tôi sẽ đăng lên đây phiên bản chơi gôn nhiều hơn.

Dùng thử trực tuyến

C #, 81 70 68 byte

d=>{unsafe{long l=*(long*)&d,s=0;for(;l!=0;l*=2)s-=l>>63;return s;}}

Lưu 11 byte nhờ @Leaky Nun.
Đã lưu 2 byte nhờ @Neil.

Hãy thử trực tuyến! Sử dụng System.BitConverter.DoubleToInt64Bitsthay vì unsafemã như tôi không thể khiến TIO làm việc với nó.

Phiên bản đầy đủ / định dạng:

namespace System
{
    class P
    {
        static void Main()
        {
            Func<double, long> f = d =>
            {
                unsafe
                {
                    long l = *(long*)&d, s = 0;

                    for (; l != 0; l *= 2)
                        s -= l >> 63;
                    return s;
                }
            };

            Console.WriteLine(f(22));
            Console.WriteLine(f(714));
            Console.WriteLine(f(0));
            Console.WriteLine(f(1));
            Console.WriteLine(f(4503599627370496));
            Console.WriteLine(f(4503599627370495));
            Console.WriteLine(f(1024));
            Console.WriteLine(f(-1024));
            Console.WriteLine(f(-4096));
            Console.WriteLine(f(1000000000));
            Console.WriteLine(f(-12345678));

            Console.ReadLine();
        }
    }
}

Python 2 , 69 byte

-12 byte, chỉ nhờ @ ASCII

lambda n:bin(*unpack('Q',pack('d',n))).count('1')
from struct import*

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

JavaScript (ES6), 81 80 77 byte

f=
n=>new Uint8Array(Float64Array.of(n).buffer).map(g=i=>i&&g(i^i&-i,x++),x=0)|x

<input oninput=o.textContent=f(this.value)><pre id=o>0

Chỉnh sửa: Đã lưu 1 byte nhờ @Arnauld. Đã lưu 3 byte nhờ @DocMax.

Mã máy x86-64, 12 byte cho int64_tđầu vào

6 byte cho doubleđầu vào

Yêu cầu popcntphần mở rộng ISA ( CPUID.01H:ECX.POPCNT [Bit 23] = 1).

. -cung cấp từ 32 đến 64 ngầm với mọi thao tác 32 bit. Tuy nhiên, nó sẽ ngăn người gọi thực hiện add rbx, [rdi]hoặc làm gì đó.)

Các hướng dẫn x87 ngắn hơn so với SSE2 cvtsi2sd/ movq( rõ ràng hơn được sử dụng trong câu trả lời của @ trần ) và [reg]chế độ địa chỉ có cùng kích thước với reg: chỉ là một byte mod / rm.

Bí quyết là đưa ra một cách để có giá trị được truyền vào bộ nhớ, mà không cần quá nhiều byte cho các chế độ địa chỉ. (ví dụ: truyền vào ngăn xếp không phải là tuyệt vời.) May mắn thay, các quy tắc cho phép đọc / ghi đối số hoặc các đối số đầu ra riêng biệt , vì vậy tôi có thể khiến người gọi chuyển cho tôi một con trỏ tới bộ nhớ mà tôi được phép viết.

Có thể gọi từ C với chữ ký: void popc_double(int64_t *in_out); Chỉ 32b thấp của kết quả là hợp lệ, điều này có thể lạ đối với C nhưng tự nhiên đối với asm. (Việc sửa lỗi này yêu cầu tiền tố REX trên cửa hàng cuối cùng ( mov [rdi], rax), do đó, thêm một byte.) Trên Windows, hãy đổi rdithành rdx, vì Windows không sử dụng x86-64 System V ABI.

Danh sách NASM. Liên kết TIO có mã nguồn mà không cần tháo gỡ.

  1  addr    machine      global popcnt_double_outarg
  2          code         popcnt_double_outarg:
  3                           ;; normal x86-64 ABI, or x32: void pcd(int64_t *in_out)
  4 00000000 DF2F             fild qword  [rdi]    ; int64_t -> st0
  5 00000002 DD1F             fstp qword  [rdi]    ; store binary64, using retval as scratch space.
  6 00000004 F3480FB807       popcnt rax, [rdi]
  7 00000009 8907             mov    [rdi], eax    ; update only the low 32b of the in/out arg
  8 0000000B C3               ret
    # ends at 0x0C = 12 bytes

Hãy thử trực tuyến! Bao gồm một_startchương trình thử nghiệm vượt qua nó một giá trị và thoát với trạng thái thoát = giá trị trả về popcnt. (Mở tab "gỡ lỗi" để xem nó.)

Việc truyền các con trỏ đầu vào / đầu ra riêng biệt cũng sẽ hoạt động (rdi và rsi trong x86-64 SystemV ABI), nhưng sau đó chúng ta không thể phá hủy hợp lý đầu vào 64 bit hoặc dễ dàng biện minh là cần bộ đệm đầu ra 64 bit trong khi chỉ viết thấp 32b.

Nếu chúng ta muốn lập luận rằng chúng ta có thể lấy một con trỏ tới số nguyên đầu vào và hủy nó, trong khi trả lại đầu ra rax, sau đó chỉ cần bỏ qua mov [rdi], eaxtừ popcnt_double_outarg, đưa nó xuống còn 10 byte.

Thay thế mà không có thủ thuật gọi hội nghị ngớ ngẩn, 14 byte

sử dụng ngăn xếp như không gian đầu, pushđể có được nó ở đó. Sử dụng push/ popđể sao chép các thanh ghi trong 2 byte thay vì 3 cho mov rdi, rsp. ( [rsp]luôn cần một byte SIB, vì vậy, đáng để chi 2 byte để sao chép rsptrước ba hướng dẫn sử dụng nó.)

Gọi từ C với chữ ký này: int popcnt_double_push(int64_t);

 11                               global popcnt_double_push
 12                               popcnt_double_push:
 13 00000040 57                       push   rdi         ; put the input arg on the stack (still in binary integer format)
 14 00000041 54                       push   rsp         ; pushes the old value (rsp updates after the store).
 15 00000042 5A                       pop    rdx         ; mov      rdx, rsp
 16 00000043 DF2A                     fild   qword [rdx]
 17 00000045 DD1A                     fstp   qword [rdx]
 18 00000047 F3480FB802               popcnt rax,  [rdx]
 19 0000004C 5F                       pop    rdi         ; rebalance the stack
 20 0000004D C3                       ret
    next byte is 0x4E, so size = 14 bytes.

Chấp nhận đầu vào ở doubleđịnh dạng

Câu hỏi chỉ nói rằng đó là một số nguyên trong một phạm vi nhất định, không phải là nó phải nằm trong biểu diễn số nguyên nhị phân base2. Chấp nhận doubleđầu vào có nghĩa là không còn sử dụng x87 nữa. (Trừ khi bạn sử dụng quy ước gọi tùy chỉnh trong đó doubles được truyền trong các thanh ghi x87. Sau đó lưu trữ vào vùng màu đỏ bên dưới ngăn xếp và popcnt từ đó.)

11 byte:

 57 00000110 66480F7EC0               movq    rax, xmm0
 58 00000115 F3480FB8C0               popcnt  rax, rax
 59 0000011A C3                       ret

Nhưng chúng ta có thể sử dụng thủ thuật chuyển qua tham chiếu tương tự như trước đây để tạo phiên bản 6 byte: int pcd(const double&d);

 58 00000110 F3480FB807               popcnt  rax, [rdi]
 59 00000115 C3                       ret

6 byte .

Perl 5 , 33 32 + 1 (-p) = 34 33 byte

Đã lưu 1 byte nhờ hobbs

$_=(unpack"B*",pack d,$_)=~y/1//

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

MATLAB, 36 byte

@(n)nnz(de2bi(typecast(n,'uint64')))

Sử dụng thực tế de2bikhông chỉ ngắn hơn dec2bin, mà còn cung cấp kết quả trong các số và số 0 thay vì ASCII 48, 49.

Java (64, 61, 41 byte)

Hoàn toàn đơn giản khi sử dụng thư viện chuẩn (Java SE 5+):

int f (dài n) {trả về Dài. bitCount (Nhân đôi. doubleToLongBits (n));}

Đóng góp của Kevin Cruijssen (Java SE 5+):

int f(Long n){return n.bitCount(Double.doubleToLongBits(n));}

Đóng góp của Kevin Cruijssen (Java SE 8+, chức năng lambda):

n->n.bitCount(Double.doubleToLongBits(n))

Chỉ để thử một cách khác, an toàn hơn - cách tiếp cận so với- TheLethalCoder , tôi đã nghĩ ra điều này (thật đáng tiếc C # có tên phương thức dài như vậy):

C # (Lõi .NET) , 76 + 13 byte

d=>Convert.ToString(BitConverter.DoubleToInt64Bits(d),2).Split('1').Length-1

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

Số lượng byte bao gồm 13 byte cho using System;. Đầu tiên tôi cần chuyển đổi doublemột longcái có cùng biểu diễn nhị phân, sau đó tôi có thể chuyển đổi nó thành nhị phân string, sau đó tôi đếm 1s chỉ bằng cách tách chuỗi và đếm các chuỗi con trừ đi 1.

Thạch , 19 byte

AB©L+⁽¡ßB;®ċ1_>0$a@

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

dc, 79 byte

[pq]su[-1r]st0dsb?dd0=u0>tsa[1+]ss[la2%1=slb1+sblad2/sa1<r]dsrxlb1022+sa0lrx+1-

Đầu ra được để lại trên đầu ngăn xếp.
Tôi sẽ thêm một lời giải thích sau.

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

Lưu ý rằng số âm được đi trước _, không -.

Groovy (với trình phân tích cú pháp Parrot) , 46 byte

f=n->Long.bitCount(Double.doubleToLongBits(n))

C, 67 byte

int i;g(char*v){int j=v[i/8]&1<<i%8;return!!j+(++i<64?g(v):(i=0));}

mã kiểm soát và kết quả

#define R     return
#define u32 unsigned
#define F        for
#define P     printf

int main()
{/*           5   6 0 10                5               55    3      4       16*/
 double v[]={22,714,0,1 ,4503599627370496,4503599627370495,1024, -1024, -12345678};
 int i; 

 F(i=0;i<9;++i)
     P("%f = %d\n", v[i], g(&v[i]));
 R 0;
}

>tri4
22.000000 = 5
714.000000 = 6
0.000000 = 0
1.000000 = 10
4503599627370496.000000 = 5
4503599627370495.000000 = 55
1024.000000 = 3
-1024.000000 = 4
-12345678.000000 = 16

Erlang 55 byte

fun(X)->length([Y||<<Y:1>><=<<X:64/float>>,Y=:=1])end.

Một hàm ẩn danh đếm tất cả các 1s trong một số được mã hóa dưới dạng float 64 bit.

tài liệu tham khảo:

• http://erlang.org/doc/programming_examples/bit_syntax.html
• http://erlang.org/doc/programming_examples/list_comprehensions.html