都是来抢楼的

小程序标题：统计单词
小程序题目：
第1行：一个整数n(1<n<=10000)，代表输出的最大排名
第2行：N个单词，每个单词后跟一个空格，单词仅由字母组成，最大长度50，最大不同单词个数10000
样例输入

15
Albus Rose Hugo and Lily laughed The train began to move and Harry walked alongside it watching his son s thin face already ablaze with excitement Harry kept smiling and waving even though it was like a little bereavement watching his son glide away from him The last trace of steam evaporated in the autumn air The train rounded a corner Harry s hand was still raised in farewell He ll be alright murmured Ginny As Harry looked at her he lowered his hand absentmindedly and touched the lightning scar on his forehead I know he will The scar had not pained Harry for nineteen years All was well
样例输出

Rank  1: the (6)
Rank  2: harry (5)
Rank  3: and (4)
Rank  3: his (4)
Rank  5: he (3)
Rank  5: was (3)
Rank  7: a (2)
Rank  7: hand (2)
Rank  7: in (2)
Rank  7: it (2)
Rank  7: s (2)
Rank  7: scar (2)
Rank  7: son (2)
Rank  7: train (2)
Rank  7: watching (2)
题目来源

安徽大学第三届ACM/ICPC 程序设计竞赛现场赛
小程序答案:给你们写一次思路...怎么实现的我就不写了
用HashMap存储单词和个数，因为map是一种映射关系。
写个比较器，让单词先按个数拍，然后在按自然顺序排列。
HashMap容器中传入比较器。
用hashMap保存单词和每个单词出现了多少次。
然后读入一行行的单词，这个就不多说了....
然后按照要求把前多少输出出来。
至于怎么控制输出结果，单词前面的数字，用一个数来保存当前是第几个就行了。
下周一前发这一题的java源码....

这么多啊，我竟然看完了

1. /**
   
2. 题目：
   
3. 一个汉字代表一个数字，相同的汉字代表相同的数字。
   
4.     学习
   
5. *     学
   
6. ————
   
7. 好好好  
   
8. 三个汉字都为0到9的数字
   
9. 学=（），习=（），好=（）
   
10. 设计程序，求出各个汉字代表的数字。
    
11. 需求：利用IO流，将D:\question.txt文件中的题目要求复写到E盘的answer.txt文件中，并将最终结果也写在该文件中
    
12. 思路：1.读取D\\question.txt文件中的题目，并复写到answer.txt中
    
13.          2.利用for循环求出各个汉字的数值
    
14.          3.将答案运用字节流输出流写入answer.txt中
    
15. */
    
16. import java.io.*;
    
17. class GuessNum
    
