黑马程序员技术交流社区

标题: ===>送技术分闪亮登场之第一周<===结束 [打印本页]

作者: Just_Only 时间: 2013-6-23 01:46
标题: ===>送技术分闪亮登场之第一周<===结束
本帖最后由 Just_Only 于 2013-6-29 20:41 编辑

{:soso__4011813854091704040_4:}为了能兼顾技术好点的和刚学习不久的，题目分为三个等级

要求:
   1.题目要自己做出来，要写明思路和步骤(可以合在一起)
   2.将程序写的清晰明了.注释到位.
   3.回复的时候把代码贴出来，和运算后结果的图片，
      不会弄图片的贴出结果来，不要蒙混过关，我会检查的，不合格者不给于技术分哦
   4. 需要写出完整代码，不要用几句术语草草了事。
   5.代码放到代码块中,不要压缩包(压缩包没分)
   6.要写注释，没注释的没分...
   7.对于本次活动的题目或是加分，存在异议的可以联系我。。。有奖励的哦...
加分说明:
         题目分为三个等级然后给予相应的分，全部做得四分，简单的各一分，做一半得三分，然后根据答题的排版和格式或是答题个数会酌情的给予特殊的奖励。
附加:

对于简单的题目或是一般的题目我想大神们都懂滴，那么就不要凑热闹的啦!!!每周日更新(持续几周不定)
不说多的啦，上题目的啦，大家踊跃参加的啊，你的支持是我们服务的最大动力哦。

简单:
   1.有一个分数序列：2/1，3/2，5/3，8/5，13/8，21/13…求出这个数列的前20项之和
   2.有五个人坐在一起，问第五个人是多少岁，他说比第四个人大两岁。问第四个人是多少岁，他说比第三个人大两岁。问第三个人是多少岁，他又说比第二个人大两岁.，问第二个人，他又说比第一个人大两岁。问最后一个人，他只是说10岁，请问第五个人多大。
一般:
   1.一球从一百米高度自由下落，每次落地后反跳原来高度的一半，再落下，求它在第10次落地时，共进过多少米？第十次反弹多高？
   2.有1,2,3,4四个数字，能组成多少个互不相同的且没有重复数字的三位数，都是多少，并且将所得的三位数按升序排列并打印。
较难:
   1.将一个正整数分解质因数，例如:输入参数90，打印出90=2*3*3*5；
   2.输入两个正整数m和n，求其最大公约数和最小公倍数。

由于评分标准的更改，给大家带来的不便，请大家谅解，由于经验不足，有考虑不周的地方，希望大家谅解。

作者: 土匪大学生 时间: 2013-6-23 03:23
哈哈...长这么大以来第一次沙发

作者: 卢祥洲 时间: 2013-6-23 07:05
本帖最后由卢祥洲于 2013-6-23 15:06 编辑

楼主重新审核下啊！

/*
有一个分数序列：2/1，3/2，5/3，8/5，13/8，21/13…求出这个数列的前20项之和
*/
public class SumDemo{
public static void main(String[] args){
System.out.println("sum为："+sumFunction(20));
}
//定义求和函数
public static float sumFunction(int n){
//第一步、数据准备
float sum = 0;
float j = 2;
//第二步、for循环求和，其中i为分子，j为分母
for(int i=1;i<=n;i++){
sum = j/i+sum;
System.out.println(sum);
j = j+i;
}
//第三步、返回和值
return sum;
}
}

复制代码

作者: ︶ㄣ紫藤ㄜ︵ 时间: 2013-6-23 07:48

public class Test0 {
/**
 * @param args
 */
public static void main(String[] args) {
 // TODO Auto-generated method stub
 int num, denom; //定义分子和分母
 int a,b;
 double sum; //和

 a = 2; //定义初始值
 b = 1;

 sum = (double)a/b;
 //放到循环中进行计算
 for ( int i=1; i<24; i++ )
 {
num = a + b;
denom = a;

sum = sum + (double)num/denom;

a = num;
b = denom;
 }

 //取小数点后两位
 sum = sum*100;
 sum = sum + 0.5;
 sum = (int)sum;
 sum = (double)sum/100;
 //打印结果
 System.out.printf("这些数的和= %f\n",sum);
}
}
版主辛苦了，请您检阅

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

作者: 、__WSD吴少东 时间: 2013-6-23 07:57

/*
1.有一个分数序列：2/1，3/2，5/3，8/5，13/8，21/13…求出这个数列的前20项之和
思路:
1.由着几个数可以看出,分子和分母都是累加规律, 分子从二开始,分母从1开始,
2.定义分子变量num1,分母变量num=1; 计数器 count=0;
还有一个累加的和sum,因为没怎么学过分数怎么表示,所以就用小数形式表示了.
3.使用for循环进行计算,结束条件是count<20;
*/
class Demo
{
public static void main(String[] args)
{
//定义变量
int num = 1;//分母
int num1 = 2;//分子
int count ;//计数器
double sum = 0;//累加和
for (count=0; count<20;count++ )
{
sum=sum+((num1+count)/(num+count));//求和运算,sum和sum1都需要进行自身的累加.
}
System.out.println("sum="+sum);//输出打印
}
}

复制代码

QQ图片20130623075636.jpg (5.48 KB, 下载次数: 0)

运行结果

作者: vicoooo 时间: 2013-6-23 08:00
简单：
1.有一个分数序列：2/1，3/2，5/3，8/5，13/8，21/13…求出这个数列的前20项之和

//题目1:有一个分数序列：2/1，3/2，5/3，8/5，13/8，21/13…求出这个数列的前20项之和
//1,2,3,5,8..为斐波那契数列
public class Test01 {
public static void main(String args[]){
double sum = getSum(20);
System.out.println(sum);
}
//定义求和方法
public static double getSum(int i){
String output ="";
double sum = 0;
int j = i+2;
for(i=3;i<=j;i++) {
sum += fibonacci(i)/fibonacci(i-1); //求和
output += (int)fibonacci(i)+"/"+(int)fibonacci(i-1)+ "+";//输出控制表达式
}
System.out.print(output.substring(0, output.length()-1)+ "=");//打印表达式
return sum;
}
//求斐波那契(fibonacci)数列
public static double fibonacci(int pos) {
if(pos==1||pos==2) {
return 1;
}else {
return fibonacci(pos-1)+fibonacci(pos-2);
}
}
}

复制代码

2.有五个人坐在一起，问第五个人是多少岁，他说比第四个人大两岁。问第四个人是多少岁，他说比第三个人大两岁。问第三个人是多少岁，他又说比第二个人大两岁。问最后一个人，他只是说10岁，请问第五个人多大。

//题目2：有五个人坐在一起，问第五个人是多少岁，他说比第四个人大两岁。问第四个人是多少岁，他说比第三个人大两岁。问第三个人是多少岁，他又说比第二个人大两岁。问最后一个人，他只是说10岁，请问第五个人多大。
//这是一个递归，但递归效率比较低，所以我同时考虑了for
public class Test02 {
public static void main(String args[]){
int x = fun1(5);
System.out.println("方法一："+x);
int y = fun2(5);
System.out.println("方法二："+y);
}
//采用递归
public static int fun1(int n){
int x = 0;
if(n>1){
x = fun1(n-1)+2;
}else if(n==1){
x = 10;
}
return x;
}
//采用for循环
public static int fun2(int n){
int x = 0;
for(int i=0;i<n;i++){
x = 10 + (n-1)*2;
}
return x;
}
}

复制代码

一般:
1.一球从一百米高度自由下落，每次落地后反跳原来高度的一半，再落下，求它在第10次落地时，共进过多少米？第十次反弹多高？

//中等题目1：一球从一百米高度自由下落，每次落地后反跳原来高度的一半，再落下，求它在第10次落地时，共进过多少米？第十次反弹多高？
//可以采用递归或者for循环
public class GeneralTest1 {
public static void main(String args[]){
System.out.println("第10次落地反弹高度："+fun1(10)+"米");
double sum = 0;
//采用for循环求出总共进过多少米
for(int i=0;i<=10;i++){
sum += fun1(i);
}
System.out.println("10次落地共进过："+sum+"米");
}
//采用递归球反弹高度
public static double fun1(int n){
double height = 0;
if(n==0){
height = 100;
}else if(n>0){
height = fun1(n-1)/2;
}
return height;
}
}

复制代码

2.有1,2,3,4四个数字，能组成多少个互不相同的且没有重复数字的三位数，都是多少，并且将所得的三位数按升序排列并打印。

//中等题目2：有1,2,3,4四个数字，能组成多少个互不相同的且没有重复数字的三位数，都是多少，并且将所得的三位数按升序排列并打印。
public class GeneralTest2 {
public static void main(String args[]){
int count = 0;
//采用for循环,组成多少个互不相同的且没有重复数字的三位数
for(int a=1;a<=4;a++){
for(int b=1;b<=4;b++){
for(int c=1;c<=4;c++){
if(a!=b&&a!=c&&b!=c){
count++;
//按升序排列并打印
System.out.println(a*100+b*10+c);
}
}
}
}
System.out.println("一共有"+count+"位");
}
}

复制代码

较难:
1.将一个正整数分解质因数，例如:输入参数90，打印出90=2*3*3*5；

//较难题目1：将一个正整数分解质因数，例如:输入参数90，打印出90=2*3*3*5
public class HardTest1 {
public static void main(String args[]){
fun1(90);
}
//整数分解质因数
public static void fun1(int num){
int k = 2;
System.out.print(num + "=");
while (num > k) {
if (num % k == 0) {
System.out.print(k + "×");
num = num / k;
}else{
k++;
}
}
System.out.println(k);
}
}

复制代码

2.输入两个正整数m和n，求其最大公约数和最小公倍数。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
//较难题目2：输入两个正整数m和n，求其最大公约数和最小公倍数。
public class HardTest2 {
public static void main(String args[]) throws IOException{
int a,b;
BufferedReader strin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("输入第一个正整数：");
a=Integer.parseInt(strin.readLine());
System.out.print("输入第二个正整数：");
b=Integer.parseInt(strin.readLine());
System.out.println("第一个正整数为"+a);
System.out.println("第二个正整数为"+b);
int c = fun1(a,b);
System.out.println("最大公约数为"+c);
int d = fun2(a,b,c);
System.out.println("最小公倍数为"+d);
}
//求最大公约数--其实就是小的除大的得一个余数，一直这样做，做到剩下的两个数字可以整除.那个大的就是
public static int fun1( int m, int n){
if( m < n ) {
int temp = n;
n = m;
m = temp;
}
if( m % n == 0 )
return n;
else {
m %= n;// m = m%n
return fun1( n, m );
}
}
//最大公倍数
public static int fun2(int m,int n,int a){
return m*n/a;
}
}

