Algorithm 具有不同相邻数字的最小较大数字

我们是一个给定的数字

n

1我的解决方案是基于相邻的数字，当我们遇到“99”时有额外的逻辑。我真的不太喜欢它，但也许它会解决你的问题，或者帮助你写出更好的解决方案

public static int Test(string nStr)
{
    var n = int.Parse(nStr);
    var needRestartCheck = true;
    while (needRestartCheck)
    {
        needRestartCheck = false;
        for (var i = 0; i < nStr.Length - 1; i++)
        {
            var first = nStr[i];
            var second = nStr[i + 1];
            if (first == second)
            {
                n += (int)Math.Pow(10, nStr.Length - 2 - i);
                nStr = n.ToString();
                needRestartCheck |= first == '9';
            }
        }
    }
    return n;
}

公共静态int测试（字符串nStr）
{
var n=int.Parse（nStr）；
var needRestartCheck=true；
while（needRestartCheck）
{
needRestartCheck=false；
对于（变量i=0；i

我的方法如下，它只适用于我自己解决的问题

#include <bits/stdc++.h>
#define ll unsigned long long

using namespace std;

bool noDec(string str,int i,ll num){
    str[i+1]--;
    return stoll(str)>num;
}

ll num;
string str;
int main() {
    cin>>num;
    str=to_string(num+1);
    for(int i=0; i<str.length()-1; i++){
        if(str[i]==str[i+1]){
            if(str[i]!='9'){
                if(noDec(str,i,num)&&str[i]!='0')str[i+1]--;
                else str[i+1]++;
            }
            else{
                if(i==0){
                    str='1'+string(str.length(),'0');
                }else{
                    str[i-1]++;
                    for(int j=i; j<str.length(); j++){
                        str[j]='0';
                    }
                }
            }i=0;
        }
    }
    if(str[0]==str[1]&&str[0]=='9'){
        str=string((ll)log10(num)+2,'1');
        for(int i=1; i<str.length(); i+=2)
            str[i]='0';
    }
    cout<<str;
}

#包括
#定义ll unsigned long long
使用名称空间std；
bool noDec（字符串str、int i、ll num）{
str[i+1]-；
返回stoll（str）>num；
}
llnum；
字符串str；
int main（）{
cin>>num；
str=到_字符串（num+1）；
对于（int i=0；这对于大数字来说速度较慢的原因是，如果您当前正在尝试100000000，那么在最左边的两个零不再相同之前，您将添加大量的1。尝试搜索最左边的一对相等的数字并直接更改它们。但是如果给定的数字是99999999，那么更改相邻的数字将如何uld工作？您可以通过在正确的位置添加1来更改它们，这样它将勾选到100999999。然后清除右边的数字以获得100000000，然后继续；最左边的相等对是00，所以在正确的位置添加1以获得101000000，依此类推。谢谢，但这篇文章是关于slowness@SandroJologua，我已经用alt解决了速度问题ernate解决方案。当你给这个问题[数论]加上标签，然后把它变成一个字符串操作问题时，我喊“犯规”！它也可以很容易地变成字母。这可以用数学来解决。在我对你的原始代码的更正中，我添加了第二个例子，它的速度和这个一样快。
bool valid(int x) {
unsigned long long n;
if (valid(n)) {

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

bool valid(unsigned long long x) {
    unsigned long long remainder = x % 10;

    while (x) {

        unsigned long long quotient = x / 10;
        unsigned long long adjacent = quotient % 10;

        if (remainder == adjacent) {
            return false;
        }

        x = quotient;
        remainder = adjacent;
    }

    return true;
}

int main(int argc, char *argv[]) {
    char *pointer;
    unsigned long long n = strtoull(argv[1], &pointer, 10) + 1;

    while (true) {
        if (valid(n)) {
            printf("%llu\n", n);
            break;
        }

        n++;
    }

    return 0;
}

> dc
10 10 ^ p
10000000000
> ./a.out 10000000000
10101010101
> dc
10 11 ^ p
100000000000
> ./a.out 100000000000
101010101010
>

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

unsigned logTen(unsigned long long number) {
    unsigned power = 0;

    while (number >= 10) {
        power += 1;
        number /= 10;
    }

    return power;
}

unsigned long long expTen(unsigned n) {
    unsigned long long product = 1;

    while (n > 0) {
        product *= 10;
        n -= 1;
    }

    return(product);
}

unsigned long long next_no_adjacent(unsigned long long number) {
    number += 1;

    unsigned power = logTen(number);

    while (power > 0) {

        unsigned long long multiplier = expTen(power);
        unsigned long long digit = (number / multiplier) % 10;

        unsigned long long adjacent_multiplier = expTen(power - 1);
        unsigned long long adjacent_digit = (number / adjacent_multiplier) % 10;

        while (digit == adjacent_digit) {

            number = ((number + adjacent_multiplier) / adjacent_multiplier) * adjacent_multiplier;

            digit = (number / multiplier) % 10;
            adjacent_digit = (number / adjacent_multiplier) % 10;
        }

        --power;
    }

    return number;
}

int main(int argc, char *argv[]) {
    char *pointer;
    unsigned long long n = strtoull(argv[1], &pointer, 10);

    printf("%llu\n", next_no_adjacent(n));

    return 0;
}

> dc
10 19 ^ p 
10000000000000000000
> time ./a.out 10000000000000000000
10101010101010101010
0.001u 0.001s 0:00.00 0.0%  0+0k 0+0io 0pf+0w
>

#include <bits/stdc++.h>
#define ll unsigned long long

using namespace std;

bool noDec(string str,int i,ll num){
    str[i+1]--;
    return stoll(str)>num;
}

ll num;
string str;
int main() {
    cin>>num;
    str=to_string(num+1);
    for(int i=0; i<str.length()-1; i++){
        if(str[i]==str[i+1]){
            if(str[i]!='9'){
                if(noDec(str,i,num)&&str[i]!='0')str[i+1]--;
                else str[i+1]++;
            }
            else{
                if(i==0){
                    str='1'+string(str.length(),'0');
                }else{
                    str[i-1]++;
                    for(int j=i; j<str.length(); j++){
                        str[j]='0';
                    }
                }
            }i=0;
        }
    }
    if(str[0]==str[1]&&str[0]=='9'){
        str=string((ll)log10(num)+2,'1');
        for(int i=1; i<str.length(); i+=2)
            str[i]='0';
    }
    cout<<str;
}