18. {
    
19.        public static void main(String[] args)
    
20.        {
    
21.               copy();//复制题目
    
22.               answer();//作答
    
23.        }
    
24.        public static void copy()
    
25.        {     
    
26.               BufferedReader br = null;
    
27.               BufferedWriter bw = null;
    
28.               try
    
29.               {
    
30.                      br = new BufferedReader(new FileReader("D:\\question.txt"));
    
31.                      bw = new BufferedWriter(new FileWriter("E:\\answer.txt"));
    
32.                      String len = null;
    
33.                      while((len = br.readLine())!=null)
    
34.                      {
    
35.                             bw.write(len);
    
36.                             bw.newLine();
    
37.                             bw.flush();
    
38.                      }                  
    
39.               }
    
40.               catch (IOException e)
    
41.               {
    
42.                      throw new RuntimeException("读取问题失败");
    
43.               }
    
44.               finally
    
45.               {
    
46.                      try
    
47.                      {
    
48.                             if(br!=null)
    
49.                                    br.close();
    
50.                      }
    
51.                      catch (IOException e)
    
52.                      {
    
53.                             throw new RuntimeException("读取关闭失败");
    
54.                      }
    
55.                      try
    
56.                      {
    
57.                             if(bw!=null)
    
58.                                    bw.close();                           
    
59.                      }
    
60.                      catch (IOException e)
    
61.                      {
    
62.                             throw new RuntimeException("写入关闭失败");
    
63.                      }
    
64.               }
    
65.        }
    
66.        public static void answer()
    
67.        {
    
68.               BufferedWriter bos = null;
    
69.               try
    
70.               {
    
71.                      bos =new BufferedWriter(new OutputStreamWriter(new FileOutputStream("E:\\answer.txt",true)));
    
72.                      String str = null;
    
73.                      int xue,xi,hao,num;
    
74.                      for(hao=1;hao<=9;hao++)
    
75.                             for(xi=0;xi<=9;xi++)
    
76.                                    for(xue=1;xue<=9;xue++)
    
77.                                    {
    
78.                                           num = xue*(xue*10+xi);
    
79.                                           if(num==hao*111)
    
80.                                           {
    
81.                                                  str = "学="+xue+",习="+xi+",好="+hao+"\r\n";
    
82.                                                  try
    
83.                                                  {
    
84.                                                         bos.write(str);
    
85.                                                  }
    
86.                                                  catch (IOException e)
    
87.                                                  {
    
88.                                                         throw new RuntimeException("答案写入失败");
    
89.                                                  }
    
90.                                           }
    
91.                                    }
    
92.               }
    
93.               catch (IOException e)
    
94.               {
    
95.                             throw new RuntimeException("写入流初始化失败");
    
96.               }
    
97.               finally
    
98.               {
    
99.                      try
    
100.                      {
     
101.                             if(bos!=null)
     
102.                             bos.close();                          
     
103.                      }
     
104.                      catch (IOException e)
     
105.                      {
     
106.                             throw new RuntimeException("写入流关闭失败");
     
107.                      }
     
108.               
     
109.               }
     
110.        }
     
111. }
     

复制代码

抢楼好了 ，貌似不能多次出题

小程序标题：打印出所有的“水仙花数”
小程序题目：打印出所有的“水仙花数”
小程序答案：

1. /*
   
2. 需求：打印出所有的“水仙花数”。
   
3. 
   
4. 思路：
   
5. 1、所谓“水仙花数”就是一个三位数，其各个位上数字的立方和等于这个数本身。
   
6. 2、因为是要查找符合条件的三位数，所以可用for循环遍历100到999.
   
7. 3、在循环中，根据条件：各个位上的数字立方和等于本身，判断出符合的数，并返回。
   
8. */
   
9. 
   
10. import java.util.*;
    
11. public class SXHS
    
12. {
    
13.         public static void main(String[] args)
    
14.         {
    
15.                 System.out.println("所有的”水仙花数“：");
    
16.                 SXH sxhs=new SXH();
    
17.                 while (!sxhs.isNull())
    
18.                 {
    
19.                         sop(sxhs.getSXHS());
    
20.                 }
    
21.         }
    
22. 
    
23.         //打印
    
24.         public static void sop(Object obj)
    
25.         {
    
26.                 System.out.println(obj);
    
27.         }
    
28. }
    
29. 
    
30. //所有的“水仙花数”为一个类封装，提供方法获取
    
31. class SXH
    
32. {
    
33.         //声明并初始化一个LinkedList集合，用于存放水仙花数
    
34.         private LinkedList list;
    
35.         {
    
36.                 list=new LinkedList();
    
37.         }
    
38. 
    
39.         //判断水仙花数，并装入集合中;
    
40.         //因为“水仙花数”个数少，范围固定，故不向外提供设置范围方法。
    
41.         SXH()
    
42.         {
    
43.                 for(int i=100;i<=999;i++)
    
44.                 {
    
45.                         int x,y,z;                //定义三个变量接收这个三位数各个位上的数
    
46.                         x=i/100;                //百位上的数
    
47.                         y=(i/10)%10;        //十位上的数
    
48.                         z=i%10;                 //个位上的数
    
49.                         if(i==(x*x*x+y*y*y+z*z*z))
    
50.                         {
    
51.                                 list.add(i);
    
52.                         }                                
    
53.                 }
    
54.         }
    
55.         
    
56.         //获取方法
    
57.         public Object getSXHS()
    
58.         {
    
59.                 return list.removeFirst();
    
60.         }
    
61. 
    
62.         //判断集合中是否为空
    
63.         public boolean isNull()
    
64.         {
    
65.                 return list.isEmpty();
    
66.         }
    
67. }