复制代码

2013-06-23_075728.jpg (38.65 KB, 下载次数: 0)

2013-06-23_075806.jpg (4.69 KB, 下载次数: 0)

2013-06-23_075840.jpg (11.11 KB, 下载次数: 0)

2013-06-23_075917.jpg (23.24 KB, 下载次数: 0)

2013-06-23_075944.jpg (5.22 KB, 下载次数: 0)

2013-06-23_080021.jpg (11.35 KB, 下载次数: 0)

作者: vicoooo 时间: 2013-6-23 08:13
一般:
1.一球从一百米高度自由下落，每次落地后反跳原来高度的一半，再落下，求它在第10次落地时，共进过多少米？第十次反弹多高？
由于是求第十次落地时共进多少米，所以这题答案修改为：

//中等题目1：一球从一百米高度自由下落，每次落地后反跳原来高度的一半，再落下，求它在第10次落地时，共进过多少米？第十次反弹多高？
//可以采用递归或者for循环
public class GeneralTest1 {
public static void main(String args[]){
System.out.println("第10次落地反弹高度："+fun1(10)+"米");
double sum = 0;
//采用for循环求出总共进过多少米
//第10次落地时
for(int i=0;i<10;i++){
sum += fun1(i);
}
System.out.println("10次落地时共进过："+sum+"米");
}
//采用递归球反弹高度
public static double fun1(int n){
double height = 0;
if(n==0){
height = 100;
}else if(n>0){
height = fun1(n-1)/2;
}
return height;
}
}

复制代码

2013-06-23_081249.jpg (11.92 KB, 下载次数: 0)

作者: 王靖远 时间: 2013-6-23 10:31
做了难的再做简单的不会都给分是吗？

作者: Just_Only 时间: 2013-6-23 11:11
本帖最后由 Just_Only 于 2013-6-23 11:19 编辑

王靖远发表于 2013-6-23 10:31
做了难的再做简单的不会都给分是吗？

不是这样的，如果你要做的话，也是可以的，只是我觉得技术好点的简单的可以不用做的。

作者: Just_Only 时间: 2013-6-23 11:18

土匪大学生发表于 2013-6-23 03:23
哈哈...长这么大以来第一次沙发

答题啊，简单的应该会的吧

作者: Just_Only 时间: 2013-6-23 11:23

