C 如何检查数字是否只有唯一的数字？

例如，2345是唯一的数字，因为没有数字显示两次，但3324不是唯一的数字，因为3有两次。我尝试使用%但我（代码）显示，但我没有得到数字我得到了数字，编辑：你不能使用字符串

number%10==number%100||number%10==number%1000||number%100==number%1000

---

您可以使用一个包含10个标志的数组来指示是否已看到某个数字。在循环中遍历数字，提取单位数字，检查数字是否已被看到，将数字标记为已看到，并将数字除以10以进行下一次迭代

正如@Bathsheba所指出的，在处理负面影响时需要谨慎 数字

例如：

int unique(long long int number)
{
    char seen[10] = {0};

    while (number) {
        int digit = number % 10;

        number /= 10;
        if (digit < 0) {
            /* 
             * The number was negative.  Make it positive.
             * (Note: Checking the number is negative before the while
             * loop could fail when number is LLONG_MIN, so do it here
             * instead.)
             */
            digit = -digit;
            number = -number;
        }
        if (seen[digit]++)
            return 0; /* not unique */
     }
     return 1; /* unique */
 }

我认为以同样的方式支持

intmax\u t

和

uintmax\u t

会很有用：

#include <stdint.h>

int unique_um(uintmax_t number)
{
    char seen[10] = {0};

    while (number) {
        int digit = number % 10;

        number /= 10;
        if (seen[digit]++)
            return 0; /* not unique */
     }
     return 1; /* unique */
 }

int unique_m(intmax_t number)
{
    uintmax_t n;

    /* Represent original number as a 2's complement number. */
    n = number;
    if (n > INTMAX_MAX) {
        /*
         * Original number was negative, so take its 2's complement to "negate" it.
         * (Note: This works even when original number is INTMAX_MIN.)
         */
        n = -n;
    }
    /* Handle as a uintmax_t. */
    return unique_um(n);
 }

#包括
int unique_um（uintmax_t编号）
{
char seen[10]={0}；
while（数字）{
整数位数=数字%10；
数目/=10；
如果（见[位数]++）
返回0；/*不是唯一的*/
}
返回1；/*唯一*/
}
唯一整数（整数最大数）
{
uintmax\u t n；
/*将原始数字表示为2的补码*/
n=数量；
如果（n>INTMAX\u MAX）{
/*
*原来的数字是负数，所以用它的2的补码来“否定”它。
*（注意：即使原始编号为INTMAX\U MIN，此选项也有效。）
*/
n=-n；
}
/*作为uintmax\t处理*/
返回唯一_um（n）；
}

我的五美分。：）

对于初学者，函数参数的类型应为

long long int

（或

intmax\t

）。在这种情况下，该函数可以应用于任何有符号整数类型的对象

这是一个演示程序

#include <stdio.h>

int unique_digits( long long int n )
{
    const long long int Base = 10;

    int unique = 1;

    while ( unique && n )
    {
        long long int digit = n % Base;
        long long int tmp = n /= Base;

        while (tmp && digit != tmp % Base ) tmp /= Base;

        unique = tmp == 0;
    }

    return unique;
}

int main(void) 
{
    int n = 12345678;

    printf( "%d: %s\n", n, unique_digits( n ) ? "unique" : "non_unique" );

    n = 12345671;

    printf( "%d: %s\n", n, unique_digits( n ) ? "unique" : "non_unique" );

    n = -12345678;

    printf( "%d: %s\n", n, unique_digits( n ) ? "unique" : "non_unique" );

    n = -112345671;

    printf( "%d: %s\n", n, unique_digits( n ) ? "unique" : "non_unique" );

    return 0;
}

#include <stdio.h>

int unique_digits( long long int n )
{
    const long long int Base = 10;

    unsigned short unique = 0;

    long long int digit;
    int offset;

    do
    {
        digit = n % Base;
        if ( digit < 0 ) digit = -digit;

        offset = 1 << digit;
        unique ^= offset;
    } while ( ( unique & offset ) && ( n /= Base )  );        

    return n == 0;
}

int main(void) 
{
    int n = 12345678;

    printf( "%d: %s\n", n, unique_digits( n ) ? "unique" : "non_unique" );

    n = 12345671;

    printf( "%d: %s\n", n, unique_digits( n ) ? "unique" : "non_unique" );

    n = -12345678;

    printf( "%d: %s\n", n, unique_digits( n ) ? "unique" : "non_unique" );

    n = -112345671;

    printf( "%d: %s\n", n, unique_digits( n ) ? "unique" : "non_unique" );

    return 0;
}

