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

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

题2
  1. package com.itheima;

  2. import java.util.Arrays;

  3. public class test2 {
  4.         public static boolean IsPrime (int m)
  5.         {
  6.          int i;
  7.          if (m == 2) return true;
  8.          if (m == 1 || m % 2 == 0) return false;
  9.          for (i = 3; i * i <= m;)
  10.          {
  11.           if (m % i == 0) return false;
  12.           i += 2;
  13.          }
  14.          return true;
  15.         }
  16.         public static void main(String[] args) {
  17.                 int []num={2,5,9,10,48,95,154,31,59,69};
  18.                 int i,j,k;
  19.                  Arrays.sort(num);//把数组元素从打到小排序
  20.                 for(i=0;i<num.length;i++){
  21.                         System.out.print(num[i]+" ");
  22.                 }
  23.                 System.out.println("\n"+"=========================");
  24.                 for(i=0;i<num.length;i++)
  25.                         {
  26.                         if(IsPrime(num[i])){
  27.                                 num[i]=0;//数组中的素数全部赋值为零
  28.                         }System.out.print(num[i]+" ");
  29.                 }        System.out.println("\n"+"=========================");
  30.                 for(i=0;i<num.length;i++){
  31.                         System.out.print("\n");
  32.                         for(j=0;j<i;j++)
  33.                                 System.out.print(" ");
  34.                                          System.out.print(num[j]);
  35.                           
  36.                 }
  37.         }

  38. }
复制代码

无标题.png (104.05 KB, 下载次数: 0)

无标题.png

评分

参与人数 1技术分 +2 收起 理由
夜默 + 2

查看全部评分

回复 使用道具 举报
[/code]晚上睡不着,逛逛论坛挣挣技术分,小健版主别忘了加分哦



[code]package reg;

public class demo {

        /**
         * 1. 打印输出一百以内的素数的累加和...
         * 解题思路:判断素数的方法:用一个数分别去除2到sqrt(这个数),如果能被整除, 则表明此数不是素数,反之是素数。   
         */
        public static void main(String[] args) {

                boolean flg;    //定义布尔值变量作判断条件
                int sum = 0;    //求和变量
               
                for (int i = 2; i < 100; i++) {      //循环2-100以内的数,素数从2开始
                        flg = true;
                        for (int j = 2; j <= Math.sqrt(i); j++) {   
                                if (i % j == 0 && j < Math.sqrt(i)) {      //判断i是否能被2到i的平方根之间的数整除
                                        flg = false;
                                        break;                          //如果能被整除不是素数给flg赋false
                                }
                        }
                        if (flg) {
                                System.out.println(i);        //判断并求和
                                sum = sum + i;
                        }
                }
                System.out.print("100以内素数的和是:"+sum);  //打印结果

        }

}


评分

参与人数 1技术分 +2 收起 理由
夜默 + 2

查看全部评分

回复 使用道具 举报
题1
  1. public class test2 {
  2.                 public static void main(String[] args) {
  3.                         int i, j;
  4.                         int sum=0;//用于计算素数的总和
  5.                         // 素数即质数,除1和本身能整除以外,不能被其他数整除
  6.                         // 判断一个数n为素数,去用2-n-1整除,如果有能整除,说明这个数不是素数
  7.                         // 双重循环
  8.                         for (i = 2; i <= 100; i++) {
  9.                                 // 判断i是否为素数
  10.                                 for (j = 2; j < i; j++) // 循环j=2--i-1
  11.                                 {
  12.                                         if (i % j == 0) {
  13.                                                 break; // 跳出循环
  14.                                         }
  15.                                 }
  16.                                 if (j >= i) // 该数是素数
  17.                                 {
  18.                                         sum+=i;//累加素数                       
  19.                                 }
  20.                         }
  21.                         System.out.println(sum);//打印最终结果
  22.                 }
  23.         }
复制代码
题1结果:
题2
  1. import java.util.Arrays;
  2. public class test3 {
  3.        
  4.         public static void main(String[] args){
  5.                
  6.                 int arrayTemp[]={2,5,9,10,48,95,154,31,59,69};//声明一个数组用于保存待处理的数据
  7.                
  8.                 BubbleSort(arrayTemp);//冒泡算法排序
  9.                 //Arrays.sort(arrayTemp);调用排序方法
  10.                 System.out.println(Arrays.toString(arrayTemp));//打印排序之后的数组
  11.                 isPrime(arrayTemp);//素数判断并且将素数改为0
  12.                 System.out.println(Arrays.toString(arrayTemp));//打印更改之后的数组
  13.                 printArray(arrayTemp);//阶梯打印数组
  14.                
  15.                 /*
  16.                 for(int n=0;n<arrayTemp.length;n++){
  17.                         System.out.print(arrayTemp[n]+",");
  18.                 }
  19.                 */
  20.         }
  21.         /**
  22.          * 将数组进行阶梯状打印
  23.          * @param arrayTemp 待输出的数组
  24.          */
  25.         static void printArray(int[] arrayTemp){
  26.                 for(int i=0;i<arrayTemp.length;i++){
  27.                         for(int j=0;j<i;j++){
  28.                                 System.out.print("    ");//打印空格
  29.                         }
  30.                         System.out.println(arrayTemp[i]);//打印数组中的值
  31.                 }
  32.         }
  33.         /**
  34.          * 判定是否是素数,如果是素数即变成0
  35.          * @param arrayTemp 待判定的数组
  36.          */
  37.         static void isPrime(int[] arrayTemp){
  38.                 int i,j;
  39.                 for(i=0;i<arrayTemp.length;i++){
  40.                         for(j=2;j<arrayTemp[i];j++){
  41.                                 if(arrayTemp[i]%j==0)//判定是否是素数
  42.                                         break;//跳出循环
  43.                         }
  44.                         if(j>=arrayTemp[i]){// 该数是素数
  45.                                 arrayTemp[i]=0;
  46.                         }
  47.                        
  48.                 }
  49.         }
  50.         /**
  51.          * 冒泡排序
  52.          * @param arrayTemp 待排序的数组
  53.          */
  54.         static void BubbleSort(int[] arrayTemp){
  55.                
  56.                 for(int i=0;i<arrayTemp.length-1;i++){
  57.                         for(int j=0;j<arrayTemp.length-i-1;j++){
  58.                                 if(arrayTemp[j]>arrayTemp[j+1]){
  59.                                         int temp=0;
  60.                                         temp=arrayTemp[j];
  61.                                         arrayTemp[j]=arrayTemp[j+1];
  62.                                         arrayTemp[j+1]=temp;
  63.                                 }
  64.                         }
  65.                 }
  66.         }

  67. }
