Generate the triangle number under (500^2)
 
loop until the triangle number's factors is more than 500
  generate next triangle number
 
return triangle number
 
to find how many factors a number has:
  divide number by prime number going from lowest to higher until it divides evenly
  if the result is prime, tally the prime number and the result
  if the result is not prime, tally the prime number and the result becomes the number and loop back to the "divide number by pr..." stage
  add 1 and multiply everything in the tally that is not zero
  the product is the number of factors
 
to generate prime numbers:
  start with 2 and 3
  int n = 1, prime = 0
  while prime is not prime
    increase n if called on an odd time
    loop back with prime = 6n-1 on every odd time and
    loop back with prime = 6n+1 on every even time
  return prime
 
and finally to check if a number is prime:
  if number is under 2, its not prime
  //this is a prime sieve
  if number is 2, its prime
  if number is divisible by 2, its not prime
  if number is 3, its prime
  if number is divisible by 3, its not prime
  ...
  int count = what ever last sieve was
  while count < sqrt number
    if number mod count = 0
      return 0 (not prime)
  return 1 (is prime)
 

int count = 1;
int triangle = 1;
while(1) {
  printf("%d\n", triangle);
  count++;
  triangle += count;
}

void fillprime( int maxPrime ) {
/* This function fills the second dimention of an array with primes. It uses the
modified version of problem 2 attemp 2's 'nextprime' and 'isprime' used in
   problem 7. Why do all these's questions rely on prime numbers? */
 
   static int c = 0, n = 0;
 
   do {
      primes[primeCount] = nextprime(&n, &c);
   }while(primes[primeCount++] <= maxPrime);
 
}

void findprimefactor(int number, int *output) {
/* This function will find all of the prime factors. It works by dividing number
by primes until it evenly divides. That prime is a prime factor, and if the
result is also prime, its is a prime factor. If the result is not a prime
   factor, it becomes the new 'number'. */
 
   int n    = 0;
   int p    = 0;
   int n1   = 0;
 
   while(n<primeCount)
   {
      p = primes[n];
      if(number == p) {             /* if result is 1 */ 
         output[n]++;               /* Add that 'number' to its place on first dim */
         return;
      }
 
      if( (number % p) ==0) {       /* number evenly divides into p  */
         output[n]++;               /* Add that 'p' to its place on first dim */
         number /= p;
         n1 = findPrime(number);
 
         if(n1 != -1) {             /* if result is prime */
            output[n1]++;           /* Add result to its place on first dim */
            return;
         } 
         /* if result is not prime */
         /* The result is the new number */
         n = 0;
      }
      else
         n++;
   }
 
   // should not get here except on 1
   if(number>0)
   {
      printf("\nRemainder - %d",number);
   }
   return;
}

int countdiv( int number) {
/* This function returns the number of divisors. It finds the prime divisors,
adds 1 to each, and finds the product of all of them. It returns the product.
*/
 
   int count = 0;
   int product = 1;
   int maxPrime;
 
 
   if(isprime(number) )
   {
      return 2;
   }
 
   maxPrime= (int) sqrt(number)+1;
 
   fillprime(maxPrime);                     /* generate next x primes */
 
   init(primeCount, primefactor);          /* clear count array array with 0's */
   findprimefactor(number, primefactor);   /* count each prime factor */
 
 
   while(primes[count] <= maxPrime) {
      if(primefactor[count] != 0)           /* If there is a number of that prime */
         product *= (primefactor[count]+1);  /* add 1 and multiply */
      count++;
   }
 
   return product;
}