黑马程序员技术交流社区

标题: ===答题送技术分(最高9分) 第三周(已结束)=== [打印本页]

作者: 神之梦 时间: 2013-7-7 15:02
标题: ===答题送技术分(最高9分) 第三周(已结束)===
本帖最后由神之梦于 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、找出数组中相同的那个素数。(程序效率最优者，分高)

作者: 张歆明 时间: 2013-7-7 15:13
好的看看谢谢楼主

作者: mulua 时间: 2013-7-7 15:30
好东西

作者: mulua 时间: 2013-7-7 16:09

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 时间: 2013-7-7 16:23
0.0

作者: 杨晓燕 时间: 2013-7-7 16:35
顶个~凑热闹

作者: ㄗs：/|丶hearts 时间: 2013-7-7 16:38

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

复制代码

QQ图片20130707163847.jpg (4.23 KB, 下载次数: 0)

作者: mulua 时间: 2013-7-7 16:51

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

复制代码

作者: 姚飞 时间: 2013-7-7 16:52
啦啦啦啦啦啦啦，德玛西亚、。

作者: lanbuohan 时间: 2013-7-7 16:53
看题了~~~~~~~~~~~

作者: 王洪波 时间: 2013-7-7 17:33
看看帧

作者: ㄗs：/|丶hearts 时间: 2013-7-7 17:34

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

复制代码

QQ图片20130707173405.jpg (8.82 KB, 下载次数: 0)

作者: lanbuohan 时间: 2013-7-7 19:09

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

复制代码

作者: 蚂蚁搬家 时间: 2013-7-7 19:14
看一下，上次就错过了

作者: 杨晓燕 时间: 2013-7-7 19:49

/*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 20:28
我要做做

作者: 刘张朋 时间: 2013-7-7 20:30
学习一下

作者: 杨晓燕 时间: 2013-7-7 20:36

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

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

作者: 张歆明 时间: 2013-7-7 20:39
版主您好：第一题代码

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

复制代码

运行结果如图：

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

第一题结果

作者: 张歆明 时间: 2013-7-7 20:40
第二题代码：

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

复制代码

运行结果如图。

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

第二题运行结果

作者: 夏一站 时间: 2013-7-7 20:42
看题目做题

作者: 张歆明 时间: 2013-7-7 20:43
版主第三题代码：

package test2;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
/*
3、在一个文件夹内有文件夹和文件，文件名的格式为：数字+名称.java。
要求：把所有的.java文件复制一份，变为文件名格式为：数字+名称+数字.java。
（其中数字是相对应的，名称由字母组成。如：01Demo.java——>01Demo01.java)
*/
/*
* 思路：
* (1). 通过递归获取指定目录下的java源文件列表并且使用正则表达式进行过滤降符合要求的文件添加到文件列表里面
* (2). 对获取到的合格的文件列表复制到指定文件加下面
* */
public class Test3{
public static void main(String[] args) {
File sourceFileDir =new File("D:\\testfolder"); //源文件文件夹对象
File destinationFileDir =new File("D:\\testFileCopies"); //目标文件夹对象
//1.构建过滤文件名的正则表达式
//标准文件名要求：数字+名称.java e.g. 01Demo.java
String fileNameRegex ="((0\\d+)Demo)(\\.java)";
List<File> filteredJavaFileList =new ArrayList<File>();
//2.按照标准生成符合条件的源文件对象列表和目标文件对象列表 ---递归方式生成
getQualifiedFilesList(sourceFileDir, filteredJavaFileList, fileNameRegex);
//3.把源文件列表中的文件复制到目标地址中
copyFileList(filteredJavaFileList, destinationFileDir, fileNameRegex);
}
//把源文件列表中的文件复制到目标地址中
private static void copyFileList(List<File> filteredJavaFileList,
File destinationFileDir, String fileNameRegex) {
for(File sourceJavaFile: filteredJavaFileList){
//根据正则标准产生按照标准的文件夹名
String newFileName = sourceJavaFile.getName().replaceAll(fileNameRegex, "$1$2$3");
File destiJavaFile =new File(destinationFileDir, newFileName);
System.out.println("原文件名："+sourceJavaFile.toString()+"-----新文件名："+ destiJavaFile);
//复制单个文件
copyFile(sourceJavaFile, destiJavaFile);
}
}
//复制单个文件
private static void copyFile(File sourceJavaFile, File destiJavaFile) {
BufferedReader bufr =null;
BufferedWriter bufw =null;
try{
//源(InputStream/Reader)--->文本(Reader)--->设备(硬盘文件 FileReader) --->高效(BufferedReader)
bufr =new BufferedReader(new InputStreamReader(new FileInputStream(sourceJavaFile), "GBK"));
//目标(OutputStream/Writer)--->文本(Writer)--->设备(硬盘文件 FileWriter) --->高效(BufferedWriter)
bufw =new BufferedWriter(new FileWriter(destiJavaFile));
String lineContent =null;
System.out.println(sourceJavaFile);
while((lineContent =bufr.readLine()) !=null){
bufw.write(lineContent);
bufw.newLine();
bufw.flush();
}
}catch(IOException ioe){
System.out.println(ioe.toString());
}finally{
try{
if(bufr !=null)
bufr.close();
}catch(IOException ioe){
System.out.println(ioe.toString());
}
try{
if(bufw !=null)
bufw.close();
}catch(IOException ioe){
System.out.println(ioe.toString());
}
}
}
private static void getQualifiedFilesList(File sourceFileDir,
List<File> filteredJavaFileList, String fileNameRegex) {
File[] files =sourceFileDir.listFiles();
//递归获取符合fileNameRegex标准的java源文件列表
for(int x =0; x <files.length; x++){
if(files[x].isDirectory()) //遍历的是目录
getQualifiedFilesList(files[x], filteredJavaFileList, fileNameRegex);
else{//遍历到的是文件
String oldFileCanonicalName =files[x].getName();
//符合要求规则的全部加进来
if(oldFileCanonicalName.matches(fileNameRegex)){
//添加符合条件的源文件对象
filteredJavaFileList.add(files[x]);
}
}
}
}
}

复制代码

运行结果如图：

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

运行测试结果

源文件夹情况.jpg (82.71 KB, 下载次数: 0)

复制的源文件夹下的文件

目标文件夹情况.jpg (44.16 KB, 下载次数: 0)

复制的目标夹下的文件

作者: 杨晓燕 时间: 2013-7-7 20:49

杨晓燕发表于 2013-7-7 20:36
木有过目不忘的本领啊，虽然看了一遍，做起题来很陌生。。苗，你就说说第一题我哪里丢了一分把 ...

oooo，有道理，收了，哈哈

作者: 傻瓜一点红 时间: 2013-7-7 20:57
先看看，有时间就弄弄

作者: emos-c 时间: 2013-7-7 21:09
看看有没有简单点的

作者: 肥猫 时间: 2013-7-7 21:14
本帖最后由肥猫于 2013-7-8 21:13 编辑

新的一周又来了，我来答~~.小喵你这题目是挺有意思，可是这个时间限定也太蛋疼了吧.白天没空啊，晚上那么点时间就过24小时.

/**
功能：键盘录入一个正整数，将其分解质因数。如：输入30，打印出30=2*3*5。
author:肥猫
*/
import java.util.*;
class Test111
{
public static void main(String[] args)
{
Scanner input =new Scanner(System.in);
System.out.print("请输入要分解质因数的值:");
int n = input.nextInt();//定义键盘输入值
System.out.print(n+"=");
for(int i=2;i<=n;i++)//从最小的质数开始,区间到N为止.
{
while(n%i==0&&n!=i)//只有当N模的尽时切本身不为质数,说明其还能分解,才进行分解操作.
{
System.out.print(i+"*");
int temp=0;
n=n/i;
}
if(n==i)//当N为质数不能在分解时就输出.
{
System.out.println(i);
}
}
}
}

复制代码

作者: 黄少海 时间: 2013-7-7 21:14
等到我花儿都谢了.

作者: 宋智超 时间: 2013-7-7 21:15
回帖看题

作者: 宋智超 时间: 2013-7-7 21:30
本帖最后由宋智超于 2013-7-7 21:32 编辑

第一题：


复制代码

作者: 宋智超 时间: 2013-7-7 21:39
第一题：
//键盘录入一个正整数，将其分解质因数。如：输入30，打印出30=2*3*5。
import java.util.Scanner;
class N1 {
public static void main(String[] args) {
 Scanner num = new Scanner(System.in);
 System.out.println("请输入所要分解质因数的数：");
 int n = num.nextInt(); //以上为获取一个整数
 System.out.print(n+"="); //先输出最终结果的前面部分，后面用累除做出质因数后，按顺序添加。
 for (int i = 2; i < n+1 ;i++){ //循环尝试可能的质因数
while(n%i==0 && n!=i) { //判断是否为质因数，如果是则顺序输出，此时给n除以得出的质因数，以便进行下一次判断。
n/=i;
System.out.print(i+"*");
}
if(n==i) { //判断是否将质因数求完
System.out.print(i);
break;
}
 }
}
}

作者: longlangcx 时间: 2013-7-7 21:49
看看~~~~求技术分~~~~

作者: ㄗs：/|丶hearts 时间: 2013-7-7 23:20

ㄗs：/|丶hearts 发表于 2013-7-7 17:34

就把这里System.out.println("数组中相同的素数的角标为："+halfSeach(a, 73));
改成System.out.println("数组中相同的素数的角标为："+halfSeach(a, a[n])); 是吧?

作者: lou413 时间: 2013-7-7 23:59
先看看题目:)

作者: mo﹎雲℡ 时间: 2013-7-8 00:34
我先看看题~~

作者: 王洪波 时间: 2013-7-8 00:38

package com.itheima.bbs.c5a3;
import java.util.Scanner;
/**
* 1、键盘录入一个正整数，将其分解质因数。如：输入30，打印出30=2*3*5。
*/
public class test1
{
public static void main(String[] args)
{
Scanner input = new Scanner(System.in);
System.out.println("please input a positive integer :");
int n ;
while((n=input.nextInt()) <= 0)//只有输入的正数才行
{
System.out.println("input a positive integer:");
}
StringBuilder sb = new StringBuilder();//构建输出字符串
int count=0;//记录质因子的个数
for(int i=2;i<=n;i++)//从最小的质数开始，依次分解完所有的质因子后，再分解下一个
{
if (n%i==0) //是因子才分解
{
count++;
if(count==1)
{
sb.append(n+"="+i);//首个因子出现时，等式的初始化
}
else
{
sb.append("*"+i);//其它因子累乘到后边
}
n=n/i;//用质因子i分解n后再赋值给n
i--;//重新尝试i整除n,可能i的多次幂为n的因子
}
}//end for
//输出结果
System.out.println(sb.toString());
}
}

复制代码

package com.itheima.bbs.c5a3;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
/**
* 2、求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。（其中n个是求出的各个素数，还有一个是随机添加其中的一个素数）
这样数组中就有相同的两个素数，写一个搜索算法，找出数组中相同的那个素数。（随机添加的素数，可手动指定，也可利用随机方法产生）
*/
public class test2
{
public static void main(String[] args)
{
List<Integer> primes = new ArrayList<Integer>();
primes.add(2);//2 为素数先加进去
for(int i=3; i<=100; i+=2)
{
if(isPrime(i))
primes.add(i);
}
//随机生成一个索引
int index = new Random().nextInt(primes.size());
//添加素数
primes.add(primes.get(index));
int size = primes.size();
//输出结果
printArray(primes);
int s = primes.get(size-1);//要找的数
System.out.println("要找的数："+s);
//查找与添加的随机素数相同的素数(因为添加时，从小到大依次添加，所以元素已有序，符合二叉查找的条件)
int result = binSearch(s, primes.subList(0, size-1));
if(result!=-1)
{
System.out.println("找到了"+s+",其在数组中的位置："+result);
}
else
{
System.out.println("没有找到");
}
}
/**
* 在集合list中查找元素i
*/
private static int binSearch(Integer i, List<Integer> list)
{
Integer[]array = list.toArray(new Integer[list.size()]);
int high = list.size()-1;
int low = 0;
int mid;
while(low<=high)
{
mid = (low+high)/2;
if(array[mid] < i)
{
low = mid + 1; //在右半部查找
}
else if(array[mid] > i)
{
high = mid - 1; //在左半部查找
}
else
return mid;
}
return -1;//没有找到则返回-1
}
private static void printArray(List<Integer> primes)
{
for(int i=1,size=primes.size(); i<size; i++)
{
//十个一行输出
System.out.print((i-1)+":"+primes.get(i-1)+" ");
if(i%10 == 0)
System.out.println();
}
System.out.println();
}
/**
* 判断i是否为素数
*/
private static boolean isPrime(int i)
{
for(int j=2; j<i; j++)
{
if(i%j == 0)
return false;
}
return true;
}
}

