黑马程序员技术交流社区

标题: 周末答题有奖之二------答题贴 [打印本页]
作者: 刘胜寒    时间: 2013-5-17 19:27
标题: 周末答题有奖之二------答题贴
本帖最后由 刘胜寒 于 2013-6-5 17:12 编辑

[fly][fly]写在别处不给分的哦！！[/fly][/fly]

题目链接：http://bbs.itheima.com/thread-50510-1-1.html



不要使用压缩包。。。
你们要累死版主也不是这个玩法啊。。。

结贴时间为周日晚八点。。。
六点之后的所有回答一律不予考虑。。。
作者: 刘胜寒    时间: 2013-5-17 19:32
题目正在酝酿中？？
作者: HM张博文    时间: 2013-5-17 19:45
题目还没出好么？
作者: HM张博文    时间: 2013-5-17 19:45
题目还没出好么？
作者: 8047107    时间: 2013-5-17 20:19
都不知道题目是哪个了 一个7天前的 一个是半小时前的 晕了
作者: joker_chan    时间: 2013-5-17 20:31
额不用压缩包用什么额。

GoldPartition.zip

1.07 KB, 阅读权限: 100, 下载次数: 1
作者: 吴文彬    时间: 2013-5-17 21:27
package cn.itcast.day01;

import java.util.Scanner;

public class Main {
        public static void main(String[] args) {
                int n;
                int[] normal_day = {31,28,31,30,31,30,31,31,30,31,30,31};
                int[] leap_day = {31,29,31,30,31,30,31,31,30,31,30,31};
                Scanner cin = new Scanner(System.in);
                while(cin.hasNext()){//判断是否还有一下个输入
                        int[] ans = new int[7]; //ans数组 记录星期几对应有几天。
                        n = cin.nextInt();
                        int total_day = 13; //距离1900年1月1日的天数.
                        ans[(total_day + 1)% 7]++;//先计算1900年，1月13号是周几，并且记录。
                        for(int i = 0; i < n; i++){//第几年。。。
                                if(isLeapYear(1900 + i)) { //如果是闰年的话，按照二月29天计算
                                        for(int j = 0; j < 12; j++){//第几月。。
                                                total_day += leap_day[j];
                                                ans[(total_day + 1)% 7]++;//记录这个月的十三号是星期几,在相应的数组变量自增1
                                        }
                                }
                                else {//如果不是闰年，按照二月28天计算
                                        for(int j = 0; j < 12; j++) {
                                                total_day += normal_day[j];
                                                ans[(total_day + 1) % 7]++;
                                        }
                                }
                        }
                       
                        printAns(ans); //打印答案。
                }
        }
       
        public static void printAns(int[] answer) {
                for(int i = 0; i < 6; i++){
                        System.out.print(answer[i] + " ");
                }
                System.out.println(answer[6]);
        }
       
        public static boolean isLeapYear(int year){//判断是否是闰年
                if(year%400 == 0 || year%100 != 0 && year % 4 == 0) return true;
                else return false;
        }
}


作者: littlefoxtail    时间: 2013-5-17 21:37
  1. import java.io.*;
  2. public class DoSomeThing {
  3.        
  4. /**
  5. *写一个程序来计算在n年里13日落在星期一,星期二......星期日的次数.
  6. 这个测试从1900年1月1日到1900+n-1年12月31日.n是一个非负数且不大于400.
  7. 这里有一些你要知道的:1900年1月1日是星期一.

  9. 样例输入：
  10. 20
  11. 样例输出：
  12. 36 33 34 33 35 35 34
  13. */
  14.         public static void main(String[] args) throws IOException{
  15.                 // TODO Auto-generated method stub
  16.                 int a[]={0,31,59,90,120,151,181,212,243,273,304,334};//平年每个月份1日到1月1日的天数
  17.                 int b[]={0,31,60,91,121,152,182,213,244,274,305,335};//闰年每个月份1日到1月1日的天数
  18.                 int []s=new int[7];//存储星期数
  19.                 int []m=new int[400];
  20.                 int n=0,i,j;
  21.                 String line=null;
  22.                 BufferedReader bfrd=new BufferedReader(new InputStreamReader(System.in));
  23.                 while((line=bfrd.readLine())!=null){       
  24.                         n=Integer.parseInt(line);
  25.                         break;
  26.                 }
  27.                 for(i=1900;i<1900+n;i++){
  28.                         m[i-1899]=dayOfYear(i)+m[i-1900];//计算i年一月一日到1990年一月一日的天数，分别存储到m集合中
  29.                         if(leapYear(i))
  30.                                 for(j=0;j<12;j++)
  31.                                         s[(b[j]+13+m[i-1900])%7]++;//闰年（i年j月13号到1990年一月一日的天数）余7
  32.                         else
  33.                                 for(j=0;j<12;j++)
  34.                                     s[(a[j]+13+m[i-1900])%7]++;//平年（i年j月13号到1990年一月一日的天数）余7
  35.                 }
  36.                 System.out.println(s[6]);//星期六
  37.                 System.out.println(s[0]);//星期天
  38.                 for(i=1;i<5;i++){
  39.                         System.out.println(s[i]);//星期一~五
  40.                 }
  41.                
  42.                
  43.                
  44.         }
  45.         public static boolean  leapYear(int n)//判断某一年是否为闰年
  46.         {
  47.                 if(n%4==0&&n%100!=0)
  48.                         return true;
  49.                 if(n%400==0)
  50.                         return true;
  51.                 return false;
  52.         }
  53.         public static int dayOfYear(int n)//获取某一年的天数
  54.         {
  55.                 if(leapYear(n))
  56.                 {
  57.                         return 366;
  58.                 }
  59.                 else
  60.                         return 365;
  61.         }

  63. }
复制代码
作者: 徐启坤    时间: 2013-5-17 21:46
结果跟样例输出好像有一点不一样，样例好像是把星期六和星期天放前面了
还有版主不让用压缩包，但又不能直接上传Java文件，所以我就直接贴上源代码了如下
  1. import java.util.Scanner;
  2. public class text{
  3.          public static void week(int n)         //将计算方法封装进week函数
  4.          {
  5.                  int num[]={0,0,0,0,0,0,0,0},year=1900,day=13;        //预定义存放结果的数组，
  6.                  int month[]={31,0,31,30,31,30,31,31,30,31,30,31};     //一年中除了二月的不确定性，其他月份的天数固定
  7.                  
  8.                 //循环计算每一年中里13日落在星期一,星期二......星期日的次数.
  9.          for(int i=0;i<n;i++)                                 
  10.          {
  11.              if((year%4==0)&&(year%100!=0)||year%400==0)     //判断当年是闰年还是平年，确定二月的天数
  12.                      
  13.                      month[1]=29;
  14.              else
  15.                      month[1]=28;
  16.             
  17.              for(int j=0;j<12;j++)  
  18.              {
  19.               num[day%7]+=1;      //day从13开始累计每月的天数，对7取余即为当天的星期数，特殊的余数为0时为星期七，对应的结果数组项加1
  20.               day+=month[j];
  21.              }
  22.              year++;
  23.          }
  24.          System.out.printf("从星期一到星期天依次为：\n"+num[1]+" "+num[2]+" "+num[3]+" "+num[4]+" "+num[5]+" "+num[6]+" "+num[0]);
  25.          }
  26.      public static void main(String args[])
  27.      {
  28.          int n;
  29.          Scanner in = new Scanner(System.in);
  30.          System.out.printf("请输入整数n：");
  31.          n=in.nextInt();
  32.          week(n);        //调用week()函数，输出结果
  33.      }
  34. }
复制代码
作者: 王靖远    时间: 2013-5-17 22:00
class ZhuanFen
{
        public static void main(String[] args)
        {
                //定义变量用来记录每个星期出现在13号的次数
                int x1 = 0;
                int x2 = 0;
                int x3 = 0;
                int x4 = 0;
                int x5 = 0;
                int x6 = 0;
                int x7 = 0;
               
                int first = 1;//定义一个变量记录每个月1号星期数，初始值为1900年1月1日的星期数
                int count = 0;//定义一个变量记录每个月13号星期数，初始值为0
               
                for (int n=1;n<=20;n++)//控制年数
                {
                        if(n%4 != 0)//判断是否为闰年
                        {
                                for(int a=1;a<=12;a++)//对每个月的13号和下个月1号进行循环记录
                                {
                                        count = (first+12)%7;//计算每个月的13日的星期数
                                       
                                       
                                        switch(a)//计算每个月的第一天的星期数
                                        {
                                        case 1 :
                                        case 3 :
                                        case 5 :
                                        case 7:
                                        case 8:
                                        case 10:
                                        case 12:
                                                first =(30+first)%7;
                                                break;
                                        case 2:
                                                first =(27+first)%7;
                                                break;
                                        case 4 :
                                        case 6 :
                                        case 9 :
                                        case 11 :
                                                first = (29+first)%7;
                                                break;
                                        }
                                       
                                        switch(count)//记录13日出现在每个星期的次数
                                        {
                                        case 1:
                                                x1++;
                                                break;
                                        case 2:
                                                x2++;
                                                break;
                                        case 3:
                                                x3++;
                                                break;
                                        case 4:
                                                x4++;
                                                break;
                                        case 5:
                                                x5++;
                                                break;
                                        case 6:
                                                x6++;
                                                break;
                                        case 0:
                                                x7++;
                                                break;
                                        }
                                }
                        }
                        else
                        {
                                for(int a=1;a<=12;a++)
                                {
                                        count = (first+12)%7;
                                       
                                       
                                        switch(a)
                                        {
                                        case 1 :
                                        case 3 :
                                        case 5 :
                                        case 7:
                                        case 8:
                                        case 10:
                                        case 12:
                                                first =(30+first)%7;
                                                break;
                                        case 2:
                                                first =(28+first)%7;
                                                break;
                                        case 4 :
                                        case 6 :
                                        case 9 :
                                        case 11 :
                                                first = (29+first)%7;
                                                break;
                                        }
                                       
                                        switch(count)
                                        {
                                        case 1:
                                                x1++;
                                                break;
                                        case 2:
                                                x2++;
                                                break;
                                        case 3:
                                                x3++;
                                                break;
                                        case 4:
                                                x4++;
                                                break;
                                        case 5:
                                                x5++;
                                                break;
                                        case 6:
                                                x6++;
                                                break;
                                        case 0:
                                                x7++;
                                                break;
                                        }
                                }
                        }
                }
               
               
               
               
                System.out.println("13日落在星期一次数"+x1);
                System.out.println("13日落在星期二次数"+x2);
                System.out.println("13日落在星期三次数"+x3);
                System.out.println("13日落在星期四次数"+x4);
                System.out.println("13日落在星期五次数"+x5);
                System.out.println("13日落在星期六次数"+x6);
                System.out.println("13日落在星期七次数"+x7);
               
        }
}
作者: 王靖远    时间: 2013-5-17 22:33
我给代码修正下再贴上来。。。我感觉样例的答案是错的。 判断是否为闰年应该用n-1模上4去判断是否结果为0.
class ZhuanFen
{
        public static void main(String[] args)
        {
                //定义变量用来记录每个星期出现在13号的次数
                int x1 = 0;
                int x2 = 0;
                int x3 = 0;
                int x4 = 0;
                int x5 = 0;
                int x6 = 0;
                int x7 = 0;
               
                int first = 1;//定义一个变量记录每个月1号星期数，初始值为1900年1月1日的星期数
                int count = 0;//定义一个变量记录每个月13号星期数，初始值为0
               
                for (int n=1;n<=20;n++)//控制年数
                {
                        if((n-1)% 4 != 0)//判断是否为闰年 这里得用n-1不能误用n。
                        {
                                for(int a=1;a<=12;a++)//对每个月的13号和下个月1号进行循环记录
                                {
                                        count = (first+12)%7;//计算每个月的13日的星期数
                                       
                                       
                                        switch(a)//计算每个月的第一天的星期数
                                        {
                                        case 1 :
                                        case 3 :
                                        case 5 :
                                        case 7:
                                        case 8:
                                        case 10:
                                        case 12:
                                                first =(31+first)%7;
                                                break;
                                        case 2:
                                                first =(28+first)%7;
                                                break;
                                        case 4 :
                                        case 6 :
                                        case 9 :
                                        case 11 :
                                                first = (30+first)%7;
                                                break;
                                        }
                                       
                                        switch(count)//记录13日出现在每个星期的次数
                                        {
                                        case 1:
                                                x1++;
                                                break;
                                        case 2:
                                                x2++;
                                                break;
                                        case 3:
                                                x3++;
                                                break;
                                        case 4:
                                                x4++;
                                                break;
                                        case 5:
                                                x5++;
                                                break;
                                        case 6:
                                                x6++;
                                                break;
                                        case 0:
                                                x7++;
                                                break;
                                        }
                                }
                        }
                        else
                        {
                                for(int a=1;a<=12;a++)
                                {
                                        count = (first+12)%7;
                                       
                                       
                                        switch(a)
                                        {
                                        case 1 :
                                        case 3 :
                                        case 5 :
                                        case 7:
                                        case 8:
                                        case 10:
                                        case 12:
                                                first =(31+first)%7;
                                                break;
                                        case 2:
                                                first =(29+first)%7;
                                                break;
                                        case 4 :
                                        case 6 :
                                        case 9 :
                                        case 11 :
                                                first = (30+first)%7;
                                                break;
                                        }
                                       
                                        switch(count)
                                        {
                                        case 1:
                                                x1++;
                                                break;
                                        case 2:
                                                x2++;
                                                break;
                                        case 3:
                                                x3++;
                                                break;
                                        case 4:
                                                x4++;
                                                break;
                                        case 5:
                                                x5++;
                                                break;
                                        case 6:
                                                x6++;
                                                break;
                                        case 0:
                                                x7++;
                                                break;
                                        }
                                }
                        }
                }
               
               
               
               
                System.out.println("13日落在星期一次数"+x1);
                System.out.println("13日落在星期二次数"+x2);
                System.out.println("13日落在星期三次数"+x3);
                System.out.println("13日落在星期四次数"+x4);
                System.out.println("13日落在星期五次数"+x5);
                System.out.println("13日落在星期六次数"+x6);
                System.out.println("13日落在星期七次数"+x7);
               
        }
}
作者: 占琳    时间: 2013-5-17 23:23
import java.util.Calendar;
import java.util.Scanner;

public class Test {
        public static void main(String[] args) {
                Scanner scan = new Scanner(System.in);
                System.out.println("请输入你要查找几年里13日落在星期一,星期二......星期日的次数");
                int n = scan.nextInt();
                // 判断输入年份是否为正数且小于400在执行以下语句
                if (n > 0 && n <= 400) {
                        Calendar c = Calendar.getInstance();
                        // 用来代表周日到周六
                        int[] counts = new int[7];
                        c.set(1900, 0, 13);// 将时间设置为1900年1月13日，注意0代表1月
                        do {
                                // 代表每次增加1个月，比如1900-01-13下个月是1900-02-13
                                c.add(Calendar.MONTH, 1);
                                // 获取这天是周几，但要注意，周日是1，周六是7
                                int i = c.get(Calendar.DAY_OF_WEEK);
                                // 如果是0周日，则0位置+1，1周一，位置1,+1，类推
                                counts[i - 1]++;
                                // 循环条件，只要年是小于定义1900+n就行
                        } while (c.get(Calendar.YEAR) < 1900 + n);

                        // 打印
                        for (int i = 0; i < counts.length; i++) {
                                System.out.print(counts + " ");
                        }
                } else {
                        System.out.println("输入错误，下次请输入正数且不大于400");
                }
        }
}
作者: 丘凤光    时间: 2013-5-17 23:58
很遗憾没有得你那个结果，觉得思路并没有错，不知道错在哪里，劳烦查看查看
  1. package day3;

  3. import java.util.Calendar;

  5. public class Weekday13 {

  7.         /**
  8.          * @param args
  9.          * 题目：
  10.          * 13号又是星期五是一个不寻常的日子吗?
  11.          * 13号在星期五比在其他日少吗?为了回答这个问题,
  12.          * 写一个程序来计算在n年里13日落在星期一,星期二......星期日的次数.
  13.          * 这个测试从1900年1月1日到1900+n-1年12月31日.n是一个非负数且不大于400.
  14.          * 这里有一些你要知道的:1900年1月1日是星期一.
  15.          * 样例输入：
  16.          * 20
  17.          * 样例输出：
  18.          * 36 33 34 33 35 35 34
  19.          *
  20.          *
  21.          * 思路：
  22.          * 1、用两个for循环来分别控制年月的改变
  23.          * 2、设置日历日期为某年某月13号
  24.          * 3、获取该日历对应的星期
  25.          * 4、统计打印
  26.          *
  27.          *
  28.          * *~*很郁闷的是没有得出和你一样的结果，感觉思路没什么错，有劳帮我查看查看错在哪了哈*~*
  29.          */
  30.         public static void main(String[] args) {
  31.                 //调用13号落在各个星期的次数统计函数
  32.                 int[] weekday=weekdayCount(20);
  33.                 //默认打印的顺序为星期天、星期一、星期二、……、星期六；为符合题目要求，只打印对应次数
  34.                 for(int count:weekday){
  35.                         System.out.print(count+"\t");
  36.                 }
  37.         }
  38.         //统计n年中13号落在各个星期的次数
  39.         public static int[] weekdayCount(int n){
  40.                 //建立一个数组存放各个星期次数，星期日对应的角标为0，以此类推
  41.                 int[] weekday=new int[7];
  42.                 //建立日历对象
  43.                 Calendar calendar=Calendar.getInstance();
  44.                 //第一个for循环控制年的改变
  45.                 for(int year=1900;year<1900+n;year++){
  46.                         //第二个for循环控制月份的改变
  47.                         for(int month=1;month<=12;month++){
  48.                                 //设置日历为year年month月的13号
  49.                                 calendar.set(year, month, 13);
  50.                                 //获取当前日历（即设置的某年某月的13号）的星期数，对应的星期自增（即+1）
  51.                                 //因为获取的星期数为1到7且对应星期日、星期一、……星期六，所以-1刚好和定义的数组对应
  52.                                 weekday[calendar.get(Calendar.DAY_OF_WEEK)-1]++;
  53.                         }
  54.                 }
  55.                 return weekday;
  56.         }

  58. }
  59.                