复制代码

1. 这题直接求就很简单了，不过刚学了集合，权当复习复习啦。

复制代码

上一题楼层及时间：第74楼，时间为：2013年3月30日
上一题推荐的理由：迭代法求最大公因数的辗转相除法用得很巧妙。

1. //最大公因数使用辗转相除法来求
   
2.         while(n != 0)        
   
3.                 {
   
4.             r = m % n;
   
5.             m = n;
   
6.             n = r;
   
7.         }

复制代码

答题者次数:我是本题第一次答题者(自己出题自己回答...伤不起)
小程序思路:和题目的思路基本一致，添加了Collections排序
小程序答案：

1. 
   
2. import java.util.*;
   
3. import java.lang.*;
   
4. 
   
5. public class Main
   
6. {
   
7.         public static void main(String[] aegs)
   
8.         {
   
9.                 Scanner cin = new Scanner(System.in);
   
10.                 Map<String,Integer> HM = new TreeMap<String,Integer>();
    
11.                 int N = cin.nextInt();
    
12.                 String tmp;//用来把单词换成小写
    
13.                 while(cin.hasNext())
    
14.                 {
    
15.                    List<Map.Entry<String, Integer>> MapSort = null;//建立一个List
    
16.                    HM.clear();//清空数组
    
17.                    String str = cin.nextLine();//读入数据
    
18.                    String reg = " +";//正则表达式  
    
19.                    String[] Tmp = str.split(reg);//把读入的数据按照郑则表达式拆分并保存到数组中
    
20.                    for(int i=0;i<Tmp.length;i++) //把单词存入到TresMap中
    
21.                    {
    
22.                            tmp = Tmp[i].toLowerCase();
    
23.                             Object value = HM.get(tmp );
    
24.                             if(value==null) HM.put(tmp , 1);
    
25.                             else  HM.put(tmp,HM.get(tmp)+1);       
    
26.                    }
    
27.                    MapSort = new ArrayList<Map.Entry<String, Integer>>(HM.entrySet());//给MapSort 赋值
    
28.                    Collections.sort(MapSort,new Comparator<Map.Entry<String, Integer>>(){//对Collections 进行自定义排序
    
29.                                                    public int compare(Map.Entry<String, Integer> Mapping1,Map.Entry<String, Integer> Mapping2)
    
30.                                                    {
    
31.                                                            return Mapping2.getValue() - Mapping1.getValue();
    
32.                                                    }
    
33.                                    }
    
34.                                   
    
35.                    );
    
36.                    int count = 0, Pos = 0, sum  = 1;// count 用来统计判断前多少个要输出   Pos 用来确定单词是第几位  sum 用来判定上下两个单词出现的平率是否一样
    
37.                    for(Map.Entry<String, Integer> Mapping:MapSort)//输出结果
    
38.                    {
    
39.                            if(count==15)break;
    
40.                            if(sum!=Mapping.getValue())
    
41.                            {
    
42.                                    sum =Mapping.getValue();
    
43.                                    Pos++;
    
44.                            }
    
45.                           
    
46.                            System.out.println("Rank "+Pos+":"+Mapping.getKey()+" ("+Mapping.getValue()+")");
    
47.                            count+=1;
    
48.                    }
    
49.                   
    
50.                 }
    
51.         }
    
52. 
    
53. }

复制代码

