A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 刘胜寒 金牌黑马   /  2013-5-17 19:27  /  5981 人查看  /  48 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

本帖最后由 刘胜寒 于 2013-6-5 17:12 编辑

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

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



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

结贴时间为周日晚八点。。。
六点之后的所有回答一律不予考虑。。。

48 个回复

倒序浏览
题目正在酝酿中??
回复 使用道具 举报
题目还没出好么?
回复 使用道具 举报
题目还没出好么?
回复 使用道具 举报
都不知道题目是哪个了 一个7天前的 一个是半小时前的 晕了
回复 使用道具 举报
额不用压缩包用什么额。

GoldPartition.zip

1.07 KB, 阅读权限: 100, 下载次数: 1

点评

哥们你的题目是上次的。。。。不是这次的。。。我还给你加分了。  发表于 2013-5-19 11:28
压缩包,基本不看,还望谅解啊。哥们  发表于 2013-5-18 03:44

评分

参与人数 1技术分 +2 收起 理由
刘胜寒 + 2

查看全部评分

回复 使用道具 举报
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;
        }
}


评分

参与人数 1技术分 +3 收起 理由
刘胜寒 + 3

查看全部评分

回复 使用道具 举报
  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日是星期一.

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

  61. }
复制代码

评分

参与人数 1技术分 +3 收起 理由
刘胜寒 + 3

查看全部评分

回复 使用道具 举报
结果跟样例输出好像有一点不一样,样例好像是把星期六和星期天放前面了
还有版主不让用压缩包,但又不能直接上传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. }
复制代码

评分

参与人数 1技术分 +3 收起 理由
刘胜寒 + 3

查看全部评分

回复 使用道具 举报
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);
               
        }
}
回复 使用道具 举报
我给代码修正下再贴上来。。。我感觉样例的答案是错的。 判断是否为闰年应该用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);
               
        }
}

评分

参与人数 1技术分 +3 收起 理由
刘胜寒 + 3

查看全部评分

回复 使用道具 举报
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");
                }
        }
}

评分

参与人数 1技术分 +3 收起 理由
刘胜寒 + 3

查看全部评分

回复 使用道具 举报
很遗憾没有得你那个结果,觉得思路并没有错,不知道错在哪里,劳烦查看查看
  1. package day3;

  2. import java.util.Calendar;

  3. public class Weekday13 {

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

  54. }
  55.                
复制代码
{:soso_e113:}

评分

参与人数 1技术分 +3 收起 理由
刘胜寒 + 3

查看全部评分

回复 使用道具 举报
老刘,你确定你题目上的例子的输出是正确的吗?
我看我那个写的简洁明了的,不像有错呢

点评

必须是对的啊。。。不然怎么敢糊弄你们几位大神呢。。  发表于 2013-5-18 03:46
回复 使用道具 举报
  1. /*
  2. 题目描述:
  3. 13号又是星期五是一个不寻常的日子吗?
  4. 13号在星期五比在其他日少吗?为了回答这个问题,
  5. 写一个程序来计算在n年里13日落在星期一,星期二......星期日的次数.
  6. 这个测试从1900年1月1日到1900+n-1年12月31日.n是一个非负数且不大于400.
  7. 这里有一些你要知道的:1900年1月1日是星期一.

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

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

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

呵呵,您是从星期六--星期五这样打印的吗

评分

参与人数 1技术分 +3 收起 理由
刘胜寒 + 3

查看全部评分

回复 使用道具 举报
8047107 发表于 2013-5-17 20:19
都不知道题目是哪个了 一个7天前的 一个是半小时前的 晕了

出好了。。。
回复 使用道具 举报
  1. /*

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

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

评分

参与人数 1技术分 +3 收起 理由
刘胜寒 + 3

查看全部评分

回复 使用道具 举报
joker_chan 发表于 2013-5-17 20:31
额不用压缩包用什么额。

恩。没事。
回复 使用道具 举报
我的来了,试试喽。
  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;

  6. public class CountDays {

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

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

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

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

  42.         }

  43.         private static void print(int[] count) {
  44.                 for (int i = 1; i < count.length + 1; i++) {
  45.                         System.out.println("星期" + i + ":" + count[i - 1]);
  46.                 }
  47.         }

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

  68. }
复制代码

评分

参与人数 1技术分 +3 收起 理由
刘胜寒 + 3

查看全部评分

回复 使用道具 举报
和样例同结果的代码不过我觉得这个是错的。还是我发的上一个是正确的。
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);
               
        }
}
回复 使用道具 举报
123下一页
您需要登录后才可以回帖 登录 | 加入黑马