C++ 数字递增测试

如果一个数字等于n+nn+nnn+，则称为数字递增。。。对于介于1和9之间的某些数字n。例如，24是数字递增，因为它等于2+22（此处n=2）

---

事实上，我的一个朋友问了我这个问题，我一直在思考这个问题，但到目前为止还没有找到确切的答案。有人能帮忙吗？我需要一个函数，如果它是数字递增的，则返回true，否则返回false。

简单的穷举搜索将起作用

def is_digit_increasing_number(x):
    # n = 1, 1+11, 1+11+111, ...
    n = 1
    i = 1
    while n <= x:
        if x % n == 0 and n * 10 > x:
            return True
        i += 1
        n = n * 10 + i
    return False

def是递增的数字（x）：
#n=1，1+11，1+11+111。。。
n=1
i=1
而nx：
返回真值
i+=1
n=n*10+i
返回错误

最简单的方法是进行加法（自下而上），我将使用simple for循环：

List<int> numbersSum = new List<int>{1,2,3,4,5,6,7,8,9};
List<int> lastNumber = new List<int>{1,2,3,4,5,6,7,8,9};
for(int i=0;i<= lg n + 1;i++)
{

   for(int j=0;j<9;j++)
   {
      if(list[j] < n)
      {
          var lastNumberJ = lastNumber[j]*10+j+1;
          list[j] += lastNumberJ; // add numbers to see will be same as n.
          if (list[j] == n)
            return j+1;
          lastNumber[j] = lastNumberJ;
      }
   }   
}

return -1;

List numbersSum=新列表{1,2,3,4,5,6,7,8,9}；
List lastNumber=新列表{1,2,3,4,5,6,7,8,9}；
对于（int i=0；i模棱两可：值1-9是否重复？（我自己懒得用谷歌搜索）

如果重复1-9，则以下操作应该有效。如果没有，并且您希望代码仅对大于10的值有效，则可以使用10初始化
mult

int i, mult = 1, result, flag;

for( i=1; i<9; i++ )
{
    flag = 0;

    while( result < TARGET )
    {
        result = result+(i*mult);
        mult   = mult*10;

        if( result == TARGET )
        {
            flag = 1;
            break;
        }
    }
    if( flag == 1 )
        break;
}

inti，mult=1，结果，标志；
for（i=1；i此处
num
是数字，
n
是数字

#include<stdio.h>

int f(int num,int n)
{
 int d=n;
 while(num>0)
 {
        num-=n;
        n=d+n*10;
 }
 if(num==0)
        return 1;
 else
        return 0;
}

int main()
{
 int num;
 int n;
 int flag;
 printf("Enter the number :");
 scanf("%d",&num);
 printf("Enter the digit :");
 scanf("%d",&n);
 flag = f(num,n);
 if(flag == 1)
        printf("It's in n+nn+nnn+...\n");
 if(flag ==0)
        printf("It's not\n");
 return 0;
}

#包括
intf（intnum，intn）
{
int d=n；
while（num>0）
{
num-=n；
n=d+n*10；
}
如果（num==0）
返回1；
其他的
返回0；
}
int main（）
{
int-num；
int n；
int标志；
printf（“输入数字：”）；
scanf（“%d”和&num）；
printf（“输入数字：”）；
scanf（“%d”和“&n”）；
flag=f（num，n）；
如果（标志==1）
printf（“在n+nn+nnn+…\n中”）；
如果（标志==0）
printf（“它不是\n”）；
返回0；
}
一般表示为：

n+（n*10+n）+（n*100+n）

若数字看起来像相同数字的总和，那个么任何数字都可以表示为

（1+111+…）*基数

.假设这样，我们可以使用简单的算法：

bool isDigitIncreasing(const int num)
{
    int n = 1;
    int sum = 1; //value to increase n
    while (n <= num) {
        //if num is (111...) * base_digit and base_digit is < 10
        if (num % n == 0 && n * 10 > num) return true;
        sum = sum * 10 + 1; //N*10+N where n is 1 as was assumed
        n += sum;  //next step
    }
    return false;
}

bool是数字递增（const int num）
{
int n=1；
int sum=1；//增加n的值
而（n num）返回true；
sum=sum*10+1；//N*10+N其中，假设N为1
n+=sum；//下一步
}
返回false；
}
我已经这样做了。请退房一次

int sum = 0, count =0;
bool flag = false;

public bool isDigitIncreasing(int input_number)
{
int  n= get_number_of_digit(input_number); // Gets number of digits
int sum = 0;
    for(int i=0;i<n;i++)
    {
        sum = sum*10+1;
        count = count + sum;
    }

    for(int i=1; i<=9;i++)
    {
        if((input_number)==count*i)
        {
            flag = true;
            break;
        }
        else
        flag = false;
    }
    return flag;

}

    public int get_number_of_digit(int num)
    {

        int size = 0;
        do
        {
            num = num/10;
            size++;
        }while(num>0);
        return size;
    }

