大家好，我是普通一本的在校大学生一枚，目前在学习java。之前也学了一段时间，本人现在已经大二结束了，开学就大三了，时间过的真的很快。我会利用好这个暑假，来复习之前学过的内容，并整理好之前写过的博客进行发布。如果博客中有错误或者没有读懂的地方。热烈欢迎大家在评论区进行讨论！！！
望支持！！！！！！
哈喽，大家好，这个板块用来记录我做过的笔试题，以及编程题。我会把每一次训练过的算法编程题记录在这个专栏中,里面也记录着我的每道题的做题思路！！！大家一起努力呀！！！
语言只是工具，不能决定你好不好找工作，决定你好不好找工作的是你的能力！！！！！
学历本科及以上就够用了！！！！！！！！！！！！！！！！！！！！！！！！！！！！
Day1（JavaSE语法）
1.
Character：是字符的包装类
String：是字符串类型，可以存放字符串常量 例如：String s = “hello word!”;故选B
StringBuffer：是字符串类型，但是不能存放字符串常量。需要new一个对象才可以存放。
Vector：是一个集合类。也不能直接存放字符串常量。
2.
构成方法重写的条件：
1）.必须要有继承关系。
2）.重写只能出现在子类中,如果没有继承关系,不存在重写,只存在重载。
3）.在子类中被重写的方法,必须和父类中的方法一致,相同的方法名,返回值类型,参数列表。
4.子类方法访问权限不能小于父类方法的访问权限。（故选D）
记忆Tips：
重载：两同一不同一无关（同类、同方法名）、（不同参数列表）、（返回值类型无关）
重写：三同一继承（同方法名，同参数列表，同返回值类型）、（有继承的父与子类）
3.
面向对象设计方法的主要特征：封装，继承，多态，组合。
结构化程序设计原则：模块化，自顶向下，逐步求精。
4.
成员变量如果没有初始化，默认是零。
6.
程序运行起来是在JVM上的，
JVM有五个区：Java虚拟机栈，本地方法栈，堆区，方法区，程序计数器。
10.
C选项
用类名去访问。除非这个方法是静态方法才可以。而很明显这个方法不是静态方法，因此C选项是错误的
1.组队竞赛(数组.循环.公式总结)
import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int[] arr = new int[3*n];
long sum = 0;
for(int i = 0 ; i<arr.length;i++){
arr[i] = in.nextInt();
}
Arrays.sort(arr);
for(int i = 0; i < n ; i++){
sum+=arr[arr.length-2*(i+1)];
}
System.out.println(sum);
}
}核心公式为arr.length-2*(i+1)。
题目意在给一组3*n的数据，让你分为n组，每组3人。每人都有对应的水平值。
每组的水平值为组内每个人水平值的中位数。
并求出如何分组使得每组水平值的和最大。
将这3*n个数据进行从小到大排序。则从后往前，第偶数个数据（有几组数几个）之和，就是所求分组水平值最大和。
2.删除公共字符(哈希思想)
思路：
1.利用哈希的思想，遍历第二个字符串的每一个字符，将字母放入map中
2.遍历第一个字符串，如果在对应的map中没找到对应的字母，那么就输出。
import java.util.*;
/**
思路：
1.利用哈希的思想，遍历第二个字符串的每一个字符，将字母放入map中
2.遍历第一个字符串，如果在对应的map中没找到对应的字母，那么就输出。
*/
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
String str1 = scan.nextLine();//They are students.
String str2 = scan.nextLine();//aeiou
HashMap<Character, Integer> map = new HashMap<>();
for (int i = 0; i < str2.length(); i++) {
if (map.get(str2.charAt(i)) == null) {
map.put(str2.charAt(i), 1);
} else {
map.put(str2.charAt(i), map.get(str2.charAt(i)) + 1);
}
}
String ret = "";
for (int i = 0; i < str1.length(); i++) {
if (map.get(str1.charAt(i)) == null) {
ret += str1.charAt(i);
}
}
System.out.println(ret);
}
}
Day2（JavaSE语法）
1.
可以用父类类型来实例化子类对象。实现子类对象的向上转型。
间接父类也可以。
2.
若给函数传入admin。.toLowerCase后比较，由于本身都是小写，因此没有产生新的对象结果就为true。
但是题目中的是Admin。通过.toLowerCase转换成小写了，不是在它本身上修改。此时新建了一个对象。此时对象和常量比较因此得false。
3.
由于hello是静态方法，也就是类方法，在类加载时产生，不依赖于对象。虽然题目中用空对象去引用了，但也没关系。可以编译通过。
4.
super()；用于调用父类的构造方法。this()；用于在同一类中调用其他构造方法。- 两者都必须放在构造方法中的第一行。
例如：
public class Example extends ParentClass {
private int value;
// 子类构造方法
public Example() {
super(); // 调用父类构造方法，必须是第一行
// 子类构造逻辑
}
// 同类其他构造方法
public Example(int value) {
this(); // 调用同类中的无参构造方法，必须是第一行
this.value = value;
// 其他构造逻辑
}
}
5.
new Alpha();时。没写super会默认调用父类无参的构造方法因此此时会打印出base
new Base();时。也会打印base，没有换行，因此是basebase。
6.
方法中不能包含静态成员变量。它是属于类的，放在方法中的话那么就是属于方法的。因此不能方法方法中。
static在定义变量的时候，不能定义局部变量。一定是成员变量才行。也就是静态成员变量。
static定义的变量属于类的。不能放在方法中，即使是静态方法。
7.
A、abstract不能修饰字段（成员变量）
B、C、D、抽象方法不能加{}。加了反而是具体的实现了，反而就错了
8.
A、可以省略，默认提供一个不带参数的构造方法。
B、方法可以和class同名
C、正确
D、可以进行重载，因此是多个
9.
A、构成方法的重载，可以。因此A正确。
B、成员变量的计算必须放在方法里面进行
C、没有花括号，又不是抽象方法
D、是抽象方法，不能有花括号。
10.
接口用public修饰。
3.排序子序列(数组，条件循环，计数器)
思路：
1.读入整数n，创建大小为n+1的整型数组
2.有3中情况arr[i]>arr[i+1],时i++，当不大于时count++，i++
3.arr[i]=arr[i+1]，i++，count不用++
4.arr[i]<arr[i+1]，当不小于时count++，i++
5.最后要注意，在遍历到最后一个元素时i+1会越界，
并且若最后一个元素是0时不影响结果，因为大条件下i<n,比较完就会直接跳出循环了
因此要创建大小为i+1的数组。
import java.util.Scanner;
/**
思路：
1.读入整数n，创建大小为n+1的整型数组
2.有3中情况arr[i]>arr[i+1],时i++，当不大于时count++，i++
3.arr[i]=arr[i+1]，i++，count不用++
4.arr[i]<arr[i+1]，当不小于时count++，i++
5.最后要注意，在遍历到最后一个元素时i+1会越界，
并且若最后一个元素是0时不影响结果，因为大条件下i<n,比较完就会直接跳出循环了
因此要创建大小为i+1的数组。
*/
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main{
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int[] arr = new int[n+1];
int count = 0;
for(int i = 0; i<n; i++){
arr[i] = scan.nextInt();
}
int i = 0;
while(i<n){
if(arr[i]<arr[i+1]){
while(i<n && arr[i]<arr[i+1]){
i++;
}
i++;
count++;
}else if(arr[i]==arr[i+1]){
i++;
}else{
if(arr[i]>arr[i+1]){
while(i<n && arr[i]>arr[i+1]){
i++;
}
count++;
i++;
}
}
}
System.out.println(count);
}
}
4.倒置字符串(方法，循环)
思路：（注意：StringBuffer和StringBuilder的reverse方法是不能传参数的）
1.整体进行逆置
2.每个单词进行逆置
import java.util.Scanner;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String str = in.nextLine();
char[] arr = str.toCharArray();
int begin = 0;
int end = arr.length;
reverse(arr, begin, end - 1);
int i = 0;
while (i < end) {
int j = i;
while (j < end && arr[j] != ' ') {
j++;
}
if (j < end) {
reverse(arr, i, j - 1);
i = j + 1;
} else {
reverse(arr, i, j - 1);
i = j;
}
}
String string = new String(arr);
System.out.println(string);
}
public static void reverse(char[] arr, int begin, int end) {
while (begin < end) {
char temp = arr[begin];
arr[begin] = arr[end];
arr[end] = temp;
begin++;
end--;
}
}
}Day3（JavaSE语法）
5.字符串中找出连续最长的数字串（定义两个空字符串）
思路：
创建两个空字符串，cur和ret。cur用来存所有数字字符串，ret用来返回最终结果判断cur和ret的长度。若cur.length();>ret.length(); ret = cur。
数字字符串的判断ch>='0' && ch <='9'
import java.util.Scanner;
/**
思路：
创建两个空字符串，cur和ret。cur用来存所有数字字符串，ret用来返回最终结果
数字字符串的判断ch>='0' && ch <='9'
*/
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String str = in.nextLine();
String cur ="";
String ret ="";
for(int i = 0; i < str.length(); i++){
char ch = str.charAt(i);
if(ch>='0' && ch <='9'){
cur =cur + ch+"";
if(cur.length()>ret.length()){
ret = cur;
}
}else{
cur = "";
}
}
System.out.println(ret);
}
}6.数组中出现次数超过一半的数字（循环）（排序）（两两相消）
思路1：1.首先对数组进行排序
2.若有众数，则最中间的数字为众数。
思路2：1.两两相比，若两数不同则消去。相同则留下。则最终剩余的数为众数。
import java.util.*;
// 思路1：1.首先对数组进行排序
// 2.若有众数，则最中间的数字为众数。
// 思路2：1.两两相比，若两数不同则消去。相同则留下。则最终剩余的数为众数。
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param numbers int整型一维数组
* @return int整型
*/
public int MoreThanHalfNum_Solution (int[] numbers) {
// write code here
if(numbers == null ||numbers.length == 0){
return 0;
}
int result = numbers[0];
int times = 1;
for(int i = 1; i<numbers.length;i++){
if(times != 0){
if(result != numbers[i]){
--times;
}else{
++times;
}
}else{
result = numbers[i];
times = 1;
}
}
int count = 0;
for(int i = 0;i<numbers.length;i++){
if(numbers[i] == result){
count++;
}
}
if(count>numbers.length/2){
return result;
}else{
return 0;
}
}
}Day4（JavaSE语法）
7.计算糖果
思路：
进行数学计算，通过A - B，B - C，A + B，B + C 这四个表达式。三个未知数
分别求出A B C的值，要知道，B有两种算法，
若两种算法得出来的B不一样，那么输出No
若一样，则分别输出A B C
import java.util.Scanner;
/**
思路：进行数学计算，通过A - B，B - C，A + B，B + C 这四个表达式。三个未知数
分别求出A B C的值，要知道，B有两种算法，
若两种算法得出来的B不一样，那么输出No
若一样，则分别输出A B C
*/
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
// 注意 hasNext 和 hasNextLine 的区别
int a = in.nextInt();
int b = in.nextInt();
int c = in.nextInt();
int d = in.nextInt();
int A = (a+c)/2;
int B1 = (b+d)/2;
int B2 = (c-a)/2;
int C = (d-b)/2;
if(B1 == B2){
System.out.println(A+" "+B1+" "+C);
}else{
System.out.println("No");
}
}
}8.进制转换
思路，进制转换，
（M%N）用十进制数M 模 进制数N。得到余数 为N进制数的末位
（M/N）可以将M缩小。（M%N）又会再次得到新进制数的倒数第二位数，循环往复。
import java.util.Scanner;
/**
思路，进制转换，
（M%N）用十进制数M 模 进制数N。得到余数 为N进制数的末位
（M/N）可以将M缩小。（M%N）又会再次得到新进制数的倒数第二位数，循环往复。
*/
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
// 注意 hasNext 和 hasNextLine 的区别
int m = in.nextInt();
int n = in.nextInt();
String table = "0123456789ABCDEF";
StringBuilder s = new StringBuilder();
boolean flag = false;
if(m == 0){
System.out.println("0");
return;
}
if (m < 0) {
m = -m;
flag = true;
}
while (m != 0) {
s.append(table.charAt(m % n));
m = m / n;
}
if (flag == true) {
s.append("-");
}
s.reverse();
System.out.println(s);
}
}Day5（JavaSE语法）
9.统计回文
StringBuffer这个字符串类型，没有equals函数。需要toString后再调用equals方法比较
StringBuffer 需要new一个对象才可以存放。
判断回文的方法：
1.专门写一个函数来判断
2.逆置。再与原字符比较，如果相同则是回文。
import java.util.Scanner;
/**
思路：
1.插入到合适的位置
2.判断是否是回文
*/
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String A = in.nextLine();
String B = in.nextLine();
int len = A.length();
int count =0;
for(int i = 0; i <= len; i++){
StringBuffer str = new StringBuffer(A);
str.insert(i,B);
StringBuffer temp = new StringBuffer(str);
temp.reverse();
if(temp.toString().equals(str.toString())){
count++;
}
}
System.out.println(count);
}
}10.连续子数组最大和
思路：
1.具有动态规划思想。max(dp[i]) = getMax(max(dp[i-1])+arr[i],arr[i])
dp[i]以i结尾的子数组。 max(dp[i])以i结尾的子数组的最大和。
2.从i=1开始求连续子数组的最大和。
比较dp[i-1]+arr[i] 和 arr[i]的大小。 记为sum。 谁大谁就是此时的 max(dp[i])
别忘了arr[0]也可能是最大的，因此还需要和arr[0]来比较
则令 int max = arr[0]; 再将之与sum作比较。 若sum大，则max＝sum
最终max就为 连续子数组最大和 max(dp[i]) 。
import java.util.*;
/**
思路：
1.具有动态规划思想。max(dp[i]) = getMax(max(dp[i-1])+arr[i],arr[i])
dp[i]以i结尾的子数组。 max(dp[i])以i结尾的子数组的最大和。
2.从i=1开始求连续子数组的最大和。
比较dp[i-1]+arr[i] 和 arr[i]的大小。 记为sum。 谁大谁就是此时的 max(dp[i])
别忘了arr[0]也可能是最大的，因此还需要和arr[0]来比较
则令 int max = arr[0]; 再将之与sum作比较。 若sum大，则max＝sum
最终max就为 连续子数组最大和 max(dp[i]) 。
*/
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
// 注意 hasNext 和 hasNextLine 的区别
int size =in.nextInt();
int[] arr = new int[size];
for(int i = 0; i < size; i++){
arr[i] = in.nextInt();
}
int sum = arr[0];
int max = arr[0];
for(int i = 1; i<size; i++){
sum = Math.max(sum+arr[i],arr[i]);
if(sum>max){
max = sum;
}
}
System.out.println(max);
}
}Day6（JavaSE语法）
11.不要二
思路：
1.遇到本题不要慌，本题可以看作一道数学题
2.可将欧几里得距离平方后求解
解得
当x1 = x2 时。 y1 = y2 + 2；
当y1 = y2 时。 x1 = x2 + 2；
也就是说在arr[i][j]位置上放了蛋糕那么在arr[i+2][j]和arr[i][j+2]就不能放了
3.这里要防止数组越界，也就是分别加一个i + 2 < W。j + 2 < H。的条件。
import java.util.Scanner;
/**
思路：
遇到本题不要慌，本题可以看作一道数学题
可将欧几里得距离平方后求解
解得
当x1 = x2 时。 y1 = y2 + 2；
当y1 = y2 时。 x1 = x2 + 2；
也就是说在arr[i][j]位置上放了蛋糕那么在arr[i+2][j]和arr[i][j+2]就不能放了
这里要防止数组越界，也就是加一个i + 2 < W。j + 2 < H。的条件。
*/
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
// 注意 hasNext 和 hasNextLine 的区别
int W = in.nextInt();
int H = in.nextInt();
int[][] arr = new int[W][H];
int count = 0;
for (int i = 0; i < W; i++) {
for (int j = 0; j < H; j++) {
if (arr[i][j] == 0) {
count++;
if (i + 2 < W) {
arr[i + 2][j] = 1;
}
if (j + 2 < H) {
arr[i][j + 2] = 1;
}
}
}
}
System.out.println(count);
}
}12.把字符串转换成整数
思路：
1.首先判断字符串是否为null或者长度为0，若不为
2. 判断字符串首位元素是否为正负号。若为正令flag=1，若为负令flag=-1。并令首元素为0，不影响后续公式sum = sum*10 + ch[i]-'0'; 。 来记录正负号
3.若首位不是正负号则直接遍历字符串，判断元素是否ch[i]<'0' || ch[i]>'9'。若是则return0；若不是则利用公式sum = sum*10 + ch[i]-'0' 来累加字符串的数。（由于字符串本质是一个用final修饰的value数组。不可被修改，令首元素为0。
因此我们需要将字符串转字符数组。）
再利用公式sum = sum*10 + ch[i]-'0';
将字符串转为整数。
import java.util.*;
/**
思路：
由于字符串本质是一个用final修饰的value数组。不可被修改
因此我们需要将字符串转字符数组。
再利用公式sum = sum*10 + ch[i]-'0';
将字符串转为整数。
*/
public class Solution {
public int StrToInt(String str) {
if(str == null || str.length() ==0){
return 0;
}
char[] ch = str.toCharArray();
//判断整数是正书还是负数
int flag = 1;
if(ch[0] == '+'){
flag = 1;
ch[0] = '0';
}
if(ch[0] == '-'){
flag = -1;
ch[0] = '0';
}
int sum = 0;
for(int i = 0;i<ch.length; i++){
if(ch[i]<'0' || ch[i]>'9'){
return 0;
}
sum = sum*10 + ch[i]-'0';
}
return sum*flag;
}
}
Day7（JavaSE语法）
13.合法括号序列判断
思路：
1.用栈结构实现，栈中存放左括号，
2.当遇到右括号之后，检查栈中是否有左括号，
3.如果有则出栈，如果没有，则说明不匹配。
（在遇到左括号时要判断栈是否为空，为空则返回false）
import java.util.*;
/**思路：
用栈结构实现，栈中存放左括号，
当遇到右括号之后，检查栈中是否有左括号，
如果有则出栈，如果没有，
则说明不匹配。
（在遇到左括号时要判断栈是否为空，为空则返回false）
*/
public class Parenthesis {
public boolean chkParenthesis(String A, int n) {
//如果n不为偶数则返回false
if(n%2 != 0){
return false;
}
//如果n为偶数
//创建栈
Stack<Character> stack = new Stack<>();
for(int i = 0; i<n; i++){
char ch = A.charAt(i);
if(ch == '('){
stack.push(ch);
}
else if(ch == ')'){ //在遇到左括号时要判断栈是否为空，为空则返回false
if(stack.empty()){
return false;
}
if(stack.peek() == '('){
stack.pop();
}
}
else{
return false;
}
}
return stack.empty();
}
}
14.Fibonacci数列(循环)
思路：
1.利用循环求出斐波那契数
f3 = f1+f2;
f1 = f2;
f2 = f3;2.记left = f1，为＜N的斐波那契数
记right = f2，为≥N的斐波那契数
3.最终返回step = Math.min(N-left,right-N); 两者的最小值
import java.util.*;
/**思路：
1.利用循环求出斐波那契数
f3 = f1+f2;
f1 = f2;
f2 = f3;
2.记left = f1，为＜N的斐波那契数
记right = f2，为≥N的斐波那契数
3.最终返回step = Math.min(N-left,right-N); 两者的最小值*/
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int N = in.nextInt();
int f1 = 0;
int f2 = 1;
int f3 = 0;
while(f2<N){
f3 = f1+f2;
f1 = f2;
f2 = f3;
}
int left = f1;
int right = f2;
int step = Math.min(N-left,right-N);
System.out.println(step);
}
}Day8（JavaSE语法）
15.两种排序方法
思路：
BufferedReader 由于输入的字符串很多 为了提高读取效率，给它缓冲一下，我们使用BufferedReader类
1.利用BufferedReader来输入。从字符流中读取文本并缓存
new InputStreamReader(System.in) 将字节流转换成字符流
Integer.parseInt(bi.readLine()); 将字符串类型转换成整型
2.创建两个返回值为boolen的方法，一个方法用compareTo方法来比较两字符串的字典排序
另一个方法用.length();来获取字符串长度比较字符串长度
3.利用if条件来输出对应的字符串
import java.util.*;
import java.io.*;
/**
思路：
BufferedReader 由于输入的字符串很多 为了提高读取效率，给它缓冲一下，我们使用BufferedReader类
1.利用BufferedReader来输入。从字符流中读取文本并缓存
new InputStreamReader(System.in) 将字节流转换成字符流
Integer.parseInt(bi.readLine()); 将字符串类型转换成整型
2.创建两个返回值为boolen的方法，一个方法用compareTo方法来比较两字符串的字典排序
另一个方法用.length();来获取字符串长度比较字符串长度
3.利用if条件来输出对应的字符串
*/
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
public static void main(String[] args) throws IOException{
BufferedReader bi = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(bi.readLine());
String[] str = new String[n];
for(int i = 0; i < n; i++){
str[i] = bi.readLine();
}
if(isSortLength(str) && isSortZiDian(str)){
System.out.println("both");
}
else if(isSortLength(str)){
System.out.println("lengths");
}
else if(isSortZiDian(str)){
System.out.println("lexicographically");
}
else{
System.out.println("none");
}
}
public static boolean isSortZiDian(String[] str){
for(int i = 0; i<str.length-1;i++){
if(str[i].compareTo(str[i+1])>0){
return false;
}
}
return true;
}
public static boolean isSortLength(String[] str){
for(int i = 0; i<str.length-1;i++){
if(str[i].length()>str[i+1].length()){
return false;
}
}
return true;
}
}
16.求最小公倍数
1.利用循环i叠减求最大公约数
2.在用m*n/最大公约数 求出最小公倍数
import java.util.Scanner;
/**
思路：
1.利用循环i叠减求最大公约数
2.在用m*n/最大公约数 求出最小公倍数
*/
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
// 注意 hasNext 和 hasNextLine 的区别
int m = in.nextInt();
int n = in.nextInt();
if(m<n){
int temp = n;
n = m;
m = temp;
}
int GCD = 0;
for(int i = m; i>=1;i--){
if(m%i==0 && n%i == 0){
GCD = i;
break;
}
}
System.out.println(m*n/GCD);
}
}思路：
1.利用辗转相除法求最大公约数
2.在用m*n/最大公约数 求出最小公倍数
import java.util.Scanner;
/**
思路：
1.利用辗转相除法求最大公约数
2.在用m*n/最大公约数 求出最小公倍数
*/
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
// 注意 hasNext 和 hasNextLine 的区别
int m = in.nextInt();
int n = in.nextInt();
int GCD = GCD(m,n);
System.out.println(m*n/GCD);
}
public static int GCD(int m,int n){
int r = 0;
if(m == n){
return m;
}
if(m<n){
int temp = n;
n = m;
m = temp;
}
while((r = m%n) > 0){
m = n;
n = r;
}
return n;
}
}求最小公倍数
Day9（JavaSE语法）
17.另类加法
1.如果在二进制中，如果A & B = 0，两数相加不进位，那么sum = A+B= A^B
2.如果A & B != 0,两数相加考虑进位。那么 (A & B)<<1 之后再^sum
3.直到(A & B)<<1 = 0时,也就是A & B = 0时，sum = A + B = A ^ B;
import java.util.*;
/**
思路：
1.如果在二进制中，如果A & B = 0，两数相加不进位，那么sum = A+B= A^B
2.如果A & B != 0,两数相加考虑进位。那么 (A & B)<<1 之后再^sum
3.直到(A & B)<<1 = 0时,也就是A & B = 0时，sum = A + B = A ^ B;
*/
public class UnusualAdd {
public int addAB(int A, int B) {
if(B == 0){
return A;
}
int sum = 0;
while(B != 0){
sum = A ^ B;
B = (A&B)<<1;
A = sum;
}
return A;
}
}18.走方格的方案数(求路径总数)
思路：
1.如果n = 1 && m = 1;那么方案数为n+m
2.如果((n == 1 && m >= 1) ||(n >= 1 && m == 1))，那么方案数为n+m
3.如果n > 1 && m > 1,
那么方案数为(n-1行，m列方格的方案数)+(n行，m-1列方格的方案数)的和
import java.util.Scanner;
/**
思路：
1.如果n = 1 && m = 1;那么方案数为n+m
2.如果((n == 1 && m >= 1) ||(n >= 1 && m == 1))，那么方案数为n+m
3.如果n > 1 && m > 1,
那么方案数为(n-1行，m列方格的方案数)+(n行，m-1列方格的方案数)的和
*/
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
// 注意 hasNext 和 hasNextLine 的区别
int n = in.nextInt();
int m = in.nextInt();
int route = route(n,m);
System.out.println(route);
}
public static int route(int n, int m){
if((n == 1 && m >= 1) ||(n >= 1 && m == 1)){
return n+m;
}
return route((n-1),m)+route(n,(m-1));
}
}Day10（JavaSE语法）
19.井字棋
思路：
1.由于玩家胜的数字为1，那么如果行/列/主对角线/副对角线加起来为 board.length 那么玩家胜利
2.检查行是否加起来为 board.length。两个for双循环累加board[i][j]即可
3.检查列是否加起来为 board.length。两个for双循环累加board[j][i]即可。注意i和j互换
4.检查主对角线双循环累加board[i][i]即可
5.检查副对角线双循环累加board[i][board[j][i]-1-i]即可
若sum为board[j][i]返回true
最终返回false
import java.util.*;
/**
思路：
1.由于玩家胜的数字为1，那么如果行/列/主对角线/副对角线加起来为 board.length 那么玩家胜利
2.检查行是否加起来为 board.length。两个for双循环累加board[i][j]即可
3.检查列是否加起来为 board.length。两个for双循环累加board[j][i]即可。注意i和j互换
4.检查主对角线双循环累加board[i][i]即可
5.检查副对角线双循环累加board[i][board[j][i]-1-i]即可
若sum为board[j][i]返回true
最终返回false
*/
public class Board {
public boolean checkWon(int[][] board) {
// write code here
int N = board.length;
int sum = 0;
int i = 0;
int j = 0;
//检查行
for (i = 0; i < N; i++) {
for (j = 0; j < N; j++) {
sum += board[i][j];
}
if (sum == N) {
return true;
}
//检查列
}
for (i = 0; i < N; i++) {
for (j = 0; j < N; j++) {
sum += board[j][i];
}
if (sum == N) {
return true;
}
}
//检查主对角线
for (i = 0; i < N; i++) {
sum += board[i][i];
if (sum == N) {
return true;
}
}
//检查副对角线
for (i = 0; i < N; i++) {
sum += board[i][N-1-i];
if (sum == N) {
return true;
}
}
return false;
}
}20.密码强度等级
思路：
1.即对于长度，字母，数字，符号单独判断，最后把所有的单项值根据题目要求相加，输出对应的安全级别。
2.得到长度分数方法就不说了很简单，
3.得到字母方法分数的函数要注意小写字母为97-122，大写字母为65-90
4.得到数字分数的方法我们可以遍历字符串后用每个字符减去'0'如果为0-9之间那么就有数字
5.对于符号，若非字母，非数字那么就为符号。
6.对于奖励先判断大小写字母，数字符号。再判断字母数字符号，再判断字母数字。
7.最终定义sum。将对应的sum1，sum2，sum3，sum4，奖励部分可以单独用sum判读，加起来。
8.得到最终分数之后就可以输出对应等级
import java.util.Scanner;
import java.io.*;
/**
思路：
1.即对于长度，字母，数字，符号单独判断，最后把所有的单项值根据题目要求相加，输出对应的安全级别。
2.得到长度分数方法就不说了很简单，
3.得到字母方法分数的函数要注意小写字母为97-122，大写字母为65-90
4.得到数字分数的方法我们可以遍历字符串后用每个字符减去'0'如果为0-9之间那么就有数字
5.对于符号，若非字母，非数字那么就为符号。
6.对于奖励先判断大小写字母，数字符号。再判断字母数字符号，再判断字母数字。
7.最终定义sum。将对应的sum1，sum2，sum3，sum4，奖励部分可以单独用sum判读，加起来。
8.得到最终分数之后就可以输出对应等级
*/
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader bi = new BufferedReader(new InputStreamReader(System.in));
String str = "";
while ((str = bi.readLine()) != null) {
int sum1 = getLen(str);
int sum2 = getChar(str);
int sum3 = getNum(str);
int sum4 = getSym(str);
int sum = 0;
if (sum2 == 20 && sum3 >= 1 && sum4 >= 1) {
sum = sum1 + sum2 + sum3 + sum4 + 5;
} else if (sum2 == 10 && sum3 >= 1 && sum4 >= 1) {
sum = sum1 + sum2 + sum3 + sum4 + 3;
} else if (sum2 == 10 && sum3 >= 1 && sum4 == 0) {
sum = sum1 + sum2 + sum3 + sum4 + 2;
} else {
sum = sum1 + sum2 + sum3 + sum4;
}
if (sum >= 90) {
System.out.println("VERY_SECURE");
} else if (sum >= 80) {
System.out.println("SECURE");
} else if (sum >= 70) {
System.out.println("VERY_STRONG");
} else if (sum >= 60) {
System.out.println("STRONG");
} else if (sum >= 50) {
System.out.println("AVERAGE");
} else if (sum >= 25) {
System.out.println("WEAK");
} else if (sum >= 0) {
System.out.println("VERY_WEAK");
}
}
}
public static int getLen(String str) {
if (str.length() <= 4) {
return 5;
}
if (str.length() > 4 && str.length() <= 7) {
return 10;
}
if (str.length() >= 8) {
return 25;
}
return 0;
}
public static int getChar(String str) {
int small = 0;
int big = 0;
for (int i = 0; i < str.length(); i++) {
if (str.charAt(i) >= 65 && str.charAt(i) <= 90) {
big++;
} else if (str.charAt(i) >= 97 && str.charAt(i) <= 122) {
small++;
}
}
if (small > 0 && big > 0) {
return 20;
} else if (small > 0 || big > 0) {
return 10;
} else {
return 0;
}
}
public static int getNum(String str) {
int num = 0;
for (int i = 0; i < str.length(); i++) {
if (str.charAt(i) - '0' >= 0 && str.charAt(i) - '0' <= 9) {
num++;
}
}
if (num > 1) {
return 20;
} else if (num == 1) {
return 10;
} else {
return 0;
}
}
public static int getSym(String str) {
int num = 0;
for (int i = 0; i < str.length(); i++) {
if (!(str.charAt(i) >= 65 && str.charAt(i) <= 90) &&
!(str.charAt(i) >= 97 && str.charAt(i) <= 122) &&
!(str.charAt(i) - '0' >= 0 && str.charAt(i) - '0' <= 9)) {
num++;
}
}
if (num > 1) {
return 25;
} else if (num == 1) {
return 10;
} else {
return 0;
}
}
}Day11（JavaSE语法）
21.最近公共祖先
1.由于parent = child/2
2.如果a>b,则a/2，否则b/2知道a == b。为止，此时相等的数为公共祖先
import java.util.*;
/**
思路：
1.由于parent = child/2
2.如果a>b,则a/2，否则b/2知道a == b。为止，此时相等的数为公共祖先
*/
public class LCA {
public int getLCA(int a, int b) {
while(a != b){
if(a>b){
a = a/2;
}else{
b = b/2;
}
}
return a;
}
}22.最大连续bit数
思路：
1.通过n&1来得到二进制中末位为0还是1
2.通过n=n/2 或者n = n>>1 (将n右移一位)依次得到二进制数的末位 最终当n = 0时结束
3.将得到的二进制数进行统计，若为1则count++，为0则count = 0；
4.用Endcount记录count的最大值。
5.最后输出Endcount
import java.util.*;
import java.io.*;
/**
思路：
1.通过n&1来得到二进制中末位为0还是1
2.通过n=n/2 或者n = n>>1 (将n右移一位)依次得到二进制数的末位 最终当n = 0时结束
3.将得到的二进制数进行统计，若为1则count++，为0则count = 0；
4.用Endcount记录count的最大值。
5.最后输出Endcount
*/
public class Main{
public static void main(String[] args) throws IOException{
BufferedReader bi = new BufferedReader(new InputStreamReader(System.in));
String str = "";
while((str = bi.readLine()) != null){
int n = Integer.parseInt(str);
int count = 0;
int Endcount = 0;
while(n!=0){
if((n & 1) == 1){
count++;
Endcount = Math.max(count,Endcount);
}else{
count = 0;
}
n = n>>1;
}
System.out.println(Endcount);
}
}
}思路2：
1.先求出对应的二进制数，再遍历
2.利用计数器来统计出连续1的个数
Day12（JavaSE语法）
23.二进制插入
思路：
1.由于n的第j到i位为0，我们先将m左移j位。那么m右边多出j个0。
2.再用n|m。由于1|0 = 1，0|0 = 0；可以保证将m插入到n的j到i位之中。
import java.util.*;
/**
思路：
1.由于n的第j到i位为0，我们先将m左移j位。那么m右边多出j个0。
2.再用n|m。由于1|0 = 1，0|0 = 0；可以保证将m插入到n的j到i位之中。
*/
public class BinInsert {
public int binInsert(int n, int m, int j, int i) {
// write code here
if( j>i ){
return 0;
}
m <<= j;
return n|m;
}
}24.查找组成一个偶数最接近的两个素数
思路：
1.首先我们将这个偶数除以2。从中间开始，依次递增，而小的数则为n-i
2.创建一个判断是否为素数的方法，每次递增都判断一下i和n-i是否为素数
3.若为素数则依次打印出n-i和i，再break；
import java.util.Scanner;
/**
思路：
1.首先我们将这个偶数除以2。从中间开始，依次递增，而小的数则为n-i
2.创建一个判断是否为素数的方法，每次递增都判断一下i和n-i是否为素数
3.若为素数则依次打印出n-i和i，再break；
*/
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
// 注意 hasNext 和 hasNextLine 的区别
int n = in.nextInt();
for(int i = n/2; i>0;i++){
if(isPrime(i)&&isPrime(n-i)){
System.out.println(n-i);
System.out.println(i);
break;
}
}
}
public static boolean isPrime(int n){
for(int i = 2; i<n; i++){
if(n%i == 0){
return false;
}
}
return true;
}
}