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

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

正文中的内容不知道怎样设置版主或作者可见
回复 使用道具 举报
只有附件才能设置权限?不是附件不知道怎么弄了

点评

版主的权限,你只要答题就行了  发表于 2013-6-21 18:46
回复 使用道具 举报
这是第一题,上面那个是第二题,看错了
public class Demo{
public static void main(String args[]){
  int sum = 0 ;
  boolean flag ;
  for(int i = 2 ; i<=100 ; i++){   
   flag = true ;
   for(int j = 2; j< i ; j++){
    if(i%j==0){                   //判断是否是素数
     flag = false ;
     break ;
    }
   }
   if(flag){                         //如果是素数,则加上
    sum += i ;
      }
  }
  System.out.print(sum) ;
}
}


评分

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

查看全部评分

回复 使用道具 举报
不好意思,理解反了,没有看清题...{:soso_e127:}
老师真是大神呵呵,您辛苦了



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;i<number.length;i++){
   System.out.print(" "+number[i]);
   if(number[i]%2!=0||number[i]==2){
   
    number[i]=0;
    continue;
   }
  }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");
  }
  
  
}
}

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

0.png

点评

再给你最后一次机会,去查下素数的概念...判定还是不对  发表于 2013-6-21 18:51
回复 使用道具 举报
之前第二题错了,现在改正
import java.util.*;
public class ArrayDemo{
        public static void main(String args[]){
                int temp[] = {2,5,9,10,48,95,154,31,59,69} ;  //定义整数数组
                System.out.print("数组改变前:") ;         
                fun(temp) ;                                                                          //输出改变前的数组
                Arrays.sort(temp);                                                          //升序排列数组
                System.out.print("数组改变后:") ;            
                fun(temp) ;                        //输出改变后的数组
                boolean flag ;
                for(int i = 0 ; i<temp.length ; i++){   
                        flag = true ;
                        for(int j = 2; j< temp ; j++){
                                if(temp%j==0){                   //判断是否是素数
                                        flag = false ;
                                        break ;
                                }
                        }
                        if(flag){                         //如果是素数则变为0
                          temp=0 ;
                    }
                }
                System.out.print("将数组中的素数变为0:");
                fun(temp) ;                                   //输出判断后的数组
                for(int i=0 ; i<temp.length ; i++){           //按阶梯状输出
                        for(int j= 0 ; j<= i ; j++){                                                  
                                System.out.print(" ") ;
                        }
                        System.out.println(temp) ;
                }
        }

        public static void fun(int temp[]){                                  //定义一个打印数组的方法
                for(int i=0;i<temp.length;i++){
                        System.out.print(temp+"\t") ;
                }
                System.out.println();                         //输出完后换行
        }
}


评分

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

查看全部评分

回复 使用道具 举报
第一题:
  1. public class Test1 {
  2.         public static void main(String[] args){
  3.                 primeSum(100);
  4.         }
  5.         private static void primeSum(int n) {
  6.                 int sum = 0;
  7.                 //遍历2到100之间的自然数,为素数则累加
  8.                 for(int i=2; i<n; i++){
  9.                         if(isPrimeNumber(i)){
  10.                                 System.out.print(i+" ");
  11.                                 sum+=i;
  12.                         }
  13.                 }
  14.                 System.out.println(sum);
  15.         }
  16.         //素数判断方法
  17.         private static boolean isPrimeNumber(int n) {
  18.                 int m = 0;
  19.                 //不能被2到自身平方根的数整除,则为素数
  20.                 for(int i=2;i<=Math.sqrt(n);i++){
  21.                         if(n%i==0)
  22.                                 m++;
  23.                 }
  24.                 return m==0;
  25.         }
  26. }
