Java面向对象编程

顺时针打印矩阵

题目描述：对于一个矩阵，请设计一个算法从左上角(mat[0][0])开始，顺时针打印矩阵元素。 

给定int矩阵mat,以及它的维数nxm，请返回一个数组，数组中的元素为矩阵元素的顺时针输出。

public class Printer {
    //顺时针打印矩阵
    public int[] clockwisePrint(int[][] mat, int n, int m) {
        //左上角坐标
        int x1 = 0;
        int y1 = 0;
        //左下角坐标
        int x2 = n - 1;
        int y2 = m - 1;
        int[] arr = new int[n * m];
        int idx = 0;
        while (x1 <= x2 && y1 <= y2) {
            //第一行：x1,y1~y2
            for (int i = y1; i <= y2; ++i) {
                arr[idx++] = mat[x1][i];
            }
            //最后一列：x1+1~x2,y2
            for (int i = x1 + 1; i <= x2; ++i) {
                arr[idx++] = mat[i][y2];
            }
            //最后一行：x2,y2-1,y1---->x1 < x2
            if (x1 < x2) {
                for (int i = y2 - 1; i >= y1; --i) {
                    arr[idx++] = mat[x2][i];
                }
            }
            //第一列：x2-1~x1+1,y1---->y1 x1; --i) {
                    arr[idx++] = mat[i][y1];
                }
            }
            x1++;
            y1++;
            x2--;
            y2--;
        }
        return arr;
    }
}

Fibonacci数列

题目描述:Fibonacci数列是这样定义的:

F[0]=0

F[1]=1

for each i ≥ 2:F[]=F[ i-1]+F[i-2]

因此，Fibonacci数列就形如:0,1,1,2,3,5,8,13...，在Fibonacc数列中的数我们称为Fibonacci数。给你一个N，你想让其变为一个Fibonacci数,每一步你可以把当前数字X变为X-1或者X+1，现在给你一个数N求最少需要多少步可以变为Fibonacci数。

输入描述:输入为一个正整数N(1≤N≤1,000,000)

输出描述:输出一个最小的步数变为Fibonacci数"

Fibonacci数列

题目描述:Fibonacci数列是这样定义的:

F[0]=0

F[1]=1

for each i ≥ 2:F[]=F[ i-1]+F[i-2]

因此，Fibonacci数列就形如:0,1,1,2,3,5,8,13...，在Fibonacc数列中的数我们称为Fibonacci数。给你一个N，你想让其变为一个Fibonacci数,每一步你可以把当前数字X变为X-1或者X+1，现在给你一个数N求最少需要多少步可以变为Fibonacci数。

输入描述:输入为一个正整数N(1≤N≤1,000,000)

输出描述:输出一个最小的步数变为Fibonacci数"

