华为机试_list.add(sc.hasnext()){list.add(sc.nextint());-CSDN博客

本文链接：https://blog.csdn.net/weixin_44251749/article/details/107385892

计算字符个数

（1）大小写字母和数字的ascii码值:

65～90为26个大写英文字母，97～122号为26个小写英文字母，48～57为0到9十个阿拉伯数字。大小写字母之间正好相差32。

（2）字符串的大小写转换：

toLowerCase()方法将String转换为小写。如果字符串中没有应该被转换的字符，则将原字符串返回，否则返回一个新的字符串。

语法：str.toLowerCase()

toUpperCase()方法将Srtring转换为大写。如果字符串中没有应该转换的字符，则将原字符串返回，否则返回一个新的字符串。

语法：str.toUpperCase()

说明:使用toLowerCase()方法和toUpperCase()方法进行大小写转换时，数字或非字符不受影响。

（3）单个字符的大小写转换

根据 Character 类提供的大小写转换方法。
Character.toUpperCase(char)：小写字符char转成大写字符。
Character.toLowerCase(char)：大写转小写。

//主要是不区分大小写
import java.util.*;
public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String str = sc.nextLine().toUpperCase();
		char char1 = Character.toUpperCase(sc.nextLine().charAt(0));
		int result = solution(str,char1);
		System.out.println(result);
		
	}
	public static int solution(String str,char char1) {
		
		
		int count = 0;
		for(int i=0;i<str.length();i++) {
			if(char1 == str.charAt(i)) {
				count++;
			}
		}
		return count;
	}
}

(1)

import java.util.*;
import java.util.ArrayList;
public class Solution {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		ArrayList<Integer> list = new ArrayList<>();
		//这个while循环会陷入死循环，程序会一直等待你的输入，while循环后面的语句都不会执行
		while(sc.hasNextInt()) {
			list.add(sc.nextInt());
		}

		for(int i=0;i<list.size();i++) {
			System.out.println(list.get(i));
		}
		
	}

}

(2)

//这种方法好像没有排序的过程，竟然都能通过
import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        /*
        像这种虽然也是while循环，但是输出语句在循环内部已经完成了输出，
        但是程序也是一直在等待输入
        */
        while (sc.hasNextInt()) {
            int n = sc.nextInt();
            Integer[] arr = new Integer[n];
            for (int i = 0; i < arr.length; i++) {
                arr[i] = sc.nextInt();
            }
            ArrayList<Integer> list = new ArrayList<>(arr.length);
            Collections.addAll(list, arr);
            TreeSet<Integer> set = new TreeSet<>(list);
            Iterator iterator = set.iterator();
            while (iterator.hasNext()){
                System.out.println(iterator.next());
            }
        }
    }
}

//增加了一个排序的过程
import java.util.*;
import java.util.ArrayList;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int n = sc.nextInt();
            Integer[] arr = new Integer[n];
            for (int i = 0; i < arr.length; i++) {
                arr[i] = sc.nextInt();
            }
            for(int i=0;i<arr.length;i++) {
            	for(int j=i+1;j<arr.length;j++) {
            		if(arr[i]>arr[j]) {
            			int temp = arr[i];
            			arr[i] = arr[j];
            			arr[j] = temp;
            		}
            	}
            }
            ArrayList<Integer> list = new ArrayList<>(arr.length);
            Collections.addAll(list, arr);

            TreeSet<Integer> set = new TreeSet<>(list);
            Iterator iterator = set.iterator();
            while (iterator.hasNext()){
                System.out.println(iterator.next());
            }
        }
    }
}

所以这种先接收所有数据再进行处理的想法是错误的。

import java.util.Scanner;
import java.util.ArrayList;
public class Main {

	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		ArrayList<Integer> list = new ArrayList<>();
		//先接受所有数据在一个list中，然后再对数据进行处理
		//（这种想法是错误的，不可能接收所有数据）
		while(sc.hasNextInt()) {
			list.add(sc.nextInt());
			
		}
	
