Project Euler

Euler 34

答案：40730

 我用程序算了无数次都是145，蛋疼，最后拿别人的程序仔细对比……
 原来 ！=……
 真蛋疼，我竟然连基础数学都忘了

Euler-44

根据公式容易得出：Pmin + Pj = Pk; Pj + Pk = Pmax。

遍历 Pmin 和 Pj，如果 Pmin + Pj 结果是 Pentagonal，那么 Pk = Pmin + Pj；继续算 Pk + Pj 的结果是否等于 Pentagonal 即可。

刚开始以 Pmin 为基准往后求解，算了十多分钟也没算出个结果，吃个饭静了下思路改成从 Pmax 为基准往前求解，秒出结果。

 #include <stdio.h>
 #include <math.h>

 #define MAX_LEN 10000

 int isPentagonal(int num)
 {
     int n = sqrt(num * 2.0 /  + 1.0/);
     if (*n*n - n == num * )
         return n;
     n++;
     if (*n*n - n == num * )
         return n;
     return ;
 }

 int main()
 {
     __int64 n, i, j, k;
     __int64 Pentagonal[MAX_LEN];

     for (i = ; i < MAX_LEN; i++)
     {
         Pentagonal[i] = (*i*i-i)/;
         for (j = i-; j > ; j--)
         {
             n = isPentagonal(Pentagonal[i] - Pentagonal[j]);
             if (n)
             {
                 n = isPentagonal(Pentagonal[j] - Pentagonal[n]);
                 if (n)
                 {
                     printf("result=%d\n", Pentagonal[n]);
                     break;
                 }
             }
         }
         if (j) break;
     }
     return ;
 }

Euler-44

Euler-45

刚开始，直接算，算了一分钟还没出结果。。。

