如何检查一个数字的每个数字是否大于或等于另一个数字？

Question

Every digit should be greater or equal than another. If all digit are equal, return false.

Examples:

201 >= 200 true
200 >= 200 false
200 >= 101 false
210 >= 201 false

The ordinary way is constantly divide by 10, and then compare the remainder.

Here is the code in Java:

private boolean isScoreBetter(final int score, final int scoreToCompare) {
    int a = score;
    int b = scoreToCompare;
    int betterCount = 0;
    while (a > 0 && b > 0) {
        int temp = a % 10 - b % 10;
        if (temp < 0) {
            return false;
        }
        if (temp > 0) {
            betterCount++;
        }
        a /= 10;
        b /= 10;
    }
    return betterCount > 0 && a >= b;
}

Is there a better way? Definition of "better":

1. Code need to be short and elegant
2. The algorithm is better based on digital calculations, and do not contains type conversion like int -> string etc.

Constraint of the two numbers:

1. They are non-negative number
2. The number of digits is not necessarily the same

Thank you for your reply.

Answer 1

str1 = '000'
str2 = '111'

all(a >= b for a, b in zip(str1, str2))
# False

all(a >= b for a, b in zip(str2, str1))
# True

Answer 2

If you don't want to convert the number to a string (as you said in your edit), there's still more than one way to do it.

You can write an iterator that give you the next digit:

def next_digit(number):
    while (number > 1):
        yield number % 10
        number = number // 10

Then you can map over all values and use all like in the other answer:

    a = 201
    b = 200

    res = all(map(lambda d: d[0] >= d[1], zip(next_digit(a), next_digit(b))))
    print(res) # True

Or you could use filter and see if there are any digits that do not satisfy the condition:

    res = filter(lambda d: d[0] < d[1], zip(next_digit(a), next_digit(b)))
    print(res) # []

But, if you have numbers with a really large amount of digits, these approaches might be inefficient, because they go through all the digits anyway.

You can write a rolled out for loop and optimize a bit by breaking out of it at the first digit that doesn't match your criteria.

You can do that with an iterator, too:

def next_two_digits(a, b):
    while (a > 1 and b > 1):
        yield (a % 10, b % 10)
        a = a // 10
        b = b // 10

And you can either use it as the previous one:

res = all(map(lambda d: d[0] >= d[1], next_two_digits(a, b)))
print(res) # True

res = filter(lambda d: d[0] < d[1], next_two_digits(a, b))
print(res) # []

Or you can do the unrolled-loop thing:

matching = True
for d in next_two_digits(a, b):
    if (d[0] < d[1]):
        matching = False
        break
print(matching)

Keep in mind that there is a constraint here on the fact that the two numbers need to have the same amount of digits.