		ArrayList<Integer> list1 = Main.solution(list);
		for(int i=0;i<list1.size();i++) {
			System.out.println(list1.get(i));
		}
		
		
		
	}
	public static ArrayList<Integer> solution(ArrayList<Integer> list) {
		
		int flag = 0;
		ArrayList<Integer> result = new ArrayList<Integer>();
		ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
		while(flag < list.size()) {
			ArrayList<Integer> temp = new ArrayList<Integer>();
			for(int i=flag+1;i<=flag+list.get(flag);i++) {
				temp.add(list.get(i));
			}
			res.add(temp);
			flag = flag+list.get(flag)+1;	
		}
		//去重
		for(int j=0;j<res.size();j++) {
			for(int m=0;m<res.get(j).size();m++) {
				for(int n=m+1;n<res.get(j).size();n++) {
					if(res.get(j).get(m) == res.get(j).get(n)) {
						res.get(j).remove(n);
					}
				}
			}
		}
		//排序
		for(int j=0;j<res.size();j++) {
			for(int m=0;m<res.get(j).size();m++) {
				for(int n=m+1;n<res.get(j).size();n++) {
					if(res.get(j).get(m) > res.get(j).get(n)) {
						int amount = res.get(j).get(m);
						res.get(j).set(m, res.get(j).get(n));
						res.get(j).set(n, amount);
					}
				}
			}
		}
		for(int j=0;j<res.size();j++) {
			for(int m=0;m<res.get(j).size();m++) {
				result.add(res.get(j).get(m));
			}
		}
		
		return result;
	}
}

字符串分隔

(1)采用while循环逐行读取输入
(2)str.substring：（左闭右开）
String str = “123”;
str.substring(int beginIndex)或者str.substring(int beginIndex, int endIndex)
参数:beginIndex – 起始索引（包括）, 索引从 0 开始。endIndex – 结束索引（不包括）。

import java.util.*;
import java.util.ArrayList;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNextLine()) {
        String str1 = sc.nextLine();
	        if(str1.length()> 0) {
	        	
	        	if(str1.length()<8) {
	        		for(int j=1;str1.length()<8;j++) {
	        			str1 = str1 + "0";
	        		}
	        		System.out.println(str1);
	        	}
	        	else if(str1.length() == 8) {
	        		System.out.println(str1);
	        	}
	        	else {
	        		int n1 = str1.length()%8;
	        		if(n1 > 0) {
	        		for(int m=1;m<=8-n1;m++) {
	        			str1 = str1 + "0";
	        		}
	        		}
	        		for(int i=0;i<str1.length();i+=8) {
	            		System.out.println(str1.substring(i,i+8));
	            	}	
	        	}
	        }
        }
    }
}

进制转换

本文提供两种Java实现任意进制转换的方法：

方法一：利用 Integer 实现进制转换
1、 Integer类的方法toBinaryString()，Integer.toOctalString(), Integer.toHexString()可实现十进制分别转换成二进制、八进制和十六进制
2、Integer.valueOf(s, radix) 将第一个参数解释为用第二个参数指定的基数表示的有符号整数，换句话说就是将 s 以 radix 进制的形式转换为十进制。