复制代码
输出结果:1060
第二题:
  1. import java.util.Arrays;

  2. public class Test2 {

  3.         /**
  4.          * @param args
  5.          */
  6.         public static void main(String[] args) {
  7.                 int[] arr = new int[]{2,5,9,10,48,95,154,31,59,69};
  8.                 mySort(arr);
  9.         }

  10.         private static void mySort(int[] arr) {
  11.                 //从小到大,自然排序即可
  12.                 Arrays.sort(arr);
  13.                 System.out.print("改变前数组: ");
  14.                 //打印排序后数组
  15.                 for(int i=0; i<arr.length;i++){
  16.                         if(i==arr.length-1)
  17.                                 System.out.println(arr[i]+" ");
  18.                         else
  19.                                 System.out.print(arr[i]+" ");
  20.                 }
  21.                 System.out.println("输出数组: ");
  22.                 for(int i=0; i<arr.length;i++){
  23.                         //遍历数组所有元素,如果是素数,则用0取代
  24.                         if(isPrimeNumber(arr[i]))
  25.                                 arr[i] = 0;
  26.                         //阶梯打印数组元素
  27.                         for(int j=0; j<i; j++){
  28.                                 System.out.print(" ");
  29.                         }
  30.                         System.out.println(arr[i]);
  31.                 }
  32.         }
  33.         private static boolean isPrimeNumber(int n) {
  34.                 int m = 0;
  35.                 //不能被2到自身平方根的数整除,则为素数
  36.                 for(int i=2;i<=Math.sqrt(n);i++){
  37.                         if(n%i==0)
  38.                                 m++;
  39.                 }
  40.                 return m==0;
  41.         }
  42. }
复制代码
输出结果:
改变前数组: 2 5 9 10 31 48 59 69 95 154
输出数组:
0
0
  9
   10
    0
     48
      0
       69
        95
         154

第三题:
  1. public class Test3 {

  2.         /**
  3.          * @param args
  4.          */
  5.         public static void main(String[] args) {
  6.                 triangleMath(3);
  7.                 System.out.println("----------");
  8.                 triangleMath(4);
  9.                 System.out.println("----------");
  10.                 triangleMath(5);
  11.         }
  12.         private static void triangleMath(int n) {
  13.                 for(int i=n; i>0; i--){
  14.                         //获取代表每行数字的数组
  15.                         int[] arr = triangleArray(i);
  16.                         sopSpace(n-i);
  17.                         //按需求打印数组元素
  18.                         for(int j=0; j<arr.length; j++){
  19.                                 if(j==arr.length-1)
  20.                                         System.out.println(arr[j]);
  21.                                 else
  22.                                         System.out.print(arr[j]+" ");
  23.                         }
  24.                 }
  25.         }
  26.         //空格输出补偿
  27.         private static void sopSpace(int n) {
  28.                 for(int i=0; i<n; i++)
  29.                         System.out.print(" ");
  30.         }
  31.         //获取代表每行数字的数组的方法
  32.         private static int[] triangleArray(int n) {
  33.                 if(n>1){
  34.                         int[] arr = new int[n];
  35.                         //第一个和最后一个数字为1
  36.                         arr[0] = 1;
  37.                         arr[n-1] = 1;
  38.                         //第i个数字为上一行第i-1数与上一行第i数之和
  39.                         int[] previous = triangleArray(n-1);
  40.                         for(int i=1; i<arr.length-1;i++){
  41.                                 arr[i] = previous[i-1]+previous[i];
  42.                         }
  43.                         return arr;
  44.                 }
  45.                 //第一行为1
  46.                 else
  47.                         return new int[]{1};
  48.         }

  49. }
复制代码
输出结果:
1 2 1
1 1
  1
----------
1 3 3 1
1 2 1
  1 1
   1
----------
1 4 6 4 1
1 3 3 1
  1 2 1
   1 1
    1

评分

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

查看全部评分

回复 使用道具 举报
/*
第一题:

需求:将数组由小到大进行排列,数组中的素数全部赋值为零,并按阶梯状输出。
思路和步骤:(1)建一个selectSort()函数,给数组由小到大排序。
            (2)建一个ifPrime()函数进行素数判定,给素数赋值0。
                        (3)建一个printArray()函数,按阶梯状输出数组中的数。
*/
class  ArrayTest1
{
        public static void main(String[] args)
        {
                int arr[] = {2,5,9,10,48,95,154,31,59,69};
                selectSort(arr);//给int数组排序。
                ifPrime(arr);//素数判定,给素数赋值0。
                printArray(arr);//阶梯状输出。
        }
       
