Code simulation

Print matrix clockwise

public class Solution {
    public static ArrayList<Integer> printMatrix(int [][] matrix) {
        ArrayList<Integer> res=new ArrayList<>();
        int m=matrix.length,n=matrix[0].length;
        int[][] flag=new int[m][n];
        int[][] direction={
   {0,1},{1,0},{0,-1},{-1,0}};
        if(m==0 || n==0) return res;
        int i=0,j=0,k=0,time=0;
        dfs(matrix,res,i,j,m,n,k,direction,flag,time);
        return res;
    }

    public static void dfs(int[][] matrix,ArrayList<Integer> res,int i,int j,int m,int n,int k,int[][] direction,int[][] flag,int time) {
            System.out.println(matrix[i][j]);
            res.add(matrix[i][j]);
            flag[i][j] = 1;
            time+=1;
            int nexti = i + direction[k % direction.length][0];
            int nextj = j + direction[k % direction.length][1];
            if(time>=m*n) return;   //time It can be used to judge the end condition 
            while (nexti < 0 || nexti >= m || nextj < 0 || nextj >= n || flag[nexti][nextj]==1) {
                int index = (++k) % direction.length;
                nexti = i + direction[index][0];
                nextj = j + direction[index][1];
            }
            dfs(matrix, res, nexti, nextj, m, n, k, direction, flag,time);
    }
}

public class Solution {
    
    static ArrayList<Integer> res = new ArrayList<>();
    
    public static ArrayList<Integer> printMatrix(int [][] matrix) {
        if(matrix==null||matrix.length==0) return res;
        int m = matrix.length;
        int n = matrix[0].length;

        print(0, n-1, 0, m-1, matrix);
        return res;
    }
    public static void print(int left, int right, int top, int bottom, int [][] matrix){
        //  From left to right 
        for(int i = left; i <= right; i ++) res.add(matrix[top][i]);
        //  The next layer 
        top ++;
        if(left > right || top > bottom) return;
        //  From top to bottom 
        for(int i = top; i <= bottom; i ++) res.add(matrix[i][right]);
        right --;
        if(left > right || top > bottom) return;
        //  From right to left 
        for(int i = right; i >= left; i --) res.add(matrix[bottom][i]);
        bottom --;
        if(left > right || top > bottom) return;
        //  From bottom to top 
        for(int i = bottom; i >= top; i --) res.add(matrix[i][left]);
        left ++;
        //  recursive 
        print(left, right, top, bottom, matrix);
    }
}

Judge whether playing cards are shunzi

public class Solution {
    public static boolean IsContinuous(int [] numbers) {
        Arrays.sort(numbers);
        int len=numbers.length;
        int count=0,zeronum=Integer.MAX_VALUE;
        for(int i=0;i<len-1;++i){
            if(numbers[i]==numbers[i+1])
                return false;
            if(i>=zeronum) count+=(numbers[i+1]-numbers[i]);  // Calculate the deviation and 
            if(numbers[i]==0 && numbers[i+1]!=0) zeronum=i;   //0 The number of 
        }
        if(count<=zeronum) return true;   // Judge 
        else return false;
    }
}

Convert a string to an integer

public class Solution {
    public static int StrToInt (String s) {
        if(s==null && s.length()==0) return 0;
        String string=s.trim();
        if(string.length()==0) return 0;
        boolean flag=true;
        char numone=string.charAt(0);
        long res=0;                     // Notice that this is Long Ah ah ah 
        if(!num(numone) && numone!='-' && numone!='+') return 0;
        if(numone=='-') flag=false;
        else if(numone=='+') flag=true;
        else res=numone-'0';
        for(int i=1;i<string.length();++i){
            char c=string.charAt(i);
            if(!num(c))
                break;
            else{
                res=res*10+(c-'0');   // Otherwise, it will calculate according to overflow , The latter judgment doesn't work at all 
                if(flag && res>Integer.MAX_VALUE) return Integer.MAX_VALUE;
                if(!flag && res*(-1)<Integer.MIN_VALUE) return Integer.MIN_VALUE;
            }
        }
        if(flag) return (int) res;
        else return  (int) -res;
    }

    public static boolean num(char c){
        if(c>='0' && c<='9')
            return true;
        else return false;
    }
}

To be continued ！