复制代码

package com.itheima.bbs.c5a3;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/**
* 3、在一个文件夹内有文件夹和文件，文件名的格式为：数字+名称.java。
要求：把所有的.java文件复制一份，变为文件名格式为：数字+名称+数字.java。
（其中数字是相对应的，名称由字母组成。如：01Demo.java——>01Demo01.java)
*/
/**
* 首先声明不能以数字开头命名java源文件
*/
public class test3
{
public static void main(String[] args)
{
File dir = new File(".");//当前文件路径是工程文件夹内部
System.out.println(dir.getAbsolutePath());
//递归遍历该文件夹，并输出所有文件
copyFiles(dir);
/*String str = "Demo01.java";
String str2 = renameFile(str);
System.out.println(str2);*/
}
/**
* 递归目录拷贝.java类型文件
* @param dir 指定的根目录
*/
private static void copyFiles(File dir)
{
//进入目录
File[]fs = dir.listFiles();
for(File f : fs)
{
if(f.isDirectory())//遍历目录
copyFiles(f);
else if(f.getName().endsWith(".java"))//找到以java为后缀名的文件
{
copyTo(f,"./bak");//将所有.java类型的文件拷贝到当前文件夹下bak目录中
}
}
}
/**
* 将文件拷贝到指定目录
* @param fileName
* @param destDir
*/
private static void copyTo(File file, String destDir)
{
String newFileName = renameFile(file.getName());
//通过字符流来复制
BufferedReader br = null;
BufferedWriter wr = null;
try
{
br = new BufferedReader(new FileReader(file.getAbsoluteFile()));
File destPath = new File(destDir);
//不存在目的目录要创建
if(!destPath.exists()) destPath.mkdirs();
wr = new BufferedWriter(new FileWriter(destDir+"/"+newFileName));
String line = null;
while(null != (line=br.readLine()))
{
wr.write(line);
wr.flush();
}
} catch (FileNotFoundException e)
{
e.printStackTrace();
} catch (IOException e)
{
e.printStackTrace();
}
finally
{
try
{
if(br!=null)
br.close();
} catch (IOException e)
{
e.printStackTrace();
}
try
{
if(wr!=null)
wr.close();
} catch (IOException e)
{
e.printStackTrace();
}
}
}
/**
* 重新命名文件
* @param fileName
* @return 重新命名后的文件名
*/
private static String renameFile(String fileName)
{
/*String regex = "^(\\D+)(\\d+)(\\..+)$";//匹配以数字结尾的字符串
String replacement = "$2$1$2$3";*/
String regex = "^(\\d+)(\\D*)(\\..+)$";//匹配以数字开头的字符串
String replacement = "$1$2$1$3";
String newFileName = fileName.replaceFirst(regex, replacement);
return newFileName;
}
}

复制代码

作者: lou413 时间: 2013-7-8 01:25

运行结果

作者: lanbuohan 时间: 2013-7-8 01:36
本帖最后由 lanbuohan 于 2013-7-8 01:56 编辑

package cn.itcast.exam;
public class Test2 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
for (int i = 2; i <100; i++)
{
for (int j = 2; j <= i; j++)
{
if (i == j)
{//
System.out.println(i);
}
if (i % j == 0)
{
break;
}
}
}
}
}

复制代码

作者: Godream 时间: 2013-7-8 02:27
我看帖的

作者: 蚂蚁搬家 时间: 2013-7-8 02:36
只做了第二题和第三题，明天还得上班啊！能力有限，做得很慢啊！
不妥之处，还请指正！
第二题，代码如下：

/*
2、求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。（其中n个是求出的各个素数，还有一个是随机
添加其中的一个素数）
这样数组中就有相同的两个素数，写一个搜索算法，找出数组中相同的那个素数。（随机添加的素数，可手动指定，
也可利用随机方法产生）
*/
/*
基本思路：1，用getPrime方法的for循环嵌套找出1到100之间的素数，并将其存入集合中；（1不是素数）
2，将集合转换为数组；
3，用find方法的for循环嵌套找出相同的素数，并输出到控制台；
4，运行结果：所有的素数是：{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}，共25个；最后的相同的素数是73；
@author：蚂蚁搬家；
*/
import java.util.*;
public class PrimeNumber
{
public static void main(String [] args)
{
ArrayList<Integer> list = new ArrayList<Integer>(); //新建集合，用于存储素数；
getPrime(list); //获取1到100之间的素数；
System.out.println(list); //输出1到100之间的素数；
Integer[] prime = list.toArray(new Integer[list.size()]);
find(prime); //找出数组中的相同素数；
}
public static void getPrime(ArrayList<Integer> tempList)
{
int count = 0; //计数器，素数的个数；
outer: //循环语句的标号；
for(int i=2; i<=100; i++) //由于1本身不是素数，所以从2开始；
{
/*用i除以从2开始到小于i的最大整数，如果能整除，说明i不是素数，跳出内层循环，进入外层循环；
如果内层循环结束还不能整除，说明i是素数，存入集合中，计数器加1；
*/
for(int j=2; j < i; j++)
{
if(i%j == 0)
continue outer;
}
tempList.add(i);
count = count+1;
}
//向集合中随机添加一个1到100之间的素数；
tempList.add(tempList.get(count-5));
}
public static void find(Integer[] tempPrime)
{
//用第一个素数跟它后面的每个素数比较，若相等，输出相等的素数，若不等，则用第二素数跟后面的每个素数比较，以此类推；
for(int i=0; i<tempPrime.length; i++)
{
for(int j=i+1; j<tempPrime.length; j++ )
{
if(tempPrime[i] == tempPrime[j])
{
System.out.println("相同的那个素数是：" + tempPrime[i]);
return ;
}
}
}
}
}

复制代码

第三题：

/*
在一个文件夹内有文件夹和文件，文件名的格式为：数字+daxiang.java。
要求：把所有的.java文件复制一份，变为文件名格式为：数字+daxiang+数字.java。
（其中数字是相对应的，名称由字母组成。在本例中,文件名应该由"数字+daxiang.java"变为"数字+daxiang+数字.java")
*/
/*
基本思路：1，用递归方法获取到源目录下的java文件；
2，用缓冲流将源文件复制到目的文件夹下的目的文件；
3，用字符串的split方法拆分并重新组合出目的文件的文件名；
@author：蚂蚁搬家；
*/
import java.io.*;
public class CopyFile
{
public static void main(String [] args)
{
File file = new File("F:\\答题有分"); //源文件夹封装为File对象；
get(file); //调用get方法实现题目要求；
}
/*用递归方法获取源目录下的每个java文件，然后调用copyFile方法，将源文件复制到另一个文件夹中，
并对文件按照题目要求进行更名；*/
public static void get(File srcFile)
{
File[] files = srcFile.listFiles(); //列出源目录下的所有文件和目录；
for(File file : files)
{
if(file.isDirectory()) //如果是目录，递归调用get方法；
{
get(file);
}
else
{
if(file.getName().endsWith(".java")) //如果是java文件，调用copyFile方法；
{
copyFile(file);
}
}
}
}
//将源文件复制到目的文件夹，并对源文件按照题目要求更名；
public static void copyFile(File file)
{
BufferedReader br = null;
BufferedWriter bw = null;
try
{
br = new BufferedReader(new FileReader(file));
String srcName = file.getName(); //获取源文件的文件名；
String[] tempName = srcName.split("daxiang"); //将源文件名用“daxiang”拆分，拆分出来的结果是“数字”和“.java”；
String lastedName = tempName[0] + "daxiang" + tempName[0] + tempName[1]; //重新组合出来的结果就是"数字+daxiang+数字.java"；
bw = new BufferedWriter(new FileWriter("F:\\目标文件夹\\" + lastedName));
String buf = null;
while((buf = br.readLine()) != null)
{
bw.write(buf);
bw.newLine();
bw.flush();
}
}
catch(IOException e)
{
System.out.println("文件复制失败！");
}
finally
{
try
{
if(br != null)
br.close();
}
catch(IOException e)
{
}
try
{
if(bw != null)
bw.close();
}
catch(IOException e)
{
}
}
}
}

复制代码

不足之处，敬请指出！在此，先谢过了！{:soso_e183:}

作者: 秦兰之 时间: 2013-7-8 04:36
晒太阳。

作者: liujkh123 时间: 2013-7-8 08:43
开始挑战

作者: 杨晓燕 时间: 2013-7-8 08:48

杨晓燕发表于 2013-7-7 20:49
oooo，有道理，收了，哈哈

:lol你苗，你太好了，怎么发现的

作者: 教皇 时间: 2013-7-8 09:56
要积分，来答题，要回复。

作者: 张歆明 时间: 2013-7-8 10:14
本帖最后由张歆明于 2013-7-8 14:50 编辑

版主第二题我已经重新做了第一题和第三题没问题吧
第二题的代码：

package test2;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Set;
/*
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.由于随机生成的数字插入的位置未知，现在要找出这个数，可以利用Set集合的属性将数组中的元素逐次添加到
//Set集合中一旦添加失败说明这个元素是重复的这样就找出了重复加入的那个素数
int repeatedPrime =detectRepeatedPrime(primesArr);
System.out.println("重复的数字是:"+ repeatedPrime);
}
//检测重复加入的数字
private static int detectRepeatedPrime(int[] primesArr) {
Set<Integer> assistSet =new HashSet<Integer>();
int repeatedNum =0;
for(int element: primesArr){
boolean flag =assistSet.add(element);
if(flag)
System.out.println(element+"添加成功...");
else{
System.out.println("**"+ element+"重复...");
//找到重复的元素就达到了目的立刻结束添加操作
repeatedNum =element;
break;
}
}
return repeatedNum;
}
//将产生的素数列表存入数组并随机重复产生一个素数存入一个随机的位置
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("随机产生的重复的素数是: "+ randomPrime);
//再次随机产生一个索引位置并将这个随机产生的素数存入这个随机产生的索引位置
int randomIndex =new Random().nextInt(primes.size());
System.out.println("这个随机产生的素数存放到原数组的随机位置是: "+ randomIndex);
insertIntoArray(randomPrime, randomIndex, primeArr);
return primeArr;
}
//将指定的数字存入指定的位置
private static void insertIntoArray(int num, int index,
int[] primeArr) {
//向指定数组的指定位置插入一个数字现将数组中此位置以后的数字依次向后进行移位
for(int i= primeArr.length-2; i>= index; i--){
primeArr[i+1] =primeArr[i];
}
//将指定的数字插入到指定的位置
primeArr[index] =num;
}
//获取指定范围的素数
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;
}
}

复制代码

不好意思版主一时疏忽没有贴完整额这回完整啦您看看对不对 :)

test2_1.jpg (105.79 KB, 下载次数: 0)

作者: liujkh123 时间: 2013-7-8 10:49
第一题，

package test;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class TestFactorization {
public static void main(String[] args) {
BufferedReader bfbr = new BufferedReader(new InputStreamReader(System.in));
System.out.println("请输入要分解因数的数，按回车确认");//
try {
String line = bfbr.readLine();
int num = Integer.parseInt(line);//获得输入的数
showFactorization(num);
} catch (IOException e) {
e.printStackTrace();
}catch(Exception e){
e.printStackTrace();
throw new RuntimeException("输入非法，请输入数字");
}
}
/**
* 这个函数就是用来计算质因数了
* @param num
*/
private static void showFactorization(int num) {
int n = num;
StringBuilder sb = new StringBuilder();
for(int i=2; i<=num/2; i++){
while(n%i == 0){
sb.append(i + "*");
n = n/i;
}
if(n < i) //这个判断条件可以减少循环次数，节省资源
break;
}
if(sb.length() != 0){
sb.deleteCharAt(sb.length()-1);//如果不是素数，就把多余的*给去掉
}else{
sb.append(1 +"*" + num);//如果是素数，就这样输出
}
System.out.println(sb.toString());
}
}