复制代码
{:soso_e113:}
作者: 丘凤光    时间: 2013-5-18 00:02
老刘，你确定你题目上的例子的输出是正确的吗？
我看我那个写的简洁明了的，不像有错呢
作者: 黑马-许鹏    时间: 2013-5-18 03:28
  1. /*
  2. 题目描述：
  3. 13号又是星期五是一个不寻常的日子吗?
  4. 13号在星期五比在其他日少吗?为了回答这个问题,
  5. 写一个程序来计算在n年里13日落在星期一,星期二......星期日的次数.
  6. 这个测试从1900年1月1日到1900+n-1年12月31日.n是一个非负数且不大于400.
  7. 这里有一些你要知道的:1900年1月1日是星期一.

  9. 样例输入：
  10. 20
  11. 样例输出：
  12. 36 33 34 33 35 35 34
  13. */
  14. import java.util.*;
  15. class CalendarTest
  16. {
  17.         public static void main(String[] args)
  18.         {
  19.                
  20.                 show(20);

  22.         }
  23.         public static void show(int y)//定义一个方法，用来打印，参数是年数
  24.         {
  25.                 //由于Calendar是一个抽象类，只能用getInstance()获取实例
  26.                 Calendar c=Calendar.getInstance();
  27.                 //设置时期到1900年1月13日，注意Calendar中0表示一月份。
  28.                 c.set(1900,0,13);
  29.                 int[] week=new int[7];//建立一个数组里面放星期一到星期日的数值
  30.                 int index;
  31.                 for(int i=0;i<7;i++)  //for循环初始化数组
  32.                         week[i]=0;
  33.                 //for循环y*12次，如果是该月的13号是星期几，数组对应的角标的值加1
  34.                 for(int x=0;x<y*12;x++)
  35.                 {       
  36.                         //get(Calendar.DAY_OF_WEEK)返回的是星期中的某天，
  37.                         //1是星期日，2是星期一以此类推，所以加5模7可以保证星期一对应的0角标。
  38.                         index=(c.get(Calendar.DAY_OF_WEEK)+5)%7;
  39.                         //是星期几就在数组角标对应的值加1
  40.                         week[index]++;
  41.                         //月加1准备下一次循环。
  42.                         c.add(Calendar.MONTH,1);
  43.                 }
  44.                 //打印数值中的值
  45.                 for(int i=0;i<7;i++)
  46.                 {
  47.                         System.out.print(week[i]+"   ");
  48.                 }
  49.         }
  50.        
  51. }
复制代码
运行结果：
34   33   35   35   34   36   33

版主的样例输出：
36 33 34 33 35 35 34

呵呵，您是从星期六--星期五这样打印的吗
作者: 刘胜寒    时间: 2013-5-18 03:42
8047107 发表于 2013-5-17 20:19
都不知道题目是哪个了 一个7天前的 一个是半小时前的 晕了

出好了。。。
作者: 钟林杰    时间: 2013-5-18 07:04
  1. /*

  3. 我分析了并测试了一段时间，觉得我的程序并没有写错，就是运行不出你说的这个结果，如果方便的话给我解释一下我哪里错了吗？

  5. 说明两点：
  6.         1、在程序开始编写前我测试了1900年1月1日，返回的DAY_OF_WEEK的值是7，说明7代表的是星期一。
  7.         2、由于现在这个程序要测试的是13号每个月出现在星期中的第几天，所以我设置初始的时间为1900年1月13号，每次只需要自增月的时间就可以判断13号在每个月中的第几天了。
  8.         3、我打印出来的结果是从星期一排序的。
  9. */
  10. import java.util.*;
  11. import javax.swing.*;
  12. class Exam
  13. {
  14.         public static void main(String args[])
  15.         {
  16.                         //调用输入窗口让用户输入一个值
  17.                         String s =(String)JOptionPane.showInputDialog("请输入一个0~400的整数：");
  18.                        
  19.                         int i = Integer.parseInt(s);
  20.                        
  21.                         //调用getdays方法返回一个数组
  22.                         int days[] = getDays(i);
  23.                        
  24.                         //遍历数组
  25.                         for(int j = 0; j < days.length; j++)
  26.                         {
  27.                                 System.out.println("13号在"+i+"年中星期"+(j+1)+"出现的天数:"+days[j]);
  28.                         }
  29.         }
  30.         public static int[] getDays(int n)
  31.         {
  32.                
  33.                         //用一个数组记录每个年13号在星期几出现的次数
  34.                         int days[] = new int[7];
  35.                
  36.                         if(n>400||n<0)
  37.                         {
  38.                                 System.out.println("输入日期错误，请重新输入");
  39.                         }
  40.                         else
  41.                         {
  42.                        
  43.                                
  44.                                 //结束计算的日期
  45.                                 Date endDate = new Date(1900+(n-1),12,31);
  46.                                
  47.                                 //开始计算的日期
  48.                                 Date startDate = new Date(1900,1,13);
  49.                                
  50.                                 //创建两个Calendar类操作日期
  51.                                 Calendar startTime = Calendar.getInstance();
  52.                                 Calendar endTime = Calendar.getInstance();
  53.                                
  54.                                 //设置日期的时间
  55.                                 startTime.setTime(startDate);
  56.                                 endTime.setTime(endDate);
  57.                                        
  58.                                 //定义一个变量记录每次13号出现在某天
  59.                                 int day13 = 0;
  60.                                
  61.                                 while(startTime.compareTo(endTime) <= 0)
  62.                                 {
  63.                                         //将13号在这一周的第几天记录下来
  64.                                         day13 = startTime.get(Calendar.DAY_OF_WEEK);
  65.                                        
  66.                                        
  67.                                         //利用while循环累加记录13号月出现在星期几的次数
  68.                                         switch(day13)
  69.                                         {
  70.                                                 case 7://星期一
  71.                                                                                
  72.                                                                                 days [0] += 1;
  73.                                                                                 break;
  74.                                                 case 1:
  75.                                                                                 //星期二
  76.                                                                                 days [1] += 1;
  77.                                                                                 break;
  78.                                                 case 2:
  79.                                                                                 //星期三
  80.                                                                                 days [2] += 1;
  81.                                                                                 break;
  82.                                                 case 3:
  83.                                                                                 //星期四
  84.                                                                                 days [3] += 1;
  85.                                                                                 break;
  86.                                                 case 4:
  87.                                                                                 //星期五
  88.                                                                                 days [4] += 1;
  89.                                                                                 break;
  90.                                                 case 5:
  91.                                                                                 //星期六
  92.                                                                                 days [5] += 1;
  93.                                                                                 break;
  94.                                                 case 6:
  95.                                                                                 //星期日
  96.                                                                                 days [6] += 1;
  97.                                                                                 break;
  98.                                         }
  99.                                        
  100.                                         //按月自加时间
  101.                                         startTime.add(Calendar.MONTH,1);
  102.                                        
  103.                                        
  104.                                 }
  105.                         }
  106.                
  107.        
  108.                 return days;
  109.         }
  110. }
复制代码
作者: joker_chan    时间: 2013-5-18 10:35
joker_chan 发表于 2013-5-17 20:31
额不用压缩包用什么额。

恩。没事。
作者: 董延京    时间: 2013-5-18 12:59
我的来了，试试喽。
  1. import java.text.ParseException;
  2. import java.text.SimpleDateFormat;
  3. import java.util.Date;
  4. import java.util.Locale;
  5. import java.util.Scanner;

  7. public class CountDays {

  9.         /**
  10.          * 13号又是星期五是一个不寻常的日子吗? 13号在星期五比在其他日少吗?为了回答这个问题,
  11.          * 写一个程序来计算在n年里13日落在星期一,星期二......星期日的次数.
  12.          * 这个测试从1900年1月1日到1900+n-1年12月31日.n是一个非负数且不大于400.
  13.          *  这里有一些你要知道的:1900年1月1日是星期一.
  14.          *
  15.          *
  16.          * 思路：知道各个日期 yyyy—MM—13，用SimpleDateFormat可以将其还原成为Date，
  17.          * 同时通过另一个Format(EEE)功能，可以将其的星期数显示出来. 通过一个数组统计即可。
  18.          */
  19.         public static void main(String[] args) {

  21.                 // 长度为七的数组，分别对应周一至周日的数目。
  22.                 int[] count = { 0, 0, 0, 0, 0, 0, 0 };

  24.                 // 在控制台通过输入获得n。
  25.                 Scanner scanner = new Scanner(System.in);
  26.                 int n = scanner.nextInt();

  28.                 // 第一个格式化的Format,可以将每个13号还原成日期类型。
  29.                 SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd");
  30.                 // 每一年。
  31.                 for (int i = 0; i < n; i++) {
  32.                         String year = String.valueOf(1900 + i);
  33.                         // 每个月。
  34.                         for (int j = 1; j < 13; j++) {
  35.                                 //每个月的十三号。
  36.                                 String ymd = year + "-" + String.valueOf(j) + "-" + "13";
  37.                                 try {
  38.                                         Date date = sf.parse(ymd);
  39.                                         count = getWeek(date, count);
  40.                                 } catch (ParseException e) {
  41.                                         System.out.println("ERROR");
  42.                                 }
  43.                         }
  44.                 }
  45.                 //按格式打印。
  46.                 print(count);

  48.         }

  50.         private static void print(int[] count) {
  51.                 for (int i = 1; i < count.length + 1; i++) {
  52.                         System.out.println("星期" + i + ":" + count[i - 1]);
  53.                 }
  54.         }

  56.         public static int[] getWeek(Date date, int[] count) {
  57.                 //将得到的日期，转换成星期的形式。
  58.                 SimpleDateFormat sf = new SimpleDateFormat("EEE", Locale.CHINA);
  59.                 String week = sf.format(date);
  60.                 if (week.equals("星期一"))
  61.                         count[0]++;
  62.                 if (week.equals("星期二"))
  63.                         count[1]++;
  64.                 if (week.equals("星期三"))
  65.                         count[2]++;
  66.                 if (week.equals("星期四"))
  67.                         count[3]++;
  68.                 if (week.equals("星期五"))
  69.                         count[4]++;
  70.                 if (week.equals("星期六"))
  71.                         count[5]++;
  72.                 if (week.equals("星期日"))
  73.                         count[6]++;
  74.                 return count;
  75.         }

  77. }
复制代码
作者: 王靖远    时间: 2013-5-18 16:55
和样例同结果的代码不过我觉得这个是错的。还是我发的上一个是正确的。
class ZhuanFen
{
        public static void main(String[] args)
        {
                //定义变量用来记录每个星期出现在13号的次数
                int x1 = 0;
                int x2 = 0;
                int x3 = 0;
                int x4 = 0;
                int x5 = 0;
                int x6 = 0;
                int x7 = 0;
               
                int first = 1;//定义一个变量记录每个月1号星期数，初始值为1900年1月1日的星期数
                int count = 0;//定义一个变量记录每个月13号星期数，初始值为0
               
                for (int n=1;n<=20;n++)//控制年数
                {
                        if(n% 4 != 0)//判断是否为闰年 这里得用n-1不能误用n。
                        {
                                for(int a=1;a<=12;a++)//对每个月的13号和下个月1号进行循环记录
                                {
                                        count = (first+12)%7;//计算每个月的13日的星期数
                                       
                                       
                                        switch(a)//计算每个月的第一天的星期数
                                        {
                                        case 1 :
                                        case 3 :
                                        case 5 :
                                        case 7:
                                        case 8:
                                        case 10:
                                        case 12:
                                                first =(31+first)%7;
                                                break;
                                        case 2:
                                                first =(28+first)%7;
                                                break;
                                        case 4 :
                                        case 6 :
                                        case 9 :
                                        case 11 :
                                                first = (30+first)%7;
                                                break;
                                        }
                                       
                                        switch(count)//记录13日出现在每个星期的次数
                                        {
                                        case 1:
                                                x1++;
                                                break;
                                        case 2:
                                                x2++;
                                                break;
                                        case 3:
                                                x3++;
                                                break;
                                        case 4:
                                                x4++;
                                                break;
                                        case 5:
                                                x5++;
                                                break;
                                        case 6:
                                                x6++;
                                                break;
                                        case 0:
                                                x7++;
                                                break;
                                        }
                                }
                        }
                        else
                        {
                                for(int a=1;a<=12;a++)
                                {
                                        count = (first+12)%7;
                                       
                                       
                                        switch(a)
                                        {
                                        case 1 :
                                        case 3 :
                                        case 5 :
                                        case 7:
                                        case 8:
                                        case 10:
                                        case 12:
                                                first =(31+first)%7;
                                                break;
                                        case 2:
                                                first =(29+first)%7;
                                                break;
                                        case 4 :
                                        case 6 :
                                        case 9 :
                                        case 11 :
                                                first = (30+first)%7;
                                                break;
                                        }
                                       
                                        switch(count)
                                        {
                                        case 1:
                                                x1++;
                                                break;
                                        case 2:
                                                x2++;
                                                break;
                                        case 3:
                                                x3++;
                                                break;
                                        case 4:
                                                x4++;
                                                break;
                                        case 5:
                                                x5++;
                                                break;
                                        case 6:
                                                x6++;
                                                break;
                                        case 0:
                                                x7++;
                                                break;
                                        }
                                }
                        }
                }
               
               
               
               
                System.out.println("13日落在星期一次数"+x1);
                System.out.println("13日落在星期二次数"+x2);
                System.out.println("13日落在星期三次数"+x3);
                System.out.println("13日落在星期四次数"+x4);
                System.out.println("13日落在星期五次数"+x5);
                System.out.println("13日落在星期六次数"+x6);
                System.out.println("13日落在星期七次数"+x7);
               
        }
}
作者: 黑马华    时间: 2013-5-18 17:28
本帖最后由 黑马华 于 2013-5-18 17:43 编辑

这是我的代码：

作者: 袁梦希    时间: 2013-5-18 17:30
黑马华 发表于 2013-5-18 17:28
这是我的代码：

黑马华的头像太帅了
作者: 黑马华    时间: 2013-5-18 17:44
是不是直接上代码？
作者: 刘林虎    时间: 2013-5-18 17:49
  1. public class Test {
  2.         public static void main(String[] args) {
  3.                 int n = 100;
  4.                 Calendar c = Calendar.getInstance();
  5.                 // 用来代表周日到周六
  6.                 int[] counts = new int[7];
  7.                 c.set(1900, 0, 13);// 将时间设置为1900年1月13日，注意0代表1月
  8.                 do {
  9.                         // 代表每次增加1个月，比如1900-01-13下个月是1900-02-13
  10.                         c.add(Calendar.MONTH, 1);
  11.                         // 获取这天是周几，但要注意，周日是1，周六是7
  12.                         int i = c.get(Calendar.DAY_OF_WEEK);
  13.                         // 如果是0周日，则0位置+1，1周一，位置1,+1，类推
  14.                         counts[i - 1]++;
  15.                         // 循环条件，只要年是小于定义1900+n就行
  16.                 } while (c.get(Calendar.YEAR) < 1900 + n);

  18.                 // 打印
  19.                 String[] strs = { "周日", "周一", "周二", "周三", "周四", "周五", "周六" };
  20.                 for (int i = 0; i < counts.length; i++) {
  21.                         System.out.println(strs[i] + "且为13日的出现次数为：" + counts[i]);
  22.                 }
  23.         }
  24. }
