2017-03-08-switch判断某一年的某天是这一年的第几天
Xplorist Lv6
  2017-03-08 14:23:01 2017-03-08 14:23      

2017-03-08-switch判断某一年的某天是这一年的第几天

实例1：

定义三个整数5,9,2，请把这三个数由小到大输出。

思路：

1.通过多次if判断将数的大小比较出来

2.使用冒泡排序算法

if判断的核心代码：

1）思路较为清晰地算法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public void test16() {
        int a = 5, b = 9, c = 2;

        if (a > b) {
            if (b > c) {
                System.out.println(c + b + a);
            } else if (a > c) {
                System.out.println(b + c + a);
            } else {
                System.out.println(b + a + c);
            }

        } else if (c > b) {// b>a
            System.out.println(a + b + c);
        } else if (c > a) {// b>c
            System.out.println(a + c + b);
        } else {
            System.out.println(c + a + b);
        }

    }

2）根据集合来判断

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public void test11() {
        int a = 5, b = 9, c = 2;

        if (a > b && a > c) {
            System.out.println(a);
        } else if (b > a && b > c) {
            System.out.println(b);
        } else {
            System.out.println(c);
        }

        if ((a > b && a < c) || (a < b && a > c)) {
            System.out.println(a);
        } else if ((b > a && b < c) || (b < a && b > c)) {
            System.out.println(b);
        } else {
            System.out.println(c);
        }

        if (a < b && a < c) {
            System.out.println(a);
        } else if (b < a && b < c) {
            System.out.println(b);
        } else {
            System.out.println(c);
        }

    }

使用排序算法的核心代码：

1）使用时间换空间：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/** 排序 */
    public void test12() {
        int a = 5, b = 9, c = 2;
        if (a > b) {
            a = a + b;
            b = a - b;
            a = a - b;
        }
        if (a > c) {
            a = a + c;
            c = a - c;
            a = a - c;
        }
        if (b > c) {
            b = b + c;
            c = b - c;
            b = b - c;
        }
        System.out.println("从小到大排列为：" + a + " " + b + " " + c);
    }

2）使用空间换时间：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/** 排序 */
    public void test9() {
        int a = 5, b = 9, c = 2;
        if (a > b) {
            int x = a;
            a = b;
            b = x;
        }
        if (a > c) {
            int x = a;
            a = c;
            c = x;
        }
        if (b > c) {
            int x = b;
            b = c;
            c = x;
        }
        System.out.println("从小到大排列为：" + a + " " + b + " " + c);
    }

使用三目运算符的一些方式：

1）实际上也是冒泡排序算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/** 排序 */
    public void test8() {
        int a = 5, b = 9, c = 2;

        int min = a < b ? a : b;
        int max = a < b ? b : a;
        a = min;
        b = max;

        min = a < c ? a : c;
        max = a < c ? c : a;
        a = min;
        c = max;

        min = b < c ? b : c;
        max = b < c ? c : b;
        b = min;
        c = max;

        System.out.println("从小到大排列为：" + a + " " + b + " " + c);
    }

实例2：

输出1~100内前5个可以被整除的数。

思路：就是for循环再加一个计数器

核心代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/** 输出1~100内前5个能被3整除的数 */
    public void test10() {
        System.out.println("前5个能被3整除的数有：");
        for (int i = 1, count = 1; i < 101; i++) {

            if (i % 3 == 0) {
                count++;
                System.out.print(i + " ");
                if (count > 5) {
                    break;
                }
            }
        }
    }

实例3：

输出9*9的乘法表。

思路：双层for循环，外层控制行数，里层控制列数

核心代码：

1
2
3
4
5
6
7
8
public void test17(){
        for(int i=1;i<10;i++){
            for(int j=1;j<=i;j++){
                System.out.print(i+"*"+j+"="+(i*j)+"\t");
            }
            System.out.println();
        }
    }

实例4：

输出100~200之间的质数。

思路：先将100~200之间的数通过for循环遍历出来，再判断质数，最后输出质数