复制代码

输出结果
请输入要分解因数的数，按回车确认
13
1*13

请输入要分解因数的数，按回车确认
100
2*2*5*5

第二题

package test;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class TestPrime {
public static void main(String[] args) {
Integer[] arr = getPrimeArr();
System.out.println("数组中相同的两个元素角标为" + getSame(arr));
}
public static Integer[] getPrimeArr(){
List<Integer> arrList = new ArrayList<Integer>();
for(int i=1; i<=100; i++){
if(isPrime(i))
arrList.add(i);
}
//这段代码简化了，就是arrList.add(int, Integer)只不过两个参数都通过随机工具来确定
arrList.add(new Random().nextInt(arrList.size()),arrList.get(new Random().nextInt(arrList.size())));
System.out.println(arrList);
return arrList.toArray(new Integer[arrList.size()]);
}
//该方法判断一个数是否为素数
public static boolean isPrime(int i){
if(i == 1||i==2||i==3)
return true;
else{
for(int j=2; j<=i/2; j++){
if(i%j == 0 ){
return false;
}
}
}
return true;
}
//这个方法可以再优化，然后寻找到拥有三个以上的相同元素的数组中相同元素的角标，这里是根据题目写的简洁版
public static String getSame(Integer[] arr){
List<Integer> arrList = new ArrayList<Integer>();
String str = null;
for(int i=0; i<arr.length; i++){
if(!arrList.contains(arr[i])){
arrList.add(arr[i]);
}else
str = arrList.indexOf(arr[i]) + "," + i;
}
return str;
}
}

复制代码

输出结果
[1, 2, 3, 17, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
数组中相同的两个元素角标为3,8

第三题

package test;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class CopyFileDemo {
public static void main(String[] args) {
File file = new File("E:\\cn");
overFile(file);
}
/**
* 遍历文件夹进行复制，题目指明了文件名称的格式，如果更严谨点还应该在方法中加入判断是否为java文件的语句
* @param file
*/
public static void overFile(File file){
if(!file.exists())
return ;
if(file.isDirectory()){
File[] files = file.listFiles();
for(File f: files){
if(f.isDirectory())
overFile(f);
else{
copyFile(f.getAbsoluteFile());
}
}
}else{
copyFile(file.getAbsoluteFile());
}
}
public static void copyFile(File file){
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
bis = new BufferedInputStream(new FileInputStream(file));
bos = new BufferedOutputStream(new FileOutputStream(changeName(file)));//调用变更名字的方法来创建复制的文件
byte[] buf = new byte[1024];
int len = 0;
while((len = bis.read(buf)) != -1){
bos.write(buf, 0, len);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
if(bis != null){
bis.close();
bis = null;
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if(bos != null){
bos.close();
bos = null;
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 变更文件名称，获得复制文件的目的文件名称
* @param file
* @return
*/
public static File changeName(File file){
String[] strs = file.getAbsolutePath().split("\\\\");
String str = strs[strs.length -1];
StringBuffer sb = new StringBuffer(str);
Pattern p = Pattern.compile("([0-9]+)[\\w]+");//正则表达式的应用
Matcher m = p.matcher(str);
if(m.find()){
sb.insert(sb.lastIndexOf(".java"), m.group(1));
}
//通过文件路径的父路径和改变好的目的文件名称创建新的文件路径
return new File(file.getParent() + File.separator + sb.toString());
}
}

复制代码

运行结果在我电脑上是成功的，不知道怎么上传图片所以就没截图了

作者: Rainbow 时间: 2013-7-8 11:07
看下啦，努力赚分

作者: Rainbow 时间: 2013-7-8 11:29

import java.util.Scanner;
public class Demo2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);//用户键盘输入数字
System.out.println("请输入你想分解的数字");
int number = sc.nextInt();//控制台获得想分解的数字
int z = 2;//2为最小质数
while (number> z) {
if (number % z== 0) {//但number能被k整除，则应打印出z的值
System.out.print(z+"x");
}
number = number / z;//并用number除以z的结果,作为新的数number,重复执行循环里的步骤
if (number % z != 0) {//(3)如果number不能被z整除，则用z+1作为k的值,重复执行循环里的步骤
z++;
}
}
System.out.println(z);
}
}

复制代码

作者: longlangcx 时间: 2013-7-8 12:15
第一次回复发表于31# 昨天 21:49~
该中饭了，先发前两道~

第一题：

import java.util.Scanner;
/*
* 题目1：键盘录入一个正整数，将其分解质因数。如：输入30，打印出30=2*3*5。
*
* 分析：应用递归的方法求解。
* 从2开始取模数对录入的正整数进行取模，如果模为零，则二者相除的结果作为被模数继续递归取模，
* 如果模不为0，则被模数不变，模数加1，继续递归，直到模数增加到被模数的1/2以上。
*
*/
public class Test1 {
public static void main(String[] args) {
//从控制台获取一个整数
Scanner in = new Scanner(System.in);
System.out.print("请输入一个正整数：");
int i = in.nextInt();
//调用递归方法获取结果
diGui(i,2,i);
}
/**
* 递归方法，将输入的正整数进行分解为质因数并输出
* @param a 被模数
* @param b 模数
* @param x 控制台输入的原值
*/
//只为完成题目要求，就private好了。
private static void diGui(int a, int b, final int x){
//结束条件：当b大于a的一半时输出最后一个被模数，如果被模数一直无变化，说明是质数。
if(a < b * 2){
if(a != x)
System.out.println(a);
else
System.out.println("您输入的是一个质数，无法分解");
return;
}
//如果可整除，则继续用此数进行递归，否则将被模数+1。
else if(a % b == 0){
if(a == x)
System.out.print(x + "= ");
System.out.print(b + "* ");
diGui(a / b, b, x);
}else
diGui(a, b + 1, x);
}
}/* Output:
请输入一个正整数：90
90= 2* 3* 3* 5
*///:~

复制代码

第二题：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;
/*
* 题目2：求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。
* （其中n个是求出的各个素数，还有一个是随机添加其中的一个素数）
* 这样数组中就有相同的两个素数，写一个搜索算法，找出数组中相同的那个素数。
* （随机添加的素数，可手动指定，也可利用随机方法产生）
* (注：存入数组后，数组中的所有元素理论上是无序的，相同的那个素数不一定就等于a[n]，
* 而是被存入了数组中的某个角标上)
*
* 分析：首先要找出1-100之间的素数。素数的判断可以用二重循环嵌套，也可以用递归，这里用
* for循环嵌套，外层枚举数，内层枚举2~sqrt(外层数字)之间的数对外层数取模。内层枚举结束
* 依然没找到模0的数则外层为素数。
*
* 因为找到的素数不是直接打印而是放在数组中，而查找过程结束前找到的素数个数未知，
* 因此使用ArrayList临时存放找到的素数，之后根据ArrayList中元素的个数确定数组大小，再
* 将其移动到数组内。
*
* 因为要在数组中添加一个重复的素数，所以数组大小可以定义为实际素数大小加1。再移入数组时，先
* 随机产生一个角标，移入时跳过此位置，之后再在素数中随机找一个放入此位，至此a[n+1]数组就搞定了。
*
* 之后要解决的就是如何在一个无序数组中找到重复元素，可以使用排序后临位比较的方法，但效率较低，
* 因此可以使用类似选择排序的方式查找重复，但不进行换位操作，这样效率较高。
*
*/
public class Test2 {
public static void main(String[] args) {
//定义一个ArrayList用于临时存储找到的素数
ArrayList<Integer> list = new ArrayList<Integer>();
//嵌套循环寻找素数，找到后插入到list中，模数限定不大于被模数的平方根，以提高效率
for(int i = 2; i <= 100; i++){
for(int j = 2;; j++){
if(j > (int)Math.sqrt(i)){
list.add(i);
break;
}
if(i % j == 0)
break;
}
}
//输出找到的list，这里直接调用了list的toString方法。
System.out.println("1-100之间的素数有:\n" + list);
//创建了一个int数组，大小为素数个数+1
int size = list.size();
int[] arr = new int[size + 1];
//生成随机数，randomNum为随机生成的1-100中的某素数，randomPos是插入数组中的位置
//这样可以让每次运行时插入的数和插入的位置都不同
Random rand = new Random();
int randomNum = list.get(rand.nextInt(size));
int randomPos = rand.nextInt(size);
//下面将ArrayList中的元素移动到数组中，在随机位插入随机素数，在尾位插入跳过的素数
for(int i = 0; i < arr.length - 1; i++){
if(i == randomPos){
arr[i] = randomNum;
continue;
}
arr[i] = list.get(i);
}
arr[arr.length - 1] = list.get(randomPos);
//输出完成插入后的数组
System.out.println("插入随机素数之后的数组为:\n" + Arrays.toString(arr));
//使用类似选择排序的方式进行多次比较，但不交换元素的位置，即实际不排序
for(int i = 0; i < arr.length -1; i++){
for(int j = i + 1; j < arr.length; j++){
if(arr[i] == arr[j])
System.out.println("重复元素为" + arr[i] + " ，出现位置为角标" + i + "和角标" + j);
}
}
}
}/* Output:
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]
插入随机素数之后的数组为:
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 11, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 47]
重复元素为11 ，出现位置为角标4和角标14
*///:~

复制代码

作者: 王洪波 时间: 2013-7-8 12:30
本帖最后由王洪波于 2013-7-8 22:03 编辑

首先谢谢版主能够指出错误。
我重新改了下，如还有错，请再指出。

package com.itheima.bbs.c5a3;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
/**
* 2、求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。（其中n个是求出的各个素数，还有一个是随机添加其中的一个素数）
这样数组中就有相同的两个素数，写一个搜索算法，找出数组中相同的那个素数。（随机添加的素数，可手动指定，也可利用随机方法产生）
*/
public class CopyOftest2
{
public static void main(String[] args)
{
List<Integer> primes = new ArrayList<Integer>();
primes.add(2);//2 为素数先加进去
for(int i=3; i<=100; i+=2)
{
if(isPrime(i))
primes.add(i);
}
int size = primes.size();//原数组的大小
Random random = new Random();
//随机生成一个索引
int index = random.nextInt(size);
int s = primes.get(index);//额外添加的的素数
System.out.println("额外添加的的相同素数"+s);
//添加素数到随机位置
int pos = random.nextInt(size);
primes.add(pos, s);
//输出结果
printArray(primes);
//找数组中相同的两个素数
searchSame(primes);
}
/**
* 在集合list中查找元素i
*/
private static void searchSame(List<Integer> list)
{
int index = -1;
for(int i=1,size=list.size(); i<size; i++)
{
//改动点：这里用二分查找相同元素，前面的元素可能是无序的,考虑不周.这里改成了用indexOf()去前边元素中找
index = list.subList(0, i).indexOf(list.get(i));//从数组前边元素【0，i-1】中找
if(-1 != index)//包含当前元素
{
//找到了
System.out.println("位置"+i+"与位置"+index+"上的素数相同！都为:"+list.get(i));
return;
}
}
System.out.println("没有找到相同元素!");
}
private static void printArray(List<Integer> primes)
{
for(int i=1,size=primes.size(); i<=size; i++)
{
//十个一行输出
System.out.print((i-1)+":"+primes.get(i-1)+" ");
if(i%10 == 0)
System.out.println();
}
System.out.println();
}
/**
* 判断i是否为素数
*/
private static boolean isPrime(int i)
{
for(int j=2; j<i; j++)
{
if(i%j == 0)
return false;
}
return true;
}
}

复制代码

作者: 刘一军 时间: 2013-7-8 12:32
先看题目

作者: 万琪 时间: 2013-7-8 13:17
水一下:lol

作者: camml 时间: 2013-7-8 13:30
这个必须顶

作者: 刘张朋 时间: 2013-7-8 15:04
抱着试试看的态度做了下，勉强做了第二、三题，不知道是否符合要求，但是对复习巩固确实很有效。第一题还是不会啊，还请多多指教哦。

 第二题：求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。（其中n个是求出的各个素数，还有一个是随机添加其中的一个素数）
这样数组中就有相同的两个素数，写一个搜索算法，找出数组中相同的那个素数。（随机添加的素数，可手动指定，也可利用随机方法产生）

package com.itheima;
import java.io.*;
import java.util.ArrayList;
import java.util.Random;
/*思路：
* 1.求1到100之间的素数，首先应该有一个判断某数是否为素数的方法。
* 2.因为素数的个数n不确定，而要将其存放于数组，但是数组长度是固定的，如直接定义数组，
* 其长度无法准确定义，但是想到集合是可变长度的，且ArrayList可转换为数组，故使用
* ArrayList先存放数组元素，再转换为int数组。
* 3.要在素数数组中随机插入一个素数，可使用ArrayList的add(int index, E element) 方法，
* 其添加位置index有Random类随机产生。而添加的素数由手动键盘输入。
* 4.查找相同的那个素数可由两个for语句嵌套遍历数组得到。
*/
public class TestTwo {
/**
 * @param args
 * @throws Exception
 */
public static void main(String[] args) throws Exception {

 //调用getPrimeToList方法。得到素数对应Integer组成的ArrayList集合
 ArrayList<Integer> al = primeToList();
 //调用listToArray(ArrayList<Integer> al)方法，将al转换成int[];
 int[] arr = listToArray(al);//如输入的不是数字，会产生异常
 String prime = getAlikeEle(arr);
 System.out.println(prime);

}
//获取相同的素数，
public static String getAlikeEle(int[] arr){
 for(int x=0;x<arr.length-2;x++){
for(int y=x+1;y<arr.length-1;y++){
if(arr[x]==arr[y])
 return "相同的素数"+arr[x]+"位于素数表的"+x+"位置和"+y;
 //该处的素数表值得是按从小到大排列的100以内的素数表
}
 }
 return -1+"";
}

//在ArrayList集合中随机插入录入的素数，并返回一个Object数组
public static int[] listToArray(ArrayList<Integer> al)throws Exception{
 //产生一个位于在al角标内的随机数，用于指定素数插入的位置
 int r = new Random().nextInt(al.size()-1);

 //创建键盘输入流，读取键盘录入的素数的字符串表示形式。
 BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));

 //读取键盘录入，去除两端空格。
 String line = bufr.readLine().trim();
 //如果输入为null，或者不是纯数字，报异常
 if((line==null) && (line.matches("\\d{1,3}")))
throw new RuntimeException("输入的不是数字");
 //将int类型的字符串转换为Integer对象
 Integer insertPrime = Integer.valueOf(line);

 //判断输入的数字是否为1到100间的素数，如不是直接报异常
 int a = insertPrime;
 if(a<1 || a>100 || !(TestTwo.isPrime(a)))
throw new RuntimeException("输入的素数不是1到100间的素数");


 //将输入的素数随机插入al集合中
 al.add(r, insertPrime);

 //遍历Object[]将其转换为int数组
 int[] arr = new int[al.size()];
 for(int i=0;i<al.size();i++){
arr = al.get(i);
 }
 return arr;
}

//获取1到100内的素数，并存放到一个ArrayList集合中
public static ArrayList<Integer> primeToList(){

 //创建ArrayList，并加范型，只允许存入Integer类型的对象
 ArrayList<Integer> al = new ArrayList<Integer>();
 for(int x=2;x<100;x++){ //因1和100都不是素数，故不作判断
if(TestTwo.isPrime(x))
al.add(x); //自动装箱，x封装为Integer
 }
 if(al.size()==0)
return null; //如果al为null，表示1到100之间无素数
 return al;
}

/*判断一个数是否为素数的方法
 *参考素数判定的“埃拉托斯特尼筛法”，检查一个正整数N是否为素数，
 *最简单的方法就是试除法，将该数N用小于等于根号N的所有素数去试除，若均无法整除，则N为素数
 */
public static boolean isPrime(int num){
 if(num<=1)
return false; //1不是素数，负数不考虑

 int x = (int) Math.ceil(Math.sqrt(num));
 for(int i=2;i*i<=x;i++){
if(num%i==0)
return false; //num有1和其本身以外的因子，故不是素数
 }
 return true; //num没有1和其本身以外的因子，故不是素数
}
}

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

package com.itheima;
import java.io.*;
/*
* 思路分析：
*1.复制.java文件用FileReader和FileWriter，可加BufferedReader和BufferedWriter提高效率。
*2. 同时因为只复制.java文件，需要进行文件过滤，用File对象的
* File[] listFiles(FilenameFilter filter) 方法获取.java文件对象。
* 这里不采用获取文件名的方式，因为要判断.java文件不是目录，而是文件，同时在读取流读取的时候也可直接使用。
*3.获取文件名前面的数字，加到原文件名的.java前面。
*4.将数据写到新文件名对应的目标文件中
*/
public class TestThree {
/**
 * @param args
 */
public static void main(String[] args) {
 // TODO Auto-generated method stub
 File file = new File("F:\\");
 if(!(file.exists()&&file.isDirectory()))
throw new NullPointerException("路径有误"); //如给定的文件夹不存在，抛异常

 //new一个本类对象调用复制文件的方法
 new TestThree().copyJava(file);
}
//实现.java文件复制的方法，此方法只能实现复制后的文件仍处于原文件夹内
public void copyJava(File file){
 //获取.java文件对象，需传入一个过滤器，并将对象存入一个File数组中
 File[] files = file.listFiles(new FilterByJava());

 //定义读取流和写入流，因操作文本文件，用字符流缓冲区提高效率
 BufferedReader bufr = null;
 BufferedWriter bufw = null;

 //for循环实现对每一个.java文件的读写
 for(File srcFile : files){

if(srcFile.isDirectory()) //如果srcFile是一个后缀为.java的目录
continue; //不再复制，而继续遍历下一个文件。

//获取复制的目的地，并用正则表达式获取写入目的地的字符串表示，即copyName
String[] sfile = srcFile.getAbsolutePath().split("\\.");
String copyName = sfile[0].replaceAll("((\\d+)(.)+)","$1$2")+".java";
File desFile = new File(copyName);

try{
bufr = new BufferedReader(new FileReader(srcFile));
bufw = new BufferedWriter(new FileWriter(desFile));
String line = null;

//频繁的读写操作
while((line=bufr.readLine())!=null){
 bufw.write(line);
 bufw.newLine();
 bufw.flush();
}
}
catch(IOException e){
throw new RuntimeException("文件复制失败！");
}
finally{
try {
 if(bufw!=null)
 bufw.close();
}
catch (IOException ex1) {
 // TODO Auto-generated catch block
 throw new RuntimeException("写入流关闭异常");
}
finally{
 if(bufr!=null)
 try{
 bufr.close();
 }
 catch(IOException ex2){
 throw new RuntimeException("读取流关闭异常");
 }
}
}
 }
}
}
/**按文件名过滤.java文件
* */
class FilterByJava implements FilenameFilter{
@Override
public boolean accept(File dir, String name) {
 // TODO Auto-generated method stub
 return name.endsWith(".java");
}

}

itheima.zip

2013-7-8 14:59 上传

点击文件名下载附件

3.83 KB, 阅读权限: 100, 下载次数: 0

作者: camml 时间: 2013-7-8 15:07
本帖最后由 camml 于 2013-7-8 15:14 编辑

import java.util.*;

class Demo1{

 public static void main(String[] args){

 //输入一个正整数，并赋值给x

 int x;

 Scanner in = new Scanner(System.in);

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

 x = in.nextInt();

 //匿名初始化一个对象

 new PrimeSplit(x);

 }

}

class PrimeSplit{

 //将最小的质数赋值给k

 int k = 2;

 public PrimeSplit(int x){

 //当输入的是1或2时特殊处理

 if(x<=1){

 System.out.println(x+"是无效的被分解数");

 }

 else if(x==2){

 System.out.println(x+"分解后的质因数为: 1*"+x);

 }else {

 //1是所有的正整数的质数,后面和输出语句相连

 System.out.print(x+"分解后的质因数为: 1");

 while(k<=x){

 //输入的数除以最小质数后重新循环

 if(x%k==0){

 System.out.print("*"+k);

 x = x/k;

 }

 //如果k不能被x整除，就将k++

 else{

 k++;

 }

 }

 }

 }

}

复制代码
作者: Rainbow 时间: 2013-7-8 15:54

package day06静态;

import java.util.Scanner;

public class Demo2 {

 public static void main(String[] args) {

 Scanner sc = new Scanner(System.in);//用户键盘输入数字

 System.out.println("请输入你想分解的数字");

 int number = sc.nextInt();//控制台获得想分解的数字

 int z = 2;//2为最小质数

 while (number> z) {

 if (number % z== 0) {//但number能被k整除，则应打印出z的值

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

 number = number / z;//并用number除以z的结果,作为新的数number,重复执行循环里的步骤

 }





 if (number % z != 0) {//(3)如果number不能被z整除，则用z+1作为k的值,重复执行循环里的步骤

 z++;

 }

 }

 System.out.println(z);

 }

 }

复制代码
刚刚看了一下，number = number / z; 应该放在if循环里面，保证可以整除最小质数。
作者: 蚂蚁搬家 时间: 2013-7-8 19:29
哥们儿，我是39楼的，帖子地址：http://bbs.itheima.com/forum.php ... 9314&pid=399428
你说我的第三题测试时出现角标越界异常，我运行了几遍没问题啊，用Eclipse和直接用cmd运行都没问题啊，都可以正常复制文件，
不知道你运行时出问题的语句在哪一行？
我把第三题的代码再贴一次，你看一下
/*

在一个文件夹内有文件夹和文件，文件名的格式为：数字+daxiang.java。

要求：把所有的.java文件复制一份，变为文件名格式为：数字+daxiang+数字.java。

（其中数字是相对应的，名称由字母组成。在本例中,文件名应该由"数字+daxiang.java"变为"数字+daxiang+数字.java")

*/

/*

基本思路：1，用递归方法获取到源目录下的java文件；

2，用缓冲流将源文件复制到目的文件夹下的目的文件；

3，用字符串的split方法拆分并重新组合出目的文件的文件名；

@author：蚂蚁搬家；

*/

import java.io.*;

public class CopyFile

{

public static void main(String [] args)

{

File file = new File("F:\\答题有分"); //源文件夹封装为File对象；

get(file); //调用get方法实现题目要求；

}

/*用递归方法获取源目录下的每个java文件，然后调用copyFile方法，将源文件复制到另一个文件夹中，

并对文件按照题目要求进行更名；*/

public static void get(File srcFile)

{

File[] files = srcFile.listFiles(); //列出源目录下的所有文件和目录；

for(File file : files)

{

if(file.isDirectory()) //如果是目录，递归调用get方法；

{

get(file);

}

else

{

if(file.getName().endsWith(".java")) //如果是java文件，调用copyFile方法；

{

copyFile(file);

}

}

}

}

//将源文件复制到目的文件夹，并对源文件按照题目要求更名；

public static void copyFile(File file)

{

BufferedReader br = null;

BufferedWriter bw = null;

try

{

br = new BufferedReader(new FileReader(file));

String srcName = file.getName(); //获取源文件的文件名；

String[] tempName = srcName.split("daxiang"); //将源文件名用“daxiang”拆分，拆分出来的结果是“数字”和“.java”；

String lastedName = tempName[0] + "daxiang" + tempName[0] + tempName[1]; //重新组合出来的结果就是"数字+daxiang+数字.java"；

bw = new BufferedWriter(new FileWriter("F:\\目标文件夹\\" + lastedName));

String buf = null;

while((buf = br.readLine()) != null)

{

bw.write(buf);

bw.newLine();

bw.flush();

}

}

catch(IOException e)

{

System.out.println("文件复制失败！");

}

finally

{

try

{

if(br != null)

br.close();

}

catch(IOException e)

{

}

try

{

if(bw != null)

bw.close();

}

catch(IOException e)

{

}

}

}

}

