#include
#include

int main(int args, char* argv[])
{
        long result=1,trinum=0,curnum=1;
        int n=0,i=0,big=0;
        int stop = 500;                //停止要求的除数个数,改成5可以测试28
        while(n         {
                n = 0;
                trinum = 0;
                // 计算当前三角数
                for(i=1;i<=curnum;i++)
                        trinum += i;

                // 从1开始除,计算除数个数
                for(i=1;i<=trinum;i++)
                {
                        if(trinum%i==0) // 如果整除,n+1
                                n += 1;
                }
               
                if(n>=stop) //如果超过stop个,保存结果跳出循环,这里是500个
                {
                        result = trinum;
                        break;
                }

                //如果没超过stop个,记录当前最大的个数并输出
                //这个if可以不要,因为我运行以为电脑死机了
                //所以加了这个判断,找到更接近stop的除数个数时输出,让我有点盼头
                if(n>big)  
                {
                        big = n;
                        printf("Current number: %i [%d]\n",trinum,big);
                }

                //自加自然数增加1,trinum = sum(1:curnum)
                curnum++;
        }
       
        // 打印结果
        printf("%i\n",result);
       
        system("PAUSE");
        return 0;
        }

% ans =
%       76576500

1. 建立素数表prime[N]，N取一个比较大的值
2. 对x=(1+i)*i/2进行质因数分解：
    x=k_1^m_1 * k_2^m_2 ... * k_n^m_n
    其中^表示指数，k_1 ... k_n表示素数
3. 计算x因子总数：
    divisors = (m_1 + 1) * (m_2 + 1) * ... * (m_n + 1)
4. 判断divisors是否超过500，如果没有，跳到第2步，尝试下一个x；如果已经超过500，则输出x

x/=prime[i]

triangle_num=76576500
slow version, elapsed time=2.060000 seconds.
triangle_num=76576500
normal version, elapsed time=0.090000 seconds.

#include
#include
#include

#define TIMERSTART clock_t start_time,stop_time;double elapsed_time;start_time = clock();
#define TIMERSTOP stop_time = clock();elapsed_time=(double)(stop_time-start_time)/CLOCKS_PER_SEC;printf("elapsed time=%f seconds.\n",elapsed_time);

int euler12(int a, long n){
  static int last_a=0;
  static int count=1;
  int tmp_count=0;
  int i=0;
  
  for(i=a;i     if(n%i==0){
      if(i>last_a){
         last_a=i;
         tmp_count=count;
         count=2;
         return tmp_count*euler12(i,n/i);
       }
      
       count++;      
       return euler12(i,n/i);
    }
  }


  tmp_count=count;
  count=1;
  last_a=0;

  if (i*i-n==0){
    return 3*tmp_count;
  } else {
    return 2*tmp_count;
  }
}



int slow(int n){
  int i=0;
  int count=0;
  for(i=2;i<=sqrt(n);i++){
    if(n%i==0){
      count++;
     }
  }

  if (i*i-n==0) {
    return 2*count+1;
  }

  return 2*(count+1);
}


int main(void){
  long triangle_num=1;
  int i=2;
  int divisor_num=500;
  

  TIMERSTART;

  do {
    triangle_num+=i;
    i+=1;
  }while(slow(triangle_num)
  printf("triangle_num=%ld\n slow version, ",triangle_num);
  TIMERSTOP;



  start_time = clock();  
  triangle_num=1;
  i=2;

  do {
    triangle_num+=i;
    i+=1;
  }while(euler12(2,triangle_num)
  printf("triangle_num=%ld\n normal version, ",triangle_num);
  TIMERSTOP;

  return 0;
}

# -*- coding: utf-8 -*-

# 初始化一个质数表
i = 0
primes = range(2, 100)
while i < len(primes):
    primes = [x for x in primes if x == primes[i] or x % primes[i] != 0]
    i = i + 1

def numbersOfFactors(n):
    """计算n的因子数
    使用了sudo说的计算方法
    加上一个质数分解
    """
    factorNumbers = 1
    factorTimes = 0
    i = 0
    while i < len(primes):
        if n % primes[i] == 0:
            factorTimes += 1
            n /= primes[i]
            continue
        else:
            if factorTimes != 0:
                factorNumbers *= factorTimes + 1
                factorTimes = 0
            i = i + 1
            if n == 1:
                break
    return factorNumbers

# 从第三个三角数开始算，只算第奇数个三角数
n = 3
while numbersOfFactors(n*(n+1)/2) < 500:
    n += 2

# 为防止对偶数个三角数的遗漏，有最后这个计算
if numbersOfFactors(n*(n-1)/2) > 500:
    print n*(n-1)/2
else:
    print n*(n+1)/2

def facp(n) :
  for i in xrange(2,n) :
    while n%i == 0 :
      n /= i
      yield i
    if i**2 > n : break
  if n!=1 : yield n

for n in xrange(3,99999) :
  p = list(facp(n/2))+list(facp(n+1)) if n%2==0 else list(facp(n))+list(facp((n+1)/2))
  c = reduce( lambda x,y: x*y, [p.count(i)+1 for i in set(p)] )
  if c > 500 : break
print n*(n+1)/2