核心代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
public void test2(){ 
        for(int i=100;i<201;i++){
            boolean flag=true;
            for(int j=2;j<i;j++){
                if(i%j==0){
                    flag=false;
                }
            }
            if(flag){
                System.out.println(i+" ");
            }
        }
    }

注意：设置布尔判断标志的时候，注意标志的位置，如果初始化位置放错了，结果就只会判断一次，后面的效果就看不到了。

实例5：

判断1995年10月3日是这一年的第几天？

错误的思路：先进入判断这一年是不是闰年，闰年的2月天数会多一天，如果是闰年，判断月份，大于2月的情况，天数加1
判断闰年，非整百年，整除4；整百年：整除400 月份分为大月和小月，用switch将每个月都不同

简单的思路：先判断月份，将月份的天数通过穿透的switch来累加，然后再判断月份是否大于2，再判断是否是闰年，最后得出结果

核心代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
public void test3() {
        int year = 1995, month = 10, day = 3, sum = 0;

        if (month > 2) {

            switch((month-1)){
            case 11:
                sum+=30;
            case 10:
                sum+=31;
            case 9:
                sum+=30;
            case 8:
                sum+=31;
            case 7:
                sum+=31;
            case 6:
                sum+=30;
            case 5:
                sum+=31;
            case 4:
                sum+=30;
            case 3:
                sum+=31;
            case 2:
                sum+=28;//一定要注意这儿是28天
            case 1:
                sum+=31;
            case 0:
                sum+=0;
                break;
            default:
                System.out.println("月份有问题");
                break;
            }
            sum+=day;
            
            if (((year % 100 != 0) && (year % 4 == 0) )|| (year % 400 == 0)) {
                sum++;
            }
        }else{
            sum=day;
        }
        System.out.println(sum);
    }

  

实例6：

将一个偶数分解为两个质数相加。

思路：先用穷举法将偶数分解为两个数相加，再判断分解的数是不是质数

核心代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
/**
     * 一个偶数分解为两个质数之和
     * */
    public void test4(){
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个偶数");
        int n=sc.nextInt();
        if(n%2==0){
            for(int i=1;i<=(n/2);i++){
                if((test5(i))&&test5(n-i)){
                    System.out.println(n+"="+i+"+"+(n-i));
                }
                
            }
        }else{
            System.out.println("对不起，你输入的不是整数。");
        }
        
    }
    /**
     * 判断是不是质数
     * */
    public boolean test5(int n){
        
        for(int i=2;i<n;i++){
            if(n%i==0){
                return false;
            }
        }
        return true;
    }
   //这个例子的主要目的是测试方法之间的调用，非静态的方法可以直接调用非静态的方法，静态的方法可以直接调用静态方法

//其实方法之间的调用可以合在一个方法里面，但是过程比较复杂，思路不够清晰。两个方法之间的实参形参还有返回值都可以在一个方法中定义变量来进行代替。比如说将这两个方法改成一个方法

一个方法的核心代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public void test7() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个偶数");
        int n = sc.nextInt();
        if (n % 2 == 0) {
            
            for (int i = 1; i <= (n / 2); i++) {
                //判断i是质数，判断（n-i）是质数
                boolean flag1=true;
                boolean flag2=true;
                
                for(int j=2;j<i;j++){
                    if(i%j==0){
                        flag1=false;
                    }
                }
                
                for(int j=2;j<(n-i);j++){
                    if((n-i)%j==0){
                        flag2=false;
                    }
                }
                
                if(flag1&&flag2){
                    System.out.println(n+"="+i+"+"+(n-i));
                }

            }
        } else {
            System.out.println("对不起，你输入的不是整数。");
        }

    }

//从上面可以看出boolean的标志可以设置出来，然后再在后面进行判断，也间接说明，两个方法揉成一个方法和一个方法拆成两个方法是互相可逆的

实例7：

菲波那切数列：1,1,2,3,5，8……..

已知项数求具体的值。

思路：

1.递归

2.不用递归，可以是数组，也可以不使用数组

使用递归的核心代码：