复制代码
作者: longlangcx 时间: 2013-7-8 20:00
下午有事耽搁了~还好时间还没到~第一次回复发表于31# 昨天 21:49~

补发下第三题：

/*

* 题目：在一个文件夹内有文件夹和文件，文件名的格式为：数字+名称.java。

* 要求：把所有的.java文件复制一份，变为文件名格式为：数字+名称+数字.java。

* （其中数字是相对应的，名称由字母组成。如：01Demo.java——>01Demo01.java)

*

* 分析：首先要获取文件夹中文件名为数字+名称.java的所有文件列表。

* 要实现此目标可以使用File.list(过滤器)方法，将目标文件夹定义为一个File对象，然后

* 设置一个过滤器类FileFilter，过滤条件为.java结尾，并且文件名中含有数字。

* 由于过滤器类仅仅创建了一个对象，并且设定的是本类的特有处理方式，不具备复用性，因此

* 可以将这个FileFilter类设置为本类的匿名内部类。

*

* 获得了要复制的文件列表之后，使用循环复制列表中的所有文件，调用改名方法将复制的目标文件名

* 改为目标值，在改名方法中，可以使用正则表达式来获取文件名中的数字部分，将此数字部分与原文

* 件名进行连接之后，即可获得新文件名。

*

* 复制文件方法中，在这里使用了文件类型兼容型更强的文件输入输出流进行复制，复制的目标文件名

* 为新文件名。

*/

import java.util.Scanner;

import java.io.File;

import java.io.FilenameFilter;

import java.io.FileInputStream;

import java.io.FileOutputStream;

public class Test3 {

public static void main(String[] args) {

//从控制台获取文件夹的绝对路径

Scanner in = new Scanner(System.in);

System.out.print("请输入此文件夹的绝对路径，如d:/workspaces/test/src :");

String path = in.nextLine();

//将此文件夹定义为一个File对象pathFile

File pathFile = new File(path);

//将过滤器类设计为了一个实现了FilenameFilter接口的匿名内部类

//此过滤器的过滤条件为获取所有文件名必须以.java结尾并包含数字

//通过调用过滤器对象，将符合条件的.java文件的文件名存入一个字符串数组list中

String[] list = pathFile.list(new FilenameFilter(){

@Override

public boolean accept(File dir, String name) {

return (name.endsWith("java")) && (name.split("\\D+").length != 0);

}

});

//遍历java文件清单，将其中的所有.java文件改名复制到同一个文件夹中。

//copyFile为自定义的赋值单个文件的方法。

//改名过程调用了自定义的getNewName方法。

for(String s : list){

String fullPath = path + "/" + s;

copyFile(fullPath, path + "/" + getNewName(s));

}

}

/**

 * 此方法用于将指定的字符串结尾处的数字连接到原文件名的开始，生成新的字符串

 * @param name 要处理的原字符串

 * @return 返回处理后的字符串

 */

private static String getNewName(String name){

String[] strArr = name.split("\\D+");

return strArr[1] + name;

}

/**

 * 此方法用于复制单个文件

 * @param oldPath 原文件路径

 * @param newPath 复制后路径

 */

public static void copyFile(String oldPath, String newPath) {

try {

//设置文件输入输出流

FileInputStream in = new FileInputStream(oldPath);

FileOutputStream out = new FileOutputStream(newPath);

//1kb的byte数组

byte[] buffer = new byte[1024];

//循环读取数据，直至读空位置

while ( (in.read(buffer)) != -1) {

out.write(buffer);

}

//关闭流

in.close();

}catch (Exception e) {

System.out.println("复制文件过程中出错");

e.printStackTrace();

}

}

}
复制代码
技术分马上要够了~~求助攻~~{:soso_e142:}
作者: 王楚鑫 时间: 2013-7-8 20:54
明早要考试啊、、、悲催、、我是看题呢还是看题呢还是看题呢还是看题呢
作者: 黄少海 时间: 2013-7-8 20:55
第二题
/**

* 2、求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。（其中n个是求出的各个素数，还有一个是随机添加其中的一个素数）

*这样数组中就有相同的两个素数，写一个搜索算法，找出数组中相同的那个素数。（随机添加的素数，可手动指定，也可利用随机方法产生）

*

*思路 :1先求出1-100中素数的个数n.建立长度为n+1的数组.

* 2循环判断1到100中的数,是素数就存入数组中.

* 3手动添加一个11的素数到数组a[n+1]中.

* 4输出相同数的角标.

*/

package a0703;

public class Exam2 {

public static void main(String[] args) {

int n= 0;//素数的个数

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

if (isPrime(i)) {

n++; //计算数组长度;

}

}

int [] a= new int [n+1];//数组长度

a[n] = 11; //手动添加一个素数11到数组中.

n = 0;

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

if (isPrime(i)) { //调用质数判断函数

a[n] = i; //i是质数存入数组中

n++; //

}

}

for (int x = 0; x < a.length-1; x++) {//每个元素分别和比他角标大的元素进行比较

for(int y = 1; y < a.length; y++) {

if (a[x] == a[y] && x != y) { //两个数相等并且角标不一样

System.out.println("在数组角标为:"+x+"和"+y+"的两个元素相等");

}

}

}

}

/**判定一个数是否是质数

 * @param int n 接收一个int类型的变量。

 * @return false 这个数不是质数

 * true 这个数是质数

 */

private static boolean isPrime(int n) {//判定一个数是否是质数

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

if(n%i==0){

return false;

}

}

return true;

}

}

复制代码
作者: 肥猫 时间: 2013-7-8 20:57
本帖最后由肥猫于 2013-7-8 21:08 编辑

第二题上交...
/**

功能：求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。

（其中n个是求出的各个素数，还有一个是随机添加其中的一个素数）

这样数组中就有相同的两个素数，写一个搜索算法，找出数组中相同的那个素数。

（随机添加的素数，可手动指定，也可利用随机方法产生）

author:肥猫

*/

import java.util.*;

class Test333

{

 public static void main(String[] args)

 {

 ArrayList<Integer> al = new ArrayList<Integer>();//先定义一个底层基于数组的容器来存储1-100的素数。

 al.add(2);//由于素数本身的意义所以需要手动添加第一个元素2。

 boolean b = false;

 for(int i =2;i<=100;i++)//双重循环找出符合条件的素数并添加到容器中。

 {

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

 {

 if(i%j==0)

 {

 b=false;

 break;

 }

 else

 b=true;

 }

 if(b)

 {

 al.add(i);

 }

 }

 int x=al.size()+1;

 int[] a = new int[x];//根据容器的大小动态初始化数组。

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

 {

 a[k]=al.get(k);//将集合容器的值赋到数组中。

 }

 System.out.println("数组的长度是:"+a.length);

 int key =a[(int)(Math.random()*(x-2))];//利用角标,随即抽取前面的角标将获得的值置于最后一位。

 a[x-1]=key;

 System.out.println("随机到的质数为:"+key);

 System.out.print("数组:");

 for(int l=0;l<a.length;l++){//遍历数组并输出以便于用二分法对其查找。

 if(a[l]==key&&l!=x-1)

 {

 System.out.print(a[l] +",");

 }

 else if(a[l]==a[x-1])

 {

 System.out.println(a[l]);

 }

 else

 {

 System.out.print(a[l]+",");

 }

}

System.out.print("查找元素的索引是:");

System.out.println(Arrays.binarySearch(a,0,x-1,key));//二分法对数组查找其索引。

}

}

复制代码