http://gcq04552015.iteye.com/blog/974580
这是我参考写Collections排序的网址。
我是被坑了...给你们送分都不要...还要我自己写...自己回...

什么都不懂先来抢楼在说...

小程序标题：自定义规则排序
小程序题目：设有n个人围绕成一圈，从第一个人开始报数，数到第m个人后出列，然后从出列的下一个人开始报数，数到第m个人后又出列，……，如此反复直到所有人都出列为止。设n                     个人的编号分别为1、2、3、……、n，打印出这n个人出列的顺序。
小程序思路：
1、先定义一个从数组中出列函数

1. private static int chulie(int[] p,int n,int m)       //将编号数组、剩余人数（初始为n）、步长m作为参数传入
   
2.         {     
   
3.                 if(m>n)//步长大于剩余人数的情况
   
4.                 {
   
5.                         int t=m-n;
   
6.                         while(t>n)
   
7.                         {
   
8.                                 t-=n;
   
9.                         }
   
10.                         return p[t];
    
11.                 }
    
12.                 return p[m];    //步长小于剩余人数情况
    
13.         }

复制代码

2、建立规则函数，该函数调用出列函数，并将出列后剩余的编号组成新的数组，将该数组和该数组长度、步长传入出列函数，如下图所示：


3、如此递归直到取出所有的编号。
4、在main函数中调用规则打印出列顺序。
上一题楼层及时间：第172楼，时间为：2013年4月2日
上一题推荐的答案：（出题时已给出）
回复者楼层：尚没有回复
本题目楼层及时间：第175楼，时间为：2013年4月6日

好帖顶上去.

小程序标题：字符串转为double二维数组
小程序题目：编写一个方法，返回一个double的二维数组，数组中的元素通过解析字符串参数获得，如“1,2；3,4,5；6,7,8”
                     对应数组为：
                     d[0,0]=1.0；d[0,1]=2.0；d[1,0]=3.0  d[1,1]=4.0；d[1,2]=5.0；d[2,0]=6.0；d[2,1]=7.0；d[2,2]=8.0
                     可直接用Arrays的deepToString(double[][] d)打印结果。
上一题楼层及时间：第138楼，时间为：2013年3月30日
上一题推荐的答案：无
本题目楼层及时间：第177楼，时间为：2013年4月7日

小程序答案：
在这里给出一个参考：
思路：

1. 
   
2. import java.util.Arrays;
   
3. 
   
4. public class WrapperClass {
   
5. 
   
6.         /**
   
7.          * 分析：
   
8.          * 1、截取字符串，双重for循环
   
9.          * 2、通过分号截完一个即存入到第一维数组中
   
10.          * 3、通过逗号截完一个即存入到第二维数组中
    
11.          */
    
12.         public static void main(String[] args) {
    
13.                 String str = "1,2;3,4,5;6,7,8";
    
14.                 double[][] d = strToDoubleArray(str);
    
15.                 System.out.println(Arrays.deepToString(d));
    
16. 
    
17.         }
    
18.        
    
19.         //编写方法
    
20.         public static double[][] strToDoubleArray(String str){
    
21.                 //通过分号截完一个即存入到第一维数组中
    
22.                 String[] s1 = str.split(";");
    
23.                 double[][] d = new double[s1.length][];
    
24.                 for(int i=0; i<s1.length; i++){
    
25.                         //通过逗号截完一个即存入到第二维数组中
    
26.                         String[] s2 = s1[i].split(",");
    
27.                         d[i] = new double[s2.length];
    
28.                         for(int j=0; j<s2.length; j++){
    
29.                                 //将字符串转为对应的数组元素
    
30.                                 d[i][j] = Double.parseDouble(s2[j]);
    
31.                         }
    
32.                 }
    
33.                 return d;
    
34.         }
    
35. 
    
36. }
    

复制代码

好繁琐的规则，先占个楼再慢慢研究