︶ㄣ紫藤ㄜ︵发表于 2013-6-23 07:48
public class Test0 {
/**
* @param args

请把代码放到添加代码那个框中，或是把排版排一下。

作者: 王靖远 时间: 2013-6-23 11:59

import java.util.*;
class Debug5
{
public static void main(String[] args)
{
ArrayList<Integer>list = new ArrayList<Integer>();
list = method_1(90,list);
print(90,list);
}
public static void print(int num,ArrayList<Integer>list)//按指定样式打印
{
StringBuilder sb = new StringBuilder();
sb.append(num+"=");
for(int x=0;x<list.size()-1;x++)
{
sb.append(list.get(x)+"*");
}
sb.append(list.get(list.size()-1)+";");
System.out.println(sb.toString());
}
public static boolean suShu(int i)//定义一个判断是否为素数的方法。
{
int count = 0;
if (i == 1)
return false;
for(int x=1;x<=i;x++)
{
if((i%x)==0)
count++;
}
if(count>2)
return false;
else
return true;
}
public static ArrayList<Integer> method_1(int num,ArrayList<Integer>list)//求因子的方法。
{
int i = 0;
for(int x=2;x<num;x++)//循环找因子
{
if(num%x==0)
{
i = x;
break;
}
}
if(!suShu(num/i))//判断是否为素数，如不是就递归
method_1(num/i,list);//这里用到递归
list.add(i);//把求到的因子添加到集合里。
Iterator<Integer>it = list.iterator();
int z =num;
while(it.hasNext())
{
int in = it.next().intValue();//找最后一个因子。因为之前的循环会漏掉最后一个因子。
z = z/in;
}
if(suShu(z))
list.add(z);
return list;
}
}

复制代码

作者: 王靖远 时间: 2013-6-23 12:57

import java.util.*;
class Debug6
{
public static void main(String[] args)
{
printResult(6,8);
}
public static void printResult(int m,int n)//打印方法。
{
int max = 0;
int min = 0;
ArrayList<Integer> list = new ArrayList<Integer>();
list = quChong(m,n);
max = list.get(list.size()-1);
min = m/max*n;
System.out.println(m+"和"+n+"的最大公约数是"+max);
System.out.println(m+"和"+n+"的最小公倍数是"+min);
}
public static ArrayList<Integer> quChong(int m,int n)//对两个数组取相同合并为一个数组，然后去重复排序
{
ArrayList<Integer>newList = new ArrayList<Integer>();
ArrayList<Integer>list1 = new ArrayList<Integer>();
ArrayList<Integer>list2= new ArrayList<Integer>();
list1 = getList(m,list1);
list2 = getList(n,list2);
Iterator<Integer> it = list1.iterator();
while(it.hasNext())
{
Integer integer = it.next();
if(list2.contains(integer) && !newList.contains(integer))
newList.add(integer);
}
Collections.sort(newList);
return newList;
}
public static ArrayList<Integer> getList(int num,ArrayList<Integer>list)//用递归方法获取所有因子。
{
int i = 0;
for(int x=2;x<num;x++)//循环找因子
{
if(num%x==0)
{
i = x;
break;
}
}
if(!suShu(num/i))//判断是否为素数，如不是就递归
getList(num/i,list);//这里用到递归
list.add(i);//把求到的因子添加到集合里。
Iterator<Integer>it = list.iterator();
int z =num;
while(it.hasNext())
{
int in = it.next().intValue();//找最后一个因子。因为之前的循环会漏掉最后一个因子。
z = z/in;
}
if(suShu(z))
list.add(z);
list.add(1);
list.add(num);
return list;
}
public static boolean suShu(int i)//定义一个判断是否为素数的方法。
{
int count = 0;
if (i == 1)
return false;
for(int x=1;x<=i;x++)
{
if((i%x)==0)
count++;
}
if(count>2)
return false;
else
return true;
}
}

复制代码

作者: 金辉 时间: 2013-6-23 16:33
1.将一个正整数分解质因数，例如:输入参数90，打印出90=2*3*3*5；

import java.util.Scanner;
public class Demo1 {
public static void fen(int num){
for(int i=2;i<num/2;i++){//这个数除以从2开始的每一位数，找到最小的可以整除的数后，输出该除数，用相除后的数作为新的参数继续往下找
if(num%i==0){ //直到这个数的一半时停下，因为过半后，就会重复
System.out.print(i+"*");
fen(num/i);} //
}
System.out.print(num);//递归中出来后得到n-1个质因数，最后的第n个质因数不满足循环条件退出，所以这里必须输出
System.exit(0);//由于递归有回溯的性质，它不会在程序结束时结束，而是回溯完所有的之后才退出，所以当它遍历到最后开始回溯前强制结束
//如果少了这句，程序必然出错
}
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入要分解的数字：");
int num=sc.nextInt();//输入要分解的数字，保存在num中
System.out.print(num+"=");
fen(num);
}
}

复制代码

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

作者: ㄗs：/|丶hearts 时间: 2013-6-23 18:48
本帖最后由ㄗs：/|丶hearts 于 2013-6-23 18:52 编辑

将一个正整数分解质因数

package com.java.test;
import java.util.*;
public class Demo {
/**
* @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++;
}
}
}
}

复制代码

2868-593a3658133336224599430c2a9f011c5510.jpg (2.8 KB, 下载次数: 0)

4049-9b34b63b164978253ffa59c3c2bbfce61867.jpg (3.95 KB, 下载次数: 0)

作者: 土匪大学生 时间: 2013-6-23 20:49
我回来啦，做了一天，有些高估自己了。我会更努力的！

/*
题目：将一个正整数分解质因数，例如:输入参数90，打印出90=2*3*3*5；

思路：
1，创建一个Factoring类。
2，每分解一次参数后，判断其是否为素数。若为素数，则表示分解到最小。
3，输入参数x，在运行后有“x的质因数为: x=a*v*c*e”字样显示出来。

步骤：
1，定义Factoring类。包涵有
(1、Prime()方法---判断是否为素数，
(2、PrimeMaking()素数生成器————用来作为短除法的质因数，
(3、Factor()方法。
(4、输出结果方法
2，定义主函数。
public static void main(String[] args)这时固定格式的。
3，为了显示具体字样，可以通过使用输出语句：System.out.println("hello world");

*/
import java.util.*;
class Factoring
{
static int PrimeValue=1; //用于暂时存储质因数
public static boolean Prime(int p)//判断参数是否为素数
{ int b = 2;
if(p<=3)//1，2，3不用判断
return true;
for(;(p % b != 0);++b){}//只能被自身整除的为素数，是返回true，反之false。
if(b==p)
return true;
else
return false;
}
public static int PrimeMaking()//素数生成器
{
do//如果PrimeValue不是素数，就增1,直至为素数。
{
PrimeValue++;
}while(!Prime(PrimeValue));
return PrimeValue;

}
public static void Factor(int key)//分解质因数，
{
System.out.print("分解质因数得 "+key+" = ");
while(!Prime(key))//判断key是否为素数，若是则输出1和key，否则执行下去。
{
int PM=PrimeMaking();//生成一个待判断的、自增的质因数。
if(key%PM == 0)//若key可以整除，则还可以继续分解。
{
SOP(PM);
key=key/PM;
// Factor(key);
PrimeValue=1;//初始化下一个质因数。
}
}
System.out.print(key);
}
public static void SOP(Object obj)//输出函数
{
System.out.print(obj+"x");
}

public static void Make()
{
try
{
int a;
Scanner sc=new Scanner(System.in);
a=sc.nextInt();////用于存储从键盘获取的整数
if(a>0&&a%1==0)
{
if(!Prime(a))
Factor(a);//如果a是非素数，则调用Factor函数
else
System.out.println("分解质因数得 "+a+" = 1x"+a);
}
else
{
System.out.println("请输入一个正整数!");
a=sc.nextInt();//获取一个数
}
}
catch(Exception e)
{
System.out.println("请输入一个正整数!");
}
}
public static void main(String[] args)
{
Make();
}
}

写得不是特别好，还有可以改进的地方。
运行结果截图

作者: 陈鹏 时间: 2013-6-23 23:56
.输入两个正整数m和n，求其最大公约数和最小公倍数。

class Demo1
{
public static void main(String[] args)
{
int m=gcd(4,8);
int n=lcm(4,8);
System.out.println("最大公约数是:"+m);
System.out.println("最小公倍数:"+n);
}
//用辗转相除法可以求得最大公约数
static int gcd( int m, int n )//最大公约数
{
if( m < n )
{
int temp = n;
n = m;
m = temp;
}
if( m % n == 0 )
return n;
else
{
m %= n;//这里就是辗转相除
return gcd( n, m );
}
}
//最小公倍数 = 两个数的积 / 最大公约数
static int lcm(int a, int b) //最小公倍数
{
return a*b/gcd(a,b);
}
}

复制代码

捕获.PNG (39.86 KB, 下载次数: 0)

作者: 万琪 时间: 2013-6-24 01:08
较难:
1.将一个正整数分解质因数，例如:输入参数90，打印出90=2*3*3*5；
2.输入两个正整数m和n，求其最大公约数和最小公倍数。

求六分哦！！！！！！

package heima;
import java.util.Scanner;
public class Test02 {
public static void main(String[] args) {
Test02 te = new Test02();
System.out.println("第一题：");
System.out.print("输入一个数：");
Scanner input = new Scanner(System.in);
int x = input.nextInt();
te.fjz(x);
System.out.println("\n第二题：");
System.out.println("输入两个数：");
int a = input.nextInt();
int b = input.nextInt();
te.dell(a, b);
}
/*
* 求一个数的分解质因数
*/
public void fjz(int x) {
// 最小的质数是2
int k = 2;
System.out.print(x + "=");
while (x >= k) {
if (x == k) {
System.out.print(x);
break;
} else if (x % k == 0) {
// 质因数
System.out.print(k + "*");
// x除以了k
x /= k;
} else {
k++;
}
}
}
/*
* 求两个数的最大公约数，最小共倍数
*/
public void dell(int a, int b) {
// 保存原数
int A = a;
int B = b;
// 最小公倍数为a,b的积除以最大共约束
// m为最大公约数
int m = 1;
// n为最小公倍数
int n = 1;
// a>=b
if (b > a) {
int temp = a;
a = b;
b = temp;
}
// a除以b,余数再被b除，，循环，，直到，可以除尽，被除数即为m
while (b != 0) {
if (a == b) {
m = a;
break;
} else {
int temp = a % b;
a = b;
b = temp;
}
}
m = a;
n = A * B / m;
System.out.println("最大公约数：" + m);
System.out.println("最小公倍数：" + n);
}
}

复制代码

结果：：

第一题：
输入一个数：90
90=2*3*3*5
第二题：
输入两个数：
12
18
最大公约数：6
最小公倍数：36

复制代码

作者: liguangcaiup 时间: 2013-6-24 09:40

public class lianxi {
public static void main(String[] args) {
lianxi1();
lianxi2();
lianxi3();
}
public static void lianxi1() {
int fenzi = 2;
int fenmu = 1;
int t;
double result = 2;
for (int i = 0; i < 19; i++) { // 第一次已经初始化，循环19次
t = fenzi;
fenzi += fenmu; // 新分子
fenmu = t; // 新分母
result += result; // 迭代一次后的结果
}
System.out.println("第一题结果:"+result); // 打印结果
}
// 题目中第二个人与第一个人之间的关系不确定，默认也是差2？
public static void lianxi2() {
int firstAge = 10; // 第一个人年龄
int result = 0;
result = 2 * 4 + firstAge; // 求地5个人年龄
System.out.println("第二题结果:"+result);
}
public static void lianxi3() {
double base = 100;
double sum = base;
for (int i = 2; i <= 10; i++) {
sum += base; // 下一次落地是运动的总距离
base /= 2; // 下一次跳起的高度
}
System.out.println("第三题结果:"+sum + "::"+ base); // 打印总高度和第十次跳起高度
}
}

复制代码

先做前三题

QQ截图20130624093943.jpg (45.37 KB, 下载次数: 0)

作者: Just_Only 时间: 2013-6-24 10:14

liguangcaiup 发表于 2013-6-24 09:40
先做前三题

只有第二题结果是对的，其它结果错误。

作者: fycrik 时间: 2013-6-24 12:39
先收藏留着慢慢回答问题

作者: 王楚鑫 时间: 2013-6-24 13:26
本帖最后由王楚鑫于 2013-6-24 13:32 编辑

/*
有一个分数序列：2/1，3/2，5/3，8/5，13/8，21/13…求出这个数列的前20项之和
*/
public class Seque
{
public static void main(String args[])
{
int fenzi, fenmu; //定义分子和分母
double sum; //定义序列之和
fenzi = 2; //初始值
fenmu = 1;
sum = (double)fenzi/fenmu;
int n; //用于记录累加的次数
for (n=1; n<20; n++ ) //求数列前20项之和，即进行累加20次
{
fenzi=fenzi+fenmu;
fenmu=fenzi-fenmu;
sum += (double)fenzi/fenmu;
}
System.out.println("分数序列的前20项之和为："+sum);
}
}

复制代码

第二题

/*
2.有五个人坐在一起，问第五个人是多少岁，他说比第四个人大两岁。问第四个人是多少岁，他说比第三个人大两岁。问第三个人是多少岁，他又说比第二个人大两岁。问最后一个人，他只是说10岁，请问第五个人多大
*/
public class Age
{
public static void main(String args[])
{
int []age=new int[6]; //定义一个数组保存五个人的年龄，age[i]表示第i个人的年龄
age[1] = 10; //初始化第一个的年龄
int i;
for (i=2; i<6; i++) // 从第2个人开始一直到第5个人，他们都比上一个人大2岁
{
age[i]=age[i-1]+2;
}
System.out.println("第五个人的年龄为：" +age[5] );
}
}

复制代码

第三题

/*
3.一球从一百米高度自由下落，每次落地后反跳原来高度的一半，再落下，求它在第10次落地时，共进过多少米？第十次反弹多高？
*/
public class Ball
{
public static void main(String args[])
{
double sum=100.00; //定义小球一共经过的长度，第一次落地时已经走过100米
double height=sum/2; //定义小球第一次落地时反弹的高度
for(int i=2;i<=10;i++) //循环控制小球落地10次
{
sum=sum+2*height; //累加，每一次小球弹起又下落经过的长度
height=height/2; //每次小球落地后反弹原来高度的一半
}
System.out.println("在第10次落地时，共经过"+sum +"米");
System.out.println("第10次反弹"+height+"米");
}
}

复制代码

第四题

/*
4.有1,2,3,4四个数字，能组成多少个互不相同的且没有重复数字的三位数，都是多少，并且将所得的三位数按升序排列并打印。
*/
public class Figure
{
public static void main(String args[])
{
int n=0; //统计满足条件的三位数的个数
int i,j,k; //定义三层嵌套循环，分别组成三位数、保证组成的三位数没有重复的
for(i=1;i<=4;i++)
{
for(j=1;j<=4;j++)
{
for(k=1;k<=4;k++)
{
if(i!=j&&j!=k&&i!=k) //保证三位数的各个位上没有重复的数字
{
System.out.print(i+""+j+""+k+",");
n++; //符合条件的数字个数累加
if(n%6==0) //控制打印格式、6个数字为一行
System.out.println();
}
}
}
}
System.out.println("综上，共有满足条件的三位数："+n+"个");
}
}

复制代码

第六题

/*
输入两个正整数m和n，求其最大公约数和最小公倍数
*/
public class Gcd_Lcm
{
public static void main(String args[])
{
int a,b,num1,num2,temp;
System.out.println("please input two numbers:");
//java的输入语句、忘了呢、先直接赋值吧
num1=4;
num2=6;
int lcm=num1*num2; //存放最小公倍数
if(num1<num2) //保证大数放在num1中
{
temp=num1;
num1=num2;
num2=temp;
}
int r=num1%num2; //定义余数，大数除小数，当余数为0时的除数即为两数的最大公约数
while(r!=0) //辗除相除法求最大公约数
{
num1=num2;
num2=r;
r=num1%num2;
}
System.out.println("gcd:"+num2);
System.out.println("lcm:"+lcm/num2); //最小公倍数=数A*数B/最大公约数
}
}

复制代码

运行时截图

QQ截图20130624132544.png (11.75 KB, 下载次数: 0)

作者: pys200603027 时间: 2013-6-24 13:42
较难题1：

import java.util.Scanner;
public class test5 {
public static void main(String[] args){
int m,k;
System.out.print("please enter a number:");
Scanner in=new Scanner(System.in);
m=in.nextInt();//获取输入的数据
System.out.print(m+"=");
for(k=2;k<m;){
if(m%k!=0){//没有被整除，说明没有找到因数，K自增1
k++;
}
else{
System.out.print(k+"*");//找到因素，打印
m=m/k;//去掉找到的因素
k=2;//k重新从2开始
}
}
System.out.println(k);
}
}

复制代码

题1截图

较难题2：

import java.util.Scanner;
public class test6 {
/**
* 求最小公倍数
* @param n
* @param m
* @return
*/
private static int minBs(int n,int m){
int temp=0;
for(int i=n;i<=n*m;i++){//令i的值在n和m*n之间
if(i%n==0&&i%m==0){//i能同时整除n和m的，i就是最小公倍数
temp=i;
break;//之间跳出循环
}
}
return temp;//返回最小公倍数
}
/**
* 求最大公约数
* @param n
* @param m
* @return
*/
private static int maxYs(int n,int m){
int temp=0;
for(int i=1;i<m;i++){
if(n%i==0&&m%i==0)//如果n和m同时能整除同一个i
temp=i;//将i值赋给临时变量temp
}
return temp;//返回循环结束最后的数值temp即是最大公约数
}
public static void main(String[] args){
int n,m;
System.out.print("please enter the first number:");
Scanner in=new Scanner(System.in);//获取第一个输入的数字
n=in.nextInt();
System.out.print("\nplease enter the second number:");
m=in.nextInt();//获取第二个输入的数字
if(n<m){//如果输入的第一个数小于第二个输入的数，调换一下
int temp=n;
n=m;
m=temp;
}
int min=minBs(n,m);//调用求最小公倍数函数
System.out.println("最小公倍数："+min);
int max=maxYs(n,m);//调用求最大公约数函数
System.out.println("最大公约数："+max);
}
}

复制代码

题2截图：

作者: 张云杰 时间: 2013-6-24 19:59
较难的我放弃了.. 10几年没学数学了忘了.. 表示这个真不会了

TestOne.rar

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

作者: 张云杰 时间: 2013-6-24 20:00
希望版主等下能贴个较难的答案出来.. 我也顺便复习下小学的数学

作者: lou413 时间: 2013-6-24 20:39

运行结果

第二题

运行结果

作者: 王楚鑫 时间: 2013-6-24 20:42
本帖最后由王楚鑫于 2013-6-25 13:04 编辑

第五题

/*
5.将一个正整数分解质因数，例如:输入参数90，打印出90=2*3*3*5；
*/
public class Factor
{
public static void main(String args[])
{
int i;
int n=16; //输入语句给忘了、先直接赋值了
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); //输出使循环结束的质因数
}
}