复制代码
作者: 刘国强    时间: 2013-5-18 19:34
  1. package abc;
  2. import java.io.BufferedReader;
  3. import java.io.InputStreamReader;


  6. public class test {

  8.        
  9.         public static void main(String[] args) throws Exception {
  10.                
  11.                 System.out.print("请输入一个不大于400的整数：");
  12.                
  13.                 BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
  14.                
  15.                 String line = bufr.readLine();
  16.                
  17.                 String reg = "\\d+";
  18.                
  19.                 //创建一个DayInfo对象，DayInfo为一个javabean，用于记录每个星期几出现的个数
  20.                 DayInfo dayInfo = new DayInfo();
  21.                
  22.                 //定义一个整形day，用于记录距离1900-1-1的天数
  23.                 int day = 0;
  24.                
  25.                 //使用正则表达式判断输入的信息时否为数字，如果不为数字，给出提示，为数字时继续进行处理
  26.                 if(line.matches(reg)){
  27.                        
  28.                         //将接受到的数据转为整形
  29.                         int n = Integer.parseInt(line);
  30.                        
  31.                         //判断接收到的数据是否为符合要求
  32.                         if(n<401){
  33.                                 int a = 1900+n-1;
  34.                                 boolean flag = false;
  35.                                 //从1900年开始，进行循环判断，判断是否为闰年，分别对闰年和非闰年进行处理
  36.                                 for(int i=1900;i<=a;i++){
  37.                                         flag = runnian(i);
  38.                                        
  39.                                        
  40.                                         if(flag){
  41.                                                 //对闰年年份进行处理
  42.                                                 //对1-12个月分别进行处理
  43.                                                 for(int j = 1;j<13;j++){
  44.                                                        
  45.                                                         //为4、6、9、11月天数为30天的月份进行处理，m代表本月13号距离1990-1-1的天数
  46.                                                         if(j==4||j==6||j==9||j==11){
  47.                                                                 int m = day+13;
  48.                                                                 int b = m%7;
  49.                                                                 add(b, dayInfo);
  50.                                                                 day=day+30;
  51.                                                         }else{
  52.                                                                
  53.                                                                 //对2月份进行处理，m代表本月13号距离1990-1-1的天数
  54.                                                                 if(j==2){
  55.                                                                        
  56.                                                                         int m = day+13;
  57.                                                                         int b = m%7;
  58.                                                                         add(b, dayInfo);
  59.                                                                         day=day+29;
  60.                                                                 }else{
  61.                                                                         //对天数为31天的月份进行处理，m代表本月13号距离1990-1-1的天数
  62.                                                                         int m = day+13;
  63.                                                                         int b = m%7;
  64.                                                                         add(b, dayInfo);
  65.                                                                         day=day+31;
  66.                                                                 }
  67.                                                         }
  68.                                                 }
  69.                                                
  70.                                         }else{
  71.                                                 //对非闰年的年份进行处理，处理方法与闰年基本相同，其中不同的为2月份
  72.                                                 for(int j = 1;j<13;j++){
  73.                                                         if(j==4||j==6||j==9||j==11){
  74.                                                                
  75.                                                                 int m = day+13;
  76.                                                                 int b = m%7;
  77.                                                                 add(b, dayInfo);
  78.                                                                 day=day+30;
  79.                                                         }else{
  80.                                                                 if(j==2){
  81.                                                                        
  82.                                                                         int m = day+13;
  83.                                                                         int b = m%7;
  84.                                                                         add(b, dayInfo);
  85.                                                                         day=day+28;
  86.                                                                 }else{
  87.                                                                        
  88.                                                                         int m = day+13;
  89.                                                                         int b = m%7;
  90.                                                                         add(b, dayInfo);
  91.                                                                         day=day+31;
  92.                                                                 }
  93.                                                         }
  94.                                                 }
  95.                                         }
  96.                                 }
  97.                                 //输出最后的结果，并对结果给出简要说明
  98.                                 System.out.println("依次为：星期六，星期日星期一，星期二，星期三，星期四，星期五");
  99.                                 System.out.println(dayInfo.getSaturday()+","+dayInfo.getSunday()+","+dayInfo.getMonday()+","+dayInfo.getTuesday()+","+dayInfo.getWednesday()+","+dayInfo.getThursday()+","+dayInfo.getFriday());


  102.                         }else{
  103.                                 System.out.println("您输入的数字过大，请输入不大于400的整数");
  104.                         }
  105.                 }else{
  106.                         System.out.println("您输入的不是整数");
  107.                 }
  108.                
  109.                
  110.                
  111.                
  112.         }
  113.        
  114.        
  115.         //判断年份是否为闰年，如果未闰年，返回true，否则返回false
  116.         public static boolean runnian(int n){
  117.                
  118.                 if(n==2000){
  119.                         return true;
  120.                 }else{
  121.                         if(n==1900){
  122.                                 return false;
  123.                         }else{
  124.                                 if(n==2100){
  125.                                         return false;
  126.                                 }else{
  127.                                         if(n==2200){
  128.                                                 return false;
  129.                                         }else{
  130.                                                 if(n==2300){
  131.                                                         return false;
  132.                                                 }else{
  133.                                                         if(n%4==0){
  134.                                                                 return true;
  135.                                                         }else{
  136.                                                                 return false;
  137.                                                         }
  138.                                                 }
  139.                                         }
  140.                                 }
  141.                         }
  142.                 }
  143.         }
  144.        
  145.         //对天数求余后进行处理，判断是星期几，并对相应的数据加1
  146.         public static void add(int b,DayInfo dayBean){
  147.                 if(b==1){
  148.                         dayBean.setMonday(dayBean.getMonday()+1);
  149.                 }
  150.                 if(b==2){
  151.                         dayBean.setTuesday(dayBean.getTuesday()+1);
  152.                 }
  153.                 if(b==3){
  154.                         dayBean.setWednesday(dayBean.getWednesday()+1);
  155.                 }
  156.                 if(b==4){
  157.                         dayBean.setThursday(dayBean.getThursday()+1);
  158.                 }
  159.                 if(b==5){
  160.                         dayBean.setFriday(dayBean.getFriday()+1);
  161.                 }
  162.                 if(b==6){
  163.                         dayBean.setSaturday(dayBean.getSaturday()+1);
  164.                 }
  165.                 if(b==0){
  166.                         dayBean.setSunday(dayBean.getSunday()+1);
  167.                 }
  168.         }

  170. }

  172. //建立一个javabean 用于存放，星期信息，并可以相应信息进行操纵
  173. class DayInfo{
  174.         int monday = 0;
  175.         int tuesday = 0;
  176.         int wednesday = 0;
  177.         int thursday = 0;
  178.         int friday = 0;
  179.         int saturday = 0;
  180.         int sunday = 0;
  181.        
  182.        
  183.         public int getMonday() {
  184.                 return monday;
  185.         }
  186.         public void setMonday(int monday) {
  187.                 this.monday = monday;
  188.         }
  189.         public int getTuesday() {
  190.                 return tuesday;
  191.         }
  192.         public void setTuesday(int tuesday) {
  193.                 this.tuesday = tuesday;
  194.         }
  195.         public int getWednesday() {
  196.                 return wednesday;
  197.         }
  198.         public void setWednesday(int wednesday) {
  199.                 this.wednesday = wednesday;
  200.         }
  201.         public int getThursday() {
  202.                 return thursday;
  203.         }
  204.         public void setThursday(int thursday) {
  205.                 this.thursday = thursday;
  206.         }
  207.         public int getFriday() {
  208.                 return friday;
  209.         }
  210.         public void setFriday(int friday) {
  211.                 this.friday = friday;
  212.         }
  213.         public int getSaturday() {
  214.                 return saturday;
  215.         }
  216.         public void setSaturday(int saturday) {
  217.                 this.saturday = saturday;
  218.         }
  219.         public int getSunday() {
  220.                 return sunday;
  221.         }
  222.         public void setSunday(int sunday) {
  223.                 this.sunday = sunday;
  224.         }
  225.        
  226. }
复制代码
作者: 刘胜寒    时间: 2013-5-18 20:17
黑马华 发表于 2013-5-18 17:44
是不是直接上代码？

代码速度的。。。
作者: 李德全    时间: 2013-5-18 21:35
求版主指导指导。
  1. /*
  2. 计算从1900年开始N年中13号所占各星期次数。

  4. 额，计算出来的和例子不一样啊，求指导

  6. */

  8. import java.util.*;
  9. class  Con13
  10. {
  11.         static Scanner sc = new Scanner(System.in);        //获取输入
  12.         public static int[] arr = new int[7];                //存13号各星期出现次数
  13.         public static int week=0,febDay;                        //星期循环,二月天数

  15.         public static void main(String[] args)
  16.         {       
  17.                 for(int x=0; x<7; x++)
  18.                         arr[x]=0;

  20.                 System.out.println("请输入需要计算多少年：");
  21.                 int N = sc.nextInt();        //获取输入
  22.                 System.out.println("需要计算 "+N+"年");
  23.                 //年数循环
  24.                 for(int x=0; x<N; x++)
  25.                 {       
  26.                         //计算是否为闰年：1.普通年能被4除但是不能被100除。
  27.                         //                                  2.世纪年能被400整除的。
  28.                         if( ( (1900+x)%400==0) || ( (1900+x)%4==0 && (1900+x)%100!=0) )
  29.                                 febDay=29;
  30.                         else
  31.                                 febDay=28;
  32.                         //月份循环
  33.                         for(int y=1; y<=12; y++)
  34.                         {
  35.                                 switch(y)
  36.                                 {
  37.                                         case 1:
  38.                                         case 3:
  39.                                         case 5:
  40.                                         case 7:
  41.                                         case 8:
  42.                                         case 10:
  43.                                         case 12:
  44.                                                 //31天月份
  45.                                                 for(int z=1; z<=31; z++)
  46.                                                 {
  47.                                                         week++;if(week==8)week=1;
  48.                                                         if(z==13) arr[week-1]++;
  49.                                                 }
  50.                                                 break;
  51.                                         case 2:
  52.                                                 //2月
  53.                                                 for(int z=1; z<=febDay; z++)
  54.                                                 {
  55.                                                         week++;if(week==8)week=1;
  56.                                                         if(z==13) arr[week-1]++;
  57.                                                 }
  58.                                                 break;
  59.                                         case 4:
  60.                                         case 6:
  61.                                         case 9:
  62.                                         case 11:
  63.                                                 //30天月份
  64.                                                 for(int z=1; z<=30; z++)
  65.                                                 {
  66.                                                         week++;if(week==8)week=1;
  67.                                                         if(z==13) arr[week-1]++;
  68.                                                 }
  69.                                                 break;
  70.                                         default:break;
  71.                                 }
  72.                         }
  73.                 }
  74.                 //打印数据
  75.                 for(int x=0; x<7; x++)
  76.                 System.out.print(arr[x]+"  ");
  77.         }
  78. }
复制代码
作者: 逸盏清茶    时间: 2013-5-18 23:03
麻烦版主阅下啊  。

逸盏清茶 5.18答案.rar

1.02 KB, 阅读权限: 100, 下载次数: 1
作者: 尖卡斌引    时间: 2013-5-18 23:54
import java.io.*;
import java.util.*;
class Demo13
{
        public static void main(String[] args)
        {
                System.out.println("请输入要查询的年数1~400：");
               
                Scanner in = new Scanner(System.in);
                int n = in.nextInt();
                while(n <= 0||n>400)
                {
                        System.out.println("输入年数超出范围 1~400  请重新输入  ");
                        n = in.nextInt();                        
                }
                int[] arr = new int[7];    // 存放顺序是 星期一，星期二，。。。，星期日。
                jiSuan(n , arr);
                for(int i=0;i<7;i++)
                {
                        System.out.print("  "+arr[i]);
                }
        }
        public static void jiSuan(int n ,int[] arr)
        {        
                int count=13;      //定义一个整数存储从1900年1月1日起到 1900+n-1年 12月31日的天数。
                for(int i=0;i<n;i++)
                {
                        for(int j=1;j<=12;j++)
                        {
                                int index=count%7;        //取 count对7 的摸                 
                                //System.out.println(i+"年"+j+"月"+"13"+"---"+"星期"+index);
                                if(index==0)       //若index为零，则这一天是星期日。
                                        arr[6]++;      //存储在数组中。
                                else
                                        arr[index-1]++; //index不为零，index就是对应的星期 ，存在相应的数组位置。
                                if(j==1||j==3||j==5||j==7||j==8||j==10||j==12)
                                {
                                        count+= 31;
                                }
                                else if(j==2)
                                {
                                        if(i==0)
                                                count+=28;
                                        else if((i+1900)%4==0)
                                        {
                                                count+=29;
                                        }               
                                        else
                                                count+=28;
                                }
                                else
                                        count+=30;                                
                        }
                }
        }
}
版主的例子存储的顺序  不是从 星期一  开始的吧。
运行结果为；
20
34  33  35  35  34  36  33
作者: 尖卡斌引    时间: 2013-5-18 23:55

是在这里答题吗？
作者: 尖卡斌引    时间: 2013-5-18 23:55

是在这里答题吗？
作者: 尖卡斌引    时间: 2013-5-18 23:57

