黑马程序员技术交流社区

标题: ====>送技术分啦! 题已更改，1题最多3分，2.3题给5分... [打印本页]

作者: 夜默 时间: 2013-6-21 12:34
标题: ====>送技术分啦! 题已更改，1题最多3分，2.3题给5分...
本帖最后由巩建于 2013-6-24 12:59 编辑

                     截止时间：6.23晚10点
   你们真心让我伤不起了....结果忘了写的，不断改代码的，自己改了把对的改成错的，需要提示多少遍才能一次解决好所有问题？
   你们做完题，不要立即提交答案，虽然这个答题活动，你只要不是改了N次，一般是会给分的...但是你们也别这样整我啊...
    本次答题活动封顶五分，是我们版主小看了你们的实力，但是下次，再一个人占好几层，不断改代码，不贴结果的，版主会怒了的哦！{:soso__5246682039739057267_3:}

活动结束后，分没有加的联系我QQ，备注论坛 id  你的真实姓名，发信息链接楼层
买了题的告诉我声，给您补上，广大黑马学员们，我错了{:soso_e154:}...
   其实2题只是把排序、素数判定和空格输出组合在一起，3题再百度可以搜到，就是变了输出方式。
   希望大家都能做一下，也相当于检查自己的学习情况... 有个零基础开始学的哥们能做出来，我相信你们都能做出来...

要求:
1.题目要自己做出来，即使百度也没有哦，原创的。
2.将程序写的清晰明了.注释到位.
3.回复的时候把代码贴出来.和运算后结果的图片，
  不会弄图片的贴出结果来，不要蒙混过关，随机抽查验证，违者扣技术分哦
4. 需要写出完整代码，不要用几句数学语言就解决了。
5.代码放到代码块中,不要压缩包(压缩包没分)
6.要写注释，没注释的没分...
7.对于本次活动的俩道题，存在异议的可以联系我。。。有奖励的哦...
8.技术分这个东东么，只要结果正确，注释清晰，2分到手，当然也可能是3分哦，俩道题一起做的，100层以前是2-5分哦。

题目：
1.  打印输出一百以内的素数的累加和...
2.将该数组由小到大进行排列，数组中的素数全部赋值为零，并按阶梯状输出。
数组：  2 5 9 10 48    95 154    31  59 69
3.手动输入一个自然数N，反向打印N行杨辉三角。

   2. 阶梯状输出

3.倒序杨辉三角

作者: 神之梦 时间: 2013-6-21 13:30
还要钱买啊，太坑了吧

作者: shang1jk 时间: 2013-6-21 13:45
第一个在这里:

import java.util.Arrays;
/*
* 将该数组由小到大进行排列，数组中的素数全部赋值为零，并按阶梯状输出。
* 数组： 2 5 9 10 48 95 154 31 59 69
**/
public class TestQ1 {
public static void main(String[] args) {
int[] arr = {2,5,9,10,48,95,154,31,59,69};
Arrays.sort(arr); //升序排列
for(int x=0; x<arr.length; x++) //遍历
{
if(isSuShu(arr[x])) //如果是素数, 赋零
{
arr[x] = 0;
}
}
show(arr); //输出
}
public static boolean isSuShu(int num) //静态方法, 用于判断是否是素数
{
for(int i=2; i<num; i++)
{
if(num%i == 0)
{
return false;
}
}
return true;
}
public static void show(int[] arr) //静态方法, 用于阶梯输出
{
for(int x=0; x<arr.length; x++)
{
int y=x;
while(y>0) //输出与当前元素脚标数相同个数的空格
{
System.out.print(" ");
y--;
}
System.out.print(arr[x] + "\n");
}
}
}

复制代码

输出:
0
  0
9
   10
      0
      48
         0
            69
            95
               154

===============
第二个麻烦, 没写, 要赶紧写博客了. .

作者: 王靖远 时间: 2013-6-21 15:18

class ZhuanFen
{
public static void main(String[] args)
{
print();
}
/*
* 1.将该数组由小到大进行排列，数组中的素数全部赋值为零，并按阶梯状输出。
数组： 2 5 9 10 48 95 154 31 59 69
* */
public static boolean suShu(int i)//定义一个判断是否为素数的方法。
{
int count = 0;
if (i == 1)
return false;
for(int x=1;x<=i;x++)
{
if((i%x)==0)
count++;
}
if(count>2)
return false;
else
return true;
}
public static void print()
{
int []i = {2,5,9,10,48,95,154,31,59,69};//来个int数组存需要处理的数
System.out.print("数组改变前");
for(int x=0;x<i.length-1;x++)
{
System.out.print(i[x]+" ");
}
System.out.println(i[i.length-1]);
int []arr = new int[i.length];//来个新数组存素数变0后的数组。
for(int x=0;x<i.length;x++)//遍历数组并打印。
{
if(suShu(i[x]))//调用suShu方法判断原数组的数是否为素数
arr[x] = 0;
else
arr[x]=i[x];
}
System.out.print("数组改变后");
for(int x=0;x<arr.length-1;x++)
{
System.out.print(arr[x]+" ");
}
System.out.println(arr[arr.length-1]);
for(int x=0;x<arr.length;x++)
{
for(int y=0;y<=x;y++)
{
if(x==y)//为了打印阶梯型。
System.out.println(arr[x]);
else
System.out.print(" ");
}
}
}
}

复制代码

_______________________________________________________________________________________________________________________________________________________________

class ZhuanFen1
{
public static void main(String args[])
{
int N =4;
yanghui(N);
}
/*
* 2.手动输入一个自然数N，反向打印N行杨辉三角。
* */
public static void yanghui( int N)
{
int a[][] = new int[N+1][];//定义一个二维数组。
for(int i=0;i<=N;i++)//初始化二维数组
{
a[i] = new int[i+1];
}
for (int i = 0; i <= N; i++)//循环行数
{
for (int j = 0; j <= a[i].length - 1; j++) //循环列数
{
if (i == 0 || j == 0 || j == a[i].length - 1)
a[i][j] = 1;//将两侧元素设为1
else//元素值为其正上方元素与左上角元素之和
a[i][j] = a[i - 1][j - 1] + a[i - 1][j];
}
}
for (int i=a.length-1-1;i>=0;i--)
{
for(int x =i+1;x<N;x++)
System.out.print(" ");
for (int j = 0; j <=a[i].length - 1; j++)
System.out.print(a[i][j] + " ");
System.out.println();//换行
}
}
}

复制代码

作者: liguangcaiup 时间: 2013-6-21 15:25

public static void main(String[] args) throws Exception {
int[] A = { 2, 5, 9, 10, 48, 95, 154, 31, 59, 69 };
Arrays.sort(A);
for (int i = 0; i < A.length; i++)
if (SuShu(A[i]))// 是素数则置为零
A[i] = 0;
for (int i = 0; i < A.length; i++) {// 阶梯打印结果
for (int j = 0; j < i; j++)
System.out.print(" ");// 打印前导空格
System.out.println(A[i]);
}
}
public static boolean SuShu(int a) { // 判断是否是素数
if (a == 2)
return true;
for (int i = 2; i < Math.sqrt(a); i++) {
if (a % i == 0)
return false;
}
return true;
}
}

复制代码

QQ截图20130621151932.jpg (21.85 KB, 下载次数: 0)

作者: 王靖远 时间: 2013-6-21 15:48

王靖远发表于 2013-6-21 15:18
__________________________________________________________________________________________________ ...

class ZhuanFen
{
public static void main(String[] args)
{
print();
}
/*
* 1.将该数组由小到大进行排列，数组中的素数全部赋值为零，并按阶梯状输出。
数组： 2 5 9 10 48 95 154 31 59 69
* */
public static boolean suShu(int i)//定义一个判断是否为素数的方法。
{
int count = 0;
if (i == 1)
return false;
for(int x=1;x<=i;x++)
{
if((i%x)==0)
count++;
}
if(count>2)
return false;
else
return true;
}
public static void print()
{
int []i = {2,5,9,10,48,95,154,31,59,69};//来个int数组存需要处理的数
System.out.print("数组改变前");
for(int x=0;x<i.length-1;x++)
{
System.out.print(i[x]+" "+"\t");
}
System.out.println(i[i.length-1]);
int []arr = new int[i.length];//来个新数组存素数变0后的数组。
for(int x=0;x<i.length;x++)//遍历数组并打印。
{
if(suShu(i[x]))//调用suShu方法判断原数组的数是否为素数
arr[x] = 0;
else
arr[x]=i[x];
}
System.out.print("数组改变后");
for(int x=0;x<arr.length-1;x++)
{
System.out.print(arr[x]+" "+"\t");
}
System.out.println(arr[arr.length-1]);
System.out.println("输出数组");
for(int x=0;x<arr.length;x++)
{
for(int y=0;y<=x;y++)
{
if(x==y)//为了打印阶梯型。
System.out.println(arr[x]+"\t");
else
System.out.print(" ");
}
}
}
}

复制代码

加了制表符给改好看点了。

作者: 王靖远 时间: 2013-6-21 15:53

王靖远发表于 2013-6-21 15:48
加了制表符给改好看点了。

哦哦前面都是按顺序排的，忘掉看需求要排序了。等我改下

作者: 王靖远 时间: 2013-6-21 15:57

王靖远发表于 2013-6-21 15:48
加了制表符给改好看点了。

import java.util.*;
class ZhuanFen
{
public static void main(String[] args)
{
print();
}
/*
* 1.将该数组由小到大进行排列，数组中的素数全部赋值为零，并按阶梯状输出。
数组： 2 5 9 10 48 95 154 31 59 69
* */
public static boolean suShu(int i)//定义一个判断是否为素数的方法。
{
int count = 0;
if (i == 1)
return false;
for(int x=1;x<=i;x++)
{
if((i%x)==0)
count++;
}
if(count>2)
return false;
else
return true;
}
public static void print()
{
int []i = {2,5,9,10,48,95,154,31,59,69};//来个int数组存需要处理的数
System.out.print("数组改变前");
for(int x=0;x<i.length-1;x++)
{
System.out.print(i[x]+" "+"\t");
}
System.out.println(i[i.length-1]);
Arrays.sort(i);
int []arr = new int[i.length];//来个新数组存素数变0后的数组。
for(int x=0;x<i.length;x++)//遍历数组并打印。
{
if(suShu(i[x]))//调用suShu方法判断原数组的数是否为素数
arr[x] = 0;
else
arr[x]=i[x];
}
System.out.print("数组改变后");
for(int x=0;x<arr.length-1;x++)
{
System.out.print(arr[x]+" "+"\t");
}
System.out.println(arr[arr.length-1]);
System.out.println("输出数组");
for(int x=0;x<arr.length;x++)
{
for(int y=0;y<=x;y++)
{
if(x==y)//为了打印阶梯型。
System.out.println(arr[x]+"\t");
else
System.out.print(" ");
}
}
}
}

复制代码

作者: ytblght55 时间: 2013-6-21 17:25
这个题也忒难了,大家都是新手啊!!!这个代码写了我3个小时,里面有很多注释的地方是重复重复试验的结果,还有写地方还是懵懵懂懂,不过还是按照楼主的要求实现了功能,我这个代码是裹脚布又长又臭,不过很适合向我这样的新手,就是把这个需求简单话,然后按照自己的意思一条一条写代码..斑竹给分啊!!= =!!

/*
需求 :将该数组由小到大进行排列，数组中的素数全部赋值为零，并按阶梯状输出。
数组： 2 5 9 10 48 95 154 31 59 69
思路:首先使用遍历数组,然后使用冒泡排序按从小到大的顺序排列,
然后对数组各个元素进行判断,如果(这个数)%(这个数-1)==0,那么就不是素数,
最后使用for循环输出数字
步骤:
1,首先定义一个数组,使用for循环遍历数组,冒泡排序使它从小到大排序
2,然后找出元素中的素数,赋为0
3,然后使用for循环按照阶梯状打印数组
*/
class Test12{
public static void main(String[] args) {
int [] arr = {2,5,9,10,48,95,154,31,59,69};
show(arr);//遍历数组的函数
sort(arr);//排列数组的方式,从小到大
prime(arr);//将数组中为素数的元素改变为0,打印输出
ladder(arr);//按照需求将改变后的数组元素呈梯形状打印出来
}
//这是一个罗列数组的函数show
public static void show(int arr[]){
System.out.println("遍历原数组的各个元素");
for (int i = 0; i < arr.length; i++) {//i为小脚标,i<数组的长度,i每次执行完自加一次
System.out.print(arr[i]+" ");//打印元素
}
System.out.println();//这个是为了调用函数的时候取到换行的作用,后面的方法中结尾都有一个换行的打印输出
}
//冒泡排序从小到大的排序sort
public static void sort(int arr[]){
System.out.println("从小到大排序的各个元素");
for (int i = 0; i < arr.length; i++) {//遍历数组元素
for (int j = 0; j < arr.length-i-1; j++) {//确定比较的次数,因为每次比较都会确定最小值所以-i-1
if (arr[j]>arr[j+1]) {//arr[j]>arr[j+1]的时候我们要进行换位
int temp = arr[j];//用第三方变量temp来实现换位
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
System.out.print(arr[i]+" ");//输出比较后的数组
}
System.out.println();//这个是为了调用函数的时候取到换行的作用,后面的方法中结尾都有一个换行的打印输出
}
public static void prime(int arr[]){
System.out.println("将数组中是素数的元素定义为0,并打印出改变后的数组");
loop://loop是个标记
for (int i = 0; i < arr.length; i++) {//首先遍历数组元素,就相当于取得每个元素的值
for (int j = 2;j<arr[i]; j++) {//因为我们是要素数所以我们就让(arr里面的元素)%(这个元素-1的值),这里我们遍历这个元素-1的值.
if (arr[i]%j==0) {//设置判断语句如果arr[i]这个元素%这个元素的值-1(即j)等于0,我们就继续回到循环
System.out.print(" " + arr[i]);//打印数组的元素,为了保证让素数变成0之后能打印出所有的元素,即 0 0 9 10 0 48 0 69 95 154这种样式
continue loop;//if判断flase的时候跳出当前循环
}
//System.out.print(" " + arr[i]);
}
//System.out.print(" " + arr[i]);
arr[i]=0;//将这个元素赋值为0
System.out.print(" " + arr[i]);//打印元素
//System.out.println();
}
System.out.println();//我起到了可爱的换行作用,你们可以忽略我
//ladder(arr);
}
public static void ladder(int arr[]){
//prime(arr);
System.out.println("将改变后的数组元素按照梯形状打印 ");
for (int i = 0; i < arr.length; i++) {//控制行数,即长度
for (int j = 0; j < i; j++) {//控制列数,即高度
System.out.print(" ");
}
System.out.println(arr[i]);
//System.out.println();
}
}
}

复制代码

作者: ytblght55 时间: 2013-6-21 17:29
遍历原数组的各个元素
2 5 9 10 48 95 154 31 59 69
从小到大排序的各个元素
2 5 9 10 31 48 59 69 95 154
将数组中是素数的元素定义为0,并打印出改变后的数组
0 0 9 10 0 48 0 69 95 154
将改变后的数组元素按照梯形状打印
0
0
  9
10
0
   48
   0
   69
      95
      154

运行结果!!!!

作者: 关关雎鸠 时间: 2013-6-21 17:36

作者: 关关雎鸠 时间: 2013-6-21 17:37

关关雎鸠发表于 2013-6-21 17:36

忘了截图。。

作者: 关关雎鸠 时间: 2013-6-21 17:42

关关雎鸠发表于 2013-6-21 17:37
忘了截图。。

截图的！

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

作者: 捌年 时间: 2013-6-21 18:14
第一题：
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) ; //输出改变后的数组
 for(int i = 0 ;i<temp.length ; i++){ //判断是否是素数，如果是，则变为0
if(temp<=2){
temp=0 ;
}else{for(int j=2 ; j< temp ; j++){
 if(temp%j==0){
 break ;
 }else{
 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(); //输出完后换行
}
}

O49U)ZX70$OH9I4U%FNHEEV.jpg (19.24 KB, 下载次数: 0)

下载附件

2013-6-21 18:13 上传

作者: 姚志远 时间: 2013-6-21 18:18
排序的问题
public class Test5 {

public static void main(String[] args) {

int []arr={2,5,9,10 ,48 ,95 ,154,31 ,59 , 69}; //定义一个数组

for(int i=0;i<arr.length-1;i++){ // 用双层循环对数组排序

for(int j=i;j<arr.length-1;j++){

if(arr[j]>arr[j+1]){ //判断是否为最大数

int temp=arr[j];

arr[j]=arr[j+1];

arr[j+1]=temp;

}

}

}

for(int i=0;i<arr.length;i++){ //打印排序后的数组

System.out.print(arr[i]+"\t");

}

}

}

[img]D:\\jad\\answer.jpg[/img]
复制代码
作者: ytblght55 时间: 2013-6-21 18:24

/*

* 需求:打印输出一百以内的素数的累加和

思路:首先按照素数的特点,打印素数然后相加求和

步骤:

1,遍历1-100的数

2,判断这个数是不是素数,是打印出来,用sum记录 sum+i的值

3,将这些素数相加求和

* */

public class Test13 {

/**

* @param args

*/

public static void main(String[] args) {

// TODO Auto-generated method stub

int sum=0;//定义个sum来记录素数的值

loop://标记点

for (int i = 2; i<=100; i++) {//遍历1-100之间的数.

for (int j = 2; j <i; j++) {//每个数和这个数-1进行比较

if (i%j==0) {//判断i%j是否为0,如果为0跳重新执行一次函数

continue loop;

}

}

System.out.print(i+" ");//打印素数

sum+=i;//用sum记录sum+i的值

}

System.out.println();

System.out.println("sum="+sum);

}

}

运行结果:<IMG border=0 alt="" src="http://bbs.itheima.com/forum.php?mod=image&aid=21509&size=300x300&key=13c83738012d6416&nocache=yes&type=fixnone" aid="attachimg_21509">
复制代码

12.jpg (20.12 KB, 下载次数: 0)

下载附件

2013-6-21 18:24 上传

作者: ︶ㄣ紫藤ㄜ︵ 时间: 2013-6-21 18:26
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]=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");
}

}

}

请您检查验收，辛苦了。{:soso_e100:}
作者: ︶ㄣ紫藤ㄜ︵ 时间: 2013-6-21 18:33
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]=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");
 }


}
}

QQ截图20130621182751.png (7.72 KB, 下载次数: 0)

下载附件

2013-6-21 18:32 上传

作者: ytblght55 时间: 2013-6-21 18:35
最后一个杨辉三角的,在网络上看挺多的代码,不过涉及到二维数组,这个还不是很理解,如果群主有人写出来了,麻烦发一份给我!!
作者: 黑马-王双 时间: 2013-6-21 18:36

/*

类中有四个函数

主函数main：负责主程序运行，调用所需功能

void PrintArray(int[] arr)：对数组排序且将素数改为0

boolean flag(int n)：标记，判断是否是素数

void Yanghui(int n)：反向打印杨辉三角

*/

import java.util.*;

class YangHui

{

public static void main(String[] args)

{

int[] arr={2,5,9,10,48,95,154,31,59,69};

System.out.println("第1题，打印数组");

PrintArray(arr);

System.out.print("第2题，请输入一个自然数N：");

Scanner in=new Scanner(System.in);

Yanghui(in.nextInt());

}

public static void PrintArray(int[] arr)

{

System.out.print("数组改变前");

//for循环遍历数组

for(int x=0;x<arr.length;x++)

{

System.out.print(arr[x]+" ");

}

//将数组由小到大进行排序

Arrays.sort(arr);

//换行

System.out.println();

System.out.println("数组排序后"+Arrays.toString(arr));

System.out.print("数组改变后");

//对排序后的数组进行遍历

for(int x=0;x<arr.length;x++)

{

//是素数就改为0

if (flag(arr[x]))

arr[x]=0;

System.out.print(arr[x]+" ");

}

System.out.println();

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

//阶梯状输出改变后的数组

for (int x=0;x<arr.length;x++ )

{

//控制空格数

for (int y=0;y<x;y++)

{

System.out.print(" ");

}

System.out.println(arr[x]);

}

}

//如果一个数能被1和自身以外的数整除就不是素数

public static boolean flag(int n)

{

for(int i=2;i<=n/2;i++)

{

if(n%i==0)

return false;

}

return true;

}

public static void Yanghui(int n)

{

int arr[][] = new int[n][n];

//每一行的首项和尾项为1

for (int i = 0; i < n; i++)

{

arr[i][0] = 1;

arr[i][i] = 1;

}

//从第二行开始遍历行，第j项的值是前一行的两数之和

for (int i = 2; i < n; i++)

{

//从第二列开始遍历列

for (int j = 1; j < n; j++)

{

arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];

}

}

//反向打印杨辉三角

for (int i=n-1; i>=0; i--)

{

//控制每行的空格数

for (int x=0;x<5-i;x++)

{

System.out.print(" ");

}

//打印二维数据的具体数值

for (int j=0; j<=i; j++)

{

System.out.print(arr[i][j] + " ");

}

//每行结束后换行

System.out.println();

}

}

}

复制代码

test.jpg (37.21 KB, 下载次数: 0)

下载附件

2013-6-21 18:33 上传

运行结果

作者: 黑马-王双 时间: 2013-6-21 18:38
正文中的内容不知道怎样设置版主或作者可见
作者: 黑马-王双 时间: 2013-6-21 18:39
只有附件才能设置权限？不是附件不知道怎么弄了
作者: 捌年 时间: 2013-6-21 18:42
这是第一题，上面那个是第二题，看错了
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) ;
}
}

