查找number2在number1中显示了多少次

Question

我正在用C解决一个练习，我被卡住了。我不知道代码的逻辑来达到我的解决方案。例如，我们从输入2个数字，让数字是123451289和12，我想看看数字2在数字1处显示了多少次(如果这让我感到困惑，请告诉我)。对于前面的数字，程序输出2。我试着解决这个问题，这里是我的代码：

#include <stdio.h>

int main() {
    int num1, num2, counter = 0;
    scanf("%d%d", num1, num2);
    if (num1 < num2) {
        int temp = num1;
        num1 = num2;
        num2 = temp;
    }
    int copy1 = num1;
    int copy2 = num2;
    while (copy2 > 0) {
        counter++; // GETTING THE LENGHT OF THE SECOND NUMBER
        copy2 /= 10;
//        lastdigits = copy1 % counter //HERE I WANT TO GET THE LAST DIGITS OF THE FIRST NUMBER
// But it does not work
    }
}

我的问题是如何根据第二个数字得到第一个数字的最后一个数字，例如，如果第二个数字有3个数字，我想得到第一个数字的最后3个数字。至于另一部分，我想我能搞清楚。

我必须不使用数组来解决这个问题。

Answer 1

这是我想要的答案，但谢谢大家的帮助:)

#include <stdio.h>
#include <math.h>
int main(){
int num1,counter1,counter2,num2,temp,digit,copy1,copy2;
scanf("%d%d",&num1,&num2);
if(num1<num2){
    temp = num1;
    num1 = num2;
    num2 = temp;
}
copy1 = num1;
copy2 = num2;
counter1 = counter2 = 0;
while (copy2>0) {
    counter1++;
    copy2/=10;
}
counter1 = pow(10,counter1);
if(num1> 1 && num2>1)
while (copy1>0) {
    digit = copy1%counter1;
    if(digit==num2){
        counter2++;
    }
    copy1/=10;
} else{
    if(num2<1){
        while (copy1>0) {
            digit = copy1%10;
            if(digit==copy2){
                counter2++;
            }
            copy1/=10;
        }
    }
}

printf("%d",counter2);

}

Answer 2

问题是:在干草堆(如123451289)中找到所有的针头(如12针)。

这可以简单地做到没有阵列使用的指针模数。对于12个人，这是100。也就是说，12是两位数宽。利用模数，我们可以分离出干草堆最右边的N个数字，并将它们与针头进行比较。

我们反复“扫描”干草堆，除以10，直到我们达到零。

以下是代码：

#include <stdio.h>

int
main(void)
{
    int need, hay, counter = 0;

    scanf(" %d %d", &hay, &need);

    // ensure that the numbers are _not_ reversed
    if (hay < need) {
        int temp = need;
        need = hay;
        hay = temp;
    }

    // get modulus for needle (similar to number of digits)
    int mod = 1;
    for (int copy = need;  copy != 0;  copy /= 10)
        mod *= 10;

    // search haystack for occurences of needle
    // examine the rightmost "mod" digits of haystack and check for match
    // reduce haystack digit by digit
    for (int copy = hay;  copy != 0;  copy /= 10) {
        if ((copy % mod) == need)
            ++counter;
    }

    printf("%d appears in %d exactly %d times\n",need,hay,counter);

    return 0;
}

更新：

，恐怕这对10岁的人不起作用。-切里利

10/0情况下模数计算的单线固定法。但是，我不得不为0/0输入添加一个特例。

此外，我还为负数添加了一个修复程序，并允许多行输入：

#include <stdio.h>

int
main(void)
{
    int need, hay, counter;

    while (scanf(" %d %d", &hay, &need) == 2) {
        counter = 0;

        // we can scan for -12 in -1237812
        if (hay < 0)
            hay = -hay;
        if (need < 0)
            need = -need;

        // ensure that the numbers are _not_ reversed
        if (hay < need) {
            int temp = need;
            need = hay;
            hay = temp;
        }

        // get modulus for needle (similar to number of digits)
        int mod = need ? 1 : 10;
        for (int copy = need; copy != 0; copy /= 10)
            mod *= 10;

        // search haystack for occurences of needle
        // examine the rightmost "mod" digits of haystack and check for match
        // reduce haystack digit by digit
        for (int copy = hay; copy != 0; copy /= 10) {
            if ((copy % mod) == need)
                ++counter;
        }

        // special case for 0/0 [yecch]
        if ((hay == 0) && (need == 0))
            counter = 1;

        printf("%d appears in %d exactly %d times\n", need, hay, counter);
    }

    return 0;
}

以下是程序输出：

12 appears in 123451289 exactly 2 times
0 appears in 10 exactly 1 times
0 appears in 0 exactly 1 times

更新2：