public class ArbitraryConversion
 {

    public static void main(String[] args) {
        System.out.println("==========十进制776转换到其它进制：==========");
        int sjz = 776;
        System.out.println("十进制转二进制： " + Integer.toBinaryString(sjz));
        System.out.println("十进制转八进制： " + Integer.toOctalString(sjz));
        System.out.println("十进制转十六进制： " + Integer.toHexString(sjz));
        
        
        
        System.out.println("==========八进制1410转换到其它进制：==========");
        String bjz = "1410";
        System.out.println("八进制转十进制: " + Integer.valueOf(bjz, 8));
        System.out.println("八进制转二进制: " + Integer.toBinaryString(Integer.valueOf(bjz , 8))); //八进制转十进制，十进制转二进制
        System.out.println("八进制转十六进制: " + Integer.toHexString(Integer.valueOf(bjz, 8))); //八进制转十进制，十进制转十六进制
        
        
        
        System.out.println("==========十六进制308转换到其它进制：==========");
        String sljz = "308";
        System.out.println("十六进制转十进制: " + Integer.valueOf(sljz , 16));
        System.out.println("十六进制转二进制: " + Integer.toBinaryString(Integer.valueOf(sljz , 16))); //十六进制转十进制，十进制转二进制
        System.out.println("十六进制转八进制: "+ Integer.toOctalString(Integer.valueOf(sljz, 16))); //十六进制转十进制，十进制转八进制
        
        
        
        System.out.println("==========二进制1100001000转换到其它进制：==========");
        String ejz = "1100001000";
        System.out.println("二进制转十进制: " + Integer.valueOf(ejz, 2));
        System.out.println("二进制转八进制: " + Integer.toOctalString(Integer.valueOf(ejz , 2))); //二进制转十进制，十进制转八进制
        System.out.println("二进制转十六进制: "+   Integer.toHexString(Integer.valueOf(ejz, 2))); //二进制转十进制，十进制转十六进制
    }
}

方法二：利用 BigInteger 实现进制转换。
利用BigInteger 实现进制转换比较简单，注释很详细。

//一定要导入这个包，注意不是Math,m是小写的！！！
import java.math.BigInteger;

/*
 * BigIntegerArbitraryConversion
 */
public class BigIntegerArbitraryConversion {
	public static void main(String[] args) {
		System.out.println(change("1410", 8, 2));   // 八进制转二进制
		System.out.println(change("1410", 8, 10));  // 八进制转十进制
		System.out.println(change("1410", 8, 16));  // 八进制转十六进制
	}

	/**
	 * number   要转换的数//注意，要转换的数是String类型的    
	 * from     原数的进制     
	 * to       要转换成的进制
	 */
	private static String change(String number, int from, int to) {
		/*
		这个形式就是这样的，返回的是一个字符串
		String str = new BigInteger("15", 10).toString(16);
		System.out.println(str);
		*/
		return new BigInteger(number, from).toString(to);
	}
}

题目代码：

//1. 注意这个math的m是小写的，不是大写的
import java.math.BigInteger;
import java.util.*;


public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNextLine()) {
	        //一定要把前两个字符截掉
	        String str1 = sc.nextLine().substring(2);
	        String str2 = new BigInteger(str1,16).toString(10);
	        System.out.println(str2);
        }
    }
}

质数因子

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        long n = sc.nextLong();
        for(int i=2;i<=n;i++){
            while(n%i == 0){
                n = n/i;
                System.out.print(i + " ");
            }
        }
    }
}

提取不重复的整数

在使用ArrayList去除重复的元素时要注意下面两点：
(1) i<res.size()-1:i不能取到res.size()-1，因为i = res.size()-1时j=i+1，则j = res.size(),越界了，而且i都是最后一个了，后面没有元素与其比较了，所以i = res.size()-1也没必要。
(2)res.remove(j);j–;
res.remove(j)后，后面的元素会补上来，如果没有j–直接进入下次循环进行j++的后会漏掉现在索引为j的元素，也就是原来索引为j+1的元素。

ArrayList<Integer> res = new ArrayList<Integer>();
for(int i=0;i<res.size()-1;i++){
    for(int j=i+1;j<res.size();j++){
        if(res.get(j) == res.get(i)){
            res.remove(j);
            j--;
        }
    }
}

翻转字符串的方法：
String str1 = “123”;
String str2 = new StringBuffer(str1).reverse().toString();
StringBuffer类才有实例方法reverse()，String类没有，所以先将字符串变成StringBuffer，翻转后再变成String。

23.删除字符串中出现次数最少的字符

StringBuilder类的常用方法：

StringBuilder strB = new StringBuilder();

1、append(String str)/append(char c)：字符串连接
System.out.println(“StringBuilder:”+strB.append(“ch”).append(“111”).append(‘c’));
//return “StringBuilder:ch111c”
2、toString()：返回一个与构建起或缓冲器内容相同的字符串
System.out.println(“String:”+strB.toString());
//return “String:ch111c”
3. charAt(int index):返回索引为index的字符
4. insert（int index，String str/char c):在索引为index处插入String str/char c)
5、setCharAt(int index, char c)：将索引为index的元素设置为 c（可以理解为替换）
strB.setCharAt(2, ‘d’);
System.out.println(“StringBuilder.setCharAt:” + strB);
//return “StringBuilder.setCharAt:chd11c”
6、delete(int startIndex,int endIndex)：删除起始位置（含）到结尾位置（不含）之间的字符串
System.out.println(“StringBuilder.delete:”+ strB.delete(2, 4));
//return “StringBuilder.delete:chSd11c”

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()) {
            String str = sc.next();
            char[] ch = str.toCharArray();
            HashMap<Character,Integer> map = new HashMap<Character,Integer>();
            for(int i=0;i<ch.length;i++){
                if(map.containsKey(ch[i])){
                    map.put(ch[i],map.get(ch[i])+1);
                }
                else{
                    map.put(ch[i],1);
                }
            }
            ArrayList<Integer> list = new ArrayList<Integer>(map.values());
            int num = Collections.min(list);
            StringBuilder res = new StringBuilder();
            for(int i=0;i<ch.length;i++){
                if(map.get(ch[i])!=num){
                    res.append(ch[i]);
                }
            }
            System.out.println(res.toString());
        }
    }
}

25.数据分类处理
判断一个字符串是不是另一个字符串的子串：
（1）parentStr.indexOf(sunStr):如果包含，返回的值是包含该子字符串在父类字符串中起始位置；如果不包含返回值为-1。
(2)parentStr.contains(sunStr):如果包含则返回true,不包含则返回false。

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            String I = sc.nextLine();
            String R = sc.nextLine();
            String[] I_str = I.split(" ");
            String[] R_str = R.split(" ");
            ArrayList<Integer> I_list = new ArrayList<Integer>();
            ArrayList<Integer> R_list = new ArrayList<Integer>();
            for(int i=1;i<I_str.length;i++){
                I_list.add(Integer.parseInt(I_str[i]));
            }
            for(int i=1;i<R_str.length;i++){
                R_list.add(Integer.parseInt(R_str[i]));
            }
            //R序列去重排序
            TreeSet R_set = new TreeSet(R_list);
            ArrayList<Integer> Rlist = new ArrayList<Integer>(R_set);
            Collections.sort(Rlist);

            ArrayList<Integer> res = new ArrayList<Integer>();
            for(int i=0;i<Rlist.size();i++){
                ArrayList<Integer> temp = isContains(Rlist.get(i),I_list);
                if(temp.size()!=0&&temp!=null){
                    res.add(Rlist.get(i));
                    res.addAll(temp);
                }
            }
            int num = res.size();
            res.add(0,num);
            for(int i=0;i<res.size()-1;i++){
                System.out.print(res.get(i)+" ");
            }
            System.out.println(res.get(res.size()-1));
        }
    }
    public static ArrayList<Integer> isContains(int R_i,ArrayList<Integer> list){
        ArrayList<Integer> con = new ArrayList<Integer>();
        int count = 0;
        for(int i=0;i<list.size();i++){
            if(String.valueOf(list.get(i)).contains( String.valueOf(R_i))){
                count++;
                con.add(i);
                con.add(list.get(i));
            }
        }
        if(count!=0){
            con.add(0,count);
        }
        return con;
    }

}

27.查找兄弟单词

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            String str1 = sc.nextLine();
            String[] str = str1.split(" ");
            int num = Integer.parseInt(str[0]);
            String key = str[num+1];
            int index = Integer.parseInt(str[num+2]);
            ArrayList<String> brolist = new ArrayList<String>();
            for(int i=1;i<str.length-2;i++){
                if(isBroStr(str[i],key)){
                    brolist.add(str[i]);
                }
            }
            System.out.println(brolist.size());
            Collections.sort(brolist);
            if(brolist.size()>=index){
                System.out.println(brolist.get(index-1));
            }
        }
    }
    //判断是否是兄弟单词的方法不错
    public static boolean isBroStr(String resource,String key){
        if(resource.equals(key)||resource.length()!=key.length()){
            return false;
        }
        for(int i='a';i<='z';i++){
            char c = (char)(i);
            if(getCharNum(resource,c)!=getCharNum(key,c)){
                return false;
            }
        }
        return true;
    }
    public static int getCharNum(String input,char ch){
        char[] inputchar = input.toCharArray();
        int count = 0;
        for(int i=0;i<inputchar.length;i++){
            if(ch == inputchar[i]){
                count++;
            }
        }
        return count;
    }
}

33.整数与ip地址间的转换

import java.util.*;

/*
Long.toBinaryString(num):将long型整数num转化为无符号的二进制数，转化成的二进制数是字符串的形式
Long.parseLong(String str,int n):n表示str是n进制的，n不写默认为10

 */
public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            String ipStr = sc.nextLine();
            String tenStr = sc.nextLine();
            ipToTen(ipStr);
            tenToIp(tenStr);
        }
    }
    public static void ipToTen(String ipStr){
        String[] ip = ipStr.split("\\.");
        StringBuilder sbAll = new StringBuilder();
        //将ip地址每段整数转化成八位二进制并结合在一起
        for(int i=0;i<ip.length;i++){
            StringBuilder sb = new StringBuilder();
            String temp = Long.toBinaryString(Long.parseLong(ip[i]));
            sb.append(temp);
            while(sb.length()<8){
                sb.insert(0, "0");
            }
            sbAll.append(sb);
        }
        //将32位二进制数转化为long型整数
        System.out.println(Long.parseLong(sbAll.toString(),2));
    }
    public static void tenToIp(String tenStr){
        StringBuilder str = new StringBuilder(Long.toBinaryString(Long.parseLong(tenStr)));
        while(str.length()<32){
            str.insert(0,"0");
        }
        ArrayList<Long> list = new ArrayList<Long>();
        for(int i=0;i<str.length();i+=8){
            String substr = str.substring(i,i+8);
            list.add(Long.parseLong(substr,2));
        }
        for(int i=0;i<list.size()-1;i++){
            System.out.print(list.get(i));
            System.out.print(".");
        }
        System.out.println(list.get(list.size()-1));

    }
}

37.统计每个月兔子的总数
递归问题，每个月的兔子总数等于上个月的兔子数加上这个月出生的兔子数，f(n)=f(n-1)+f(n-2),
f(n-1)是上个月的兔子数，f(n-2)为两个月前就有的兔子数，到这个月刚好是第三个月，可以生兔子了。


import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNextInt()) {
            int month = sc.nextInt();
            System.out.println(count(month));
        }
    }
    public static int count(int month){
        if(month == 1){
            return 1;
        }
        else if(month == 2){
            return 1;
        }
        else{
            return count(month-1)+count(month-2);
        }
    }
}

61.放苹果

import java.util.*;

