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

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

本帖最后由 神之梦 于 2013-7-13 12:17 编辑


说明:
1、回复看题,第一次回复后24小时内答题有效。(如果接下来24小时内没有足够时间答题,可先不回复。)
2、共有三个题。能做出多少就做多少,如果全部答对,可获得5~9技术分。
3、此帖结束时间:下周答题帖发布之日(7月13日或者14日)。


题目:
1、键盘录入一个正整数,将其分解质因数。如:输入30,打印出30=2*3*5。

2、求出1-100之间的素数,假设有n个,将这些素数存入a[n+1]的数组中。(其中n个是求出的各个素数,还有一个是随机添加其中的一个素数)
      这样数组中就有相同的两个素数,写一个搜索算法,找出数组中相同的那个素数。(随机添加的素数,可手动指定,也可利用随机方法产生)
      (注:存入数组后,数组中的所有元素理论上是无序的,相同的那个素数不一定就等于a[n],而是被存入了数组中的某个角标上)

3、在一个文件夹内有文件夹和文件,文件名的格式为:数字+名称.java。
     要求:把所有的.java文件复制一份,变为文件名格式为:数字+名称+数字.java。

    (其中数字是相对应的,名称由字母组成。如:01Demo.java——>01Demo01.java)

加分说明:
  1、第一题1~2分,第二题2~4分,第3题2~3分。
  2、题目须自己做出,直接回复。将完整代码放在代码块中,不接收附件。
  3、必须有适当注释和思路。没有注释无分。
  4、对题目或加分有不明或异议的,可联系楼主。


第二题特别说明:
对于第二题的通俗理解:
有100个篮球,分别标号为1到100,现在你找出了其中的标号是素数的篮球(假设有n个),并把它们分别装入了n个篮子(相当于数组)里。这时有一个淘气的小朋友,从别的地方拿了1个篮球,这个篮球的标号刚好也是一个素数。然后他也拿了一个篮子装着,并随意的放在了你的某两个篮子之间(这时数组的长度就是n+1)。现在你要做的事情就是找出小孩子拿来的那个篮球。
用程序写就是3个关键点:1、找出素数,并存入数组;2、产生你找出素数中随机的一个,也存入数组,位置不确定;3、找出数组中相同的那个素数。(程序效率最优者,分高)




评分

参与人数 2技术分 +2 黑马币 +4 收起 理由
Just_Only + 4 赞一个!
张勇1993 + 2 辛苦了

查看全部评分

182 个回复

倒序浏览
好的 看看 谢谢楼主
回复 使用道具 举报
好东西                                 
回复 使用道具 举报
  1. package huodong;
  2. /**第一题
  3. *思路
  4. *要质数分解   需要先找出从2到n之间的质数
  5. *然后找出能后整除n的输出
  6. *如果是1的话就不输出*
  7. *
  8. */
  9. import java.util.Scanner;

  10. public class ZhiShu {
  11.         //判断是否是质数
  12.         static boolean is_odd(int n)
  13.           {
  14.            if(n==2||n==3)
  15.                    return true;
  16.            if(n%2==0)
  17.                    return false;
  18.            int i;
  19.            for(i=3;i<=n/2;i+=2)
  20.                if(n%i==0)
  21.                       return false;
  22.            return true;
  23.           }
  24.          
  25.           public static void main(String[] args)
  26.           {
  27.       //读取一个数
  28.            Scanner in=new Scanner(System.in);
  29.            System.out.println("输入数值");
  30.            int n=in.nextInt();
  31.            int i;
  32.            System.out.print(n+"=");
  33.            //找出从2到n之间的质数去除n
  34.            for(i=2;i<=n;i++)
  35.            {
  36.             if(!is_odd(i))
  37.                     continue;
  38.             //可以整除就输出
  39.             if(n%i==0)
  40.             {
  41.              while(true)
  42.              {
  43.               System.out.print(i);
  44.               n/=i;
  45.               if(n!=1) System.out.print("*");
  46.               if(n%i!=0)
  47.                       break;
  48.              }
  49.             }
  50.            }
  51.            System.out.println();
  52.           }
  53. }
复制代码

点评

方法还可以精简下  发表于 2013-7-7 20:05

评分

参与人数 1技术分 +1 收起 理由
神之梦 + 1 很给力!

查看全部评分

