Question

编写一个程序，它将找到小于N的最大数字，它与给定的数字X完全不同。一个数字与其他数字完全不同，只有它不包含其他数字的任何数字。从标准输入读取N和X.应该在不使用数组的情况下解决问题。

示例输入1：400 897

示例输出1：366

示例输入2：1000 1236498

示例输出2：777

不，这不是家庭作业，它是在其中一个中期，它一直在杀我。我虽然用％10取第一个数字的最后一个数字，然后用％10比较它们的第二个数字，但是......我只是无法让它工作......我最终得到了无限循环...我只是不明白如何获得数字的每个数字，并将它们与其他数字进行比较。

#include <stdio.h>

int main () {
int N, X, num_N, num_X, i, lastDigit_N, lastDigit_X, flag, smaller_than_N;

scanf("%d%d", &N, &X);
smaller_than_N = N - 1;

for (i = smaller_than_N; i > 0; i--) {
num_N = i;
num_X = X;
flag = 0;

while (num_N > 0) {
lastDigit_N = num_N % 10;

while (num_X > 0) {
lastDigit_X = num_X % 10;

if (lastDigit_N == lastDigit_X) {
break;
}

else {
flag = 1;
}

num_X /= 10;
}
num_N /= 10;
}

if(flag) {
printf("%d", i);    
break;
}
}

return 0;
}

Answer 1

您可以为数字构建一个位掩码，显示包含的数字。

uint16_t num2bitmask(int number)
{
    uint16_t result = 0;
    while (number) {
        int digit = number % 10;
        number /= 10;
        result |= (1 << digit);
    }
    return result;
}

使用此功能，您可以为X创建位掩码，然后从N-1向下迭代到1，直到找到一个与另一个值没有任何共同位的值。

Answer 2

如果您的数字为d_1，d_2，...，d_n，并且您可以使用集D中的数字，那么可能的解决方案如下：

d_1, ..., d_{i-1}, max(d in D | d < d_i), max(d in D), ..., max(d in D).

也就是说，数字在某一点上是相同的，然后下一个数字尽可能大，同时低于输入数字，其余数字尽可能大。

并非所有这些“解决方案”都是有效的，但是如果你以相反的顺序迭代它们（对于大小为n的输入数字恰好是n），你找到的第一个有效的解决方案就是答案。

一些代码，包括测试：

#include <stdio.h>

int digit_length(int a) {
    int r = 0;
    while (a) {
        a /= 10;
        r += 1;
    }
    return r;
}

int get_digit(int a, int k) {
    while (k--) a /= 10;
    return a % 10;
}

int largest_different(int a, int b) {
    int lena = digit_length(a);
    int invalid = b ? 0 : 1;
    for (; b; b /= 10) invalid |= 1 << (b % 10);
    int max_valid = 9;
    while (max_valid >= 0 && (invalid & (1 << max_valid)))
        max_valid--;
    if (max_valid == -1) return -1;
    for (int i = 0; i < lena; i++) {
        int d = get_digit(a, i) - 1;
        while (d >= 0 && (invalid & (1 << d)))d--;
        if (d < 0) continue;
        int solution = 0;
        for (int k = lena - 1; k >= 0; k--) {
            solution *= 10;
            solution += (k < i ? max_valid : k > i ? get_digit(a, k) : d);
        }
        return solution;
    }
    return -1;
}

int main(int argc, char *argv[]) {
    struct {int n; int x; int want;} examples[] = {
        {400, 897, 366},
        {1000, 1236498, 777},
        {998, 123, 997},
    };
    int error = 0;
    for (int i = 0; i < sizeof(examples) / sizeof(*examples); i++) {
        int got = largest_different(examples[i].n, examples[i].x);
        if (got != examples[i].want) {
            error = 1;
            printf("largest_different(%d, %d) = %d, want %d\n",
                examples[i].n, examples[i].x, got, examples[i].want);
        }
    }
    return error;
}

并不总是有解决方案。在这种情况下，函数返回-1。

如何划分数字并比较它们，用C表示

2 个答案: