/*
需求：用户任意输入一个年份，判断十二生肖中的那一年；
思路：利用取余运算，根据余数进行推导；
      2008年是鼠年；2008\12=167...4;所以公元1年是鸡年；公元前怎么办？下边是我的程序
*/
import java.util.Scanner;
class ShengXiao1{
        public static void main(String[] args){
                System.out.println("请输入一个年份");
                Scanner x=new Scanner(System.in);
                int n=x.nextInt();
                switch(n % 12){
                        case -9:
                        case 4:
                                System.out.println(n+"年是鼠年");
                                break;
                        case -8:
                        case 5:
                                System.out.println(n+"年是牛年");
                                break;
                        case -7:
                        case 6:
                                System.out.println(n+"年是虎年");
                                break;
                        case -6:
                        case 7:
                                System.out.println(n+"年是兔年");
                                break;
                        case -5:
                        case 8:
                                System.out.println(n+"年是龙年");
                                break;
                        case -4:
                        case 9:
                                System.out.println(n+"年是蛇年");
                                break;
                        case -3:
                        case 10:
                                System.out.println(n+"年是马年");
                                break;
                        case -2:
                        case 11:
                                System.out.println(n+"年是羊年");
                                break;
                        case -1:
                        case 0:
                                System.out.println(n+"年是猴年");
                                break;
                        //case 0:
                        case 1:
                                System.out.println(n+"年是鸡年");
                                break;
                        case -11:
                        case 2:
                                System.out.println(n+"年是狗年");
                                break;
                        case -10:
                        case 3:
                                System.out.println(n+"年是猪年");
                                break;
                        default:
                                System.out.println("您输入的数据有误！");
                                break;

                        }

        }
}

版主你好，我来黑马论坛没多久，我的这个帖子问题已经解决了，可以换成，已解决了 谢谢，具体我还要做什么吗？

嗯，已经完成了

神之梦 发表于 2013-7-12 18:58
俩大神继续讨论

谢谢你的技术分 太感谢了！

闲人忙啊 发表于 2013-7-12 21:50
因为公元没有0,所以只要把负数都+1,符合正常数字的规律就可以解决当公元年为负数时,负数模12等于0与正数模1 ...

这个思想牛！负数都加1，正好抵掉了那个误差。恩 不错，人多就是力量大！谢谢了
还有其他办法吗各位？？

file:///C:/Users/hero/Desktop/1.JPG
运行结果。。。。。。
还不行！！！！不过思想我懂了 办法还行！有点偏门 呵呵 谢了

因为公元没有0,所以只要把负数都+1,符合正常数字的规律就可以解决当公元年为负数时,负数模12等于0与正数模12等于0不匹配的问题了.希望可以帮助到你!

1. import java.util.Scanner;
   