回复 使用道具 举报
0.0                           
回复 使用道具 举报
顶个~凑热闹
回复 使用道具 举报
  1. package com.java.test;

  2. import java.util.*;

  3. public class PrimeNum {

  4.         /**
  5.          * 将一个正整数分解质因数,例如:输入参数30,打印出30=2*3*5;
  6.          * @param args
  7.          */
  8.         public static void main(String[] args) {
  9.                 // TODO Auto-generated method stub

  10.                 System.out.println("请输入一个正整数:");
  11.                 //从控制台读取输入的数字
  12.                 Scanner s = new Scanner(System.in);
  13.                 int i = s.nextInt();
  14.                 primeNum(i);
  15.         }
  16.         //将一个正整数分解质因数  并打印
  17.         public static void primeNum(int n)
  18.         {
  19.                 int j = 2;
  20.                 System.out.print(n + "=" );
  21.                 while(j<= n)
  22.                 {
  23.                         //如果该因数等于n,则说明分解质因数的过程已经结束,  打印该因数 并退出while循环
  24.                         if(j == n)
  25.                         {
  26.                                 System.out.println(j);
  27.                                 break;
  28.                         }                                                        
  29.                         //如果n%j==0那么j则是n的因子  又因为j<n 所以j是n的质因数
  30.                         if(n % j == 0 )
  31.                         {
  32.                                 //n能被j整除,则应打印出j的值,并用n除以j的商,作为新的正整数n,重复执行   
  33.                                 System.out.print(j + "*");
  34.                                 n = n / j;
  35.                         }else
  36.                         {
  37.                                 //n%j != 0  则j++ 继续循环找n的因数
  38.                                 j++;
  39.                         }
  40.                 }
  41.                
  42.         }
  43.         
  44. }
复制代码

QQ图片20130707163847.jpg (4.23 KB, 下载次数: 0)

QQ图片20130707163847.jpg

评分

参与人数 1技术分 +2 收起 理由
神之梦 + 2 赞一个!

查看全部评分

回复 使用道具 举报
  1. package huodong;
  2. /**第二题
  3. * 思路
  4. *   先找出1-100中所有的素数
  5. *   将这些素数存到数组中
  6. *   在添加一个素数
  7. *          遍历数组取出相同的元素  

  8. */

  9. public class HuoDong2 {
  10.        
  11.         public static void main(String[] args) {
  12.                 //定义变量统计素数的个数
  13.                 int count = 0;
  14.                 //打印出1-100中所有的素数
  15.                 System.out.println("1-100中的素数有:");
  16.                 for (int i = 0; i < 100; i++)
  17.                 {
  18.                         if(is_odd(i))
  19.                         {
  20.                                 System.out.print(i+"  ");
  21.                                
  22.                                 count++;
  23.                         }
  24.                                
  25.                 }
  26.                 System.out.println();
  27.                 System.out.println("一共有:"+count+"个");
  28.                
  29.                 int n = count;
  30.                 int x = 0;
  31.                 int[] array = new int[n+1];
  32.                 //将求出的素数存入a[n+1]的数组中
  33.                 for (int i = 0; i < 100; i++)
  34.                 {
  35.                         if(is_odd(i))
  36.                         {
  37.                                 array[x] = i;
  38.                                 x++;
  39.                         }
  40.                 }
  41.                 //将自定义的素数5存入a[n+1]的数组中
  42.                 array[n] = 5;
  43.                
  44.                 //查找出相同的素数
  45.                 fetch(array);
  46.                
  47.                
  48.         }
  49.         //查找出相同的素数
  50.         public static void fetch(int[] array)
  51.         {
  52.                 int same = 0;
  53.                 for( int arr : array)
  54.                 {
  55.                         System.out.print(arr+"  ");
  56.                 }
  57.                 System.out.println();
  58.                 //遍历数组取出相同的元素
  59.                 for (int i = 0; i < array.length; i++)
  60.                 {
  61.                        
  62.                         for (int j = i+1; j < array.length; j++)
  63.                         {
  64.                                 if (array[i]==array[j])
  65.                                 {
  66.                                         //将相同的素数存到same中
  67.                                         same = array[i];
  68.                                 }
  69.                         }
  70.                        
  71.                 }
  72.                 System.out.println();
  73.                 System.out.println("相同的素数为:"+same);
  74.                
  75.         }
  76.        
  77.        
  78.        
  79.        
  80.         //判断是否是素数
  81.         static boolean is_odd(int n)
  82.           {
  83.            if(n==2||n==3)
  84.                    return true;
  85.            if(n%2==0)
  86.                    return false;
  87.            int i;
  88.            for(i=3;i<=n/2;i+=2)
  89.                if(n%i==0)
  90.                       return false;
  91.            return true;
  92.           }

  93. }
