How can I get my program to do anything when a "multidigit number with all digits identical" appears?

Question

Hello, my program generates random numbers with up to 6 digits with

int number = arc4random % 1000000;

I want that my program do something when a number like 66 or 4444 or 77777 appears (multidigit number with all digits identical). I could manual write:

    switch (number) {
    case 11: blabla...;
    case 22: blabla...;
    (...)
    case 999999: blabla;
}

That would cost me many program code. (45 cases...)

Is there an easy way to solve the problem.

Answer 1

You could figure out how many digits, then divide a six-digit number by 111111, 5-digit number by 11111, etc, and see if the result is an integer.

Excuse me if I don't suggest any Objective-C code, I don't know that language.

Answer 2

Convert to a string and check if each char in the string, starting at position 1, is the same as the previous one.

Answer 3

As long as you use the mod operator (sorry I do not know objective C) but I'm quite certain there must be a mod operator like % and modding it based on 1's.

For instance:

66%11

You know it is the same number of digits because mod returned 0 in this case.

Same here:

7777%1111

Answer 4

You could do this recursively with the divide and multiply operator (a divide with remainder could simplify it though)

e.g.

bool IsNumberValid(int number)
{
    if(number > 10)
    {
        int newNumber = number / 10;
        int difference = number - newNumber * 10;
        number = newNumber;
        do
        {
            newNumber = number / 10;
            if((number - newNumber * 10) != difference)
            {
                // One of the number didn't match the first number, thus its valid
                return true;
            }
            number = newNumber;
        } while(number);
        // all of the numbers were the same, thus its invalid
        return false;
    }
    // number was <= 10, according to your specifications, this should be valid
    return true;
}

Answer 5

convert the number to a string, check the length to get the number of digits, then mod by the appropriate number. pseudocode follows where num_to_check is the number you start out with (i.e. 777)

string my_num = (string)num_to_check;
int num_length = my_num.length;
int mod_result;
string mod_num = "1";
int mod_num_int;

for(int i = 1; i < num_length - 1; i++)
{
  mod_num = mod_num + "1";
}

mod_num_int = (int)mod_num;
mod_result = num_to_check % mod_num_int;

//If mod_result == 0, the number was divisible by the appropriate 111... string with no remainder

Answer 6

Here's one way to check that all digits are the same:

bool AllDigitsIdentical(int number)
{
    int lastDigit = number % 10;
    number /= 10;
    while(number > 0)
    {
        int digit = number % 10;
        if(digit != lastDigit)
            return false;
        number /= 10;
    }

    return true;
}

Answer 7

Here's a recursive version, just for larks. Again, not the most efficient way, but probably the shortest codewise.

bool IsNumberValid (int number) {
   if (number < 10) return true;
   int n2 = number / 10; 
   // Check if the last 2 digits are same, and recurse in to check 
   // other digits:
   return ((n2 % 10) == (number % 10)) && IsNumberValid (n2);
}

Actually, this is tail recursion, so a decent compiler ought to generate pretty efficient code.

Answer 8

Assuming Objective-C has a 'bool' type analogous Standard C99:

#include <assert.h>
#include <stdbool.h>

extern bool all_same_digit(int number);  // Should be in a header!

bool all_same_digit(int number)
{
    static const struct
    {
        int   lo_range;
        int   divisor;
    } control[] =
    {
         { 100000, 111111 },
         {  10000,  11111 },
         {   1000,   1111 },
         {    100,    111 },
         {     10,     11 },
    };
    static const int ncontrols = (sizeof(control)/sizeof(control[0]));
    int i;

    assert(number < 10 * control[0].lo_range);
    for (i = 0; i < ncontrols; i++)
    {
         if (number > control[i].lo_range)
             return(number % control[i].divisor == 0);
    }
    return(false);
}

You can probably work out a variation where the lo_range and divisor are each divided by ten on each iteration, starting at the values in control[0].

Answer 9

#include #include

int main() {
    int a = 1111;
    printf("are_all_equal(%d) = %d\n",a,are_all_equal(a));
    a = 143;
    printf("are_all_equal(%d) = %d\n",a,are_all_equal(a));
    a = 1;
    printf("are_all_equal(%d) = %d\n",a,are_all_equal(a));
    a = 101;
    printf("are_all_equal(%d) = %d\n",a,are_all_equal(a));
    return 0;
}

int are_all_equal(int what) {
    int temp = what;
    int remainder = -1;
    int last_digit = -1;
    while (temp > 0) {
        temp = temp/10;
        remainder = temp%10;
        if (last_digit != -1 && remainder != 0) {
            if (last_digit != remainder) return 0;
        }
        last_digit = remainder;
    }
    return 1;
}

Similar, but not exactly equal to the other answers (which I didn't notice were there).

Answer 10

You might consider looking into a regular expression library (probably overkill for this particular problem, but in general the right solution for pattern matching problems).