优化了下，秒出结果

 int main()
 {
    DWORD next_tri = ;
    DWORD ind_tri = ;
    DWORD next_pen = ;
    DWORD ind_pen = ;
    DWORD next_hex = ;
    DWORD ind_hex = ;
    while()
      {
           next_tri += ++ind_tri;
           if (next_tri > next_pen) next_pen += (ind_pen++*)+;
           if (next_tri > next_hex) next_hex += (ind_hex++ *)+;

           if(next_tri == next_pen && next_tri == next_hex)
           {
               cout<<"solution: "<<next_tri<<endl;
               return ;
           }
     }

Euler-45

 

Euler-46

odd composite 其实是奇数&合数的意思

 #include <stdio.h>
 #include <math.h>

 #define MAX_LEN 10000

 int prime[MAX_LEN]; //0-素数， 1-非素数
 int goldbach[MAX_LEN];

 int main()
 {
     int i, j, num;
     for (i = ; i < MAX_LEN; i++)
     {
         if (prime[i] == )
         {
             for (j = i + i; j< MAX_LEN; j+= i)
             {
                 prime[j] = ;
             }
         }
     }
     goldbach[] = ;
     for (i = ; i < MAX_LEN; i+= )
     {
         if (goldbach[i] ==  && prime[i] == ) //不满足i + j*j*2，且为合数
         {
             printf("result=%d\n", i);
         }
         if (prime[i] == )
         {
             for (j = ; j < sqrt(MAX_LEN); j ++)
             {
                 num = i + j*j*;
                 if (num < MAX_LEN)
                 {
                     goldbach[num] = ;
                 }
             }
         }
     }
     return ;
 }

 Euler-47

其实就是求每个数有多少个素数公约数

 #include <stdio.h>
 #include <math.h>

 #define MAX_LEN 1000000
 #define DISTINCT_COUNT 4

 int isPrime[MAX_LEN]; //0-素数， 1-非素数
 int num[MAX_LEN];

 int main()
 {
     int i, j, k, count;
     for (i = ; i < MAX_LEN; i++)
     {
         if (isPrime[i] == )
         {
             for (j = i + i; j < MAX_LEN; j+= i)
             {
                 isPrime[j] = ;
             }
             for (k = i; k < MAX_LEN; k+= i)
             {
                 num[k] ++;
             }
         }
     }

     count = ;
     for (i = ; i < MAX_LEN; i ++)
     {
         if (num[i] == DISTINCT_COUNT)
         {
             count ++;
             if (count == DISTINCT_COUNT)
             {
                 printf("result=%d", i - DISTINCT_COUNT + );
                 break;
             }
         }
         else
         {
             count = ;
         }
     }

     return ;
 }

Euler-50

 什么好说的，就是考阅读理解了。
 求素数之和，要求连续的素数个数要是最多的，而且连续素数之和也是素数。

Euler-51

暴力解法，400秒，囧。

其实求出两个素数的相同处以后，把不同的位置上分别用0~9去算一遍应该更快，刚想到就出结果了，那也懒的再改了哈哈。

 #include <stdio.h>
 #include <math.h>

 #define MAX_LEN 1000000
 #define REPLACEMENTS_LEN 8

 int isPrime[MAX_LEN]; //0-素数， 1-非素数

 /**获取相同部分，相同部分用数字字符表示，不同部分用'.'表示， 注意结果是倒的*/
 char *getdiff(int i, int j)
 {
     static char diff[] = "";
     int count = ;
     char diffchar = '\0';
     char diffchar2 = '\0';
     memset(diff, , sizeof(diff));
     while (i > )
     {
         if (i% == j%)
         {
             diff[count] = i% + '';
         }
         else
         {
             if (diffchar == '\0')
             {
                 diffchar = i %  + '';
             }
             if (diffchar < REPLACEMENTS_LEN-+'' || diffchar != i %  + '')
             {
                 return "";
             }
             if (diffchar2 == '\0')
             {
                 diffchar2 = j %  + '';
             }
             if (diffchar2 < REPLACEMENTS_LEN-+'' || diffchar2 != j %  + '')
             {
                 return "";
             }
             diff[count] = '.';
         }
         i /= ;
         j /= ;
         count ++;
     }
     return diff;
 }

 int check(int num, char *diff, int nth)
 {
     int idifflen = strlen(diff);
     int count = ;
     char diffchar = '.';
     while (num > )
     {
         if (diff[count] == '\0')
         {
             return ;
         }
         if (diff[count] != '.' && diff[count] != num %  + '')
         {
             return ;
         }
         if (diff[count] == '.')
         {
             if (diffchar == '.')
                 diffchar = num %  + '';
             if (diffchar != num %  + '' || diffchar < REPLACEMENTS_LEN-nth+'')
                 return ;
         }
         count ++;
         num /= ;
     }
     if (diff[count] == '\0')
     {
         return ;
     }
     return ;
 }

 int main()
 {
     int i, j, k, count, len, maxlen = ;
     char diff[];
     for (i = ; i < MAX_LEN; i++)
     {
         if (isPrime[i] == )
         {
             for (j = i + i; j < MAX_LEN; j+= i)
             {
                 isPrime[j] = ;
             }
         }
     }

 /**
  *1.找两个素数之间相同的部分
  *2.往前找所有素数，如果有相同的部分，记录count
  *  注意，如果是两位相同，这两位的数字必然是相同的数字
  */
     for (i = ; i < MAX_LEN; i++)
     {
         if (isPrime[i] == )
         {
             for (j = i - ; j > ; j -- )
             {
                 count = ;
                 if (isPrime[j] == )
                 {
                     strcpy(diff, getdiff(i, j));
                     if (diff[] != '\0')
                     {
                         count = ;
                         for (k = j-; k > ; k --)
                         {
                             if (isPrime[k] == )
                             {
                                 count += check(k, diff, count+);
                                 if (count == REPLACEMENTS_LEN) //先用3试试水
                                 {
                                     printf("%d,", k);
                                     break;
                                 }
                             }
                         }
                     }
                     if (count == REPLACEMENTS_LEN)
                     {
                         printf("%d,", j);
                         break;
                     }
                 }
             }
         }
         if (count == REPLACEMENTS_LEN)
         {
             printf("%d\n", i);
             break;
         }
     }

     //printf("%d", check(56663, "3..65"));

     return ;
 }