是在这里答题吗？
作者: JinnyZh    时间: 2013-5-19 02:22
标题: RE: 周末答题有奖之二------答题贴
怎么没有版主可见选项啊
作者: JinnyZh    时间: 2013-5-19 02:29
import java.util.Calendar;
import java.util.Scanner;

public class Test5 {
        public static void main(String[] args) {
                //从键盘输入n年
                Scanner sc = new Scanner(System.in);
                int n = sc.nextInt();
                //判断n的范围
                if(n >= 0 && n <= 400) {
                        Calendar c = Calendar.getInstance();
                        //将时间设为1900年1月13日
                        c.set(1900, 0 , 13);
                        //定义一个记数的动态初始化数组, 数组长度为7
                        int[] counts = new int[7];
                        //循环条件,只要年份不大于自定义的1900+n-1就循环
                        while(c.get(Calendar.YEAR) <= 1900 + n - 1) {
                                //由于数组是从索引0开始的,而通过Calendar.DAY_OF_WEEK获取的星期是从1开始的,所以 - 1,星期日为一个星期的第一天
                                //循环后就将得到新得counts数组
                                counts[c.get(Calendar.DAY_OF_WEEK) - 1]++;
                                //每次循环增加一个月,既第一次是1900年1月13日,增加一个月就是1900年2月13日
                                c.add(Calendar.MONTH, 1);
                        }
                        //输出13号在周一到周末出现的次数
                        System.out.println(counts[1]+" "+counts[2]+" "+counts[3]+" "+counts[4]+" "+counts[5]+" "+counts[6]+" "+counts[0]);
                }else           //当不在范围内时输出
                        System.out.println("您输入的数值有误,不在范围内!");
        }

}
//版主, 我确认了很多次, 你的样例输出有误, 而且你题目的顺序是从周1到周日.
作者: kaka小明    时间: 2013-5-19 08:53
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Calendar;
public class Main {
        static Calendar cal=Calendar.getInstance();
        static int[] res=new int[7];//结果存放数组,res[0]为周日
        public static void main(String[] args) {
                int n=0;
                //从1900年1月13日开始计数
                cal.set(Calendar.YEAR, 1900);
                cal.set(Calendar.MONTH, 0);
                cal.set(Calendar.DAY_OF_MONTH, 13);
                try {
                        System.out.println("请输入年数..");
                        //录入键盘,获取年数
                        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
                        n=new Integer(br.readLine());
                        getRes(n);
                } catch (NumberFormatException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
               
                }
        /*
         * 获取并打印结果
         */
        public static void getRes(int n){
                //截止日期19**
                if((n<400)&&(n>0)){
                        while(!(((cal.get(Calendar.YEAR)==(1900+n-1))&&//截止日期****年12月31日
                                    (cal.get(Calendar.MONTH)==11)&&
                                    (cal.get(Calendar.DAY_OF_MONTH)==13)))){       
                        res[cal.get(Calendar.DAY_OF_WEEK)-1]++;
                        cal.add(Calendar.MONTH, 1);//月份加一
                   }
                        res[cal.get(Calendar.DAY_OF_WEEK)-1]++;//最后一天的weekday判断
                        sop(res);
                }else{
                        System.out.println("年数1-400");
                }
               
        }
        public static void sop(int[] a){
                System.out.println("周日天数"+a[0]);
                System.out.println("周一天数"+a[1]);
                System.out.println("周二天数"+a[2]);
                System.out.println("周三天数"+a[3]);
                System.out.println("周四天数"+a[4]);
                System.out.println("周五天数"+a[5]);
                System.out.println("周六天数"+a[6]);       
        }
}
作者: joker_chan    时间: 2013-5-19 11:43
joker_chan 发表于 2013-5-17 20:31
额不用压缩包用什么额。

晕 。是上次的。。。。。额不好意思。我去看看这次的。
作者: 逸盏清茶    时间: 2013-5-19 12:33
逸盏清茶 发表于 2013-5-18 23:03
麻烦版主阅下啊  。

额。。。。论坛不是只能传压缩包的么 。。。
作者: 李罡    时间: 2013-5-19 15:21
原题中给的数据貌似有问题吧，星期一怎么是36天？
  1. package cn.itheima.two;

  3. import java.util.Calendar;
  4. import java.util.Scanner;

  6. /**
  7. * 用Calendar类来做貌似挺简单的吧。。。
  8. */
  9. public class Test13 {
  10.         public static void main(String[] args) {
  11.                 System.out.println("请输入一个不大于400的非负数：");
  12.                 Scanner in = new Scanner(System.in);
  13.                 int num = in.nextInt();
  14.                 if (num < 0 || num > 400) {
  15.                         System.out.println("请输入正确的数字");
  16.                 } else {
  17.                         test2(num);
  18.                 }
  19.         }
  20.         public static void test2(int n) {
  21.                 //在日历中，第1天是星期日，第2天到第7天依次为星期一到星期六
  22.                 String[] weeks = { "", "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六", };
  23.                 // 创建一个Calendar对象
  24.                 Calendar cal = Calendar.getInstance();
  25.                 // 定义一个数组来存放星期一天到星期天的次数
  26.                 int[] counts = new int[7];
  27.                 for (int i = 0; i < n; i++) {
  28.                         for (int j = 0; j < 12; j++) {
  29.                                 // 设定日期
  30.                                 cal.set(1900 + i, j, 13);
  31.                                 // 获取这一天是一周的第多少天
  32.                                 int count = cal.get(Calendar.DAY_OF_WEEK);
  33.                                 // 判断是星期几并把天数加1
  34.                                 String str = weeks[count];
  35.                                 if (str.equals("星期日")) {
  36.                                         counts[6]++;
  37.                                 } else if (str.equals("星期一")) {
  38.                                         counts[0]++;
  39.                                 } else if (str.equals("星期二")) {
  40.                                         counts[1]++;
  41.                                 } else if (str.equals("星期三")) {
  42.                                         counts[2]++;
  43.                                 } else if (str.equals("星期四")) {
  44.                                         counts[3]++;
  45.                                 } else if (str.equals("星期五")) {
  46.                                         counts[4]++;
  47.                                 } else if (str.equals("星期六")) {
  48.                                         counts[5]++;
  49.                                 }
  50.                         }
  51.                 }
  52.                 System.out.println("星期一:" + counts[0] + ",星期二:" + counts[1] + ",星期三："
  53.                                 + counts[2] + ",星期四：" + counts[3] + ",星期五：" + counts[4]
  54.                                 + ",星期六：" + counts[5] + ",星期日：" + counts[6]);

  56.         }
  57. }
复制代码
作者: 严露华    时间: 2013-5-19 17:17
本帖最后由 严露华 于 2013-5-19 17:26 编辑

请版主查看，代码如果有问题或能够在优化，请帮忙指出。谢谢
  1. import java.util.*;
  2. /*思路：
  3. * 1.使用日期类，Calendar
  4. * 2.要获取每年，每月的13号是星期几？使用循环嵌套
  5. * 3.将循环嵌套获取的值放入容器中
  6. * 4.定义一个map集合，将值放入进去
  7. *5. 取出键值对，放入一个容器中
  8. * */
  9. public class Lianxi {

  11.         public static void main(String[] args) {
  12.                
  13.                 String s = date();
  14.                 System.out.println(charCount(s));
  15.                 }
  16.         public static String date(){
  17.                 Calendar c =Calendar.getInstance();
  18.                 StringBuilder sb = new StringBuilder();   //定义一个容器，将遍历到的星期加进容器中

  20.                 String[] weeks = {
  21.                                                 "","日","一","二","三","四","五","六"
  22.                                                         };                                        //定义一个数组，获取对应的星期
  23.                 for(int i=1900;i<2300;i++){
  24.                         for(int j=0;j<=11;j++){
  25.                                 c.set(i, j, 13);
  26.                                 
  27.                                 int index = c.get(Calendar.DAY_OF_WEEK);
  28.                                 
  29.                                 sb.append(weeks[index]+"");//将获取的值加进容器中
  30.                                 
  31.                         }
  32.                         
  33.                         
  34.                         }
  35.                 return sb.toString();
  36.                
  37.         }
  38.         public static String charCount(String s)
  39.         {
  40.                 char[] chs =s.toCharArray();//转化为字符数组
  41.                 TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();//定义一个集合容器

  43.                
  44.                 int count = 0;
  45.                 for(int x=0; x<chs.length; x++)
  46.                 {
  47.                

  49.                         Integer value = tm.get(chs[x]);

  51.                         
  52.                         if(value!=null)                        //值不等于空，则开始对对应的日期进行计数
  53.                                 count = value;
  54.                         count++;
  55.                         tm.put(chs[x],count);//将元素放入集合中

  57.                         count = 0;                //计数器清零


  60.                 }

  62.                 StringBuilder sb1 = new StringBuilder();//在定义一个容器，见迭代去除的值放入容器中

  64.                 Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet();
  65.                 Iterator<Map.Entry<Character,Integer>>  it = entrySet.iterator();

  67.                 while(it.hasNext())
  68.                 {
  69.                         Map.Entry<Character,Integer> me = it.next();
  70.                         Character ch = me.getKey();
  71.                         Integer value = me.getValue();
  72.                         sb1.append(ch+"("+value+")");
  73.                 }



  77.                 return sb1.toString();
  78.         }
  79.         
  80. }
复制代码
作者: 孙茜茜    时间: 2013-5-19 19:51
时间快到了啊，我现在还在写，刚看视频第二天，全凭3年前的c基础琢磨了，不管写到什么时候一定得放上来试试
作者: 刘海陆    时间: 2013-5-20 00:37
求答案,谢谢
作者: student    时间: 2013-5-22 19:25
标题: 周末答题
本帖最后由 student 于 2013-5-22 19:29 编辑
  1. import java.util.Calendar;
  2. import java.util.Iterator;
  3. import java.util.Map;
  4. import java.util.Set;
  5. import java.util.TreeMap;

