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

杨兴庭 · 杨兴庭

[/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 · pys200603027

题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结果：

题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结果：

题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结果：

万琪 · 万琪

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

杨增坤 · 杨增坤

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]);
}
}
}
结果：

vicoooo · vicoooo

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

复制代码

结果为：

tpsu88 · tpsu88

这次结果对了吧！我数学常识有待提高啊！呵呵，居然把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);
}
}

复制代码

yooc · yooc

/*
********************
项目名:黑马版主题解
作者：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

输入7

︶ㄣ紫藤ㄜ︵ · ︶ㄣ紫藤ㄜ︵

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

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

关关雎鸠 · 关关雎鸠

唉，没检查代码，出糗了。版主我修改了。。

<P>为了节约空间，值贴出for循环的那一部分。 </P>

复制代码

太粗心了，呵呵~

关关雎鸠 · 关关雎鸠

本帖子需要验证码才可查看，请输入验证码：heima 即可正常访问

︶ㄣ紫藤ㄜ︵ · ︶ㄣ紫藤ㄜ︵

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

for(j=2;j<=n;j++){
if(i%j==0){
   break;
}
}
//将是素数的数进行累加
if(j>n){
num+=i;

}
  }System.out.println(num);
}

}

请您验收，您辛苦了。

萧萧北 · 萧萧北

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

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:55
1. 打印输出一百以内的素数的累加和...

运算结果为：1060

版主不好意思哈，忘记贴上我的结果了

刘晓 · 刘晓

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

复制代码

陈新 · 陈新

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);
}
}
//先做一道。。。后面的在想想。。

张歆明 · 张歆明

第一题：

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

复制代码

张歆明 · 张歆明

版主不好意思刚才寻思发完编辑一下但是发现不能编辑只能重新回复
第一题：

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

复制代码

运行结果：

萧萧北 · 萧萧北

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:23
2.将该数组由小到大进行排列，数组中的素数全部赋值为零，并按阶梯状输出。
数组： 2 5 9 10 ...

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

运算结果为：

蔡汉康 · 蔡汉康

{:soso_e100:}来看看

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

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

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

点评

评分

评分

评分

黑马骑士勋章