Как я могу заставить свою программу делать что-нибудь, когда “многоразрядное число со всеми цифрами, идентичными”, появляется?

Пока Вы используете оператор mod (извините, я не знаю объектива C), но я вполне уверен, что должен быть оператор mod вида % и модифицировать его на основе 1's.

Например:

66%11

Вы знаете, что это одно и то же количество цифр, потому что в данном случае mod вернул 0.

То же самое здесь:

7777%1111

Можно было бы вычислить, сколько цифр, затем поделить шестизначное число на 111111, 5-значное число на 11111 и т.д., и посмотреть, получится ли целое число.

Извините, если я не предлагаю никакого кода Objective-C, я не знаю этого языка.

преобразовать число в строку, проверить длину, чтобы получить количество цифр, а затем модифицировать на соответствующее число. Далее следует псевдокод, где num_to_check - это число, с которого вы начинаете (т.е. 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

Вот рекурсивная версия, только для жаворонков. Опять же, не самый эффективный способ, но, наверное, самый короткий в коде.

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);
}

На самом деле, это рекурсия хвоста, поэтому приличный компилятор должен генерировать довольно эффективный код.

Преобразовать в строку и проверить, не совпадает ли каждый графический элемент в строке, начинающийся с позиции 1, с предыдущим.

Предположим, что Objective-C имеет тип 'bool', аналогичный 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);
}

Вероятно, можно вычислить вариант, в котором lo_range и divisor делятся на десять в каждой итерации, начиная со значений в control[0].

digitsequal = ( ((number < 1000000) && (number > 111110) && (number % 111111 == 0)) ||
                ...
                ((number < 1000) && (number > 110) && (number % 111 == 0)) ||
                ((number < 100) && (number > 10) && (number % 11 == 0)) 
              );

Благодаря булевым операциям, которые сокращают время выполнения, это должно быть достаточно хорошим решением относительно среднего количества сравнений, оно требует не более одной операции по модулю на число, оно не имеет цикла, оно может быть красиво отформатировано, чтобы выглядеть симметричным, и очевидно, что оно тестирует. Но, конечно, преждевременная оптимизация, знаете ли, но так как уже дано много других решений... ;)

Это можно сделать рекурсивно с помощью оператора divide and multiply (разделить с остатком можно, однако, упростить)

например

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;
}

#include <stdlib.h>
#include <stdio.h>

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;
}

Похожие, но не совсем совпадающие с другими ответами (которых я не заметил).