        /**
        给int数组排序。
        @param arr 接收一个int类型的数组。
        @param 给int数组进行从小到大选择排序。
        */
        public static void selectSort(int[] arr)
        {
                for (int x=0; x<arr.length-1 ; x++ )
                {
                        for(int y=x+1; y<arr.length; y++)
                        {
                                if(arr[x]>arr[y])
                                {
                                        swap(arr,x,y);
                                }
                        }
                }
        }
        /**
        给数组中元素进行位置的置换。
        @param arr  接收一个int类型的数组。
        @param a 要置换的位置
        @param b 要置换的位置
        */
        private  static void swap(int[] arr,int a,int b)
        {
                int temp = arr[a];
                arr[a] = arr[b];
                arr[b] = temp;
        }
        /**
        对一个数组中的数进行判断,把素数赋值为0。
        @param arr 接收一个int类型的数组。
        @param 对这个数组中遍历。
        @param 判断这个数组中的每个数是否素数,如果素数则赋值为0。
        */
        public static void ifPrime(int[] arr)
        {
                for (int x=0; x<arr.length; x++ )
                {
                        int count = 0;
                        for (int j=1; j<=arr[x]; j++)
                        {
                                if(arr[x]%j == 0)
                                        count++;
                        }
                        if(count==2)
                                arr[x] = 0;
                }
        }
        /**
        用于打印数组中的元素。打印形式是阶梯状。
        */
        public static void printArray(int[] arr)
        {
                for(int x=0; x<arr.length; x++)
                {
                        for(int y=1;y<=x;y++)
                        {
                                System.out.print("\t");
                        }
                        System.out.println(arr[x]);
                }
        }
}

/*
  第二题:

  需求:输出倒序杨辉三角。
  思路:(1)创建一个正序杨辉三角。发现杨辉三角中有行和列,行数
             和列数相同,建立一个二维数组,把杨辉三角中的数全部放到
                     二维数组中。
        (2)倒序打印这个二维数组,可以得到倒序的杨辉三角。

  步骤:(1)创建一个yangHui()函数,用于建立一个正序杨辉三角,并赋
             相应的数值。
        (2)创建一个printArr()函数,用于倒序打印杨辉三角。
                (3)在yangHui()函数中调用printArr()函数,在main()中调用
                     yangHui()函数。可以得到倒序杨辉三角。
*/

class ArrayTest2
{
        public static void main(String[] args)
        {
                yangHui(5);//要打印的倒序杨辉三角图形有五行,因此把5传给yangHui()函数。
        }

        /*
        建一个正序的杨辉三角函数yangHui()。
        */
        public static void yangHui(int row)
        {
                int[][] arr = new int[row][row];
                for (int x=0; x<row; x++)
                {
                        for (int y=0;y<=x ;y++ )
                        {
                                if (y==0 || y==x)
                                {
                                        arr[x][y] = 1;//杨辉三角每行的行首和行尾数值都是1。
                                        continue;
                                }
                                else
                                        arr[x][y] = arr[x-1][y-1] + arr[x-1][y];//在杨辉三角相应位置赋值。
                        }
                }
                printArr(arr,row);
        }


        /*
        建一个用于倒序打印杨辉三角的printArr函数。
        */
        private static void printArr(int[][] arr,int row)
        {
                for (int x=row-1; x>=0; x--)
                {
                        for (int m=row-1; m>x; m--)
                        {
                                System.out.print("\t");
                        }
                        for (int y=0;y<=x ;y++ )
                        {
                                System.out.print(arr[x][y]);
                                System.out.print("\t\t");
                        }
                        System.out.println();
                       
                }
        }
                               
}


运行结果图示.jpg (54.02 KB, 下载次数: 0)

运行结果图示.jpg

评分

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

查看全部评分

回复 使用道具 举报
重新上传了运行结果图片

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

第一题结果

第一题结果

2.jpg (12.95 KB, 下载次数: 0)

第二题结果

第二题结果

3.jpg (10.84 KB, 下载次数: 0)

第三题结果

