JAVA题目

public class Practice02 {
    public static void main(String[] args) {
        int count = 0;  //含数字4的个数
        int num = 0; //一共多少数
        for (int i = 10000; i <= 99999; i++) {
            if(i%10==4 | i%100/10==4 | i%1000/100==4 | i/1000%10==4 |i/10000==4){
                count += 1;
            }
            num += 1;
        }
        System.out.println("最多一共可发出"+(num-count)+"张");
    }

public class Practice03 {
    public static void main(String[] args) {
        //用字母表顺序表示牌的花色
        //A 2 3 4 5 6 7 8 9 10 J Q K
        //a b c d e f g h i j k l m
        int count = 0; //一共出现牌型组合数
        for (int a = 0; a <= 4; a++) {
            for (int b = 0; b <= 4; b++) {
                for (int c = 0; c <= 4; c++) {
                    for (int d = 0; d <= 4; d++) {
                        for (int e = 0; e <= 4; e++) {
                            for (int f = 0; f <= 4; f++) {
                                for (int g = 0; g <= 4; g++) {
                                    for (int h = 0; h <= 4; h++) {
                                        for (int i = 0; i <= 4; i++) {
                                            for (int j = 0; j <= 4; j++) {
                                                for (int k = 0; k <= 4; k++) {
                                                    for (int l = 0; l <= 4; l++) {
                                                        for (int m = 0; m <= 4; m++) {
                                                            if (a+b+c+d+e+f+g+h+i+j+k+l+m==13){  //每个人当得到13张牌
                                                                count++;
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        System.out.println("一共出现的种数有：" + count);
    }
}

初始化两个int[100]的数组,一个值全为0,一个值全为1,将值为1的数组的下标为21到30的值复制给值为0的组,并输值为0的组,用空格分隔,如0 0 0 0 1 1 1 1 0 0 0 0

public class Practice04 {
    public static void main(String[] args) {
        int[] a = new int[100];
        int[] b = new int[100];
        for (int i = 0; i < 100 ; i++) {
            a[i] = 0;
            b[i] = 1;
            System.arraycopy(b,21,a,21,10);
            System.out.print(a[i]+"\t");
        }
    }
}

定义一个Vector,并添加一个字符串 abc 一个整数 1 一个字符串数组{“abc”,”efg”,”ijk”},输出这些值,用空格分隔如 abc 1 abc efg ijk

public class Practice05 {
    public static void main(String[] args) {
        String Vector[] = {null,null,"abc","efg","ijk"};
        String a = "abc";
        int b = 1;
        for (int i = 0; i < Vector.length; i++) {
            Vector[0] = a;
            Vector[1] = Integer.toString(b);
            System.out.print(Vector[i]+"\t");
        }
    }
}

有N级楼梯，每次可以上一级或两级，
问有多少总方法走到第N级
比如，只有两级楼梯，就有两种走法，1+1 2
比如，有3级楼梯，1+1+1 1+2 2+1

import java.util.Scanner;
public class Practice06 {
    static int count(int stair){
        if(stair <= 0){
            return 0;
        }
        if(stair == 1 ){
            return 1;
        }
        if(stair == 2){
            return 2;
        }
        return count(stair-1) + count(stair-2);
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.print("请输入阶梯数：");
        int stairs = in.nextInt();
        System.out.println("\n共有"+ count(stairs) +"种走法");
    }
}

我们都知道：1+2+3+ … + 49 = 1225。现在要求你把其中两个不相邻的加号变成乘号，
使得结果为 2015。
例如： 1+2+3+…+1011+12+…+2728+29+…+49 = 2015 就是符合要求的答案。
请你寻找所有可能的答案，并把前面的两个数字输出，如上面的就是输出（10 27）。

public class Practice08 {
    public static void main(String[] args) {
        for (int i = 1; i < 48; i++) {
            for (int j = i+2; j < 49; j++) {
                if (1225 - i - j - (i+1) - (j+1) + i*(i+1) + j*(j+1) == 2015) {
                    System.out.println(i +"\t" + j);
                }
            }
        }
    }
}

要求用递归实现
编写一个程序，输入一个数字 ，输出它的阶乘 （N!）。
5！= 54321 = 120。
当我们输入数字5时，输出一个120。
如：
输入：5
输出：120

普通方法：
import java.util.Scanner;
public class Practice09 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入数字(1-10)：");
        int num = sc.nextInt();
        int i = 1;
        int fac = 1;
        while(i <= num){
            fac *=i;
            i++;
        }
        System.out.println(fac);
    }
}

递归：
import java.util.Scanner;
public class Practice09 {
    public static long fact(int n){
        if (n<1){
            return 1;
        }else {
            return n * fact(n-1);
        }
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入数字(1-10)：");
        int num = sc.nextInt();
        System.out.println(fact(num));
    }
}

我的函数就是将n个从源柱移到目标柱（也就是实现从1移到3），那它的以此类推是什么？就是将n-1个移到中间柱上(由于这个函数就能将n个从源移到目标柱，所以n-1个也可以将给它来移，至于它是怎么移的，我不用关心)，再将第n移到目标柱上，再将中间柱上的n-1个移到目标柱上。
第二，那它的退出条件是什么？极端情况下，n只有一个了，直接移到目标柱。

public class Practice10 {
    static String zz[] = {"1", "2", "3"};

    static void Move(int n, String s, String d) {
        if (n == 1) {
            System.out.println(s + "--->" + d);
            return;
        }
        String zjz = "";
        for(int i=0;i<zz.length; i++){
            if(zz[i] !=s && zz[i] !=d){
                zjz = zz[i];
            }
        }
        Move(n-1, s, zjz);
        System.out.println(s + "--->" + d);
        Move(n-1, zjz, d);
    }
    public static void main(String[] args) {
        Move(3, zz[0], zz[2]);
    }
}

搞清楚两个问题：
1 以此类推是什么？就是当前这一步和下一步的关系
2 结束条件是什么？

我要写个函数实现求开了多少天和发了多少金牌。就是求前一天发了多少金牌，再加上今天发的金牌（第N天发了多少呢，就是 N枚 + （总的－到前一天已经发掉了的）* 七分之一）。
这里和这前有点不同的地方就是需要假定开了几天，可以用循环从2开始，这个不知道如何写退出条件。改成假定有M块金牌，M从1开始

第N天发完后剩下的金牌（（M－N）* 6/7）给第N+1天
退出条件是 M==N

由于M＝1时，第一天正好是1块，所以从2块开始

public class Practice11 {
    public static void main(String[] args) {
        for(int i=1;i<Integer.MAX_VALUE;i++){
            int n = Fn(1, i);
            if(n >0 ){
                System.out.println("开了" + n +"天发了" + i + "块！");
            }
        }
    }
    static int Fn(int n, int M){
        if(n == M){
            return n;
        }
        int y = (M-n) % 7;
        if(y != 0){
            return -1;
        }
        return Fn(n+1, (M-n) * 6 / 7);
    }
}

要求用递归实现
输入一个N个长度的字符串，如abc，将它反转后输出，如cba。
输入：abcde
输出：edcba

import java.util.Scanner;
public class Practice12 {
    public static String strings(String n){
        char []array = n.toCharArray();
        String words1 = "";
        for (int i = array.length-1; i >=0 ; i--) {
            words1+=array[i];
        }
        System.out.println(words1);
        return words1;
    }
    public static void main(String[] args) {
        System.out.println("请输入字符串：");
        Scanner sc = new Scanner(System.in);
        String words = sc.next();
        strings(words);
    }

要求用递归实现
斐波那契数列（Fibonacci sequence），又称黄金分割数列、因数学家列昂纳多·斐波那契（Leonardoda Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：1、1、2、3、5、8、13、21、34、……（从第3位开始，每一位数字都是前两位数字之和）
在现代物理、准晶体结构、化学等领域，斐波纳契数列都有直接的应用。
要求输入N，输出第N位数字。如：
输入：8
输出：21

import java.util.Scanner;
public class Practice13 {
    public static Integer fs(int n){
        if (n > 0 && n < 3){
            return 1;
        }else {
            return fs(n-2)+fs(n-1);
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入N：");
        int i = sc.nextInt();
        System.out.println(fs(i));
    }
}