public class Main79 {
    //Fibonacci数列
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int n=scanner.nextInt();
        int f1=0;
        int f2=1;
        while (f2

合法括号序列判断

题目描述:给定一个字符串A和其长度n，请返回一个bool值代表它是否为一个合法的括号串(只能由括号组成)。

public class Parenthesis {
    //合法括号序列判断
    public boolean chkParenthesis(String A, int n) {
        if (n % 2 != 0) {
            return false;
        }
        Stack stack = new Stack<>();
        for (char c : A.toCharArray()) {
            if (c == '(') {
                stack.push(c);
            } else if (c == ')') {
                //左括号先于右括号出现，为非法
                if (stack.isEmpty()) {
                    return false;
                } else if (stack.peek() == '(') {
                    stack.pop();
                }
            } else {
                return false;
            }
        }
        return stack.isEmpty();
    }
}

参数解析

题目描述：在命令行输入如下命令： 

xcopy /s c:\\ d:\\e， 

各个参数如下： 

参数1：命令字xcopy 

参数2：字符串/s 

参数3：字符串c:\\ 

参数4: 字符串d:\\e 

请编写一个参数解析程序，实现将命令行各个参数解析出来。 

解析规则： 

1.参数分隔符为空格 

2.对于用""包含起来的参数，如果中间有空格，不能解析为多个参数。比如在命令行输入xcopy /s "C:\\program files" "d:\"时，参数仍然是4个，第3个参数应 该是字符串C:\\program files，而不是C:\\program，注意输出参数时，需要将""去掉，引号不存在嵌套情况。 

3.参数不定长 

4.输入由用例保证，不会出现不符合要求的输入 

数据范围：字符串长度：1<=len<=1000

进阶：时间复杂度：O(N)，空间复杂度：O(M)

输入描述：输入一行字符串，可以有空格 

输出描述：输出参数个数，分解后的参数，每个参数都独占一行

public class Main80 {
    //参数解析
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        String str= scanner.nextLine();
        int count=0;
        for (int i = 0; i < str.length(); i++) {
            //遇到双引号的时候，要一直遍历，直到碰到第二个双引号
            //才说明双引号中的参数遍历完了
            if (str.charAt(i)=='"'){
                do {
                    i++;
                }while (str.charAt(i) !='"');
            }
            //碰到双引号以外的空格
            if (str.charAt(i)==' '){
                count++;
            }
        }
        //参数的总个数=空格个数+1
        System.out.println(count+1);
        int flag=1;
        for (int i = 0; i < str.length(); i++) {
            //当碰到第一个双引号flag变为0,当碰到第二个双引号flag变为1
            //说明在flag==0的时候，我们一直在遍历双引号中的参数
            if (str.charAt(i)=='"'){
                flag^=1;
            }
            //除了双引号中的空格和双引号，其他字符都输出
            if (str.charAt(i) !=' ' && str.charAt(i) !='"'){
                System.out.print(str.charAt(i));
            }
            //双引号里面的空格需要输出
            if (str.charAt(i)==' ' && flag==0){
                System.out.print(str.charAt(i));
            }
            //碰到双引号以外的空格需要换行
            if (str.charAt(i)==' ' && flag==1){
                System.out.println();
            }
        }
    }
}

跳石板

题目描述：小易来到了一条石板路前，每块石板上从1挨着编号为：1、2、3....... 

这条石板路要根据特殊的规则才能前进：对于小易当前所在的编号为K的 石板，小易单次只能往前跳K的一个约数(不含1和K)步，即跳到K+X(X为K的一个非1和 本身的约数)的位置。 小易当前处在编号为N的石板，他想跳到编号恰好为M的石板去，小易想知道最少需要跳跃几次可以到达。 

例如： N = 4，M = 24： 

4->6->8->12->18->24 于是小易最少需要跳跃5次，就可以从4号石板跳到24号石板 

输入描述：输入为一行，有两个整数N，M，以空格隔开。 

(4 ≤ N ≤ 100000) (N ≤ M ≤ 100000) 

输出描述：输出小易最少需要跳跃的步数,如果不能到达输出-1

public class Main81 {
    //跳石板
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int n=scanner.nextInt();
        int m=scanner.nextInt();
        int[] step=new int[m+1];
        for (int i = 0; i < m+1; i++) {
            step[i]=Integer.MAX_VALUE;
        }
        step[n]=0;
        for (int i = n; i < m; i++) {
            if (step[i]==Integer.MAX_VALUE){
                continue;
            }
            List list=div(i);
            //j代表一次可以跳几块石板
            //i代表当前石板的编号
            for (int j:list) {
                if (i+j<=m && step[i+j] !=Integer.MAX_VALUE){
                    step[i+j]=Math.min(step[i+j],step[i]+1);
                }else if (i+j<=m){
                    step[i+j]=step[i]+1;
                }
            }
        }
        if (step[m]==Integer.MAX_VALUE){
            System.out.println(-1);
        }else {
            System.out.println(step[m]);
        }
    }
    public static List div(int num){
        List list=new ArrayList();
        for (int i = 2; i*i <= num; i++) {
            if (num%i==0){
                list.add(i);
                if (num/i !=i){
                    list.add(num/i);
                }
            }
        }
        return list;
    }
}