使用C语言的长十进制二进制表示法

我一直在尝试使用C编程打印长整数的二进制表示形式

我的代码是

#include<stdio.h>
#include <stdlib.h>
#include<limits.h>

int main()
{
    long long number, binaryRepresentation = 0, baseOfOne = 1, remainder;
    scanf("%lld", &number);
    while(number > 0) {
        remainder = number % 2;
        binaryRepresentation = binaryRepresentation + remainder * baseOfOne;
        baseOfOne *= 10;
        number = number / 2;
    }
    printf("%lld\n", binaryRepresentation);

}

2.测试用例

5
101

9223372036854775807
-1024819115206086201

---

我不确定您真正想要实现什么，但这里有一些代码可以打印数字的二进制表示形式（将

typedef

更改为您想要的整数类型）：

typedef int shift\t；
#定义NBIT（大小（班次）*8）
void printnum（移位数，整数）
{
int k=（num&（1LL我不确定您真正想要实现的是什么，但这里有一些代码可以打印数字的二进制表示形式（将
typedef
更改为您想要的整数类型）：

typedef int shift\t；
#定义NBIT（大小（班次）*8）
void printnum（移位数，整数）
{
int k=（num&（1LL）为了解释一些注释，最简单的方法是使用
char
数组来保存二进制数字。此外，在处理位时，位运算符更清晰。否则，我保留了基本的代码结构

int main()
{
    char bits[64];
    int i = 0;
    unsigned long long number;   // note the "unsigned" type here which makes more sense

    scanf("%lld", &number);

    while (number > 0) {
        bits[i++] = number & 1; // get the current bit
        number >>= 1;         // shift number right by 1 bit (divide by 2)
    }

    if ( i == 0 )   // The original number was 0!
        printf("0");

    for ( ; i > 0; i-- )
        printf("%d", bits[i]);  // or... putchar('0' + bits[i])

    printf("\n");
}

为了解释一些注释，最简单的方法是使用
char
数组来保存二进制数字。此外，在处理位时，位运算符更清晰。否则，我保留了您的基本代码结构

int main()
{
    char bits[64];
    int i = 0;
    unsigned long long number;   // note the "unsigned" type here which makes more sense

    scanf("%lld", &number);

    while (number > 0) {
        bits[i++] = number & 1; // get the current bit
        number >>= 1;         // shift number right by 1 bit (divide by 2)
    }

    if ( i == 0 )   // The original number was 0!
        printf("0");

    for ( ; i > 0; i-- )
        printf("%d", bits[i]);  // or... putchar('0' + bits[i])

    printf("\n");
}

如果您不介意单独打印数字，可以使用以下方法：

#include<stdio.h>
#include <stdlib.h>
#include<limits.h>

void bindigit(long long num);

int main()
{
    long long number, binaryRepresentation = 0, baseOfOne = 1, remainder;
    scanf("%lld", &number);
    bindigit(number);
    printf("\n");

}

void bindigit(long long num) {
  int remainder;
  if (num < 2LL) {
    printf("%d",(int)num);
  } else {
    remainder = num % 2;
    bindigit(num/2);
    printf("%d",remainder);
  }
}

#包括
#包括
#包括
void bindigit（long-long-num）；
int main（）
{
长数字，二进制表示=0，baseOfOne=1，余数；
scanf（“%lld”、&number）；
宾迪吉特（数字）；
printf（“\n”）；
}
void bindigit（long-long-num）{
整数余数；
if（num<2LL）{
printf（“%d”，（int）num）；
}否则{
余数=num%2；
bindigit（num/2）；
printf（“%d”，余数）；
}
}
如果您不介意单独打印数字，可以使用以下方法：

#include<stdio.h>
#include <stdlib.h>
#include<limits.h>

void bindigit(long long num);

int main()
{
    long long number, binaryRepresentation = 0, baseOfOne = 1, remainder;
    scanf("%lld", &number);
    bindigit(number);
    printf("\n");

}

void bindigit(long long num) {
  int remainder;
  if (num < 2LL) {
    printf("%d",(int)num);
  } else {
    remainder = num % 2;
    bindigit(num/2);
    printf("%d",remainder);
  }
}

#包括
#包括
#包括
void bindigit（long-long-num）；
int main（）
{
长数字，二进制表示=0，baseOfOne=1，余数；
scanf（“%lld”、&number）；
宾迪吉特（数字）；
printf（“\n”）；
}
void bindigit（long-long-num）{
整数余数；
if（num<2LL）{
printf（“%d”，（int）num）；
}否则{
余数=num%2；
bindigit（num/2）；
printf（“%d”，余数）；
}
}
使用一个二元数来表示二进制数字永远不会结束得特别好：输入量小得惊人，很容易导致溢出，所有后续的算术运算都将毫无意义

另一种方法是边走边打印数字，但使用递归技术，以便按与处理顺序相反的顺序打印数字：

#include <stdio.h>

unsigned long long output(unsigned long long n)
{
    unsigned long long m = n ? output(n / 2) : 0;
    printf("%d", (int)(n % 2));
    return m;
}

int main()
{
    unsigned long long number = 9223372036854775807;
    output(number);
    printf("\n");
}

我还将类型更改为
unsigned long long
，它具有更好的定义位模式，
%
对负数执行奇怪的操作

实际上，我在这里所做的只是滥用堆栈来存储真正的0和1数组。
使用一个二元数来表示二进制数字永远不会结束得特别好：对于一个非常小的输入，您将很容易溢出，并且所有后续的算术运算都将毫无意义

另一种方法是边走边打印数字，但使用递归技术，以便按与处理顺序相反的顺序打印数字：

#include <stdio.h>

unsigned long long output(unsigned long long n)
{
    unsigned long long m = n ? output(n / 2) : 0;
    printf("%d", (int)(n % 2));
    return m;
}

int main()
{
    unsigned long long number = 9223372036854775807;
    output(number);
    printf("\n");
}

我还将类型更改为
unsigned long long
，它具有更好的定义位模式，
%
对负数执行奇怪的操作

实际上，我在这里所做的就是滥用堆栈来存储一个由0和1组成的数组。
最后，我自己尝试了一个代码，从你的代码中得到了一些有用的想法

#include<stdio.h>
#include<stdlib.h>

int main() {
   unsigned long long number;
   int binaryRepresentation[70], remainder, counter, count = 0;
   scanf("%llu", &number);
   while(number > 0) {
       remainder = number % 2;
       binaryRepresentation[count++] = remainder;
       number = number / 2;
   }
   for(counter = count-1; counter >= 0; counter--) {
       printf("%d", binaryRepresentation[counter]);
   }
}

#包括
#包括
int main（）{
无符号长数字；
int二进制表示[70]，余数，计数器，计数=0；
scanf（“%llu”、&number）；
而（数量>0）{
余数=数字%2；
二进制表示法[count++]=余数；
数量=数量/2；
}
对于（计数器=计数-1；计数器>=0；计数器--）{
printf（“%d”，二进制表示[counter]）；
}
}
最后，我自己尝试了一个代码，并从您的代码中获得了一些有用的想法

#include<stdio.h>
#include<stdlib.h>

int main() {
   unsigned long long number;
   int binaryRepresentation[70], remainder, counter, count = 0;
   scanf("%llu", &number);
   while(number > 0) {
       remainder = number % 2;
       binaryRepresentation[count++] = remainder;
       number = number / 2;
   }
   for(counter = count-1; counter >= 0; counter--) {
       printf("%d", binaryRepresentation[counter]);
   }
}

#包括
#包括
int main（）{
无符号长数字；
int二进制表示[70]，余数，计数器，计数=0；
scanf（“%llu”、&number）；
而（数量>0）{
余数=数字%2；
二进制表示法[count++]=余数；
数量=数量/2；
}
对于（计数器=计数-1；计数器>=0；计数器--）{
printf（“%d”，二进制表示[counter]）；
}
}
如前所述，您需要的空间比实际空间更大
如果您使用十进制数来表示这样的位序列，则此选项可用

由于您打算打印结果，因此最好一次打印一位。我们可以通过创建一个只有最高位设置的掩码来实现这一点。为任何类型创建此掩码的神奇之处在于，对该类型的零进行补码，得到一个“全一”数字；然后减去其中的一半（即1111…-0111…）只得到一个位。然后我们可以沿着数字向右移动它，依次确定每个位的状态

下面是一个使用该逻辑重新工作的版本，还有以下其他更改：


我使用一个单独的函数，返回（如
printf
）打印的字符数
我接受一个无符号的值，因为我们忽略了负值
我从命令行处理参数——我倾向于发现在stdin上输入东西更方便

#包括
#包括
int print_二进制（无符号长n）
{
int=0；
/*~ZERO-~ZERO/2是ZERO类型的值1000*/
for（无符号长掩码=~0ull-~0ull/2；掩码；掩码/=2）{
if（putc（n&掩码？'1'：'0'，标准输出）<0）
返回