int sum=0，count=0；
布尔标志=假；
公共布尔值为数字递增（整数输入\ U编号）
{
int n=get_number_of_digit（输入_number）；//获取位数
整数和=0；
对于（int i=0；i，具有此属性的数字相对较少：在
无符号长
（64位）范围内，只有172位递增数字

因此，就实际解决方案而言，预先计算它们并将它们放入散列中是有意义的

# Auxiliary function that generates
# one of the 'nnnn' elements
def digits(digit,times):
  result = 0
  for i in range(times):
    result += digit*(10**i)
  return result

# Pre-computing a hash of digit-increasing
# numbers:
IncDig = {}
for i in range(1,30):
  for j in range(1,10):
    number = reduce(lambda x,y:x+y,[digits(j,k) for k in range(1,i+1)])
    IncDig[number] = None

那么，实际的检查函数只是散列中的一个查找：

def IncDigCheck(number):
  return (number in IncDig)

这实际上是O（1），预计算所占用的时间和空间最小，因为只有9个不同的数字（零不计算）因此，对于长度之和，只有
K*9
类型组合
n+nn+…
，
这里是一个python代码。这里的基本逻辑是，如果数字递增的数字除以1-9之间的特定数字，则给出一个仅由1构成的数字递增。所有数字递增的数字1都遵循一个特定的pattern ie 12345678

import sys
for n in range(1,10):
    a=1
    if k%n!=0:
        a=0
    else:
        g=str(k/n)
        j=int(g[0])
        for i in range(1,len(g)):
            if int(g[i])==j+1:
                j=int(g[i])
            else:
                a=0
                break
    if a==1:
        print "Yes,it is a digit increasing number"
        sys.exit(0)
print "No,it is not a digit increasing number"

公共布尔ISDigitinIncreming（整数）
{
整数和；
int size=计算数字（数字）；
对于（int i=1；i=1）
{
对于（int j=温度；j0）；
返回大小；
}
以下是最短的解决方案

 public static int isDigitIncreasing (int n)
        {       
            if(n<10)
            {
                return 1;
            }

            for(int i=1;i<=9;i++)
            {
                int tempsum=i;
                int previous=i;
                while(tempsum<=n)
                {
                    previous=previous*10 + i;
                    tempsum=tempsum + previous;
                    if(tempsum==n)
                    {
                        return 1;
                    }
                }
            }

            return 0;
        }

公共静态整数是数字增量（整数n）
{       
如果（n设d（k）为1+11+111+…+（11…11），其中最后一个数字有k位，则d（1）=1，d（k+1）=10d（k）+k+1

我们想测试d（k）*i=n，对于一些k，对于一些i=1..9

如果我们已经计算了d（k），那么i（如果存在）必须是n/d（k）。我们可以通过将n与（（n/d（k））%10）*d（k）进行比较来检查n/d（k）是否正确。如果i大于9，%10将导致测试失败

这给了我们一个相对简洁的解决方案：计算后续的d（k），直到它们大于n，并在每个点检查n是否是d（k）的数字倍数

下面是这个想法的一个非常简单的代码golfed实现：

#include <stdio.h>

int is_digit_increasing(int n) {
    for(int d=1,k=1;d<=n;d=d*10+ ++k)if(n==(n/d)%10*d)return 1;
    return 0;
}

int main(int argc, char**argv) {
    for (int i=0; i<10000; i++) {
        if (is_digit_increasing(i)) {
            printf("%d\n", i);
        }
    }
    return 0;
}

#包括
整数是数字递增（整数n）{
对于（int d=1，k=1；d
//示例程序
#包括
#包括
int isDigitIncreasingNo（int n）{
if（如果你不需要特定语言的答案，我会回答。我只需要逻辑。任何语言的代码都可以。你只有9个选项可以尝试。它可以是（1+11+…）或（2+22+…）…或（9+99+…）
。你可以使用模/除法来分离数字。比如，24/10=2，然后乘以10，得到20。然后把商“2”加到这个“20”上，得到“22”。现在再把商“22”加到这个“20”上，得到24。如果它等于给定的数字，那么它是数字递增的。只要把它推广到N个数字。很简单。为什么要把它加起来呢？我只有一个在C语言中，这是有效的…我认为OP想要算法，而不需要输入基本数字。你可以使用一个循环来检查每个基本数字。为什么是我？我不需要这个算法）@DenisErmolin：对不起，我实际上是指OP，但它是我的原生类型。每个O（n）算法都是O（1）当n被限制为某个常数时。@SaeedAmiri这不是重点。重点是哈希中的查找不取决于您查找的数字的大小，甚至不取决于条目的数量。（后者不是完全正确的，取决于哈希如何处理冲突。这就是为什么我说的几乎是O（1）。）在Python中，对于整数，
散列（x）=x
，因此很容易出现一些冲突非常糟糕的情况。@jogojapan，这有什么好处？首先你搜索的是最大数，然后你说它是O（1）？我很确定你的算法是正确的
#include <stdio.h>

int is_digit_increasing(int n) {
    for(int d=1,k=1;d<=n;d=d*10+ ++k)if(n==(n/d)%10*d)return 1;
    return 0;
}

int main(int argc, char**argv) {
    for (int i=0; i<10000; i++) {
        if (is_digit_increasing(i)) {
            printf("%d\n", i);
        }
    }
    return 0;
}

// Example program
#include <iostream>
#include <string>


int isDigitIncreasingNo(int n) {

    if(n<=0)
      return 0;

    int len = std::to_string(n).length();

    int vector1 = 0;
    int vector2 = 0;

    for(int i=1;i<=len;i++)
       vector2 = (vector2*10)+i;

    vector1 = vector2/10;

    if(n % vector2 == 0 && (n / vector2)<=9  )
        return 1;

    if(n % vector1 == 0 && (n / vector1)<=9  )
        return 1;

    return 0;
}

int main()
{
  for (int i=0; i<10000000; i++) {
        if (isDigitIncreasingNo(i)) {
            printf("%d\n", i);
        }
    }
    return 0;
}