~4QH_VFFB`99T{Y[QVL7AQK.jpg (2.27 KB, 下载次数: 0)

下载附件

2013-6-21 18:42 上传

作者: ︶ㄣ紫藤ㄜ︵ 时间: 2013-6-21 18:47
不好意思，理解反了,没有看清题...{: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)

下载附件

2013-6-21 18:46 上传

作者: 捌年 时间: 2013-6-21 19:01
之前第二题错了，现在改正
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(); //输出完后换行
}
}

XTL4DXJ%W9MP37R][%BRM8K.jpg (16.79 KB, 下载次数: 0)

下载附件

2013-6-21 19:01 上传

作者: 杨政 时间: 2013-6-21 19:31
第一题：
public class Test1 {

public static void main(String[] args){

primeSum(100);

}

private static void primeSum(int n) {

int sum = 0;

//遍历2到100之间的自然数，为素数则累加

for(int i=2; i<n; i++){

if(isPrimeNumber(i)){

System.out.print(i+" ");

sum+=i;

}

}

System.out.println(sum);

}

//素数判断方法

private static boolean isPrimeNumber(int n) {

int m = 0;

//不能被2到自身平方根的数整除，则为素数

for(int i=2;i<=Math.sqrt(n);i++){

if(n%i==0)

m++;

}

return m==0;

}

}
复制代码
输出结果：1060
第二题：
import java.util.Arrays;

public class Test2 {

/**

 * @param args

 */

public static void main(String[] args) {

int[] arr = new int[]{2,5,9,10,48,95,154,31,59,69};

mySort(arr);

}

private static void mySort(int[] arr) {

//从小到大，自然排序即可

Arrays.sort(arr);

System.out.print("改变前数组： ");

//打印排序后数组

for(int i=0; i<arr.length;i++){

if(i==arr.length-1)

System.out.println(arr[i]+" ");

else

System.out.print(arr[i]+" ");

}

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

for(int i=0; i<arr.length;i++){

//遍历数组所有元素，如果是素数，则用0取代

if(isPrimeNumber(arr[i]))

arr[i] = 0;

//阶梯打印数组元素

for(int j=0; j<i; j++){

System.out.print(" ");

}

System.out.println(arr[i]);

}

}

private static boolean isPrimeNumber(int n) {

int m = 0;

//不能被2到自身平方根的数整除，则为素数

for(int i=2;i<=Math.sqrt(n);i++){

if(n%i==0)

m++;

}

return m==0;

}

}
复制代码
输出结果：
改变前数组： 2 5 9 10 31 48 59 69 95 154
输出数组：
0
0
 9
10
0
 48
 0
 69
 95
 154

第三题：
public class Test3 {

/**

 * @param args

 */

public static void main(String[] args) {

triangleMath(3);

System.out.println("----------");

triangleMath(4);

System.out.println("----------");

triangleMath(5);

}

private static void triangleMath(int n) {

for(int i=n; i>0; i--){

//获取代表每行数字的数组

int[] arr = triangleArray(i);

sopSpace(n-i);

//按需求打印数组元素

for(int j=0; j<arr.length; j++){

if(j==arr.length-1)

System.out.println(arr[j]);

else

System.out.print(arr[j]+" ");

}

}

}

//空格输出补偿

private static void sopSpace(int n) {

for(int i=0; i<n; i++)

System.out.print(" ");

}

//获取代表每行数字的数组的方法

private static int[] triangleArray(int n) {

if(n>1){

int[] arr = new int[n];

//第一个和最后一个数字为1

arr[0] = 1;

arr[n-1] = 1;

//第i个数字为上一行第i-1数与上一行第i数之和

int[] previous = triangleArray(n-1);

for(int i=1; i<arr.length-1;i++){

arr[i] = previous[i-1]+previous[i];

}

return arr;

}

//第一行为1

else

return new int[]{1};

}

}
复制代码
输出结果：
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

作者: 李复安 时间: 2013-6-21 19:31
/*
第一题：

需求：将数组由小到大进行排列，数组中的素数全部赋值为零，并按阶梯状输出。
思路和步骤：（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)

下载附件

2013-6-21 19:30 上传

作者: 杨政 时间: 2013-6-21 19:35
重新上传了运行结果图片

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

下载附件

2013-6-21 19:34 上传

第一题结果

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

下载附件

2013-6-21 19:35 上传

第二题结果

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

下载附件

2013-6-21 19:35 上传

第三题结果

作者: 刘利民 时间: 2013-6-21 19:46
先做一、二题吧

 

<DIV class=blockcode>

<BLOCKQUOTE>/*

需求1：打印输出一百以内的素数的累加和...

分析：

1.定义两个函数：

求100以内的素数

求和。sum

*/

class PrimeSum

{

 public static void main(String[] args)

 {

 int sum = 0;//初始化num.

 for(int i=2; i<=100; i++)//素数只被1和他本身整除，根据这个特性可以求出素数，通过两次遍历，可求得，100以内的素数。

 {

 boolean flag = true;//判断是否为素数的标志。

 for(int j=2; j<i; j++)

 {

 if(i%j==0)

 {

 flag = false;

 break;

 }

 }

 if(flag)

 {

 sum = sum + i;

 }

 }

 System.out.println("sum:"+sum);

 }

}

/*

需求2：1.将该数组由小到大进行排列，数组中的素数全部赋值为零，并按阶梯状输出。

数组： 2 5 9 10 48 95 154 31 59 69

分析：

1.先将该数组由小到大进行排列。

2.定义函数求出素数。

3.把符合素数要求的赋值为零。

4.按阶梯状输出。

步骤：

1.素数：prime; 数组array;

2.将数组由小到大进行排列：

本次需求采用冒泡排序。

3.定义一个函数专门求素数。

满足条件的数赋值成0。

4.采用双遍历按阶梯状输出。

*/

class ArrayPrime

{

 public static void main(String[] args)

 {

 int[] arr = {2, 5, 9, 10, 48, 95, 154, 31, 59, 69};

//排序前

 System.out.print("数组改变前: ");printArray(arr);

 System.out.println();

//排序

 bubbleSort(arr);

//排序后

 System.out.print("数组改变后: ");

/*

求素数：素数只被1和他本身整除，根据这个特性可以求出素数。

*/

 int pr = 2;

 for(int i=2; i<=154; i++)

 {

 boolean flag = true;

 for(int j=2; j<i; j++)

 {

 if(i%j==0)

 {

 flag = false;

 break;

 }

 }

 if(flag)

 {

 for(int y=0; y<arr.length-1; y++)

 {

 if(arr[y] == i)

 arr[y] = 0;

 }

 }

 }

 printArray(arr);

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

 printArray1(arr);

}

//尝试了很多次，发现还是不能用定义的函数来对满足的素数进行操作，也就是所说的赋值成0.

//若版主有时间，可以帮忙找下原因，为什么下面定义的方法不行。

// public static void getPrime(int pr)

// {

//// int pr = 2;

// for(int i=2; i<=100; i++)

// {

// boolean flag = true;

//

// for(int j=2; j<i; j++)

// {

// if(i%j==0)

// {

// flag = false;

// break;

// }

// }

// if(flag)

// {

// compare(arr, i);

// }

// }

// }

//

// public static void compare(int[] arr, int x)

// {

// for(int y=0; y<arr.length-1; y++)

// {

// if(arr[y] == x)

// arr[y] = 0;

// }

// }

/*

定义一个互换功能的函数。

*/

 public static void bubbleSort(int[] arr)

 {

 for (int x=0; x<arr.length; x++)

 {

 for (int y=0; y<arr.length-1-x; y++)

 {

 swap(arr, y, y+1);

 }

 }

 }

/*

打印输出。

*/

 public static void printArray(int[] arr)

 {

 for (int x=0; x<arr.length; x++)

 {

 System.out.print(arr[x]+"\t");

 }

 }

/*

定义一个按阶梯状输出数组元素功能的函数。

*/

 public static void printArray1(int[] arr)

 {

 for (int x=0; x<arr.length; x++)

 {

 // System.out.print(arr[x]);

 for (int y=0; y<arr.length; y++)

 {

 while(y<x)

//抱歉了，版主，貌似输出空格有个专门的功能，但还没有学到，故投机取巧了一下，用了此方法。

 {

 System.out.print("\t");

 y++;

 }

 }

 System.out.println(arr[x]);

 }

 }

/*

定义一个功能为排序的函数，方便以后调用。

*/

 public static void swap(int[] arr, int a, int b)

 {

 if(arr[a]>arr[b])

 {

 int temp = arr[a];

 arr[a] = arr[b];

 arr[b] = temp;

 }

 }

}

复制代码
作者: 刘利民 时间: 2013-6-21 19:47

刘利民发表于 2013-6-21 19:46
先做一、二题吧

忘了发图了。。。补上，

_H@HEJ1P@LT]T_}(][MY({X.jpg (43.8 KB, 下载次数: 0)

下载附件

2013-6-21 19:46 上传

作者: oxf974025918 时间: 2013-6-21 20:23
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:26

public class test {

public static void main(String args[]) {

int i, j, add = 0;

for (i = 2; i <= 100; i++) { // 从2循环到100

for (j = 2; j < i; j++) {// 从2开始判断j是否比i小

if (i % j == 0)

break; // 判断i是否能被j整除，如果为真就结束本次循环

}

if (j >= i) { // 判断j与i的大小

System.out.print(i + " "); // 如果为真就打印出i,这个数就是素数

add += i; //计算之和

System.out.println(""+add); //循环打印出每次之和

}

}

}

}
复制代码

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

下载附件

2013-6-21 20:25 上传

最终答案是1060

作者: 刘利民 时间: 2013-6-21 20:27

刘利民发表于 2013-6-21 19:46
先做一、二题吧

嗯，谢谢版主，已经解决了！
作者: 陈鹏 时间: 2013-6-21 20:34
这是第一题的代码:
class ShuDemo

{

public static void main(String[] args)

{

int m=0;

for(int i=1,j;i<=100;i++)

{

int k=(int)Math.sqrt(i);

for(j=2;j<=k;j++)

{

if(i%j==0)

{

 break;

 }

 }

 if(j>k)

{

m=m+i;

}

}

System.out.println(m);

}

}

复制代码
作者: oxf974025918 时间: 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:44
第一题：

public class Test11 {

public static int isPrimeNum(int number)//判断一个数是否为素数，若是则返回该数，否则返回0

{

if(number <= 1)//小于等于1的数全部是素数

return 0;

if(number == 2)//2为素数

return 2;

int i = 2;

for(i = 2; i <= number; i++)//循环遍历小雨number的数，当有余数等于0时，结束循环

{

if(number % i == 0)

break;

}

if(number == i)//判断是否为素数

return number;

else

return 0;

}

public static void main(String[] args)

{

int sum = 0;

for(int i = 1; i < 100; i++)//100以内的素数循环相加

{

sum = sum + isPrimeNum(i);

}

System.out.println(sum);

}

}

复制代码
结果是：1060；第二题：

public class Test12 {

public static void sort (int[] a)//对数组排序

{

for(int i = 0; i < a.length - 1; i++)

{

for(int j = i + 1; j < a.length; j++)

{

if(a[i] > a[j])

{

int t = a[i];

a[i] = a[j];

a[j] = t;

}

}

}

}

public static boolean isPrimeNum(int number)//判断一个数是否为素数，若是则返回true，否则返回false

{

if(number == 1)//1不是素数

return false;

if(number == 2)//2为素数

return true;

int i = 2;

for(i = 2; i <= number; i++)//循环遍历小雨number的数，当有余数等于0时，结束循环

{

if(number % i == 0)

break;

}

if(number == i)//判断是否为素数

return true;

else

return false;

}

public static void main(String[] args)

{

int a[] = {1,2,3,4,5};

sort(a); //调用函数排序

for(int i = 0; i < 5; i++)//循环遍历数组，将为素数的元素置为0

{

if(isPrimeNum(a[i]))

a[i] = 0;

}

for(int i = 0; i < 5; i++)

{

int j = i;

while(j != 0) //控制空格输出的数量

{

System.out.print(" ");

j--;

}

System.out.println(a[i]);//输出各元素

}

}

}

复制代码

1234.JPG (8.91 KB, 下载次数: 0)

下载附件

2013-6-21 20:41 上传

版主第三题稍后再教可以不

作者: 陈鹏 时间: 2013-6-21 20:46
第一题的结果

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

下载附件

2013-6-21 20:44 上传

作者: 无气打火机 时间: 2013-6-21 20:49
我是你没该题做得，你后来那题我就放在第三题了，嘻嘻。还有第二题纯属是取巧，因为我完全不会，现在还在传智上基础班，第二题能给就给点技术分，拜托了，本菜鸟赚点技术分不容易。下面上代码：
第一题：

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)

下载附件

2013-6-21 20:48 上传

第一题

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

下载附件

2013-6-21 20:49 上传

第二题

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

下载附件

2013-6-21 20:49 上传

第三题

作者: 饭后小笼包 时间: 2013-6-21 20:57
第一题
代码：
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

第二题不会
作者: 陈鹏 时间: 2013-6-21 20:58
加注释的第一题,结果上楼已经传了
class ShuDemo

{

public static void main(String[] args)

{

int m=0;//这是相加的数,一开始定义为0

for(int i=1,j;i<=100;i++)//

{

int k=(int)Math.sqrt(i);//这里就是对i开方，结果取整后，赋给整型变量k.这个k在下面就是用来判断i的,如果k能够被i整除,那么就不是素数了

for(j=2;j<=k;j++)//j为什么从2开始,是因为1就是素数的一个因数,而2不一定.

{

if(i%j==0)//这个如果为真,就不是素数了

{

 break;

 }

 }

 if(j>k)//这个步骤是根据上面来的,就是说如果j一直加到k都没有被i整除,那说明i就是素数了

{

m=m+i;//求得的素数相加

}

}

System.out.println(m);

}

}

复制代码
作者: 风爽 时间: 2013-6-21 21:24
第三题：

public class Test13 {

public static void main(String[] args)

{

int a[][];

a = new int[4][]; //创建二维数组

for(int i = 1; i <= 4; i++)

a[i - 1] = new int[i];

for(int i = 0; i < 4; i++)

{

for(int j = 0; j <= i; j++)

{

if(i == 0) //第一行元素全为1

a[0][0] = 1;

else if(j == 0 || i == j )//第一列和对角线上的元素全为1

{

a[i][j] = 1;

}

else // 其他元素为其上一行所对应元素和前一个元素的和

a[i][j] = a[i - 1][j - 1] + a[i - 1][j];

}

}

//倒序打印杨辉三角

for(int m = 3; m >= 0; m-- )

{

int p = 3 - m;

while(p != 0)// 控制每行前的空格数

{

System.out.print("\t");

p--;

}

for(int n = 0; n <= m; n++)//输出每行元素极其各元素之间的空格

{

System.out.print(a[m][n]);

System.out.print("\t\t");

}

System.out.println();//换行

}

}

}

复制代码
结果：

捕获.JPG (10.38 KB, 下载次数: 0)

下载附件

2013-6-21 21:23 上传

版主三题全解出来了，前两个刚才提交了，有啥好处没？？

作者: 风爽 时间: 2013-6-21 21:26

风爽发表于 2013-6-21 20:44
第一题：结果是：1060；第二题：

怎么不对？？？能说明白点不？？应该没错啊

作者: 风爽 时间: 2013-6-21 21:31

风爽发表于 2013-6-21 21:26
怎么不对？？？能说明白点不？？应该没错啊

那还没给加分呢？？:(
作者: 陈鹏 时间: 2013-6-21 21:56

class ShuDemo

{

public static void main(String[] args)

{

int m=0;//这是相加的数,一开始定义为0

for(int i=2,j;i<=100;i++)//素数大于1

{

int k=(int)Math.sqrt(i);//这里就是对i开方，结果取整后，赋给整型变量k.这个k在下面就是用来判断i的,如果k能够被i整除,那么就不是素数了

for(j=2;j<=k;j++)//j为什么从2开始,是因为1就是素数的一个因数,而2不一定.

{

if(i%j==0)//这个如果为真,就不是素数了

{

 break;

 }

 }

 if(j>k)//这个步骤是根据上面来的,就是说如果j一直加到k都没有被i整除,那说明i就是素数了

{

m=m+i;//求得的素数相加

}

}

System.out.println(m);

}

}

复制代码
刚才忘了素数原来是大于1的,所以结果才为1061,正确结果为1060

1.PNG (23.5 KB, 下载次数: 0)

下载附件

2013-6-21 21:54 上传

打印的结果

作者: oxf974025918 时间: 2013-6-21 22:32

oxf974025918 发表于 2013-6-21 20:35
package com.heima;

import java.util.Arrays;

没有排序前：[2, 5, 9, 10, 48, 95, 154, 31, 59, 69]
排序后：[2, 5, 9, 10, 31, 48, 59, 69, 95, 154]
数组中的素数全部赋值为零,排序后：[0, 0, 9, 10, 0, 48, 0, 69, 95, 154]

作者: oxf974025918 时间: 2013-6-21 22:33

oxf974025918 发表于 2013-6-21 20:23
package com.heima;

public class PrimeNum {

结果：1060
作者: oxf974025918 时间: 2013-6-21 22:47

oxf974025918 发表于 2013-6-21 22:32
没有排序前：[2, 5, 9, 10, 48, 95, 154, 31, 59, 69]
排序后：[2, 5, 9, 10, 31, 48, 59, 69, 95, 154]
...

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)) //数组为质素设置为0
arr=0;
}
System.out.println("数组中的素数全部赋值为零,排序后："+Arrays.toString(arr));//
for(int i=0;i<arr.length-1;i++){
for (int k = 0; k < i; k++) {
System.out.print(" ");
}
for(int j=i;j<=i;j++){
System.out.print(arr);
}
System.out.println();
}
}
//判断是否是质素
static boolean isPrime(int n){
for(int i=2;i<n/2;i++)
if(n%i==0)
return false;
return true;
}

}
结果：
没有排序前：[2, 5, 9, 10, 48, 95, 154, 31, 59, 69]
排序后：[2, 5, 9, 10, 31, 48, 59, 69, 95, 154]
数组中的素数全部赋值为零,排序后：[0, 0, 9, 10, 0, 48, 0, 69, 95, 154]
0
0
 9
10
0
 48
 0
 69
 95

作者: oxf974025918 时间: 2013-6-21 22:49

oxf974025918 发表于 2013-6-21 22:33
结果：1060

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);//打印和
}

}
结果：1060
作者: HM张博文 时间: 2013-6-21 22:49

//1. 打印输出一百以内的素数的累加和...

class Test3

{

public static void main(String[] args)

{

int sum=0;//定义sum为素数和并赋初值为0

for(int i=2;i<=100;i++)

if(isPrime(i))//如果是素数

{

sum+=i;//将素数加到和里面

if(i!=97)//如果不是最后一个素数

System.out.print(i+"+");//打印该素数后在后面加一个+

else

System.out.print(i+"=");//如果是最后一个素数，则后面打印一个=

}

System.out.println(sum);//最后打印他们的和

}

static boolean isPrime(int i)//定义一个判断素数的函数

{

for(int j=2;j<=Math.sqrt(i);j++)

if(i%j==0)

return false;

return true;

}

}

//最后运行结果是2+3+5+……+97=1060

复制代码

结果.jpg (12.45 KB, 下载次数: 0)

下载附件

2013-6-21 22:48 上传

result

作者: 郑锐 时间: 2013-6-21 22:54
package test;
/*
* 思路：
*1需要对数组进行排序
*2，对数组中的元素进行素数判定，如果是素数则返回0，不是返回元素。
*3.先用嵌套for循环输出一个空格直角三角形，在每一行后面加上非素数即可。
*
*/

public class Test {

/**
 * @param args
 */
public static void main(String[] args) {
int[] arr={2,5,9,10,48,95,154,31,59,69};
//对数组进行选择排序
arraySort(arr);
//遍历数组
for(int x=0;x<arr.length;x++){
System.out.print(arr[x]+" ");
}
System.out.println("");
//按要求格式输出非素数
select(arr);
}
//选择排序
public static void arraySort(int [] arr){
int temp;
for(int i=0;i<arr.length;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[i]>arr[j]){
temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
}
//输出一个空格直角三角形
public static void select(int [] arr){
for(int i=0;i<arr.length;i++){
for(int j=0;j<i;j++){
System.out.print(" ");
}
System.out.println(getNotSuShu(arr[i]));
}

}
//判断元素是不是素数
public static int getNotSuShu(int arr){
int y=0;

int temp = (int) Math.sqrt(arr);
if (arr <= 3) {
y=arr;
} else {
 for (int x = 2; x <= temp; x++) {
 if (arr % x == 0) {
 return 0;
 }
 if (x >= temp) {
 y= arr;
 }
 }
}
return y;
}
}

输出结果.jpg (17.68 KB, 下载次数: 0)

下载附件

2013-6-21 22:54 上传

作者: tpsu88 时间: 2013-6-21 22:56

/**

* 打印输出一百以内的素数的累加和...

*/

public class Sum {

public static void main (String args []) {

int sum = 0;//初始化变量

//循环1-100

for (int i=1; i<=100; i+=2) {

boolean f = true;

//判断每个数是不是素数

for (int j=2; j<i; j++) {

if (i%j ==0) {

f = false;

break;

}

}

if (!f) {continue;}

sum += i;//累加

System.out.print(" " + i);

}

System.out.println();

System.out.println("Sum= "+sum);

}

}
复制代码

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

下载附件

2013-6-21 22:56 上传

作者: 李九一 时间: 2013-6-21 22:56
题1
package com.itheima;

public class test1 {

public static boolean IsPrime (int m)

{

 int i;

 if (m == 2) return true;

 if (m == 1 || m % 2 == 0) return false;

 for (i = 3; i * i <= m;)

 {

 if (m % i == 0) return false;

 i += 2;

 }

 return true;

}

public static void main(String[] args) {

int n,sum,i;

 n=100; //上限是100

sum =0;

for(i=2;i<n;i++) //从2到100依次循环判断

{

 if(IsPrime(i)) //如果是素数

 sum += i; //累加和

}

System.out.println("sum="+sum); //输出累加和

}

}

复制代码

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

下载附件

2013-6-21 22:56 上传

作者: .netNo1 时间: 2013-6-21 22:58

int a, b;

 int sum =0; //用来存储素数和

 for (a = 2; a <= 100; a++) //从2到100一次循环判断（1不是素数）

 {

 for (b = 2; b <= a - 1; b++)//2到该数如果没有可以被该数整除的则为素数

 {

 if (a % b == 0) //求余为0表示可以被整出，则跳出

 break;

 }

 if (a == b) //没有可以被整除的，为素数

 {

 sum +=a; //求和

 }

 }

 Console.Write(sum);

 Console.ReadKey();

 //结果：1060(图片不会搞)

复制代码
作者: tpsu88 时间: 2013-6-21 22:59
最小的素数是2,也是唯一的偶质数
/**

*题目：1.将该数组由小到大进行排列，数组中的素数全部赋值为零，并按阶梯状输出。

* 数组： 2 5 9 10 48 95 154 31 59 69

*/

//排序

class Sort {

public void chooseSort(int[] arr) {

//外循环选第一个挨个比，然后选第二个挨个比。-1是最后一个不用比。

for(int i=0;i<arr.length-1; i++) {

//内循环拿外循环第一个跟后面的挨个比,i+1是不用第0角标跟第0角标比。

for(int j=i+1; j<arr.length; j++) {

if(arr[i]>arr[j]) {

int temp = arr[i];//定义一个变量temp临时存储

arr[i] = arr[j];

arr[j] = temp;

}

}

}

}

}

//素数

class ZhiShu {

public void zhiShu(int[] arr) {

new PrintArr().printArray(arr);//排序后的数组，打印一遍

for(int i=0; i<arr.length-1;i++) {

boolean f = true;

for(int j=2; j<arr[i]; j++) {

if(arr[i]%j==0) {

f = false;

break;

}

}

if(!f) { continue;}

arr[i] = 0;

}

}

}

//打印数组

class PrintArr {

public void printArray(int[] arr) {

System.out.print("[");

//i是从0角标开始

for(int i=0; i<arr.length; i++) {

//length-1是不最后一个不打印,

if(i!=arr.length-1) {

System.out.print(arr[i] + ", ");

}

else {

System.out.println(arr[i] + "]");

}

}

}

}

//阶梯输出

class LouTi {

public void louTi(int[] arr) {

//定义行数

for(int i=0; i<arr.length; i++) {

//i和x都是每次递增1

for(int j=0; j<=i; j++) {

System.out.print(" ");

}

System.out.print(arr[i]);

System.out.println();

}

}

}

class JieTi{

public static void main(String[] args) {

int[] arr = {2,5,9,10,48,95,154,31,59,69};

new Sort().chooseSort(arr);

new ZhiShu().zhiShu(arr);

new PrintArr().printArray(arr);

new LouTi().louTi(arr);

}

}
复制代码

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

下载附件

2013-6-21 22:58 上传

作者: 杨兴庭 时间: 2013-6-21 23:38
看看。。
作者: oxf974025918 时间: 2013-6-21 23:51
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);//打印和
}

}
结果：1060
作者: 小冰块 时间: 2013-6-21 23:51

/*

需求：打印输出一百以内的素数的累加和...

*/

class Sushu

{

public static void main(String[] args)

{

int sum= 0;//定义累加器

for (int i = 2;i <= 100 ;i++ )//一百以内循环判断

{

if (isSuShu(i))//如果是素数，则累加到累加器中

{

sum = sum+i;

}

}

System.out.println(sum);

}

//判断是否为素数

public static boolean isSuShu(int x)

{

for (int k = 2 ; k<x ; k++ )

{

if ((x % k)==0)

{

return false;

}

}

return true;

}

}

复制代码

1060.PNG (10.17 KB, 下载次数: 0)

下载附件

2013-6-21 23:48 上传

/*

第二题：将该数组由小到大进行排列，数组中的素数全部赋值为零，并按阶梯状输出。

 数组： 2 5 9 10 48 95 154 31 59 69

*/

class Sort

{

public static void main(String[] args)

{

int arr[] = {2,5,9,10,48,95,154,31,59,69};//定义数组

sop("排序前的数组是：");

sop(arr);//输出数组

sort(arr);//调用排序算法

sop("排序后的数组是：");

sop(arr);//输出数组

sop("素数全部赋值为0后的数组是：");

for (int i = 0;i<arr.length ;i++ )//将所有素数元素赋值为零

{

if (isSuShu(arr[i]))

{

arr[i]=0;

}

}

sop(arr);

sop("排成阶梯型后的数组为：");

jieTi(arr);//调用阶梯型算法并输出

}

//数组排序

public static void sort(int[] arr)

{

for (int j=0 ; j<arr.length-1 ; j++ )

{

for (int i = 0 ;i<arr.length-1-j ;i++ )

{

if (arr[i]>arr[i+1])

{

int temp = arr[i];

arr[i] = arr[i+1];

arr[i+1] = temp;

}

}

}

}

//判断是否为素数

public static boolean isSuShu(int x)

{

for (int k = 2 ; k<x ; k++ )

{

if ((x % k)==0)

{

return false;

}

}

return true;

}

//数组排成阶梯型后：

public static void jieTi(int[] arr)

{

for (int i = 0;i<arr.length ;i++ )

{

for (int j = 0;j<=i ;j++ )

{

System.out.print(" ");

}

sop(arr[i]);

}

}

//输出数组

public static void sop(int[] arr)

{

for (int i = 0;i<arr.length ;i++ )

{

System.out.print(arr[i]+" ");

}

System.out.println();

}

//重载输出语句

public static void sop(Object obj)

{

System.out.println(obj);

}

}

复制代码

2.PNG (41.8 KB, 下载次数: 0)

下载附件

2013-6-21 23:50 上传

/*

第三题需求：手动输入一个自然数N，反向打印N行杨辉三角

*/

class YangHui

{

public static void main(String[] args)

{

int x=5;

int[][] a = new int[x][x];

for(int i=0;i<x;i++)//先赋值边际元素为1

{

a[i][0]=1;a[i][i]=1;

}

for(int i=2;i<x;i++)//填满整个杨辉三角

{

for(int j=1;j<i;j++)

a[i][j]=a[i-1][j]+a[i-1][j-1];

}

for (int i = x-1;i>=0 ;i-- )//倒着打印

{

for (int k = 0;k<x-i ;k++ )

{

System.out.print(" ");//控制空格的数量

}

for (int j=0;j<=i ;j++ )

{

System.out.print(" "+a[i][j]);

}

System.out.println();

}

}

}

复制代码

3.PNG (21 KB, 下载次数: 0)

下载附件

2013-6-21 23:51 上传

作者: oxf974025918 时间: 2013-6-21 23:52
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;
}
System.out.println("数组中的素数全部赋值为零,排序后："+Arrays.toString(arr));//
for(int i=0;i<arr.length-1;i++){
for (int k = 0; k < i; k++) {
System.out.print(" ");
}
for(int j=i;j<=i;j++){
System.out.print(arr[i]);
}
System.out.println();
}
}
//判断是否是质素
static boolean isPrime(int n){
for(int i=2;i<n/2;i++)
if(n%i==0)
return false;
return true;
}

}
结果：
没有排序前：[2, 5, 9, 10, 48, 95, 154, 31, 59, 69]
排序后：[2, 5, 9, 10, 31, 48, 59, 69, 95, 154]
数组中的素数全部赋值为零,排序后：[0, 0, 9, 10, 0, 48, 0, 69, 95, 154]
0
0
 9
10
0
 48
 0
 69
 95

作者: oxf974025918 时间: 2013-6-22 00:24
package com.heima;

public class PrintDemo {

/**
 * 3.手动输入一个自然数N，反向打印N行杨辉三角。

 * @author oxf
 */
public static void main(String[] args) {
// TODO Auto-generated method stub
 getPri(4);
}
public static void getPri(int n){
int[][]a=new int[n][n];
int i=0,j=0;
for (i = 0; i < n; i++) {
a[i][i]=1; //使对角线为1
a[i][0]=1; //使第一列为1
}
for(i=1;i<n;i++){
for (j = 1; j<= i-1; j++) {
a[i][j]=a[i-1][j-1]+a[i-1][j]; //上一行中同列和前一列两个数之和

}

}
int b=n;
for (i = n-1; i>=0; i--) {
for(int k=0;k<=n-i;k++){
System.out.print(" ");
}
for(j=i;j>=0;j--){

System.out.print(a[i][j]+"\t");
}
System.out.println();
}
}

}
结果：
 1 3 3 1
1 2 1
1 1
 1

作者: 李九一 时间: 2013-6-22 00:28
题2
package com.itheima;

import java.util.Arrays;

public class test2 {

public static boolean IsPrime (int m)

{

 int i;

 if (m == 2) return true;

 if (m == 1 || m % 2 == 0) return false;

 for (i = 3; i * i <= m;)

 {

 if (m % i == 0) return false;

 i += 2;

 }

 return true;

}

public static void main(String[] args) {

int []num={2,5,9,10,48,95,154,31,59,69};

int i,j,k;

 Arrays.sort(num);//把数组元素从打到小排序

for(i=0;i<num.length;i++){

System.out.print(num[i]+" ");

}

System.out.println("\n"+"=========================");

for(i=0;i<num.length;i++)

{

if(IsPrime(num[i])){

num[i]=0;//数组中的素数全部赋值为零

}System.out.print(num[i]+" ");

} System.out.println("\n"+"=========================");

for(i=0;i<num.length;i++){

System.out.print("\n");

for(j=0;j<i;j++)

System.out.print(" ");

 System.out.print(num[j]);



}

}

}

复制代码

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

下载附件

2013-6-22 00:28 上传

作者: 杨兴庭 时间: 2013-6-22 00:56
[/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); //打印结果

}

}

作者: pys200603027 时间: 2013-6-22 01:25
题1
public class test2 {

public static void main(String[] args) {

int i, j;

int sum=0;//用于计算素数的总和

// 素数即质数，除1和本身能整除以外，不能被其他数整除

// 判断一个数n为素数，去用2-n-1整除，如果有能整除，说明这个数不是素数

// 双重循环

for (i = 2; i <= 100; i++) {

// 判断i是否为素数

for (j = 2; j < i; j++) // 循环j=2--i-1

{

if (i % j == 0) {

break; // 跳出循环

}

}

if (j >= i) // 该数是素数

{

sum+=i;//累加素数

}

}

System.out.println(sum);//打印最终结果

}

}

复制代码
题1结果：

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

下载附件

2013-6-22 01:15 上传

题2
import java.util.Arrays;

public class test3 {

public static void main(String[] args){

int arrayTemp[]={2,5,9,10,48,95,154,31,59,69};//声明一个数组用于保存待处理的数据

BubbleSort(arrayTemp);//冒泡算法排序

//Arrays.sort(arrayTemp);调用排序方法

System.out.println(Arrays.toString(arrayTemp));//打印排序之后的数组

isPrime(arrayTemp);//素数判断并且将素数改为0

System.out.println(Arrays.toString(arrayTemp));//打印更改之后的数组

printArray(arrayTemp);//阶梯打印数组

/*

for(int n=0;n<arrayTemp.length;n++){

System.out.print(arrayTemp[n]+",");

}

*/

}

/**

 * 将数组进行阶梯状打印

 * @param arrayTemp 待输出的数组

 */

static void printArray(int[] arrayTemp){

for(int i=0;i<arrayTemp.length;i++){

for(int j=0;j<i;j++){

System.out.print(" ");//打印空格

}

System.out.println(arrayTemp[i]);//打印数组中的值

}

}

/**

 * 判定是否是素数，如果是素数即变成0

 * @param arrayTemp 待判定的数组

 */

static void isPrime(int[] arrayTemp){

int i,j;

for(i=0;i<arrayTemp.length;i++){

for(j=2;j<arrayTemp[i];j++){

if(arrayTemp[i]%j==0)//判定是否是素数

break;//跳出循环

}

if(j>=arrayTemp[i]){// 该数是素数

arrayTemp[i]=0;

}

}

}

/**

 * 冒泡排序

 * @param arrayTemp 待排序的数组

 */

static void BubbleSort(int[] arrayTemp){

for(int i=0;i<arrayTemp.length-1;i++){

for(int j=0;j<arrayTemp.length-i-1;j++){

if(arrayTemp[j]>arrayTemp[j+1]){

int temp=0;

temp=arrayTemp[j];

arrayTemp[j]=arrayTemp[j+1];

arrayTemp[j+1]=temp;

}

}

}

}

}

复制代码
题2结果：

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

下载附件

2013-6-22 01:17 上传

题3
import java.util.Scanner;

public class test4 {

public static void main(String[] args){

System.out.println("please enter a number:");

Scanner in=new Scanner(System.in);//用于输入一个数值N

int conutYH=in.nextInt();

 int[][] array=YH(conutYH);//计算杨辉三角



 //开始打印杨辉三角

 for(int i=array.length-1;i>-1;i--){

 for(int n=array.length-1;n>i;n--)

 System.out.print(" ");//控制打印空格

 for(int j=0;j<array[i].length;j++){

 System.out.print(array[i][j]+" ");//打印输出数值

 }



 System.out.println();//换行

 }



}

/**

 *

 * @param num 杨辉三角的行数

 * @return 返回保存着杨辉三角的数组

 */

public static int[][] YH(int num){

 int[][] array=new int[num][];//建立一个二维数组用于保存数值

 for(int i=0;i<array.length;i++){

 array[i]=new int[i+1]; //动态生成二维数组的子数组，可以节省内存空间

 for (int j = 0; j < array[i].length; j++) {

 if(j==0||j==i){

 array[i][j]=1; //杨辉三角的外边都是1

 }else{

 //第n行的第m个数和第n-m+1个数相等，即C(n-1,m-1)=C(n-1,n-m)

 array[i][j]=array[i-1][j-1]+array[i-1][j];

 }

 }

 }

 return array;//返回保存的数组

}

}

复制代码
题3结果：

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

下载附件

2013-6-22 01:25 上传

作者: 万琪 时间: 2013-6-22 01:42

package heima;

import java.util.Arrays;

import java.util.Scanner;

public class Test01 {

public static void main(String[] args) {

Test01 ts = new Test01();

System.out.println("第一题：");

ts.sushu100();

System.out.println("\n\n第二题：");

ts.arr();

System.out.println("\n\n第三题：");

ts.yagnhui();

}

// 素数判断方法

boolean isSuShu(int num) {

for (int i = 2; i < num; i++) {

if (num % i == 0) {

return false;

}

}

return true;

}

// 第一题

// 1-100中的素数

void sushu100() {

System.out.println("1-100中的素数:");

// 1不是素数也不是和数

for (int i = 2; i <= 100; i++) {

if (isSuShu(i))

System.out.print(i + ",");

}

}

// 第二题

void arr() {

// 原数组

int arr[] = { 2, 5, 9, 10, 48, 95, 154, 31, 59, 69 };

Arrays.sort(arr);

for (int i = 0, z = 0; i < 4; i++) {

for (int j = 0; j <= i; j++, z++) {

// 替换素数

if (isSuShu(arr[z]))

arr[z] = 0;

System.out.print(arr[z] + " ");

}

System.out.println();

}

}

// 第三题

void yagnhui() {

// 输入行数

// Scanner input = new Scanner(System.in);

System.out.println("请输入行数：");

// int n = input.nextInt();

int n = 10;

int mat[][] = new int[n + 1][];

int i, j;

// 给二维赋值

for (i = 0; i < n + 1; i++) {

mat[i] = new int[i + 1];

mat[i][i] = 1;

for (j = 1; j < i; j++) {

mat[i][j] = mat[i - 1][j - 1] + mat[i - 1][j];

}

}

// 打印了

for (i = mat.length - 1; i >= 0; i--) {

for (int j2 = 0; j2 <mat.length-i; j2++) {

System.out.print(" ");

}

for (j = mat[i].length - 1; j > 0; j--)

System.out.print(" " + mat[i][j]);

System.out.println();

}

}

}

复制代码
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
结果是：

第一题：
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


作者: 杨增坤 时间: 2013-6-22 08:25
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)

下载附件

2013-6-22 08:24 上传

作者: vicoooo 时间: 2013-6-22 08:31
1. 打印输出一百以内的素数的累加和
public class PrimeNumber{

public static void main (String []args) {

//素数：指在一个大于1的自然数中，除了1和此整数自身外，不能被其他自然数整除的数。

int j;

int sum = 0;

for(int n=1;n<=100;n++) {

for(j=2;j<=n-1;j++) {

if(n%j==0)

break;

}

if(j>=n-1&&n>1) {

//System.out.print(n+",");

sum += n;

}

}

System.out.println("sum="+sum);

}

}

复制代码
输出结果：

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

public static void main(String args[]){

int[] arr1 = {2,5,9,10,11,48,95,154,31,59,69};

System.out.println("排序前：");

printArr(arr1);

int[] arr2 = arrSort(arr1);

System.out.println("排序后：");

printArr(arr2);

int[] arr3 = primeArr(arr2);

System.out.println("数组改变后：");

printArr(arr3);

System.out.println("阶梯输出：");

ladPrint(arr3);

}

/**

 * 使用冒泡排序对数组进行排序

 * @param arr

 * @return

 */

public static int[] arrSort(int[] arr){

for(int i=0;i<arr.length;i++){

for(int j=0;j<arr.length-i-1;j++){

if(arr[j]>arr[j+1]){

int temp = arr[j];

arr[j]=arr[j+1];

arr[j+1]=temp;

}

}

}

return arr;

}

/**

 * 打印输出数组

 * @param arr

 */

public static void printArr(int[] arr){

for(int i=0;i<arr.length;i++){

System.out.print(arr[i]+" ");

}

System.out.println();

}

/**

 * 判断数组中是否存在素数，并替换为0

 * @param arr

 * @return

 */

public static int[] primeArr(int[] arr){

int j;

System.out.println("数组中存在的素数：");

for(int i=0;i<arr.length;i++){

//除以比自身小的数，如果没有余数，则表示能被其他数整除，不是素数

for(j=2;j<=arr[i];j++) {

if(arr[i]%j==0)

break;

}

if(j>=arr[i]-1&&arr[i]>1) {

System.out.print(arr[i]+" ");

arr[i]=0;

}

}

System.out.println();

return arr;

}

/**

 * 阶梯输出

 * @param arr

 */

public static void ladPrint(int[] arr){

for(int i=0;i<arr.length;i++){

for(int j=0;j<i;j++){

System.out.print(" ");

}

System.out.println(arr[i]);

}

}

}

复制代码
输出结果为：

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

import java.io.IOException;

import java.io.InputStreamReader;

public class Triangle {

public static void main(String args[]) throws IOException{

int a;

System.out.print("请输入一个整数：");

BufferedReader strin=new BufferedReader(new InputStreamReader(System.in));

a=Integer.parseInt(strin.readLine());

System.out.println("输入的数是："+a);

calculate(a);

}

public static void calculate(int n){

 //倒置杨辉三角

for(int i=n;i>=1;i--){

 for(int j=1;j<=n-i;j++){

 System.out.print(" ");

 }

 //打印空格后面的字符,从第1列开始往后打印

 for(int j=1;j<=i;j++){

 System.out.print(num(i,j) +" ");

 }

 System.out.println();

 }

}

public static int num(int x,int y){//第x行，第y列

 if(y==1||y==x){

 return 1;

 }

 //每一行的数字（除了第一列和最后一列）都是上一行两个数字之和

 int c = num(x-1,y-1)+num(x-1,y);

 return c;

}

}

复制代码
结果为：

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

下载附件

2013-6-22 08:28 上传

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

下载附件

2013-6-22 08:29 上传

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

下载附件

2013-6-22 08:31 上传

作者: tpsu88 时间: 2013-6-22 09:03
这次结果对了吧！我数学常识有待提高啊！呵呵，居然把1也当素数！！
/**

* 打印输出一百以内的素数的累加和...

*/

public class Sum {

public static void main (String args []) {

int sum = 0;//初始化变量

//循环1-100

for (int i=1; i<=100; i++) {

boolean f = true;

//判断每个数是不是素数

if(i!=1) {

for (int j=2; j<i; j++) {

if (i%j ==0) {

f = false;

break;

}

}

if (!f) {continue;}

sum += i;//累加

System.out.print(" " + i);

}}

System.out.println();

System.out.println("Sum= "+sum);

}

}
复制代码

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

下载附件

2013-6-22 09:03 上传

作者: yooc 时间: 2013-6-22 09:14

/*

********************

项目名:黑马版主题解

作者：yooc

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

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

********************

*/

import java.util.*;

class HeimaTest

{

//主函数

public static void main(String[] args)

{

sop("***********题目1**********");

timu1(); //执行题目1

sop("***********题目2**********");

timu2(); //执行题目2

sop("***********题目3**********");

timu3(); //执行题目3

}

//功能函数打印到控制台

public static void sop(Object obj)

{

System.out.println(obj);

}

//********题目1 求素数********

public static void timu1()

{

int N = 100; //范围

int i, j,temp=0;

sop("100以内的素数有：");

for (i = 2; i <= 100; i++) //求素数开始

{

for (j = 2; j < i; j++)

if (i % j== 0) //不满足素数条件直接跳出内循环

break;

if(j==i) //内循环没有中途跳出则找到素数一枚

{

System.out.print(i+" "); //输出单个素数

temp+=i; //记录累加和

}

}

sop("\n累加和为："+temp); //输出结果

}

//********题目1结束********

/*

********题目2********

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

数组： 2 5 9 10 48 95 154 31 59 69

*/

public static void timu2()

{

int i,j;

int[] a = {2,5,9,10,48,95,154,31,59,69};

Arrays.sort(a); //将数组排序

sop("数组排序后:");

sop(Arrays.toString(a));

for (i=0;i<a.length;i++)

{

for (j = 2; j < a[i]; j++) //判断数组a中有无素数

if (i % j== 0) //不满足素数条件直接跳出内循环

break;

if(j==a[i]) //内循环没有中途跳出则找到素数一枚

{

a[i]=0; //将其置0

}

}

sop("数组改变后:");

sop(Arrays.toString(a));

//按题目要求将其输出

for (int m=0;m<a.length ;m++ )

{

for (int n=0;n<m ;n++ )

{

System.out.print(" ");

}

sop(a[m]);

}

}

//******题目2结束********

/*

********题目3********

手动输入一个自然数N，反向打印N行杨辉三角。

*/

public static void timu3()

{

StringBuilder sb = new StringBuilder(); //创建字符串缓冲以字符为单位存入数据

List<String> al = new ArrayList<String>(); //创建list集合以行为单位存入数据 (反转用)

try

{

//手动输入一个自然数N，反向打印N行杨辉三角。

Scanner ss=new Scanner(System.in);

System.out.print("请输入一个数(建议不大于10)：");

int n=(int)ss.nextInt()+1;

//根据 mat[i][j] = mat[i - 1][j - 1] + mat[i - 1][j] 计算杨辉三角

int mat[][] = new int[n][];

int i, j;

for (i = 0; i < n; i++)

{

mat[i] = new int[i + 1];

mat[i][i] = 1; //最右边全为1

for (j = 1; j < i; j++)

{

mat[i][j] = mat[i - 1][j - 1] + mat[i - 1][j];

}

}

for (i = 0; i < mat.length; i++)

{

for (j = 1; j < n - i; j++)

{

sb.append(" "); //字符缓冲器存入循环次数为每行前边的空格数

}

for (j = 1; j < mat[i].length; j++)

{

if (mat[i][j]!=0)

{

sb.append(" " + mat[i][j]); //字符缓冲器存入主要数据

}

}

al.add(sb.toString()); //字符缓冲器所有数据存入 List集合

sb.delete(0,sb.length());//字符缓冲器清空以便继续循环

}

//逆序输出List集合所有元素

for (int k = al.size()-1;k>0 ;k-- )

{

System.out.println(al.get(k));

}

}

catch(Exception e)

{

e.printStackTrace();

}

}

//******题目3结束********

}

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

121.jpg (37.38 KB, 下载次数: 0)

下载附件

2013-6-22 09:13 上传

输入7

122.jpg (38.89 KB, 下载次数: 0)

下载附件

2013-6-22 09:13 上传

作者: ︶ㄣ紫藤ㄜ︵ 时间: 2013-6-22 09:15
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)

下载附件

2013-6-22 09:15 上传

作者: 关关雎鸠 时间: 2013-6-22 09:30
唉，没检查代码，出糗了。版主我修改了。。

为了节约空间，值贴出for循环的那一部分。 
复制代码
太粗心了，呵呵~

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

下载附件

2013-6-22 09:29 上传

作者: 关关雎鸠 时间: 2013-6-22 09:31

作者: ︶ㄣ紫藤ㄜ︵ 时间: 2013-6-22 09:32

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)

下载附件

2013-6-22 09:32 上传

作者: 萧萧北 时间: 2013-6-22 09:55
1. 打印输出一百以内的素数的累加和...
public class Num {

public static void main(String[] args)

{

int flag; //定义标识数 1表示素数 0表示非素数

int sum=0;

for(int i=2;i<=100;i++) //

{

flag=1;

for(int m=2;m<=i/2;m++)

{//如果这个数能被整除，则为非素数，flag 标识变为0

if(i%m==0)

flag=0;

}

if(flag==1) //如果这个数是素数，则累加

{

sum+=i;

}

}

System.out.println(sum);

}

}

复制代码
作者: 萧萧北 时间: 2013-6-22 09:57

萧萧北发表于 2013-6-22 09:55
1. 打印输出一百以内的素数的累加和...

运算结果为：1060

版主不好意思哈，忘记贴上我的结果了
作者: 刘晓 时间: 2013-6-22 10:31

第一题：

/*

* 1. 打印输出一百以内的素数的累加和...

* */

public class test1 {

public static void main(String[] args)

{

int sum=1;

p:for(int i=2;i<100;i++)//标记循环跳出的位置和控制循环100以内的整数

{

for(int j=2;j<i;j++)//控制循环的次数

if(i%j==0) //判断是否为素数

continue p;//是的话，跳到标记的循环位置，继续下一次循环

sum=sum+i; //是素数的话，累加

System.out.print(i+" "); //打印所有的素数

}

System.out.println();

System.out.println("素数和为："+sum);

}

}

第二题：

/*

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

数组： 2 5 9 10 48 95 154 31 59 69

* */

public class Test2 {

public static void main(String[] args)

{

int[] arr={2,5,9,10,48,95,154,31,59,69};

for(int i=0;i<arr.length;i++)//把数组从大到小排序

{

for(int j=i+1;j<arr.length;j++)

{

if(arr[i]>arr[j])

{

int temp=arr[i];

arr[i]=arr[j];

arr[j]=temp;

}

}

}

for(int i=0;i<arr.length;i++)//打印排完序的数组

System.out.print(arr[i]+" ");

System.out.println();

for(int i=0;i<arr.length;i++)//把数组中是素数的数置为零

{

for(int j=2;j<arr[i];j++)

{ if(arr[i]%j==0)

arr[i]=0;

}

}

for(int i=0;i<arr.length;i++)//控制循环次数

{

for(int j=0;j<i;j++)//控制打印空格的次数

{

System.out.print(" ");

}

System.out.println(arr[i]);

}

}

}

复制代码
作者: 陈新 时间: 2013-6-22 11:25
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)

下载附件

2013-6-22 11:25 上传

作者: 张歆明 时间: 2013-6-22 12:15
第一题：
/*1. 题目打印输出一百以内的素数的累加和...*/

/*

* 素数：在一个大于1的自然数中，除了1和此整数自身外，不能被其他自然数整除的数

* */

/*

* 思路：首先利用循环(1-100)检验每一个数是否是素数

* 如果是 累加到一个表示和的变量里面

* */

public class Test1 {

public static void main(String[] args) {

//素数的定义是除了1以外所以 1-100这个范围的素数最小是2 下界定为2

int lowPrimeBound =2;

//素数的定义是除了1以外所以 1-100这个范围的素数最小是2

int upPrimeBound =100;

//prime含义是素数 isPrime这个变量值为true表示是素数 这里初始化

boolean isPrime =true;

//primeSum用来记录给定范围的所有素数的和的变量

int primeSum =0;

//外层循环用：

//--来检测给定范围的数有哪些是素数

System.out.println("["+ lowPrimeBound+ ", "+upPrimeBound+"]的素数有：");

for(int i=lowPrimeBound; i<=upPrimeBound; i++){

//内层循环的作用：

//--根据素数的定义：在一个大于1的自然数中，除了1和此整数自身外，不能被其他自然数整除的数

//--要对给定的数 i 判定除了1和自身(i)以外的整数是不是有能被i整除的

for(int j=2; j<i; j++){

if(i%j==0){ //如果能被整除整除标记isPrime标记为false 表示不是素数

isPrime =false;

//开区间(1, i)之间一旦有一个数能整除i

//--就表示i不是素数 直接跳出 不用继续进行判断节省计算量

break;

}

//如果(1, i)之间都没有能整出i的数出现，就表示这个数i是素数 要更新isPrime

isPrime =true;

}

if(isPrime){

primeSum += i;

System.out.print(i +" ");

}

}

System.out.println();

System.out.println("["+ lowPrimeBound+ ", "+upPrimeBound+"]的素数的和是："+ primeSum);

}

}

复制代码
作者: 张歆明 时间: 2013-6-22 12:23
版主不好意思 刚才寻思发完 编辑一下但是发现不能编辑只能重新回复
第一题：
/*1. 题目打印输出一百以内的素数的累加和...*/

/*

* 素数：在一个大于1的自然数中，除了1和此整数自身外，不能被其他自然数整除的数

* */

/*

* 思路：首先利用循环(1-100)检验每一个数是否是素数

* 如果是 累加到一个表示和的变量里面

* */

public class Test1 {

public static void main(String[] args) {

//素数的定义是除了1以外所以 1-100这个范围的素数最小是2 下界定为2

int lowPrimeBound =2;

//素数的定义是除了1以外所以 1-100这个范围的素数最小是2

int upPrimeBound =100;

//prime含义是素数 isPrime这个变量值为true表示是素数 这里初始化

boolean isPrime =true;

//primeSum用来记录给定范围的所有素数的和的变量

int primeSum =0;

//外层循环用：

//--来检测给定范围的数有哪些是素数

System.out.println("["+ lowPrimeBound+ ", "+upPrimeBound+"]的素数有：");

for(int i=lowPrimeBound; i<=upPrimeBound; i++){

//内层循环的作用：

//--根据素数的定义：在一个大于1的自然数中，除了1和此整数自身外，不能被其他自然数整除的数

//--要对给定的数 i 判定除了1和自身(i)以外的整数是不是有能被i整除的

for(int j=2; j<i; j++){

if(i%j==0){ //如果能被整除整除标记isPrime标记为false 表示不是素数

isPrime =false;

//开区间(1, i)之间一旦有一个数能整除i

//--就表示i不是素数 直接跳出 不用继续进行判断节省计算量

break;

}

//如果(1, i)之间都没有能整出i的数出现，就表示这个数i是素数 要更新isPrime

isPrime =true;

}

if(isPrime){

primeSum += i;

System.out.print(i +" ");

}

}

System.out.println();

System.out.println("["+ lowPrimeBound+ ", "+upPrimeBound+"]的素数的和是："+ primeSum);

}

}

复制代码
运行结果：

第二题代码：
/*2. 将该数组由小到大进行排列，数组中的素数全部赋值为零，并按阶梯状输出。*/

/*

*思路：首先采用一种排序算法将数组进行排序-- 采用选择排序

* 然后对排序后的数组的每一个元素进行素数条件检测 检测到是素数 清零

* 最后阶梯打印该数组

*/

public class Test2 {

public static void main(String[] args) {

int[] arr ={2, 5, 9, 10, 48, 95, 154, 31, 59, 69};

//Step1. 对数组进行排序 ---采用选择排序

selectSort(arr);

System.out.print("改变前：");

//****改变前 --打印输出测试

printArry(arr);

//Step2. 对数组中的每一个数进行素数检测 并置换为0

primeChange(arr);

System.out.println();

System.out.print("改变后：");

//****改变后 --打印输出测试

printArry(arr);

//Step3. 阶梯状打印数组元素

stagePrintArry(arr);

}

//阶梯状打印数组元素 ---实际上在对角线上进行数组元素的打印---打印三角形

private static void stagePrintArry(int[] arr) {

//优化显示信息

System.out.println();

//外层循环控制打印的行数

//---由于一个元素占据一行所以 一共打印的行数就是数组中元素的个数

for(int i=0; i< arr.length; i++){

for(int j=1; j<=i+1; j++){

//对角线元素 打印该数组的元素

if(i==j)

System.out.print(arr[i]);

else

System.out.print(" ");

}

System.out.println();

}

}

//打印数组元素

private static void printArry(int[] arr) {

for(int x: arr){

System.out.print(x +" ");

}

}

//对数组中的素数进行清零

private static void primeChange(int[] arr) {

for(int x =0; x<arr.length; x++){

if(isPrime(arr[x]))//是素数 元素清零

arr[x] =0;

}

}

//判断一个数是否为素数

private static boolean isPrime(int num) {

boolean isPrime =true;

//--根据素数的定义：在一个大于1的自然数中，除了1和此整数自身外，不能被其他自然数整除的数

//--要对给定的数 i 判定除了1和自身(num)以外的整数是不是有能被i整除的

for(int i=2; i<num; i++){

if(num%i==0){ //如果能被整除整除标记isPrime标记为false 表示不是素数

isPrime =false;

//开区间(1, i)之间一旦有一个数能整除i

//--就表示i不是素数 直接跳出 不用继续进行判断节省计算量

break;

}

//如果(1, i)之间都没有能整出i的数出现，就表示这个数i是素数 要更新isPrime

isPrime =true;

}

return isPrime;

}

//对数组进行选择排序

private static void selectSort(int[] arr) {

//循环数组中的元素 --- 每完成一次外层循环 数组对应的位置就是本次循环中最小的值

//--i< arr.length-1 最后一次的时候一定是循环到数组的最后一个元素 最后一个元素已经没有

//--要比较的对象了所以将i< arr.length改为 i< arr.length -1

for(int i =0; i< arr.length-1; i++){

//每个位置的元素都要和该位置以后素组元素比较

for(int j =i+1; j <arr.length; j++){

//升序排列 --前面的数大了 就要和后面的交换

if(arr[i] >arr[j])

swap(i, j, arr);

}

}

}

//交换数组中两个元素的位置

private static void swap(int i, int j, int[] arr) {

int temp =arr[i];

arr[i] =arr[j];

arr[j] =temp;

}

}

复制代码
运行结果：

第三题代码：
/*3.倒序杨辉三角*/

import java.util.ArrayList;

public class Test3 {

public static void main(String[] args) {

int layers =4;

//Step1. 产生杨辉三角列表

ArrayList<ArrayList<Integer>> yanghuiTrList = generateYangTrList(layers);

System.out.println("产生的杨辉列表如下：");

printYanghuiList(yanghuiTrList);

//Step2.倒序打印杨辉三角

System.out.println("倒序打印杨辉三角如下：");

printInverseYanghuiArr(layers, yanghuiTrList);

}

/**

 * function: 倒序打印杨辉三角

 * @param layers ---表示杨辉三角的层数

 * @param yanghuiTrList ----杨辉三角的列表

 */

private static void printInverseYanghuiArr(int layers,

ArrayList<ArrayList<Integer>> yanghuiTrList) {

//Step1. 控制打印的行数

for(int i=1, layer =layers-1; i<=layers; i++, layer--){

//先打印空格部分 填充空白区域

for(int j=1; j<= i-1; j++){

System.out.print(" ");

}

//取出本层的杨辉数字列表

ArrayList<Integer> eachLayerList =yanghuiTrList.get(layer);

int index =0;

for(int j=1; j<=9 -2*i; j++){

if(j%2 ==0)//隔一位打印一个数字

System.out.print(" ");

else{

System.out.print(eachLayerList.get(index));

index++;

}

}

System.out.println();

}

}

//打印杨辉列表 -- 测试使用

private static void printYanghuiList(

ArrayList<ArrayList<Integer>> yanghuiTrList) {

System.out.println("**************************************");

for(int i=0; i<yanghuiTrList.size(); i++){

for(int j=0; j<yanghuiTrList.get(i).size(); j++){

System.out.print(yanghuiTrList.get(i).get(j)+ " ");

}

System.out.println();

}

System.out.println("**************************************");

}

//产生杨辉三角列表 方法的参数表示产生几层杨辉三角

private static ArrayList<ArrayList<Integer>> generateYangTrList(int layers) {

ArrayList<ArrayList<Integer>> trList =new ArrayList<ArrayList<Integer>>();

ArrayList<Integer> eachLayerList =null;

//顺序产生各层杨辉列表

for(int i=0; i<layers; i++){

eachLayerList =new ArrayList<Integer>();

//第0层杨辉列表： 1

if(i==0){

eachLayerList.add(1);

trList.add(eachLayerList);

continue;

}

//第1层杨辉列表： 1 1

if(i==1){

eachLayerList.add(1);

eachLayerList.add(1);

trList.add(eachLayerList);

continue;

}

//第0, 1层以外的杨辉列表

//--每层杨辉列表的首数字都为1

eachLayerList.add(1);

//取出最后一次的杨辉列表 一共下面累加获得本层的杨辉列表的元素

ArrayList<Integer> lastList =trList.get(trList.size()-1);

//累加上一层的相邻两个元素进行求和

for(int startIndex =0; startIndex <lastList.size() -1; startIndex++){

int adjacentSum =lastList.get(startIndex)+ lastList.get(startIndex+1);

eachLayerList.add(adjacentSum);

}

//--每层杨辉列表的尾数字都为1

eachLayerList.add(1);

trList.add(eachLayerList);

}

return trList;

}

}

复制代码
运行结果：

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

下载附件

2013-6-22 12:18 上传

第一题结果

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

下载附件

2013-6-22 12:20 上传

第二题运行结果

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

下载附件

2013-6-22 12:22 上传

第三题运行结果

作者: 萧萧北 时间: 2013-6-22 12:23
2.将该数组由小到大进行排列，数组中的素数全部赋值为零，并按阶梯状输出。
数组： 2 5 9 10 48 95 154 31 59 69
package test;

public class Num2 {

public static void main(String[] args)

{

int[] arr={2,5,9,10,48,95,154,31,59,69};

bubbleSort(arr); //调用排序功能

isS(arr); //调用判断素数功能

printArray(arr); //调用输出数组功能

}

//定义冒泡排序功能 由小到大

static public void bubbleSort(int[] arr)

{

for(int x=arr.length-1;x>0;x--)

{

for(int y=0;y<x;y++)

{

if(arr[y]>arr[y+1])

{

int temp=arr[y];

arr[y]=arr[y+1];

arr[y+1]=temp;

}

}

}

}

//定义按阶梯状输出数组中元素

public static void printArray(int[] arr)

{

for(int i=0;i<arr.length;i++)

{

for(int j=0;j<=i;j++)

{//实现按阶梯状输出 根据行数空出相应的空格

System.out.print(" ");

}

System.out.println(arr[i]); //输出数组元素

}

}

//判断素数的函数

public static void isS(int[] arr)

{

int flag; //定义标识数 1表示素数 0表示非素数

for(int i=0;i<arr.length;i++)

{

flag=1;

for(int m=2;m<=arr[i]/2;m++)

{//如果这个数能被整除，则为非素数，flag 标识变为0

if(arr[i]%m==0)

flag=0;

}

//如果这个数是素数则赋值为0

if(flag==1)

{

arr[i]=0;

}

}

}

}

复制代码
作者: 萧萧北 时间: 2013-6-22 12:25

萧萧北发表于 2013-6-22 12:23
2.将该数组由小到大进行排列，数组中的素数全部赋值为零，并按阶梯状输出。
数组： 2 5 9 10 ...

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

运算结果为：

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

下载附件

2013-6-22 12:25 上传

2题运算结果

作者: 蔡汉康 时间: 2013-6-22 12:27
{:soso_e100:}来看看
作者: 蔡汉康 时间: 2013-6-22 13:03

package itheima;

import java.util.Arrays;

public class Sushu {

public static void main(String[] args) {

System.out.println("-------------第一题--------------");

int sum = 0;

//因为1不是素数也不是合数，所以从2开始判断

for(int i = 2; i <= 100; i++) {

 //如果是素数就进行累加

if(isPrime(i)) {

 sum+=i;

 }

 }

System.out.println("1～100的素数和："+sum);

System.out.println("-------------第二题--------------");

int [] arrs = {2,5,9,10,48,95,154,31,59,69};

//打印数组改变前内容

System.out.println("数组改变前："+Arrays.toString(arrs));

//数组排序

Arrays.sort(arrs);

//遍历数组

for(int i = 0;i<arrs.length;i++){

//遍历数组，如果是素数，就将其赋值为0

if(isPrime(arrs[i])){

arrs[i]=0;

}

}

//打印数组改变后内容

System.out.println("数组改变后："+Arrays.toString(arrs));

//打印阶梯状数组

for(int i = 0;i<arrs.length;i++){

for(int j = 0;j<i;j++)

System.out.print(" ");

System.out.println(arrs[i]);

}

}

//判断是否为素数的方法，返回值为boolean

public static boolean isPrime(int num) {

//把一个数开方，得到该数可能被整除的取值范围：2～该数的开方值

 for(int i = 2; i <= Math.sqrt(num); i++) {

 //如果能被整除，就不是素数

 if(num % i == 0) {

 return false;

 }

 }

 //否则不能被整除，即是素数

 return true;

 }

}

复制代码

QQ截图20130622130455.png (8.72 KB, 下载次数: 0)

下载附件

2013-6-22 13:03 上传

作者: 蔡汉康 时间: 2013-6-22 13:07
不好意思啊，第二题因为疏忽，判断条件写反了，这是修正好的代码和结果！！！
package itheima;

import java.util.Arrays;

public class Sushu {

public static void main(String[] args) {

System.out.println("-------------第一题--------------");

int sum = 0;

//因为1不是素数也不是合数，所以从2开始判断

for(int i = 2; i <= 100; i++) {

 //如果是素数就进行累加

if(isPrime(i)) {

 sum+=i;

 }

 }

System.out.println("1～100的素数和："+sum);

System.out.println("-------------第二题--------------");

int [] arrs = {2,5,9,10,48,95,154,31,59,69};

//打印数组改变前内容

System.out.println("数组改变前："+Arrays.toString(arrs));

//数组排序

Arrays.sort(arrs);

//遍历数组

for(int i = 0;i<arrs.length;i++){

//遍历数组，如果是素数，就将其赋值为0

if(isPrime(arrs[i])){

}else{

arrs[i]=0;

}

}

//打印数组改变后内容

System.out.println("数组改变后："+Arrays.toString(arrs));

//打印阶梯状数组

for(int i = 0;i<arrs.length;i++){

for(int j = 0;j<i;j++)

System.out.print(" ");

System.out.println(arrs[i]);

}

}

//判断是否为素数的方法，返回值为boolean

public static boolean isPrime(int num) {

//把一个数开方，得到该数可能被整除的取值范围：2～该数的开方值

 for(int i = 2; i <= Math.sqrt(num); i++) {

 //如果能被整除，就不是素数

 if(num % i == 0) {

 return false;

 }

 }

 //否则不能被整除，即是素数

 return true;

 }

}

复制代码

QQ截图20130622130903.png (7.28 KB, 下载次数: 0)

下载附件

2013-6-22 13:07 上传

作者: xiaohu1218 时间: 2013-6-22 13:13
我今天上午刚看到的，三道题都写了

import java.util.Scanner;

class GetPrimeNumber {

/**

 * @param args

 *

 * 1. 打印输出一百以内的素数的累加和...

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

 * 数组： 2 5 9 10 48 95 154 31 59 69

 * 3.手动输入一个自然数N，反向打印N行杨辉三角。

 */

private static int sum = 0;//定义全局变量素数和 sum

private static int arr[]={2,5,9,10,48,95,154,31,59,69};//定义并初始化数组

private static int rownum = 0;//定义杨辉三角的行数rownum

public static void main(String[] args) {

// TODO Auto-generated method stub

getPrimeNumSum();//获取100以内的素数累加和

printNewNum();//重新排列输出

printTriangle();//反向打印杨辉三角

}

private static void getPrimeNumSum()

{

for(int i=2;i<100;i++)

{

if(i == 2 || i==3)//将2、3 两个特殊的数单列出来

{

System.out.println(i+"是素数");

sum += i;

}

for(int j=2;j<Math.sqrt(i);j++)

{

//如果除了1和它本身两个约数外，还有别的约数，那么这个数就不是素数

if(i%j==0 )

{

break;

}

//如果除了1和它本身两个约数外，没有别的约数，那么这个数就是素数

//加上j> Math.sqrt(i)-1)是为了限制计算和打印只进行一次

else if((i%j != 0) && (j > Math.sqrt(i)-1) )

{

System.out.println(i+"是素数");

sum += i;

}

}

}

System.out.println("100以内的素数之和是："+sum);

}

// 数组： 2 5 9 10 48 95 154 31 59 69

private static void printNewNum()

{

for(int k = 0;k < arr.length;k++)//判别数据是否是素数，并将数组中的素数改变为0

{

if(arr[k]==2 || arr[k]==3)

{

arr[k] = 0;

}

else

{

for(int kk = 2;kk <Math.sqrt(arr[k]);kk++)

{

if(arr[k] % kk == 0)//如果有其他约数,则跳出循环

break;

else if(arr[k]%kk !=0 && kk>Math.sqrt(arr[k])-1)//如果是素数，则将其数值修改为0

arr[k] = 0;

}

}

}

for (int ii = 0;ii<arr.length;ii++)//打印数据

for(int jj = 0 ;jj <=ii ;jj++)

if(jj == ii)

System.out.println(arr[ii]);//对角线形式打印并换行

else

System.out.print(" ");//打印空格

}

private static int getRow()

{

Scanner sc = new Scanner(System.in);// 获取输入数字

 try

 {

 rownum = sc.nextInt();

 while(rownum<1)//数据合法性判断

 {

 System.out.println("输入的数据大小不合法，请重新输入:");

 rownum = sc.nextInt();

 }

 }

 catch(Exception e)

 {

 System.out.println("输入数据不合法，出现异常："+e.toString());

 System.out.println("请重新输入一个正整数：");

 getRow();

 }

 return rownum;

}

//反向打印杨辉三角组合数开始结束部分采用定义的格式打印1 中间部分采用定义的方法计算出相应的数值并打印出来

private static void printTriangle()

{

System.out.println("请输入杨辉三角的行数：");

 rownum= getRow();

 //System.out.println(rownum);

for(int row = 1;row < rownum+1 ;row++)

{

for(int col=1;col<=2*rownum-row ;col++)

{

if(row == 1 && col%2 == 0)

System.out.print(" ");

else if(col == row || col == 2*rownum-row)//每行的开始、结束部分都是1

System.out.print(1);

else if (col>row && col <2*rownum-row && col % row == 0 )

{

//求分子

int numerator =getFactorial(rownum-row);

//求分母

int denominator = getFactorial(rownum-row-(col-1)/2)*getFactorial((col-1)/2);

//System.out.print(numerator+" "+denominator);

System.out.print(numerator/denominator);

}

else

System.out.print(" ");

}

System.out.println();

}

}

private static int getFactorial(int n)//求n的阶乘

{

if(n==1)

return 1;

else if(n>1)

return(n* getFactorial(n-1));

else

System.out.println("参数有误!");

return -1;

}

}

复制代码
作者: 星仔子 时间: 2013-6-22 13:45

/*3.倒序杨辉三角*/

import java.util.ArrayList;

public class Test3 {

public static void main(String[] args) {

int layers =4;

//Step1. 产生杨辉三角列表

ArrayList<ArrayList<Integer>> yanghuiTrList = generateYangTrList(layers);

System.out.println("产生的杨辉列表如下：");

printYanghuiList(yanghuiTrList);

//Step2.倒序打印杨辉三角

System.out.println("倒序打印杨辉三角如下：");

printInverseYanghuiArr(layers, yanghuiTrList);

}

/**

 * function: 倒序打印杨辉三角

 * @param layers ---表示杨辉三角的层数

 * @param yanghuiTrList ----杨辉三角的列表

 */

private static void printInverseYanghuiArr(int layers,

ArrayList<ArrayList<Integer>> yanghuiTrList) {

//Step1. 控制打印的行数

for(int i=1, layer =layers-1; i<=layers; i++, layer--){

//先打印空格部分 填充空白区域

for(int j=1; j<= i-1; j++){

System.out.print(" ");

}

//取出本层的杨辉数字列表

ArrayList<Integer> eachLayerList =yanghuiTrList.get(layer);

int index =0;

for(int j=1; j<=9 -2*i; j++){

if(j%2 ==0)//隔一位打印一个数字

System.out.print(" ");

else{

System.out.print(eachLayerList.get(index));

index++;

}

}

System.out.println();

}

}

//打印杨辉列表 -- 测试使用

private static void printYanghuiList(

ArrayList<ArrayList<Integer>> yanghuiTrList) {

for(int i=0; i<yanghuiTrList.size(); i++){

for(int j=0; j<yanghuiTrList.get(i).size(); j++){

System.out.print(yanghuiTrList.get(i).get(j)+ " ");

}

System.out.println();

}

}

//产生杨辉三角列表 方法的参数表示产生几层杨辉三角

private static ArrayList<ArrayList<Integer>> generateYangTrList(int layers) {

ArrayList<ArrayList<Integer>> trList =new ArrayList<ArrayList<Integer>>();

ArrayList<Integer> eachLayerList =null;

//顺序产生各层杨辉列表

for(int i=0; i<layers; i++){

eachLayerList =new ArrayList<Integer>();

//第0层杨辉列表： 1

if(i==0){

eachLayerList.add(1);

trList.add(eachLayerList);

continue;

}

//第1层杨辉列表： 1 1

if(i==1){

eachLayerList.add(1);

eachLayerList.add(1);

trList.add(eachLayerList);

continue;

}

//第0, 1层以外的杨辉列表

//--每层杨辉列表的首数字都为1

eachLayerList.add(1);

//取出最后一次的杨辉列表 一共下面累加获得本层的杨辉列表的元素

ArrayList<Integer> lastList =trList.get(trList.size()-1);

//累加上一层的相邻两个元素进行求和

for(int startIndex =0; startIndex <lastList.size() -1; startIndex++){

int adjacentSum =lastList.get(startIndex)+ lastList.get(startIndex+1);

eachLayerList.add(adjacentSum);

}

//--每层杨辉列表的尾数字都为1

eachLayerList.add(1);

trList.add(eachLayerList);

}

return trList;

}

}

复制代码
结果：
产生的杨辉列表如下：
1
1 1
1 2 1
1 3 3 1
倒序打印杨辉三角如下：
1 3 3 1
1 2 1
 1 1
1
/*2. 将该数组由小到大进行排列，数组中的素数全部赋值为零，并按阶梯状输出。*/

public class Test2 {

public static void main(String[] args) {

int[] arrs ={2, 5, 9, 10, 48, 95, 154, 31, 59, 69};

//对数组进行排序 ---采用选择排序

selectSort(arrs);

System.out.print("数组改变前：");

printArry(arrs);

//对数组中的每一个数进行素数检测 并置换为0

primeIsZero(arrs);

System.out.println();

System.out.print("数组改变后：");

printArry(arrs);

// 阶梯状打印数组元素

PrintArry1(arrs);

}

//阶梯状打印数组元素

private static void PrintArry1(int[] arr) {

//外层循环控制打印的行数

for(int i=0; i< arr.length; i++){

for(int j=1; j<=i+1; j++){

if(i==j)

System.out.print(arr[i]);

else

System.out.print(" ");

}

System.out.println();

}

}

//打印数组元素

private static void printArry(int[] arr) {

for(int x: arr){

System.out.print(x +" ");

}

}

//对数组中的素数进行清零

private static void primeIsZero(int[] arr) {

for(int x =0; x<arr.length; x++){

if(isPrime(arr[x]))//是素数 元素清零

arr[x] =0;

}

}

//判断一个数是否为素数

private static boolean isPrime(int num) {

boolean isPrime =true;

for(int i=2; i<num; i++){

if(num%i==0){

isPrime =false;

break;

}

isPrime =true;

}

return isPrime;

}

//对数组进行选择排序

private static void selectSort(int[] arr) {

for(int i =0; i< arr.length-1; i++){

for(int j =i+1; j <arr.length; j++){

if(arr[i] >arr[j])

swap(i, j, arr);

}

}

}

//交换数组中两个元素的位置

private static void swap(int i, int j, int[] arr) {

int temp =arr[i];

arr[i] =arr[j];

arr[j] =temp;

}

}

复制代码
结果：
数组改变前：2 5 9 10 31 48 59 69 95 154
数组改变后：0 0 9 10 0 48 0 69 95 154
0
9
 10
0
48
 0
 69
 95
 154
/*1. 题目打印输出一百以内的素数的累加和...*/

/*

* 思路：

* 素数是指，在一个大于1的自然数中，除了1和此整数自身外，不能被其他自然数整除的数

* 首先利用循环(1-100)检验每一个数是否是素数

* 如果是 累加到一个表示和的变量里面

* */

public class Test1 {

public static void main(String[] args) {

//素数的定义是除了1以外，所以在1~100之间，最小值为2，最大值为100

int min =2;

int max =100;

//定义变量isPrime，当为true时为素数

boolean isPrime =true;

//所有素数的和的变量

int sum =0;

//外层循环用：

//--来检测给定范围的数有哪些是素数

System.out.println("（"+ min+ ", "+max+"）的素数有：");

for(int i=min; i<=max; i++){

for(int j=2; j<i; j++){

if(i%j==0){ //如果能被整除整除标记isPrime标记为false 表示不是素数

isPrime =false;

break;

}

isPrime =true;

}

if(isPrime){

sum += i;

System.out.print(i +" ");

}

}

System.out.println();

System.out.println("（"+ min+ ", "+max+"）的素数的和是："+ sum);

}

}

复制代码
结果：
（2, 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
（2, 100）的素数的和是：1060

作者: xiaohu1218 时间: 2013-6-22 14:14

xiaohu1218 发表于 2013-6-22 13:13
我今天上午刚看到的，三道题都写了

不好意思，忘了贴了，刚才发现我的第三题有点Bug，修改了一下，现在把所有正式的程序和结果都重新贴上来，辛苦版主了

import java.util.Scanner;

class GetPrimeNumber {

/**

 * @param args

 *

 * 1. 打印输出一百以内的素数的累加和...

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

 * 数组： 2 5 9 10 48 95 154 31 59 69

 * 3.手动输入一个自然数N，反向打印N行杨辉三角。

 */

private static int sum = 0;//定义全局变量素数和 sum

private static int arr[]={2,5,9,10,48,95,154,31,59,69};//定义并初始化数组

private static int rownum = 0;//定义杨辉三角的行数rownum

public static void main(String[] args) {

// TODO Auto-generated method stub

getPrimeNumSum();//获取100以内的素数累加和

printNewNum();//重新排列输出

printTriangle();//反向打印杨辉三角

}

private static void getPrimeNumSum()

{

for(int i=2;i<100;i++)

{

if(i == 2 || i==3)//将2、3 两个特殊的数单列出来

{

System.out.println(i+"是素数");

sum += i;

}

for(int j=2;j<Math.sqrt(i);j++)

{

//如果除了1和它本身两个约数外，还有别的约数，那么这个数就不是素数

if(i%j==0 )

{

break;

}

//如果除了1和它本身两个约数外，没有别的约数，那么这个数就是素数

//加上j> Math.sqrt(i)-1)是为了限制计算和打印只进行一次

else if((i%j != 0) && (j > Math.sqrt(i)-1) )

{

System.out.println(i+"是素数");

sum += i;

}

}

}

System.out.println("100以内的素数之和是："+sum);

}

// 数组： 2 5 9 10 48 95 154 31 59 69

private static void printNewNum()

{

for(int k = 0;k < arr.length;k++)//判别数据是否是素数，并将数组中的素数改变为0

{

if(arr[k]==2 || arr[k]==3)

{

arr[k] = 0;

}

else

{

for(int kk = 2;kk <Math.sqrt(arr[k]);kk++)

{

if(arr[k] % kk == 0)//如果有其他约数,则跳出循环

break;

else if(arr[k]%kk !=0 && kk>Math.sqrt(arr[k])-1)//如果是素数，则将其数值修改为0

arr[k] = 0;

}

}

}

for (int ii = 0;ii<arr.length;ii++)//打印数据

for(int jj = 0 ;jj <=ii ;jj++)

if(jj == ii)

System.out.println(arr[ii]);//对角线形式打印并换行

else

System.out.print(" ");//打印空格

}

private static int getRow()

{

Scanner sc = new Scanner(System.in);// 获取输入数字

 try

 {

 rownum = sc.nextInt();

 while(rownum<1)//数据合法性判断

 {

 System.out.println("输入的数据大小不合法，请重新输入:");

 rownum = sc.nextInt();

 }

 }

 catch(Exception e)

 {

 System.out.println("输入数据不合法，出现异常："+e.toString());

 System.out.println("请重新输入一个正整数：");

 getRow();

 }

 return rownum;

}

//反向打印杨辉三角组合数开始结束部分采用定义的格式打印1 中间部分采用定义的方法计算出相应的数值并打印出来

private static void printTriangle()

{

System.out.println("请输入杨辉三角的行数：");

 rownum= getRow();

 //System.out.println(rownum);

for(int row = 1;row < rownum+1 ;row++)

{

for(int col=1;col<=2*rownum-row ;col++)

{

if(row == 1 && col%2 == 0)

{

System.out.print(" ");

continue;

}

else if(col == row || col == 2*rownum-row)//每行的开始、结束部分都是1

{

System.out.print(1);

continue;

}

else if (col>row && col <2*rownum-row && (col-row) %2 == 0 )

{

//求分子

if((rownum-row-(col-row)/2)>=0 && (col-row)/2>=0)

{

int numerator =getFactorial(rownum-row);

int denominator = getFactorial(rownum-row-(col-row)/2)*getFactorial((col-row)/2);

System.out.print(numerator/denominator);

continue;

}

//求分母

}

else

System.out.print(" ");

}

System.out.println();

}

}

private static int getFactorial(int n)//求n的阶乘

{

if(n==1 || n==0)

return 1;

else if(n>1)

return(n* getFactorial(n-1));

else

System.out.println("参数有误!");

return -1;

}

}

复制代码
运行结果如下：
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是素数
100以内的素数之和是：1060
0
0
 9
10
48
 95
 154
 0
 0
 69
请输入杨辉三角的行数：
5
1 4 6 4 1
1 3 3 1
 1 2 1
1 1
1

作者: 刘晓 时间: 2013-6-22 14:19

刘晓发表于 2013-6-22 10:31

第一题结果：
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
素数和为：1061
第二题的结果：
C:\Users\Administrator\Desktop
作者: .netNo1 时间: 2013-6-22 15:14

int length = 0; //杨辉三角形的长度

Console.Write("输入杨辉三角长度");

length = Convert.ToInt32(Console.ReadLine()); //指定杨辉三角的长度

if (length <= 13)

{

int[][] a = new int[length][]; //二维数组

for (int i = 0; i < a.Length; i++)

{

a[i] = new int[i + 1];//遍历，赋值增量

}

for (int j = 0; j < a.Length; j++)

{

a[j][0] = 1; //把第一列的元素都赋1

a[j][j] = 1;//把第一列最右边的元素都赋1

for (int m = 1; m < a[j].Length - 1; m++)

{

a[j][m] = a[j - 1][m - 1] + a[j - 1][m];//其余的值由杨辉公式计算

}

}

for (int i = a.Length - 1; i >= 0; i--)//遍历数组输出杨辉三角形

{

for (int b = 0; b < a.Length - a[i].Length; b++)

{

Console.Write("\0"); //输出空格

}

for (int j = a[i].Length-1; j >= 0; j--)

{

Console.Write("{0}\0", a[i][j]);

}

Console.Write("\n"); //换行

}

Console.Read();

}
复制代码
作者: 刘晓 时间: 2013-6-22 15:42

刘晓发表于 2013-6-22 14:19
第一题结果：
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
素数和为：106 ...

好吧，那我不上传相片了。直接给你复制第二题的结果。
2 5 9 10 31 48 59 69 95 154
2
5
 0
0
31
 0
 59
 0
 0
 0
作者: .netNo1 时间: 2013-6-22 16:05

int length = 0; //杨辉三角形的长度

Console.Write("输入杨辉三角长度");

length = Convert.ToInt32(Console.ReadLine()); //指定杨辉三角的长度

int[][] a = new int[length][]; //二维数组

for (int i = 0; i < a.Length; i++)

{

a[i] = new int[i + 1];//遍历，赋值增量

}

for (int j = 0; j < a.Length; j++)

{

a[j][0] = 1; //把第一列的元素都赋1

a[j][j] = 1;//把第一列最右边的元素都赋1

for (int m = 1; m < a[j].Length - 1; m++)

{

a[j][m] = a[j - 1][m - 1] + a[j - 1][m];//其余的值由杨辉公式计算

}

}

for (int i = a.Length - 1; i >= 0; i--)//遍历数组输出杨辉三角形

{

for (int b = 0; b < a.Length - a[i].Length; b++)

{

Console.Write("\0"); //输出空格

}

for (int j = a[i].Length - 1; j >= 0; j--)

{

Console.Write("{0}\0", a[i][j]);

}

Console.Write("\n"); //换行

}

Console.Read();

[img]桌面/三角[/img]
复制代码
作者: 刘晓 时间: 2013-6-22 16:11

刘晓发表于 2013-6-22 15:42
好吧，那我不上传相片了。直接给你复制第二题的结果。
2 5 9 10 31 48 59 69 95 154
2

:sleepy:我错了。。。
作者: 杨彬 时间: 2013-6-22 19:14

/*1. 题目打印输出一百以内的素数的累加和...*/

/*

* 思路：首先利用循环(1-100)检验每一个数是否是素数

* 如果是 累加到一个表示和的变量里面

*/

public class Test1 {

public static void main(String[] args) {

// boo这个变量值为true表示是素数

boolean boo = true;

// sum用来记录给定范围的所有素数的和的变量

int sum = 0;

// 外层循环用来控制个数

System.out.println("1~100所有的素数：");

for (int i = 2; i <= 100; i++) {

// 内层循环确定是否为素数

// 根据素数的定义：在一个大于1的自然数中，除了1和此整数自身外，不能被其他自然数整除的数为素数所以找到不是素数的数，然后输出即可

for (int j = 2; j < i; j++) {// 循环判断小于自己的数能否被整除

if (i % j == 0) { // 如果能被整除则表示不是素数

boo = false;// 更改标记

// 如果程序周到此处就证明当前这个数不是素数可以停止循环

break;

}

}

if (boo) { //判断标记的是否是素数如果是素数则求和并打印这个数

sum += i;

System.out.print(i + " ");

}

boo = true;//改回标记用于下次使用

}

System.out.println();

System.out.println("1~100的素数的和是：" + sum);

}

}

复制代码
/*2. 将该数组由小到大进行排列，数组中的素数全部赋值为零，并按阶梯状输出。*/

/*

*思路：首先采用一种排序算法将数组进行排序

* 然后对排序后的数组的每一个元素进行素数条件检测 检测到是素数 清零

* 最后阶梯打印该数组

*/

public class Test2 {

public static void main(String[] args) {

int[] arr0 = { 2, 1, 4, 66, 8, 3, 11 };

System.out.print("原数组：");

printArry(arr0);// 打印数组元素方法

System.out.println();

sort(arr0);// 对数组进行排序

System.out.print("改变前：");

printArry(arr0);

System.out.println();

primeToZero(arr0);// 遍历数组并置换为并改写成0

System.out.print("改变后：");

printArry(arr0);

System.out.println();

//阶梯状打印数组元素

tiXingPrintArry(arr0);

}

// 阶梯状打印数组元素 ---实际上在对角线上进行数组元素的打印---打印三角形

private static void tiXingPrintArry(int[] arr) {

// 外层循环控制打印的行数

// ---由于一个元素占据一行所以一共打印的行数就是数组中元素的个数

for (int i = 0; i < arr.length; i++) {

for (int j = 0; j <= i + 1; j++) {

if (i == j)// 这个就相当于判断是不是第1行第1个...或第n行第n个

System.out.print(arr[i]);

else

System.out.print(" ");

}

System.out.println();

}

}

// 打印数组

private static void printArry(int[] arr) {

for (int x : arr) {

System.out.print(x + " ");

}

}

// 对数组中的素数进行清零先遍历再判断

private static void primeToZero(int[] arr) {

for (int x = 0; x < arr.length; x++) {

if (isPrime(arr[x]))// 此方法返回布尔类型进行判断判断是否为素数

arr[x] = 0;// 元素清零

}

}

// 判断一个数是否为素数

private static boolean isPrime(int num) {

boolean boo = true;// boo这个变量值为true表示是素数

// 根据素数的定义：在一个大于1的自然数中，除了1和此整数自身外，不能被其他自然数整除的数为素数所以找到不是素数的数即可

for (int i = 2; i < num; i++) {

if (num % i == 0) { // 如果能被整除整除标记boo标记为false 表示不是素数

boo = false;

// 如果程序周到此处就证明当前这个数不是素数可以跳出循环

break;

}

// 是素数则返回true

boo = true;

}

return boo;

}

// 对数组进行选择排序

private static void sort(int[] arr) {

// 遍历数组外层控制个数

for (int x = 0; x < arr.length; x++) {

for (int y = 0; y < arr.length - 1; y++) {

// 判断大小

if (arr[y] > arr[y + 1]) {

// 交换

int temp = arr[y];

arr[y] = arr[y + 1];

arr[y + 1] = temp;

}

}

}

}

}

复制代码
/*3.倒序杨辉三角*/

import java.util.ArrayList;

public class Test3 {

public static void main(String[] args) {

int layers =4;

//Step1. 产生杨辉三角列表

ArrayList<ArrayList<Integer>> yanghuiTrList = generateYangTrList(layers);

System.out.println("产生的杨辉列表如下：");

printYanghuiList(yanghuiTrList);

//Step2.倒序打印杨辉三角

System.out.println("倒序打印杨辉三角如下：");

printInverseYanghuiArr(layers, yanghuiTrList);

}

/**

 * function: 倒序打印杨辉三角

 * @param layers ---表示杨辉三角的层数

 * @param yanghuiTrList ----杨辉三角的列表

 */

private static void printInverseYanghuiArr(int layers,

ArrayList<ArrayList<Integer>> yanghuiTrList) {

//Step1. 控制打印的行数

for(int i=1, layer =layers-1; i<=layers; i++, layer--){

//先打印空格部分 填充空白区域

for(int j=1; j<= i-1; j++){

System.out.print(" ");

}

//取出本层的杨辉数字列表

ArrayList<Integer> eachLayerList =yanghuiTrList.get(layer);

int index =0;

for(int j=1; j<=9 -2*i; j++){

if(j%2 ==0)//隔一位打印一个数字

System.out.print(" ");

else{

System.out.print(eachLayerList.get(index));

index++;

}

}

System.out.println();

}

}

//打印杨辉列表 -- 测试使用

private static void printYanghuiList(

ArrayList<ArrayList<Integer>> yanghuiTrList) {

System.out.println("**************************************");

for(int i=0; i<yanghuiTrList.size(); i++){

for(int j=0; j<yanghuiTrList.get(i).size(); j++){

System.out.print(yanghuiTrList.get(i).get(j)+ " ");

}

System.out.println();

}

System.out.println("**************************************");

}

//产生杨辉三角列表 方法的参数表示产生几层杨辉三角

private static ArrayList<ArrayList<Integer>> generateYangTrList(int layers) {

ArrayList<ArrayList<Integer>> trList =new ArrayList<ArrayList<Integer>>();

ArrayList<Integer> eachLayerList =null;

//顺序产生各层杨辉列表

for(int i=0; i<layers; i++){

eachLayerList =new ArrayList<Integer>();

//第0层杨辉列表： 1

if(i==0){

eachLayerList.add(1);

trList.add(eachLayerList);

continue;

}

//第1层杨辉列表： 1 1

if(i==1){

eachLayerList.add(1);

eachLayerList.add(1);

trList.add(eachLayerList);

continue;

}

//第0, 1层以外的杨辉列表

//--每层杨辉列表的首数字都为1

eachLayerList.add(1);

//取出最后一次的杨辉列表 一共下面累加获得本层的杨辉列表的元素

ArrayList<Integer> lastList =trList.get(trList.size()-1);

//累加上一层的相邻两个元素进行求和

for(int startIndex =0; startIndex <lastList.size() -1; startIndex++){

int adjacentSum =lastList.get(startIndex)+ lastList.get(startIndex+1);

eachLayerList.add(adjacentSum);

}

//--每层杨辉列表的尾数字都为1

eachLayerList.add(1);

trList.add(eachLayerList);

}

return trList;

}

}

复制代码
作者: majunm 时间: 2013-6-22 19:27

package ma.jun;

//第2题答案[code]package ma.jun;

//第1题答案

public class SumDemo {

/**

 * 1. 打印输出一百以内的素数的累加和...

 *

 * ===========================================================

 * 运行结果

 * ===========================================================

 * 100以内素数有：2

100以内素数有：3

100以内素数有：5

100以内素数有：7

100以内素数有：11

100以内素数有：13

100以内素数有：17

100以内素数有：19

100以内素数有：23

100以内素数有：29

100以内素数有：31

100以内素数有：37

100以内素数有：41

100以内素数有：43

100以内素数有：47

100以内素数有：53

100以内素数有：59

100以内素数有：61

100以内素数有：67

100以内素数有：71

100以内素数有：73

100以内素数有：79

100以内素数有：83

100以内素数有：89

100以内素数有：97

100以内素数和为：1060

 */

public static void main(String[] args) {

primeSum();

}

//判断 100之内的素数

public static void primeSum() {

int sum = 0;

for (int i = 2; i <= 100; i++) {

int j;

for (j = 2; j <= i-1; j++) {

// 拿要循环的数i 从2开始除以 i-1之间的所有数能整除代表不是素数

if (i % j == 0){

break;

}

}

if (j >= i) {

System.out.println("100以内素数有："+i);

sum+=i;

}

}

System.out.println("100以内素数和为：" + sum);

}

}

复制代码
第3题研究中....
public class PrintPrimeDemo {

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

 运行结果

 ===============================================================

 排序前：
arr[2,5,9,10,48,95,154,31,59,69]
排序后：
arr[2,5,9,10,31,48,59,69,95,154]
替换素数后：
arr[0,0,9,10,0,48,0,69,95,154]
按规则输出后：
0
 0
 9
 10
 0
 48
 0
 69
 95
 154

 */
public static void main(String[] args) {
int[] arr={2,5,9,10,48,95,154,31,59,69};
System.out.println("排序前：");
printArr(arr);

sortArr(arr);//进行数组排序

System.out.println("排序后：");
printArr(arr);//排序后

replacePrime(arr);//替换素数

System.out.println("替换素数后：");
printArr(arr);

System.out.println("按规则输出后：");
ruleOutArr(arr);//按规则输出
}
//替换素数 4
public static void replacePrime(int arr[]){
for(int x=0;x<arr.length;x++){
int j;
for(j=2;j<arr[x];j++){
if(arr[x]%j==0){
break;
}
}
if(j>=arr[x]){
// 把0赋值给 x；即素数
arr[x]=0;
}
}
}
// 排序数组
public static void sortArr(int arr[]){
for(int x=0;x<arr.length;x++){
for(int y=x+1;y<arr.length;y++){
if(arr[x]>arr[y]){
// 数值替换
int temp=arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
}
}
}
// 打印数组
public static void printArr(int arr[]){
System.out.print("arr[");
for(int x=0;x<arr.length;x++){
if(arr[x]==arr[arr.length-1])
System.out.print(arr[x]+"]");
else
System.out.print(arr[x]+",");
}
System.out.println();
}
// 规则输出数组
public static void ruleOutArr(int arr[]){

for(int x=0;x<arr.length;x++){

for(int y=0;y<x;y++){
System.out.print(" ");//打印空格
}
System.out.println(arr[x]);
}
}
}[/code]
作者: liye20110 时间: 2013-6-22 20:40

/*第一题代码*/

class PrimeNum

{

public static void main(String[] args)

{

int sum =2;//2是最小的素数，可省略判断

int flag=0;//是否为素数的标志位

for(int num=3;num<=100;num++)//从3开始判断是否为素数

{

for(int j=2;j<num;j++)//遍历num是否可以整除2到num-1之间的数

{

if(num%j!=0)

{

flag=1;//素数

}

else

{

flag=0;//非素数

break;//非素数跳出内循环j

}

}

if(flag==1)//如果是素数

{

sum+=num;//素数累加

//System.out.println(num);//打印素数

}

}

System.out.println("sum="+sum);//打印素数累加和

}

} 
复制代码

/*第二题代码*/

class SortNum

{

public static void main(String[] args)

{

int[] arr = {2,5,9,10,48,95,154,31,59,69};

System.out.print("数组打印前：");

for(int i=0;i<arr.length;i++)

{

System.out.print(arr[i]+" ");//打印原数组

}

System.out.println();//换行

int temp;//中间变量

int flag=0;//素数标志位

System.out.print("数组打印后：");

for(int i=0;i<arr.length;i++)

{

for(int j=i+1;j<arr.length;j++)//将数组元素按从小到大顺序排序

{

if(arr[i]>arr[j])

{

temp=arr[i];

arr[i]=arr[j];

arr[j]=temp;

}

}

if(arr[i]==2)

{

flag=1;//素数

}

for(int j=2;j<arr[i];j++)//遍历num是否可以整除2到num-1之间的数

{

if(arr[i]%j!=0)

{

flag=1;//素数

}

else

{

flag=0;//非素数

break;//非素数跳出内循环j

}

}

if(flag==1)//如果是素数

{

arr[i]=0;//将素数赋为0

//System.out.println(num);//打印素数

}

System.out.print(arr[i]+" ");//打印改变后的数组

}

for(int i=0;i<arr.length;i++)//将数组打印成阶梯状

{

for(int j=0;j<i;j++)

{

System.out.print(" ");

}

System.out.println(arr[i]);

}

}

}
复制代码

primenum.jpg (10.33 KB, 下载次数: 0)

下载附件

2013-6-22 20:35 上传

1到100内的素数

SortNum.jpg (18.45 KB, 下载次数: 0)

下载附件

2013-6-22 20:35 上传

排序打印

作者: xuluheng718 时间: 2013-6-22 20:50
第一题代码：

)T@XU}UOC8@HEHAOVXT[9OT.jpg (116.53 KB, 下载次数: 0)

下载附件

2013-6-22 20:49 上传

结果：

K$X(57~(Y_HMRS6(1}N1$BH.jpg (12.39 KB, 下载次数: 0)

下载附件

2013-6-22 20:50 上传

作者: xuluheng718 时间: 2013-6-22 20:54
晕，贴成图片了，
第一题代码附上：
public class Ques1 { /**

 * 分析和思路：

 * 1，什么事素数：在大于1的自然数中，只能被1和自身整除的数叫素数

 * 2，如何求出100以内的素数有哪些：

 * ①因为涉及到两个数值的循环操作所以用嵌套for循环实现

 * ②外循环求出2-100的自然数，内循环求出不能被除了1和自身整除的素数

 * ③内循环的循环数值设为和外循环数值相等，内循环数值每循环一次自减1，

 * 因为任何自然数都能被1整除所以内循环的除数可以设为>=2的自然数

 * ④假如要求的数值能被小于它自身的数值整除，那么直接跳出内循环，进行下一次外循环

 * ⑤假如内循环数值到了最小值2还没跳出内循环，那么就得出此数值属于素数，然后进行累加求和

 *

 */

public static void main(String[] args) {



 int sum = 0;//记录和

 for(int i = 2; i<=100; i++)

 {

for(int j = i;j>=2;j--)

{

if((i%j==0)&&(i!=j))//要求的数能被整除，并且除数不等于自身则跳出次循环

break;

if(j==2)//到达最小值还没满足以上条件，得出素数

{

 sum = sum+i;//进行素数和的累加

}

}

 }

 System.out.println("100以内的素数和为："+sum); }}
复制代码
运行结果：

K$X(57~(Y_HMRS6(1}N1$BH.jpg (12.39 KB, 下载次数: 0)

下载附件

2013-6-22 20:53 上传

作者: xuluheng718 时间: 2013-6-22 20:56
第二题代码附上：
public class Ques2 { /**

 * 思路：

 * 1，先进行冒泡排序

 * 2，把排序后的数组进行素数判断，把素数和0进行替换

 * 3，阶梯打印数组：每打印一个数组中的元素换行一次，每换行一次多打印一个空格

 */

public static void main(String[] args) {

 // TODO Auto-generated method stub

 int[] arry ={2,5,9,10,48,95,154,31,59,69};

 sort(arry);//进行冒泡排序

 System.out.print("数组改变前：");

 print(arry);//打印排序后的数组

 System.out.println();

 System.out.print("数组改变后：");

 replacePrime(arry);//把数组的中的素数替换成0

 print(arry);//打印替换后的数组

 System.out.println();

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

 augmentPrint(arry);//阶梯打印数组

}

/*

 * 打印数组

 */

public static void print(int[] arry)

{

 for(int i = 0;i<arry.length;i++)

 {

System.out.print(arry[i]);

System.out.print("\t");

 }

}

/*

 * 进行冒泡排序，并把数组中的素数替换成0

 */

public static void sort(int[] arry)

{

 for(int i =arry.length-1;i>0;i--)

 {

for(int j =0;j<i;j++)

{

if(arry[j]>arry[j+1])

{

 int temp = arry[j];

 arry[j] = arry[j+1];

 arry[j+1] = temp;

}

}

 }

}

/*

 * 阶梯状输出数组

 */

public static void augmentPrint(int[] arry)

{

 for(int i = 0; i<arry.length;i++)

 {

for(int j = i;j>0;j--)

{

System.out.print(" ");

}

System.out.println(arry[i]);

 }

}

/*

 * 判断值是否为素数，假如是则替换成0，否则不改变

 */

public static void replacePrime(int[] arry)

{

 for(int i = 0;i<arry.length;i++)

 {

for(int j = arry[i]-1;j>=2;j--)

{

if(arry[i]%j==0)

{

 arry[i]=0;

 break;

}

}

 }

}}

 
复制代码
运行结果：

3ILGTC0XPD733CI2UV6]L.jpg (22.47 KB, 下载次数: 0)

下载附件

2013-6-22 20:56 上传

作者: xuluheng718 时间: 2013-6-22 21:14

P}W7I{93N8WD(~87W3@GR.jpg (17.66 KB, 下载次数: 0)

下载附件

2013-6-22 21:14 上传

第三题代码附上：
import java.util.Scanner;

public class Ques3 {

/**

 * 思路分析：

 * 1，如何实现杨辉三角

 * <1>分析图形：

 * ①每行的元素个数等于行数。

 * ②每行中元素的头和尾都是1。

 * ③除了第一第二行和每行的头尾元素外，第二个元素的值是其上一行的相邻元素的和，以此类推。

 * <2>确定数据结构：

 * ①通过分析，这里可以使用二位数组来实现，第一维度用来记录行数与其相关的元素个数。

 * ②建立一个不规则的二位数组，第一维度的长度（打印的行数）通过键盘录入。

 * ③因为第二维度的元素个数取决于第一维度，所以可以通过循环给第一维度相对应的元素个数赋值。

 * ④当二维数组的第一和第二维的大小都确定了就可以给每个元素进行赋值了。

 * <3>如何存入数据：

 * ①用嵌套循环可以实现二位数组的数据存储

 * ②用此二位数组的第一维度确定外循环的次数

 * ③根据第一维度的长度确定第二维度的长度

 * ④根据分析图形得到的数据之间的关系，当第二维度的下标为头尾时候都是1，可以通过判断第二维度的

 * 下标来实现赋值。

 * int[][] arry = new int[i][j];

 * if(j==0||j==arry.length-1)

 * arry[i][j]=1；

 * ⑤第二维度的元素除了头尾外都是上一维的元素相邻的两个值的和，可以定义一个数组下标用于记录当前

 * 位置，每存储一个数据下标自增1，假如当前的第一维度相对应的第二维度数据存储满了，把记录的下标重置。

 * arry[i][j]=arry[i-1][index]+arry[i-1][index+1];

 * index++;

 *

 * 2，如何实现杨辉三角的倒立打印：

 * <1>分析图形：

 * ①这是由数组的第一维度倒着打印实现

 * ②每打印一行多一个空格，而每打印同一行的元素用2个空格隔开

 * <2>图形实现：

 * ①用3个for循环实现，外循环控制行数，可以用数组的第一维度长度实现。

 * 因为数组的下标从0开始，所以外循环的条件for(int i = arry.length-1; i>=0; i--)

 * ②内嵌2个for循环：

 * 第一个嵌套循环用于控制横向打印开始的空格数，

 * 空格数 = arry.length-元素的个数-1

 * 第二个嵌套循环用于控制横向打印的元素。

 * 因为数组下标的关系，这里的条件还是要用第二维数组的长度-1

 */

public static void main(String[] args) {

// TODO Auto-generated method stub

Scanner in=new Scanner(System.in);

System.out.print("请输入行数：");

int num=in.nextInt();//读取键盘录入

//初始化行数

int[][] arry = new int[num][];

//初始化第二维数组的长度

for(int i =0;i<arry.length;i++)

{

arry[i] = new int[i+1];//因为第一维的下标关系，这里要+1

}

int index;//定义下标指针

//给二位数组赋值

for(int i = 0; i<arry.length;i++)

{

index =0;//给不同维度的数组赋值都要初始化指针

//给arry[i]维度下的元素赋值

for(int j = 0 ;j<arry[i].length;j++)

{

//假如是第二维数组的头尾，那么就把值赋为1

if((j==0)||(j==arry[i].length-1))

arry[i][j]=1;

else

{

//根据杨辉三角的规律，除了头和尾，每个不同维度的值都是上以维度的相邻两个值的和

arry[i][j]=arry[i-1][index]+arry[i-1][index+1];

index++;

}

}

}

//倒立打印杨辉三角

for(int i = arry.length-1; i>=0; i--)

{

//打印横向开始时的空格数

for(int j = arry.length-i-1;j>0;j--)

System.out.print("\t");

//打印每一行的元素(在每一行的元素没打印完前，不换行)

for(int k =0;k<=arry[i].length-1;k++)

{

System.out.print(arry[i][k]);

System.out.print("\t\t");

}

//打印完一行，换行

System.out.println();

}

}

}
复制代码
运行结果：

作者: xuluheng718 时间: 2013-6-22 21:19

xuluheng718 发表于 2013-6-22 21:14
第三题代码附上：运行结果：

第三题的运行图片没上传成功，补上：

P}W7I{93N8WD(~87W3@GR.jpg (17.66 KB, 下载次数: 0)

下载附件

2013-6-22 21:19 上传

作者: lou413 时间: 2013-6-22 21:22
file:///E:/12.jpg
运行结果
file:///C:/Users/Administrator.PC--20130621GXC/AppData/Roaming/Tencent/Users/1009761314/QQ/WinTemp/RichOle/%7BC]G668OEEK6K%60OHST~41YS.jpg

作者: .netNo1 时间: 2013-6-22 21:34

static void Main(string[] args)

{

int[] S = { 2, 5, 9, 10, 48, 95, 154, 31, 59, 69 };

int min = 0; //中间变量

for (int i = 0; i <= S.Length - 1; i++) //比较S.Length-1次排序

{

for (int j = 0; j < S.Length - 1; j++)

{

if (S[j] > S[j + 1])

{

min = S[j]; //交换变量，由小到大排列

S[j] = S[j + 1];

S[j + 1] = min;

}

}

}

 int m;

 for (int a = 0; a < S.Length; a++)

 {

 for (m = 2; m <= S[a]; m++)

 {

 if (S[a] % m == 0 && S[a] != 2)

 break;

 }

 if (S[a] == m) //为素数，则赋值0

 S[a] = 0;

 Console.Write("{0}", S[a]);

 Console.Write("\n");

 for (int b = 0; b <= a; b++) //输出空格

 {

 Console.Write("\0");

 }

 }

Console.ReadKey();

}//结果为：2 0 9 10 0 48 0 69 95 154
复制代码

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2