复制代码

作者: lou413 时间: 2013-6-24 22:37

运行结果

作者: ㄗs：/|丶hearts 时间: 2013-6-24 23:03
本帖最后由ㄗs：/|丶hearts 于 2013-6-29 12:25 编辑

package com.java.test;
import java.util.Scanner;
public class Fraction {
/**
* @param args
* 有一个分数序列：2/1，3/2，5/3，8/5，13/8，21/13…求出这个数列的前20项之和
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("--计算一个分数序列的前n项和--");
System.out.println("请输入一个正整数n：");
//从控制台读取输入的数字
Scanner s = new Scanner(System.in);
int n = s.nextInt();
System.out.println("这个分数序列的前n项的和为："+method(n));
}
public static double method(int n)
{
double sum = 0.0;
//double x = 2.0,y = 1.0;
int x = 2,y = 1;
for(int i = 0; i< n;i++)
{
//将x/y的结果强制转换成double
sum += (double)x/y;
//将x的值保留赋给s
int s = x;
//将x+y赋给x 作为下一个数的分子
x = x+y;
//将分子的值赋给y 作为下个数的分母
y = s;
}
return sum;
}
}

复制代码

QQ图片20130624230232.jpg (11.11 KB, 下载次数: 0)

作者: 土匪大学生 时间: 2013-6-25 04:12
终于调试好了，那个ArrayList《Integer》找了好久。本想继承之前做的Factoring类的，但是忘记了{:soso_e101:}，不过，现在正在复习，以后会修改的会把扩展性做到更好！先上传。。。

/*
题目：输入两个正整数m和n，求其最大公约数和最小公倍数。

思路：
1，用质因数分解法：把每个数分别分解质因数，再把各数中的全部公有质因数提取出来连乘，所得的积就是这几个数的最大公约数。再把两个正整数中的全部公有的质因数和独有的质因数提取出来连乘，所得的积就是这几个数的最小公倍数
2，可以重用Factoring类。
3，只要将两个正整数的公有质因数放入一个ArrayList<Integer>集合，然后将元素连乘即得到最大公约数。同时，从两集合中删掉公有质因数。
4，得到最大公约数后，最小公倍数就是用最大公约数x独有的质因数。
3，输入参数m，n，在运行后输出：最大公约数为：xx, 最小公倍数为：xx字样显示出来。

步骤：

1，在Factoring类的基础上，修改Make()方法.
(1、定义三个ArrayList<Integer>集合类型的变量。
(2、获取两正整数后分别调用Factor()方法，得到两正整数的分解质因数。将M的分解质因数存于集合ali_m,将N的分解质因数存于集合ali_n.
(3、将两集合公有质因数存于集合ali_get.
(4、将公有质因数连乘得，最大公约数; 再将最大公约数与M、N独有质因数连乘，得最小公倍数。
(5、输出结果方法

*/
import java.util.*;
class Factoring
{
static int PrimeValue=1; //用于暂时存储质因数
public static boolean Prime(int p)//判断参数是否为素数
{ int b = 2;
if(p<=3)//1，2，3不用判断
return true;
for(;(p % b != 0);++b){}//只能被自身整除的为素数，是返回true，反之false。
if(b==p)
return true;
else
return false;
}
public static int PrimeMaking()//素数生成器
{
do//如果PrimeValue不是素数，就增1,直至为素数。
{
PrimeValue++;
}while(!Prime(PrimeValue));
return PrimeValue;

}
static ArrayList Factor(int key)//功能：给定一个正整数，调用SOP(ArrayList)可得获得正整数的分解质因数。
{
ArrayList<Integer> al = new ArrayList<Integer>();

while(!Prime(key))//判断key是否为素数，若是则输出1和key，否则执行下去。
{
int PM=PrimeMaking();//生成一个待判断的、自增的质因数。
if(key%PM == 0)//若key可以整除，则还可以继续分解。
{
al.add(PM);
key=key/PM;
PrimeValue=1;//初始化下一个质因数。
}
}
// System.out.print(key);
al.add(key);
al.add(1);//当正整数有一个或两个是素数时，最大公约数是1

return al;

}

public static void Make()
{
try
{
int M,N;
Scanner sc=new Scanner(System.in);
System.out.println("请输入两个正整数!");
System.out.println("M=");
M=sc.nextInt();
System.out.println("N=");
N=sc.nextInt();////用于存储从键盘获取的整数
if((M>0&&M%1==0) && (N>0&&N%1==0) )//判断是否为正整数。
{
int HCF=1,LCM=1;//要初始化为1!
// ArrayList<Integer> ali_demo = new ArrayList<Integer>();
ArrayList<Integer> ali_get = new ArrayList<Integer>();
ArrayList<Integer> ali_m = new ArrayList<Integer>();
ArrayList<Integer> ali_n = new ArrayList<Integer>();
ali_m = Factor(M);//将M的分解质因数存于集合ali_m
ali_n = Factor(N);//将N的分解质因数存于集合ali_n
for (int m=0; m<ali_m.size(); m++ )//forfor的功能：将两集合公有质因数存于一个集合，同时删除在两集合ali_n、ali_m公有质因数。
{
for (int n=0; n<ali_n.size() ;n++ )
{
if(ali_m.get(m)==ali_n.get(n))//如果两集合中的质因数相同，则放到用于存储公因数集合ali_get中。
{
ali_get.add(ali_n.get(n));
ali_m.remove(m);
ali_n.remove(n);
n--;//此语句很重要!如ali_n：2,2,2,3；ali_m:2,2,3,5。当比较完第0个元素后，因为相等，会删掉两集合的第0个元素，
//当再次执行if语句时，n的值已是1，这样会跳过第0个元素!
}
}
}
for (int j=0,k=ali_get.size();j<k ; j++)//将公有质因数连乘得，最大公约数。
{
LCM=LCM*ali_get.get(j);
}
HCF=LCM;//把最大公约数赋给HCF
for (int j=0,k=ali_m.size();j<k ; j++)//将最大公约数与M独有质因数相乘
{
LCM=LCM*ali_m.get(j);
}
for (int j=0,k=ali_n.size();j<k ; j++)//将N独有质因数与最大公约数与M独有质因数连乘
{
LCM=LCM*ali_n.get(j);
}
System.out.println("["+M+" "+N+"] "+"最大公约数为："+HCF+" , "+"最小公倍数为："+LCM);//输出结果

}
else
{
System.out.println("请输入正整数!");
System.out.println("M=");
M=sc.nextInt();
System.out.println("N=");
N=sc.nextInt();
}
}
catch(Exception e)
{
System.out.println("Exception e请输入正整数!");
}
}

public static void main(String[] args)
{
Make();
// method();
}

}

运行结果

作者: 金辉 时间: 2013-6-25 08:07
我做的三分的题，你刚开始加了3分，又减掉，加一分，请问版主是什么意思

作者: Just_Only 时间: 2013-6-25 08:35

金辉发表于 2013-6-25 08:07
我做的三分的题，你刚开始加了3分，又减掉，加一分，请问版主是什么意思

请看上面的说明，我上面说的很清楚的哦，请谅解。

作者: 金辉 时间: 2013-6-25 08:37
帖子是不可见的，我看不到啊

作者: emos-c 时间: 2013-6-25 09:02
简单：1.
需求：有一个分数序列：2/1，3/2，5/3，8/5，13/8，21/13…求出这个数列的前20项之和
思路：
1.首先找规律：发现从第二个数开始，每个数的分子都是上一个数的分子分母之和；分母则是上一个数的分子。于是可以定义分子为x，分母为y。
初始化赋值x=2,y=1;
2.要想所有的数字都可以用x/y来表示，就需要每次对x，y重新赋值。可以通过第三方变量来实现temp=x;x=x+y;y=x;
3.因为要求前20项之和，需要使用累加思想。累加思想一般都要用到循环结构，于是定义了一个变量z来进行累加的动作，初始化z=0；z<20.又
定义了sum记住每次变化的结果。

class Test1
{
public static void main(String[] args)
{
double sum=0;//由于x/y的结果不一定是整数，所以定义了double类型来存储
for (int x=2,y=1,z=0;z<20 ;z++ )//累加思想需要使用到循环结构，z是用于进行累加20次的动作
{
sum=sum+x/y;
int temp=x; x=x+y; y=temp;//对x和y进行重新赋值
}
System.out.println("该数列前20项之和是"+sum);
}
}
//打印结果是“该数列前20项之和是21.0”。

复制代码

这道题我定义了x，y，z，temp，sum五个变量，自己觉得有点多，但是没找到优化的方法。活动结束以后楼主将帖子回复修改为所有人可见
我觉得很有帮助，这样就可以借鉴别人的方法是不是更好，对自己不会做的题目也可以学习一下别人的思路，有助于我们学习。

一般：1.
需求：一球从一百米高度自由下落，每次落地后反跳原来高度的一半，再落下，求它在第10次落地时，共进过多少米？第十次反弹多高？
思路：
1.定义一个变量h记住球每次下落时的高度，初始化double h=100;所以每次反跳的高度是h=h/2;
2.想要知道第十次落地时共经过多少米，就需要知道每一次落下和反跳的高度，所以使用累加思想，定义一个一个变量z来进行累加的动作，
初始化z=0；z<10.又定义了sum记住每次下落和弹起的总高度。
3.第十次落地后并未反跳，所以需要将第十次的反跳高度(h/2)减去就可以得到总高度了，第十次反跳高度也即为h/2.

class Test2
{
public static void main(String[] args)
{
double h=100,sum=0;
for (int x=0;x<10 ;x++ )
{
sum=sum+h+h/2;//由sum来记录每一次下落反跳的总高度
h=h/2;//本次的反跳高度即是下次的下落高度，每次高度减半
}
sum=sum-h/2;//第十次落地时没有反跳，需要将这段高度减去
System.out.println("第十次落地时小球共经过"+sum+"m；第十次反弹高度为"+h+"m");
}
}
//打印结果是“第十次落地时小球共经过299.658203125m；第十次反弹高度为0.09765625m”。

复制代码

第一次上传图片，担心出问题，所以把结果都在代码里写出来了。
现在刚看完异常其它题目不知道是自己水平不够还是用到了没学到的知识，暂时都没做出来，我最好奇的是简单里的第二题，我觉得压根做不出来的呀，坐等结果公布后看看别人的代码学习学习。

作者: 金辉 时间: 2013-6-25 09:31
算了，各种不方便，我看不到你回复的，又不能发消息。几个技术分而已，不在乎。还有那题没必要去抄，你发贴前一天我就做过了，以前蓝桥杯的一道题目而已

作者: 关亮何 时间: 2013-6-25 10:03
本帖最后由关亮何于 2013-6-26 19:05 编辑

简单的第一题：

public class test1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//定义sum为数列之和的变量
float sum = 0;
//第一项的分母a1,分子a2
int a1 = 1;
int a2 = 2;
//定义一个长度为20的数组。
float[] b = new float[20];
//循环20遍
for (int i = 0; i < b.length; i++) {
b[i]= (float)a2/a1;
sum +=b[i];
//后一项分子是前一项分子分母之和，分母为前一项的分子。
int temp = a2;
a2 =a1+a2;
a1 = temp;
}
System.out.println("这个数列的前20项之和:"+sum);
}
}