{)H{Z@XQ281VE%IEB2`ZMFK.jpg (46.63 KB, 下载次数: 0)

下载附件

2013-7-8 20:57 上传

作者: Rainbow 时间: 2013-7-8 20:58

package day06静态;

import java.util.Scanner;

public class Demo2 {

 public static void main(String[] args) {

 Scanner sc = new Scanner(System.in);//用户键盘输入数字

 System.out.println("请输入你想分解的数字");

 int number = sc.nextInt();//控制台获得想分解的数字

 int z = 2;//2为最小质数

 if(number<z){

 System.out.println("您输入的值有误，请输入<=2的正整数");

 return;

 }

 while (number> z) {

 if (number % z== 0) {//但number能被k整除，则应打印出z的值

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

 number = number / z;//并用number除以z的结果,作为新的数number,重复执行循环里的步骤

 }





 if (number % z != 0) {//(3)如果number不能被z整除，则用z+1作为k的值,重复执行循环里的步骤

 z++;

 }

 }



 System.out.println(z);

 }

 }

复制代码
考虑的不够全面，版主帮忙看下，如果有错误会继续改正的，下面的题争取严谨！
作者: sunriselzz 时间: 2013-7-8 21:00
看看，学习学习
作者: 陈昊 时间: 2013-7-8 21:02
给力啊，试试再说
作者: 以防万一 时间: 2013-7-8 21:14
我想试试、、、、、、、阿门。
作者: 王冬 时间: 2013-7-8 21:20
{:2_34:}{:2_33:}
作者: 王楚鑫 时间: 2013-7-8 21:37
第一题
/*

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

*/

import java.util.*;

public class Factors

{

public static void main(String args[])

{

int i;

Scanner sc = new Scanner(System.in);

int n=Integer.parseInt(sc.nextLine()); //实现从键盘输入一个正整数

System.out.print(n+"=");

for(i=2;i<n;i++) //分解质因数、从除1外最小的质数开始循环

{

while(n!=i) //如果这个质数恰等于n，则说明分解质因数的过程已经结束, 否则进行分解

{

if(n%i==0) //取i余0说明i是一个因数、输出该质因数

{

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

n=n/i;//控制循环、操作与i相对的另一个因数是否是质数、不是质数即循环进行分解

}

else

break;

}

}

System.out.print(n); //输出使循环结束的质因数

}

}
复制代码
运行截图

第三周1.jpg (4.49 KB, 下载次数: 0)

下载附件

2013-7-8 21:37 上传

作者: 陈昊 时间: 2013-7-8 21:48
怎么设置
作者: 陈昊 时间: 2013-7-8 21:49
import java.util.Scanner;
public class FenJie{
public static void main(String[] args){
 System.out.println("请输入一个正整数：");
 Scanner sc = new Scanner(System.in);
 int n = sc.nextInt();
 int a=2;
 if(n<=1){//当n小于等于1的时候，数字不能分解。
 System.out.println("被分解数无效，请重新输入");
 return;
 }
 if(n==a){//当分解数为a时，分解的因数为1与他本身相乘。
 System.out.println(n+"="+"1*"+n);
 }
 if(n>a){//当n>a时，打印分解数n=;
 System.out.print(n+"=1");
 while(n>=a){
 if(n%a==0){
n=n/a;//当n%a余数为0，且n/a为它本身的时候打印出*和a的值
 System.out.print("*"+a);


 }
 else{
 a=a+1;//a+1的值赋值给a.
 }
 }
 }

 System.out.println("");
}

}
作者: 一木榜公 时间: 2013-7-8 21:55
瞅瞅……巩固知识
作者: 王洪波 时间: 2013-7-8 21:58

王洪波发表于 2013-7-8 12:30
这是改后的，请指教：

首先谢谢版主能够指出错误之处。
我改了下，如若再有错误，望不悋指出。
package com.itheima.bbs.c5a3;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Random;

/**

* 2、求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。（其中n个是求出的各个素数，还有一个是随机添加其中的一个素数）

 这样数组中就有相同的两个素数，写一个搜索算法，找出数组中相同的那个素数。（随机添加的素数，可手动指定，也可利用随机方法产生）

*/

public class CopyOftest2

{

public static void main(String[] args)

{

List<Integer> primes = new ArrayList<Integer>();

primes.add(2);//2 为素数先加进去

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

{

if(isPrime(i))

primes.add(i);

}

int size = primes.size();//原数组的大小

Random random = new Random();

//随机生成一个索引

int index = random.nextInt(size);

int s = primes.get(index);//额外添加的的素数

System.out.println("额外添加的的相同素数"+s);

//添加素数到随机位置

int pos = random.nextInt(size);

primes.add(pos, s);

//输出结果

printArray(primes);

//找数组中相同的两个素数

searchSame(primes);

}

/**

 * 在集合list中查找元素i

 */

private static void searchSame(List<Integer> list)

{

int index = -1;

for(int i=1,size=list.size(); i<size; i++)

{

//改动点：这里用二分查找相同元素，前面的元素可能是无序的,考虑不周.这里改成了用indexOf()去前边元素中找

index = list.subList(0, i).indexOf(list.get(i));//从数组前边元素【0，i-1】中找

if(-1 != index)//包含当前元素

{

//找到了

System.out.println("位置"+i+"与位置"+index+"上的素数相同！都为:"+list.get(i));

return;

}

}

System.out.println("没有找到相同元素!");

}

private static void printArray(List<Integer> primes)

{

for(int i=1,size=primes.size(); i<=size; i++)

{

//十个一行输出

System.out.print((i-1)+":"+primes.get(i-1)+" ");

if(i%10 == 0)

System.out.println();

}

System.out.println();

}

/**

 * 判断i是否为素数

 */

private static boolean isPrime(int i)

{

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

{

if(i%j == 0)

return false;

}

return true;

}

}

复制代码
作者: qdlglibin 时间: 2013-7-8 22:15
看看题~~~~~~~~~
作者: qdlglibin 时间: 2013-7-8 22:16
看看题~~~~~~~~~
作者: qdlglibin 时间: 2013-7-8 22:16
{:soso_e130:}{:soso_e130:}
作者: qdlglibin 时间: 2013-7-8 22:27
{:soso_e102:}{:soso_e102:}

作者: 以防万一 时间: 2013-7-8 22:32
本帖最后由咦，我盗了太阳于 2013-7-9 15:11 编辑

好吧，我是第一次动脑子去想一个Java问题，虽然过程有点苦逼，没按要求用数组，但是我写出来了

继续努力咯

以后要经常参加这种活动才行啊
既锻炼了代码的灵活性也得到了分
嘿嘿
加油！
/*打印输出一百以内的素数

1,遍历1-100的数,使用for循环进行遍历

2,判断这个数是不是素数,是就打印出来

*/

class sushu

{

public static void main(String[] args)

{

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

int j;

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

{

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

{

if(i%j==0)

break;

}

if(j>=i-1&&i>1)

{

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

}

}

}

}
复制代码
结果：

QQ截图20130708222818.png (1.25 KB, 下载次数: 0)

下载附件

2013-7-8 22:31 上传

作者: qdlglibin 时间: 2013-7-8 22:37

作者: 亲雨泽 时间: 2013-7-8 23:16
看看题目啊
作者: 一木榜公 时间: 2013-7-9 00:07
本帖最后由一木榜公于 2013-7-9 00:09 编辑

/*

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

思路：

1.用哪个函数实现从键盘接收一个整数：Integer.parseInt(arg[0]);

2.怎么将其分解质因数？质因数就是质数因子，最小质数为2.任何合数都能分解成几个质数相乘

如：18 = 2 * 3 *3 ，36 = 2*2*3*3，105 = 3*5*7，

发现:

1,36如果被最小质数2除起，能被整除，商继续除2，直到不能被2整除，就2加1，再与3除，

能被整除，其商再与3除，以此类推……可求出质因子。

2,大于18的整数肯定不能与36整除，也就是不可能是他的质因子。

*/

class TestDemo

{

 public static void main(String[] args)

 {

 // 接收键盘输入的正整数

 int x;

 x = Integer.parseInt(args[0]);

 // 判断输入的是否为正整数

 if( x <= 0)

 {

 System.out.println("输入错误！所输入的数不是正整数。");

 return;

 }

 //记录x与质因数相除后的商

 int n = x;

 int[] zishu = new int[32]; // 存放质因子数组

 int p = 0; // 操作数组的角标

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

 {



 /*

 ** i能被n整除就将i输出，并求其商,直到i不能被n整除退出循环

 */

 while(n%i==0)

 {

 zishu[p++] = i;

 n = n/i;

 }

 }

 //判断是否有质因数,有打印质数因子

 if(n==x)

 System.out.println(x+"这个正整数不存在质因数！");

 else

 {

 //数组遍历

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

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

 {

 if(j != p-1)

 {

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

 }

 else

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

 }

 }



 }

}

复制代码
编译结果：

编译结果1.jpg (22.52 KB, 下载次数: 0)

下载附件

2013-7-9 00:09 上传

作者: ytblght55 时间: 2013-7-9 00:10
凑个热闹!!!
作者: 王安琪 时间: 2013-7-9 00:12
貌似来的有点晚啊
作者: 黄少海 时间: 2013-7-9 01:44
白天没时间在上课没时间上网.晚上加班加点搞出来.望楼主见谅啊! 第三题文件名没改出来.不过新加了一个功能可以复制自定义后缀的文件.
/**

 题目3、在一个文件夹内有文件夹和文件，文件名的格式为：数字+名称.java。

 要求：把所有的.java文件复制一份，变为文件名格式为：数字+名称+数字.java。

（其中数字是相对应的，名称由字母组成。如：01Demo.java——>01Demo01.java)

*/

package test;

import java.io.File;

import java.io.FileReader;

import java.io.FileWriter;

import java.util.Scanner;

class Exam {

public static void main(String[] args) {

Scanner s = new Scanner(System.in);

System.out.println("复制文件的目录(去掉结尾的两个\\否则运行失败):");

String sourcePath = s.next();

System.out.println("源目录路径字符的个数.(如d:\\demo有7个字符 ,就输入7 ).请输入:");

int count = s.nextInt();

System.out.println("文件存储的目录(去掉结尾的两个\\否则运行失败):");

String storePath = s.next();

System.out.println("要复制的文件后缀名(如.java)");

String layout = s.next();

File f = new File(sourcePath);//创建一个文件夹对象

reCopy(f, sourcePath,count,storePath,layout);//

}

/**

@param f 接收一个文件夹对象

@param sourcePath 被复制文件的路径.(去掉结尾的两个\否则运行失败)

@param storePath 复制目的目录(去掉结尾的两个\否则运行失败)

@param count 源目录路径字符的个数.(如d:\demo有7个字符 ,就输入7 )

@param layout 要复制的文件后缀名

*/

public static void reCopy(File f, String sourcePath, int count,

String storePath,String layout) {

//Copy c = new Copy();

File[] st = f.listFiles();//创建一个抽象路径名数组,存储文件对象

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

//判断如果是文件就复制.文件夹跳过不操作

if(st[i].isFile()) {

String s =st[i]+"";

String fileName = s.substring(count);//提取要文件名

if(fileName.endsWith(layout)) {

System.out.println(fileName);

copyFile(sourcePath ,fileName, storePath);

}

//用字符流传输(FileReader)

}

}

}

//复制一个文件到另外一个文件夹

public static void copyFile(String sourcePath, String fileName,String storePath) {

FileReader fr = null;

FileWriter fw = null;

int c = 0;

try {

//创建输入流

fr = new FileReader(sourcePath+"\\"+fileName);

//创建输出流

fw = new FileWriter(storePath+"\\"+fileName);

//输入流直接存进输出流达到文件传输

while ( (c = fr.read()) != -1) {

fw.write(c);

}

fw.flush(); // 强制刷新流

} catch(Exception e) {

e.printStackTrace();

}finally {

try {

//关闭流

fr.close();

fw.close();//

System.out.println("已经成功复制文件");

}catch(Exception e){}

}

}

}

复制代码

小Q截图-20130709014005.png (17.89 KB, 下载次数: 0)

下载附件

2013-7-9 01:40 上传

.java文件复制

小Q截图-20130709014246.png (14.67 KB, 下载次数: 0)

下载附件

2013-7-9 01:43 上传

.class复制

小Q截图-20130709014439.png (6.33 KB, 下载次数: 0)

下载附件

2013-7-9 01:44 上传

源目录

作者: 秦兰之 时间: 2013-7-9 04:41

/*

*题目：

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

*/

import java.util.Scanner;//分解质因数

public class fenjiezys {

public static void main(String[] args) {

System.out.println("输入所求数：");

Scanner r = new Scanner(System.in);

long n = r.nextLong();

int flag = 0;

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

if (n%i == 0) {

flag++;

if(flag == 1){

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

}

else

{

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

}

n = n/i;

i--;

}

}

if (flag == 0) {

System.out.println(n+" 为质数");

}

else

{

System.out.println(" 共有"+flag+"个质因数"); }

}

}
复制代码
作者: 刘张朋 时间: 2013-7-9 08:39

刘张朋发表于 2013-7-8 15:04
抱着试试看的态度做了下，勉强做了第二、三题，不知道是否符合要求，但是对复习巩固确实很有效。第一题还是 ...

可能是贴进去的时候什么地方弄错了
package com.itheima;

import java.io.*;

import java.util.ArrayList;

import java.util.Random;

/*思路：

* 第二题：求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。（其中n个是求出的各个素数，还有一个是随机添加其中的一个素数）

* 这样数组中就有相同的两个素数，写一个搜索算法，找出数组中相同的那个素数。（随机添加的素数，可手动指定，也可利用随机方法产生）

* 1.求1到100之间的素数，首先应该有一个判断某数是否为素数的方法。

* 2.因为素数的个数n不确定，而要将其存放于数组，但是数组长度是固定的，如直接定义数组，

* 其长度无法准确定义，但是想到集合是可变长度的，且ArrayList可转换为数组，故使用

* ArrayList先存放数组元素，再转换为int数组。

* 3.要在素数数组中随机插入一个素数，可使用ArrayList的add(int index, E element) 方法，

* 其添加位置index有Random类随机产生。而添加的素数由手动键盘输入。

* 4.查找相同的那个素数可由两个for语句嵌套遍历数组得到。

*/

public class TestTwo {

/**

* @param args

* @throws Exception

*/

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

//调用getPrimeToList方法。得到素数对应Integer组成的ArrayList集合

ArrayList<Integer> al = primeToList();

//调用listToArray(ArrayList<Integer> al)方法，将al转换成int[];

int[] arr = listToArray(al);//如输入的不是数字，会产生异常

String prime = getAlikeEle(arr);

System.out.println(prime);

}

//获取相同的素数，

public static String getAlikeEle(int[] arr){

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

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

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

return "相同的素数"+arr[x]+"位于素数表的"+x+"位置和"+y;

//该处的素数表值得是按从小到大排列的100以内的素数表

}

}

return -1+"";

}

//在ArrayList集合中随机插入录入的素数，并返回一个Object数组

public static int[] listToArray(ArrayList<Integer> al)throws Exception{

//产生一个位于在al角标内的随机数，用于指定素数插入的位置

int r = new Random().nextInt(al.size()-1);

//创建键盘输入流，读取键盘录入的素数的字符串表示形式。

BufferedReader bufr =

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

//读取键盘录入，去除两端空格。

String line = bufr.readLine().trim();

//如果输入为null，或者不是纯数字，报异常

if((line==null) && (line.matches("\\d{1,3}")))

throw new RuntimeException("输入的不是数字");

//将int类型的字符串转换为Integer对象

Integer insertPrime = Integer.valueOf(line);

//判断输入的数字是否为1到100间的素数，如不是直接报异常

int a = insertPrime;

if(a<1 || a>100 || !(TestTwo.isPrime(a)))

throw new RuntimeException("输入的素数不是1到100间的素数,请核准后输入");

//将输入的素数随机插入al集合中

al.add(r, insertPrime);

//遍历Object[]将其转换为int数组

int[] arr = new int[al.size()];

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

arr[i] = al.get(i);

}

return arr;

}

//获取1到100内的素数，并存放到一个ArrayList集合中

public static ArrayList<Integer> primeToList(){

//创建ArrayList，并加范型，只允许存入Integer类型的对象

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

for(int x=2;x<100;x++){ //因1和100都不是素数，故不作判断

if(TestTwo.isPrime(x))

al.add(x); //自动装箱，x封装为Integer

}

if(al.size()==0)

return null; //如果al为null，表示1到100之间无素数

return al;

}

/*判断一个数是否为素数的方法

*参考素数判定的“埃拉托斯特尼筛法”，检查一个正整数N是否为素数，

*最简单的方法就是试除法，将该数N用小于等于根号N的所有素数去试除，若均无法整除，则N为素数

*/

public static boolean isPrime(int num){

if(num<=1)

return false; //1不是素数，负数不考虑

int x = (int) Math.ceil(Math.sqrt(num));

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

if(num%i==0)

return false; //num有1和其本身以外的因子，故不是素数

}

return true; //num没有1和其本身以外的因子，故不是素数

}

}

复制代码
作者: 刘张朋 时间: 2013-7-9 09:11

刘张朋发表于 2013-7-9 08:39
可能是贴进去的时候什么地方弄错了

我错了，以前的代码的60行和61行，在测试时如果直接按enter或者输入字母不是按我想的那样执行的，下面是修改后的代码，[code]package com.itheima;

import java.io.*;
import java.util.ArrayList;
import java.util.Random;

/*思路：
* 第二题：求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。（其中n个是求出的各个素数，还有一个是随机添加其中的一个素数）
* 这样数组中就有相同的两个素数，写一个搜索算法，找出数组中相同的那个素数。（随机添加的素数，可手动指定，也可利用随机方法产生）
* 1.求1到100之间的素数，首先应该有一个判断某数是否为素数的方法。
* 2.因为素数的个数n不确定，而要将其
作者: 刘张朋 时间: 2013-7-9 09:18

刘张朋发表于 2013-7-9 08:39
可能是贴进去的时候什么地方弄错了

我错了，以前代码在60行和61的，如果直接按enter和输入字母不是按我想的那样执行的，下面是修改后的代码：

package com.itheima;

import java.io.*;

import java.util.ArrayList;

import java.util.Random;

/*思路：

* 第二题：求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。（其中n个是求出的各个素数，还有一个是随机添加其中的一个素数）

* 这样数组中就有相同的两个素数，写一个搜索算法，找出数组中相同的那个素数。（随机添加的素数，可手动指定，也可利用随机方法产生）

* 1.求1到100之间的素数，首先应该有一个判断某数是否为素数的方法。

* 2.因为素数的个数n不确定，而要将其存放于数组，但是数组长度是固定的，如直接定义数组，

* 其长度无法准确定义，但是想到集合是可变长度的，且ArrayList可转换为数组，故使用

* ArrayList先存放数组元素，再转换为int数组。

* 3.要在素数数组中随机插入一个素数，可使用ArrayList的add(int index, E element) 方法，

* 其添加位置index有Random类随机产生。而添加的素数由手动键盘输入。

* 4.查找相同的那个素数可由两个for语句嵌套遍历数组得到。

*/

public class TestTwo {

/**

* @param args

* @throws Exception

*/

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

//调用getPrimeToList方法。得到素数对应Integer组成的ArrayList集合

ArrayList<Integer> al = primeToList();

//调用listToArray(ArrayList<Integer> al)方法，将al转换成int[];

int[] arr = listToArray(al);//如输入的不是数字，会产生异常

String prime = getAlikeEle(arr);

System.out.println(prime);

}

//获取相同的素数，

public static String getAlikeEle(int[] arr){

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

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

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

return "相同的素数"+arr[x]+"位于素数表的"+x+"位置和"+y;

//该处的素数表值得是按从小到大排列的100以内的素数表

}

}

return -1+"";

}

//在ArrayList集合中随机插入录入的素数，并返回一个Object数组

public static int[] listToArray(ArrayList<Integer> al)throws Exception{

//产生一个位于在al角标内的随机数，用于指定素数插入的位置

int r = new Random().nextInt(al.size()-1);

//创建键盘输入流，读取键盘录入的素数的字符串表示形式。

BufferedReader bufr =

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

//读取键盘录入，去除两端空格。

String line = bufr.readLine().trim();

//如果输入为null，或者不是纯数字，报异常

if((line=="") ||! (line.matches("\\d{1,3}")))

throw new RuntimeException("输入的不是数字");

//将int类型的字符串转换为Integer对象

Integer insertPrime = Integer.valueOf(line);

//判断输入的数字是否为1到100间的素数，如不是直接报异常

int a = insertPrime;

if(a<1 || a>100 || !(TestTwo.isPrime(a)))

throw new RuntimeException("输入的素数不是1到100间的素数,请核准后输入");

//将输入的素数随机插入al集合中

al.add(r, insertPrime);

//遍历Object[]将其转换为int数组

int[] arr = new int[al.size()];

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

arr[i] = al.get(i);

}

return arr;

}

//获取1到100内的素数，并存放到一个ArrayList集合中

public static ArrayList<Integer> primeToList(){

//创建ArrayList，并加范型，只允许存入Integer类型的对象

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

for(int x=2;x<100;x++){ //因1和100都不是素数，故不作判断

if(TestTwo.isPrime(x))

al.add(x); //自动装箱，x封装为Integer

}

if(al.size()==0)

return null; //如果al为null，表示1到100之间无素数

return al;

}

/*判断一个数是否为素数的方法

*参考素数判定的“埃拉托斯特尼筛法”，检查一个正整数N是否为素数，

*最简单的方法就是试除法，将该数N用小于等于根号N的所有素数去试除，若均无法整除，则N为素数

*/

public static boolean isPrime(int num){

if(num<=1)

return false; //1不是素数，负数不考虑

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

if(num%i==0)

return false; //num有1和其本身以外的因子，故不是素数

}

return true; //num没有1和其本身以外的因子，故不是素数

}

}

复制代码

作者: 以防万一 时间: 2013-7-9 10:03

咦，我盗了太阳发表于 2013-7-8 22:32
好吧，我是第一次动脑子去想一个Java问题，虽然过程有点苦逼，但是我写出来了

虽然只有素数这个。。。。

额，，，，，，，，好吧，题错了，是第二题，，，，，忘记了
作者: 方珂 时间: 2013-7-9 10:13
来做做题目~
作者: longlangcx 时间: 2013-7-9 12:09
57楼发的第三题，改了半天，最后发现原来是题目看错了，按照java命名习惯，想当然的以为是要将Demo01.java改成01Demo01.java，结果原来是反过来要将01Demo.java改01Demo01.java。

对原程序做了一些修改，代码如下：

/*

* 题目：在一个文件夹内有文件夹和文件，文件名的格式为：数字+名称.java。

* 要求：把所有的.java文件复制一份，变为文件名格式为：数字+名称+数字.java。

* （其中数字是相对应的，名称由字母组成。如：01Demo.java——>01Demo01.java)

*

* 分析：首先要获取文件夹中文件名为数字+名称.java的所有文件列表。

* 要实现此目标可以使用File.list(过滤器)方法，将目标文件夹定义为一个File对象，然后

* 设置一个过滤器类FileFilter，过滤条件为.java结尾，并且文件名中含有数字。

* 由于过滤器类仅仅创建了一个对象，并且设定的是本类的特有处理方式，不具备复用性，因此

* 可以将这个FileFilter类设置为本类的匿名内部类。

*

* 获得了要复制的文件列表之后，使用循环复制列表中的所有文件，调用改名方法将复制的目标文件名

* 改为目标值，在改名方法中，可以使用正则表达式来获取文件名开头的数字部分，将原文件名与此

* 数字部分+.java进行连接之后，即可获得新文件名。

*

* 复制文件方法中，在这里使用了文件类型兼容型更强的文件输入输出流进行复制，复制的目标文件名

* 为新文件名。

*/

import java.util.Scanner;

import java.io.File;

import java.io.FilenameFilter;

import java.io.FileInputStream;

import java.io.FileOutputStream;

public class Test3 {

public static void main(String[] args) {

//从控制台获取文件夹的绝对路径

Scanner in = new Scanner(System.in);

System.out.print("请输入此文件夹的绝对路径，如d:/workspaces/test/src :");

String path = in.nextLine();

//将此文件夹定义为一个File对象pathFile

File pathFile = new File(path);

//将过滤器类设计为了一个实现了FilenameFilter接口的匿名内部类

//此过滤器的过滤条件为获取所有文件名必须以.java或.JAVA结尾并开头包含数字但不全为数字

//通过调用过滤器对象，将符合条件的.java文件的文件名存入一个字符串数组list中

String[] list = pathFile.list(new FilenameFilter(){

@Override

public boolean accept(File dir, String name) {

return name.matches("\\d+\\D+.*\\.java") || name.matches("\\d+\\D+.*\\.JAVA");

}

});

//遍历java文件清单，将其中的所有.java文件改名复制到同一个文件夹中。

//copyFile为自定义的赋值单个文件的方法。

//改名过程调用了自定义的getNewName方法。

//如设定的文件夹不存在，则list为null，捕获空指针异常，并给出提示。

try{

for(String s : list){

String fullPath = path + "/" + s;

copyFile(fullPath, path + "/" + getNewName(s));

}

}catch(NullPointerException e){

System.out.println("输入的文件夹路径有误！");

}

}

/**

 * 此方法用于将指定的字符串结尾处的数字连接到原文件名的开始，生成新的字符串

 * @param name 要处理的原字符串

 * @return 返回处理后的字符串

 */

private static String getNewName(String name){

//获取文件名中的数字

String[] numArr = name.split("\\D+");

//去除文件名中的java后缀

String[] strArr = name.split("\\.java|\\.JAVA");

//strArr[0]为去除后缀的文件名，numArr[0]为文件名开头的数字，最后再加上.java后缀

return strArr[0] + numArr[0] + ".java";

}

/**

 * 此方法用于复制单个文件

 * @param oldPath 原文件路径

 * @param newPath 复制后路径

 */

public static void copyFile(String oldPath, String newPath) {

try {

File newFile = new File(newPath);

if(newFile.exists()){

System.out.println(newPath + "已存在，跳过复制");

return;

}

//设置文件输入输出流

FileInputStream in = new FileInputStream(oldPath);

FileOutputStream out = new FileOutputStream(newPath);

//1kb的byte数组

byte[] buffer = new byte[1024];

//循环读取数据，直至读空位置

while ( (in.read(buffer)) != -1) {

out.write(buffer);

}

//关闭流

out.close();

in.close();

}catch (Exception e) {

System.out.println("复制文件过程中出错");

e.printStackTrace();

}

}

}
复制代码
修改的地方：
1. 过滤器肯定是要改的，过滤条件改成了数字开头且不全为数字的.java或.JAVA文件。之前报数组越界应该是因为题目看错所以没考虑数字开头的java文件。
2.复制时添加了捕获空指针异常，这样在用户的文件夹路径输入错误时可以给出提示。
3.获取新名字的方法相应的也要改正，将文件名去除后缀 + 文件名开头的数字 + .java后缀。
4.在文件复制的方法中，添加了文件存在判断，当改名后的文件存在时跳过复制并给出提示，否则就把复制的内容添加到这个已存在文件的后面去了。
作者: 杨彬 时间: 2013-7-9 15:21
技术分啊
作者: 星仔子 时间: 2013-7-9 15:35
瞅瞅啊，膜拜，学习，提高，练习。

作者: 方珂 时间: 2013-7-9 17:07
第一题：
import java.util.Scanner;

import java.util.Vector;

public class Decomposition {

public static void main(String[] args) {

System.out.println("请输入一个正整数:");

Scanner sc = new Scanner(System.in);

int num = sc.nextInt();

//我们首先要得到输入的正整数以内的所有质数

Vector<Integer> v = new Vector<Integer>();

Lab:for(int i=2;i<=num;i++)

{

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

{

if(i%j==0&&i!=2)//如果i能被整除，继续循环

{

continue Lab;

}

}

v.add(i);//如果能正常完成内层for循环，说明i是质数。

}

System.out.println("分解结果是：");

boolean flag =true;

for(int k=0;k<v.size();k++)

{

int z =(int)v.get(k);

if(num<z)

break;

if(num%z==0)//如果能被整除，说明z是num的一个质因数。

{

if (flag == true){

System.out.print(num+"="+z);

flag = false;

}

else{

System.out.print("*"+z);

}

k--;//因为有可能num还能被z整除，所以重新执行一遍.

num=num/z;

}

}

sc.close();

}

}

复制代码
运行结果：

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

下载附件

2013-7-9 17:04 上传

第二题：
import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

public class Prime {

public static void main(String[] args) {

 //获取100以内的素数

 List<Integer> list = new ArrayList<Integer>();

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

{

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

{

if(i%j==0&&i!=2)//如果i能被整除，继续循环

{

continue Lab;

}

}

list.add(i);//如果能正常完成内层for循环，说明i是质数。

}



 //无序化得到的素数List，存入数组，并随机生成一个相同的素数

 int number = list.size();

 int[] primes = new int[number + 1];

 int random = (int) (Math.random() * number);

 primes[random] = list.get(random);

 for (int i = 0; i < number + 1; i++) {

 if (i != random) {

 int index = (int) (Math.random() * list.size());

 primes[i] = list.get(index);

 list.remove(index);

 }

 }



 //寻找相同的素数

 Map<Integer, Integer> map = new HashMap<Integer, Integer>();

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

 if (map.put(primes[i], i) != null) {

 System.out.println("相同的素数是" + primes[i]);

 break;

 }

 }

}

}
复制代码
运行结果：

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

下载附件

2013-7-9 17:05 上传

第三题：
import java.io.File;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

public class FileCopy {

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

{

try

{

String filePath = "d:/java/demo/";

File inFile = new File(filePath);

File[] files = inFile.listFiles();//列出当前路径下所有文件

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

{

File file = files[i];

if(file != null && file.isFile())//如果是文件且不为空

{

String fileName = file.getName();//获得文件名

//修改文件名

if("java".equalsIgnoreCase(fileName.substring(fileName.indexOf(".")+1)))

{

char ch[] = fileName.toCharArray();

int end = 0;

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

if(ch[j] < '0' || ch[j] > '9')

{

end = j;

j = ch.length;

}

String newFileName = fileName.replace(".", fileName.substring(0,end)+".");//重新命名文件

//复制文件

BufferedReader br = new BufferedReader(new FileReader(file));

File outFile = new File(filePath + newFileName);

BufferedWriter bw = new BufferedWriter(new FileWriter(outFile));

char buf[] = new char[1024];

int len = 0;

while((len = br.read(buf)) != -1)

bw.write(buf, 0, len);

bw.close();

br.close();

}

}

}

} catch (Exception e)

{

e.printStackTrace();

}

}

}

复制代码
运行结果：

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

下载附件

2013-7-9 17:06 上传

急求技术分，希望版主酌情给分，谢谢。

作者: 董延京 时间: 2013-7-9 18:10
来晚了哦
作者: 陈昊 时间: 2013-7-9 18:10

import java.util.Scanner;

public class FenJie{

public static void main(String[] args){

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

 Scanner sc = new Scanner(System.in);

 int n = sc.nextInt();

 int a=2;

 if(n<1){//当n小于1的时候，数字不能分解。

 System.out.println("被分解数无效，请重新输入");

 return;

 }

 if(n==a){//当分解数为a时，分解的因数为1与他本身相乘。

 System.out.println(n+"="+"1*"+n);

 }

 if(n>a){//当n>a时，打印分解数n=;

 System.out.print(n+"=1");

 while(n>=a){

 if(n%a==0){

 n=n/a;//当n%a余数为0，且n/a为它本身的时候打印出*和a的值

 System.out.print("*"+a);



 }

 else{

 a=a+1;//a+1的值赋值给a.

 }

 }

 }

 System.out.println("");

}

}
复制代码
作者: 风乐 时间: 2013-7-9 18:22
看一看，瞧一瞧

作者: 一木榜公 时间: 2013-7-9 20:40
本帖最后由一木榜公于 2013-7-9 20:46 编辑

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

/*
思路：
1，找出1——100的素数，存入一个数组中
（1），计数器思想，计算素数的个数，接着可以定义数组
（2），将素数随机存入数组
2，在这些素数中随机取一个，放入数组，位置不确定
（1）遍历数组找到，数组元素为0的位置
（2）将随机产生的素数放入该位置
3，搜索出两个相同素数，和在数组中的位置
用折半查找相同的素数。

*/
import java.util.Random; //int nextInt();

class TestDemo2
{
 /*
 ** 判断一个整数是否是素数
 */
 public static boolean isSuShu(int num)
 {
 //小于1的整数不是素数
 if( num <=1 )
 return false;

 //能被小于num/2的数整除不是素数
 for(int x = 2; x <= num/2; x++ )
 {
 if( num % x == 0 )
 return false;
 }

 return true;
 }

 /*
 ** 求 1到某个整数之间的素数的总数
 */
 public static int countSuShu(int num)
 {
 int count = 0;
 for(int x =2; x <num; x++)
 {
 if(isSuShu(x))
 count++;
 }

 return count;
 }

 /*
 ** 将一个非0整数随机存入一个整型数组
 */
 public static void saveIntToArray(int[] arr, int num)
 {
 Random rand = new Random(); //能够随机产生一个数的对象

 int len = arr.length;
 int p = rand.nextInt(len); //能够产生0~arr.length-1的整数
 //将一个非0整数存入数组
 while(true)
 {
 if(arr[p] != 0)
 p = rand.nextInt(len);
 else
 {
 arr[p] = num;
 return;
 }
 }
 }
 /*
 ** 遍历数组
 */
 public static void printArray(int[] arr)
 {
 System.out.print("[ ");
 for(int x = 0; x < arr.length; x++ )
 {
 if(x != arr.length-1)
 System.out.print(arr[x]+" ");
 else
 System.out.println(arr[x]+" ]");
 }
 }

 /*
 ** 折半查找，从角标为i的位置开始查找
 */
 public static int halfSearch(int[] arr,int i,int key)
 {
 int min=i, max=arr.length-1, mid=(min+max)/2;
 while(min<=max)
 {
 if(key == arr[mid])
 return mid;
 else if(key > arr[mid])
 min = mid + 1;
 else
 max = mid - 1;
 mid=(min+max)/2;
 }
 return -1;
 }

 /*
 ** 打印数组中相同的元素
 */
 public static void printSame(int[] arr)
 {
 for(int x = 0; x < arr.length; x++)
 {
 int p = halfSearch(arr, x+1, arr[x]);
 if(p!= -1)
 System.out.println("数组中第"+(p+1)+"个元素和第"+(x+1)+"个元素相同为："+arr[x]);

 }

 }

 public static void main(String[] args)
 {

 int n = countSuShu(100); //计算素数的个数

 int[] arr = new int[n+1]; // 定义数组

 for(int x=2;x<100; x++) //找出1——100之间的素数，随机存入一个数组中
 {
 if(isSuShu(x))
 saveIntToArray(arr,x);
 }

 Random r =new Random();
 for(int y = 0; y < arr.length; y++) //将随机产生的素数放入数组元素为0的位置
 {
 if(arr[y]==0)
 {
 int p = r.nextInt(arr.length);
 while(p == y)
 {
 p = r.nextInt(arr.length);
 }
 arr[y] = arr[p];
 break;
 }
 }
 //打印数组
 printArray(arr);

 //打印数组中相同的元素
 printSame(arr);

 }
}

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

下载附件

2013-7-9 20:46 上传

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

下载附件

2013-7-9 20:46 上传

作者: 一木榜公 时间: 2013-7-9 20:53

一木榜公发表于 2013-7-9 00:07
编译结果：

哥们，初学者，不容易啊，给点分吧:handshake

程序中多了个判断是否存在正整数，所以才有了“7这个正整数不存在质因数”
作者: 朱晓杰 时间: 2013-7-9 23:03
俺来猫一猫，顺便顶楼主
作者: 杨彬 时间: 2013-7-9 23:16
版主你好，第一题代码如下
import java.util.ArrayList;

import java.util.List;

import java.util.Scanner;/*

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

*

* 思路：键盘接收数字然后找到该数字内所有质数，再找到该质数该有的个数然后字符串拼接输出

* */

public class Test5 { public static void main(String[] args) {

 Scanner in = new Scanner(System.in);

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

 int num = in.nextInt();

 //定义一个计数集合存放质因数个数

 List<Integer> counts=new ArrayList<Integer>();

 //定义一个质数集合存放质数

 List<Integer> zhiyinshu=new ArrayList<Integer>();



 StringBuilder builder=new StringBuilder();

 builder.append(num+"=");



 getZhiYinShu(num,counts,zhiyinshu);



 int zys=0;

 int count=0;

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

//循环集合回去质数

zys=zhiyinshu.get(i);

//获取个数

count=counts.get(i);

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

builder.append(zys+"*");

}

//判断结尾

if(i<zhiyinshu.size()-1){

builder.append(zys+"*");

}else{

builder.append(zys);

}

 }

System.out.println("结果为：："+builder);

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

private static boolean zhiShu(int num) {

 boolean b = true;

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

if (num % i == 0) {

b = false; // 不是素数直接跳出

break;

}

// 如果是质数就更改标记

b = true;

 }

 return b;

} // 找出该正整数范围内的质因数

private static void getZhiYinShu(int num, List<Integer> counts,

List<Integer> zhiyinshu) {

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

// 判断i是不是输入的这个数的质因数

int numTemp = num;

int count = 0;

if (zhiShu(i) && (numTemp % i == 0)) {

//如果是质因数就存到质因数集合中

zhiyinshu.add(i);

//循环判断因式个数并添加到个数集合

while (numTemp % i == 0) {

 count++;

 numTemp = numTemp / i;

}

counts.add(count);

}

 }

}}

 
复制代码
运行结果如图

QQ图片20130709231550.jpg (3.39 KB, 下载次数: 0)

下载附件

2013-7-9 23:16 上传

第一题运行结果

作者: 杨彬 时间: 2013-7-9 23:19
第二题代码如下
import java.util.HashSet;

import java.util.Iterator;

import java.util.Random;

import java.util.Set;/*

* 求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。（其中n个是求出的各个素数，还有一个是随机添加其中的一个素数）

这样数组中就有相同的两个素数，写一个搜索算法，找出数组中相同的那个素数。（随机添加的素数，可手动指定，也可利用随机方法产生）

(注：存入数组后，数组中的所有元素理论上是无序的，相同的那个素数不一定就等于a[n]，而是被存入了数组中的某个角标上)思路：先定义一个HashSet集合存入100以内的所有质数，然后定义一个长度是（n+1）的数组储存Set集合中的质数

再随机生成一个数组中的素数存到数组最后位置，循环迭代数组并把数据存入一个新的Set集合中并找到与随机产生的

数重复的数字 * */

public class Test6 { public static void main(String[] args) {

 int num = 100;

 Set<Integer> set = getZhiYinShu(num);// 0-24

 Set<Integer> set1 = new HashSet<Integer>();

 System.out.print("1~100所有的质数为：：");

 System.out.println(set); // 将集合中的元素添加到集合中

 int[] arr = setToArray(set);// 0-25

 // 定义随机数r

 Random r = new Random();

 // 将随机生成的角标下的数存入数组中（n+1）处

 arr[arr.length - 1] = arr[r.nextInt(arr.length)];

 System.out.println("随机插入的质数为：：" + arr[arr.length - 1]);

 System.out.println();

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

set1.add(arr[x]);

if (arr[x] == arr[arr.length - 1]) {

System.out.println("添加失败，数字重复：" + arr[x]);

continue;

} else {

System.out.println(arr[x] + "添加成功！");

}

 }

} // 转换集合中的元素到数组中

private static int[] setToArray(Set<Integer> set) {

 int[] arr = new int[set.size() + 1];// 26

 Iterator<Integer> it = set.iterator();

 int i = 0;

 while (it.hasNext()) {

arr[i] = it.next();

i++;

 }

 return arr;

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

private static boolean zhiShu(int num) {

 boolean b = true;

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

if (num % i == 0) {

b = false; // 不是素数直接跳出

break;

}

// 如果是质数就更改标记

b = true;

 }

 return b;

} // 找出该正整数范围内的质因数

private static Set<Integer> getZhiYinShu(int num) { Set<Integer> set = new HashSet<Integer>();

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

if (zhiShu(i)) {

// 如果是质因数就存到质因数集合中

set.add(i);

}

 }

 return set;

}}

 
复制代码
第二题运行结果

QQ截图20130709231847.png (19.92 KB, 下载次数: 0)

下载附件

2013-7-9 23:19 上传

第二题运行结果

作者: 一木榜公 时间: 2013-7-10 08:38

一木榜公发表于 2013-7-9 20:40
2、求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。
（其中n个是求出的各个素数，还有一 ...

白天看视频，晚上做题所以有点赶……呵呵

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2