博主从2020.5.9下定决心，每天两道算法题，写博客是为了有动力坚持下去，望各位博友监督与鼓励 (ง •_•)ง
2020.5.17 学校开始上课了，博主忙于课设，从今天开始每天一道
算法题来自微信公众号：数据结构和算法
1、最大质因数
13195的所有质因数为5、7、13和29。600851最大的质因数是多少？
分析：通过不断的递归调用，判断number是否为质数。
public class Algorithe01 {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("600851的最大质因数："+primeFactor(600851));
}
public static long primeFactor(long num) {
if(num==1)
return 1;
for(int i=2;i<num;i++) {
if(num%i==0) {
return primeFactor(num/i);
}
}
return num;
}
}
2、最大回文乘积
回文数就是从前往后和从后往前读都一样的数。由两个2位数相乘得到的最大回文乘积是 9009 = 91 × 99。找出由两个3位数相乘得到的最大回文乘积。
分析：通过循环一个个判断。
public class Algorithe02 {
public static void main(String[] args) {
System.out.println("两个3位数相乘得到的最大回文乘积是"+palindrome());
}
public static long palindrome() {
long num=0;
for(int j=999;j>100;j--) {
for(int i=999;i>100;i--) {
long result=i*j;
if(result>num &&palindrome(result))
num=result;
}
}
return num;
}
private static boolean palindrome(long result) {
int count=0;
long[] a=new long[10];
while(result!=0) {
a[count]=result%10;
count++;
result=result/10;
}
for(int i=0;i<=count/2;i++) {
if(a[i]!=a[count-i-1])
return false;
}
return true;
}
}
3、最小倍数
2520是最小的能够被1到10整除的数。最小的能够被1到20整除的正数是多少
分析：其实就是求1到20的最小公倍数，讲道理直接写个for，计算1到n的乘积即可，这样未免太简单。这道算法题应该要展现整除的过程，令product=n*(n-1)可以减少循环次数
public class Algorithe03 {
public static void main(String[] args) {
System.out.println("求最小的能被1到n整除的数，请输入n：");
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int product=n*(n-1);
int num = 0;
for(int j=1;j<=Integer.MAX_VALUE;j++) {
num=product*j;
int count=0;
for(int i=1;i<=n;i++) {
if(num%i!=0) {
break;
}
count++;
}
if(count==n) {
break;
}
}
System.out.println(num);
}
}
4、第10001个素数
列出前6个素数，它们分别是2、3、5、7、11和13。我们可以看出，第6个素数是13。第10001个素数是多少？
分析：判断n是否为素数，根据定义直接判断从2到n-1是否存在约数即可
public class Algorithe04 {
public static void main(String[] args) {
System.out.println(prime(10001));
}
public static int prime(int num) {
int i=0;
for(int j=2;j<Integer.MAX_VALUE;j++) {
if(isPrime(j)) {
i++;
if(i==num)
return j;
}
}
return -1;
}
private static boolean isPrime(int j) {
if(j==2) {
return true;
}
for(int i= 2;i<=j-1;i++) {
if(j%i== 0)
return false;
}
return true;
}
}
5、连续数字最大乘积
在下面这个1000位正整数中，连续4个数字的最大乘积是
9 × 9 × 8 × 9 = 5832。
73167176531330624919225119674426574742355349194934
96983520312774506326239578318016984801869478851843
85861560789112949495459501737958331952853208805511
12540698747158523863050715693290963295227443043557
66896648950445244523161731856403098711121722383113
62229893423380308135336276614282806444486645238749
30358907296290491560440772390713810515859307960866
70172427121883998797908792274921901699720888093776
65727333001053367881220235421809751254540594752243
52584907711670556013604839586446706324415722155397
53697817977846174064955149290862569321978468622482
83972241375657056057490261407972968652414535100474
82166370484403199890008895243450658541227588666881
16427171479924442928230863465674813919123162824586
17866458359124566529476545682848912883142607690042
24219022671055626321111109370544217506941658960408
07198403850962455444362981230987879927244284909188
84580156166097919133875499200524063689912560717606
05886116467109405077541002256983155200055935729725
71636269561882670428252483600823257530420752963450
找出这个1000位正整数中乘积最大的连续13个数字。它们的乘积是多少？
分析：相邻的13个数相乘，直到循环完，然后返回最大的。注意的是如果乘积为0就跳出循环，charAt()取值，如0的ASCII码是48，减去48，就是对应的int值
public class Algorithe05 {
public static void main(String[] args) {
String num="73167176531330624919225119674426574742355349194934" +
"96983520312774506326239578318016984801869478851843" +
"85861560789112949495459501737958331952853208805511" +
"12540698747158523863050715693290963295227443043557" +
"66896648950445244523161731856403098711121722383113" +
"62229893423380308135336276614282806444486645238749" +
"30358907296290491560440772390713810515859307960866" +
"70172427121883998797908792274921901699720888093776" +
"65727333001053367881220235421809751254540594752243" +
"52584907711670556013604839586446706324415722155397" +
"53697817977846174064955149290862569321978468622482" +
"83972241375657056057490261407972968652414535100474" +
"82166370484403199890008895243450658541227588666881" +
"16427171479924442928230863465674813919123162824586" +
"17866458359124566529476545682848912883142607690042" +
"24219022671055626321111109370544217506941658960408" +
"07198403850962455444362981230987879927244284909188" +
"84580156166097919133875499200524063689912560717606" +
"05886116467109405077541002256983155200055935729725" +
"71636269561882670428252483600823257530420752963450";
int max=0;
for(int i=0;i<num.length()-13;i++) {
int result=1;
for(int j=i;j<i+13;j++) {
int digit=num.charAt(j)-48;
result*=digit;
if(result==0)
break;
}
if(result>max) {
max=result;
}
}
System.out.println("连续13个数字最大乘积是"+max);
}
}
6、特殊毕达哥拉斯三元组
毕达哥拉斯三元组是三个自然数a < b < c组成的集合，并满足a2 + b2 = c2。例如，32 + 42 = 9 + 16 = 25 = 52。有且只有一个毕达哥拉斯三元组满足 a + b + c = 1000。求这个三元组的乘积abc。
分析：满足毕达哥拉斯定理，可以把它想象成为一个直角三角形的三条边，a是小的直角边，b是大的直角边，c是斜边。b如果等于a，那么c就是无理数了，相加不可能等于1000，所以b不能等于a。下面的循环要满足直角三角形的几个条件，1：直角边要小于斜边，2：两边之和大于第三边，3：两边之差小于第三边。如果查找到就直接返回。
public class Algorithe06 {
public static void main(String[] args) {
System.out.println(pythagorean(1000));
}
public static int pythagorean(int sum) {
for(int a=1;a<sum/3;a++) {
for(int b=a+1;b<sum/2;b++) {
int c=sum-a-b;
if(b<c &&(a*a+b*b==c*c)) {
return a*b*c;
}
}
}
return -1;
}
}
7、素数的和
所有小于10的素数的和是2 + 3 + 5 + 7 = 17。求所有小于两百万的素数的和。
分析：通过循环遍历，能提高算法效率的点有，素数除了2以外都是奇数。判断是否为素数时，可以从2到i的平方根之间循环，至于为什么这样简化，可以拿计算器试一试就明白了，这样极大缩短了运行时间
public class Algorithe07 {
public static void main(String[] args) {
long sum=2;
for(int i=3;i<2000000;i+=2) {
if(isPrime(i)) {
sum+=i;
}
}
System.out.println(sum);
}
private static boolean isPrime(int i) {
for(int j=2;j<=Math.sqrt(i);j++) {
if(i%j==0)
return false;
}
return true;
}
}
8、高度可约的三角形数
三角形数数列是通过逐个加上自然数来生成的。例如，第7个三角形数是 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28。三角形数数列的前十项分别是：
1, 3, 6, 10, 15, 21, 28, 36, 45, 55, …
让我们列举出前七个三角形数的所有约数：
1: 1
3: 1,3
6: 1,2,3,6
10: 1,2,5,10
15: 1,3,5,15
21: 1,3,7,21
28: 1,2,4,7,14,28
我们可以看出，28是第一个拥有超过5个约数的三角形数。
第一个拥有超过500个约数的三角形数是多少？
分析：列举三角形数，判断他的约数是否大于500，如果大于直接返回。注意下面的判断是否是平方数，如果是要减1，比如9的约数是1,3,9不是1,3,3,9。
public class Algorithe08 {
public static void main(String[] args) {
System.out.println(triangleNumber(500));
}
public static int triangleNumber(int number) {
for(int i=1;i<Integer.MAX_VALUE;i++) {
int count=0;
int result=(1+i)*i/2;
int prime=(int) Math.sqrt(result);
for(int j=1;j<=prime;j++) {
if(result%j==0)
count++;
}
count= (prime*prime==result?2*count-1:2*count);
if(count>number)
return result;
}
return -1;
}
}
9、硬币求和
英国的货币单位包括英镑£和便士p，在流通中的硬币一共有八种：
1p, 2p, 5p, 10p, 20p, 50p, £1 (100p), £2 (200p)
以下是组成£2的其中一种可行方式：
1×£1 + 1×50p + 2×20p + 1×5p + 1×2p + 3×1p
不限定使用的硬币数目，组成£2有多少种不同的方式？
分析：通过递归计算，只有相减等于0的时候sum才会加1，否则通过循环递归计算sum的值。
public class Algorithe09 {
public static void main(String[] args) {
System.out.println(coinSum(200, 0));
}
public static int coinSum(int totalMoney,int index) {
int money[]= {
1,2,5,10,20,50,100,200};
int sum=0;
for(int i=index;i<money.length;i++) {
if(totalMoney-money[i]==0) {
sum++;
break;
}
if(totalMoney-money[i]>0)
sum+=coinSum(totalMoney-money[i],i);
}
return sum;
}
}
10、最长考拉兹序列
在正整数集上定义如下的迭代序列：
n → n/2 （若n为偶数）
n → 3n + 1 （若n为奇数）
从13开始应用上述规则，我们可以生成如下的序列：
13 → 40 → 20 → 10 → 5 → 16 → 8 → 4 → 2 → 1
可以看出这个序列（从13开始到1结束）共有10项。尽管还没有被证明，但我们普遍认为，从任何数开始最终都能迭代至1（“考拉兹猜想”）。
从小于一百万的哪个数开始，能够生成最长的序列呢？
注： 序列开始生成后允许其中的项超过一百万。
分析：返回最长的序列即可。
public class Algorithe10 {
public static void main(String[] args) {
System.out.println(longestCollatz(1000000));
}
public static int longestCollatz(int num) {
int max=0;
int j=0;
for(int i=2;i<num;i++) {
int length=collatzLength(i);
if(max<length) {
max=length;
j=i;
}
}
return j;
}
private static int collatzLength(int num) {
int i=1;
while(num!=1) {
if(num%2==0)
num=num>>>1;
else
num=num*3+1;
i++;
}
return i;
}
}
11、幂的数字和
215 = 32768，而32768的各位数字之和是 3 + 2 + 7 + 6 + 8 = 26。
21000的各位数字之和是多少（2的1000次方）？
分析：我们知道2的64次方就已经很大了，那么2的1000次方就更大了，常规的算法是不行的，换个思路。2的1000次方，相当于把1往左移动1000位，然后转化为BIgInteger在计算各位数字之和。digit就是表示每个位置上的数字的字符串，遍历相加即可。
public class Algorithe11 {
public static void main(String[] args) {
System.out.println(powerDigit(1000));
}
public static int powerDigit(int max) {
int sum=0;
StringBuilder sb=new StringBuilder(max+1);
sb.append(1);
for(int j=0;j<max;j++) {
sb.append(0);
}
BigInteger num=new BigInteger(sb.toString(),2);
String digit=num.toString(10);
for(int i=0;i<digit.length();i++) {
sum+=digit.charAt(i)-48;
}
return sum;
}
}
12、表达数字的英文字母计数
如果把1到5写成英文单词，分别是：one, two, three, four, five，这些单词一共用了3 + 3 + 5 + 4 + 4 = 19个字母。
如果把1到1000都写成英文单词，一共要用多少个字母？
注意： 不要算上空格和连字符。例如，342（three hundred and forty-two）包含23个字母，而115（one hundred and fifteen）包含20个字母。单词“and”的使用方式遵循英式英语的规则。
分析：主要就是找规律，然后总结，注意1000的时候不要忘了。
public class Algorithe12 {
public static void main(String[] args) {
System.out.println(NumberLetterCounts());
}
private static int NumberLetterCounts() {
int sum=0;
for(int i=1;i<21;i++) {
sum+=LetterCountsOne(i);
}
for(int i=21;i<100;i++) {
sum+=LetterCountsTwo(i/10)+LetterCountsTwo(i%10);
}
for(int i=100;i<1000;i++) {
if(i%100<=20)
sum+=LetterCountsOne(i/100) + (i%100==0?7:10)+LetterCountsOne(i%100);
else
sum+=LetterCountsOne(i/100) + (i%100==0?7:10)+LetterCountsTwo(i%100/10)+LetterCountsOne(i%10);
}
//one thousand
sum+=11;
return sum;
}
private static int LetterCountsTwo(int num) {
/**
* one two three four five six seven eight nine ten
* eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen twenty
* twenty-one twenty-two twenty-three twenty-four twenty-five twenty-six
* twenty-seven twenty-eight twenty-nine
* thirty forty fifty sixty seventy eighty ninety
* one hundred
*/
if(num==1)
return 3;
if(num==2)
return 3;
if(num==3)
return 5;
if(num==4)
return 4;
if(num==5)
return 4;
if(num==6)
return 3;
if(num==7)
return 5;
if(num==8)
return 5;
if(num==9)
return 4;
if(num==10)
return 3;
if(num==11)
return 6;
if(num==12)
return 6;
if(num==13)
return 8;
if(num==14)
return 8;
if(num==15)
return 7;
if(num==16)
return 7;
if(num==17)
return 9;
if(num==18)
return 8;
if(num==19)
return 8;
if(num==20)
return 6;
return 0;
}
private static int LetterCountsOne(int num) {
if(num==2)
return 6;
if(num==3)
return 6;
if(num==4)
return 5;
if(num==5)
return 5;
if(num==6)
return 5;
if(num==7)
return 7;
if(num==8)
return 6;
if(num==9)
return 6;
return 0;
}
}
13、数星期日
下列信息是已知的，当然你也不妨自己再验证一下。
1900年1月1日是星期一。
三十天在九月中，
四六十一也相同。
剩下都是三十一，
除去二月不统一。
二十八天平常年，
多加一天在闰年。
闰年指的是能够被4整除却不能被100整除的年份，或者能够被400整除的年份。
在二十世纪（1901年1月1日到2000年12月31日）中，有多少个月的1号是星期天？
分析：这个虽然简单但有点麻烦，自己慢慢看，就不在介绍。
public class Algorithe13 {
public static void main(String[] args) {
System.out.println(countSundays());
}
public static int countSundays() {
//1900年1月1日是星期一，那么7号就是星期日
int sum=365-6;
int count=0;
for(int i=1901;i<=2000;i++) {
for(int j=1;j<=12;j++) {
sum+=daysOfYear(i,j);
if(sum%7==0)
count++;
}
sum+=30;//最后一个月只加到1号，年循环完要把剩余的30天加上
}
return count;
}
private static int daysOfYear(int year, int month) {
if(month==1)
return 1;
return days(year,month-1)+daysOfYear(year,month-1);
}
private static int days(int year, int month) {
if(month==1 || month==3 || month==5 || month==7 || month==8 || month==10 || month==12)
return 31;
if(month==4 || month==6 || month==9 || month==11)
return 30;
if(month==2 &&(year%4!=0 || year%400!=0))
return 28;
return 29;
}
}
14、阶乘数字和
n! 的意思是 n × (n − 1) × … × 3 × 2 × 1
例如，10! = 10 × 9 × … × 3 × 2 × 1 = 3628800，所以10!的各位数字和是 3 + 6 + 2 + 8 + 8 + 0 + 0 = 27。
求出100!的各位数字和。
分析：int和long都不能表示，所以要使用BinInteger，也很简单就不在介绍。
public class Algorithe14 {
public static void main(String[] args) {
System.out.println(factorialDigitSum(100));
}
public static int factorialDigitSum(int num) {
int i=1;
BigInteger bigInteger=new BigInteger("1");
while(i<=num) {
bigInteger=bigInteger.multiply(new BigInteger(i+""));
i++;
}
String numString=bigInteger.toString();
int sum=0;
for(int j=0;j<numString.length();j++) {
sum+=Character.digit(numString.charAt(j), 10);
}
return sum;
}
}
15、亲和数
记d(n)为n的所有真因数（小于n且整除n的正整数）之和。
如果d(a) = b且d(b) = a，且a ≠ b，那么a和b构成一个亲和数对，a和b被称为亲和数。
例如，220的真因数包括1、2、4、5、10、11、20、22、44、55和100，因此d(220) = 284；而284的真因数包括1、2、4、71和142，因此d(284) = 220。
求所有小于10000的亲和数的和。
分析：先判断是否是亲和数，然后相加，但要防止加两次。
public class Algorithe15 {
public static void main(String[] args) {
System.out.println(amicableNumberSum(10000));
}
public static int amicableNumberSum(int num) {
int sum=0;
for(int i=1;i<num;i++) {
int amicable=amicableNumbers(i);
if(amicable>i) {
sum+=i;
sum+=amicable;
}
}
return sum;
}
private static int amicableNumbers(int num) {
int sum1=0;
for(int i=1;i<num;i++) {
if(num%i==0)
sum1+=i;
}
int sum2=sum1;
sum1=0;
for(int i=1;i<sum2;i++) {
if(sum2%i==0)
sum1+=i;
}
if(num==sum1)
return sum2;
return -1;
}
}
16、全数字的倍数
将192分别与1、2、3相乘：得到192，384，576
连接这些乘积，我们得到一个1至9全数字的数192384576。我们称192384576为192和(1,2,3)的连接乘积。同样地，将9分别与1、2、3、4、5相乘，得到1至9全数字的数918273645，即是9和(1,2,3,4,5)的连接乘积。对于n > 1，所有某个整数和(1,2, … ,n)的连接乘积所构成的数中，最大的1至9全数字的数是多少？
分析：判断是否是全数字，然后返回最大的。
public class Algorithe16 {
public static void main(String[] args) {
System.out.println(pandigitalMultiples());
}
public static int pandigitalMultiples() {
int max=0; //因为n>1，所以i<10000
for(int i=1;i<10000;i++) {
String product="";
for(int j=1;j<10;j++) {
product=product+(i*j);
if(product.length()>9)
break;
if(repetition(product))
continue;
if(product.length()==9) {
if(max<Integer.parseInt(product)) {
max=Integer.parseInt(product);
}
}
}
}
return max;
}
private static boolean repetition(String i) {
List<String> list=new ArrayList<String>();
for(int j=0;j<i.length();j++) {
if(i.charAt(j)=='0' || list.contains(i.charAt(j)+""))
return true;
list.add(i.charAt(j)+"");
}
return false;
}
}
17、字典序排列
排列指的是将一组物体进行有顺序的放置。例如，3124是数字1、2、3、4的一个排列。如果把所有排列按照数字大小或字母先后进行排序，我们称之为字典序排列。0、1、2的字典序排列是：
012 021 102 120 201 210
数字0、1、2、3、4、5、6、7、8、9的字典序排列中第一百万位的排列是什么？
分析：这里用到阶乘的概念，比如n可以组合成n*(n-1)*(n-2)**21中方式。只需要计算(n-1)的阶乘即可，就可以知道除了n有多少种形式，然后把i放到数的最前面，i是list中第几个元素，list的初始元素相当于已经排序好的，然后在通过不断的递归即可求出。
public class Algorithe17 {
public static void main(String[] args) {
List<Integer> list=new ArrayList<Integer>();
for(int i=0;i<10;i++) {
list.add(i);
}
System.out.println(lexicographicPermutations(10, 999999, list));
}
public static String lexicographicPermutations(int num,int max,List<Integer> list) {
if(num>0) {
int prexLeicographicNum=1;
if(num!=1)
prexLeicographicNum=recursion(num-1);
int quotients=max/prexLeicographicNum;
int mod=max%prexLeicographicNum;
int i=list.remove(quotients);
return i+""+lexicographicPermutations(num-1, mod, list);
}
return "";
}
private static int recursion(int num) {
if(num==1)
return 1;
return num*recursion(num-1);
}
}
18、一千位斐波那契数
斐波那契数列是按如下递归关系定义的数列：
F1 = 1 F2 = 1
Fn = Fn−1 + Fn−2
因此斐波那契数列的前12项分别是：
F1 = 1
F2 = 1
F3 = 2
F4 = 3
F5 = 5
F6 = 8
F7 = 13
F8 = 21
F9 = 34
F10 = 55
F11 = 89
F12 = 144
第一个有三位数字的项是第12项F12。
在斐波那契数列中，第一个有1000位数字的是第几项？
分析：用BigInteger计算即可。
public class Algorithe18 {
public static void main(String[] args) {
System.out.println(digitFibonacciNumber());
}
public static String digitFibonacciNumber() {
BigInteger first=new BigInteger("1");
BigInteger second=new BigInteger("1");
for(int i=3;i<Integer.MAX_VALUE;i++) {
BigInteger corren=first.add(second);
if(corren.toString().length()>=1000)
return i+"";
first=second;
second=corren;
}
return "";
}
}
19、倒数的循环节
单位分数指分子为1的分数。分母为2至10的单位分数的十进制表示如下所示：
1/2= 0.5
1/3= 0.(3)
1/4= 0.25
1/5= 0.2
1/6= 0.1(6)
1/7= 0.(142857)
1/8= 0.125
1/9= 0.(1)
1/10= 0.1
这里0.1(6)表示0.166666…，括号内表示有一位循环节。可以看出，1/7有六位循环节。
找出正整数d < 1000，其倒数的十进制表示小数部分有最长的循环节。
分析：只需要求出循环节的长度即可，任何分数都可以写成有限小数或者无限循环小数，如果是有限的好说，如果是无限的，通过不断的求余运算，计算出mod，然后直到找到第一个出现重复的即可。
public class Algorithe19 {
public static void main(String[] args) {
System.out.println(reciprocalCycles());
}
private static int reciprocalCycles() {
int max=0;
int target=0;
for(int i=1;i<1000;i++) {
int circulationCount=circulation(1,i);
if(circulationCount>max) {
target=i;
max=circulationCount;
}
}
return target;
}
private static int circulation(int dividend, int divisor) {
List quoientList=new ArrayList<>();
List moList=new ArrayList<>();
int index=-1;
while(true) {
quoientList.add(dividend/divisor);
int mod=dividend%divisor;
if(mod==0)
break;
index=moList.indexOf(mod);
if(index>=0)
break;
else
moList.add(mod);
dividend=mod*10;
}
if(index>=0)
return quoientList.size()-(index+1);
else
return 0;
}
}
更新至2020.5.20 23:45
PS：最近比较忙，停更，更新日期待定o(╥﹏╥)o