/*
 解题分析：
        设f(m,n) 为m个苹果，n个盘子的放法数目，则先对n作讨论，
        当n>m：必定有n-m个盘子永远空着，去掉它们对摆放苹果方法数目不产生影响。即if(n>m) f(m,n) = f(m,m)　　
        当n<=m：不同的放法可以分成两类：
        1、有至少一个盘子空着，即相当于f(m,n) = f(m,n-1);
        2、所有盘子都有苹果，相当于可以从每个盘子中拿掉一个苹果，不影响不同放法的数目，即f(m,n) = f(m-n,n).
        而总的放苹果的放法数目等于两者的和，即 f(m,n) =f(m,n-1)+f(m-n,n)
    递归出口条件说明：
        当n=1时，所有苹果都必须放在一个盘子里，所以返回１；
        当没有苹果可放时，定义为１种放法；
        递归的两条路，第一条n会逐渐减少，终会到达出口n==1;
        第二条m会逐渐减少，因为n>m时，我们会return f(m,m)　所以终会到达出口m==0．
 */
public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int M = sc.nextInt();
            int N = sc.nextInt();
            if(M>=1&&M<=10&&N>=1&&N<=10){
                System.out.println(applePlace(M,N));
            }
            else{
                System.out.println(-1);
            }

        }
    }
    public static int applePlace(int M,int N){
        if(M==0||N==1) return 1;
        else if(M<N) return applePlace(M,M);
        else return applePlace(M-N,N)+applePlace(M,N-1);
    }
}

65.查找两个字符串a,b中的最长公共子串

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            String str1 = sc.next();
            String str2 = sc.next();
            String shortstr = str1.length()>str2.length() ? str2:str1;
            String longstr = str1.length()>str2.length() ? str1:str2;
            int max = 0;
            String substr = "";
            for(int i=0;i<shortstr.length();i++){
                for(int j=i+1;j<=shortstr.length();j++){
                    if(longstr.contains(shortstr.substring(i,j))&&(j-i)>max){
                        substr = shortstr.substring(i,j);
                        max = j-i;
                    }
                }
            }
            System.out.println(substr);
        }
    }
}

92.在字符串中找出连续最长的数字串

//注意处理输出即可，要求多个字符串挨着输出，不用空格，字符串和最后的数字之间有个逗号
import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            String str = sc.next();

            ArrayList<String> list = new ArrayList<String>();
            int max = 1;
            if(str.length()!=0){
                for(int i=0;i<str.length();i++){
                    int num = i;
                    String substr = "";
                    while((str.charAt(num)>='0')&&(str.charAt(num)<='9')){
                        substr = substr + str.charAt(num);
                        num++;
                        if(num>=str.length()){
                            break;
                        }
                    }
                    if(substr.length()>=max){
                        list.add(substr);
                        max = substr.length();
                    }
                }
                if(list.size()!=0&&list!=null){
                    
                    for(int i=0;i<list.size();i++){
                        if(list.get(i).length() == max){
                            System.out.print(list.get(i));
                            
                        }
                    }
                    System.out.print(",");
                    System.out.println(max);
                }
                else{
                    System.out.println("");
                }
            }
            else{
                System.out.println("");
            }
        }
    }
}

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int num = sc.nextInt();
            int sum1 = 0,sum2 = 0;
            int index = 0;
            int[] rest = new int[num];
            for(int i=0;i<num;i++){
                int temp = sc.nextInt();
                if(temp % 5 == 0){
                    sum1 += temp;
                }
                else if(temp % 3 == 0){
                    sum2 += temp;
                }
                else{
                    rest[index++] = temp;
                }
            }
            System.out.println(isEqual(sum1,sum2,rest,0));
        }
    }
    public static boolean isEqual(int sum1,int sum2,int[] rest,int index){
        //一定要找好递归基
        if(index == rest.length && sum1 == sum2){
            return true;
        }
        else if(index == rest.length && sum1 != sum2){
            return false;
        }
        else{
            //剩余数字要么放在sum1中，要么放在sum2中
            return (isEqual(sum1+rest[index],sum2,rest,index+1))||
                    (isEqual(sum1,sum2+rest[index],rest,index+1));
        }
    }
}