复制代码

点评

1不是素数  发表于 2013-7-7 20:13

评分

参与人数 1技术分 +2 收起 理由
神之梦 + 2 很给力!

查看全部评分

回复 使用道具 举报
啦啦啦啦啦啦啦,德玛西亚、。
回复 使用道具 举报
看题了~~~~~~~~~~~
回复 使用道具 举报
看看帧
回复 使用道具 举报
  1. package com.java.test;

  2. import java.util.Arrays;

  3. public class PrimeArray {

  4.         /**
  5.          * @param args
  6.          * 2.求出1-100之间的素数,假设有n个,将这些素数存入a[n+1]的数组中。
  7.          * (其中n个是求出的各个素数,还有一个是随机添加其中的一个素数)
  8.          * 这样数组中就有相同的两个素数,写一个搜索算法,找出数组中相同的那个素数。
  9.          * (随机添加的素数,可手动指定,也可利用随机方法产生)
  10.          *  
  11.          */
  12.         public static void main(String[] args) {
  13.                 // TODO Auto-generated method stub
  14.                
  15.                 int n = 0;
  16.                 //先将得到的素数放入一个大小为100 的数组中
  17.                 int[] a1 = new int[100];
  18.                 for (int i = 2; i <= 100; i++) {
  19.                         if (isPrime(i)) {
  20.                                 a1[n] = i;
  21.                                 n++;
  22.                         }
  23.                 }
  24.                 //将数组a1中的素数放入大小为n+1 的数组a中
  25.                 int[] a = new int[n+1];
  26.                 a = Arrays.copyOf(a1, n+1);
  27.                 a[n] = 73;//手动添加一个素数
  28.                 for (int i : a) {
  29.                         System.out.print(i+" ");
  30.                 }
  31.                 System.out.println();
  32.                 System.out.println("数组中相同的素数的角标为:"+halfSeach(a, 73));
  33.         }
  34.         //二分查找法。必须有前提:数组中的元素要有序。
  35.         public static int halfSeach(int[] arr,int key){
  36.                 int min,max,mid;
  37.                 min = 0;
  38.                 max = arr.length-1;
  39.                 mid = (max + min)/2;
  40.                 while(arr[mid]!=key){
  41.                         if(key > arr[mid]){
  42.                                 min = mid + 1;
  43.                         }
  44.                         else if(key < arr[mid])
  45.                                 max = mid - 1;
  46.                         
  47.                         mid = (max + min)/2;        
  48.                 }
  49.                 return mid;
  50.         }
  51.         //判断一个数是不是 素数
  52.         public static  Boolean isPrime(int i ) {
  53.                 for(int j = 2; j <= i/2; j++){
  54.                         if(i % j == 0){
  55.                                 return false;
  56.                         }
  57.                 }
  58.                 return true;
  59.         }
  60. }
复制代码

QQ图片20130707173405.jpg (8.82 KB, 下载次数: 0)

QQ图片20130707173405.jpg

点评

题意是不清楚相同素数是哪个,且不确定位置,程序稍微改下即可  发表于 2013-7-7 20:15

评分

参与人数 1技术分 +2 收起 理由
神之梦 + 2 很给力!

查看全部评分

回复 使用道具 举报
  1. package cn.itcast.exam;

  2. import java.io.BufferedReader;
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.io.InputStreamReader;

  6. public class Test1 {

  7. /**1、键盘录入一个正整数,将其分解质因数。如:输入30,打印出30=2*3*5。
  8. * @param args
  9. * @throws IOException
  10. */
  11. public static void main(String[] args) throws IOException {

  12. //读取数据
  13. BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));

  14. String len = null;

  15. //读取数据
  16. while((len=bufr.readLine())!=null)
  17. {
  18. //转化为整数型
  19. int num = Integer.parseInt(len);
  20. System.out.print(num+"=");

  21. //这个变量时保证在循环输出时,保证第一没有“*”
  22. int b = 0;

  23. //进行因数计算 因数都是在这个期间的数字
  24. for(int i=2;i<=num;i++)
  25. {
  26. while(num%i==0)
  27. {
  28. num/=i;

  29. //除第一次不带“*”,其他数字都带“*”
  30. if(0 == b)
  31. {
  32. System.out.print(+i);
  33. }
  34. else
  35. System.out.print("*"+i);
  36. b++;
  37. }
  38. }
  39. }


  40. }

  41. }
复制代码

点评