复制代码
题2结果:


题3
  1. import java.util.Scanner;


  2. public class test4 {
  3.         public static void main(String[] args){
  4.                
  5.                
  6.                 System.out.println("please enter a number:");
  7.                 Scanner in=new Scanner(System.in);//用于输入一个数值N
  8.                 int conutYH=in.nextInt();
  9.                
  10.                  int[][] array=YH(conutYH);//计算杨辉三角
  11.                  
  12.                  //开始打印杨辉三角
  13.                  for(int i=array.length-1;i>-1;i--){
  14.                          for(int n=array.length-1;n>i;n--)
  15.                                  System.out.print("  ");//控制打印空格
  16.                          for(int j=0;j<array[i].length;j++){
  17.                                  System.out.print(array[i][j]+"  ");//打印输出数值
  18.                          }
  19.                                  
  20.                          System.out.println();//换行
  21.                  }
  22.                  
  23.         }
  24.         /**
  25.          *
  26.          * @param num 杨辉三角的行数
  27.          * @return 返回保存着杨辉三角的数组
  28.          */
  29.         public static int[][] YH(int num){  
  30.         int[][] array=new int[num][];//建立一个二维数组用于保存数值  
  31.         for(int i=0;i<array.length;i++){  
  32.             array[i]=new int[i+1]; //动态生成二维数组的子数组,可以节省内存空间
  33.             for (int j = 0; j < array[i].length; j++) {  
  34.                 if(j==0||j==i){  
  35.                     array[i][j]=1; //杨辉三角的外边都是1
  36.                 }else{
  37.                          //第n行的第m个数和第n-m+1个数相等,即C(n-1,m-1)=C(n-1,n-m)
  38.                     array[i][j]=array[i-1][j-1]+array[i-1][j];
  39.                 }  
  40.             }  
  41.         }
  42.         return array;//返回保存的数组
  43.     }  

  44. }
复制代码
题3结果:

评分

参与人数 1技术分 +5 收起 理由
夜默 + 5

查看全部评分

回复 使用道具 举报
  1. package heima;

  2. import java.util.Arrays;
  3. import java.util.Scanner;

  4. public class Test01 {

  5.         public static void main(String[] args) {
  6.                 Test01 ts = new Test01();
  7.                 System.out.println("第一题:");
  8.                 ts.sushu100();
  9.                 System.out.println("\n\n第二题:");
  10.                 ts.arr();
  11.                 System.out.println("\n\n第三题:");
  12.                 ts.yagnhui();
  13.         }

  14.         // 素数判断方法
  15.         boolean isSuShu(int num) {
  16.                 for (int i = 2; i < num; i++) {
  17.                         if (num % i == 0) {
  18.                                 return false;
  19.                         }
  20.                 }
  21.                 return true;
  22.         }

  23.         // 第一题
  24.         // 1-100中的素数
  25.         void sushu100() {
  26.                 System.out.println("1-100中的素数:");
  27.                 // 1不是素数也不是和数
  28.                 for (int i = 2; i <= 100; i++) {
  29.                         if (isSuShu(i))
  30.                                 System.out.print(i + ",");
  31.                 }
  32.         }

  33.         // 第二题
  34.         void arr() {
  35.                 // 原数组
  36.                 int arr[] = { 2, 5, 9, 10, 48, 95, 154, 31, 59, 69 };

  37.                 Arrays.sort(arr);
  38.                 for (int i = 0, z = 0; i < 4; i++) {
  39.                         for (int j = 0; j <= i; j++, z++) {
  40.                                 // 替换素数
  41.                                 if (isSuShu(arr[z]))
  42.                                         arr[z] = 0;
  43.                                 System.out.print(arr[z] + " ");
  44.                         }
  45.                         System.out.println();
  46.                 }

  47.         }

  48.         // 第三题
  49.         void yagnhui() {
  50.                 // 输入行数
  51.                 // Scanner input = new Scanner(System.in);
  52.                 System.out.println("请输入行数:");
  53.                 // int n = input.nextInt();
  54.                 int n = 10;
  55.                 int mat[][] = new int[n + 1][];
  56.                 int i, j;
  57.                 // 给二维赋值
  58.                 for (i = 0; i < n + 1; i++) {
  59.                         mat[i] = new int[i + 1];
  60.                         mat[i][i] = 1;

  61.                         for (j = 1; j < i; j++) {
  62.                                 mat[i][j] = mat[i - 1][j - 1] + mat[i - 1][j];
  63.                         }
  64.                 }
  65.                 // 打印了
  66.                 for (i = mat.length - 1; i >= 0; i--) {
  67.                         for (int j2 = 0; j2 <mat.length-i; j2++) {
  68.                                 System.out.print(" ");
  69.                         }
  70.                         for (j = mat[i].length - 1; j > 0; j--)
  71.                                 System.out.print(" " + mat[i][j]);
  72.                         System.out.println();
  73.                 }
  74.         }
  75. }
复制代码
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
结果是:

第一题:
1-100中的素数:
2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,

第二题:
0
0 9
10 0 48
0 69 95 154


第三题:
请输入行数:
  1 9 36 84 126 126 84 36 9 1
      1 8 28 56 70 56 28 8 1
        1 7 21 35 35 21 7 1
          1 6 15 20 15 6 1
           1 5 10 10 5 1
             1 4 6 4 1
               1 3 3 1
                1 2 1
                 1 1
                  1
           



评分

参与人数 1技术分 +5 收起 理由
夜默 + 5

查看全部评分

