Question

我的作业是写一个递归函数，打印从零到n的所有二进制数，一个输入整数。它被禁止使用循环，静态变量，数组，全局变量。

例如，如果输入为7，则输出应为：

我的输出：

如何使用这些零来修复输出？

这是我的代码：

#include <stdio.h>


void convert(int num)//converts decimal number to binary
{
    if(num>0)
    {
    convert(num/2);
    printf("%d", num%2);
    }
}

void print_binary_number(int num)
{
    if(num<0)
       return;
    print_binary_number(num-1);
     printf("\n");
    convert(num);

}

int main()
{

    int num;
    printf("Please enter an integer:");
    scanf("%d", &num);
    print_binary_number(num);
    return 0;

}

Answer 1

这是我的解决方案（对代码的更改很少）：

#include <stdio.h>


void convert(int num, int limit)
{
    if(limit>0)
    {
        convert(num/2, limit/2);
        printf("%d", num%2);
    }
}

void print_binary_number(int num, int limit)
{
    if(num>limit)
        return;
    convert(num, limit);
    printf("\n");
    print_binary_number(num+1, limit);
}

int main()
{

    int num;
    printf("Please enter an integer:");
    scanf("%d", &num);
    print_binary_number(0, num);
    return 0;
}

convert函数现在需要两个参数而不是一个：除了要打印的数字之外，它还接收limit，用户输入和循环的最终值。它使用num生成二进制数字，但它使用limit来决定何时停止打印。这具有产生零的效果，直到达到limit的大小。

Answer 2

一种方法是查找各种格式化方式＆＃34;引导零＆＃34;但是，我通常看到希望解决这个问题的教师的方法是将其作为字符串处理问题来处理。

空案例很简单：返回的是＆＃34;＆＃34;。

对于下一次扩展，返回两组字符串：前一组用＆＃34; 0＆＃34;在前面，和之前设置的＆＃34; 1＆＃34;在前。这给了我们

0
and
1

重复此过程至需要两种力量：

然后

足以让你感动吗？

Answer 3

找出有多少个零：

#include <limits.h>
#define BITS_IN_INT (sizeof(int) * CHAR_BIT)
// would keep the strings small and legible, but the above gives the correct value
// #define BITS_IN_INT 8

// recurse until first set bit is reached
int number_of_leading_zeros(int n, int count){
  if(n != 0){
    count--;
    n >>= 1;
    return number_of_leading_zeros(n, count);
  } 
  return count;
}

将上述功能调用为

 number_of_leading_zeros(counter, BITS_IN_INT);

然后在转换后的数字

之前打印它们

// simple loop, made recursive
void print_leading_zeros(int n){
  if(n != 0){
     putchar('0');
     n--;
     print_leading_zeros(n);
  }
}

如果必须递归的事情是我的一个误解，请随意与循环交换。

Answer 4

以下仅产生log2（n）的递归深度。使用深度为n的递归会给递归带来错误的名称。

没有循环，静态变量，数组，全局变量。没有字符串文字，它们是类似数组但技术上字符序列。

print_binary_numbers_ll()在每一步调用2条路径。一个使用'0'，另一个使用'1'。达到最低有效位后，递归打印digit_ll列表。

#include <stdio.h>

typedef struct digit_ll {
  int digit;
  struct digit_ll *previous;
} digit_ll;

void print_ll(const digit_ll *prev) {
  if (prev) {
    print_ll(prev->previous);
    putchar(prev->digit);
  }
}

void print_binary_numbers_ll(int num, digit_ll *prev) {
  if (num <= 0) {
    print_ll(prev);
    putchar('\n');
  } else {
    digit_ll current = { '0', prev };
    print_binary_numbers_ll(num / 2, &current);
    current.digit = '1';
    print_binary_numbers_ll(num / 2, &current);
  }
}

void print_binary_numbers(int num) {
  print_binary_numbers_ll(num, 0);
}

int main() {
  print_binary_numbers(3);
  print_binary_numbers(7);
}

输出

要将0打印到n，即使n不是 power-of-2 - 1 ，仍然只能递归log2(n)最大深度，不使用链表：

static void print_b(int value, int limit) {
  if (limit) {
    print_b(value/2, limit/2);
    putchar('0' + value%2);
  }
}

static void print_binary_numberR(int depth, int value, int limit) {
  if (depth) {
    print_binary_numberR(depth/2, value*2 + 0, limit);
    print_binary_numberR(depth/2, value*2 + 1, limit);
  } else if (value <= limit) {
    print_b(value, limit);
    putchar('\n');
  }
}

void print_binary_numbers(int num) {
  print_binary_numberR(num, 0, num);
}

print_binary_numbers(3);
print_binary_numbers(4);

输出

带十进制输入的递归函数打印从零到n的所有数字以二进制形式输出

4 个答案: