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

zhou5852 · zhou5852

看看题。。。。

zhou5852 · zhou5852

package org.openscience.zhoubo;
//1、键盘录入一个正整数，将其分解质因数。如：输入30，打印出30=2*3*5。
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
public class exolodeInt {
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
ArrayList<Integer> it = new ArrayList<Integer>();//用来存放分解后的数
System.out.println("请输入一个大于1整数");
StringBuilder conclution = new StringBuilder();//存放字符串
BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
String str = buf.readLine();// 键盘录入
Long long1 = Long.parseLong(str);
long tmp = long1;//临时储存long值
for (int i = 2; i <= long1; i++) {
if (long1%i==0) {
it.add(i); // 如果整除，则将i记录下来同时将值整除
long1 /=i;
i = 2;// 将i重新赋值后进行循环。
}
else {
continue;//否则跳出循环，继续下一次
}
}
int j = it.size();
if (j==1) {
System.out.println("这个数字不能分解");
}
else {
for(int i:it){
conclution.append(i+"*");
}
conclution.deleteCharAt(conclution.length()-1);
System.out.println("该数分解后为"+tmp+"="+conclution);
}
}
}

复制代码

zhou5852 · zhou5852

package org.openscience.zhoubo;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Random;
//2、求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。（其中n个是求出的各个素数，还有一个是随机添加其中的一个素数）
//这样数组中就有相同的两个素数，写一个搜索算法，找出数组中相同的那个素数。（随机添加的素数，可手动指定，也可利用随机方法产生）
//(注：存入数组后，数组中的所有元素理论上是无序的，相同的那个素数不一定就等于a[n]，而是被存入了数组中的某个角标上)
public class 素数 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Random 随机数 = new Random();
ArrayList<Integer> 集合 = new ArrayList<Integer>();//借助于这个主要是用它来模拟动态数组，防止预定义的空间不够。
int count = 0;//计数器用来观察其中非0元素的个数
for (int i = 2; i <=100; i++) {
if(IS素数(i)){
集合.add(i);// 遍历100以内的数字，若是素数就放在集合中
}
}
for (int i:集合) {
if(i != 0){
count++;
}
}
int[] 数组 = new int[count+1];
count=0;
for(int i:集合){
if(i != 0){
数组[count]=i;//将a中不等于0的数组加入到里面
count++;
}
}
数组[count] = 数组[随机数.nextInt(count)];
随机排序数组(数组);
ArrayList<Integer> al2 = new ArrayList<Integer>();
for (int i: 数组) {
if(!al2.contains(i)){
al2.add(i);
}
else {
System.out.println("找到了那个数是"+i);
}
}
}
public static boolean IS素数(int n){
for (int i = 2; i < n; i++) {
if (n%i==0&&i!=n) {
return false;
}
}
return true;
}
public static void 随机排序数组(int[] a) {
Random 随机数 = new Random();//随机数生成器
int j,k,tmp;
for(int i=0;i<=100;i++){// 随机生成角标最后互换两个数字生成乱序的数组；
j=随机数.nextInt(a.length);
k=随机数.nextInt(a.length);
if(j!=k){
tmp = a[j];
a[j] = a[k];
a[k] = tmp;
}
}
}
}

复制代码

周之浩 · 周之浩