回复 使用道具 举报
public class text {
        public static void main(String[] args) {
                System.out.println("100以内的素数和:"+sum(100));
                int s[]={2,5,9,10,48,95,154,31,59,69};       
                sort(s);
                System.out.print("数组改变前:");
                show(s);
                System.out.println();
                System.out.print("数组改变后:");
                update(s);
                show(s);
                System.out.println();
                showJie(s);
        }
        /**
         * 求1~n之间的素数和
         */
        public static int sum(int n){
                int sum=0;
                int i=1;
                for(i=2;i<n;i++){
                        if(IsPrime(i)==true){
                                sum+=i;
                        }
                }
               
                return sum;
        }
        /**
         * 判断一个数是否是素数
         */
        public static boolean IsPrime(int n){
                int i=0;
                for(i=2;i<n;i++){
                        if(n%i==0)
                                break;
                }
                if(i==n){
                        return true;
                }else{
                        return false;
                }
        }
        /**
         * 数组输出
         */
    public static void show(int s[]){
            for(int i=0;i<s.length;i++){
                    System.out.print(s[i]+"  ");
            }
    }
    /**
     * 数组排序
     */
    public static void sort(int s[]){
            int i=0,j=0;
            for(i=0;i<s.length-1;i++){
                    for(j=0;j<s.length-1-i;j++){
                            if(s[j]>s[j+1]){
                                    int t=0;
                                    t=s[j];
                                    s[j]=s[j+1];
                                    s[j+1]=t;
                            }
                    }
            }                 
    }
    /**
     * 置换数组中的元素
     */
    public static void update(int s[]){
            for(int i=0;i<s.length;i++){
                    if(IsPrime(s[i])==true){
                            s[i]=0;
                    }
            }
    }
    /**
     * 阶梯输出数组元素
     */
    public static void showJie(int s[]){
            for(int i=0;i<s.length;i++){
                    for(int j=0;j<i;j++){
                            System.out.print(" ");
                    }
                    System.out.println(s[i]);
            }
    }
}
结果:


aa.png (6.26 KB, 下载次数: 0)

aa.png

评分

参与人数 1技术分 +5 收起 理由
夜默 + 5

查看全部评分

回复 使用道具 举报
1.  打印输出一百以内的素数的累加和
  1. public class PrimeNumber{
  2.         public static void main (String []args) {
  3.                 //素数:指在一个大于1的自然数中,除了1和此整数自身外,不能被其他自然数整除的数。
  4.                 int j;
  5.                 int sum = 0;
  6.                 for(int n=1;n<=100;n++) {
  7.                         for(j=2;j<=n-1;j++) {
  8.                                 if(n%j==0)
  9.                                         break;
  10.                         }
  11.                         if(j>=n-1&&n>1) {
  12.                                 //System.out.print(n+",");
  13.                                 sum += n;
  14.                         }                       
  15.                 }
  16.                 System.out.println("sum="+sum);       
  17.         }

  18. }
复制代码
输出结果:

2.将该数组由小到大进行排列,数组中的素数全部赋值为零,并 按阶梯状输出。
    数组:  2   5    9    10   48     95   154     31  59    69
  1. public class PrimeArray {

  2.         public static void main(String args[]){
  3.                 int[] arr1 = {2,5,9,10,11,48,95,154,31,59,69};
  4.                 System.out.println("排序前:");
  5.                 printArr(arr1);
  6.                 int[] arr2 = arrSort(arr1);
  7.                 System.out.println("排序后:");
  8.                 printArr(arr2);
  9.                 int[] arr3 = primeArr(arr2);
  10.                 System.out.println("数组改变后:");
  11.                 printArr(arr3);
  12.                 System.out.println("阶梯输出:");
  13.                 ladPrint(arr3);
  14.         }
  15.         /**
  16.          * 使用冒泡排序对数组进行排序
  17.          * @param arr
  18.          * @return
  19.          */
  20.         public static int[] arrSort(int[] arr){
  21.                 for(int i=0;i<arr.length;i++){
  22.                         for(int j=0;j<arr.length-i-1;j++){
  23.                                 if(arr[j]>arr[j+1]){
  24.                                         int temp = arr[j];
  25.                                         arr[j]=arr[j+1];
  26.                                         arr[j+1]=temp;
  27.                                 }
  28.                         }
  29.                 }
  30.                 return arr;
  31.         }
  32.         /**
  33.          * 打印输出数组
  34.          * @param arr
  35.          */
  36.         public static void printArr(int[] arr){
  37.                 for(int i=0;i<arr.length;i++){
  38.                         System.out.print(arr[i]+" ");
  39.                 }
  40.                 System.out.println();
  41.         }
  42.         /**
  43.          * 判断数组中是否存在素数,并替换为0
  44.          * @param arr
  45.          * @return
  46.          */
  47.         public static int[] primeArr(int[] arr){
  48.                 int j;
  49.                 System.out.println("数组中存在的素数:");
  50.                 for(int i=0;i<arr.length;i++){
  51.                         //除以比自身小的数,如果没有余数,则表示能被其他数整除,不是素数
  52.                         for(j=2;j<=arr[i];j++) {
  53.                                 if(arr[i]%j==0)
  54.                                         break;
  55.                         }
  56.                         if(j>=arr[i]-1&&arr[i]>1) {
  57.                                 System.out.print(arr[i]+" ");
  58.                                 arr[i]=0;
  59.                         }
  60.                 }
  61.                 System.out.println();
  62.                 return arr;
  63.         }
  64.         /**
  65.          * 阶梯输出
  66.          * @param arr
  67.          */
  68.         public static void ladPrint(int[] arr){
  69.                 for(int i=0;i<arr.length;i++){
  70.                         for(int j=0;j<i;j++){
  71.                                 System.out.print(" ");
  72.                         }
  73.                         System.out.println(arr[i]);
  74.                 }
  75.         }
  76. }
复制代码
输出结果为:

3.手动输入一个自然数N,反向打印N行杨辉三角。
  1. import java.io.BufferedReader;
  2. import java.io.IOException;
  3. import java.io.InputStreamReader;

  4. public class Triangle {

  5.         public static void main(String args[]) throws IOException{
  6.                 int a;
  7.                 System.out.print("请输入一个整数:");
  8.                 BufferedReader strin=new BufferedReader(new InputStreamReader(System.in));
  9.                 a=Integer.parseInt(strin.readLine());
  10.                 System.out.println("输入的数是:"+a);
  11.                 calculate(a);
  12.         }
  13.         public static void calculate(int n){
  14.         //倒置杨辉三角
  15.                 for(int i=n;i>=1;i--){
  16.             for(int j=1;j<=n-i;j++){
  17.                 System.out.print(" ");
  18.             }
  19.             //打印空格后面的字符,从第1列开始往后打印
  20.             for(int j=1;j<=i;j++){
  21.                 System.out.print(num(i,j) +" ");
  22.             }
  23.             System.out.println();
  24.         }
  25.     }
  26.     public static int num(int x,int y){//第x行,第y列
  27.         if(y==1||y==x){
  28.             return 1;
  29.         }
  30.         //每一行的数字(除了第一列和最后一列)都是上一行两个数字之和
  31.         int c = num(x-1,y-1)+num(x-1,y);
  32.         return c;
  33.     }
  34. }
复制代码
结果为:

2013-06-22_082813.jpg (4.13 KB, 下载次数: 0)

2013-06-22_082813.jpg

2013-06-22_082940.jpg (29.54 KB, 下载次数: 0)

2013-06-22_082940.jpg

2013-06-22_083113.jpg (28.52 KB, 下载次数: 0)

2013-06-22_083113.jpg

评分

参与人数 1技术分 +5 收起 理由
夜默 + 5

查看全部评分

回复 使用道具 举报
这次结果对了吧!我数学常识有待提高啊!呵呵,居然把1也当素数!!
  1. /**
  2. * 打印输出一百以内的素数的累加和...
  3. */
  4. public class Sum {
  5.         public static void main (String args []) {
  6.                 int sum = 0;//初始化变量
  7.                 //循环1-100
  8.                 for (int i=1; i<=100; i++) {
  9.                         boolean f = true;
  10.                                 //判断每个数是不是素数
  11.                         if(i!=1) {       
  12.                                 for (int j=2; j<i; j++) {
  13.                                         if (i%j ==0) {
  14.                                                 f = false;
  15.                                                 break;
  16.                                                 }
  17.                                         }
  18.                                 if (!f) {continue;}
  19.                                 sum += i;//累加
  20.                                
  21.                         System.out.print(" " + i);
  22.                         }}
  23.                         System.out.println();
  24.                         System.out.println("Sum= "+sum);
  25.                
  26.                
  27.                 }       
  28.        
  29.        
  30. }
复制代码

1.jpg (9.82 KB, 下载次数: 0)

1.jpg

评分

参与人数 1技术分 +2 收起 理由
夜默 + 2

查看全部评分

回复 使用道具 举报
yooc 中级黑马 2013-6-22 09:14:18
68#
  1. /*
  2. ********************
  3. 项目名:黑马版主题解
  4. 作者:yooc

  5. 满分13分吗?我来冲刺满分:)  早上6点开始除去吃饭时间用时2小时40分钟

  6. 本代码可直接复制执行  方便版主检测!

  7. ********************
  8. */

  9. import java.util.*;

  10. class  HeimaTest
  11. {

  12.         //主函数
  13.         public static void main(String[] args)
  14.         {
  15.                 sop("***********题目1**********");
  16.                 timu1();        //执行题目1
  17.                 sop("***********题目2**********");
  18.                 timu2();        //执行题目2
  19.                 sop("***********题目3**********");
  20.                 timu3();        //执行题目3

  21.         }

  22.         //功能函数 打印到控制台
  23.         public static void sop(Object obj)  
  24.         {
  25.                 System.out.println(obj);
  26.         }

  27.         //********题目1 求素数********
  28.         public static void timu1()         
  29.         {
  30.                 int N = 100;                         //范围
  31.                 int i, j,temp=0;
  32.                 sop("100以内的素数有:");
  33.                 for (i = 2; i <= 100; i++)   //求素数开始
  34.                 {
  35.                         for (j = 2; j < i; j++)   
  36.                         if (i % j== 0)         //不满足素数条件直接跳出内循环
  37.                                 break;

  38.                         if(j==i)          //内循环没有中途跳出 则找到素数一枚
  39.                         {
  40.                                 System.out.print(i+" "); //输出单个素数
  41.                                 temp+=i;     //记录累加和
  42.                         }

  43.                 }
  44.                 sop("\n累加和为:"+temp);  //输出结果
  45.         }
  46.         //********题目1结束********



  47.         /*
  48.         ********题目2********
  49.         将该数组由小到大进行排列,数组中的素数全部赋值为零,并 按阶梯状输出。
  50.         数组:  2   5    9    10   48     95   154     31  59    69
  51.         */
  52.         public static void timu2()  
  53.         {
  54.                 int i,j;
  55.                 int[] a = {2,5,9,10,48,95,154,31,59,69};
  56.                 Arrays.sort(a);      //将数组排序

  57.                 sop("数组排序后:");
  58.                 sop(Arrays.toString(a));

  59.                 for (i=0;i<a.length;i++)
  60.                 {
  61.                         for (j = 2; j < a[i]; j++)  //判断数组a中有无素数
  62.                         if (i % j== 0)         //不满足素数条件直接跳出内循环
  63.                                 break;

  64.                         if(j==a[i])          //内循环没有中途跳出 则找到素数一枚
  65.                         {
  66.                                 a[i]=0;        //将其置0
  67.                         }
  68.                        
  69.                 }
  70.                 sop("数组改变后:");
  71.                 sop(Arrays.toString(a));

  72.                 //按题目要求将其输出
  73.                 for (int m=0;m<a.length ;m++ )
  74.                 {
  75.                         for (int n=0;n<m ;n++ )
  76.                         {
  77.                                 System.out.print(" ");
  78.                         }
  79.                         sop(a[m]);
  80.                 }

  81.         }
  82.         //******题目2结束********


  83.         /*
  84.         ********题目3********
  85.         手动输入一个自然数N,反向打印N行杨辉三角。       
  86.         */       
  87.         public static void timu3()
  88.         {
  89.                 StringBuilder sb = new StringBuilder();  //创建字符串缓冲 以字符为单位存入数据
  90.                 List<String> al = new ArrayList<String>();               //创建list集合 以行为单位存入数据  (反转用)

  91.                 try
  92.                 {
  93.                         //手动输入一个自然数N,反向打印N行杨辉三角。       
  94.                         Scanner ss=new Scanner(System.in);
  95.                         System.out.print("请输入一个数(建议不大于10):");
  96.                         int n=(int)ss.nextInt()+1;
  97.                        
  98.                         //根据 mat[i][j] = mat[i - 1][j - 1] + mat[i - 1][j] 计算杨辉三角         
  99.                         int mat[][] = new int[n][];
  100.                         int i, j;
  101.                         for (i = 0; i < n; i++)
  102.                         {
  103.                                 mat[i] = new int[i + 1];
  104.                                 mat[i][i] = 1;        //最右边全为1
  105.                                 for (j = 1; j < i; j++)
  106.                                 {
  107.                                         mat[i][j] = mat[i - 1][j - 1] + mat[i - 1][j];
  108.                                 }

  109.                         }
  110.                         for (i = 0; i < mat.length; i++)
  111.                         {
  112.                                 for (j = 1; j < n - i; j++)
  113.                                 {
  114.                                         sb.append(" ");        //字符缓冲器存入 循环次数为每行前边的空格数
  115.                                 }

  116.                                 for (j = 1; j < mat[i].length; j++)
  117.                                 {
  118.                                         if (mat[i][j]!=0)
  119.                                         {
  120.                                                 sb.append(" " + mat[i][j]);  //字符缓冲器存入主要数据
  121.                                         }

  122.                                 }
  123.                                 al.add(sb.toString());   //字符缓冲器所有数据存入 List集合
  124.                                 sb.delete(0,sb.length());//字符缓冲器清空 以便继续循环
  125.                         }

  126.                         //逆序输出List集合所有元素
  127.                         for (int k = al.size()-1;k>0 ;k-- )
  128.                         {
  129.                                 System.out.println(al.get(k));
  130.                         }

  131.                 }

  132.                
  133.                 catch(Exception e)
  134.                 {
  135.                         e.printStackTrace();
  136.                 }

  137.         }
  138.         //******题目3结束********





  139. }
