GET Functions and Explaination

Because of le copyright joke, this document is licensed under a Creative Commons Attribution 4.0 International License.
The C implementation, however, is WTF PL (wtfpl.org).

The first function, the one that determines the number of repeating digits in a post number, is by far the simpler one. When most programmers are confronted with this problem, they solve it by converting the post number to an array/string, and compare the digits in reverse order. By trying to not use any string conversions I have found a much more efficient and simple technique. The last digit of any integer can be obtained with modulo by 10. Thus, if the integer is repeatedly divided by 10, modulo by 10 will reveal all of the digits in reverse order for comparison. Here is the C implementation:

/* repdigits: return the number of repeating digits
 * in num, from the right.
 * divide by 10 version */
int repdigits(int num)
{
	int repdig	= 0;
	int pdigit	= -1;	//previous digit
	int cdigit	= 0;	//current digit

	 do {
		cdigit = num % 10;
		if (cdigit != pdigit && pdigit != -1)
			return repdig; //non-repeating digit located
		repdig++;
		pdigit = cdigit;
	} while (num /= 10);
	return repdig;
}

The second function, the one that determines the next GET based on the current post number, is more complicated, as anybody who has tried to implement it knows. The function can be divided into four tasks. The first is to separate the digits that are to be unchanged, the second is to generate an array of digits to be changed, the third is to determine the repeating digit of the next GET and assemble it into a repeating integer of the GET length, and the fourth is to return the sum of the unchanged digits and the repeating digits.
The first task is simple enough: integer divide by 10^n, then multiply by 10^n to clear the n low order digits. I don't know how modern CPU compute powers and multiplication, so I decided to use this method instead of repeatedly dividing and multiplying by 10 in the hope that hardware acceleration will make it more efficient. Note that you may need to link the math library on your system to compile the C implementation.
The second task is also simple. It uses the repeated modulo paired with division from the first function to generate the array. This task arguably goes against my ideal of not using a string conversion, but after spending a long time considering how the third task would need to access the digits, I decided to use this method. Also, this method only generates as many digits as necessary.
The third task is what makes this function difficult to implement. It is also the part that is most likely to be inefficient or needlessly complicated, and is hard to explain. I suggest if want to really understand how the first part of this task works, you should try flow charting it from the C implementation and drawing out how it modifies and compares the variables. The second part is simple; after the repeating digits is determined, it is multiplied by 10 n times and the repeating digit is add each time.
Finally, the fourth task, simply adds the unchanged digits and the repeating digits and returns the result.

code:
int nextget(int num, int n)
{
	int unchanged, repdigit, repdigits, i, tpow, digits[n];
	unchanged = num;

	/* separate unchanged digits */
	tpow = (int)pow(10,n);
	unchanged /= tpow;
	unchanged *= tpow;	//Erase n low-order digits. Possibly could be more efficient?

	/* generate array of digits to be changed */
	for (i=n-1; i >= 0 && num; i--) {
		digits[i] = num % 10;
		num /= 10;
	}

	/* run comparisons to determine the repeating digit of the next get */
	repdigit = digits[0];	//repdigit must be stored elsewhere so that
							//it can be mutated without changing the digits
	for (i=0; i < n; i++)
		if (digits[0] < digits[i]) {
			repdigit++;
			if (repdigit > 9)
				repdigit = 0;
			break;
		} else if (digits[0] > digits[i])
			break;
	if (i==n && digits[0]==digits[i-1]) {
		repdigit++;
		if (repdigit > 9)
			repdigit = 0;
	}
	/* assemble the repeating digit into a repeating integer of n columns */
	repdigits = repdigit;
	for (; n > 1; n--)
		repdigits = repdigits * 10 + repdigit;

	/* return the sum of the unchanged digits and the repeating digits */
	return unchanged + repdigits;
}