===答题送技术分(最高9分) 第三周(已结束)===

Just_Only

本帖最后由神之梦于 2013-7-13 12:17 编辑

说明：
1、回复看题，第一次回复后24小时内答题有效。（如果接下来24小时内没有足够时间答题，可先不回复。）
2、共有三个题。能做出多少就做多少，如果全部答对，可获得5~9技术分。
3、此帖结束时间：下周答题帖发布之日（7月13日或者14日）。

题目：
1、键盘录入一个正整数，将其分解质因数。如：输入30，打印出30=2*3*5。

2、求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。（其中n个是求出的各个素数，还有一个是随机添加其中的一个素数）
   这样数组中就有相同的两个素数，写一个搜索算法，找出数组中相同的那个素数。（随机添加的素数，可手动指定，也可利用随机方法产生）
    (注：存入数组后，数组中的所有元素理论上是无序的，相同的那个素数不一定就等于a[n]，而是被存入了数组中的某个角标上)

3、在一个文件夹内有文件夹和文件，文件名的格式为：数字+名称.java。
   要求：把所有的.java文件复制一份，变为文件名格式为：数字+名称+数字.java。
（其中数字是相对应的，名称由字母组成。如：01Demo.java——>01Demo01.java)

加分说明：
  1、第一题1~2分，第二题2~4分，第3题2~3分。
  2、题目须自己做出，直接回复。将完整代码放在代码块中，不接收附件。
  3、必须有适当注释和思路。没有注释无分。
  4、对题目或加分有不明或异议的，可联系楼主。

第二题特别说明：
对于第二题的通俗理解：
有100个篮球，分别标号为1到100，现在你找出了其中的标号是素数的篮球（假设有n个），并把它们分别装入了n个篮子（相当于数组）里。这时有一个淘气的小朋友，从别的地方拿了1个篮球，这个篮球的标号刚好也是一个素数。然后他也拿了一个篮子装着，并随意的放在了你的某两个篮子之间（这时数组的长度就是n+1）。现在你要做的事情就是找出小孩子拿来的那个篮球。
用程序写就是3个关键点：1、找出素数，并存入数组；2、产生你找出素数中随机的一个，也存入数组，位置不确定；3、找出数组中相同的那个素数。(程序效率最优者，分高)

张歆明 · 张歆明

好的看看谢谢楼主

mulua · mulua

好东西

mulua · mulua

package huodong;
/**第一题
*思路
*要质数分解需要先找出从2到n之间的质数
*然后找出能后整除n的输出
*如果是1的话就不输出*
*
*/
import java.util.Scanner;
public class ZhiShu {
//判断是否是质数
static boolean is_odd(int n)
{
if(n==2||n==3)
return true;
if(n%2==0)
return false;
int i;
for(i=3;i<=n/2;i+=2)
if(n%i==0)
return false;
return true;
}
public static void main(String[] args)
{
//读取一个数
Scanner in=new Scanner(System.in);
System.out.println("输入数值");
int n=in.nextInt();
int i;
System.out.print(n+"=");
//找出从2到n之间的质数去除n
for(i=2;i<=n;i++)
{
if(!is_odd(i))
continue;
//可以整除就输出
if(n%i==0)
{
while(true)
{
System.out.print(i);
n/=i;
if(n!=1) System.out.print("*");
if(n%i!=0)
break;
}
}
}
System.out.println();
}
}

复制代码

ㄗs：/|丶hearts · ㄗs：/|丶hearts

0.0

杨晓燕 · 杨晓燕

顶个~凑热闹

ㄗs：/|丶hearts · ㄗs：/|丶hearts

