คุณจะได้รับเป็นอินพุตจำนวนเต็มkในช่วงตั้งแต่-4503599627370496(−2 ⁵² ) ถึง4503599627370496(2 ⁵² ) ในฐานะที่เป็นที่รู้จักกันดีจำนวนเต็มในช่วงนี้สามารถแทนค่าทศนิยมที่มีความแม่นยำสองเท่า

คุณควรส่งออกน้ำหนัก Hamming (จำนวนคน) ของการเข้ารหัสของkใน รูปแบบ binary64 สิ่งนี้ใช้ 1 บิตสำหรับเครื่องหมาย, 11 บิตสำหรับเลขชี้กำลัง (เข้ารหัสด้วยออฟเซ็ต) และ 52 สำหรับ mantissa; ดูลิงค์ด้านบนเพื่อดูรายละเอียด

ในฐานะที่เป็นตัวอย่างจำนวน22จะแสดงเป็น

0 10000000011 0110000000000000000000000000000000000000000000000000

เนื่องจากมีคนออกเป็น55

โปรดทราบว่า endianness จะไม่ส่งผลกระทบต่อผลลัพธ์ดังนั้นคุณสามารถใช้การแทนค่าภายในที่แท้จริงของเครื่องเพื่อคำนวณผลลัพธ์ได้อย่างปลอดภัย

กฎเพิ่มเติม

• อนุญาตให้ใช้โปรแกรมหรือฟังก์ชั่น
• สามารถใช้ภาษาโปรแกรมใดก็ได้
• ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม
• หมายเลขอินพุตจะเป็นทศนิยม นอกเหนือจากนั้นหมายถึงอินพุต / เอาต์พุตและรูปแบบมีความยืดหยุ่นตามปกติ
• รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ

กรณีทดสอบ

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

MATL , 5 ไบต์

3Z%Bz

ลองออนไลน์!

การทับศัพท์ที่แน่นอนของคำตอบ MATLAB ของฉัน โปรดทราบว่าอินพุตและเอาต์พุตมีความหมายโดยนัย -2 ไบต์ขอบคุณ 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

x86_64 ภาษาเครื่อง (Linux), 16 ไบต์

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

ยอมรับพารามิเตอร์จำนวนเต็ม 64- บิตเดียวในRDIแปลงเป็นค่าเลขทศนิยมในXMM0เก็บบิตเหล่านั้นกลับมาRAXแล้วคำนวณน้ำหนัก hamming ของRAXออกจากผลลัพธ์RAXเพื่อให้สามารถส่งกลับไปยังผู้เรียก

ต้องใช้โปรเซสเซอร์ที่รองรับPOPCNTคำสั่งซึ่งจะเป็น Intel Nehalem, AMD Barcelona และสถาปัตยกรรมขนาดเล็กในภายหลัง

เพื่อลองออนไลน์! รวบรวมและเรียกใช้โปรแกรม C ต่อไปนี้:

#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 ไบต์

9 ไบต์ขอบคุณ Neil

การแฮ็กระดับบิตที่ลอยระดับความชั่วร้าย

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

ลองออนไลน์!

Python 3 , 72 71 ไบต์

1 ไบต์ต้องขอขอบคุณ Lynn

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

ลองออนไลน์!

คำอธิบาย

รูปแบบ binary64 ประกอบด้วยสามองค์ประกอบ:

• บิตแรกคือบิตเครื่องหมายซึ่งก็คือ1ถ้าจำนวนเป็นลบ
• 11 บิตถัดไปจะเก็บเลขชี้กำลังด้วยการเพิ่ม 1,023
• 52 บิตถัดไปจะเก็บซิกนิฟิแคนด์หรือแมนทิสซา

C (gcc) , 47 ไบต์

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

นี่ไม่ใช่พกพา มันได้รับการทดสอบด้วย gcc 7.1.1 บน x86_64 ที่ใช้ Linux โดยไม่มีธงของคอมไพเลอร์

ลองออนไลน์!

Java (OpenJDK 8) , 92 ไบต์

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

ลองออนไลน์!

C (gcc), 63 ไบต์

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

