acwing语法题刷题中的细节总结

刷题中的细节总结

equals方法

java中让字符串相等用的是equals()方法，不是等号
equals()方法使用，最好是用 常量.equals(变量)， 这样在工程中不会报异常。

取模时需要注意的点

java中用%取模求奇偶数时，正数是+1，负数是-1，所以如果在正数和负数区间的话，可以这样求
i%2 != 0 或者 i%21 || i%2-1

数组反转

反转数组时，for遍历定义的变量应该为两个，这样才可以反转成功，一个递增，一个递减，然后让他们相等，用同一个的话会只反转一半，详情参考 acwing 740

Math相关方法

Math.abs（）

作用 : 返回一个数的绝对值 Math.abs(x) 参数x必须是一个数值 返回值: Number x 的绝对值。如果 x 不是数字返回 NaN,如果 x 为 null 返回 0。

Math.pow（）

可以用来求幂运算， Math.pow(底数x,指数y)

注意：Math.pow的返回值为double类型的

2的幂运算可以用位运算来表示

1 << i+j 表示为二进制的数里面，1向左移 i+j ，因为二进制数为1248…

数组的翻转

字符串反转参考 775.倒排单词

数组反转参考740.数组反转

会又不同的收获

字符串

1. length（）

统计字符串的长度

2. Character（）

里面有一些方法可以调用

求字符串的数字个数：

CHaracter.isDigit(那个变量)

3. 字符串转换为字符数组

String.toCharArray

4. 想要一个一个的遍历字符串可以用的方法

可以将其转换为字符串数组for(char c : str.toCharArray())

用for循环长度遍历之后，char c = str.charAt(i)

5. 替换字符

replace()方法

str.replace(String oldChar, String newChar)

暴力枚举的方法

String s = sc.nextLine() ;
char flag = sc.next().charAt(0) ;    
for(char c : s.toCharArray()){
        if(c == flag)
            System.out.print("#") ;
        else
            System.out.print(c) ;
    }

6. 字符串的插入（有找ascii最大码的方法）

substring（）方法

循环移位操作也可以用到这个方法，学会举一反三。

主要功能：从一段字符串中截取一一段下来

substring（0，k+1）表示输出从0到k的字符

substring（k+1)表示输入从k+1开始到最后的字符

     while(sc.hasNext()){
            String str = sc.next() ;
            String substr = sc.next() ;
            
       int k = 0 ;
        for(int i = 1; i < str.length(); i++){
            if(str.charAt(i) > str.charAt(k))
                k = i ;
        }
        
        System.out.println(str.substring(0,k+1)+substr+str.substring(k+1)) ;
        
    }

StringBuilder()

	    String str = "aaaaabbbbcccc";
        StringBuilder sb = new StringBuilder(str);
        sb.insert(4,"123");
        System.out.println(sb.toString());

//输出结果为 aaaa123abbbbcccc

7. 只出现一次的字符串（这里用到了一个方法）

	   String str = sc.next() ;
        int[] n = new int[26] ;
        for(char c: str.toCharArray()){
            n[c-'a'] ++ ;
        }
        for(char c : str.toCharArray()){
            if(n[c-'a'] == 1){
                System.out.println(c) ;
                return ;
            }
        }
/*这里用到的一个方法，26个小写的英文字母a-z,int类型的数组，然后用 n[c-'a'],因为a是的ascii码是98，依次往后，减去a之后就是其余的字母的，如果有多个相同的数字，就会 n[c-'a']++ , 入宫最后这个数的等于1，就说明它只出现了一次。
*/

8. 输入与输出

sc.next() 输入字符串，遇到空格，回车等空白字符时停止输入。

next（）读入时会自动跨过多个空格，因为是读一个输出一个，遇到空格就会停止。

sc.nextLine() 输入一整行字符串，遇到空格不会停止输入，遇到回车才会停止

9. 字符串的信息加密，判断大写和小写

/*这个是将字符串往后加一
1. c-'a' 是将其转换为0-25的数组，再加上1，相当于往后增加了一
2.之后模26，是因为当为z时要变成a，所以是变为了0。
3.再加上'a' , 就变为了之前的数。 
*/
import java.util.Scanner ;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in); 
        String s = sc.nextLine(); 
        
        for(char c : s.toCharArray()){
            if(c >= 'a' && c <= 'z'){
                c =(char)((c - 'a' +1) % 26 + 'a') ;
            }
            else if(c >= 'A' && c <= 'Z')
                c = (char)((c - 'A' +1) % 26 + 'A' );  
                
            System.out.printf("%s",c) ;
        }
        
    }
}

10. 一种解决问题的思路（将字符串分割为子串）

需要掌握的思想是学会利用分割字符串，成为字符类型的数组，然后遍历

// 单词替换，没有用replace的原因是因为它是一将所有的这个字符都给替换了，所以用replace的话，比较麻烦。

import java.util.Scanner ;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in); 
        String[] strs = sc.nextLine().split(" ") ; // 将子串用空格分开
        String a = sc.next() , b = sc.next() ;
        
        for(String str : strs){
            if(a.equals(str)){
                System.out.printf("%s ",b) ;
            }else{
                System.out.printf("%s ",str) ;
            }
        }   
    }
}

字符串中常用的api

split 分割字符串

subString（） 参考上面的 6. 字符串的插入

toLowerCase（） 全部小写字符