package com.itcase.test;
/**
* 1、键盘录入一个正整数，将其分解质因数。如：输入30，打印出30=2*3*5。
*/
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
public class PrimeTest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
try {
print();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void print() throws IOException
{
BufferedReader br =new BufferedReader(new InputStreamReader(System.in));
String str = br.readLine();
int parma = 0;
if(str.matches("\\d+"))
{
parma = Integer.parseInt(str);
}
List<Integer> list = getFactor(parma);
System.out.print(parma +"=");
for(int i = 0 ; i< list.size(); i++)
{
if(i<list.size()-1)
System.out.print(list.get(i)+"*");
else
System.out.print(list.get(i));
}
}
/**
* 方法通过获得传入的要分解的合数，并传入用于存放期分解质数的数组
* @param parma
* @param factor
* @return
*/
public static List<Integer> getFactor(int parma)
{
List<Integer> list = new ArrayList<Integer>();
for(int i = 2;i < parma/2;i++)
{
if(parma%i == 0&& getPrime(i))
{
list.add(i);
}
}
return list;
}
/**
* 判断一个整形数据是否为质数
* @param prime
* @return 是否为质数
*/
public static boolean getPrime(int prime)
{
boolean flag = false;
if(prime == 2)
flag = true;
if(prime > 2)
{
int i = 2;
for(; i <= (int)Math.sqrt(prime);i++)
{
if(prime%i == 0)
{
flag = false;
break;
}
}
if(i>(int)Math.sqrt(prime))
{
flag = true;
}
}
return flag;
}
}
[code]package com.itcase.test;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/**
* 3、在一个文件夹内有文件夹和文件，文件名的格式为：数字+名称.java。
* 要求：把所有的.java文件复制一份，变为文件名格式为：数字+名称+数字.java。
* （其中数字是相对应的，名称由字母组成。如：01Demo.java——>01Demo01.java)
* @author Administrator
*
*/
public class FileCopy {
public static void main(String[] args) {
// TODO Auto-generated method stub
String path = "test";//源文件的目录，这是相对本工程的相对路径
new FileCopy().copyFile(path);
}
/**
* 将指定目录下的文件拷贝到与该文件目录相同的地方，
* 文件名的格式为：数字+名称.java
* 并将文件名改为：数字+名称+数字.java。
* @param path
*/
public void copyFile(String path)
{
File file = new File(path);
File[] files = file.listFiles();//获得目录下的文件列表
BufferedReader br = null;
BufferedWriter bw = null;
for(File fl : files)
{
String fileName =fl.getParent()+File.separator+ this.changName(fl);//拼接文件名
try {
br = new BufferedReader(new FileReader(fl));
bw = new BufferedWriter(new FileWriter(new File(fileName)));
String str = null;
while((str = br.readLine())!= null)
{
bw.write(str);//将内容写出
bw.newLine();//创建一个换行
}
bw.close();
br.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
/**
* 为复制的文件确定名字
* 利用正则表达式的替代功能来确定文件名称
* @param file
* @return
*/
public String changName(File file)
{
String name = file.getName();//源文件的
String rel = "(\\d*)([a-zA-Z]+)\\.java";
//利用正则表达式的替代功能来确定文件名称
name = name.replaceAll(rel, name.substring(0, name.indexOf("."))+"$$1"+name.substring(name.indexOf(".")));
return name;
}
}

复制代码

[

/code]

复制代码

package com.itcase.test;
/**
* 2、求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。（其中n个是求出的各个素数，还有一个是随机添加其中的一个素数）
* 这样数组中就有相同的两个素数，写一个搜索算法，找出数组中相同的那个素数。（随机添加的素数，可手动指定，也可利用随机方法产生）
* (注：存入数组后，数组中的所有元素理论上是无序的，相同的那个素数不一定就等于a[n]，而是被存入了数组中的某个角标上)
*/
import java.util.ArrayList;
import java.util.List;
public class SearchPrime {
public static void main(String[] args) {
// TODO Auto-generated method stub
int reslut = new SearchPrime().searchPrime(100);
System.out.println(reslut);
}
/**
* 判断一个整形数据是否为质数
* @param prime
* @return 是否为质数
*/
public boolean isPrime(int prime)
{
boolean flag = false;
if(prime == 2)
flag = true;
if(prime > 2)
{
int i = 2;
for(; i <= (int)Math.sqrt(prime);i++)
{
if(prime%i == 0)
{
flag = false;
break;
}
}
if(i>(int)Math.sqrt(prime))
{
flag = true;
}
}
return flag;
}
/**
* 将100中的素数加入数组，并在数组的随机位置上添加了一个100以内的随机质数
* @param parma
* @return
*/
public int[] getPrime(int parma)
{
List<Integer> list = new ArrayList<Integer>();
for(int i = 2;i<= parma; i++)
{
if(isPrime(i))
{
list.add(i);//将为素数的元素加入List集合
}
}
int[] primes = new int[list.size()+1];
//random1获得一个List中的一个随机索引
int random1 =(int)(Math.random()*list.size()+1);
//random2将list中获得的一个随机的数加入数组中的速记位置；
int random2 =(int)(Math.random()*list.size()+1);
for(int i = 0; i < list.size()+1; i++)
{
if(i<random2)
{
primes[i] = list.get(i);//
}else
if(i==random2)
primes[i] = list.get(random1);
else primes[i] = list.get(i-1);
}
return primes;
}
/**
* 通过快速排序方法将数组排序，并对数组中存在加入的质数找到
* @param parma
* @return 返回那个素数
*/
public int searchPrime(int parma)
{
int result = 0;
int []primes = this.getPrime(parma);
this.quickSort(primes, 0, primes.length -1);
for(int i = 0; i< primes.length; i++)
{
if(primes[i] == primes[i+1])
{
result = primes[i];
break;
}
}
return result;
}
/**
* 实现数组内两个数值交换
* @param a对应的数组
* @param i数组的下标
* @param j数组的下标
*/
public void change(int a[], int i, int j)
{
if(i==j)
{
return;
}
int tmp = a[i];//实现交换
a[i] =a[j];
a[j] = tmp;
}
/**
*
* @param arr 带排序的数组
* @param low
* @param height
* @return i
*/
public int partition(int arr[],int low,int height)
{
//当前位置为第一个元素所在位置
int p_pos = low;
//采用第一个元素为轴
int pivot = arr[p_pos];
for (int i = low + 1; i <= height; i++) {
if (arr[i] < pivot) {
p_pos++;
change(arr, p_pos, i);
}
}
change(arr, low, p_pos);
return p_pos;
}
/**
* 实现快速排序
* @param arr
* @param low
* @param high
*/
public void quickSort(int arr[], int low, int high)
{
if(low < high)
{
int pivot = partition(arr, low, high);
//System.out.println(pivot);
quickSort(arr, low, pivot-1);
quickSort(arr, pivot+1, high);
}
}
}

复制代码

周之浩 · 周之浩

周之浩发表于 2013-7-13 12:18
[

请说明第三题那个参数出现无效异常
还有第一题，我运行这很正常啊

周之浩 · 周之浩

周之浩发表于 2013-7-13 12:18
[

昨天第一题没搞好测试，真的太马虎啦，下面是我修改了一下的代码

package com.itcase.test;
/**
* 1、键盘录入一个正整数，将其分解质因数。如：输入30，打印出30=2*3*5。
*/
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
public class PrimeTest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
try {
print();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void print() throws IOException
{
BufferedReader br =new BufferedReader(new InputStreamReader(System.in));
String str = br.readLine();
int parma = 0;
if(str.matches("\\d+"))
{
parma = Integer.parseInt(str);
}
List<Integer> list = getFactor(parma);
System.out.print(parma +"=");
for(int i = 0 ; i< list.size(); i++)
{
if(i<list.size()-1)
System.out.print(list.get(i)+"*");
else
System.out.print(list.get(i));
}
}
/**
* 方法通过获得传入的要分解的合数，并传入用于存放期分解质数的数组
* @param parma
* @param factor
* @return
*/
public static List<Integer> getFactor(int parma)
{
List<Integer> list = new ArrayList<Integer>();
int i = 2;
while(i<= parma )
{
if(parma %i == 0 && isPrime(i))
{
list.add(i);
parma = parma/i;
i=2;
}
else
i++;
}
return list;
}
/**
* 判断一个整形数据是否为质数
* @param prime
* @return 是否为质数
*/
public static boolean isPrime(int prime)
{
boolean flag = false;
if(prime == 2)
flag = true;
if(prime > 2)
{
int i = 2;
for(; i <= (int)Math.sqrt(prime);i++)
{
if(prime%i == 0)
{
flag = false;
break;
}
}
if(i>(int)Math.sqrt(prime))
{
flag = true;
}
}
return flag;
}
}

复制代码

Just_Only · Just_Only

支持了。。。

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

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

点评

评分

点评

评分