复制代码

运行结果：这个数列的前20项之和:32.660263
简单的第二题：

public class test2 {
/**
* 思路：定义一个方法，age(1)返回的是10，而age(n)=age(n-1)+2，即前面的人+2岁得后一项。
* @param args
*/
//定义一个age(n)方法
public static int age(int n){
int old;
if(n==1){
//age(1)=10,即最后一个人为10岁
old = 10;
}else{
//后面比前面的人大2岁
old = age(n-1)+2;
}
return old;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("第五个人的岁数为"+age(5));
}
}

复制代码

运行结果：第五个人的岁数为18

一般的第一题：

public class test2 {
//求这个球反跳的高度
public static float height(int n){
float h=0;
if (n==1) {
//第一次落地时反跳的高度
h=100/2;
}else{
//后面反跳的高度为前面一次的高度一半。
h= height(n-1)/2;
}
return h;
}
//求这个球所有运行轨迹的长度。
public static float total(int n){
float t=0;
if (n==1) {
//第一次落地的长度
return 100;
}else{
//把除了第一次所有的落地前一弹一落相加。
for (int i = 2; i <= n; i++) {
//落地前的一弹一落长度是落地后反弹高度的4倍
t += height(i)*4;
}
return t+100;
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("第10次反弹的高度为:"+height(10));
System.out.println("第10次所有的运行长度为："+total(10));
}
}

复制代码

第10次反弹的高度为:0.09765625
第10次所有的运行长度为：299.60938
一般的第二题：

public class test4 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//一个数组放1，2，3，4这四个数
int[] nums = new int[]{1,2,3,4};
//组成的新数放进newnums数组中
int[] newnums = new int[100];
int count=0;
//i是新数的百位数，j是新数的十位数，k是新数的个位数
for (int i = 0; i < nums.length; i++) {
for (int j = 0; j < nums.length; j++) {
//如果百位、十位数相同就跳过
if (nums[i]==nums[j]) {
continue;
}
for (int k = 0; k < nums.length; k++) {
//如果百位、个位相同或十位、个位相同就跳过
if (nums[i]==nums[k]||nums[j]==nums[k]) {
continue;
}
for (int k2 = 0; k2 < newnums.length; k2++) {
//把组成的新数放进为0的数组元素中。
if (newnums[k2]==0) {
newnums[k2]=nums[i]*100+nums[j]*10+nums[k];
count++;
break;
}
}
}
}
}
System.out.println("这样的数的个数有"+count);
System.out.println("这些数是：");
for (int i = 0; i < count; i++) {
System.out.print(newnums[i]+"\t");
}
}
}

复制代码

这样的数的个数有24
这些数是：
123 124 132 134 142 143 213 214 231 234 241 243 312 314 321 324 341 342 412 413 421 423 431 432

作者: 张云杰 时间: 2013-6-25 11:14
package com.work.cloudy;

import java.awt.List;
import java.util.TreeSet;

/*
* 1.有一个分数序列：2/1，3/2，5/3，8/5，13/8，21/13…求出这个数列的前20项之和
*/
public class TestOne {
public static void main(String[] args) {
// sumOne();
// sumTwo();
// System.out.println("第十次反弹"+Three(10,100,0)+"米");
sumFour();

}

private static void sumOne() {
int a=1, b=1, temp; //从规律可以得出第3个分母的值是前两个分母的和, 由此可以定义出一个变量 a=1;
double c;
double sum = 0;

for (int i = 0; i < 20; i++) {
temp = a; // 分子是前一个分母的值, 所以先用一个临时变量存着,
a = a + b;
b = temp; // 在把临时变量里的值赋给 b;
c = (double)a/b; // 由于是int类型, 转成double;
sum += c;
System.out.println(a+"/"+b);
}
System.out.println(sum);

}

/*
* 2.有五个人坐在一起，问第五个人是多少岁，他说比第四个人大两岁。问第四个人是多少岁，他说比第三个人大两岁。
* 问第三个人是多少岁，他又说比第二个人大两岁。问最后一个人，他只是说10岁，请问第五个人多大。
*/

private static void sumTwo() {
int first = 10;

for (int i = 0; i < 4; i++) {
first+=2; //从后往前退每个人的年龄加上2
}
System.out.println(first);
}

/*
 * 一球从一百米高度自由下落，每次落地后反跳原来高度的一半，再落下，求它在第10次落地时，共进过多少米？第十次反弹多高？
 */

private static double Three (int count,double mi,double temp) {
System.out.println(temp+"-----"+mi);
double sum = temp+mi;
if(count < 1){
System.out.println("共"+sum+"米");
return mi;
}else{
count--;
return Three(count,mi/2,sum); //递归方法, 10次, 每次都是除以2的高度, sum是记录器, 记录每次降落多少米
}
}
/*
 * 2.有1,2,3,4四个数字，能组成多少个互不相同的且没有重复数字的三位数，都是多少，并且将所得的三位数按升序排列并打印。
 */
private static List sumFour() {
//思路: 因为是3个数, 那么可以写3层循环来进行判断.. 首先最外层是第1个数, 第2层是中间的数, 第3层是第3个数..
int count = 0;
StringBuilder sb = new StringBuilder();
List list =new List();
for (int i = 1; i <=4; i++) {
for (int j = 1; j <=4; j++) {
for (int k = 1; k <=4; k++) {
if(i!=j&&j!=k&&k!=i){ //只需要判断它们各自不都相等对方即可.. 然后一个计数器++
count++;
// System.out.print(i);
// System.out.print(j);
// System.out.println(k);
sb.append(i); // 然后我把数存在一个StringBuilder 缓冲区里
sb.append(j);
sb.append(k);
myCompareTo(sb.toString());// 由于TreeSet 的排序会比较方便, 于是我就不放在数组里了.. TreeSet 是自带升序功能
sb.delete(0, sb.length()); 最后再做一步, 存一个删一个..
}
}
}
}

System.out.println(count+"个");
return list;
}

private static void myCompareTo(String sb) {
int i = Integer.parseInt(sb);
TreeSet<Integer> s = new TreeSet<Integer>();
s.add(i);

for (Integer integer : s) {
System.out.println(integer);
}
}

}

作者: 王楚鑫 时间: 2013-6-25 13:06
第五题

/*
5.将一个正整数分解质因数，例如:输入参数90，打印出90=2*3*3*5；
*/
public class Factor
{
public static void main(String args[])
{
int i;
int n=16; //输入语句给忘了、先直接赋值了
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); //输出使循环结束的质因数
}
}

复制代码

作者: 土匪大学生 时间: 2013-6-25 18:09
再完成一个

/*
题目：有一个分数序列：2/1，3/2，5/3，8/5，13/8，21/13…求出这个数列的前20项之和

思路：
1、根据给出的数列可得规律：分子=前项的(分子+分母)，分母=前项的分子。

步骤：
1、要有一个存储sum变量，n分子，m分母。还要一个临时存储tp。
2、用for循环实现多项和。
3、要注意的是当把前项的分子、分母相加赋值给分子时，此时前项的分子值已被覆盖，所以要一个暂存变量tp用来保存前项分子值。

*/
class SequenceSum
{
static double sequence(int number)
{
double sum=0,n=2,m=1,tp;
for (int a=0; a<number; a++)
{
sum += n/m;//把每一项数相加
tp = n;//分子暂存于tp
n = n + m;//把前项的分子、分母相加作为分子
m = tp;//再把前项的分子赋值给分母
}
return sum;

}

public static void main(String[] args)
{
System.out.println("此数列前20项之和为："+sequence(20));//输出结果
}
}

