Как проверить цифры, которые одинаковы в целых числах без использования массивов?

Question

Я пытаюсь написать простую программу, которая генерирует C 1 из 3 случая:

1. целое число без каких-либо смежных цифр то же самое.
2. Целое число с одной парой одинаковых смежных цифр.
3. Целое число с одним трио одинаковых смежных цифр.

После того, как целочисленное значение не соответствует требованиям любого из случаев, целое число будет увеличено на 1, а затем снова будет проверено.

Условия: пользователь вводит опцию между 1-3, начальное целочисленное значение представляет собой неотрицательное целое число, а сгенерированное значение больше начального целочисленного значения, введенного пользователем.

ПРИМЕЧАНИЕ. Я не могу использовать метод, включающий массив или строку. Рекурсия разрешена, но мой профессор не поощряет ее использование.

Моей текущей проблемой является определение того, как сравнивать цифры во введенном целочисленном значении без создания новой переменной для каждой из них. Вот то, что я до сих пор:

int getOption() //retrieves the option entered by the user 
{ 
    int option; 
    do 
    { 
    printf("\nEnter desired option: "); 
    scanf("%d", &option); 
    if (option <= 0 || option > 3) 
    { 
     printf("\nError! Invalid option selected!!\n"); 
    } 
    }while(option <= 0 || option > 3); 
    return(option); 
} 

int getStart() //retrieves the starting integer value entered by the user 
{ 
    int startValue; 
    do 
    { 
    printf("\nEnter starting integer: "); 
    scanf("%d", &startValue); 
    if (startValue <= 0) 
    { 
     printf("\nError! Non-negative values only!!\n"); 
    } 
    }while(startValue <= 0); 
    return(startValue); 
} 

int checkSame(int startValue); //checks if the user-given integer has any pairs of same adjecent digits. 
{ 
int counter; 
int sameAdjacent = 0; 
while (sameAdjacent < 1) 
{ 
    while(startValue > 0) 
    { 
    startValue = startValue % 10; 
    counter++; 
    } 
    for(startValue; startValue > 0; startValue/10) 
    { 
    //????? 

    } 


    } 
} 

Вот некоторые примеры того, что надлежащее исполнение выглядит следующим образом:

1. No adjacent digits the same. 
2. A single pair of adjacent digits the same. 
3. A single trio of adjacent digits the same. 
Enter desired option: 1 
Enter starting integer: 1222 
Next larger value with no two adjacent digits the same is 1230. 

1. No adjacent digits the same. 
2. A single pair of adjacent digits the same. 
3. A single trio of adjacent digits the same. 
Enter desired option: 2 
Enter starting integer: 133300 
Next larger value with only a single pair of digits the same is 133401. 

1. No adjacent digits the same. 
2. A single pair of adjacent digits the same. 
3. A single trio of adjacent digits the same. 
Enter desired option: 3 
Enter starting integer: 123456 
Next larger value with only a single trio of digits the same is 123555. 

Любая помощь приветствуется. Спасибо!

Answer 1

Поскольку это задание, которое вы предположительно призваны решить самостоятельно, позвольте мне дать намек, чтобы вы на правильном пути:

• Если x является целой переменной, то:
  • x % 10 дает последний базовый 10 разряд x и
  • x = x/10 отрубает последней цифры x.

отметить также, что вы можете сохранить последнюю цифру x в другой переменной, прежде чем рубить его. Фактически, вы можете легко сохранить две (или более!) Последние недавно отрубленные цифры таким образом, просто имея одну переменную для каждого из них.

Если это не достаточный намек, сообщите мне, где вы все еще застряли, и я попытаюсь немного помочь.

---

ОК, так как вы говорите, что вы все еще застряли, позвольте мне показать вам, как я бы решить эту проблему:

int pairs = 0, triples = 0; 
int digit1 = -1, digit2 = -1, digit3 = -1; // no actual digit can be -1 

while (x > 0) { 
    // keep track of the last three digits chopped off 
    digit3 = digit2; 
    digit2 = digit1; 
    digit1 = x % 10; 

    // chop off the last digit of x 
    x /= 10; 

    // check whether we've just chopped off a pair or a triple 
    if (digit1 == digit2) { 
     pairs++; 
     if (digit2 == digit3) { 
      triples++; 
     } 
    } 

    // uncomment these lines for debugging output: 
    // fprintf(stderr, "x = %d, digit(1-3) = %d, %d, %d; %d pairs and %d triples seen\n", 
    //   x, digit1, digit2, digit3, pairs, triples); 
} 

В качестве упражнения, вы можете запустить этот код для различных значения x и либо пройти через цикл в отладчике (рекомендуется!), либо раскомментировать вызов fprintf(), чтобы увидеть, как переменные изменяются на каждой итерации.

Как только вы это сделали, я считаю, что вы должны легко заполнить оставшуюся часть задания.

Answer 2

Для чего это стоит, следующий метод возвращает 1 (истина), если пользователь данное число имеет ровно 1 пара одинаковых соседних цифр, 0 (ложь) иначе:

public int checkSame(int startValue) 
{ 
    int sameAdjacent = 0; 
    int last,pre_last; 
    while(startValue > 0) 
    { 
     last = startValue % 10; 
     pre_last = (startValue/10) % 10; 
     if(last == pre_last) 
      sameAdjacent++; 
     startValue/=10; 
    } 
    return sameAdjacent == 1 ? 1 : 0; 
}