第三题结果
回复 使用道具 举报
先做一、二题吧

  1. <P> </P>
  2. <DIV class=blockcode>
  3. <BLOCKQUOTE>/*
  4. 需求1:打印输出一百以内的素数的累加和...

  5. 分析:
  6. 1.定义两个函数:
  7. 求100以内的素数
  8. 求和。sum
  9. */
  10. class PrimeSum
  11. {
  12.         public static void main(String[] args)
  13.        {
  14.               int sum = 0;//初始化num.

  15.              for(int i=2; i<=100; i++)//素数只被1和他本身整除,根据这个特性可以求出素数,通过两次遍历,可求得,100以内的素数。
  16.             {
  17.                     boolean flag = true;//判断是否为素数的标志。

  18.                     for(int j=2; j<i; j++)
  19.                    {
  20.                          if(i%j==0)
  21.                         {
  22.                               flag = false;
  23.                               break;
  24.                         }
  25.                    }
  26.                   if(flag)
  27.                   {
  28.                          sum = sum + i;
  29.                   }
  30.             }
  31.        System.out.println("sum:"+sum);
  32.      }
  33. }

  34. /*
  35. 需求2:1.将该数组由小到大进行排列,数组中的素数全部赋值为零,并按阶梯状输出。
  36. 数组: 2 5 9 10 48 95 154 31 59 69

  37. 分析:
  38. 1.先将该数组由小到大进行排列。
  39. 2.定义函数求出素数。
  40. 3.把符合素数要求的赋值为零。
  41. 4.按阶梯状输出。

  42. 步骤:
  43. 1.素数:prime; 数组array;
  44. 2.将数组由小到大进行排列:
  45. 本次需求采用冒泡排序。
  46. 3.定义一个函数专门求素数。
  47. 满足条件的数赋值成0。
  48. 4.采用双遍历按阶梯状输出。
  49. */

  50. class ArrayPrime
  51. {
  52.              public static void main(String[] args)
  53.             {
  54.                    int[] arr = {2, 5, 9, 10, 48, 95, 154, 31, 59, 69};
  55. //排序前
  56.                    System.out.print("数组改变前: ");printArray(arr);
  57.                    System.out.println();
  58. //排序
  59.                    bubbleSort(arr);
  60. //排序后
  61.                    System.out.print("数组改变后: ");

  62. /*
  63. 求素数:素数只被1和他本身整除,根据这个特性可以求出素数。
  64. */
  65.                   int pr = 2;
  66.                   for(int i=2; i<=154; i++)
  67.                  {
  68.                         boolean flag = true;

  69.                         for(int j=2; j<i; j++)
  70.                        {
  71.                                if(i%j==0)
  72.                               {
  73.                                     flag = false;
  74.                                     break;
  75.                               }
  76.                       }
  77.                     if(flag)
  78.                     {
  79.                            for(int y=0; y<arr.length-1; y++)
  80.                             {
  81.                                   if(arr[y] == i)
  82.                                  arr[y] = 0;
  83.                             }
  84.                     }
  85.               }

  86.         printArray(arr);

  87.        System.out.println("输出数组: ");

  88.         printArray1(arr);
  89. }
  90. //尝试了很多次,发现还是不能用定义的函数来对满足的素数进行操作,也就是所说的赋值成0.
  91. //若版主有时间,可以帮忙找下原因,为什么下面定义的方法不行。

  92. // public static void getPrime(int pr)
  93. // {
  94. //// int pr = 2;
  95. // for(int i=2; i<=100; i++)
  96. // {
  97. // boolean flag = true;
  98. //
  99. // for(int j=2; j<i; j++)
  100. // {
  101. // if(i%j==0)
  102. // {
  103. // flag = false;
  104. // break;
  105. // }
  106. // }
  107. // if(flag)
  108. // {
  109. // compare(arr, i);
  110. // }
  111. // }
  112. // }
  113. //
  114. // public static void compare(int[] arr, int x)
  115. // {
  116. // for(int y=0; y<arr.length-1; y++)
  117. // {
  118. // if(arr[y] == x)
  119. // arr[y] = 0;
  120. // }
  121. // }

  122. /*
  123. 定义一个互换功能的函数。
  124. */
  125.           public static void bubbleSort(int[] arr)
  126.           {
  127.                  for (int x=0; x<arr.length; x++)
  128.                 {
  129.                        for (int y=0; y<arr.length-1-x; y++)
  130.                        {
  131.                              swap(arr, y, y+1);
  132.                        }
  133.                }
  134.           }

  135. /*
  136. 打印输出。
  137. */
  138.          public static void printArray(int[] arr)
  139.         {
  140.               for (int x=0; x<arr.length; x++)
  141.              {
  142.                         System.out.print(arr[x]+"\t");
  143.               }
  144.         }

  145. /*
  146. 定义一个按阶梯状输出数组元素功能的函数。
  147. */
  148.          public static void printArray1(int[] arr)
  149.          {
  150.                 for (int x=0; x<arr.length; x++)
  151.                 {
  152.                       // System.out.print(arr[x]);
  153.                        for (int y=0; y<arr.length; y++)
  154.                       {
  155.                             while(y<x)
  156. //抱歉了,版主,貌似输出空格有个专门的功能,但还没有学到,故投机取巧了一下,用了此方法。
  157.                              {
  158.                                     System.out.print("\t");
  159.                                     y++;
  160.                              }
  161.                      }
  162.                         System.out.println(arr[x]);
  163.                 }
  164.         }

  165. /*
  166. 定义一个功能为排序的函数,方便以后调用。
  167. */
  168.           public static void swap(int[] arr, int a, int b)
  169.          {
  170.                if(arr[a]>arr[b])
  171.                {
  172.                      int temp = arr[a];
  173.                      arr[a] = arr[b];
  174.                      arr[b] = temp;
  175.                }
  176.         }

  177. }