99.自守数

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int num = sc.nextInt();
            int count = 0;
            //0和1也是自守数
            for(int i=0;i<=num;i++){
                String i_str = String.valueOf(i);
                String sqr = String.valueOf(i*i);
                //必须是在尾部出现，所以不能用contains()方法
                if(sqr.indexOf(i_str) == sqr.length()-i_str.length()){
                    count++;
                }
            }
            System.out.println(count);
        }
    }
}

104.字符串分割

/*
2
abc
123456789
注意，上面那只是一组完整的输入，包括一个整数和几行字符串，所以不能用只一个for循环获取输入，那样得到的只是一个输入
*/
import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        //换成sc.hasNextLine()就不对了，不知道为啥
        while(sc.hasNext()) {
            int num = sc.nextInt();
            for(int n=0;n<num;n++) {
                String str1 = sc.next();
                if (str1.length() > 0) {

                    if (str1.length() < 8) {
                        for (int j = 1; str1.length() < 8; j++) {
                            str1 = str1 + "0";
                        }
                        System.out.println(str1);
                    } else if (str1.length() == 8) {
                        System.out.println(str1);
                    } else {
                        int n1 = str1.length() % 8;
                        if (n1 > 0) {
                            for (int m = 1; m <= 8 - n1; m++) {
                                str1 = str1 + "0";
                            }
                        }
                        for (int i = 0; i < str1.length(); i += 8) {
                            System.out.println(str1.substring(i, i + 8));
                        }
                    }
                }
            }
        }
    }
}

看看别人的答案多么简洁

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()) {
            int n = sc.nextInt();
            for(int i=0; i<n; i++) {
                String temp = sc.next();
                while(temp.length()%8!=0) {
                    temp += "0";
                }
                for(int j=0; j<temp.length(); j+=8) {
                    System.out.println(temp.substring(j, j+8));
                }
            }
        }
    }
}

108.求最小公倍数

import java.util.Scanner;
 
public class Main {
    /**
    求最大公约数可以用辗转相除法，
    先取两数之中较大的数作为被除数，较小的数作为除数，
    以除数和余数反复做除法运算，当余数为0时，取当前算式除数为最大公约数。
    */
    public static int getResult(int m ,int n){
        if(m<n){
            int temp=m;
            m=n;
            n=temp;
        }
        int k=0;
        while(n!=0){
            k=m%n;
            m=n;
            n=k;
        }
        return m;
    }
    public static void main(String[] args) {
        Scanner reader = new Scanner(System.in);
        while(reader.hasNext()){
            int m = reader.nextInt();
            int n = reader.nextInt();
            //最小公倍数等于两数乘积除以最大公约数
            System.out.println(m*n/getResult(m, n));
        }
    }
}


46.按字节截取字符串

```java
 /**
     * 判断一个字符是否是汉字
     * PS：中文汉字的编码范围：[\u4e00-\u9fa5]
     *
     * @param c 需要判断的字符
     * @return 是汉字(true), 不是汉字(false)
     */
    public static boolean isChineseChar(char c) {
        return String.valueOf(c).matches("[\u4e00-\u9fa5]");
    }

import java.util.*;

/**
汉字占两个字节
*/
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()) {
            String str = sc.next();
            char[] ch = str.toCharArray();
            int num = sc.nextInt();
            int count = 0;
            StringBuilder res = new StringBuilder();

            for(int i=0;i<ch.length;i++){
                if((ch[i]>='a'&&ch[i]<='z')||(ch[i]>='A'&&ch[i]<='Z')){
                    if(count >= num){
                        break;
                    }
                    else{
                        res.append(ch[i]);
                        count++;
                    }
                }
                else{
                    if(count == num){
                        break;
                    }
                    //count > num,则删除上一个添加进去的汉字
                    else if(count > num){
                        res.deleteCharAt(res.length()-1);
                    }
                    else{
                        res.append(ch[i]);
                        count += 2;
                    }
                }
            }
            System.out.println(res.toString());
        }
    }
}