我在 C 中使用位运算符时遇到的问题 (HackerRank)答案

【问题标题】：A Problem I faced using Bitwise Operators in C (HackerRank)我在 C 中使用位运算符时遇到的问题 (HackerRank)
【发布时间】：2022-08-18 05:59:24
【问题描述】：

HackerRank link

在本挑战中，您将使用逻辑位运算符。所有数据都以其二进制表示形式存储。逻辑运算符和 C 语言用 1 表示真，用 0 表示假。逻辑运算符比较两个数字中的位，并为每个比较的位返回真或假、0 或 1。

位与运算符 & 如果两个操作数的对应位为 1，则位与的输出为 1。如果操作数的任一位为 0，则对应位的结果为 0。用 & 表示。
按位或运算符 |如果两个操作数的至少一个对应位为 1，则按位或的输出为 1。用 | 表示。
按位异或（异或）运算符 ^ 如果两个操作数的对应位相反，按位异或运算符的结果为 1。它用 ^ 表示。

例如，对于整数 3 和 5，

3 = 00000011 (In Binary)
5 = 00000101 (In Binary)

AND operation        OR operation        XOR operation
  00000011             00000011            00000011
& 00000101           | 00000101          ^ 00000101
  ________             ________            ________
  00000001  = 1        00000111  = 7       00000110  = 6

你会得到一个整数n和一个门槛，ķ.对于每个数字，找到最大值逻辑和,或者和异或当与通过 n 的所有整数进行比较时。

例子 n=3 k=3

比较结果如下：

a b   and or xor
1 2   0   3  3
1 3   1   3  2
2 3   2   3  1

对于 and 比较，最大值为 2。对于 or 比较，没有一个值小于ķ，所以最大值为0。对于异或比较，最大值小于ķ是 2. 函数应该打印：

2
0
2

功能说明

在下面的编辑器中完成 calculate_the_maximum 函数。

calculate_the_maximum 具有以下参数：

int n：要考虑的最高数字
int n：要考虑的最高数字

印刷

在单独的行上打印与、或和异或比较的最大值。

输入格式

唯一的一行包含 2 个空格分隔的整数，n和ķ.

约束

2 <=n<= (10)^3
2 <=ķ<=n

样本输入 0

5 4

*样本输出 0

2
3
3

**所以这是我的答案**

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



void calculate_the_maximum(int n, int k) {
  int m1=0,m2=0,m3=0;
  for (int x=1; x<n; x++){
      for (int y=2; y<=n; y++){
          //and
          int a=x&y;
          if((a>m1) && (a<k)){
            m1=a;
          };
          //or
          int b=x|y;
          if((b>m2) && (b<k)){
            m2=b;
          };
          //xor
          int c=x^y;
          if((c>m3) && (c<k)){
            m3=c;
          };
      }
  }
  
  printf(\"%d \\n\",m1);
  printf(\"%d \\n\",m2);
  printf(\"%d \\n\",m3);
}

int main() {
    int n, k;
  
    scanf(\"%d %d\", &n, &k);
    calculate_the_maximum(n, k);
 
    return 0;
}

我的输出是

3 
3 
3

预期产出

2
3
3

我的代码有什么错误？

int m1,m2,m3=0; 那只是初始化最后一个变量。您需要int m1=0, m2=0, m3=0; 您应该能够通过调试代码来发现此类错误。例如，在调试器中运行，单步执行代码并在运行时检查流和变量值。
还是一样的建议 - 进行调试。
打开编译器的警告！它会告诉你第一个问题。使用 gcc，我使用 -Wall -Wextra -pedantic
鉴于 x != y，您似乎需要找到最大值。
x = 3, y = 3 将产生结果 m1 = 3。我想可能是它忽略了 x = y 的情况

标签： c algorithm xor bitwise-and bitwise-xor

【解决方案1】：

这是我的回答我先转换成二进制然后再转换回来

    #include <stdio.h>
    #include <string.h>
    #include <math.h>
    #include <stdlib.h>
    //Complete the following function.


    void calculate_the_maximum(int n, int k)
    {
        int i,j,a,b;
        int max_and = 0;
        int max_or = 0;
        int max_xor = 0;
        for (i = 1; i < n+1; i++)
        {
            for (j = 1; j < n+1; j++)
            {
                if (j>i)
                {
                    a = i;
                    b = j;
                    int count_1 = 0;
                    int sum_1 = 0;
                    int count_2 = 0;
                    int sum_2 = 0;

                    while (!(a==0))
                    {
                        sum_1 += (a%2)*(pow(10,count_1));
                        a = a/2;
                        count_1++;

                    }
                    while (!(b==0))
                    {
                        sum_2 += (b%2)*(pow(10,count_2));
                        b = b/2;
                        count_2++;
                    }
                    int sum_3 = 0;
                    int sum_4 = 0;
                    int sum_5 = 0;
                    int num_1 = 0;
                    int num_2 = 0;
                    int num_3 =0;
                    int count_3 = 0;
                    while (!((sum_1 == 0)&&(sum_2 == 0)))
                    {
                        if ((sum_1%10 == 1)&&(sum_2%10 == 1))
                        {
                            sum_3 += pow(10,count_3);

                        }
                        if ((sum_1%10 == 1)||(sum_2%10 == 1))
                        {
                            sum_4 += pow(10,count_3);
                        }
                        if (((sum_1%10 == 1)&&(sum_2%10 == 0))||((sum_1%10 == 0)&&(sum_2%10 == 1)))
                        {
                            sum_5 += pow(10,count_3);
                        }
                        sum_1 = sum_1/10;
                        sum_2 = sum_2/10;
                        count_3++;
                    }
                    int count_4 = 0;
                    while (!(sum_3 == 0))
                    {
                        num_1 += (sum_3%10)*(pow(2,count_4));
                        sum_3 = sum_3/10;
                        count_4++;
                    }
                    int count_5 = 0;
                    while (!(sum_4 == 0))
                    {
                        num_2 += (sum_4%10)*(pow(2,count_5));
                        sum_4 = sum_4/10;
                        count_5++;
                    }
                    int count_6 = 0;
                    while (!(sum_5 == 0))
                    {
                        num_3 += (sum_5%10)*(pow(2,count_6));
                        sum_5 = sum_5/10;
                        count_6++;
                    }

                    if ((max_and < num_1)&&(num_1<k))
                    {
                        max_and = num_1;


                    }
                    if ((max_or < num_2)&&(num_2<k))
                    {
                        max_or = num_2;

                    }
                    if ((max_xor < num_3)&&(num_3<k))
                    {
                        max_xor = num_3;
                    }
                }
            }
        }
        printf("%d\n%d\n%d",max_and,max_or,max_xor);
    }

    int main() {
        int n, k;

        scanf("%d %d", &n, &k);
        if (!((n < 2)||(n > 1000)||(k < 2)||(k >n)))
        {
            calculate_the_maximum(n, k);
            return 0;
        }
        else
        {
            printf("Error!\n");
            return 1;
        }
    }

【讨论】：