复制代码

点评

定义方法 你返回一个数组类型的值  发表于 2013-6-21 19:53
回复 使用道具 举报

忘了发图了。。。补上,

评分

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

查看全部评分

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

public class PrimeNum {

        /**
         * 打印输出一百以内的素数的累加和...  
         * @author 欧雄风
         */
        public static void main(String[] args) {
                PrimeNum num=new PrimeNum();
                num.printPrime(100);

        }
        //判断是否是质素
        boolean isPrime(int n){
                for(int i=2;i<=n/2;i++){
                        if(n%i==0){
                                return false;//能被整除则不是素数
                        }
                }
                return true;
        }
        //打印一个小于m的质素的和
        void printPrime(int m){
                int j=0;
                for(int i=2;i<=m;i++){
                        if(isPrime(i)){
                                j+=i;          //计算累加
                        }
                }
                System.out.println(j);//打印和
        }

}

点评

结果呢  发表于 2013-6-21 20:25
回复 使用道具 举报
  1. public class test {
  2.         public static void main(String args[]) {
  3.                 int i, j, add = 0;
  4.                         for (i = 2; i <= 100; i++) { // 从2循环到100
  5.                                 for (j = 2; j < i; j++) {// 从2开始判断j是否比i小
  6.                                 if (i % j == 0)
  7.                                 break; // 判断i是否能被j整除,如果为真就结束本次循环
  8.                         }
  9.                         if (j >= i) { // 判断j与i的大小
  10.                                 System.out.print(i + " "); // 如果为真就打印出i,这个数就是素数
  11.                                 add += i;                   //计算之和
  12.                                 System.out.println(""+add); //循环打印出每次之和
  13.                         }
  14.                 }
  15.         }
  16. }
复制代码

QQ截图20130621202503.png (10.52 KB, 下载次数: 0)

最终答案是1060

最终答案是1060

评分

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

查看全部评分

回复 使用道具 举报

嗯 ,谢谢版主,已经解决了!
回复 使用道具 举报
这是第一题的代码:
  1. class  ShuDemo
  2. {
  3.         public static void main(String[] args)
  4.         {
  5.                 int m=0;
  6.                 for(int i=1,j;i<=100;i++)
  7.                 {
  8.                         int k=(int)Math.sqrt(i);
  9.                         for(j=2;j<=k;j++)
  10.                         {
  11.                                 if(i%j==0)
  12.                                 {
  13.                                     break;
  14.                              }
  15.                          }
  16.                          if(j>k)
  17.                         {
  18.                                 m=m+i;
  19.                         }
  20.                 }
  21.                 System.out.println(m);
  22.         }
  23. }
复制代码

点评

结果...  发表于 2013-6-21 20:35
回复 使用道具 举报
package com.heima;

import java.util.Arrays;