package com.java.test;
import java.util.*;
public class PrimeNum {
/**
* 将一个正整数分解质因数，例如:输入参数30，打印出30=2*3*5；
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("请输入一个正整数：");
//从控制台读取输入的数字
Scanner s = new Scanner(System.in);
int i = s.nextInt();
primeNum(i);
}
//将一个正整数分解质因数并打印
public static void primeNum(int n)
{
int j = 2;
System.out.print(n + "=" );
while(j<= n)
{
//如果该因数等于n,则说明分解质因数的过程已经结束, 打印该因数并退出while循环
if(j == n)
{
System.out.println(j);
break;
}
//如果n%j==0那么j则是n的因子又因为j<n 所以j是n的质因数
if(n % j == 0 )
{
//n能被j整除，则应打印出j的值，并用n除以j的商,作为新的正整数n,重复执行
System.out.print(j + "*");
n = n / j;
}else
{
//n%j != 0 则j++ 继续循环找n的因数
j++;
}
}
}
}

复制代码

mulua · mulua

package huodong;
/**第二题
* 思路
* 先找出1-100中所有的素数
* 将这些素数存到数组中
* 在添加一个素数
* 遍历数组取出相同的元素
*/
public class HuoDong2 {
public static void main(String[] args) {
//定义变量统计素数的个数
int count = 0;
//打印出1-100中所有的素数
System.out.println("1-100中的素数有：");
for (int i = 0; i < 100; i++)
{
if(is_odd(i))
{
System.out.print(i+" ");
count++;
}
}
System.out.println();
System.out.println("一共有："+count+"个");
int n = count;
int x = 0;
int[] array = new int[n+1];
//将求出的素数存入a[n+1]的数组中
for (int i = 0; i < 100; i++)
{
if(is_odd(i))
{
array[x] = i;
x++;
}
}
//将自定义的素数5存入a[n+1]的数组中
array[n] = 5;
//查找出相同的素数
fetch(array);
}
//查找出相同的素数
public static void fetch(int[] array)
{
int same = 0;
for( int arr : array)
{
System.out.print(arr+" ");
}
System.out.println();
//遍历数组取出相同的元素
for (int i = 0; i < array.length; i++)
{
for (int j = i+1; j < array.length; j++)
{
if (array[i]==array[j])
{
//将相同的素数存到same中
same = array[i];
}
}
}
System.out.println();
System.out.println("相同的素数为："+same);
}
//判断是否是素数
static boolean is_odd(int n)
{
if(n==2||n==3)
return true;
if(n%2==0)
return false;
int i;
for(i=3;i<=n/2;i+=2)
if(n%i==0)
return false;
return true;
}
}

复制代码

姚飞 · 姚飞

啦啦啦啦啦啦啦，德玛西亚、。

lanbuohan · lanbuohan

看题了~~~~~~~~~~~

王洪波 · 王洪波

看看帧

ㄗs：/|丶hearts · ㄗs：/|丶hearts

package com.java.test;
import java.util.Arrays;
public class PrimeArray {
/**
* @param args
* 2.求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。
* （其中n个是求出的各个素数，还有一个是随机添加其中的一个素数）
* 这样数组中就有相同的两个素数，写一个搜索算法，找出数组中相同的那个素数。
* （随机添加的素数，可手动指定，也可利用随机方法产生）
*
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int n = 0;
//先将得到的素数放入一个大小为100 的数组中
int[] a1 = new int[100];
for (int i = 2; i <= 100; i++) {
if (isPrime(i)) {
a1[n] = i;
n++;
}
}
//将数组a1中的素数放入大小为n+1 的数组a中
int[] a = new int[n+1];
a = Arrays.copyOf(a1, n+1);
a[n] = 73;//手动添加一个素数
for (int i : a) {
System.out.print(i+" ");
}
System.out.println();
System.out.println("数组中相同的素数的角标为："+halfSeach(a, 73));
}
//二分查找法。必须有前提：数组中的元素要有序。
public static int halfSeach(int[] arr,int key){
int min,max,mid;
min = 0;
max = arr.length-1;
mid = (max + min)/2;
while(arr[mid]!=key){
if(key > arr[mid]){
min = mid + 1;
}
else if(key < arr[mid])
max = mid - 1;
mid = (max + min)/2;
}
return mid;
}
//判断一个数是不是素数
public static Boolean isPrime(int i ) {
for(int j = 2; j <= i/2; j++){
if(i % j == 0){
return false;
}
}
return true;
}
}

复制代码

lanbuohan · lanbuohan

package cn.itcast.exam;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
public class Test1 {
/**1、键盘录入一个正整数，将其分解质因数。如：输入30，打印出30=2*3*5。
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
//读取数据
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
String len = null;
//读取数据
while((len=bufr.readLine())!=null)
{
//转化为整数型
int num = Integer.parseInt(len);
System.out.print(num+"=");
//这个变量时保证在循环输出时，保证第一没有“*”
int b = 0;
//进行因数计算因数都是在这个期间的数字
for(int i=2;i<=num;i++)
{
while(num%i==0)
{
num/=i;
//除第一次不带“*”，其他数字都带“*”
if(0 == b)
{
System.out.print(+i);
}
else
System.out.print("*"+i);
b++;
}
}
}
}
}

复制代码

蚂蚁搬家 · 蚂蚁搬家

看一下，上次就错过了

杨晓燕 · 杨晓燕

/*1、键盘录入一个正整数，将其分解质因数。如：输入30，打印出30=2*3*5
思路：分解质因数的方法是让该数x模与i，i从i=2开始，结果为0就输出i，
得到第一个质因数，x=x/i;如果结果不为0，那么i自增，再进行模与运算。
最后x不能为分解，输出x*/
import java.util.Scanner;
class Test3_1
{
public static void main(String[] args)
{
Scanner in=new Scanner(System.in);//接收键盘录入的数
int x=in.nextInt();
for(int i=2;i<=x/2;)
{
if(x%i==0)//当x%i为0，说明i是x的质因数
{
System.out.print(i+"*");
x=x/i;
}
else
i++;
}
System.out.println(x);
}
}

复制代码

嗨~第三题，还没学到，学了也忘了，第二题还得想想

孙四有 · 孙四有

我要做做

刘张朋 · 刘张朋

学习一下

杨晓燕 · 杨晓燕

杨晓燕发表于 2013-7-7 19:49
嗨~第三题，还没学到，学了也忘了，第二题还得想想

木有过目不忘的本领啊，虽然看了一遍，做起题来很陌生。。苗，你就说说第一题我哪里丢了一分把

张歆明 · 张歆明

版主您好：第一题代码

package test2;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
/*
* 需求：1、键盘录入一个正整数，将其分解质因数。如：输入30，打印出30=2*3*5。
* */
/*
* 思路：
* (1). 键盘读取一个正整数，之后产生[2，该正整数]之间所有的质数存放到一个质数列表中
* (2). 循环判断这些质数有哪些可以整除刚才录入的正整数
* */
public class Test1 {
public static void main(String[] args) throws Exception{
//1.键盘录入数字
BufferedReader bufr =new BufferedReader(new InputStreamReader(System.in));
System.out.println("请您输入一个正整数：");
String numLine =bufr.readLine();
//检验用户输入的数字是不是数字
int number =0;
try{
number =Integer.parseInt(numLine);
}catch(NumberFormatException nfe){
System.out.println("对不起，您输入的内容含有非数字字符");
return;
}
if(number <=0){
System.out.println("您输入的数字不是正整数，请您重新输入...");
return;
}
//现在的数字一定是正整数
//2.产生[2, 该正整数]范围的质数列表
//获取该正整数的不重复的质因数列表 e.g.12质因数有[2, 3]
List<Integer> primes =generatePrimeFacotrs(number);
//3.在产生的质因数的列表中，计算出键盘输入的正整数含有每个质因数的个数
List<Integer> primesDetails =getPrimeDetails(primes, number);
//4.打印输出该正整数的列表
printPrimeFactorsStr(primes, primesDetails, number);
}
//打印输出改该正整数的列表
private static void printPrimeFactorsStr(List<Integer> primes, List<Integer> primesDetails, int number) {
StringBuilder sBuilder =new StringBuilder();
sBuilder.append(number+"=");
int primeFactor =0;
int pCount =0;
for(int i =0; i<primes.size(); i++){
primeFactor =primes.get(i);
pCount =primesDetails.get(i);
for(int j =0; j<pCount -1; j++)
sBuilder.append(primeFactor+"*");
if(i <primesDetails.size()-1)
sBuilder.append(primeFactor+"*");
else
sBuilder.append(primeFactor);
}
System.out.println("质因数分解结果:"+ sBuilder.toString());
}
//获取每个质因数在键盘输入的数中所含的具体个数
private static List<Integer> getPrimeDetails(List<Integer> primeFactors, int number) {
List<Integer> pDetails =new ArrayList<Integer>();
for(int primeIndex =0; primeIndex <primeFactors.size(); primeIndex++){
int pCount =0;
int primeFactor =primeFactors.get(primeIndex);
//一直用同一个质因数去整数该整数一旦除到余数不为0的时候表示这个整数里面不再含有这个质因数的成分
while(number%primeFactor ==0){
//整除一次，就把对应的质因数的次数变量pCount自加
pCount++;
//更新该整数
number =number/primeFactor;
}
pDetails.add(pCount);
// System.out.println(primeFactors.get(primeIndex) +"...."+ pCount);
}
return pDetails;
}
//产生[2, 该正整数]范围内的质数列表
private static List<Integer> generatePrimeFacotrs(int number) {
List<Integer> primes =new ArrayList<Integer>();
for(int i=2; i<=number; i++){
//如果是质数并且能被传入的整数number整除那么这个数i一定是number的一个质因数
if(isPrime(i)&&(number%i ==0))
primes.add(i);
}
// System.out.println(primes);
return primes;
}
//判断一个数是否为素数
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;
}
}

复制代码

运行结果如图：

张歆明 · 张歆明

第二题代码：

package test2;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
/*
2、求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。
（其中n个是求出的各个素数，还有一个是随机添加其中的一个素数）
这样数组中就有相同的两个素数，写一个搜索算法，找出数组中相同的那个素数。
（随机添加的素数，可手动指定，也可利用随机方法产生）
*/
/*
* 思路：
* (1). 循环判断1-100之间哪些数是素数
* (2). 按从大到小的顺序将这些素数存入指定的数组中并随机添加原有素数中的某一个放在数组的最后一个位置上
* (3). 上面的数组除最后一个要查找的元素以外，前面所有的元素顺从大到小排过顺序的。采用折半查找即可
* */
public class Test2 {
public static void main(String[] args) {
int upBound =100;
//1.获取1-100的所有的质数
List<Integer> primes =getPrimes(upBound);
System.out.println("1-100以内的素数是："+ primes);
//2.将列表转换成数组并随机多产生一个已产生的素数存放到转化到的数组的最后一位
int[] primesArr =toArray(primes);
System.out.println("产生的数组是(假如随机的素数之后)："+ Arrays.toString(primesArr));
//3.折半搜索
int repeatedKey =binarySearch(primesArr, primesArr[primesArr.length-1]);
int repeatedPrime =primesArr[repeatedKey];
System.out.println("重复的数字是:"+ repeatedPrime);
}
//折半搜索 ----以中间值和查找的内容作比较来作为是否继续循环的条件
private static int binarySearch(int[] arr, int key){
int min =0, max =arr.length -1, mid =(min+ max)/2;
while(key!= arr[mid]){
if(key <arr[mid]){
max =mid -1;
}else if(key >arr[mid]){
min =mid +1;
}
if(min >max)
return -1;
mid =(min+ max)/2;
}
return mid;
}
//将列表转换成数组并随机多产生一个已产生的素数存放到转化到的数组的最后一位
private static int[] toArray(List<Integer> primes) {
int[] primeArr =new int[primes.size() +1]; //题目要求多一个元素
for(int x=0; x <primes.size(); x++){
primeArr[x] =primes.get(x);
}
//随机产生一个素数
int randomPrime =primeArr[new Random().nextInt(primes.size())];
// System.out.println("random prime is: "+ randomPrime);
primeArr[primeArr.length -1] =randomPrime;
return primeArr;
}
private static List<Integer> getPrimes(int upBound) {
List<Integer> primes =new ArrayList<Integer>();
for(int i=2; i<=100; i++){
if(isPrime(i))
primes.add(i);
}
return primes;
}
//判断一个数是否为素数
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;
}
}

复制代码

运行结果如图。

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

===答题送技术分(最高9分) 第三周(已结束)===

评分

182 个回复

点评

评分

评分

点评

评分

点评

评分

点评

评分

点评

评分

评分

黑马骑士勋章