-2
$\begingroup$

I want to count from 0 to n. And when I have reached n, adding 1 to n would give me 0 again.

For example:

0, 1, 2, 3, 4, 0, 1, 2, ...

Is there such an algorithm to do this?

Edit:

I need an equation to simple get the number after the given number. In the example above if I put 1 in the equation I would get 2, if I put 4, I would get 0. Maybe algorithm isn't the best word for this problem.

$\endgroup$
4
  • 1
    $\begingroup$ Your question seems a little unclear. Obviously you're having no trouble counting up to $n$ and then starting from $0$ again, so what exactly do you need the algorithm for? $\endgroup$
    – Ilmari Karonen
    Feb 11, 2012 at 9:03
  • $\begingroup$ In this case, I would say that "algorithm" is another word for "piece of code". $\endgroup$
    – utdiscant
    Feb 11, 2012 at 9:06
  • 1
    $\begingroup$ @utdiscant: I think you're right, and that this question is simply on the wrong site; it belongs on SO, not here. $\endgroup$
    – Ilmari Karonen
    Feb 11, 2012 at 9:20
  • 2
    $\begingroup$ If you're looking for a function, you want $f(m):= $ the unique non-negative integer less than $n+1$ such that $m+1$ is congruent to $f(m) \operatorname{mod} n+1$. $\endgroup$
    – Paul Slevin
    Feb 11, 2012 at 10:06

3 Answers 3

Reset to default
1
$\begingroup$

This will be the remainder when the consecutive whole numbers are divided by $n+1$.

A C++ code, if that please you:

for(i=0;%@%@;i++)

{

k=i%(n+1);

cout<< k;

}

In the above code, Substitute your value of $n$. And, in between the place where there is a wild card entry, you could put in the maximum number upto which you'd like to count.

$\endgroup$
2
  • $\begingroup$ A loop wouldn't be the best solution, because when I get the next number, I need to do other things with that number and the loop would eat my ram and cpu. An equation would be the best, but if it's not possible then I have recode all my application. $\endgroup$
    – Cobold
    Feb 11, 2012 at 9:03
  • $\begingroup$ What kind of formula do you need: I told you they are the remainder when the consecutive whole numbers are divided by $n+1$. So, the modulo % should do. If you tell me what exactly you need to do, "may be" I can be of some help. $\endgroup$
    – user21436
    Feb 11, 2012 at 9:08
0
$\begingroup$

Here are a few ways to implement a function that adds one to $i$ and jumps back to $0$ after reaching $n$. I've chosen to write these in the C programming language, but they should be easy to port to other imperative languages.

This is probably the most straightforward way to accomplish the task:

int add_one_upto_n (int i, int n) {
    if (i >= n)
        return 0;
    else
        return i + 1;
}

Alternatively, we can use the C divide-and-take-remainder operator %. This will work nicely on modern desktop CPUs, but may be inefficient on simple embedded systems where division is slow:

int add_one_upto_n (int i, int n) {
    return (i + 1) % (n + 1);
}

Also, if $n$ happens to equal $2^k-1$ for some $k$, the % operator may be replaced with a simple bitwise and operation:

int add_one_upto_n (int i, int n) {
    return (i + 1) & n;  /* only works if n + 1 is a power of 2 */
}

I think that about exhausts all the reasonable ways to do it I could think of. Of course, if we get into the realm of deliberately obfuscated code, I'm sure there are many more creative ways to accomplish this task...

$\endgroup$
0
$\begingroup$

Maple counting code :

n:=4:

for a from 0  do
s:=0:

for k from 1 to n do
s:=s+1:
print(s);
end do;

end do;

Output is sequence : $0,1,2,3,4,0,1,2,3,4,0,1....$

$\endgroup$

Not the answer you're looking for? Browse other questions tagged .