public class ArrayDemo {

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

         * @author oxf
         */
        public static void main(String[] args) {
                // TODO Auto-generated method stub
                int arr[]={2,5,9,10,48,95,154,31,59,69};
                System.out.println("没有排序前:"+Arrays.toString(arr));
                Arrays.sort(arr);                       
                System.out.println("排序后:"+Arrays.toString(arr));//数组排序
                for (int i = 0; i < arr.length; i++) {
                        if(isPrime(arr[i]))                                //数组为质素设置为0
                                arr[i]=0;        //设置为0
                }
                System.out.println("数组中的素数全部赋值为零,排序后:"+Arrays.toString(arr));//数组中的素数全部赋值为零,排序后
               
        }
        //判断是否是质素
        static boolean isPrime(int n){
                for(int i=2;i<n/2;i++)
                        if(n%i==0)
                                return false;
                return true;
        }

}

点评

结果..  发表于 2013-6-21 20:37
回复 使用道具 举报
第一题:

  1. public class Test11 {
  2.        
  3.         public static int isPrimeNum(int number)//判断一个数是否为素数,若是则返回该数,否则返回0
  4.         {
  5.                 if(number <= 1)//小于等于1的数全部是素数
  6.                         return 0;
  7.                 if(number == 2)//2为素数
  8.                         return 2;
  9.                 int i = 2;
  10.                 for(i = 2; i <= number; i++)//循环遍历小雨number的数,当有余数等于0时,结束循环
  11.                 {
  12.                         if(number % i == 0)
  13.                                 break;
  14.                 }
  15.                 if(number == i)//判断是否为素数
  16.                         return number;
  17.                 else
  18.                         return 0;
  19.         }
  20.        
  21.         public static void main(String[] args)
  22.         {
  23.                 int sum = 0;
  24.                 for(int i = 1; i < 100; i++)//100以内的素数循环相加
  25.                 {
  26.                         sum = sum + isPrimeNum(i);
  27.                 }
  28.                 System.out.println(sum);
  29.         }
  30.        
  31. }
复制代码
结果是:1060;第二题:

  1. public class Test12 {
  2.        
  3.         public static void sort (int[] a)//对数组排序
  4.         {
  5.                 for(int i = 0; i < a.length - 1; i++)
  6.                 {
  7.                         for(int j = i + 1; j < a.length; j++)
  8.                         {
  9.                                 if(a[i] > a[j])
  10.                                 {
  11.                                         int t = a[i];
  12.                                         a[i] = a[j];
  13.                                         a[j] = t;
  14.                                 }
  15.                         }
  16.                 }
  17.         }
  18.        
  19.         public static boolean isPrimeNum(int number)//判断一个数是否为素数,若是则返回true,否则返回false
  20.         {
  21.                 if(number == 1)//1不是素数
  22.                         return false;
  23.                 if(number == 2)//2为素数
  24.                         return true;
  25.                 int i = 2;
  26.                 for(i = 2; i <= number; i++)//循环遍历小雨number的数,当有余数等于0时,结束循环
  27.                 {
  28.                         if(number % i == 0)
  29.                                 break;
  30.                 }
  31.                 if(number == i)//判断是否为素数
  32.                         return true;
  33.                 else
  34.                         return false;
  35.         }
  36.        
  37.         public static void main(String[] args)
  38.         {
  39.                 int a[] = {1,2,3,4,5};
  40.                 sort(a);                                //调用函数排序
  41.                 for(int i = 0; i < 5; i++)//循环遍历数组,将为素数的元素置为0
  42.                 {
  43.                         if(isPrimeNum(a[i]))
  44.                                 a[i] = 0;               
  45.                 }
  46.                 for(int i = 0; i < 5; i++)
  47.                 {
  48.                         int j = i;
  49.                         while(j != 0)        //控制空格输出的数量
  50.                         {
  51.                                 System.out.print("  ");
  52.                                 j--;
  53.                         }
  54.                         System.out.println(a[i]);//输出各元素
  55.                 }
  56.         }

  57. }
复制代码




版主第三题稍后再教可以不
回复 使用道具 举报
第一题的结果

QQ截图20130621204415.png (19.88 KB, 下载次数: 0)

