For this to work, you have to be counting your digits from the right hand end of the number.

If his number is 48367 and he wants the second digit ( counted from the left, the 8 ), then to implement this scheme, you would need to figure out that there are 5 digits and the 2nd one from the left is the 4th digit from the right, and then divide by ten to the power of 4-1

This is simple if you are looking at it personally and the number is written down. It's not so straightforward if it is an actual binary number.

I didn't read the question correctly. It seemed to ask that you wanted the digit at a specific position in the number. It didn't say the power associated with it. So, which is it: 1) the digit character at that position in the number, or 2) the power associated with the digit position?

The easiest way would be to convert the number to an ascii string then return the index that you want.
Granted now instead of looking at each number at "x" place, now you need to look at it as an array.

My first solution in the link I gave, works but it uses pow which is very slow, but again it works and it reads in the "x" place.

But now an array substituting for pow assumes the value will not exceed 5 digits. Once you get to the 6 digits, now you have an array of long variables which uses up more memory.

int ExtractDigit(int V, int P)
{
unsigned long Pow = 1;
for(byte D= 0; D < (P-1); D++)
Pow *= 10;
return (V / Pow) % 10;
//return (V/(Pow)) - (V/(Pow*10))*10; //Fixed and works
}

HazardsMind:
But now an array substituting for pow assumes the value will not exceed 5 digits. Once you get to the 6 digits, now you have an array of long variables which uses up more memory.

int ExtractDigit(int V, int P)

{
unsigned long Pow = 1;
for(byte D= 0; D < (P-1); D++)
Pow *= 10;

return (V / Pow) % 10;
//return (V/(Pow)) - (V/(Pow*10))*10; //Fixed and works
}

http://cpp.sh/7tv5

There's a tradeoff of time vs space. The array method is faster in most cases, and there's some break-even point in the number of digits you want to support where the array is larger than an iterative multiplication (that point might actually be larger than 6, depending on the size of the code that performs the iterative multiplication).

Sidenote: your functions take slightly different parameters. MarkT's takes P=0 for the unit digit while HazardsMind's takes P=1 for the unit digit. I prefer P=0 for the unit digit because 10^{0} = 1.

int ExtractDigit(int V, int P)
{
return V / pow[P] % 10 ;
}

Here's a power function that doesn't need any pre-stored variables and works up to a 64 bit number:

// performs base to the exp power
uint64_t intPower (uint8_t base, uint8_t exp)
{
uint64_t result = 1;
while (exp--) {
result *= base;
}
return result;
}