====>送技术分啦! 题已更改，1题最多3分，2.3题给5分...

蔡汉康 · 蔡汉康

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;
}
}

复制代码

蔡汉康 · 蔡汉康

不好意思啊，第二题因为疏忽，判断条件写反了，这是修正好的代码和结果！！！

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;
}
}

复制代码

xiaohu1218 · xiaohu1218

我今天上午刚看到的，三道题都写了

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;
}
}

复制代码

星仔子 · 星仔子

/*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 · xiaohu1218

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 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 · .netNo1

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 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 · .netNo1

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 15:42
好吧，那我不上传相片了。直接给你复制第二题的结果。
2 5 9 10 31 48 59 69 95 154
2

:sleepy:我错了。。。

杨彬 · 杨彬

/*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 · majunm

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 · liye20110

/*第一题代码*/
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]);
}
}
}

复制代码

xuluheng718 · xuluheng718

第一题代码：

结果：

xuluheng718 · xuluheng718

晕，贴成图片了，
第一题代码附上：

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); }}

复制代码

运行结果：

xuluheng718 · xuluheng718

第二题代码附上：

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;
}
}
}
}}

复制代码

运行结果：

xuluheng718 · xuluheng718

第三题代码附上：

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 · xuluheng718

xuluheng718 发表于 2013-6-22 21:14
第三题代码附上：运行结果：

第三题的运行图片没上传成功，补上：

lou413 · lou413

file:///E:/12.jpg
运行结果
file:///C:/Users/Administrator.PC--20130621GXC/AppData/Roaming/Tencent/Users/1009761314/QQ/WinTemp/RichOle/%7BC]G668OEEK6K%60OHST~41YS.jpg

.netNo1 · .netNo1

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

复制代码

帐号		自动登录	找回密码
密码			加入黑马

====>送技术分啦! 题已更改，1题最多3分，2.3题给5分...

评分

点评

点评

评分

评分

点评

点评

评分

评分

评分

评分

评分