复制代码
贴出来排版没有了  郁闷
结果如下:
输入4


输入7


评分

参与人数 1技术分 +5 收起 理由
夜默 + 5 封顶5分,不然我搞俩次活动,你分就够了....

查看全部评分

回复 使用道具 举报
package com.itheima;
import java.util.Arrays;
public class Test {
/**
  * @param args
  */
public static void main(String[] args) {
  // TODO Auto-generated method stub
  //定义一个int类型数组进行保存这些数
  int []number={2,5,9,10,48,95,154,31,59,69};
  //用Arrays.sort排序函数进行排序
  Arrays.sort(number);
  
  //进行素数判断
  for(int i=0,j;i<number.length;i++){
   //用Math.sqrt求平方根
   int n=(int)Math.sqrt(number[i]);
   //放到循环里判断是否符合条件
   for(j=2;j<=n;j++){
    if(number[i]%j==0){  
     break;
    }
   }
   //如果是素数进行赋值为零
   if(j>n){
    number[i]=0;
   }
  }
  System.out.println();
  
  
  
  //用嵌套循环进行控制格式打印
  for(int i=0;i<number.length;i++){
   //每行缩进的格式控制
   for(int j=0;j<i;j++){
     System.out.print(" ");
   }
   System.out.print(number[i]);
   System.out.print("\n");
  }
}
}



经过不断的改进代码,查资料,我终于做出了我认为正确的答案。通过此次的答题我认识到了自己还是太马虎,您一而再再而三的给我机会,衷心的感谢您的指出错误。请您验收。

QQ截图20130622091217.png (4.68 KB, 下载次数: 0)

QQ截图20130622091217.png

评分

参与人数 1技术分 +3 收起 理由
夜默 + 3

查看全部评分

回复 使用道具 举报
唉,没检查代码,出糗了。版主我修改了。。

  1. <P>为了节约空间,值贴出for循环的那一部分。 </P>
复制代码
太粗心了,呵呵~

QQ拼音截图未命名.png (19.5 KB, 下载次数: 0)

QQ拼音截图未命名.png

评分

参与人数 1技术分 +2 收起 理由
夜默 + 2

查看全部评分

回复 使用道具 举报
本帖子需要验证码才可查看,请输入验证码:heima 即可正常访问  
回复 使用道具 举报

public class HeiMa {
/**
  * @param args
  */
public static void main(String[] args) {
  // TODO Auto-generated method stub
  //定义一个变量进行保存素数的和
        int num=0;
        //把这些数字放到循环中判断是否是素数
  for(int i=2,j;i<100;i++){
   //用Math.sqrt方法求平方根
   int n=(int)Math.sqrt(i);
   
   for(j=2;j<=n;j++){
    if(i%j==0){
     break;
    }
   }
   //将是素数的数进行累加
   if(j>n){
    num+=i;
   
   
   }
  }System.out.println(num);
}

}


请您验收,您辛苦了。

1.png (5.44 KB, 下载次数: 0)

1.png

评分

参与人数 1技术分 +2 收起 理由
夜默 + 2

查看全部评分

回复 使用道具 举报
1.  打印输出一百以内的素数的累加和...
  1. public class Num {
  2.         public static void main(String[] args)
  3.         {
  4.                 int flag;  //定义标识数 1表示素数  0表示非素数
  5.                 int sum=0;  
  6.                 for(int i=2;i<=100;i++)  //
  7.                 {
  8.                         flag=1;
  9.                         for(int m=2;m<=i/2;m++)
  10.                         {//如果这个数能被整除,则为非素数,flag 标识变为0
  11.                                 if(i%m==0)  
  12.                                         flag=0;                               
  13.                         }       
  14.                        
  15.                         if(flag==1) //如果这个数是素数,则累加
  16.                         {
  17.                                 sum+=i;
  18.                         }
  19.                 }
  20.                 System.out.println(sum);
  21.         }
  22. }
复制代码

评分

参与人数 1技术分 +2 收起 理由
夜默 + 2

查看全部评分

回复 使用道具 举报
萧萧北 发表于 2013-6-22 09:55
1.  打印输出一百以内的素数的累加和...

运算结果为:1060

版主不好意思哈,忘记贴上我的结果了
回复 使用道具 举报
  1. 第一题:
  2. /*
  3. * 1.  打印输出一百以内的素数的累加和...  
  4. * */
  5. public class test1 {
  6.         public static void main(String[] args)
  7.         {
  8.                 int sum=1;
  9.                 p:for(int i=2;i<100;i++)//标记循环跳出的位置和控制循环100以内的整数
  10.                 {
  11.                         for(int j=2;j<i;j++)//控制循环的次数
  12.                                 if(i%j==0)      //判断是否为素数
  13.                                         continue p;//是的话,跳到标记的循环位置,继续下一次循环
  14.                                 sum=sum+i;     //是素数的话,累加
  15.                                 System.out.print(i+" ");        //打印所有的素数                               
  16.                                                                                                                                                        
  17.                 }
  18.                 System.out.println();
  19.                 System.out.println("素数和为:"+sum);
  20.         }
  21. }

  22. 第二题:

  23. /*
  24. * 2.将该数组由小到大进行排列,数组中的素数全部赋值为零,并 按阶梯状输出。
  25.     数组:  2   5    9    10   48     95   154     31  59    69
  26. * */
  27. public class Test2 {
  28.         public static void main(String[] args)
  29.         {
  30.                 int[] arr={2,5,9,10,48,95,154,31,59,69};
  31.                 for(int i=0;i<arr.length;i++)//把数组从大到小排序
  32.                 {
  33.                         for(int j=i+1;j<arr.length;j++)
  34.                         {
  35.                                 if(arr[i]>arr[j])
  36.                                         {
  37.                                                 int temp=arr[i];
  38.                                                 arr[i]=arr[j];
  39.                                                 arr[j]=temp;
  40.                                         }
  41.                         }               
  42.                 }
  43.                 for(int i=0;i<arr.length;i++)//打印排完序的数组
  44.                         System.out.print(arr[i]+" ");
  45.                 System.out.println();
  46.                 for(int i=0;i<arr.length;i++)//把数组中是素数的数置为零
  47.                 {
  48.                         for(int j=2;j<arr[i];j++)
  49.                         {        if(arr[i]%j==0)      
  50.                                         arr[i]=0;       
  51.                         }
  52.                 }
  53.                 for(int i=0;i<arr.length;i++)//控制循环次数
  54.                 {
  55.                         for(int j=0;j<i;j++)//控制打印空格的次数
  56.                         {
  57.                                         System.out.print(" ");
  58.                         }
  59.                         System.out.println(arr[i]);
  60.                                
  61.                 }
  62.                
  63.         }
  64.        
  65. }
复制代码
回复 使用道具 举报
public class cx5
{
public static void main(String[] args){
  //用来存储和
  int sum = 0;
  //默认该整数是素数
  boolean sS = true;
//2到该数的前一个数如果没有可以被该数整除的则为素数,否则不为素数sS修改的false
for(int i = 2;i <= 100;i++){
  //1不是素数
  for(int j = 2;j < i; j++){
   if(i%j == 0){
   sS = false;
   break;  
   }  
  }   
if(sS){
  sum += i;
}   
  //素数标志器初始化
  sS = true;
}   
System.out.println("1到100之间素数的和为:" + sum);
}
}
//先做一道。。。后面的在想想。。

QQ图片20130622112503.jpg (6.79 KB, 下载次数: 0)

QQ图片20130622112503.jpg

评分

参与人数 1技术分 +2 收起 理由
夜默 + 2

查看全部评分

回复 使用道具 举报
第一题:
  1. /*1. 题目打印输出一百以内的素数的累加和...*/
  2. /*
  3. * 素数:在一个大于1的自然数中,除了1和此整数自身外,不能被其他自然数整除的数
  4. * */
  5. /*
  6. * 思路:首先利用循环(1-100)检验每一个数是否是素数
  7. *                  如果是  累加到一个表示和的变量里面
  8. * */
  9. public class Test1 {
  10.         public static void main(String[] args) {
  11.                 //素数的定义是除了1以外 所以 1-100这个范围的素数最小是2  下界定为2
  12.                 int lowPrimeBound =2;
  13.                 //素数的定义是除了1以外 所以 1-100这个范围的素数最小是2
  14.                 int upPrimeBound =100;
  15.                
  16.                 //prime含义是素数  isPrime这个变量值为true表示是素数  这里初始化
  17.                 boolean isPrime =true;
  18.                
  19.                 //primeSum用来记录给定范围的所有素数的和的变量
  20.                 int primeSum =0;
  21.                 //外层循环用:
  22.                         //--来检测给定范围的数有哪些是素数
  23.                 System.out.println("["+ lowPrimeBound+ ", "+upPrimeBound+"]的素数有:");
  24.                 for(int i=lowPrimeBound; i<=upPrimeBound; i++){
  25.                         //内层循环的作用:
  26.                         //--根据素数的定义 :在一个大于1的自然数中,除了1和此整数自身外,不能被其他自然数整除的数
  27.                         //--要对给定的数 i 判定除了1和自身(i)以外的整数 是不是有能被i整除的
  28.                         for(int j=2; j<i; j++){
  29.                                 if(i%j==0){ //如果能被整除 整除标记isPrime标记为false  表示不是素数
  30.                                         isPrime =false;
  31.                                         //开区间(1, i)之间一旦有一个数能整除i
  32.                                         //--就表示i不是素数  直接跳出  不用继续进行判断 节省计算量
  33.                                         break;
  34.                                 }
  35.                                 //如果(1, i)之间都没有能整出i的数出现, 就表示这个数i是素数  要更新isPrime
  36.                                 isPrime =true;
  37.                         }
  38.                        
  39.                         if(isPrime){
  40.                                 primeSum += i;
  41.                                 System.out.print(i +" ");
  42.                         }
  43.                 }
  44.                 System.out.println();
  45.                 System.out.println("["+ lowPrimeBound+ ", "+upPrimeBound+"]的素数的和是:"+ primeSum);
  46.         }
  47. }
复制代码
回复 使用道具 举报
版主 不好意思  刚才寻思 发完  编辑一下 但是 发现不能编辑 只能重新回复
第一题:
  1. /*1. 题目打印输出一百以内的素数的累加和...*/
  2. /*
  3. * 素数:在一个大于1的自然数中,除了1和此整数自身外,不能被其他自然数整除的数
  4. * */
  5. /*
  6. * 思路:首先利用循环(1-100)检验每一个数是否是素数
  7. *                  如果是  累加到一个表示和的变量里面
  8. * */
  9. public class Test1 {
  10.         public static void main(String[] args) {
  11.                 //素数的定义是除了1以外 所以 1-100这个范围的素数最小是2  下界定为2
  12.                 int lowPrimeBound =2;
  13.                 //素数的定义是除了1以外 所以 1-100这个范围的素数最小是2
  14.                 int upPrimeBound =100;
  15.                
  16.                 //prime含义是素数  isPrime这个变量值为true表示是素数  这里初始化
  17.                 boolean isPrime =true;
  18.                
  19.                 //primeSum用来记录给定范围的所有素数的和的变量
  20.                 int primeSum =0;
  21.                 //外层循环用:
  22.                         //--来检测给定范围的数有哪些是素数
  23.                 System.out.println("["+ lowPrimeBound+ ", "+upPrimeBound+"]的素数有:");
  24.                 for(int i=lowPrimeBound; i<=upPrimeBound; i++){
  25.                         //内层循环的作用:
  26.                         //--根据素数的定义 :在一个大于1的自然数中,除了1和此整数自身外,不能被其他自然数整除的数
  27.                         //--要对给定的数 i 判定除了1和自身(i)以外的整数 是不是有能被i整除的
  28.                         for(int j=2; j<i; j++){
  29.                                 if(i%j==0){ //如果能被整除 整除标记isPrime标记为false  表示不是素数
  30.                                         isPrime =false;
  31.                                         //开区间(1, i)之间一旦有一个数能整除i
  32.                                         //--就表示i不是素数  直接跳出  不用继续进行判断 节省计算量
  33.                                         break;
  34.                                 }
  35.                                 //如果(1, i)之间都没有能整出i的数出现, 就表示这个数i是素数  要更新isPrime
  36.                                 isPrime =true;
  37.                         }
  38.                        
  39.                         if(isPrime){
  40.                                 primeSum += i;
  41.                                 System.out.print(i +" ");
  42.                         }
  43.                 }
  44.                 System.out.println();
  45.                 System.out.println("["+ lowPrimeBound+ ", "+upPrimeBound+"]的素数的和是:"+ primeSum);
  46.         }
  47. }