QQ截图20130621204415.png

点评

怎么成1061了  发表于 2013-6-21 21:16
回复 使用道具 举报
我是你没该题做得 ,你后来那题我就放在第三题了,嘻嘻。还有第二题纯属是取巧,因为我完全不会,现在还在传智上基础班,第二题能给就给点技术分,拜托了,本菜鸟赚点技术分不容易。下面上代码:
第一题:


public class Demo {

        /**
         *     1.将该数组由小到大进行排列,数组中的素数全部赋值为零,并 按阶梯状输出。
         *     实现思路:
         *                     1)定义一个数组,一个排列时用到得中间变量trm.
         *                     2)先用选择排序方法把数组从小到大排列出来
         *                     3)求质数,定义一个求质数时用到的变量inter,一个求质数时用到的boolean变量。
         *                     4)把数组以阶梯形状输出
         *                     5)完成
         */
        public static void main(String[] args) {
                // TODO Auto-generated method stub
                Test t = new Test();
                t.arrange();
        }

}
class Test {
        int[] arr ={2,5,9,10,48,95,154,31,59,69};
        int temp;//中间变量
               
        public void arrange() {
                       
                for (int i = 0; i < arr.length-1; i++) {//定义外层for循环,控制一个数跟多个数比较。-1是为了提高代码的运行速度
                        for (int j = i+1; j < arr.length; j++) {//定义内层循环,控制顺序的跟外层的i进行多次比较,因为每次都是这个角标的数与下个角标的数比较,
                                                                                                                //不会出现同样的相同角标的数比较,所以j的值永远都比i大1,也就是i+1。

                                if(arr[i]>arr[j]) {//判断两个数,如果arr[i]大于arr[j]那么就利用中间变量把他们换位。
                                        temp=arr[i];
                                        arr[i]=arr[j];
                                        arr[j]=temp;
                                }
                        }
                }
                for (int x = 0; x < arr.length; x++) {//定义循环,遍历查看哪个是素数。
                        int inter=2;//临时变量,定义在这里是因为每循环一次都要初始化一次
                        boolean isZhi=true;//同上,每循环一次都要初始化一次

                        while(inter < (arr[x]/2)){//定义while循环,如果定义的临时变量小于数组当前角标里的数除以2,因为如果大于了相除的话肯定是由余数的。那么就进入循环。如果不那么不进入循环
                                if(arr[x] % inter == 0) {//求素数,循环判断当前角标下的数%临时变量,如果余数为0,那么代表不是素数,就把isZhi改为false,并且结束循环,
                                                                                        //如果余数不为0,那么代表该数是素数,isZhi依然是true       
                                        isZhi=false;
                                        break;//结束循环
                                }
                                       
                                inter++;
                        }
                               
                        if(isZhi) {        //判断如果isZhi是true,那么就把当前角标下的值改为0,如果为false,那么就不改变
                                arr[x]=0;
                        }               
                }
                       
                for (int i = 0; i < arr.length; i++) {//定义外层循环控制输出的行数
                        for (int j = 0; j < i; j++) {//定义层循环控制输出的空格数,因为每一行的空格都是随着行数的增加而增加,每一行的空格也是跟行数相等,所以j<i
                                System.out.print(" ");
                                       
                        }
                        System.out.println(arr[i]);
                }       
        }
}


第二题:(纯属取巧,请版主手下留情)
import java.util.Scanner;

/**
* 2.手动输入一个自然数N,反向打印N行杨辉三角。
* */
public class Demo1 {
        public static void main(String[] args) {
                Scanner input = new Scanner(System.in);
                System.out.println("请输入一个数:");
                int i = input.nextInt();
                Test1 t = new Test1();
                t.triangle(i);
        }
}
class Test1 {
        public void triangle(int i) {
                int p = 0;
                for (int x = 1; x <=i; x++) {
                        for (int y = 0; y<x; y++) {
                                System.out.print(" ");
                                 p=y;
                        }
                        assist(i);
                        for (int z = 0; z<=i-x ; z++) {
                                System.out.print(" "+i+" ");
                               
                        }
                        assist(i);
                        //System.out.print(" \n");
                        System.out.println("");
                }for (int j = 0; j <= p+2; j++) {
                       
               
                System.out.print(" ");
                }
                assist(i);
        }
        public void assist(int i) {
               
                if(i!=1){
                        System.out.print("1");
                        }
        }
}