  7. class Thirteenth {

  9.         // 查表法定义星期数组，星期日是每个星期的第一天
  10.         private static final String[] week = { "星期日", "星期一", "星期二", "星期三", "星期四",
  11.                         "星期五", "星期六" };

  13.         private String key;
  14.         private Integer value;

  16.         public void getTimes(int n) {
  17.                 // 限定n的取值范围
  18.                 if (n < 0 || n > 400) {
  19.                         System.out.println("n的值是一个非负数且不大于400的数");
  20.                         return;
  21.                 }
  22.                 // 创建TreeMap集合对象，采用面向接口的方式
  23.                 Map<String, Integer> tm = new TreeMap<String, Integer>();
  24.                 // 获取日历对象
  25.                 Calendar calendar = Calendar.getInstance();
  26.                 // 计数器
  27.                 int count = 0;
  28.                 // 变量一年的12个月份，0月份代表第一个月
  29.                 for (int i = 0; i < 12; i++) {
  30.                         calendar.set(1900 + n - 1, i, 13);
  31.                         // 获取日历对象中星期，作为成员变量week[]的下标
  32.                         int weekIndex = calendar.get(Calendar.DAY_OF_WEEK);
  33.                         // 星期作为集合的键
  34.                         key = week[weekIndex - 1];
  35.                         // 星期出现的次数作为键值
  36.                         value = tm.get(key);
  37.                         if (!(value == null))
  38.                                 count = value;
  39.                         count++;
  40.                         // 将键值对添加到集合中
  41.                         tm.put(key, count);
  42.                         // 归零,避免本次值加到他键的值上
  43.                         count = 0;
  44.                 }
  45.                 // 打印集合中的元素（键值对）
  46.                 printMap(tm, calendar);
  47.         }

  49.         // 遍历集合
  50.         public void printMap(Map<String, Integer> m, Calendar c) {
  51.                 Set<Map.Entry<String, Integer>> entrySet = m.entrySet();
  52.                 Iterator<Map.Entry<String, Integer>> it = entrySet.iterator();
  53.                 System.out.println(c.get(Calendar.YEAR) + "年的12个月中，13日出现的次数为：");
  54.                 String[] keyValue = new String[week.length];
  55.                 // 遍历集合
  56.                 while (it.hasNext()) {
  57.                         Map.Entry<String, Integer> entry = it.next();
  58.                         String key = entry.getKey();
  59.                         int value = entry.getValue();
  60.                         for (int i = 0; i < week.length; i++) {
  61.                                 if (key != week[i]) {
  62.                                         continue;
  63.                                 }
  64.                                 // 将键值对转换成字符串
  65.                                 keyValue[i] = key + "  " + value + "次";
  66.                         }
  67.                 }
  68.                 // 打印字符串
  69.                 printString(keyValue);
  70.         }

  72.         // 打印字符串
  73.         public void printString(String[] keyValue) {
  74.                 for (int i = 1; i < week.length; i++) {
  75.                         System.out.println(keyValue[i]);
  76.                 }
  77.                 System.out.println(keyValue[0]);
  78.         }
  79. }

  81. // 主函数
  82. public class Demo {
  83.         public static void main(String[] args) {

  85.                 int n = 114;
  86.                 new Thirteenth().getTimes(n);
  87.                 /*
  88.                  * 运行结果：
  89.                  *
  90.                  * 2013年的12个月中，13日出现的次数为：
  91.                  * 星期一 1次
  92.                  * 星期二 1次
  93.                  * 星期三 3次
  94.                  * 星期四 1次
  95.                  * 星期五 2次
  96.                  * 星期六 2次
  97.                  * 星期日 2次
  98.                  */
  99.         }
  100. }
复制代码
作者: 孙茜茜    时间: 2013-5-24 14:32
晚了这么久，好歹做出来了还是发一下
  1. class Fri13
  2. {
  3. public static void main(String[] args)
  4.         {
  5.                 int[] result=new int[7];
  6.                 int weekday;
  7.                 for (int year=1900;year<2300;year+=1)
  8.                 {       
  9.                         int s1=365*(year-1900)-((year-1900)/4-1);
  10.                         for (int month=1;month<13;month+=1)
  11.                         {       
  12.                                 int s2=0;
  13.                                 if (year%4==0)       
  14.                                 {
  15.                                         int[] monthday={0,31,29,31,30,31,30,31,31,30,31,30,31};
  16.                                         for (int i=0;i<month-1;i+=1)
  17.                                         s2+=monthday[i];
  18.                                 }
  19.                                 else            
  20.                                 {
  21.                                         int[] monthday={0,31,28,31,30,31,30,31,31,30,31,30,31};
  22.                                         for (int i=0;i<month-1;i+=1)
  23.                                         s2+=monthday[i];
  24.                                 }
  25.                         weekday=(s1+s2+13)%7;
  26.                         result[weekday]+=1;
  27.                         }
  28.                 }
  29.                 System.out.println("从1900到2300年，13号落在每个星期数上的次数：");
  30.                 System.out.println("星期日"+"\t"+"星期一"+"\t"+"星期二"+"\t"+"星期三"+"\t"+"星期四"+"\t"+"星期五"+"\t"+"星期六");
  31.                 System.out.println(result[0]+"\t"+result[1]+"\t"+result[2]+"\t"+result[3]+"\t"+result[4]+"\t"+result[5]+"\t"+result[6]);
  32.         }
  33. }
复制代码

QQ截图20130524142707.jpg (17.08 KB, 下载次数: 0)

算的结果

算的结果
作者: 风爽    时间: 2013-5-28 20:36
  1. import java.util.Calendar;
  2. import java.util.Date;
  3. import java.util.Scanner;

