How to find it out from 1 million numbers?

You will not learn if we do your homework for you!

However, OriginalGriff's answer is the easiest solution, a plodding, donkey-work way of doing it, but probably the simplest one in order for you to get a pass on the work from your tutor.

Best of luck.

This is trivial: keep a trace of the previous digit processed and compare to the current one. Stop at equal.

int Was= Digit[0];
for (i= 1; i < 1000000 && Was != Digit[i]; i++)
    Was= Digit[i];

if (i < 1000000) printf("Digit %d at positions %d and %d\n", Was, i - 1, i);

Well, simple way is to keep the last number kipping in mind and compare with the next number, if succeed stop if fail keep the next number in mind and look for the next number.

grow up

This is very simple if repeated numbers are on neighboring positions (by the way, sorting will not help):

int list[] = {1,3,2,3,8,5,7,7,9};

bool main()
{

     for(int i=0;i<9;i++)
        {
         if (list[i]==list[i+1])
            {
            printf("position: %x, number: %x\n",i,list[i]);
            return true;
            }
        }

    printf("No repeated numbers found!\n");
    return false;
}

This is, actually, the obvious solution described by OriginalGriff.

Update (corrected after comments from YvesDaoust, see below):

1. Miscalculated the size of array.
2. To handle more than two repeated numbers in the row:

int list[] = {1,3,3,3,8,5,7,7,9,5};

bool main()
{

     for(int i=0;i<9;i++)
        {
         if (list[i]==list[i+1])
            {
            if ((list[i+1]!=list[i+2])&&(list[i]!=list[i-1]))
                {
                printf("position: %x, number: %x\n",i,list[i]);
                return true;
                }
            }
        }

    printf("No only twice repeated numbers found!\n");
    return false;
}

3. I always try to follow the requirements given. Here - to make the search as efficient as possible.

P.S. How nice it could be if someone would point on errors in code proposing the right solution!

string millionNumbers = "...";
int repeated = -1;
for (int i =0; i <= 9; i++)
{
    string search = string.Format("{0},{0}", i);
    if (millionNumbers.Contains(search))
    {
        repeated = i;
        break;
    }
}

As the expression "repeated twice" sound a bit pleonastic to me, I cannot help imagining different interpretations, hence different algorithms.

1. A digit that is "repeated" can be a digit that appears two times or more in the sequence, anywhere. 1, 2, 3, 4, 2, 5, 2 has 2 repeated.

1a. With the meaning of (1.), "repeated twice" would mean appearing exactly two times, anywhere. 1, 2, 3, 4, 2, 5, 6 has 2 repeated twice.

1b. But doesn't it make more sense to say that when a digit is repeated two times, that means two copies in addition to the original. Hence, three instances ! With this interpretation 1, 2, 2, 7, 2, 4, 5 has 2 repeated twice.

2. Or "repeated" can be a digit that appears two times or more in a row in the sequence. 1, 2, 2, 2, 2, 2, 4, 5 has 2 repeated.

2a. With the meaning of (2.), "repeated twice" can be appearing exactly two times in a row, not more. 1, 2, 2, 4, 5 has 2 repeated twice. 1, 2, 2, 2, 4, 5 does not have 2 repeated twice.

2b. As in (1a.), consider two extra copies. Here 1, 2, 2, 2, 4, 5 has 2 repeated twice.

2c. But don't let's forget another interpretation: some digit can be repeated, as in (1.), and this occurs twice. I.e. 1, 2, 2, 2, 4, 3, 6, 2, 2, 9 has 2 repeated twice.

The algorithms:

1a. Compute the histogram of frequencies and find the bin where frequency = 2.

1b. Compute the histogram of frequencies and find the bin where frequency = 3.

2a. Keep a counter and keep the value of the previous digit. When you process a digit, if same as previous increment the counter; otherwise { if the counter is 2, stop } and reset the counter. In the end, check if the counter is 2.

2b. Keep a counter and keep the value of the previous digit. When you process a digit, if same as previous increment the counter; otherwise { if the counter is 3, stop } and reset the counter. In the end, check if the counter is 3.

2c. The hardest: compute an histogram of digit replications while keeping a counter and the value of the previous digit. When you process a digit, if same as previous increment the counter; otherwise, { if the counter is greater than 1, increment the corresponding bin } and reset the counter. In the end, if the counter is greater than 1, increment the corresponding bin. Find the bin where frequency = 2.

Important: following this analysis, none of the solutions proposed before are correct because they accept sequences longer than twice the same character.