要求：给出16个数：3，9,43,25,2,4，11,71,63,53,7，251,279,191,51,39
           找出其中的素数，并按从大到小的顺序输出。
         

占个楼！

真好 真好

没点思路啊!!  得求教黄老邪去了。。。

樊鹏飞 发表于 2012-10-29 12:04
真好 真好

小樊子，近来可好啊……

占个楼先，算法先想想

头痛……

请问一下 题目是否要求每个魔方中的数 各不相同？

javasrcipt可以吗！！

1. 
   
2. package com.itheima;
   
3. 
   
4. public class Test {
   
5.         public static void main(String[] args){
   
6.                 int j,k,n=0;
   
7.                 int[] b=new int[10];
   
8.                 int[] arr = {3,9,43,25,2,4,11,71,63,53,7,251,279,191,51,39};
   
9.                 for(int i=0;i<arr.length;i++)
   
10.         {
    
11.                 k=(int) Math.sqrt(arr[i]);
    
12.                 for( j=2;j<=k;j++)
    
13.                         if(arr[i]%j==0) break;//判断是否素数
    
14.                         if(j>k)
    
15.                         {
    
16.                         b[n]=arr[i]; //存放素数
    
17.                         n++;
    
18.                         }
    
19.                         
    
20.             }
    
21.                
    
22.                 System.out.print("所有的素数为：");
    
23.                 for(int i = 0;i<n;i++)
    
24.                         
    
25.                         System.out.print(" "+b[i]);
    
26.                
    
27.                 for(int i=0;i<n-1;i++){
    
28.                         for( j=i+1;j<n;j++){
    
29.                                 if(b[i]>b[j]){
    
30.                                         int temp = b[i];
    
31.                                         b[i] = b[j];
    
32.                                         b[j] = temp;
    
33.                                 }
    
34.                         }
    
35.                 }
    
36.         
    
37. 
    
38.                 System.out.println("");
    
39.                 System.out.print("小到大排序为：");        
    
40.                 for(int i = 0;i<n;i++)
    
41.                 System.out.print(" "+b[i]);
    
42.                         
    
43.                
    
44.         
    
45.         }
    
46.         
    
47.         
    
48. }
    
49. 
    
50. 
    

复制代码

运行结果为：
所有的素数为： 3 43 2 11 71 53 7 251 191
小到大排序为： 2 3 7 11 43 53 71 191 251

梁枝武 发表于 2012-10-29 16:48
看看这个行不行

你要不要适当的加点注释

1. import java.util.ArrayList;
   
2. import java.util.Arrays;
   
3. 
   
4. public class day1029 {
   
5. 
   
6.         public static void main(String[] args) {
   
7.                 //创建数组。
   
8.                 int[] array = {3,9,43,25,2,4,11,71,63,53,7,251,279,191,51,39};
   
9.                 //创建ArrayList对象。
   
10.                 ArrayList<Integer> al = new ArrayList<Integer>();
    
11.                
    
12.                 //遍历需要判断的数组，调用isSuShu()判断是否为素数。素数添加到ArrayList
    
13.                 for(int i=0; i<array.length; i++) {
    
14.                         if(isSuShu(array[i])) {
    
15.                                 al.add(array[i]);
    
16.                         }
    
17.                 }
    
18.                 //创建Integer数组。
    
19.                 Integer[] arr = new Integer[al.size()];
    
20.                 //将ArrayList中的元素转换到Integer数组中。
    
21.                 arr = al.toArray(arr);
    
22.                 //排序。
    
23.                 Arrays.sort(arr);
    
24.                 //打印。
    
25.                 print(arr);
    
26.         }
    
27.         
    
28.         //判断是否为素数。
    
29.         public static boolean isSuShu(int m) {
    
30.                 int mid = (int)Math.sqrt(m);
    
31.                 if(m == 1) {
    
32.                         return false;
    
33.                 }
    
34.                 for(int i=2; i<=mid; i++) {
    
35.                         if(m % i == 0) {
    
36.                                 return false;
    
37.                         }
    
38.                 }
    
39.                 return true;
    
40.         }
    
41.         //打印数组。
    
42.         public static void print(Integer[] arr) {
    
43.                 System.out.print("[");
    
44.                 for(int i=0; i<arr.length; i++) {
    
45.                         if(i!=arr.length-1) {
    
46.                                 System.out.print(arr[i] + ",");
    
47.                         } else {
    
48.                                 System.out.print(arr[i]);
    
49.                         }
    
50.                 }
    
51.                 System.out.print("]");
    
52.         }
    
53. 
    
54. }
    

复制代码

public class Prime {

