Most occuring digit in an array of numbers
Outer loop unnecessary
If there are N numbers, each with M digits, your solution is using 10 * N * M operations to compute the solution.  This is because for each digit (e.g. 0, 1, 2), you look at every digit in every number.  But you could make your solution 10 times faster by only looking at each digit once.  All you need to do is to track duplicate digits for each new number.
Here is how that would work:
for (i = 0; i &lt;= 9; i++)
{
    Y[i].number = i;
    Y[i].howmany = 0;
}

for (i = 0; i &lt; sizex; i++)
{
    int foundDigits = 0;

    for (int curNumber = X[i]; curNumber &gt; 0; curNumber /= 10) {
        int digit = curNumber % 10;
        int bit   = 1 &lt;&lt; digit;

        if ((foundDigits &amp; bit) == 0) {
            foundDigits |= bit;
            Y[digit].howmany++;
        }
    }
}

Here, foundDigits is a bitmask which contains a 1 bit for each digit already seen in the current number.  This is what is used to track duplicate digits.  When a non-duplicate digit is seen, we can just increment the Y[digit].howmany array directly.
struct numbers unnecessary
Actually, the numbers structure is unnecessary because Y[i].number is always equal to i.  So you can just have Y be an array of integers holding the count of each digit.  Wherever you currently use Y[i].number, just replace that with i instead.