2. class ShengXiao1{
   
3.         public static void main(String[] args){
   
4.                 System.out.println("请输入一个年份");
   
5.                 Scanner x=new Scanner(System.in);
   
6.                 int n=x.nextInt();
   
7.                                 if (n<=0) {
   
8.                                         n+=1;
   
9.                                 }
   
10.                                         switch(n % 12){
    
11.                                                 case -11:
    
12.                                                 case 1:
    
13.                                                                 print(n);
    
14.                                 System.out.println("年是鸡年");
    
15.                                 break;
    
16.                         case -10:
    
17.                         case 2:
    
18.                                 print(n);
    
19.                                                                 System.out.println("年是狗年");
    
20.                                 break;
    
21.                         case -9:
    
22.                         case 3:
    
23.                                                                 print(n);
    
24.                                 System.out.println("年是猪年");
    
25.                                 break;
    
26.                         case -8:
    
27.                         case 4:
    
28.                                                                 print(n);
    
29.                                 System.out.println("年是鼠年");
    
30.                                 break;
    
31.                         case -7:
    
32.                         case 5:
    
33.                                                                 print(n);
    
34.                                 System.out.println("年是牛年");
    
35.                                 break;
    
36.                         case -6:
    
37.                         case 6:
    
38.                                                                 print(n);
    
39.                                 System.out.println("年是虎年");
    
40.                                 break;
    
41.                         case -5:
    
42.                         case 7:
    
43.                                                                 print(n);
    
44.                                 System.out.println("年是兔年");
    
45.                                 break;
    
46.                         case -4:
    
47.                         case 8:
    
48.                                                                 print(n);
    
49.                                 System.out.println("年是龙年");
    
50.                                 break;
    
51.                         case -3:
    
52.                         case 9:
    
53.                                                                 print(n);
    
54.                                 System.out.println("年是蛇年");
    
55.                                 break;
    
56.                         case -2:
    
57.                         case 10:
    
58.                                                                 print(n);
    
59.                                 System.out.println("年是马年");
    
60.                                 break;
    
61.                         case -1:
    
62.                         case 11:
    
63.                                                                 print(n);
    
64.                                 System.out.println("年是羊年");
    
65.                                 break;
    
66.                         case 0:
    
67.                                                                 print(n);
    
68.                                 System.out.println("年是猴年");
    
69.                                 break;
    
70.                        
    
71.                         default:
    
72.                                 System.out.println("您输入的数据有误！");
    
73.                                 break;
    
74. 
    
75.                         }
    
76.         }
    
77.                 public static void print(int n){
    
78.                         if (n<=0) {
    
79.                                 n-=1;
    
80.                         }
    
81.                         System.out.print(n);
    
82.                        
    
83.                 }
    
84. }

复制代码

云游天下 发表于 2013-7-12 18:38
你好，你没理解我的问题的，比如公元12年和公元前12年取余数都是0，但公元12年是猴年，公元前12年是鸡年
...

那不是很简单吗？单独用一个变量y记录%12的结果，如果是公元前，-12的倍数%12都是0，那你就判断如果%12=0，那么y=-12,以后遇到-12的都是公元前的，代码也很简单，不知道这下给你解决了没！！！

1. import java.util.Scanner;
   
2. class ShengXiao1 {
   
3.     public static void main(String[] args){
   
4.         System.out.println("请输入有效年份");
   
5.         Scanner x = new Scanner(System.in);
   
6.         int n = x.nextInt();
   
7.         if(n==0)
   
8.             System.out.println("输入的不是有效年份，请重新输入");
   
9.         else{
   
10.             int y = n % 12;
    
11.             if (n<0 && n % 12 == 0)
    
12.                     y = -12;
    
13.             switch(y){
    
14.                 case -9:
    
15.                 case 4:
    
16.                     System.out.println(n+"年是鼠年");
    
17.                     break;
    
18.                 case -8:
    
19.                 case 5:
    
20.                     System.out.println(n+"年是牛年");
    
21.                     break;
    
22.                 case -7:
    
23.                 case 6:
    
24.                     System.out.println(n+"年是虎年");
    
25.                     break;
    
26.                 case -6:
    
27.                 case 7:
    
28.                     System.out.println(n+"年是兔年");
    
29.                     break;
    
30.                 case -5:
    
31.                 case 8:
    
32.                     System.out.println(n+"年是龙年");
    
33.                     break;
    
34.                 case -4:
    
35.                 case 9:
    
36.                     System.out.println(n+"年是蛇年");
    
37.                     break;
    
38.                 case -3:
    
39.                 case 10:
    
40.                     System.out.println(n+"年是马年");
    
41.                     break;
    
42.                 case -2:
    
43.                 case 11:
    
44.                     System.out.println(n+"年是羊年");
    
45.                     break;
    
46.                 case -1:
    
47.                 case 0:
    
48.                     System.out.println(n+"年是猴年");
    
49.                     break;
    
50.                     case -12:
    
51.                 case 1:
    
52.                     System.out.println(n+"年是鸡年");
    
53.                     break;
    
54.                 case -11:
    
55.                 case 2:
    
56.                     System.out.println(n+"年是狗年");
    
57.                     break;
    
58.                 case -10:
    
59.                 case 3:
    
60.                     System.out.println(n+"年是猪年");
    
61.                     break;
    
62.                 default:
    
63.                     System.out.println("您输入的数据有误！");
    
64.                     break;
    
65.             }
    
66.         }
    
67.     }
    
68. }

