对于1到9之间的某个数字n，如果它等于n + nn + nnn + ...，则数字称为数字增加。例如，24是数字增加，因为它等于2 + 22（此处n = 2）。
实际上，我的一个朋友问我这个问题，我一直在考虑这个问题，但到目前为止找不到确切的解决方案。有人可以帮忙吗？我需要的函数如果是数字增加则返回true，否则返回false。
对于1到9之间的某个数字n，如果它等于n + nn + nnn + ...，则数字称为数字增加。例如，24是数字增加，因为它等于2 + 22（此处n = 2）。
实际上，我的一个朋友问我这个问题，我一直在考虑这个问题，但到目前为止找不到确切的解决方案。有人可以帮忙吗？我需要的函数如果是数字增加则返回true，否则返回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;
}
此属性只有相对较少的数字：在范围内 unsigned long long （64位），只有172位数字增加。
因此，就实际解决方案而言，它是有意义的 预先计算它们 并将它们放入哈希。这是Python代码：
# 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 + ... 总和的长度 K。
简单详尽的搜索将起作用。
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
最简单的方法是添加（自下而上），我将使用简单的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;
重要的是你最多只需要 log n 迭代，如果所有数字都大于给定数字，你也可以更快地返回，这是 O(log n) 算法。
这是一个python代码。这里的基本逻辑是，如果除以1-9之间的特定数字，则数字增加的数字给出仅由1组成的数字增加数。所有数字增加的数字1遵循特定模式，即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"
一般代表是：
n +（n * 10 + n）+（n * 100 + n）......
如果数字看起来像相同数字的总和那么任何数字都可以表示为
（1 + 111 + ...）* base_digit
。假设我们可以使用简单的算法：
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;
}
Ambiguitiy： 值1-9是否为自己重复？ （我自己懒得谷歌）
如果1-9重复，那么以下应该有效。如果没有，并且您希望代码仅在值> 10时工作，那么您可以初始化 mult 10。
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;
}
执行后， i 必须包含RESULT为重复数字IF的值 flag 如果执行后标志为零，那么TARGET不是重复数字。
我想知道是否有可能一个数字可以重复多个值，只是好奇。
这里 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;
}
这是最短的解决方案
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;
}
设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）的数字倍数。
这是一个非常轻松的代码高尔夫实现的想法：
#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;
}