        /**
         * 给出16个数：3，9,43,25,2,4，11,71,63,53,7，251,279,191,51,39
     *     找出其中的素数，并按从大到小的顺序输出      
         */
        public static void main(String[] args) {

                //已知的16个数
                int a[]={3,9,43,25,2,4,11,71,63,53,7,251,279,51,39};
                //筛选10000以内的素数
                final int MAX = 10000;
                final int NSQR = 1000;
                //定义arr数组来表示筛选出来的素数
                int arr[] = new int[MAX];

                //arr数组坐标i不是素数的话就令arr[i]=1
                for(int k=2;k<NSQR;k++){
                        if(arr[k]==0){
                                for(int i=2*k;i<MAX;i+=k){
                                        arr[i] = -1;
                                }
                        }
                }

                //arr[i]==0的话 i就是素数  当arr[a[i]]==0时 a[i]就是素数
                for(int i=0;i<a.length;i++){
                        if(arr[a[i]]==0){
                                arr[a[i]] = a[i];
                        }
                }
                //查找出arr[i]中大于1的值，这些值刚好是数组a中的素数，并按大小排序。
                for(int i=0;i<arr.length ;i++){
                        if(arr[i]>=1){
                                System.out.print(arr[i]+"\t");
                        }
                }

        }

}

1. 
   
2. import java.util.Comparator;
   
3. import java.util.TreeSet;
   
4. 
   
5. public class PrimeNumberSort {
   
6. 
   
7.     /*
   
8.      *要求：给出16个数：3，9,43,25,2,4，11,71,63,53,7，251,279,191,51,39
   
9.            找出其中的素数，并按从大到小的顺序输出。
   
10.      */
    
11.     public static void main(String[] args) {
    
12.         //定义数组存放16个数
    
13.         int[] arr = {3,9,43,25,2,4,11,71,63,53,7,251,279,191,51,39};
    
14.         //定义一个TreeSet用于存放素数，因为TreeSet是有序的，所以可以使用其排序，MyComparator为自定义的排序顺序
    
15.         TreeSet<Integer> ts = new TreeSet<Integer>(new MyComparator());
    
16.         
    
17.         
    
18.         for (int i = 0; i < arr.length; i++) {//遍历数组
    
19.             for (int j = 2; j <=Math.sqrt(arr[i])+1; j++) { //判断数组中的元素能否从2到它的平方根的数整除
    
20.                 if(arr[i]==2)  //数组中元素是2的话，它直接就是素数了
    
21.                     ts.add(arr[i]);  //把2放入TreeSet
    
22.                 else if(arr[i]%j==0)  //能被整除，证明它不是素数，终止本轮循环
    
23.                     break;
    
24.                 if (j > Math.sqrt(arr[i])) { //从2到这个元素的平方根，都没有能数能整除这个元素，证明它是素数
    
25.                     ts.add(arr[i]);
    
26.                 }
    
27.             }
    
28.         }
    
29.         System.out.println(ts.toString()); //打印最后的结果
    
30.     }
    
31. }
    
32. 
    
33. 
    
34. //自定义TreeSet里的比较方法
    
35. class MyComparator implements Comparator<Integer>{  
    
36. 
    
37.     @Override
    
38.     public int compare(Integer o1, Integer o2) {  
    
39.         return o2-o1; //TreeSet里默认是从小到大排列，比较的是o1-o2，用o2-o1使其从大到小排列
    
40.     }
    
41. }
    

复制代码

1. package test;
   
2. 
   
3. public class Sushu
   
4. {
   
5.         public static void zhao(int[] arr )//找到素数
   
6.         {
   
7.                 System.out.print("素数为:");
   
8.                 for (int a=0;a<arr.length;a++)
   
9.                 {
   
10.                         for (int x=2;x<arr[a];x++)
    
11.                         {
    
12.                                 if(arr[a]%x==0)
    
13.                                         break;
    
14.                                 if(x==arr[a]-1)
    
15.                                         System.out.print(arr[a]+",");
    
16.                         }
    
17.                 }System.out.println();
    
18.         }
    
19.         public static void pao(int[] arr)//冒泡排序
    
20.         {
    
21.                 System.out.print("排序:");
    
22.                 for (int x=0;x<arr.length-1 ;x++ )
    
23.                 {
    
24.                         for (int y=0;y<arr.length-x-1 ;y++ )
    
25.                         {
    
26.                                 if (arr[y]>arr[y+1])
    
27.                                 {
    
28.                                         int b=arr[y];
    
29.                                         arr[y]=arr[y+1];
    
30.                                         arr[y+1]=b;
    
31.                                 }
    
32.                         }
    
33.                 }
    
34.         }
    
35.         public static void print(int[] arr)//打印
    
36.         {
    
37.                 System.out.print("[");
    
38.                 for (int x=0;x<arr.length ;x++ )
    
39.                 {
    
40.                         System.out.print(arr[x]);
    
41.                         if (x!=arr.length-1)
    
42.                                 System.out.print(",");
    
43.                 }
    
44.                 System.out.println("]");
    
45.         }
    
46.         public static void main(String[] args)
    
47.         {
    
48.                 int arr[]={3,9,43,25,2,4,11,71,63,53,7,251,279,191,51,39};
    
49.                 print(arr);
    
50.                 zhao(arr);
    
51.                 pao(arr);
    
52.                 print(arr);
    
53.         }
    
54. }
    
55.        
    

复制代码

我也来了