复制代码

俩大神继续讨论{:soso_e179:}

Jiewin 发表于 2013-7-11 23:50
最简单的判断就是n==0就提示错误，否则就执行switch，懂了吗，这样输入的0和%12得到的0就不冲突了。
如果 ...

你好，你没理解我的问题的，比如公元12年和公元前12年取余数都是0，但公元12年是猴年，公元前12年是鸡年
有办法解决吗？谢谢

云游天下 发表于 2013-7-11 22:42
意思是判断输入的值正负以后再各进行一次switch判断？我上边程序中是公元前后一起算在0年处出现了bug了。公 ...

最简单的判断就是n==0就提示错误，否则就执行switch，懂了吗，这样输入的0和%12得到的0就不冲突了。
如果你想要限制一个范围，或判断输入的是不是有效年份，比如别人输入2013aaa，这样的就不是有效年份，你可以用正则表达式判断，但这里你只是打印到控制台演示一下，没必要那么精确，下面的代码我只加了一个判断语句，如果输入的是0就提示用户后不再执行下面的语句，否则就执行switch的语句。我觉得你的控制流程没有看明白。

1. import java.util.Scanner;
   
2. class ShengXiao1 {
   
3.     public static void main(String[] args){
   
4.         System.out.println("请输入有效年份");
   
5.         Scanner x = new Scanner(System.in);
   
6.         int n = x.nextInt();
   
7.         if(n==0)
   
8.             System.out.println("输入的不是有效年份，请重新输入");
   
9.         else{
   
10.             switch(n % 12){
    
11.                 case -9:
    
12.                 case 4:
    
13.                     System.out.println(n+"年是鼠年");
    
14.                     break;
    
15.                 case -8:
    
16.                 case 5:
    
17.                     System.out.println(n+"年是牛年");
    
18.                     break;
    
19.                 case -7:
    
20.                 case 6:
    
21.                     System.out.println(n+"年是虎年");
    
22.                     break;
    
23.                 case -6:
    
24.                 case 7:
    
25.                     System.out.println(n+"年是兔年");
    
26.                     break;
    
27.                 case -5:
    
28.                 case 8:
    
29.                     System.out.println(n+"年是龙年");
    
30.                     break;
    
31.                 case -4:
    
32.                 case 9:
    
33.                     System.out.println(n+"年是蛇年");
    
34.                     break;
    
35.                 case -3:
    
36.                 case 10:
    
37.                     System.out.println(n+"年是马年");
    
38.                     break;
    
39.                 case -2:
    
40.                 case 11:
    
41.                     System.out.println(n+"年是羊年");
    
42.                     break;
    
43.                 case -1:
    
44.                 case 0:
    
45.                     System.out.println(n+"年是猴年");
    
46.                     break;
    
47.                 //case 0:
    
48.                 case 1:
    
49.                     System.out.println(n+"年是鸡年");
    
50.                     break;
    
51.                 case -11:
    
52.                 case 2:
    
53.                     System.out.println(n+"年是狗年");
    
54.                     break;
    
55.                 case -10:
    
56.                 case 3:
    
57.                     System.out.println(n+"年是猪年");
    
58.                     break;
    
59.                 default:
    
60.                     System.out.println("您输入的数据有误！");
    
61.                     break;
    
62.             }
    
63.         }
    
64.     }
    
65. }

复制代码

意思是判断输入的值正负以后再各进行一次switch判断？我上边程序中是公元前后一起算在0年处出现了bug了。公元一年是鸡年，公元前一年是猴年，但公元12年和公元前12年余数都是0，但一个是猴年，另一个是鸡年，这个没法啊

公园前用负数表示是对的啊，如果你问公元前和公元后之间没有0年，这里输入的0和n%12产生的0是可以判断的，那你在进入switch语句之前，就先判断输入的是不是0就可以了，如果n等于0，就不要进入switch语句，这样就不会冲突了。

公元前后之间没有公元零年 所以余数有冲突怎么办？？？？