Python 检查 integer 是否都是相同的数字

Question

My goal here is to take a serial number and attempt to reject it. I need to reject anything that is not a number. I also need to reject anything where each digit is the same number. I know there has to be a way other than listing out 111111111 - 999999999. I need to mention that s is an integer with 9 digits such as 123456789. the set() method will not work here as an int object is not iterable.

def rejectSerial(s):
    try:
        int(s)
    except:
        return True
    rejectList = [111111111],[222222222],[333333333],[444444444],[555555555],[666666666]
    if s in rejectList:
        return True

    return False

Answer 1

Convert the string to a set and see if it has more than 1 element in it:

return (len(set(s)) == 1)

The entire function could be:

def rejectSerial(s: str) -> bool:
    return (
        not s.isdecimal()
        or len(set(s)) == 1
    )

This assumes that s is a string, as implied by the int() call in your original post. If s is already an int then you don't need to check whether it's a number and the function would simply be:

def rejectSerial(s: int) -> bool:
    return len(set(str(s))) == 1

If the type of s is completely unknown and you want the function to accept either numbers OR string representations of numbers and simply return True for other input types, then you could just convert it to a string and then apply the string version of this check:

def rejectSerial(s) -> bool:
    return (
        not str(s).isdecimal()
        or len(set(str(s))) == 1
    )

This will return True if you pass random types like None or a list to it, since the string representation of those will fail the isdecimal() check.

If you want the function be be able to accept arbitrary (non-int) values without raising an exception, but only return False for int values (not string representations of int values), and you want to enforce the 9-digit positive number requirement, THEN you might want:

def rejectSerial(s) -> bool:
    return not (
        isinstance(s, int)
        and 100000000 <= s <= 999999999
        and len(set(str(s))) != 1
    )

Answer 2

you can use set to achieve this.

def rejectSerial(s):
    try:
        int(s)
    except:
        return True
    if len(set(s)) == 1:
        return True

    return False

Answer 3

@Maxwell: A possible solution could be implemented as in the follows:

def rejectSerial(data):
    """Reject data is an integer with different digits.

    Parameters
    ----------
    data: int
        A serial number

    Returns:
    --------
    True if data is not and integer or if it is an integer with the same digits
    False otherwise (this means the data is conforming and must not be rejected)."""
    throw = not isinstance(data, int)   # False is the data is an integer
    datastr = str(data)
    similar = None,
    if len(datastr) == 1: # is the data an integer < 10
        similar = False   # it is a good serial number, and must not be rejected
    else:
        # Create and iterable (here a generator) for testing where the digits are the
        # same
        similar = (datastr[0] == item for item in datastr)
     result = throw or all(similar)
     return result

#------ Test ------
rejectSerial(1)            # -> False
rejectSerial(11111)        # -> True
rejectSerial(11112)        # -> False

Answer 4

in C language:

int CheckDigits(int givenNumber)
{
    int m = givenNumber; // spare to number to digits
    int count = 0;
    while (m != 0) 
    {
        m = m / 10;
        count++;
    }
    //printf("digit number :%d \n", count);
    
    if(count == 1)
    {
         return 2; // check one digit
    }

    int tempArray[count];
    for (int i = 0; i < count; i++)
    {
        tempArray[i] = givenNumber%10;
        givenNumber=givenNumber/10;
        //printf("Digit %d = %d, ",count-i, tempArray[i]);
    }
    
    for (int i = 0; i < count; i++)
    {
        if(tempArray[0] != tempArray[i])
        {
            return 0;
        }
    }
    return 1;
}