博主從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