วิธีการแก้ปัญหานี้ขึ้นอยู่กับคำตอบของ @ LeakyNun แต่เนื่องจากเขาไม่ต้องการปรับปรุงคำตอบของเขาเองฉันจึงโพสต์เวอร์ชันที่ตีกอล์ฟให้มากกว่านี้

ลองออนไลน์

C #, 81 70 68 ไบต์

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

บันทึก 11 ไบต์ด้วย @Leaky Nun
บันทึก 2 ไบต์ขอบคุณ @Neil

ลองออนไลน์! ใช้System.BitConverter.DoubleToInt64Bitsแทนการunsafeรหัสเพราะฉันไม่สามารถทำให้ TIO ทำงานได้

เวอร์ชั่นเต็ม / ฟอร์แมต:

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 ไบต์

-12 ไบต์ขอบคุณ @ ASCII-only

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

ลองออนไลน์!

JavaScript (ES6), 81 80 77 ไบต์

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

แก้ไข: บันทึก 1 ไบต์ขอบคุณ @Arnauld บันทึก 3 ไบต์ด้วย @DocMax

รหัสเครื่อง x86-64, 12 ไบต์สำหรับint64_tอินพุต

6 ไบต์สำหรับdoubleอินพุต

ต้องการpopcntส่วนขยาย ISA ( CPUID.01H:ECX.POPCNT [Bit 23] = 1)

(หรือ 13 ไบต์หากการแก้ไข ARG แบบแทนที่ต้องเขียน 64- บิตทั้งหมดแทนที่จะทิ้งขยะใน 32 ด้านบนฉันคิดว่ามันสมเหตุสมผลที่จะโต้แย้งว่าผู้เรียกอาจต้องการโหลด 32b ต่ำเท่านั้นและ x86 ศูนย์ - ขยายจาก 32 ถึง 64 โดยนัยกับการดำเนินการทุก 32- บิต แต่มันจะหยุดไม่ให้ผู้เรียกทำadd rbx, [rdi]หรืออะไรบางอย่าง)

คำแนะนำ x87 จะสั้นกว่า SSE2 cvtsi2sd/ ชัดเจนมากขึ้นmovq(ใช้ในคำตอบของ @ ceilingcat ) และ[reg]โหมดการกำหนดแอดเดรสนั้นมีขนาดเท่ากับ a reg: เพียงแค่ mod / rm byte

เคล็ดลับคือการหาวิธีส่งค่าในหน่วยความจำโดยไม่จำเป็นต้องมีไบต์มากเกินไปสำหรับการกำหนดโหมด (เช่นการส่งผ่านสแต็กนั้นไม่ได้ยอดเยี่ยม) โชคดีที่กฎอนุญาตให้อ่าน / เขียน args หรือแยกเอาท์พุท argsดังนั้นฉันสามารถให้ผู้โทรส่งค่าตัวชี้ไปยังหน่วยความจำที่ฉันอนุญาตให้เขียนได้

เรียกได้จาก C ที่มีลายเซ็น: void popc_double(int64_t *in_out); ผลลัพธ์ที่ต่ำเพียง 32b นั้นใช้ได้ซึ่งอาจแปลกสำหรับ C แต่เป็นธรรมชาติสำหรับ asm (การแก้ไขนี้ต้องใช้คำนำหน้า REX ในร้านสุดท้าย ( mov [rdi], rax) ดังนั้นอีกหนึ่งไบต์) บน Windows เปลี่ยนrdiเป็นrdxเนื่องจาก Windows ไม่ได้ใช้ x86-64 System V ABI

รายชื่อ NASM ลิงก์ TIO มีซอร์สโค้ดโดยไม่มีการถอดแยก

  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

ลองออนไลน์! รวม_startโปรแกรมทดสอบที่ส่งค่าและออกด้วยสถานะการออก = ค่าส่งคืน popcnt (เปิดแท็บ "แก้ไขข้อบกพร่อง" เพื่อดู)

การผ่านตัวชี้อินพุต / เอาท์พุตแบบแยกจะทำงานได้เช่นกัน (rdi และ rsi ใน x86-64 SystemV ABI) แต่จากนั้นเราไม่สามารถทำลายอินพุต 64- บิตได้อย่างสมเหตุสมผลพอสมควร ต่ำ 32b