黄玉昆 发表于 2013-3-30 15:46
这个我知道的，我刚试了一下，是我没保存，太纠结了。谢谢你啊

这个 类似吧···
  我集合学的不怎么好，没进行分析整理
用数组一样！！！
  数组就是集合的底层

抢楼了。。。

看看飞到哪了.......

这个，真的需要抢么？？

小程序标题：继承关系小程序
小程序题目： 编写一个类Person，为Person类定义年龄、姓名两个属性，并且定义一个SayHello方法，方法执行时输出“我是***我的年龄是***”；
定义一个Chinese类从Person类继承。
上一题楼层及时间：无
上一题推荐的答案：无
本题目楼层及时间：第183楼 时间为：2013年4月8日
/*
需求：
8、 编写一个类Person，为Person类定义年龄、姓名两个属性，
并且定义一个SayHello方法，方法执行时输出“我是***我的年龄是***”；
定义一个Chinese类从Person类继承。

*/
/*
思路：
1. 需要编写两个类，Person和Chinese
2. Person里有两个属性和一个方法
3. Chinese里需要两个属性外还有个国籍属性是共有的，所以业需要列出来
4. 测试两个类是否能够执行

步骤：
1. 建立Person 类，定义属性name 和 age 并且定义SayHello方法
2. 建立Chinese 类。并继承Person。 定义属性 GUO_JI
3. 编写Test8，测试是否能够通过编译。
*/
class Person
{
        private String name;//定义变量
        private int age;

        Person(String name,int age)//定义构造函数，当未定义构造函数时，
                                                                //系统默认有一个没有接收值得构造函数。
        {
                this.name = name;//this   谁调用该构造函数，this就代表谁
                this.age = age;
        }
        public void SayHello() //定义方法。
        {
                System.out.println("我是"+this.name+"我的年龄是"+this.age+"岁。");
        }
}
class Chinese extends Person
{
        private  String GUO_JI = "CN";
        Chinese(String name,int age)//定义构造函数，
        {
                super(name,age);//将信息传送给父系，由父系赋值。
        }
}

class  Test8 //测试该程序是否能运行
{
        public static void main(String[] args)
        {
                Chinese fbb = new Chinese("范冰冰",49);
                fbb.SayHello();//对象已经建立，可以直接通过对象.函数名来调用，
        }
}
一个小题目，刚学，就能写成这样了。

话说现在楼层，还有奖励没了...

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.Arrays;


public class test2 {

        /**
         * @param args
         */
        /*周三老师叫我们用汇编语言写一段密码验证程序：
         *   请 输入密码，最多输入三次若第一次输入错误
         *   则在进行输入，直到输入正确。若其中有一次
         *   输入正确，则输出"welcome you !";若三次都输入
         *   错误则输出"error!"
         */
        static int count = 0;
        public static void main(String[] args) {
       
                int[] pw = new int[]{1,2,4};  //assume password is 1 and 2,4;
               
                boolean flag = true;
                while(count <3 && flag)
                        flag= result(pw);
       
                if(flag)
                        System.out.println("error!");
                else
                        System.out.println("Welcome you !");
       
        }

        private static boolean result(int pw[]) {
                BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
                System.out.print("请输入密码：");
                boolean flag = true;
                String password1 = null;
                try {
                        password1 = br.readLine();
                } catch (IOException e) {
                        e.printStackTrace();
                }
                int password[]  = new int[password1.length()];
                //讲字符串转化为数字存储在pssword数组中
                for(int i = 0; i < password1.length(); i++) {
                        password[i] = password1.charAt(i) - '0';  //必须减去32.负责得到的是asc码
                }
                //验证密码是否相等
                //System.out.println(Arrays.toString(password));
                for(int i = 0; i < password.length; i++) {
                        if(!(password[i] != pw[i])) {
                                flag = false;
                        }
                        break;
                }
                count++;
                return flag;   //error return ture ,else return false
        }

}

我的···················