在数组中查找重复图案

Question

In an array that starts with 1,9,9,0,9,7,5,1 each number after the 4th one is the last digit of the sum of the previous 4 numbers ( 1 + 9 + 9 + 0 = 19, 9 is the next digit), calculate when will the pattern 1,9,9,0 happen again in the array. I'm having problems finding the pattern, here is my current code.

#include <iostream>
using namespace std;

int main()
{
    int n[500];
    n[0]=1,n[1]=9,n[2]=9,n[3]=0,n[4]=9;
    int suma,i=5,b=0,c=0;
do
    {
        b=i;
        suma=0;
        suma=suma+(n[i-1]+n[i-2]+n[i-3]+n[i-4]); 
        n[i]=suma%10;
        cout << n[i] << "::" << endl;
        if(n[i-1]==0 && n[i-2]==9 && n[i-3]==9 && n[i-4]==1)
        {
            cout << "break"; break;
        }
        i++;
    }while(i!=1000);
    return 0;
}

Answer 1

One problem I see here is.

You are not looping enough to get the sequence. For that you need larger array.

When you declare smaller array and loop more than that you invoke undefined behavior because of array out of bound access.

Solution:

Either you declare larger array and loop enough

Or

As told in the comment section repetition can occur any time hence you cannot have array with predefined length as you don't know how many repetition will occur.

Hence you only need array of length 5 and use % operator with while(1) loop to solve the problem .

The clue is you need to store the sum after the 4th element hence (i+4)%5 will get you the place where sum need to be stored and you access the 1st,2nd,3rd and 4th element same way

(i+0)%5 --> will get you the first element
(i+1)%5 --> will get you the second element
(i+2)%5 --> will get you the third element
(i+3)%5 --> will get you the fourth element

Complete code might look like below.

#include <iostream>
using namespace std;

int main()
{
    int n[5];
    n[0]=1,n[1]=9,n[2]=9,n[3]=0;
    int suma,i=0;
    do
    {
        suma=0;
        suma=suma+(n[(i+0)%5]+n[(i+1)%5]+n[(i+2)%5]+n[(i+3)%5]); 
        n[(i+4)%5]=suma%10;
        cout << n[(i+0)%5] <<n[(i+1)%5]<<n[(i+2)%5]<<n[(i+3)%5]<<n[(i+4)%5]<< "::" << endl;
        if(n[(i+0)%5]==1 && n[(i+1)%5]==9 && n[(i+2)%5]==9 && n[(i+3)%5]==0 && i > 0)
        {
            cout << "break"; break;
        }
        i++;
    }while(1);
    return 0;
}

or As you see the above code is less readable.

You can make it readable by using a lambda as below.

#include <iostream>
using namespace std;

int main()
{
    int n[5];
    n[0]=1,n[1]=9,n[2]=9,n[3]=0;
    int suma,i=0;
    do
    {
        auto p = [&](int offset) -> int& { return n[(i+offset)%5]; };
        suma=p(0)+p(1)+p(2)+p(3); 
        p(4)=suma%10;        
        if(p(0)==1 && p(1)==9 && p(2)==9 && p(3)==0 && i >0)
        {
            cout << "break \n"; break;
        }
        i++;
    }while(1);
    std::cout << i;
    return 0;
}

and compile using -std=gnu++1y flag.

For your information repetition is occurring at 1560th iteration

Answer 2

The only problem with your code is that you access the array out of bounds. Your array is

int n[500];

and then the loop goes till

}while(i!=1000);

If you fix that it does find a solution!

Anyhow, I thought it is an interesting problem and actually wrote this before realizing that your code is already correct (apart from the out-of-bounds):

#include <iostream>
#include <array>

using quad = std::array<int,4>;

int get_next_number(const quad& q) { return (q[0]+q[1]+q[2]+q[3])%10; }
quad get_next(const quad& q) { return { q[1],q[2],q[3],get_next_number(q) }; }

int main() {
    quad init{1,9,9,0};
    int counter = 0;
    quad current = get_next(init);
    while (init != current) { 
        ++counter;
        current = get_next(current);
    }   
    std::cout << counter;
}

You dont need to store all numbers when all you need at any time are the last four entries. By using an std::array that holds only the last 4 numbers also the comparison is more readable.

Note that @kiran Biradar s solution is more efficient, because above I unecessarily do shift all the numbers in each step while his code just assigns one element in each step.