输出一次后最好换行,不能停止程序  发表于 2013-7-7 20:27

评分

参与人数 1技术分 +1 收起 理由
神之梦 + 1

查看全部评分

回复 使用道具 举报
看一下,上次就错过了
回复 使用道具 举报
  1. /*1、键盘录入一个正整数,将其分解质因数。如:输入30,打印出30=2*3*5
  2. 思路:分解质因数的方法是让该数x模与i,i从i=2开始,结果为0就输出i,
  3. 得到第一个质因数,x=x/i;如果结果不为0,那么i自增,再进行模与运算。
  4. 最后x不能为分解,输出x*/
  5. import java.util.Scanner;
  6. class  Test3_1
  7. {
  8.         public static void main(String[] args)
  9.         {
  10.                 Scanner in=new Scanner(System.in);//接收键盘录入的数
  11.                 int x=in.nextInt();
  12.                 for(int i=2;i<=x/2;)
  13.                 {
  14.                         if(x%i==0)//当x%i为0,说明i是x的质因数
  15.                         {
  16.                                 System.out.print(i+"*");
  17.                                 x=x/i;
  18.                         }
  19.                         else
  20.                                 i++;
  21.                 }
  22.                 System.out.println(x);
  23.         }
  24. }
复制代码
嗨~第三题,还没学到,学了也忘了,第二题还得想想

点评

第三题考的是字符串操作和io读写文件的知识,你都学了吧  发表于 2013-7-7 20:32
按格式输出,程序需要停止。方法很简练,赞一个!  发表于 2013-7-7 20:31

评分

参与人数 1技术分 +1 收起 理由
神之梦 + 1

查看全部评分

回复 使用道具 举报
我要做做
回复 使用道具 举报
学习一下
回复 使用道具 举报
杨晓燕 发表于 2013-7-7 19:49
嗨~第三题,还没学到,学了也忘了,第二题还得想想

木有过目不忘的本领啊,虽然看了一遍,做起题来很陌生。。苗,你就说说第一题我哪里丢了一分把

点评