截图

作者: ㄗs：/|丶hearts 时间: 2013-6-25 20:10

package com.java.test;
public class Age {
/**
* @param args
* 有五个人坐在一起，问第五个人是多少岁，他说比第四个人大两岁。问第四个人是多少岁，他说比第三个人大两岁。
* 问第三个人是多少岁，他又说比第二个人大两岁。问最后一个人，他只是说10岁，请问第五个人多大。
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int age = 10;
int i = 4;
//每循环一次 i自减1 ，i不大于0时退出循环
while(i-- >0)
{
//下个人的年龄
age += 2;
}
System.out.println(age);
}
}

复制代码

运行结果：18 就不用贴图了吧
话说问题中少了一句：第二个人比第一个人大两岁

作者: 姚飞 时间: 2013-6-26 16:12
版主你看我这个，三个题，我觉得是不是我的思想水平怎么这么低？只会这个。。。下面看结果。。。最好来个三分。。嘿嘿。。
第一题，我这个有点瑕疵，算出来的是整数：

class s1
{
public static void main(String[] args)
{
int x=2,y=1,i;
float sum=0,s;
for (i=1;i<21 ;i++ )//累加21次
{
sum+=(x/y);//结果值累加，保留下来
x=x+y;//后一个分子是前一个分子分母之和
y=x-y;//后一个分母是前一个分子
}
System.out.println(sum );
}
}

复制代码

结果：

D:\11>javac s1.java

D:\11>java s1
21.0

D:\11>
第二题：

class age
{
public static void main(String[] args)
{int i=2,age=10;
for(i=2;i<6;i++)
{
age=(age+2);//都是大2岁么，嘿嘿。。。。
System.out.println("这是第"+i+"个人的年龄"+age);
}
}
}

复制代码

结果：

D:\11>java age
这是第2个人的年龄12
这是第3个人的年龄14
这是第4个人的年龄16
这是第5个人的年龄18

D:\11>
第三个：

class high
{
public static void main(String[] args)
{int i=1;
float h=100;
for(i=1;i<11;i++)
{
h=(h/2);//赋值，后一次位前一次的一半
System.out.printf("这是落地第"+i+"次高度"+h);
System.out.println("这是落地第"+i+"次高度"+h);
}
}
}

复制代码

结果：

D:\11>java high
这是落地第1次高度50.0这是落地第1次高度50.0
这是落地第2次高度25.0这是落地第2次高度25.0
这是落地第3次高度12.5这是落地第3次高度12.5
这是落地第4次高度6.25这是落地第4次高度6.25
这是落地第5次高度3.125这是落地第5次高度3.125
这是落地第6次高度1.5625这是落地第6次高度1.5625
这是落地第7次高度0.78125这是落地第7次高度0.78125
这是落地第8次高度0.390625这是落地第8次高度0.390625
这是落地第9次高度0.1953125这是落地第9次高度0.1953125
这是落地第10次高度0.09765625这是落地第10次高度0.09765625

D:\11>

作者: camml 时间: 2013-6-26 17:34
我现在还不能上传图片，那个网络图片从空间里面也弄不过来

作者: 张勇1993 时间: 2013-6-26 17:35
辛苦了！！！兄弟

作者: ㄗs：/|丶hearts 时间: 2013-6-26 21:31

package com.java.test;
import java.util.*;
public class Num {
/**
* @param args
* 有1,2,3,4四个数字，能组成多少个互不相同的且没有重复数字的三位数，都是多少，
* 并且将所得的三位数按升序排列并打印。
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int count = 0;
//使用for循环，在循环中打印出符合条件的数字就是从小到大排序的可以不用考虑排序
//因为都是数字，具备比较性可以存入TreeSet集合让集合帮忙排序
Set<Integer> s = new TreeSet<Integer>();
//百位上的数字
for(int x = 1; x<5;x++)
{
//十位上的数字
for(int y = 1;y<5;y++)
{
//个位上的数字
for(int z = 1; z<5;z++)
{
//判断：如果各位上的数字互不相同则是符合条件的三位数
if(x != y && x!=z && y!=z)
{
//符合条件总数+1
count++;
int num = x*100 + y*10 + z;
//打印该数字
System.out.print(num+" ");
//将该数字存入TreeSet集合
s.add(num);
}
}
}
}
System.out.println("\n互不相同的三位数共有："+count+"个");
//遍历TreeSet集合打印排序好的数字
for(int i:s)
{
System.out.print(i+" ");
}
}
}

复制代码

QQ图片20130626213036.jpg (20.38 KB, 下载次数: 0)

作者: ㄗs：/|丶hearts 时间: 2013-6-26 22:25
本帖最后由ㄗs：/|丶hearts 于 2013-6-26 22:46 编辑

package com.java.test;
public class Ball {
/**
* @param args
* .一球从一百米高度自由下落，每次落地后反跳原来高度的一半，再落下，
* 求它在第10次落地时，共进过多少米？第十次反弹多高？
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//第一次定义为int类型运行结果sum的值为0
//因为结果中有小数，所以定义为double类型
double high = 100, sum = 100;
for(int i=1;i<10;i++)
{
high /= 2;
//球弹起到下一次弹起走过的路程是弹起高度的2倍
sum += (high*2);
}
//第十次反弹的高度应为当前高度的一半即high/2
System.out.println("球在第10次落地时，共进过"+sum+"米,第十次反弹高度为"+high/2);
}
}

复制代码

QQ图片20130626224526.jpg (9.86 KB, 下载次数: 0)

作者: 李九一 时间: 2013-6-26 23:11
题1

package com.itheima;
public class NewTest {
public static void main(String[] args) {
int i,n=20;
float a=2,b=1,s=0,t;
for(i=1;i<=n;i++){
s=s+a/b;
t= a;
a=a+b;//将前一项分子与分母之和作为下一项的分子
b=t;//讲前一项的分子作为下一项的分母
}
System.out.println("前20项的和为："+s);
}
}

复制代码

作者: 李九一 时间: 2013-6-26 23:20
本帖最后由李九一于 2013-6-27 11:57 编辑

题2

package com.itheima;
public class NewTest {
public static void main(String[] args) {
float s=100,h=s/2;
int n;
for(n=2;n<=10;n++){
s=s+2*h;
h=h/2;
}
System.out.println("第10次落地时共经过："+s);
System.out.println("第10次反弹："+h);
}

复制代码

作者: 李九一 时间: 2013-6-26 23:48
题（求公约数和共倍数）

package com.itheima;
import java.util.Scanner;
public class NewTest {
public static void main(String[] args) {
int p,r,n,m,temp;
Scanner sc1=new Scanner(System.in);
Scanner sc2=new Scanner(System.in);
n=sc1.nextInt();m=sc2.nextInt();
if(n<m){
temp=n;
n=m;
m=temp;//把大数放在n中，小数放在m中
}
p=n*m;//先将n和m的成绩保存在p中，以便求最小公倍数
while(m!=0){//求最大公约数
r=n%m;
n=m;
m=r;
}
System.out.println("最大公约数："+n);
System.out.println("最大公倍数："+p/n);
}
}

复制代码

结果

12 3
最大公约数：6
最小公倍数：12

复制代码

作者: 姚飞 时间: 2013-6-27 08:22
本帖最后由姚飞于 2013-6-27 11:41 编辑

第一题修正后：

复制代码

class s1
{
public static void main(String[] args)
{
float x=2,y=1,i;
float sum=0,s;
for (i=1;i<21 ;i++ )//累加21次
{
sum+=(x/y);//结果值累加，保留下来
x=x+y;//后一个分子是前一个分子分母之和
y=x-y;//后一个分母是前一个分子
}
System.out.println(sum );
}
}

复制代码

结果：

D:\11>javac s1.java
D:\11>java s1
32.660263
D:\11>
第三题：

class high
{
public static void main(String[] args)
{int i=1;
float h=100,sum=100;
for(i=1;i<11;i++)
{
h=(h/2);//赋值，后一次位前一次的一半
sum+=h;
System.out.println("这是落地第"+i+"次后的高度"+h);
}
System.out.println("这是落地第10次高度"+sum);
}
}

复制代码

结果：

D:\11>javac high.java
D:\11>java high
这是落地第1次后的高度50.0
这是落地第2次后的高度25.0
这是落地第3次后的高度12.5
这是落地第4次后的高度6.25
这是落地第5次后的高度3.125
这是落地第6次后的高度1.5625
这是落地第7次后的高度0.78125
这是落地第8次后的高度0.390625
这是落地第9次后的高度0.1953125
这是落地第10次后的高度0.09765625
这是落地第10次高度199.90234
D:\11>

作者: Just_Only 时间: 2013-6-27 08:23

姚飞发表于 2013-6-27 08:22
额，我还没有改好。。等下我从新编辑一下。。。。。

好的，再接再厉，加油，答题的时候，搞好了在帖，不然我不好加分的啊，帖子太多了。。。

作者: 张林敏 时间: 2013-6-27 09:02
本帖最后由张林敏于 2013-6-27 14:03 编辑

顶起，好贴
我领“1.将一个正整数分解质因数，例如:输入参数90，打印出90=2*3*3*5；”

package com.itheima;
import java.util.ArrayList;
import java.util.List;
/**
* 1.将一个正整数分解质因数，例如:输入参数90，打印出90=2*3*3*5；
* @author ZhangLinmin
*/
public class Main_6_27 {
public static void main(String[] args) {
Integer num = 90;
//1、定义存放分解结果
List<Integer> list = new ArrayList<Integer>();
//2、把分解的数据加入list中
list.add(num);
while(true){
boolean isFinal = true;
//3、对list中每个数据进行分别分解
for (int i = 0; i < list.size(); i++) {
Integer cutNum = list.get(i);
for (int j = 2; j < cutNum; j++) {
Integer result = cutNum % j;
//4、对list中查找到需要进行分解的，进行删除需分解数据，并把分解结果加入list中，等待再次分解
if (result == 0) {
//如果有查找到需要分解的，就不让结束
isFinal = false;
list.remove(i);
list.add(j);
list.add(cutNum/j);
break;
}
}
}
if(isFinal){
break;
}
}
//输出结果
System.out.print(num+"=");
for (int i = 0; i < list.size(); i++) {
System.out.print((i==0?"":"*")+list.get(i));
}
}
}

复制代码

作者: 李九一 时间: 2013-6-27 10:12

1.将一个正整数分解质因数，例如:输入参数90，打印出90=2*3*3*5；
(1)如果这个质数恰等于n，则说明分解质因数的过程已经结束，打印出即可。
(2)如果n<>k，但n能被k整除，则应打印出k的值，并用n除以k的商,作为新的正整数n,重复执行第一步。
(3)如果n不能被k整除，则用k+1作为k的值,重复执行第一步

package com.itheima;
public class 分解质因数 {
public static void main(String[] args){
int n = 90;
decompose(n);
}
private static void decompose(int n){
System.out.print(n+"=");
for(int i=2;i<n+1;i++){
while(n%i==0 && n!=i){
n/=i;
System.out.print(i+"*");
}
if(n==i){
System.out.println(i);
break;
}
}
}
}

复制代码

分解质因数.jpg (74.14 KB, 下载次数: 0)

作者: 李九一 时间: 2013-6-27 11:58

李九一发表于 2013-6-26 23:20
题2

代码实现了，结果少粘上去了

第10次落地时共经过：299.60938
第10次反弹：0.09765625

复制代码

作者: 水。。。海 时间: 2013-6-27 20:53
今天先写两个简单的后面的有点难，以后在写，不知道对不对，给你们看看

/** Test1.有五个人坐在一起，问第五个人是多少岁，他说比第四个人大两岁。问第四个人是多少岁，他说比第三个人大两岁。问第三个人是多少岁，他又说比第二个人大两岁.，问第二个人，他又说比第一个人大两岁。问最后一个人，他只是说10岁，请问第五个人多大。
*@ auther 倪成伟
*/
/*
思路：1.通过一个for循环4次实现累加
*/
class FifthOld
{
public static void main(String[] args)
{
int x=10;
for(int y=1;y<5;y++) //用for循环实现4次累加
{
x+=2;
}
System.out.println("FifthOld="+x);
}
}

复制代码

下面是第二题

/**
*Test2.有一个分数序列：2/1，3/2，5/3，8/5，13/8，21/13…求出这个数列的前20项之和
*auther@倪成伟
*/
/*思路：1.建立两个数组分别接受前20项分子分母的值
2.然后通过一个累加的方法实现且20项的和
*/
class Sum
{
public static void main(String[] args)
{
//定义两个长度为20的数组分别接受分子分母的值
int arr1[]=new int[20];
int arr2[]=new int[20];
//初始化前两项的值
arr1[0]=2;
arr1[1]=3;
arr2[0]=1;
arr2[1]=2;
//通过一个for循环来算出前数组中的元素
for(int x=2,y=2;x<=19;x++,y++)
{
arr1[x]=arr1[x-2]+arr1[x-1];
arr2[y]=arr2[y-2]+arr2[y-1];
}
int sum=0; //用来接受累加的值
//在通过一个for循环来实现累加
for(int m=0,n=0;m<=19;m++,n++)
{
sum=sum+(arr1[m]/arr2[n]);
}
System.out.println("前20项之和 "+sum);
}
}

复制代码

R(_(Z6L3)LC1BZBVFHIJNE3.jpg (12.23 KB, 下载次数: 0)

第一题

M[ILD6}8SR60D[_@S9BWO(Y.jpg (9 KB, 下载次数: 0)

第二题

作者: 水。。。海 时间: 2013-6-28 10:47
我改了下不知道对不对，如果这也错了，那是不是我的思路有问题，求指导

/**
*Test2.有一个分数序列：2/1，3/2，5/3，8/5，13/8，21/13…求出这个数列的前20项之和
*auther@倪成伟
*/
/*思路：1.建立两个数组分别接受前20项分子分母的值
2.然后通过一个累加的方法实现且20项的和
*/
class Sum
{
public static void main(String[] args)
{
//定义两个长度为20的数组分别接受分子分母的值
double arr1[]=new double[20];
double arr2[]=new double[20];
//初始化前两项的值
arr1[0]=2.0;
arr1[1]=3.0;
arr2[0]=1.0;
arr2[1]=2.0;
//通过一个for循环来算出前数组中的元素
for(int x=2,y=2;x<=19;x++,y++)
{
arr1[x]=arr1[x-2]+arr1[x-1];
arr2[y]=arr2[y-2]+arr2[y-1];
}
double sum=0; //用来接受累加的值
//在通过一个for循环来实现累加
for(int m=0,n=0;m<=19;m++,n++)
{
sum=sum+(arr1[m]/arr2[n]);
}
System.out.println("前20项之和 "+sum);
}
}

复制代码

$FP9]_5B8PZ)_AF7_)9CE70.jpg (11.32 KB, 下载次数: 0)

第二题

作者: 杨晓燕 时间: 2013-6-28 11:16
本帖最后由杨晓燕于 2013-6-28 11:18 编辑

我总是那么后知后觉啊，{:soso_e120:}先贴一个试试，【第一题】请杨大哥多多关照

/*
需求：有一个分数序列：2/1，3/2，5/3，8/5，13/8，21/13…求出这个数列的前20项之和
思路:1，要先定义一个变量记录总和，为float类型
2，定义一个自增变量，控制循环次数，这里我们使用的是for循环
3，根据分数数列的规律，设置分母初始值为x=1，分子初始值为y=2；
*/
class Test1
{
public static void main(String[] args)
{
float sum=0f; //定义一个记录总和的变量，不要在循环里面定义，因为循环结束，该变量就在内存中释放了
float x=1f,y=2f;//定义分母和分子的初始值，也不要在循环里面定义，否则每次循环都会重新初始化该值
for(int i=1;i<=20;i++)
{
sum+=y/x;
float temp=y;//定义一个第三方变量，将分子y的值取出
y=y+x; //根据需求，分子的值=分子+分母
x=temp; //根据需求，分母的值=前一个分数的分子
}
System.out.println(sum);
}
}

复制代码

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

作者: 水。。。海 时间: 2013-6-28 11:45
再搞一题，求指教

/**一般：
Test1.一球从一百米高度自由下落，每次落地后反跳原来高度的一半，再落下，求它在第10次落地时，共进过多少米？第十次反弹多高？
*auther @ 倪成伟
*/
/*
思路：1.通过循环递减来计算第十次反弹的高度
2.通过一个数组来接受每次反弹的高度
3.通过循环累加来记录第十次落地共进行了多少米
*/
class Jump
{
public static void main(String[] args)
{
int x=0,y=0; //初始化高度，并且定义两个变量来记录结果
double m=100,sum=0;
double[] arr=new double[10]; //定义一个数组来接受每次反弹的高度
while(y<10) //while循环来得出反弹高度
{
m=m/2;
arr[y]=m;
y++;
}
System.out.println("第十次反弹高度 "+m);
for(m=100;x<10;x++) //用for循环来初始化m值，并累加高度
{
sum+=(arr[x]*2);
}
sum=sum+100; //加一百记录第一次落下所走得路
System.out.println("反弹十次共进多少米 "+sum);
}
}

复制代码

2N[CJQ22)IE`0IIJEL$NGKS.jpg (10.92 KB, 下载次数: 0)

作者: ゞ傀儡鮭鮭ぃ 时间: 2013-6-28 13:05
本帖最后由ゞ傀儡鮭鮭ぃ于 2013-6-28 13:08 编辑

第一题
java代码:
class one
{
public static void main(String args [])
{
 double sum = 0;
 double a = 2.0;
 double b = 1.0;
 double c = 0; //分子为b 分母为a
 for(double n=1; n<=20; n++)
{
 sum+=(double)a/(double)b; //序列求和
 c=a;
 a+=b;
 b=c; //求下一项序列
 }
 System.out.println("分数序列之和为"+sum);
}
}
程序分析：先观察出序列之间的联系，根据分子分母之间的变化关系,算出每一项，再利用for循环进行求和.
运行结果：

第二题
java代码:
class two{
static int getAge(int n)
{
if (n==1)
{
return 10; //第一个人年龄
}
return getAge(n-1)+2; //逆推，一次增加2年
}
public static void main(String[] args) {
System.out.println("第五个年龄为:"+getAge(5));//获取第五个人年龄
}
}
程序分析：利用递归,知道第五个人的年龄之后推第四个年龄，由此，知道第一个人年龄，再反推.
运行结果:

第三题
java代码:
class three{
public static void main(String [] args)
{
int n=1 ;//弹跳数
double s=100;//初始高度100米
double h=s/2;//第一次碰到地面反弹高度
for(n=1;n<10;n++){
s=s+h*2;//第n次落地经过多少米
h=h/2;//第n次反弹的高度
}
System.out.println("第"+n+"次落地经过"+s+"米");
System.out.println("第"+n+"次反弹"+h+"米");
}
}
//程序思路：这是绝对值小于1的无穷递缩等比数列，首项a1为100，公比q=1/2，路程求和极限，先用for循环求和，再把a10表示出来即可.
//运行结果：

第四题
java 代码:
class four{
public static void main(String [] args)
{
int i=0;
int a=1;
int b=1;
int c=1;
for(a=1;a<=4;a++)
for(b=1;b<=4;b++)
for(c=1;c<=4;c++)//按顺序自动生成所有三个1234随机数的组合
if(a!=b&&b!=c&&c!=a&&i++!=0)//抽取互不相同且无重复数字的三位数
System.out.println("第"+i+"个数是:"+a+""+b+""+c);
System.out.println("有"+i+"个");
}
}
//程序思想:先按顺序自动生成所有三个1234随机数的组合，再根据互不相同且无重复数字的条件逐步筛选，并计算出组合数个数，打印输出.
运行结果:

第五题
java代码：
import java.util.*;
class five{
public static void main(String [] args){
System.out.println("java分解正整数质因数案例");
System.out.println("请输入一个合适的正整数，并按Enter确认");
Scanner sc=new Scanner(System.in);
int Num=sc.nextInt();
//首先，我们需要得到，输入的这个数Num的一半以内的所有质数
Vector<Integer> vec=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;
}
}
//内层for正常完成后,说明i是质数
vec.add(i);//添加到列表
}
//下面开始分解质因数
System.out.println(Num+"的分解结果是：\n");
System.out.print(Num+"=");
int theNum=Num;
boolean help=true;
for(int k=0;k<vec.size();k++){
int zhi=(int)vec.get(k);
if(theNum<zhi)
break;
if(theNum%zhi==0){//说明能被整除，则zhi就是Num的一个质因数
if(help==true){
System.out.print(zhi);
help=false;
}else{
System.out.print("*"+zhi);
}
k--;//因为，完全有可能Num还能被zhi整除，
//所以重新执行一遍
theNum=theNum/zhi;
}
}
}
}
程序分析：对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成：
(1)如果这个质数恰等于n，则说明分解质因数的过程已经结束，打印出即可。
(2)如果n<>k，但n能被k整除，则应打印出k的值，并用n除以k的商,作为新的正整数n,重复执行第一步。
(3)如果n不能被k整除，则用k+1作为k的值,重复执行第一步。运行结果：

第六题

java代码:
import java.util.*;
class six{
public static void main(String[] args) {
 int a ,b,m;
 Scanner s = new Scanner(System.in);
 System.out.print( "键入一个整数： ");
 a = s.nextInt();System.out.print( "再键入一个整数： ");
 b = s.nextInt();
 // new 一个类目的是调用类中的方法 deff
deff cd = new deff();
// 调用类中的方法 deff 获得最大公约数
 m = cd.deff(a,b);

 // 计算最小公倍数
 int n = a * b / m;
 System.out.println("最大公约数: " + m);
 System.out.println("最小公倍数: " + n);
}
}class deff {
public int deff(int x, int y) {
 int t;
 // 如果x<y 则将x和y的值互换
 if (x < y) {
t = x;
x = y;
y = t;
 }

 //程序执行到这里 x肯定大于或者等于y

 while (y != 0) {
// 如果x和y相等，那么他们的最大公约数是x
if (x == y){
return x;
}
// 当x和y不相等的时候将y的值赋值给x 将原x的值和y的余数赋值给y
// 这时候x依然大于或者等于y 接着进行下一轮计算
// 一直循环下去，当k为0的时候，x就是最大公约数了
else {
int k = x % y;
x = y;
y = k;
}
 }
 return x;
}
}
程序设计：利用辗转相除法，先输入两个随机正数，然后通过数学思想求出最大公约数和最小公倍数.

运算结果:

作者: 殷挥笔 时间: 2013-6-28 17:31

package Demo;
public class JianDan1 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
double sum = 0;
double a = 2.0;
double b = 1.0; //分子为b 分母为a 你这里应该是分母为b，分子为a把
for(int n=1; n<=20; n++) // 定义一个for循环，是求前20项。
{
sum+=(double)a/(double)b;//序列求和
double temp=b;//定义一个第三方变量，将b的值取出来
b=a;
a+=temp;
}
System.out.println("分数序列之和为"+sum);
}
}

复制代码

作者: 殷挥笔 时间: 2013-6-28 17:32
上面忘记写运算结果了……结果为——分数序列之和为32.66026079864164

作者: 殷挥笔 时间: 2013-6-28 17:37

package Demo;
public class JianDan2 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int a =10;//定义第一个人的岁数
for(int i=1;i<=4;i++){//定义一个for循环，后一个人都比前一个人大2岁，第一个人前面有4个人，所以循环4次。
a +=2;
}
System.out.print("第五个人是"+a+"岁");//输出第四次循环时的结果，也就是第五个人的年龄
}
}

复制代码

结果为——第五个人是18岁

作者: 殷挥笔 时间: 2013-6-28 17:52

package Demo;
public class ZhongDeng1 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
double a =100;
double b =0;
for(int i=1;i<=10;i++){
b = b +a;
a /= 2;
}
System.out.println("第十次弹起："+a+"米！");
System.out.println("总共经过了："+b+"米！");
}
}

复制代码

结果是：
第十次弹起：0.09765625米！
总共经过了：199.8046875米！

作者: camml 时间: 2013-6-28 17:57
本帖最后由 camml 于 2013-6-28 17:58 编辑

/*
第一题;求出分数1/2+2/3+3/5+5/8+8/13+....+的前20项的和
public class Test1{
public static void main(String[] args){
add();
}
//定义一个add方法，用来求出前20项的和
public static void add(){
double A = 1,B = 2,C = 0,sum = 0;
//定义一个for循环，将加法循环20次
for(int i=1;i<=20;i++){
//输出前20项的每个分数
sop(A+"/"+B);
sum = sum + A/B;
//将A B的值进行调整得到下一个分数
C=B;
B=B+A;
A=C;
}
sop("前20项的和为："+sum);
}
//定义一个输出打印方法
public static void sop(Object obj){
System.out.println(obj);
}
}

复制代码

微博桌面截图3.jpg (23.21 KB, 下载次数: 0)

作者: 殷挥笔 时间: 2013-6-28 17:59

package Demo;
public class ZhongDeng2 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int a = 0;
for(int i = 1; i <= 4; ++i)
for(int y = 1; y <= 4; ++y)
for(int j = 1; j <= 4; ++j)
if(i != y && y != j && i != j && ++a != 0)
System.out.println("第."+a+"个数:"+i+""+y+""+j);
System.out.println("一共有:" + a + "个");
}
}

复制代码

结果是：
第.1个数:123
第.2个数:124
第.3个数:132
第.4个数:134
第.5个数:142
第.6个数:143
第.7个数:213
第.8个数:214
第.9个数:231
第.10个数:234
第.11个数:241
第.12个数:243
第.13个数:312
第.14个数:314
第.15个数:321
第.16个数:324
第.17个数:341
第.18个数:342
第.19个数:412
第.20个数:413
第.21个数:421
第.22个数:423
第.23个数:431
第.24个数:432
一共有:24个

作者: camml 时间: 2013-6-28 17:59
本帖最后由 camml 于 2013-6-28 18:03 编辑

class Test2 {
public static void main(String[] args) {
getAge();
}
//定义一个获取第五个人年龄的方法
public static void getAge(){
//定义第一个人年龄，并对第五个人年龄进行初始化
int x1 = 10,x5 = 0;
//进行四次循环获得第五个人年龄
for(int i = 0;i < 4;i++) {
x1 = x1 + 2;
x5 = x1;
}
//对第五个人年龄进行输出打印
sop("x5 = "+ x5);
}
//定义一个输出函数
public static void sop(Object obj){
System.out.println(obj);
}
}

复制代码

微博桌面截图_4.jpg (4.13 KB, 下载次数: 0)

作者: 殷挥笔 时间: 2013-6-28 18:11

package Demo;
import java.util.Scanner;
public class JiaoNan1 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.print("请输入你想分解质因数的正整数：");
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
Demo(a);
}
private static void Demo(int a){
System.out.print("分解质因数后为："+a+"=");
for(int i=2;i<a+1;i++){
while(a%i==0 && a!=i){
a =a/i;
System.out.print(i+"*");
}
if(a==i){
System.out.println(i);
break;
}
}
}
}

复制代码

如果输入90的话，输出结果为：
请输入你想分解质因数的正整数：90
分解质因数后为：90=2*3*3*5

作者: 殷挥笔 时间: 2013-6-28 18:31

package Demo;
import java.util.Scanner;
public class JiaoNan2 {
/**
* 输入两个正整数m和n，求其最大公约数和最小公倍数。
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.print("请输入m的值：");
Scanner sc = new Scanner(System.in);
int m = sc.nextInt();
System.out.print("请输入n的值：");
int n = sc.nextInt();
int a = gongyue(m,n);
int a1 = gongbei(m,n);
System.out.print("最大公约数为："+a+"\n"+"最大公倍数为："+a1);
}
public static int gongyue(int m, int n) {
while(m % n != 0) {
int temp = m % n;
m = n;
n = temp;
}
return n;
}
//求m和n的最小公倍数
public static int gongbei(int m, int n) {
return m * n / gongyue(m, n);
}
}

复制代码

如果m=18，n=12；结果为：
请输入m的值：18
请输入n的值：12
最大公约数为：6
最大公倍数为：36

作者: 教皇 时间: 2013-6-28 23:11
/**
* 求分数前20项之和
*/
public class Sum {
public static void main (String[] args){
System.out.println(sumFenShu(20));
}

public static double sumFenShu(int n){
float fenzi = 2F;
float fenmu = 1F;
float sum = 0F;
float tmp;
for(int i = 0; i < n; i++){
sum += fenzi/fenmu;
tmp = fenzi;
fenzi = fenzi +fenmu;
fenmu = tmp;

}
return sum;
}
}

结果.PNG (1.74 KB, 下载次数: 0)

作者: .netNo1 时间: 2013-6-29 17:27

int num, dnum; //定义分子和分母
int a, b;
double sum; //和
a = 2; //定义初始值
b = 1;
sum = (double)a / b; //初始值
for (int i = 0; i < 20; i++)
{
num = a + b;
dnum = a;
sum = sum + (double)num / dnum;
a = num;
b = dnum;
}
Console.WriteLine("和为{0}", sum);
Console.ReadKey();
//结果为：34.2782947888172

复制代码

作者: .netNo1 时间: 2013-6-29 20:47

int num = 5;
int years;
int cout = 10;
int d1 = 2;
years = cout + (num - 1) * d1;
Console.WriteLine("第五个人{0}岁", years);
Console.ReadKey();
//运行结果：18

复制代码

作者: Just_Only 时间: 2013-6-29 20:56

.netNo1 发表于 2013-6-29 17:27

第一题错误，这个活动已经结束了，可以看第二周的，你也可以看看这些题目，看看自己能不能做。。。

作者: .netNo1 时间: 2013-6-29 21:09

double height = 100; //初始化球落地时的高度
double sum = 0; //和
sum=sum+100; //初始化
for (int i = 0; i < 10; i++)
{
sum = sum + height;
height = height / 2;
}
Console.WriteLine("第10次落地共经过{0}米,第10次反弹高度为{1}米", sum, height);
Console.ReadKey();
//结果分别为：299.8046875和0.09765625;

复制代码

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

黑马程序员IT技术论坛 X3.2