  5. class Demo2{
  6.         public static void main(String[] args)
  7.         {
  8.                 int year = 0;
  9.                 int month = 0;
  10.                 int day = 0;
  11.                 int[] week = new int[7];//定义数组保存13号落在一周内每天的天数
  12.                 Calendar calendar = Calendar.getInstance();//使用Calendar类的static方法getInstance()初始化一个日历对象
  13.                 //calendar.set(1900, 0, 1);//将日期设置为1900年1月1日
  14.                 Scanner input = new Scanner(System.in);
  15.                 int n = input.nextInt();
  16.                 for(year = 1900; year < 1900 + n; year++)//控制年份的变化
  17.                 {
  18.                         for(month = 0; month < 12; month++)//控制月份的变化，0表示一月，11表示十二月
  19.                         {
  20.                                 calendar.set(year, month, 13);//设置当前日期
  21.                                 int weekday = calendar.get(Calendar.DAY_OF_WEEK);//返回当前日期是一星期中的第几天，星期天为1，星期六为7
  22.                                 //System.out.println(weekday);
  23.                                 if(weekday == 1)//入为weekday1即星期天
  24.                                 {
  25.                                         week[6]++;
  26.                                 }
  27.                                 else//当weekday为2时，即星期一weekday[0]加1，为7时weekday即星期五week[5]加1
  28.                                 {
  29.                                         week[weekday - 2]++;
  30.                                 }
  31.                         }
  32.                 }
  33.                 for(int i = 0; i < 7; i++)//循环输出
  34.                 {
  35.                         System.out.print(week[i] + "\t");
  36.                 }
  37.         }
  38. }
复制代码
作者: 不破大地    时间: 2013-5-29 13:15
有点深度。。
作者: 精彩生活向钱看    时间: 2013-6-1 08:16
  1. class Huangzhitong
  2. {
  3.         public static void main(String[] args)
  4.         {
  5.                 //定义变量用来记录每个星期出现在13号的次数
  6.                 int x1 = 0;
  7.                 int x2 = 0;
  8.                 int x3 = 0;
  9.                 int x4 = 0;
  10.                 int x5 = 0;
  11.                 int x6 = 0;
  12.                 int x7 = 0;
  13.                
  14.                 int first = 1;//定义一个变量记录每个月1号星期数，初始值为1900年1月1日的星期数
  15.                 int count = 0;//定义一个变量记录每个月13号星期数，初始值为0
  16.                
  17.                 for (int n=1;n<=20;n++)//控制年数
  18.                 {
  19.                         if((n-1)% 4 != 0)//判断是否为闰年 这里得用n-1不能误用n。
  20.                         {
  21.                                 for(int a=1;a<=12;a++)//对每个月的13号和下个月1号进行循环记录
  22.                                 {
  23.                                         count = (first+12)%7;//计算每个月的13日的星期数
  24.                                        
  25.                                        
  26.                                         switch(a)//计算每个月的第一天的星期数
  27.                                         {
  28.                                         case 1 :
  29.                                         case 3 :
  30.                                         case 5 :
  31.                                         case 7:
  32.                                         case 8:
  33.                                         case 10:
  34.                                         case 12:
  35.                                                 first =(31+first)%7;
  36.                                                 break;
  37.                                         case 2:
  38.                                                 first =(28+first)%7;
  39.                                                 break;
  40.                                         case 4 :
  41.                                         case 6 :
  42.                                         case 9 :
  43.                                         case 11 :
  44.                                                 first = (30+first)%7;
  45.                                                 break;
  46.                                         }
  47.                                        
  48.                                         switch(count)//记录13日出现在每个星期的次数
  49.                                         {
  50.                                         case 1:
  51.                                                 x1++;
  52.                                                 break;
  53.                                         case 2:
  54.                                                 x2++;
  55.                                                 break;
  56.                                         case 3:
  57.                                                 x3++;
  58.                                                 break;
  59.                                         case 4:
  60.                                                 x4++;
  61.                                                 break;
  62.                                         case 5:
  63.                                                 x5++;
  64.                                                 break;
  65.                                         case 6:
  66.                                                 x6++;
  67.                                                 break;
  68.                                         case 0:
  69.                                                 x7++;
  70.                                                 break;
  71.                                         }
  72.                                 }
  73.                         }
  74.                         else
  75.                         {
  76.                                 for(int a=1;a<=12;a++)
  77.                                 {
  78.                                         count = (first+12)%7;
  79.                                        
  80.                                        
  81.                                         switch(a)
  82.                                         {
  83.                                         case 1 :
  84.                                         case 3 :
  85.                                         case 5 :
  86.                                         case 7:
  87.                                         case 8:
  88.                                         case 10:
  89.                                         case 12:
  90.                                                 first =(31+first)%7;
  91.                                                 break;
  92.                                         case 2:
  93.                                                 first =(29+first)%7;
  94.                                                 break;
  95.                                         case 4 :
  96.                                         case 6 :
  97.                                         case 9 :
  98.                                         case 11 :
  99.                                                 first = (30+first)%7;
  100.                                                 break;
  101.                                         }
  102.                                        
  103.                                         switch(count)
  104.                                         {
  105.                                         case 1:
  106.                                                 x1++;
  107.                                                 break;
  108.                                         case 2:
  109.                                                 x2++;
  110.                                                 break;
  111.                                         case 3:
  112.                                                 x3++;
  113.                                                 break;
  114.                                         case 4:
  115.                                                 x4++;
  116.                                                 break;
  117.                                         case 5:
  118.                                                 x5++;
  119.                                                 break;
  120.                                         case 6:
  121.                                                 x6++;
  122.                                                 break;
  123.                                         case 0:
  124.                                                 x7++;
  125.                                                 break;
  126.                                         }
  127.                                 }
  128.                         }
  129.                 }
  130.                
  131.                
  132.                
  133.                
  134.                 System.out.println("13日落在星期一次数"+x1);
  135.                 System.out.println("13日落在星期二次数"+x2);
  136.                 System.out.println("13日落在星期三次数"+x3);
  137.                 System.out.println("13日落在星期四次数"+x4);
  138.                 System.out.println("13日落在星期五次数"+x5);
  139.                 System.out.println("13日落在星期六次数"+x6);
  140.                 System.out.println("13日落在星期七次数"+x7);
  141.                
  142.         }
  143. }
复制代码
作者: 精彩生活向钱看    时间: 2013-6-1 08:27
  1. class Huangzhitong
  2. {
  3.         public static void main(String[] args)
  4.         {
  5.                 //定义变量用来记录每个星期出现在13号的次数
  6.                 int x1 = 0;
  7.                 int x2 = 0;
  8.                 int x3 = 0;
  9.                 int x4 = 0;
  10.                 int x5 = 0;
  11.                 int x6 = 0;
  12.                 int x7 = 0;
  13.                
  14.                 int first = 1;//定义一个变量记录每个月1号星期数，初始值为1900年1月1日的星期数
  15.                 int count = 0;//定义一个变量记录每个月13号星期数，初始值为0
  16.                
  17.                 for (int n=1;n<=20;n++)//控制年数
  18.                 {
  19.                         if(n% 4 != 0)//判断是否为闰年 这里得用n-1不能误用n。
  20.                         {
  21.                                 for(int a=1;a<=12;a++)//对每个月的13号和下个月1号进行循环记录
  22.                                 {
  23.                                         count = (first+12)%7;//计算每个月的13日的星期数
  24.                                        
  25.                                        
  26.                                         switch(a)//计算每个月的第一天的星期数
  27.                                         {
  28.                                         case 1 :
  29.                                         case 3 :
  30.                                         case 5 :
  31.                                         case 7:
  32.                                         case 8:
  33.                                         case 10:
  34.                                         case 12:
  35.                                                 first =(31+first)%7;
  36.                                                 break;
  37.                                         case 2:
  38.                                                 first =(28+first)%7;
  39.                                                 break;
  40.                                         case 4 :
  41.                                         case 6 :
  42.                                         case 9 :
  43.                                         case 11 :
  44.                                                 first = (30+first)%7;
  45.                                                 break;
  46.                                         }
  47.                                        
  48.                                         switch(count)//记录13日出现在每个星期的次数
  49.                                         {
  50.                                         case 1:
  51.                                                 x1++;
  52.                                                 break;
  53.                                         case 2:
  54.                                                 x2++;
  55.                                                 break;
  56.                                         case 3:
  57.                                                 x3++;
  58.                                                 break;
  59.                                         case 4:
  60.                                                 x4++;
  61.                                                 break;
  62.                                         case 5:
  63.                                                 x5++;
  64.                                                 break;
  65.                                         case 6:
  66.                                                 x6++;
  67.                                                 break;
  68.                                         case 0:
  69.                                                 x7++;
  70.                                                 break;
  71.                                         }
  72.                                 }
  73.                         }
  74.                         else
  75.                         {
  76.                                 for(int a=1;a<=12;a++)
  77.                                 {
  78.                                         count = (first+12)%7;
  79.                                        
  80.                                        
  81.                                         switch(a)
  82.                                         {
  83.                                         case 1 :
  84.                                         case 3 :
  85.                                         case 5 :
  86.                                         case 7:
  87.                                         case 8:
  88.                                         case 10:
  89.                                         case 12:
  90.                                                 first =(31+first)%7;
  91.                                                 break;
  92.                                         case 2:
  93.                                                 first =(29+first)%7;
  94.                                                 break;
  95.                                         case 4 :
  96.                                         case 6 :
  97.                                         case 9 :
  98.                                         case 11 :
  99.                                                 first = (30+first)%7;
  100.                                                 break;
  101.                                         }
  102.                                        
  103.                                         switch(count)
  104.                                         {
  105.                                         case 1:
  106.                                                 x1++;
  107.                                                 break;
  108.                                         case 2:
  109.                                                 x2++;
  110.                                                 break;
  111.                                         case 3:
  112.                                                 x3++;
  113.                                                 break;
  114.                                         case 4:
  115.                                                 x4++;
  116.                                                 break;
  117.                                         case 5:
  118.                                                 x5++;
  119.                                                 break;
  120.                                         case 6:
  121.                                                 x6++;
  122.                                                 break;
  123.                                         case 0:
  124.                                                 x7++;
  125.                                                 break;
  126.                                         }
  127.                                 }
  128.                         }
  129.                 }
  130.                
  131.                
  132.                
  133.                
  134.                 System.out.println("13日落在星期一次数"+x1);
  135.                 System.out.println("13日落在星期二次数"+x2);
  136.                 System.out.println("13日落在星期三次数"+x3);
  137.                 System.out.println("13日落在星期四次数"+x4);
  138.                 System.out.println("13日落在星期五次数"+x5);
  139.                 System.out.println("13日落在星期六次数"+x6);
  140.                 System.out.println("13日落在星期七次数"+x7);
  141.                
  142.         }
  143. }
复制代码
作者: 刘海芳    时间: 2013-6-1 09:50
  1. public class Test {
  2.         public static void main(String[] args) {
  3.                 Test test=new Test();
  4.                 //从控制获取数据
  5.                 Scanner in=new Scanner(System.in);
  6.                 while (true) {
  7.                         //n是一个非负数且不大于400.
  8.                         int num=in.nextInt();
  9.                         if(num<0||num>=400){
  10.                                 System.err.println("输入的数据必须是是一个非负数且不大于400的数");
  11.                                 continue;
  12.                         }
  13.                         test.print_data(num);
  14.                 }
  15.                
  16.         }
  17.         public void print_data(int year_num){
  18.                
  19.                 Calendar cale = Calendar.getInstance();
  20.                 Calendar cale2 = Calendar.getInstance();
  21.                 //0代表的是1月···
  22.                 int week_day[]=new int[7];
  23.                 //设置开始时间0表示1月，以此类推
  24.                 cale.set(1900, 0, 13);
  25.                 //设置结束时间
  26.                 cale2.set(1900+year_num, 11, 13);
  27.                 // 获取这天是周几，但要注意，周日是1，周六是7
  28.                 //每个只有一个13号  所以每次加1个月
  29.                 for (cale.get(Calendar.YEAR); cale.get(Calendar.YEAR)<=cale2.get(Calendar.YEAR);cale.add(Calendar.MONTH,1)) {
  30.                         int i=cale.get(Calendar.DAY_OF_WEEK);
  31.                         week_day[i-1]++;
  32.                 }
  33.                 String[] weeks = { "周日", "周一", "周二", "周三", "周四", "周五", "周六" };
  34.                 for (int i = 0; i < week_day.length; i++) {
  35.                         int data_num = week_day[i];
  36.                         System.out.println(weeks[i]+"的天数有："+data_num);
  37.                 }
  38.         }
  39. }
复制代码
作者: 梁宝昌    时间: 2014-9-1 23:41
默默的赞一个 我现在的基础还不能做这些题啊



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2