如果要包含标题

，则可以用类型

long-long-int

替换类型

intmax\t

另一种方法是使用整数作为数字数组。这是一个演示程序

#include <stdio.h>

int unique_digits( long long int n )
{
    const long long int Base = 10;

    int unique = 1;

    while ( unique && n )
    {
        long long int digit = n % Base;
        long long int tmp = n /= Base;

        while (tmp && digit != tmp % Base ) tmp /= Base;

        unique = tmp == 0;
    }

    return unique;
}

int main(void) 
{
    int n = 12345678;

    printf( "%d: %s\n", n, unique_digits( n ) ? "unique" : "non_unique" );

    n = 12345671;

    printf( "%d: %s\n", n, unique_digits( n ) ? "unique" : "non_unique" );

    n = -12345678;

    printf( "%d: %s\n", n, unique_digits( n ) ? "unique" : "non_unique" );

    n = -112345671;

    printf( "%d: %s\n", n, unique_digits( n ) ? "unique" : "non_unique" );

    return 0;
}

#include <stdio.h>

int unique_digits( long long int n )
{
    const long long int Base = 10;

    unsigned short unique = 0;

    long long int digit;
    int offset;

    do
    {
        digit = n % Base;
        if ( digit < 0 ) digit = -digit;

        offset = 1 << digit;
        unique ^= offset;
    } while ( ( unique & offset ) && ( n /= Base )  );        

    return n == 0;
}

int main(void) 
{
    int n = 12345678;

    printf( "%d: %s\n", n, unique_digits( n ) ? "unique" : "non_unique" );

    n = 12345671;

    printf( "%d: %s\n", n, unique_digits( n ) ? "unique" : "non_unique" );

    n = -12345678;

    printf( "%d: %s\n", n, unique_digits( n ) ? "unique" : "non_unique" );

    n = -112345671;

    printf( "%d: %s\n", n, unique_digits( n ) ? "unique" : "non_unique" );

    return 0;
}

---

这里有一种方法可以实现这一点

#include <stdio.h>

int main(){
    int n, i, digit;
    static int arr[10];
    scanf("%d", &n);
    while(n>0){
        digit = n%10;
        arr[digit]++;
        n=n/10;
    }
    for(i=0; i<10; i++){
        if(arr[i]>1){
            printf("Not unique!");
            break;
        }
    }
    if(i==10){
        printf("unique");
    }
    return 0;
}

#包括
int main（）{
int n，i，数字；
静态int-arr[10]；
scanf（“%d”和“&n”）；
而（n>0）{
数字=n%10；
arr[数字]+；
n=n/10；
}
对于（i=0；i1）{
printf（“不是唯一的！”）；
打破
}
}
如果（i==10）{
printf（“唯一”）；
}
返回0；
}

---

请注意，静态数组的元素是用默认值0初始化的。

您可以使用set STL来检查数字是否只有唯一的数字。例如，让我们考虑数字2020，然后我们可以将数字转换成字符串，

int num;
cin>>num
string s = to_string(num);

然后，用字符串s的内容初始化一个集合

set<int> uniDigits(s.begin(), s.end());

if(s.size() == uniDigits.size()) { break; }

我们知道集合的属性，集合只存储唯一的数字并丢弃重复的数字，如果两个大小相等，则意味着所有数字都是唯一的。如果集合的大小小于字符串的大小，则表示该数字不包含不同的数字，所有重复的数字都将被丢弃

#include <bits/stdc++.h>
using namespace std;

int main()
{
    string s = "2020";
    set<int> digits(s.begin(), s.end());
    cout << s.size() << " " << digits.size() << endl;
    return 0;
}

#包括
使用名称空间std；
int main（）
{
字符串s=“2020”；
设置数字（s.begin（），s.end（））；
提示，定义一个数组
int-visted[10]={0}
。然后使用
%10
提取最右边的数字，并使用
/10
删除该数字，以此填充。处理多余的前导零可能需要一些思考。这有帮助吗？嗯……二进制中的11表示为
1011
，十六进制中表示为
b
如果
number
为n，则需要考虑消极。（我个人会将类型更改为
unsigned long
）@Bathsheba谢谢，我为负数添加了一个安全的更正。我想它需要一个不同的
unsigned long
函数，以防有人真的需要将其用于负数
long
数字。
#include <bits/stdc++.h>
using namespace std;

int main()
{
    string s = "2020";
    set<int> digits(s.begin(), s.end());
    cout << s.size() << " " << digits.size() << endl;
    return 0;
}