复制代码
运行结果:

第二题代码:
  1. /*2. 将该数组由小到大进行排列,数组中的素数全部赋值为零,并 按阶梯状输出。*/
  2. /*
  3. *思路:首先采用一种排序算法将数组进行排序-- 采用选择排序
  4. *              然后对排序后的数组的每一个元素进行素数条件检测  检测到是素数  清零
  5. *             最后 阶梯打印该数组
  6. */
  7. public class Test2 {
  8.         public static void main(String[] args) {
  9.                 int[] arr ={2, 5, 9, 10, 48, 95, 154, 31, 59, 69};
  10.                 //Step1. 对数组进行排序 ---采用选择排序
  11.                 selectSort(arr);
  12.                 System.out.print("改变前:");
  13.                 //****改变前 --打印输出测试
  14.                 printArry(arr);
  15.                
  16.                 //Step2. 对数组中的每一个数进行素数检测  并置换为0
  17.                 primeChange(arr);
  18.                 System.out.println();
  19.                 System.out.print("改变后:");
  20.                 //****改变后 --打印输出测试
  21.                 printArry(arr);
  22.                
  23.                 //Step3. 阶梯状打印数组元素
  24.                 stagePrintArry(arr);
  25.         }
  26.        
  27.         //阶梯状打印数组元素 ---实际上在对角线上进行数组元素的打印---打印三角形
  28.         private static void stagePrintArry(int[] arr) {
  29.                 //优化显示信息
  30.                 System.out.println();
  31.                 //外层循环控制打印的行数
  32.                 //---由于一个元素占据一行 所以  一共打印的行数就是数组中元素的个数
  33.                 for(int i=0; i< arr.length; i++){
  34.                         for(int j=1; j<=i+1; j++){
  35.                                 //对角线元素  打印该数组的元素
  36.                                 if(i==j)
  37.                                         System.out.print(arr[i]);
  38.                                 else
  39.                                         System.out.print(" ");
  40.                         }
  41.                         System.out.println();
  42.                 }
  43.         }

  44.         //打印数组元素
  45.         private static void printArry(int[] arr) {
  46.                 for(int x: arr){
  47.                         System.out.print(x +" ");
  48.                 }
  49.         }
  50.        
  51.         //对数组中的素数进行清零
  52.         private static void primeChange(int[] arr) {
  53.                 for(int x =0; x<arr.length; x++){
  54.                         if(isPrime(arr[x]))//是素数  元素清零
  55.                                 arr[x] =0;
  56.                 }
  57.         }
  58.        
  59.         //判断一个数是否为素数
  60.         private static boolean isPrime(int num) {
  61.                 boolean isPrime =true;
  62.                 //--根据素数的定义 :在一个大于1的自然数中,除了1和此整数自身外,不能被其他自然数整除的数
  63.                 //--要对给定的数 i 判定除了1和自身(num)以外的整数 是不是有能被i整除的
  64.                 for(int i=2; i<num; i++){
  65.                         if(num%i==0){ //如果能被整除 整除标记isPrime标记为false  表示不是素数
  66.                                 isPrime =false;
  67.                                 //开区间(1, i)之间一旦有一个数能整除i
  68.                                 //--就表示i不是素数  直接跳出  不用继续进行判断 节省计算量
  69.                                 break;
  70.                         }
  71.                         //如果(1, i)之间都没有能整出i的数出现, 就表示这个数i是素数  要更新isPrime
  72.                         isPrime =true;
  73.                 }
  74.                 return isPrime;
  75.         }

  76.         //对数组进行选择排序
  77.         private static void selectSort(int[] arr) {
  78.                 //循环数组中的元素 --- 每完成一次外层循环  数组对应的位置就是本次循环中最小的值
  79.                 //--i< arr.length-1 最后一次的时候 一定是循环到数组的最后一个元素  最后一个元素已经没有
  80.                 //--要比较的对象了 所以 将i< arr.length改为 i< arr.length -1
  81.                 for(int i =0; i< arr.length-1; i++){
  82.                         //每个位置的元素都要和该位置以后素组元素比较
  83.                         for(int j =i+1; j <arr.length; j++){
  84.                                 //升序排列 --前面的数大了  就要和后面的交换
  85.                                 if(arr[i] >arr[j])
  86.                                         swap(i, j, arr);
  87.                         }
  88.                 }
  89.         }

  90.         //交换数组中两个元素的位置
  91.         private static void swap(int i, int j, int[] arr) {
  92.                 int temp =arr[i];
  93.                 arr[i] =arr[j];
  94.                 arr[j] =temp;
  95.         }
  96. }
复制代码
运行结果:

第三题代码:
  1. /*3.倒序杨辉三角*/
  2. import java.util.ArrayList;
  3. public class Test3 {
  4.         public static void main(String[] args) {
  5.                 int layers =4;
  6.                 //Step1. 产生杨辉三角列表
  7.                 ArrayList<ArrayList<Integer>> yanghuiTrList = generateYangTrList(layers);
  8.                 System.out.println("产生的杨辉列表如下:");
  9.                 printYanghuiList(yanghuiTrList);
  10.                
  11.                 //Step2.倒序打印杨辉三角
  12.                 System.out.println("倒序打印杨辉三角如下:");
  13.                 printInverseYanghuiArr(layers, yanghuiTrList);
  14.         }
  15.        
  16.         /**
  17.          * function: 倒序打印杨辉三角
  18.          * @param layers ---表示杨辉三角的层数
  19.          * @param yanghuiTrList ----杨辉三角的列表
  20.          */
  21.         private static void printInverseYanghuiArr(int layers,
  22.                         ArrayList<ArrayList<Integer>> yanghuiTrList) {
  23.                 //Step1. 控制打印的行数
  24.                 for(int i=1, layer =layers-1; i<=layers; i++, layer--){
  25.                         //先打印空格部分  填充空白区域
  26.                         for(int j=1; j<= i-1; j++){
  27.                                 System.out.print(" ");
  28.                         }
  29.                        
  30.                         //取出本层的杨辉数字列表
  31.                         ArrayList<Integer> eachLayerList =yanghuiTrList.get(layer);
  32.                        
  33.                         int index =0;
  34.                         for(int j=1; j<=9 -2*i; j++){
  35.                                 if(j%2 ==0)//隔一位打印一个数字
  36.                                         System.out.print(" ");
  37.                                 else{
  38.                                         System.out.print(eachLayerList.get(index));
  39.                                         index++;
  40.                                 }
  41.                         }
  42.                         System.out.println();
  43.                 }
  44.         }
  45.        
  46.         //打印杨辉列表  -- 测试使用
  47.         private static void printYanghuiList(
  48.                         ArrayList<ArrayList<Integer>> yanghuiTrList) {
  49.                 System.out.println("**************************************");
  50.                 for(int i=0; i<yanghuiTrList.size(); i++){
  51.                         for(int j=0; j<yanghuiTrList.get(i).size(); j++){
  52.                                 System.out.print(yanghuiTrList.get(i).get(j)+ " ");
  53.                         }
  54.                         System.out.println();
  55.                 }
  56.                 System.out.println("**************************************");
  57.         }

  58.         //产生杨辉三角列表  方法的参数表示产生几层杨辉三角
  59.         private static ArrayList<ArrayList<Integer>> generateYangTrList(int layers) {
  60.                 ArrayList<ArrayList<Integer>> trList =new ArrayList<ArrayList<Integer>>();
  61.                 ArrayList<Integer> eachLayerList =null;
  62.                 //顺序产生各层杨辉列表
  63.                 for(int i=0; i<layers; i++){
  64.                         eachLayerList =new ArrayList<Integer>();
  65.                        
  66.                         //第0层杨辉列表: 1
  67.                         if(i==0){
  68.                                 eachLayerList.add(1);
  69.                                 trList.add(eachLayerList);
  70.                                 continue;
  71.                         }
  72.                        
  73.                         //第1层杨辉列表: 1  1
  74.                         if(i==1){
  75.                                 eachLayerList.add(1);
  76.                                 eachLayerList.add(1);
  77.                                 trList.add(eachLayerList);
  78.                                 continue;
  79.                         }
  80.                        
  81.                         //第0, 1层以外的杨辉列表
  82.                         //--每层杨辉列表的首数字都为1
  83.                         eachLayerList.add(1);
  84.                        
  85.                         //取出最后一次的杨辉列表  一共下面累加获得本层的杨辉列表的元素
  86.                         ArrayList<Integer> lastList =trList.get(trList.size()-1);
  87.                        
  88.                         //累加上一层的相邻两个元素进行求和
  89.                         for(int startIndex =0; startIndex <lastList.size() -1; startIndex++){
  90.                                 int adjacentSum =lastList.get(startIndex)+ lastList.get(startIndex+1);
  91.                                 eachLayerList.add(adjacentSum);
  92.                         }
  93.                         //--每层杨辉列表的尾数字都为1
  94.                         eachLayerList.add(1);
  95.                        
  96.                         trList.add(eachLayerList);
  97.                 }
  98.                 return trList;
  99.         }
  100. }
复制代码
运行结果:

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

第一题结果

第一题结果

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

第二题运行结果

第二题运行结果

test3.jpg (38.73 KB, 下载次数: 0)

第三题运行结果

第三题运行结果

评分

参与人数 1技术分 +5 收起 理由
夜默 + 5

查看全部评分

回复 使用道具 举报
2.将该数组由小到大进行排列,数组中的素数全部赋值为零,并 按阶梯状输出。
    数组:  2   5    9    10   48     95   154     31  59    69
  1. package test;

  2. public class Num2 {
  3.         public static void main(String[] args)
  4.         {
  5.                 int[] arr={2,5,9,10,48,95,154,31,59,69};
  6.                 bubbleSort(arr);   //调用排序功能
  7.                 isS(arr);                        //调用判断素数功能
  8.                 printArray(arr);        //调用输出数组功能       
  9.         }
  10.        
  11.         //定义冒泡排序功能  由小到大
  12.         static public void bubbleSort(int[] arr)
  13.         {
  14.                 for(int x=arr.length-1;x>0;x--)
  15.                 {       
  16.                         for(int y=0;y<x;y++)
  17.                         {
  18.                                 if(arr[y]>arr[y+1])
  19.                                 {
  20.                                         int temp=arr[y];
  21.                                         arr[y]=arr[y+1];
  22.                                         arr[y+1]=temp;
  23.                                 }
  24.                         }                       
  25.                 }
  26.         }
  27.        
  28.         //定义按阶梯状输出 数组中元素
  29.         public static void printArray(int[] arr)
  30.         {
  31.                 for(int i=0;i<arr.length;i++)
  32.                 {       
  33.                         for(int j=0;j<=i;j++)
  34.                         {//实现按阶梯状输出  根据行数空出相应的空格
  35.                                 System.out.print(" ");
  36.                         }
  37.                         System.out.println(arr[i]); //输出数组元素
  38.                 }
  39.         }
  40.        
  41.         //判断素数的函数
  42.         public static void isS(int[] arr)
  43.         {
  44.                 int flag;  //定义标识数 1表示素数  0表示非素数
  45.                 for(int i=0;i<arr.length;i++)
  46.                 {
  47.                         flag=1;
  48.                         for(int m=2;m<=arr[i]/2;m++)
  49.                         {//如果这个数能被整除,则为非素数,flag 标识变为0
  50.                                 if(arr[i]%m==0)  
  51.                                         flag=0;                               
  52.                         }       
  53.                         //如果这个数是素数则赋值为0
  54.                         if(flag==1)
  55.                         {
  56.                                 arr[i]=0;   
  57.                         }
  58.                        
  59.                 }
  60.         }
  61. }
复制代码
回复 使用道具 举报
萧萧北 发表于 2013-6-22 12:23
2.将该数组由小到大进行排列,数组中的素数全部赋值为零,并 按阶梯状输出。
    数组:  2   5    9    10 ...

.将该数组由小到大进行排列,数组中的素数全部赋值为零,并 按阶梯状输出

运算结果为:

搜狗截图_2013-06-22_12-24-59.png (2.56 KB, 下载次数: 0)

2题 运算结果

2题 运算结果

评分

参与人数 1技术分 +5 收起 理由
夜默 + 5

查看全部评分

回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马