Factor is a scary word, but not really a mathematical monstrosity. If you have an integer value, its factors are the other integers that can divide evenly into the original value. The computer can deftly discover these values, providing you give it the proper C code to munch upon.

When I boned-up on this topic, I thought of money. Yes, I think of money often, but in this case I thought of making change.

For example, currency denominations are all factors of higher values: A $20 bill can be broken into 20 $1s or 4 $5s or two $10s. The values 1, 2, 4, 5, and 10 are all factors of 20. The value 20 is also a factor of 20. Incidentally, all numbers have their own value and 1 as factors. A prime number has only its own value and 1 as factors.

Yes, all this mathematical stuff can get nauseating quite quickly. For coding, however, calculating the factors of an integer presents an interesting puzzle.

One solution I saw had about 150 lines of code and three functions to do the job. Oh, and it used pointers. “Rubbish!” I thought, as I set upon to code my own factoring program.

To handle the math, I employed the modulus operator, %. It returns zero when two integers divide evenly into each other. That’s pretty much the golden ticket I need to determine whether variable x is a factor of integer f:

#include <stdio.h>

int main()
{
    int x;
    unsigned f;

    printf("Enter a positive integer: ");
    scanf("%u",&f);

    printf("Factors of %d:\n",f);
    for(x=1;x<=f;x++)
        if( f % x == 0)
            printf("%d\n",x);

    return(0);
}

The program prompts the user to enter a positive (unsigned) integer value in Lines 8 and 9. A for loop at Line 12 plows through the values 1 through variable f. If the result of f % x is equal to zero, the value is output.

Here’s a sample run for the value 56:

Enter a positive integer: 56
Factors of 56:
1
2
4
7
8
14
28
56

Each of the values output divides evenly into 56.

Here’s output for a prime number:

Enter a positive integer: 101
Factors of 101:
1
101

I tried the code on some humongous values and it ran just fine, though as the values increase, the code runs more slowly. That’s to be expected. Still, I don’t understand why the other example I saw used so many lines of code and different functions to do the same thing?