来凑凑热闹，{:soso_e142:}

1. public class PrintSuShu {
   
2. public static void main(String[] args) {
   
3.       int[] source = {3,9,43,25,2,4,11,71,63,53,7,251,279,191,51,39};
   
4.       int[] newSource = new int[9];//定义数组装素数，因为数组有个自带排序的方法
   
5.       int count=0;
   
6.       for(int x=0;x<source.length;x++){
   
7.          int num = isPrime(source[x]);
   
8.          if(num!=-1){//根据返回值来判断是否是素数
   
9.              newSource[count]= num;
   
10.              count++;
    
11.          }
    
12. }
    
13. Arrays.sort(newSource);//数组自带的排序方法
    
14.     for(int x=0;x<newSource.length;x++){//打印
    
15.         System.out.print(newSource[x] + " ");
    
16.     }
    
17. }
    
18. /*判断是否是素数的方法，如果是返回该数，如果不是返回-1*/
    
19. public static int isPrime(int n){
    
20.      for(int i=2;i<=n/2;i++){
    
21.            if(n%i == 0)
    
22.                return -1;
    
23.      }
    
24.     return n;
    
25. }
    
26. }
    

复制代码

得到结果是：
2 3 7 11 43 53 71 191 251

1. public class TestPrime{
   
2.         public static boolean isPrime(int num){
   
3.                 if(num <2)
   
4.                         return false;
   
5.                 for(int i=2;i<=Math.sqrt(num);i++){
   
6.                         if(num%i==0)
   
7.                                 return false;
   
8.                 }
   
9.                 return true;
   
10.         }
    
11.         public static void sortArray(int a[]){
    
12.                 int temp;
    
13.                 for(int i=0; i<a.length-1; i++){
    
14.                         for(int j=i+1; j<a.length; j++){
    
15.                                 if(a[i]<a[j]){
    
16.                                         temp =a[i];
    
17.                                         a[i]=a[j];
    
18.                                         a[j]=temp;
    
19.                                 }
    
20.                         }
    
21.                 }
    
22.         }        
    
23.         public static void main(String[] args){
    
24.                 int n[] ={3,9,43,25,2,4,1,71,63,53,7,251,279,191,51,39};               
    
25.                 int j =0;
    
26.                 //先排序再判断是否素数和输出。。这也可以的吧=,=
    
27.                 sortArray(n);
    
28.                 for(int i =0 ;i<n.length; i++)
    
29.                 {
    
30.                         if(isPrime(n[i])){                                
    
31.                                 System.out.print(n[i]+" ");
    
32.                                 }
    
33.                 }               
    
34.         }
    
35. }

复制代码

输出结果：251 191 71 53 43 7 3 2

1. package du;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.Arrays;
   
5. import java.util.List;
   
6. 
   
7. import org.junit.Test;
   
8. 
   
9. public class Demo {
   
10.         @Test
    
11.         public void test() {
    
12.                 int[] source = { 3, 9, 43, 25, 2, 4, 11, 71, 63, 53, 7, 251, 279,
    
13.                                 191, 51, 39 };
    
14.                 Arrays.sort(source);
    
15.                 List<Integer> l=new ArrayList<Integer>();
    
16.                 System.out.println("其中的素数是：");
    
17.                 for(int i:source){
    
18.                         if(isPrime(i)){
    
19.                                 l.add(i);
    
20.                                 System.out.print(i);
    
21.                                 System.out.print(" ");
    
22.                         }
    
23.                 }
    
24.                 System.out.println("\n从大到小排列结构为");
    
25.                 for(int j=l.size()-1;j>=0;j--){
    
26.                         System.out.print(l.get(j));
    
27.                         System.out.print(" ");
    
28.                 }
    
29.         }
    
30.         boolean isPrime(int num) {
    
31.                 if (num == 2 || num == 3) {
    
32.                         return true;
    
33.                 }
    
34.                 if (num % 6 != 1 && num % 6 != 5) {
    
35.                         return false;
    
36.                 }
    
37.                 for (int i = 5; i * i <= num; i += 6) {
    
38.                         if (num % i == 0 || num % (i + 2) == 0) {
    
39.                                 return false;
    
40.                         }
    
41.                 }
    
42.                 return true;
    
43.         }
    
44. }
    

复制代码

其中的素数是：
2 3 7 11 43 53 71 191 251
从大到小排列结构为
251 191 71 53 43 11 7 3 2

import java.util.Arrays;

class Test12
{
        public static void main(String[] args)
        {
                int[] arr = {3,9,43,25,2,4,11,71,63,53,7,251,279,191,51,39};
                Arrays.sort(arr);
                for(int x=arr.length-1; x>=0; x--)
                {
                        if(isPrime(arr[x]))
                                System.out.print(arr[x]+" ");
                }
        }

        public static boolean isPrime(int num)
        {
                if(num==2 || num==3)
                        return true;
                for(int x=2; x<num; x++)
                {
                        if(num%x == 0)
                                return false;
                }
                return true;
        }
}


251 191 71 53 43 11 7 3 2