หากเราต้องการโต้แย้งว่าเราสามารถนำตัวชี้ไปยังจำนวนเต็มอินพุทและทำลายมันได้ในขณะที่ส่งคืนเอาต์พุตกลับมาraxก็เพียงแค่ละเว้นmov [rdi], eaxจากpopcnt_double_outargนั้นนำมาไว้ที่ 10 ไบต์

ทางเลือกโดยไม่มีเทคนิคการเรียกประชุมแบบโง่ 14 ไบต์

ใช้สแต็กเป็นพื้นที่เริ่มต้นpushเพื่อไปที่นั่น การใช้push/ popการคัดลอกลงทะเบียนใน 2 ไบต์แทน mov rdi, rsp3 ( [rsp]ต้องการ SIB ไบต์เสมอดังนั้นจึงควรใช้ 2 ไบต์เพื่อคัดลอกrspก่อนสามคำแนะนำที่ใช้)

โทรจาก C พร้อมลายเซ็นนี้: 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.

ยอมรับอินพุตในdoubleรูปแบบ

คำถามก็บอกว่ามันเป็นจำนวนเต็มในช่วงที่แน่นอนไม่ใช่ว่ามันจะต้องอยู่ในการแสดงจำนวนเต็ม base2 ไบนารี การยอมรับdoubleอินพุตหมายความว่าไม่มีประโยชน์ในการใช้ x87 อีกต่อไป (ยกเว้นว่าคุณใช้การเรียกแบบกำหนดเองที่doubleมีการส่งผ่าน s ในการลงทะเบียน x87 จากนั้นเก็บไว้ในพื้นที่สีแดงด้านล่างสแต็กและ popcnt จากที่นั่น)

11 ไบต์:

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

แต่เราสามารถใช้เคล็ดลับ Pass-by-Reference เช่นเดียวกับก่อนหน้านี้เพื่อสร้างเวอร์ชัน 6 ไบต์: int pcd(const double&d);

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

6 ไบต์

Perl 5 , 33 32 + 1 (-p) = 34 33 ไบต์

บันทึก 1 ไบต์ขอบคุณฮอบส์

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

ลองออนไลน์!

MATLAB, 36 ไบต์

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

การใช้ความจริงที่de2biไม่เพียง แต่สั้นกว่าdec2binเท่านั้น แต่ยังให้ผลลัพธ์ในรูปแบบและเลขศูนย์แทน ASCII 48, 49

Java (64, 61, 41 ไบต์)

ตรงไปตรงมาอย่างสมบูรณ์โดยใช้ไลบรารีมาตรฐาน (Java SE 5+):

int f (long n) {return Long bitCount (สองครั้งdoubleToLongBits (n));}

เงินบริจาคโดย Kevin Cruijssen (Java SE 5+):

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

บริจาคโดย Kevin Cruijssen (Java SE 8+, ฟังก์ชัน lambda):

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

เพียงลองใช้วิธีอื่นที่ปลอดภัยกว่าTheLethalCoderฉันมากับสิ่งนี้ (มันน่าเสียดาย C # มีชื่อวิธียาว ๆ ):

C # (. NET Core) , 76 + 13 ไบต์

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

ลองออนไลน์!

นับไบต์รวมถึง 13 using System;ไบต์ ก่อนอื่นฉันต้องแปลงdoublea ไปเป็น a longที่มีการแสดงเลขฐานสองเท่ากันจากนั้นฉันสามารถแปลงมันเป็นไบนารีstringแล้วนับจำนวน1s โดยการแยกสตริงและนับสารตั้งต้นลบ 1

เยลลี่ขนาด 19 ไบต์

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

ลองออนไลน์!

dc, 79 ไบต์

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

เอาต์พุตถูกทิ้งไว้ที่ด้านบนสุดของสแต็ก
ฉันจะเพิ่มคำอธิบายในภายหลัง

ลองออนไลน์!

โปรดทราบว่าตัวเลขที่ติดลบจะนำหน้าด้วยไม่ได้_-

Groovy (พร้อมตัวแยกวิเคราะห์ Parrot)ขนาด 46 ไบต์

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

C, 67 ไบต์

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

รหัสควบคุมและผลลัพธ์

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

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

An anonymous function that counts all the 1s in a number encoded as a 64 bit float.

references:

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