1
2
3
4
5
6
7
8
9
10
11
/**
     * 菲波那切数列的递归求解
     * */
    public int  test10(int n){
        int result=1;
        
        if(n>2){
            result=test10(n-1)+test10(n-2);
        }
        return result;
    }

不使用递归的核心代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/**
     * 不用递归求菲波那切数列：
     * 1,1,2,3,5,8..... 
     * f s t 
     *   f s t 
     *     f s t
     * 
     */
    public int test7(int n) {
        int f = 1, s = 1, t = 1;

        if (n > 2) {
            for (int i = 3; i <= n; i++) {
                f = s;
                s = t;
                t = f + s;
            }
            return t;
        } else {
            return f;
        }
    }

实例8：

台阶问题：一个人上上台阶，可以一次上1阶，也可以一次上2阶，有n阶台阶，求有多少种上法
     * 
     * 分析： 【1】1 【2】2 【3】3 【4】5 【5】8 【6】13 【7】21 【8】34
     * 
     * 通过观察可以发现：是菲波那切数列的变种，可以通过递归和不用递归的方法来做，只要将规律传递下去就行了。
     *  1,2,3,5,8,13,21 
     *  f s t(n=3) 
     *    f s t(n=4)
     * 使用递归实现的台阶问题解法
     */

递归实现核心代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
     * 使用递归实现的台阶问题解法
     */
    public int test8(int n) {
        int result = 1;

        if (n == 1) {
        } else if (n == 2) {
            result = 2;
        } else {
            result = test8(n - 1) + test8(n - 2);
        }
        return result;
    }

不使用递归核心代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/** 不使用递归实现的台阶问题解法 */
    public int test9(int n) {
        int result = 1;

        int f = 1, s = 2, t = 3;
        if (n > 2) {
            for (int i = 4; i <= n; i++) {
                f=s;
                s=t;
                t=f+s;
                result=t;
            }
        }else if(n==1){
            result=f;
        }else if(n==2){
            result=s;
        }else{
            result=t;
        }
        return result;
    }

实例9：

题目：将一个正整数分解质因数。例如：输入90,打印出90=233*5。 

较为高级的实现核心代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package com.gongsi.xiexi2;

import java.util.Scanner;

public class Ys {
public static void main(String[] args) {
Scanner bi=new Scanner(System.in);
System.out.println("请输入一个要分解的数");
int a=bi.nextInt();
System.out.print(a+"=");
if(a>2){
for (int i = 2; i < a; i++) {
if(a%i==0){
System.out.print(i+"*");
a=a/i;
i-=1;
}
}
System.out.print(a);
}
else {
System.out.print(a);
}
}
}

我的复杂的思维方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/**
     * 题目：将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5。
     */
    public void test13(int n) {
        for (int i = 2; i < n; i++) {
            if (test14(i) && n % i == 0) {
                int a = i;
                int b = n / a;
                System.out.print("*" + a);
                if (test14(b)) {
                    System.out.print("*" + b);
                    break;
                } else {
                    test13(b);
                    break;
                }
            }
        }
    }

    // 判断是不是质数
    public boolean test14(int n) {
        for (int i = 3; i < n; i += 2) {
            if (n % i == 0) {
                return false;
            }
        }
        return true;
    }

实例10：

水仙花数问题

核心代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public void test3() {
        // a*100+b*10+c=a*a*a+b*b*b+c*c*c
        //
        int a = 0, b = 0, c = 0;
        // int n=a*100+b*10+c;
        for (int i = 100; i < 1000; i++) {
            a = i / 100;
            b = (i - 100 * a) / 10;// b=i%100/10;
            c = i - 100 * a - 10 * b;// c=i%10;
            if (i == a * a * a + b * b * b + c * c * c) {
                System.out.println(i + "这个数是水仙花数。");
            }
        }

    }
  • 本文标题：2017-03-08-switch判断某一年的某天是这一年的第几天
  • 本文作者：Xplorist
  • 创建时间：2017-03-08 14:23:01
  • 本文链接：https://xplorist.tech/2017/03/08/f4b8bbff9f29/
  • 版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
 评论