输出格式为:30=2*3*5,这个不是主要,程序怎么停止啊,总不能让我来强制停止吧。可加一些提示性语句,如:请输入一个正整数。  发表于 2013-7-7 20:46
回复 使用道具 举报
版主  您好:第一题代码
  1. package test2;

  2. import java.io.BufferedReader;
  3. import java.io.InputStreamReader;
  4. import java.util.ArrayList;
  5. import java.util.List;

  6. /*
  7. * 需求:1、键盘录入一个正整数,将其分解质因数。如:输入30,打印出30=2*3*5。
  8. * */
  9. /*
  10. * 思路:
  11. * (1). 键盘读取一个正整数,之后产生[2,该正整数]之间所有的质数 存放到一个质数列表中
  12. * (2). 循环判断这些质数有哪些可以整除刚才录入的正整数
  13. * */
  14. public class Test1 {
  15.         public static void main(String[] args) throws Exception{
  16.                 //1.键盘录入数字
  17.                 BufferedReader bufr =new BufferedReader(new InputStreamReader(System.in));
  18.                 System.out.println("请您输入一个正整数:");
  19.                 String numLine =bufr.readLine();
  20.                 //检验用户输入的数字是不是数字
  21.                 int number =0;
  22.                 try{
  23.                         number =Integer.parseInt(numLine);
  24.                 }catch(NumberFormatException nfe){
  25.                         System.out.println("对不起,您输入的内容含有非数字字符");
  26.                         return;
  27.                 }
  28.                
  29.                 if(number <=0){
  30.                         System.out.println("您输入的数字不是正整数,请您重新输入...");
  31.                         return;
  32.                 }
  33.                
  34.                 //现在的数字一定是正整数
  35.                 //2.产生[2, 该正整数]范围的质数列表
  36.                         //获取该正整数的不重复的质因数列表  e.g.12质因数有[2, 3]
  37.                 List<Integer> primes =generatePrimeFacotrs(number);
  38.                
  39.                 //3.在产生的质因数的列表中,计算出键盘输入的正整数含有每个质因数的个数
  40.                 List<Integer> primesDetails =getPrimeDetails(primes, number);
  41.                
  42.                 //4.打印输出该正整数的列表
  43.                 printPrimeFactorsStr(primes, primesDetails, number);
  44.         }
  45.        
  46.         //打印输出改该正整数的列表
  47.         private static void printPrimeFactorsStr(List<Integer> primes, List<Integer> primesDetails, int number) {
  48.                 StringBuilder sBuilder =new StringBuilder();
  49.                 sBuilder.append(number+"=");
  50.                
  51.                 int primeFactor =0;
  52.                 int pCount =0;
  53.                
  54.                 for(int i =0; i<primes.size(); i++){
  55.                         primeFactor =primes.get(i);
  56.                         pCount =primesDetails.get(i);
  57.                        
  58.                         for(int j =0; j<pCount -1; j++)
  59.                                 sBuilder.append(primeFactor+"*");
  60.                        
  61.                         if(i <primesDetails.size()-1)
  62.                                 sBuilder.append(primeFactor+"*");
  63.                         else
  64.                                 sBuilder.append(primeFactor);
  65.                 }
  66.                 System.out.println("质因数分解结果:"+ sBuilder.toString());
  67.         }

  68.         //获取每个质因数在键盘输入的数中所含的具体个数
  69.         private static List<Integer> getPrimeDetails(List<Integer> primeFactors, int number) {
  70.                 List<Integer> pDetails =new ArrayList<Integer>();
  71.                
  72.                 for(int primeIndex =0; primeIndex <primeFactors.size(); primeIndex++){
  73.                         int pCount =0;
  74.                         int primeFactor =primeFactors.get(primeIndex);
  75.                        
  76.                         //一直用同一个质因数去整数该整数 一旦除到余数不为0的时候 表示这个整数里面不再含有这个质因数的成分  
  77.                         while(number%primeFactor ==0){
  78.                                 //整除一次,就把对应的质因数的次数变量pCount自加
  79.                                 pCount++;
  80.                                
  81.                                 //更新该整数
  82.                                 number =number/primeFactor;
  83.                         }
  84.                         pDetails.add(pCount);
  85. //                        System.out.println(primeFactors.get(primeIndex) +"...."+ pCount);
  86.                 }
  87.                
  88.                 return pDetails;
  89.         }

  90.         //产生[2, 该正整数]范围内的质数列表
  91.         private static List<Integer> generatePrimeFacotrs(int number) {
  92.                 List<Integer> primes =new ArrayList<Integer>();
  93.                 for(int i=2; i<=number; i++){
  94.                         //如果是质数并且能被传入的整数number整除  那么  这个数i一定是number的一个质因数
  95.                         if(isPrime(i)&&(number%i ==0))
  96.                                 primes.add(i);
  97.                 }
  98. //                System.out.println(primes);
  99.                 return primes;
  100.         }
  101.         //判断一个数是否为素数
  102.         private static boolean isPrime(int num){
  103.                 boolean isPrime =true;
  104.                 //--根据素数的定义 :在一个大于1的自然数中,除了1和此整数自身外,不能被其他自然数整除的数
  105.                 //--要对给定的数 i 判定除了1和自身(num)以外的整数 是不是有能被i整除的
  106.                 for(int i=2; i<num; i++){
  107.                         if(num%i==0){ //如果能被整除 整除标记isPrime标记为false  表示不是素数
  108.                                 isPrime =false;
  109.                                 //开区间(1, i)之间一旦有一个数能整除i
  110.                                 //--就表示i不是素数  直接跳出  不用继续进行判断 节省计算量
  111.                                 break;
  112.                         }
  113.                         //如果(1, i)之间都没有能整出i的数出现, 就表示这个数i是素数  要更新isPrime
  114.                         isPrime =true;
  115.                 }
  116.                 return isPrime;
  117.         }
  118. }
复制代码
运行结果如图:

test1.jpg (10.44 KB, 下载次数: 0)

第一题结果

第一题结果

点评

这题哥们考虑的很全面,但是在程序上可以简练些  发表于 2013-7-8 14:18

评分

参与人数 1技术分 +1 收起 理由
神之梦 + 1 很给力!

查看全部评分

