blocks|key|447060|text|简单的穷举搜索将会起作用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|447061|def+is_digit_increasing_number(x):
++++#+n+=+1,+1%2B11,+1%2B11%2B111,+...
++++n+=+1
++++i+=+1
++++while+n+<=+x:
++++++++if+x+%25+n+==+0+and+n+*+10+>+x:
++++++++++++return+True
++++++++i+%2B=+1
++++++++n+=+n+*+10+%2B+i
++++return+False|code-block|syntax|javascript|447062|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Simple exhaustive search will work.

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

blocks|key|229029|text|最简单的方法是做加法(自下而上)，我将使用简单的for循环：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|229030|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+%2B+1;i%2B%2B)
{

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

return+-1;|code-block|syntax|javascript|229031|重要的是你只需要最多的log+n迭代，而且如果所有的数字都大于给定的数字，你可以更快地返回，这就是O(log+n)算法。|offset|length|style|CODE|229032|entityMap^0|0|0|B|5|1D|8|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

Simplest possible way is do the addition (bottom-up), I'll use simple for loop:

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

 for(int j=0;j&lt;9;j++)
 {
 if(list[j] &lt; 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;
</code></pre>

The important part is you just need at most <code>log n</code> iteration and also you can return sooner if all numbers are bigger than given number, this is <code>O(log n)</code> algorithm.

blocks|key|447090|text|这里num是数字，n是数字|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|447091|#include<stdio.h>

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

int+main()
{
+int+num;
+int+n;
+int+flag;
+printf("Enter+the+number+:");
+scanf("%25d",&num);
+printf("Enter+the+digit+:");
+scanf("%25d",&n);
+flag+=+f(num,n);
+if(flag+==+1)
++++++++printf("It's+in+n%2Bnn%2Bnnn%2B...\n");
+if(flag+==0)
++++++++printf("It's+not\n");
+return+0;
}|code-block|syntax|javascript|447092|entityMap^0|2|3|9|1|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

Here <code>num</code> is the number and <code>n</code> is the digit 

<pre><code>#include&lt;stdio.h&gt;

int f(int num,int n)
{
 int d=n;
 while(num&gt;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",&amp;num);
 printf("Enter the digit :");
 scanf("%d",&amp;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;
}
</code></pre>

blocks|key|229074|text|我就是这样做的。退房一次。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|229075|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%2B%2B)
++++{
++++++++sum+=+sum*10%2B1;
++++++++count+=+count+%2B+sum;
++++}

++++for(int+i=1;+i<=9;i%2B%2B)
++++{
++++++++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%2B%2B;
++++++++}while(num>0);
++++++++return+size;
++++}|code-block|syntax|javascript|229076|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I have done in this way. Check out once.

<pre><code>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&lt;n;i++)
 {
 sum = sum*10+1;
 count = count + sum;
 }

 for(int i=1; i&lt;=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&gt;0);
 return size;
 }
</code></pre>

blocks|key|447130|text|这是一个python+code.The的基本逻辑，它是一个数字递增数，如果除以1-9之间的特定数字，得到一个仅由ones.All组成的数字递增数，1的数字递增数遵循一个特定的模式，即12345678...|type|unstyled|depth|inlineStyleRanges|entityRanges|data|447131|import+sys
for+n+in+range(1,10):
++++a=1
++++if+k%25n!=0:
++++++++a=0
++++else:
++++++++g=str(k/n)
++++++++j=int(g[0])
++++++++for+i+in+range(1,len(g)):
++++++++++++if+int(g[i])==j%2B1:
++++++++++++++++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"|code-block|syntax|javascript|447132|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is a python code.The basic logic here is that a digit increasing number if divided by a specific number between 1-9 gives a digit increasing number made of only ones.All the digit increasing numbers of 1 follow a specific pattern ie 12345678...

<pre><code>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"
</code></pre>

blocks|key|447138|text|+public+boolean+isDigitIncreasing(int+number)

+{
++int+sum;
++int+size=calculateNumberOfDigits(number);

++for(int+i=1;i<=9;i%2B%2B)
+++{
++++++sum=0;
++++++int+temp=size;
++++++while(temp>=1)
++++++++{
++++++++++++for(int+j=temp;j<=1;j--)
+++++++++++++{
++++++++++++++++sum=sum%2Bi*(int)Math.pow(10,j-1);
+++++++++++++}
++++++++++++temp--;
+++++++++}
++++++if(sum==number)
+++++++{
++++++++++return+true;//Its+a+digit+increasing
++++++++}
++++}

+++++return+false;
++}

+public+int+calculateNumberOfDigits(int+number)
++{
+++++int+size=0;
+++++do
+++++++{
+++++++++++++number=number/10;
+++++++++++++size%2B%2B;
++++++++}while(size>0);

+++++++return+size;
++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|447139|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code> public boolean isDigitIncreasing(int number)

 {
 int sum;
 int size=calculateNumberOfDigits(number);

 for(int i=1;i&lt;=9;i++)
 {
 sum=0;
 int temp=size;
 while(temp&gt;=1)
 {
 for(int j=temp;j&lt;=1;j--)
 {
 sum=sum+i*(int)Math.pow(10,j-1);
 }
 temp--;
 }
 if(sum==number)
 {
 return true;//Its a digit increasing
 }
 }

 return false;
 }

 public int calculateNumberOfDigits(int number)
 {
 int size=0;
 do
 {
 number=number/10;
 size++;
 }while(size&gt;0);

 return size;
 }
</code></pre>

blocks|key|229121|text|以下是最短的解决方案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|229122|+public+static+int+isDigitIncreasing+(int+n)
++++++++{+++++++
++++++++++++if(n<10)
++++++++++++{
++++++++++++++++return+1;
++++++++++++}

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

++++++++++++return+0;
++++++++}|code-block|syntax|javascript|229123|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is the shortest solution 

<pre><code> public static int isDigitIncreasing (int n)
 { 
 if(n&lt;10)
 {
 return 1;
 }

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

 return 0;
 }
</code></pre>

blocks|key|447201|text|设d(k)为1%2B11%2B111%2B...%2B(11...11)，其中最后一个数有k位。d(1)=1，d(k%2B1)=10d(k)%2Bk%2B1。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|447202|我们想要测试d(k)*i+=+n，对于一些k，对于一些i=1..9。|447203|如果我们已经计算了d(k)，那么i(如果存在)一定是n/d(k)。我们可以通过将n与((+n/d(k)+)%2510)*d(k)进行比较来检查n/d(K)是否正确。如果i大于9，%2510会使测试失败。|447204|这给了我们一个相对简洁的解决方案:计算后续的d(k)，直到它们大于n，并在每个点上检查n是否为d(k)的数字倍数。|447205|下面是这个想法的一个非常简单的代码实现：|447206|#include+<stdio.h>

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

int+main(int+argc,+char**argv)+{
++++for+(int+i=0;+i<10000;+i%2B%2B)+{
++++++++if+(is_digit_increasing(i))+{
++++++++++++printf("%25d\n",+i);
++++++++}
++++}
++++return+0;
}|code-block|syntax|javascript|447207|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|T|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|U|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|V|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Let d(k) be 1+11+111+...+(11...11) where the last number has k digits. Then d(1)=1, and d(k+1)=10d(k)+k+1.

We want to test if d(k)*i = n, for some k, and for some i=1..9.

If we've computed d(k), then i (if it exists) must be n/d(k). We can check if n/d(k) is correct, by comparing n with ((n/d(k))%10)*d(k). The %10 makes the test fail if i is larger than 9.

This gives us a relatively terse solution: compute subsequent d(k) until they are bigger than n, and at each point check to see if n is a digit-multiple of d(k).

Here's a very lightly code-golfed implementation of that idea:

<pre><code>#include &lt;stdio.h&gt;

int is_digit_increasing(int n) {
 for(int d=1,k=1;d&lt;=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&lt;10000; i++) {
 if (is_digit_increasing(i)) {
 printf("%d\n", i);
 }
 }
 return 0;
}
</code></pre>

blocks|key|229189|text|//+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%2B%2B)
+++++++vector2+=+(vector2*10)%2Bi;

++++vector1+=+vector2/10;

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

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

++++return+0;
}

int+main()
{
++for+(int+i=0;+i<10000000;+i%2B%2B)+{
++++++++if+(isDigitIncreasingNo(i))+{
++++++++++++printf("%25d\n",+i);
++++++++}
++++}
++++return+0;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|229190|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>// Example program
#include &lt;iostream&gt;
#include &lt;string&gt;


int isDigitIncreasingNo(int n) {

 if(n&lt;=0)
 return 0;

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

 int vector1 = 0;
 int vector2 = 0;

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

 vector1 = vector2/10;

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

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

 return 0;
}

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

A number is called digit-increasing if it is equal n + nn + nnn + ... for some digit n between 1 and 9. For example 24 is digit-increasing because it equals 2 + 22 (here n = 2).

Actually, a friend of mine asked me this question and i am stuck thinking about it but couldn't find the exact solution so far. Can anyone help ? I needed the function that returns true if it is digit-increasing else false.

Digit-increasing number test

如果一个数等于n+ nn + nnn + ...对于1到9之间的某个数字n。例如，24是数字递增的，因为它等于2+ 22 (这里n= 2)。实际上，我的一个朋友问了我这个问题，我一直在思考这个问题，但到目前为止还找不到确切的解决方案。有人能帮上忙吗？我需要一个函数，如果它是数字递增的，则返回true，否则返回false...

问数字递增测试
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问数字递增测试EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问数字递增测试
EN