第三题:



/**
*  1.  打印输出一百以内的素数的累加和...
*         分析:
*                 第一步:先找出一百以内的素数,利用循环,
*                 第二步:把他们相加,然后输出
*                                
* */
public class Demo2 {
        public static void main(String[] args) {
                Test3 t = new Test3();
                t.prime();
        }
}
class Test3 {
                int and;//定义一个变量接收素数累加;
                public void prime() {
                       
                        for (int i = 0; i <= 100; i++) {//利用循环遍历一百以内的所有数
                                int temp=2;//定义临时变量,把其赋值为2,因为所有数字都从2开始除。定义在这里是每循环一次就要初始化一次;
                                boolean isZhi=true;//每循环一次要初始化一次
                                while(temp<=i/2) {//判断临时变量是否大于一百以内的某个数除以二;因为如果大于了相除的话肯定是由余数的。
                                       
                                        if(i%temp==0) {//循环判断这个数除以临时变量是否没有余数,如果没有那么就不是素数。就把false赋值给isZhi;
                                                isZhi=false;
                                                break;//结束循环
                                        }
                                        temp++;
                                }
                                if(isZhi) {//判断如果isZhi为真 那么就把其输出,以及跟变量and相加然后赋值给and;
                                        System.out.println(i);
                                        and=and+i;
                                }
                        }
                        System.out.println("一百以内的素数和是:"+and);
                }
       
}


下面是结果图:


QQ图片20130621204324.jpg (16.01 KB, 下载次数: 0)

第一题

第一题

QQ图片20130621204623.jpg (18.02 KB, 下载次数: 0)

第二题

第二题

QQ图片20130621204819.jpg (20.2 KB, 下载次数: 0)

第三题

第三题

点评

第三题 结果不对...  发表于 2013-6-21 21:20

评分

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

查看全部评分

回复 使用道具 举报
第一题
代码:
C:\Documents and Settings\Administrator\桌面
//打印1~100质数的和

public class TestZS{
       
        public static void main(String[] args){
               
                int temp = 0;//定义一个中间变量用于质数之间的加法累计
               
                for(int i=2;i<=100;i++){//由于1不是质数也不是合数,定义一个i从2开始循环到100
                       
                        boolean b = true;//定义一个boolean类型的变量用于判断其是不是质数
                       
                        for(int a=2;a<i;a++){
                               
                                if(i%a==0){
                                       
                                        b = false;
                                       
                                        break;
                                }//if语句用于判断是不是质数
                        }
                       
                        if(b){
                               
                                temp +=i;
                        }//如果b为true,i为质数,把i的值赋予temp
                        else continue;
                }
               
        System.out.println(temp);//最终打印出来所有质数的和
        }
}
结果:
C:\Documents and Settings\Administrator\桌面
1060

第二题不会

评分

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

查看全部评分

回复 使用道具 举报
加注释的第一题,结果上楼已经传了
  1. class  ShuDemo
  2. {
  3.         public static void main(String[] args)
  4.         {
  5.                 int m=0;//这是相加的数,一开始定义为0
  6.                 for(int i=1,j;i<=100;i++)//
  7.                 {
  8.                         int k=(int)Math.sqrt(i);//这里就是对i开方,结果取整后,赋给整型变量k.这个k在下面就是用来判断i的,如果k能够被i整除,那么就不是素数了
  9.                         for(j=2;j<=k;j++)//j为什么从2开始,是因为1就是素数的一个因数,而2不一定.
  10.                         {
  11.                                 if(i%j==0)//这个如果为真,就不是素数了
  12.                                 {
  13.                                     break;
  14.                              }
  15.                          }
  16.                          if(j>k)//这个步骤是根据上面来的,就是说如果j一直加到k都没有被i整除,那说明i就是素数了
  17.                         {
  18.                                 m=m+i;//求得的素数相加
  19.                         }
  20.                 }
  21.                 System.out.println(m);
  22.         }
  23. }
复制代码

点评

结果1060....  发表于 2013-6-21 21:23
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马