回复 使用道具 举报
第二题代码:
  1. package test2;

  2. import java.util.ArrayList;
  3. import java.util.Arrays;
  4. import java.util.List;
  5. import java.util.Random;

  6. /*
  7. 2、求出1-100之间的素数,假设有n个,将这些素数存入a[n+1]的数组中。
  8. (其中n个是求出的各个素数,还有一个是随机添加其中的一个素数)
  9.       这样数组中就有相同的两个素数,写一个搜索算法,找出数组中相同的那个素数。
  10.      (随机添加的素数,可手动指定,也可利用随机方法产生)
  11. */

  12. /*
  13. * 思路:
  14. * (1). 循环判断1-100之间哪些数是素数
  15. * (2). 按从大到小的顺序将这些素数存入指定的数组中  并随机添加原有素数中的某一个放在数组的最后一个位置上
  16. * (3).        上面的数组除最后一个要查找的元素以外,前面所有的元素顺从大到小排过顺序的。采用折半查找即可
  17. * */
  18. public class Test2 {
  19.         public static void main(String[] args) {
  20.                 int upBound =100;
  21.                 //1.获取1-100的所有的质数
  22.                 List<Integer> primes =getPrimes(upBound);
  23.                 System.out.println("1-100以内的素数是:"+ primes);
  24.                 //2.将列表转换成数组并随机多产生一个已产生的素数存放到转化到的数组的最后一位
  25.                 int[] primesArr =toArray(primes);
  26.                 System.out.println("产生的数组是(假如随机的素数之后):"+ Arrays.toString(primesArr));
  27.                 //3.折半搜索
  28.                 int repeatedKey =binarySearch(primesArr, primesArr[primesArr.length-1]);
  29.                 int repeatedPrime =primesArr[repeatedKey];
  30.                 System.out.println("重复的数字是:"+ repeatedPrime);
  31.         }
  32.        
  33.         //折半搜索  ----以中间值和查找的内容作比较 来作为是否继续循环的条件
  34.         private static int binarySearch(int[] arr, int key){
  35.                 int min =0, max =arr.length -1, mid =(min+ max)/2;
  36.                
  37.                 while(key!= arr[mid]){
  38.                         if(key <arr[mid]){
  39.                                 max =mid -1;
  40.                         }else if(key >arr[mid]){
  41.                                 min =mid +1;
  42.                         }
  43.                        
  44.                         if(min >max)
  45.                                 return -1;
  46.                         mid =(min+ max)/2;
  47.                 }
  48.                 return mid;
  49.         }
  50.        
  51.         //将列表转换成数组并随机多产生一个已产生的素数存放到转化到的数组的最后一位
  52.         private static int[] toArray(List<Integer> primes) {
  53.                 int[] primeArr =new int[primes.size() +1]; //题目要求多一个元素
  54.                
  55.                 for(int x=0; x <primes.size(); x++){
  56.                         primeArr[x] =primes.get(x);
  57.                 }
  58.                
  59.                 //随机产生一个素数
  60.                 int randomPrime =primeArr[new Random().nextInt(primes.size())];
  61. //                System.out.println("random prime is: "+ randomPrime);
  62.                 primeArr[primeArr.length -1] =randomPrime;
  63.                 return primeArr;
  64.         }

  65.         private static List<Integer> getPrimes(int upBound) {
  66.                 List<Integer> primes =new ArrayList<Integer>();
  67.                
  68.                 for(int i=2; i<=100; i++){
  69.                         if(isPrime(i))
  70.                                 primes.add(i);
  71.                 }
  72.                 return primes;
  73.         }

  74.         //判断一个数是否为素数
  75.         private static boolean isPrime(int num){
  76.                 boolean isPrime =true;
  77.                 //--根据素数的定义 :在一个大于1的自然数中,除了1和此整数自身外,不能被其他自然数整除的数
  78.                 //--要对给定的数 i 判定除了1和自身(num)以外的整数 是不是有能被i整除的
  79.                 for(int i=2; i<num; i++){
  80.                         if(num%i==0){ //如果能被整除 整除标记isPrime标记为false  表示不是素数
  81.                                 isPrime =false;
  82.                                 //开区间(1, i)之间一旦有一个数能整除i
  83.                                 //--就表示i不是素数  直接跳出  不用继续进行判断 节省计算量
  84.                                 break;
  85.                         }
  86.                         //如果(1, i)之间都没有能整出i的数出现, 就表示这个数i是素数  要更新isPrime
  87.                         isPrime =true;
  88.                 }
  89.                 return isPrime;
  90.         }
  91. }
复制代码
运行结果如图。

test2.jpg (61.11 KB, 下载次数: 0)

第二题运行结果

第二题运行结果

点评

可能是我的题目没表述清楚,发现好几个哥们都是把数组的最后一个拿来折半查找。折半查找的思路是正确的,但是  发表于 2013-7-8 02:35
最后一个不一定就是相同的那个元素,如果已知最后一个就是相同的那个数了,就不需要去找了。  发表于 2013-7-8 02:35
现在我在题目中又加了个说明,哥们你看下,如果还是没表述清楚望告知。鉴于此第二题可再次提交,明天我再加分  发表于 2013-7-8 02:34
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马