toUpperCase() 全部大写字符

compareTo（）判断两个字符串的大小，正数大于，负数小于，0相等

indexOf（）方法

• public int indexOf(int ch): 返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。
• public int indexOf(int ch, int fromIndex): 返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。
• int indexOf(String str): 返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。
• int indexOf(String str, int fromIndex): 返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

语法

初涉算法，偏移量的方法来解决回形矩阵的问题

例题 ：acwing 756 (蛇形矩阵，或者回形矩阵都可以)

原理图，可以理解偏移量是怎么一回事，在后面的算法中会用到很多

//图中的0,1,2,3代表了四个方向记为d，绿色的四个坐标分别是x，y的偏移量，这里的x,y指的是行和列，并不是数学上的x，y的坐标

// 下面的那个图像代表的是沿着d方向移动，新的偏移量值，等于原来的加上d方向的偏移量
// 当一个d到头，就需要转换方向，从1-2-3-0-1，这样四个方向，可以发现规律 d =(d+1) % 4
// 撞墙到头的几种情况，1.出界，2.重复之前走过的格子，分别是小于0或者大于行或列的值，还有重复之前走过的，也就是他的值大于0，int类型的数组，默认值为0，这一点忘记了，导致没有完全理解。
//

import java.util.Scanner ;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in) ;
        int n = sc.nextInt() , m = sc.nextInt() ;
        int[][] res = new int[n][m] ;
        int x = 0 , y = 0 , d= 1 ; 
        int[] dx = {-1,0,1,0} , dy = {0,1,0,-1} ;

        for(int i = 1 ; i <= m*n ; i++){
            res[x][y] = i ; 
            int a = x + dx[d] , b = y + dy[d] ; 

            if(a < 0 || a >= n || b < 0 || b >= m || res[a][b] > 0 ){
                d = (d+1) % 4 ; // 转换方向
                a = x + dx[d] ;
                b = y + dy[d] ;
            }
            x = a; 
            y = b;
        }
        for(int[] row : res){
            for(int col : row){
                System.out.printf("%d ",col) ;
            }
            System.out.println() ;
        }
    }
}

初涉双指针算法解决问题

字符串中最长的连续出现的字符

/*初涉双指针算法，对这一用法不太熟悉，后续做题中会经常用到，所以需要掌握双指针的思想。
- 指针一 :本题中的i
- 指针二 ；j
- 遍历字符串的长度，然后令指针二 等于指针一+1，进入一个循环，为的是指针二在满足条件的范围内可以变化，用指针二来遍历相同的剩下的字符
-条件为 ：必须小于字符串的长度，同时指针一的字符和指针二的相同，因为本题的题意。
*/
import java.util.Scanner ;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in) ;
        int n = sc.nextInt() ;
        
        while(n -- > 0) {
            String str = sc.next() ;
            char rec = 0 ;
            int maxnum = 0 ;
            for(int i = 0; i < str.length(); ){
                int j = i + 1 ;
                // int num = j-i ;
                while(j < str.length() && str.charAt(i) == str.charAt(j) ) {
                    j++ ; //移动指针末尾
                    // num++ ;
                    // num = j-i ;
                }
                    if(j-i > maxnum){
                        maxnum = j-i ;
                        rec = str.charAt(i) ;
                    }
                i = j;  // 更新指针下一起始位置
            }
            System.out.printf("%c %d\n",rec,maxnum) ;
        }
    
    }
}

数组去重

/*双指针算法，枚举每个元素，用boolean来判断这个元素是不是第一个出现的枚举 i之前有没有相同的元素，如果想等就跳出这次循环，flag变为false，如果flag为true，表示为不相同的元素。
*/
import java.util.Scanner ;
public class Main{
    private static int get_unique_count(int[] a , int n ){
        int count = 0 ;
        for(int i = 0 ; i < n ; i++){
            boolean flag = true ;
           for(int j = 0; j< i; j++){
               if(a[i] == a[j]){
                   flag = false;
                   break ;
               }
           }
           if(flag) count ++  ;
        }
        return count ;
    }
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in) ;
        int n = sc.nextInt() ;
        int[] a = new int[n] ;
        for(int i = 0 ; i < n ; i++){
            a[i] = sc.nextInt() ;
        }
        System.out.println(get_unique_count(a,n)) ;
    }
}

需要加深印象的题

753（平方矩阵|）754（平方矩阵||）

740（数组变换，倒置） 717 741（数组） 727（菱形）

773（字符串插入），769（替换字符串），761（数字个数）、

756（蛇形矩阵）!!!

772 (只出现一次的字符) 764.（输出字符串）

771（字符串中最长的连续出现的字符）

776. 字符串移位包含问题 777. 字符串乘方

779（最长公共字符串后缀）

817（数组去重）学会利用Boolean来求解
[i] = sc.nextInt() ;
}
System.out.println(get_unique_count(a,n)) ;
}
}

# 需要加深印象的题

753（平方矩阵|）754（平方矩阵||） 

  740（数组变换，倒置） 717    741（数组） 727（菱形）

773（字符串插入），769（替换字符串），761（数字个数）、

756（蛇形矩阵）!!!  

772 (只出现一次的字符)  764.（输出字符串）

771（字符串中最长的连续出现的字符）

776. 字符串移位包含问题           777. 字符串乘方

779（最长公共字符串后缀） 

817（数组去重）学会利用Boolean来求解