很好的修正，包括负数测试.但是我担心大量的数据仍然会造成问题，比如2000000000 2000000000和-2147483648 8- chqrlie。

由于OP已经发布了一个答案，这有点像击败一匹死马，但我要做最后一次尝试。

我已经从计算针头的模数转变为计算针头的数字数。这与其他一些答案的方法相似。

然后，比较现在是从右边的数字一个数字进行的。

我还切换到了unsigned，如果需要/支持编译选项，允许数字为__int128。

我增加了解码和打印数字的功能，所以即使不支持128位数字，它也能工作。

我可能忽略了另一个边缘情况，但这是一个学术问题(例如，我们不能使用数组)，我的解决方案是只对数字使用更大的类型。如果我们可以使用数组，我们会将其保留为字符串，这类似于使用strstr。

总之，这是密码：

#include <stdio.h>

#ifndef NUM
#define NUM     long long
#endif
typedef unsigned NUM num_t;

FILE *xfin;

int
numget(num_t *ret)
{
    int chr;
    num_t acc = 0;
    int found = 0;

    while (1) {
        chr = fgetc(xfin);
        if (chr == EOF)
            break;

        if ((chr == '\n') || (chr == ' ')) {
            if (found)
                break;
        }

        if ((chr >= '0') && (chr <= '9')) {
            found = 1;
            acc *= 10;
            chr -= '0';
            acc += chr;
        }
    }

    *ret = acc;

    return found;
}

#define STRMAX  16
#define STRLEN  100

const char *
numprt(num_t val)
{
    static char strbuf[STRMAX][STRLEN];
    static int stridx = 0;
    int dig;
    char *buf;

    buf = strbuf[stridx++];
    stridx %= STRMAX;

    char *rhs = buf;
    do {

        if (val == 0) {
            *rhs++ = '0';
            break;
        }

        for (;  val != 0;  val /= 10, ++rhs) {
            dig = val % 10;
            *rhs = dig + '0';
        }
    } while (0);
    *rhs = 0;

    if (rhs > buf)
        --rhs;
    for (char *lhs = buf;  lhs < rhs;  ++lhs, --rhs) {
        char tmp = *lhs;
        *lhs = *rhs;
        *rhs = tmp;
    }

    return buf;
}

int
main(int argc,char **argv)
{
    num_t need, hay, counter;

    --argc;
    ++argv;

    if (argc > 0)
        xfin = fopen(*argv,"r");
    else
        xfin = stdin;

    while (1) {
        if (! numget(&hay))
            break;
        if (! numget(&need))
            break;

        counter = 0;

        // we can scan for -12 in -1237812
        if (hay < 0)
            hay = -hay;
        if (need < 0)
            need = -need;

        // ensure that the numbers are _not_ reversed
        if (hay < need) {
            num_t temp = need;
            need = hay;
            hay = temp;
        }

        // get number of digits in needle (zero has one digit)
        int ndig = 0;
        for (num_t copy = need; copy != 0; copy /= 10)
            ndig += 1;
        if (ndig == 0)
            ndig = 1;

        // search haystack for occurences of needle
        // starting from the right compare digit-by-digit
        // "shift" haystack right on each iteration
        num_t hay2 = hay;
        for (;  hay2 != 0;  hay2 /= 10) {
            num_t hcopy = hay2;

            // do the rightmost ndig digits match in both numbers?
            int idig = ndig;
            int match = 0;
            for (num_t need2 = need; idig != 0;
                --idig, need2 /= 10, hcopy /= 10) {
                // get single current digits from each number
                int hdig = hcopy % 10;
                int ndig = need2 % 10;

                // do they match
                match = (hdig == ndig);
                if (! match)
                    break;
            }

            counter += match;
        }

        // special case for 0/0 et. al. [yecch]
        if (hay == need)
            counter = 1;

        printf("%s appears in %s exactly %s times\n",
            numprt(need), numprt(hay), numprt(counter));
    }

    return 0;
}

这是程序输出：

12 appears in 123451289 exactly 2 times
123 appears in 123451289 exactly 1 times
1234 appears in 123451289 exactly 1 times
1 appears in 123451289 exactly 2 times
0 appears in 10 exactly 1 times
0 appears in 0 exactly 1 times
1000000000 appears in 1000000000 exactly 1 times
2000000000 appears in 2000000000 exactly 1 times

Answer 3

这看起来和你想要的一样。

您可以使用math.h中的pow()函数将10提高到模数运算需要多少位数的幂。

用-lm编译或创建自己的函数来计算10^num_digits

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

int main() {
    int x = 123456789;
    double num_digits = 3.0;
    int last_digits = x % (int)pow(10.0, num_digits);
    printf("x = %d\nLast %d Digits of x = %d\n", x, (int)num_digits, last_digits);

    return 0;
}

产出：

x = 123456789
Last 3 Digits of x = 789