A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© Just_Only   /  2013-6-23 01:46  /  7139 人查看  /  71 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

先收藏 留着慢慢回答问题
回复 使用道具 举报
本帖最后由 王楚鑫 于 2013-6-24 13:32 编辑
  1. /*
  2. 有一个分数序列:2/1,3/2,5/3,8/5,13/8,21/13…求出这个数列的前20项之和
  3. */
  4. public class Seque
  5. {

  6. public static void main(String args[])
  7. {
  8. int fenzi, fenmu; //定义分子和分母
  9. double sum; //定义序列之和
  10. fenzi = 2; //初始值
  11. fenmu = 1;
  12. sum = (double)fenzi/fenmu;
  13. int n; //用于记录累加的次数

  14. for (n=1; n<20; n++ ) //求数列前20项之和,即进行累加20次
  15. {
  16. fenzi=fenzi+fenmu;
  17. fenmu=fenzi-fenmu;
  18. sum += (double)fenzi/fenmu;
  19. }
  20. System.out.println("分数序列的前20项之和为:"+sum);
  21. }
  22. }
复制代码
第二题
  1. /*
  2. 2.有五个人坐在一起,问第五个人是多少岁,他说比第四个人大两岁。问第四个人是多少岁,他说比第三个人大两岁。问第三个人是多少岁,他又说比第二个人大两岁。问最后一个人,他只是说10岁,请问第五个人多大
  3. */
  4. public class Age
  5. {

  6. public static void main(String args[])
  7. {
  8. int []age=new int[6]; //定义一个数组保存五个人的年龄,age[i]表示第i个人的年龄
  9. age[1] = 10; //初始化第一个的年龄
  10. int i;
  11. for (i=2; i<6; i++) // 从第2个人开始一直到第5个人,他们都比上一个人大2岁
  12. {
  13. age[i]=age[i-1]+2;
  14. }
  15. System.out.println("第五个人的年龄为:" +age[5] );
  16. }
  17. }
复制代码
第三题
  1. /*
  2. 3.一球从一百米高度自由下落,每次落地后反跳原来高度的一半,再落下,求它在第10次落地时,共进过多少米?第十次反弹多高?
  3. */
  4. public class Ball
  5. {
  6. public static void main(String args[])
  7. {
  8. double sum=100.00; //定义小球一共经过的长度,第一次落地时已经走过100米
  9. double height=sum/2; //定义小球第一次落地时反弹的高度
  10. for(int i=2;i<=10;i++) //循环控制小球落地10次
  11. {
  12. sum=sum+2*height; //累加,每一次小球弹起又下落经过的长度
  13. height=height/2; //每次小球落地后反弹原来高度的一半
  14. }
  15. System.out.println("在第10次落地时,共经过"+sum +"米");
  16. System.out.println("第10次反弹"+height+"米");

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

  25. }
  26. System.out.println("综上,共有满足条件的三位数:"+n+"个");
  27. }
  28. }
复制代码
第六题
  1. /*
  2. 输入两个正整数m和n,求其最大公约数和最小公倍数
  3. */
  4. public class Gcd_Lcm
  5. {
  6. public static void main(String args[])
  7. {
  8. int a,b,num1,num2,temp;
  9. System.out.println("please input two numbers:");
  10. //java的输入语句、忘了呢、先直接赋值吧
  11. num1=4;
  12. num2=6;
  13. int lcm=num1*num2; //存放最小公倍数


  14. if(num1<num2) //保证大数放在num1中
  15. {
  16. temp=num1;
  17. num1=num2;
  18. num2=temp;
  19. }
  20. int r=num1%num2; //定义余数,大数除小数,当余数为0时的除数即为两数的最大公约数
  21. while(r!=0) //辗除相除法求最大公约数
  22. {
  23. num1=num2;
  24. num2=r;
  25. r=num1%num2;
  26. }
  27. System.out.println("gcd:"+num2);
  28. System.out.println("lcm:"+lcm/num2); //最小公倍数=数A*数B/最大公约数
  29. }
  30. }
复制代码
运行时截图



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

QQ截图20130624132544.png

评分

参与人数 1技术分 +3 收起 理由
Just_Only + 3 赞一个!

查看全部评分

回复 使用道具 举报
较难题1:
  1. import java.util.Scanner;
  2. public class test5 {
  3.         public static void main(String[] args){
  4.                 int m,k;
  5.                
  6.                 System.out.print("please enter a number:");
  7.                 Scanner in=new Scanner(System.in);
  8.                 m=in.nextInt();//获取输入的数据
  9.                 System.out.print(m+"=");
  10.                 for(k=2;k<m;){
  11.                         if(m%k!=0){//没有被整除,说明没有找到因数,K自增1
  12.                                 k++;
  13.                         }
  14.                         else{
  15.                                 System.out.print(k+"*");//找到因素,打印
  16.                                 m=m/k;//去掉找到的因素
  17.                                 k=2;//k重新从2开始
  18.                         }
  19.                 }
  20.                 System.out.println(k);
  21.         }
  22. }
复制代码
题1截图

较难题2:
  1. import java.util.Scanner;
  2. public class test6 {
  3.         /**
  4.          * 求最小公倍数
  5.          * @param n
  6.          * @param m
  7.          * @return
  8.          */
  9.         private static int minBs(int n,int m){
  10.                 int temp=0;
  11.                 for(int i=n;i<=n*m;i++){//令i的值在n和m*n之间
  12.                         if(i%n==0&&i%m==0){//i能同时整除n和m的,i就是最小公倍数
  13.                                 temp=i;
  14.                                 break;//之间跳出循环
  15.                         }
  16.                 }
  17.                 return temp;//返回最小公倍数
  18.         }
  19.         /**
  20.          * 求最大公约数
  21.          * @param n
  22.          * @param m
  23.          * @return
  24.          */
  25.         private static int maxYs(int n,int m){
  26.                 int temp=0;
  27.                 for(int i=1;i<m;i++){
  28.                         if(n%i==0&&m%i==0)//如果n和m同时能整除同一个i
  29.                                 temp=i;//将i值赋给临时变量temp
  30.                 }
  31.                 return temp;//返回循环结束最后的数值temp即是最大公约数
  32.         }
  33.         public static void main(String[] args){
  34.                 int n,m;
  35.                 System.out.print("please enter the first number:");
  36.                 Scanner in=new Scanner(System.in);//获取第一个输入的数字
  37.                 n=in.nextInt();
  38.                 System.out.print("\nplease enter the second number:");
  39.                 m=in.nextInt();//获取第二个输入的数字
  40.                 if(n<m){//如果输入的第一个数小于第二个输入的数,调换一下
  41.                         int temp=n;
  42.                         n=m;
  43.                         m=temp;
  44.                 }
  45.                 int min=minBs(n,m);//调用求最小公倍数函数
  46.                 System.out.println("最小公倍数:"+min);
  47.                 int max=maxYs(n,m);//调用求最大公约数函数
  48.                 System.out.println("最大公约数:"+max);
  49.         }

  50. }
复制代码
题2截图:


评分

参与人数 1技术分 +2 收起 理由
Just_Only + 2 很给力!

查看全部评分

回复 使用道具 举报
较难的 我放弃了..  10几年没学数学了 忘了.. 表示这个真不会了

TestOne.rar

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

回复 使用道具 举报
希望版主等下能贴个较难的答案出来..  我也顺便复习下小学的数学
回复 使用道具 举报

运行结果


第二题

运行结果

回复 使用道具 举报
本帖最后由 王楚鑫 于 2013-6-25 13:04 编辑

第五题
  1. /*
  2. 5.将一个正整数分解质因数,例如:输入参数90,打印出90=2*3*3*5;
  3. */
  4. public class Factor
  5. {
  6. public static void main(String args[])
  7. {
  8. int i;
  9. int n=16; //输入语句给忘了、先直接赋值了
  10. System.out.print(n+"=");

  11. for(i=2;i<n;i++) //分解质因数、从除1外最小的质数开始循环
  12. {
  13. while(n!=i) //如果这个质数恰等于n,则说明分解质因数的过程已经结束,否则进行分解
  14. {
  15. if(n%i==0) //取i余0说明i是一个因数、输出该质因数
  16. {
  17. System.out.print(i+"x");
  18. n=n/i; //控制循环、操作与i相对的另一个因数是否是质数、不是质数即循环进行分解
  19. }
  20. else
  21. break;
  22. }
  23. }
  24. System.out.print(n); //输出使循环结束的质因数
  25. }
  26. }
复制代码
回复 使用道具 举报

运行结果

评分

参与人数 1技术分 +2 收起 理由
Just_Only + 2 赞一个!

查看全部评分

回复 使用道具 举报
本帖最后由 ㄗs:/|丶hearts 于 2013-6-29 12:25 编辑
  1. package com.java.test;

  2. import java.util.Scanner;

  3. public class Fraction {

  4. /**
  5. * @param args
  6. * 有一个分数序列:2/1,3/2,5/3,8/5,13/8,21/13…求出这个数列的前20项之和
  7. */
  8. public static void main(String[] args) {
  9. // TODO Auto-generated method stub
  10. System.out.println("--计算一个分数序列的前n项和--");
  11. System.out.println("请输入一个正整数n:");
  12. //从控制台读取输入的数字
  13. Scanner s = new Scanner(System.in);
  14. int n = s.nextInt();

  15. System.out.println("这个分数序列的前n项的和为:"+method(n));
  16. }

  17. public static double method(int n)
  18. {
  19. double sum = 0.0;
  20. //double x = 2.0,y = 1.0;
  21. int x = 2,y = 1;
  22. for(int i = 0; i< n;i++)
  23. {
  24. //将x/y的结果强制转换成double
  25. sum += (double)x/y;
  26. //将x的值保留 赋给s
  27. int s = x;
  28. //将x+y赋给x 作为下一个数的分子
  29. x = x+y;
  30. //将分子的值赋给y 作为下个数的分母
  31. y = s;
  32. }
  33. return sum;
  34. }
  35. }
复制代码

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

QQ图片20130624230232.jpg

评分

参与人数 1技术分 +1 收起 理由
Just_Only + 1

查看全部评分

回复 使用道具 举报
        终于调试好了,那个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();
        }

}



运行结果


评分

参与人数 1技术分 +1 收起 理由
Just_Only + 1 辛苦了。

查看全部评分

回复 使用道具 举报
我做的三分的题,你刚开始加了3分,又减掉,加一分,请问版主是什么意思
回复 使用道具 举报
金辉 发表于 2013-6-25 08:07
我做的三分的题,你刚开始加了3分,又减掉,加一分,请问版主是什么意思

请看上面的说明,我上面说的很清楚的哦,请谅解。
回复 使用道具 举报
帖子是不可见的,我看不到啊
回复 使用道具 举报
简单: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记住每次变化的结果。

  1. class Test1
  2. {
  3. public static void main(String[] args)
  4. {
  5. double sum=0;//由于x/y的结果不一定是整数,所以定义了double类型来存储
  6. for (int x=2,y=1,z=0;z<20 ;z++ )//累加思想需要使用到循环结构,z是用于进行累加20次的动作
  7. {
  8. sum=sum+x/y;
  9. int temp=x; x=x+y; y=temp;//对x和y进行重新赋值
  10. }
  11. System.out.println("该数列前20项之和是"+sum);
  12. }
  13. }
  14. //打印结果是“该数列前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.
  1. class Test2
  2. {
  3. public static void main(String[] args)
  4. {
  5. double h=100,sum=0;
  6. for (int x=0;x<10 ;x++ )
  7. {
  8. sum=sum+h+h/2;//由sum来记录每一次下落反跳的总高度
  9. h=h/2;//本次的反跳高度即是下次的下落高度,每次高度减半
  10. }
  11. sum=sum-h/2;//第十次落地时没有反跳,需要将这段高度减去
  12. System.out.println("第十次落地时小球共经过"+sum+"m;第十次反弹高度为"+h+"m");
  13. }
  14. }
  15. //打印结果是“第十次落地时小球共经过299.658203125m;第十次反弹高度为0.09765625m”。
复制代码



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

评分

参与人数 1技术分 +1 收起 理由
Just_Only + 1

查看全部评分

回复 使用道具 举报
算了,各种不方便,我看不到你回复的,又不能发消息。几个技术分而已,不在乎。还有那题没必要去抄,你发贴前一天我就做过了,以前蓝桥杯的一道题目而已
回复 使用道具 举报
本帖最后由 关亮何 于 2013-6-26 19:05 编辑

简单的第一题:
  1. public class test1 {

  2.         public static void main(String[] args) {
  3.                 // TODO Auto-generated method stub

  4.                 //定义sum为数列之和的变量
  5.                 float sum = 0;
  6.                 //第一项的分母a1,分子a2
  7.                 int a1 = 1;
  8.                 int a2 = 2;
  9.                 //定义一个长度为20的数组。
  10.                 float[] b = new float[20];
  11.                 //循环20遍
  12.                 for (int i = 0; i < b.length; i++) {
  13.                         b[i]= (float)a2/a1;
  14.                         sum +=b[i];
  15.                         //后一项分子是前一项分子分母之和,分母为前一项的分子。
  16.                         int temp = a2;
  17.                         a2 =a1+a2;
  18.                         a1 = temp;
  19.                 }
  20.                 System.out.println("这个数列的前20项之和:"+sum);
  21.         }
  22. }
复制代码
运行结果:这个数列的前20项之和:32.660263
简单的第二题:
  1. public class test2 {
  2.         /**
  3.          * 思路:定义一个方法,age(1)返回的是10,而age(n)=age(n-1)+2,即前面的人+2岁得后一项。
  4.          * @param args
  5.          */
  6.         //定义一个age(n)方法
  7.         public static int age(int n){
  8.                 int old;
  9.                 if(n==1){
  10.                         //age(1)=10,即最后一个人为10岁
  11.                         old = 10;
  12.                 }else{
  13.                         //后面比前面的人大2岁
  14.                         old = age(n-1)+2;
  15.                 }
  16.                 return old;
  17.         }
  18.         public static void main(String[] args) {
  19.                 // TODO Auto-generated method stub
  20.                 System.out.println("第五个人的岁数为"+age(5));
  21.         }
  22. }
复制代码
运行结果:第五个人的岁数为18

一般的第一题:
  1. public class test2 {

  2.         //求这个球反跳的高度
  3.         public static float height(int n){
  4.                 float h=0;
  5.                 if (n==1) {
  6.                         //第一次落地时反跳的高度
  7.                         h=100/2;
  8.                 }else{
  9.                         //后面反跳的高度为前面一次的高度一半。
  10.                         h= height(n-1)/2;
  11.                 }
  12.                 return h;
  13.         }
  14.         //求这个球所有运行轨迹的长度。
  15.         public static float total(int n){
  16.                 float t=0;
  17.                 if (n==1) {
  18.                         //第一次落地的长度
  19.                         return 100;
  20.                 }else{
  21.                         //把除了第一次所有的落地前一弹一落相加。
  22.                         for (int i = 2; i <= n; i++) {
  23.                                 //落地前的一弹一落长度是落地后反弹高度的4倍
  24.                                 t += height(i)*4;
  25.                         }
  26.                         return t+100;
  27.                 }
  28.                
  29.         }
  30.         public static void main(String[] args) {
  31.                 // TODO Auto-generated method stub
  32.                 System.out.println("第10次反弹的高度为:"+height(10));
  33.                 System.out.println("第10次所有的运行长度为:"+total(10));
  34.         }

  35. }
复制代码
第10次反弹的高度为:0.09765625
第10次所有的运行长度为:299.60938
一般的第二题:
  1. public class test4 {

  2.         public static void main(String[] args) {
  3.                 // TODO Auto-generated method stub
  4.                 //一个数组放1,2,3,4这四个数
  5.                 int[] nums = new int[]{1,2,3,4};
  6.                 //组成的新数放进newnums数组中
  7.                 int[] newnums = new int[100];
  8.                 int count=0;
  9.                 //i是新数的百位数,j是新数的十位数,k是新数的个位数
  10.                 for (int i = 0; i < nums.length; i++) {
  11.                         for (int j = 0; j < nums.length; j++) {
  12.                                 //如果百位、十位数相同就跳过
  13.                                 if (nums[i]==nums[j]) {
  14.                                         continue;
  15.                                 }
  16.                                 for (int k = 0; k < nums.length; k++) {
  17.                                         //如果百位、个位相同或十位、个位相同就跳过
  18.                                         if (nums[i]==nums[k]||nums[j]==nums[k]) {
  19.                                                 continue;
  20.                                         }
  21.                                         for (int k2 = 0; k2 < newnums.length; k2++) {
  22.                                                 //把组成的新数放进为0的数组元素中。
  23.                                                 if (newnums[k2]==0) {
  24.                                                         newnums[k2]=nums[i]*100+nums[j]*10+nums[k];
  25.                                                         count++;
  26.                                                         break;
  27.                                                 }
  28.                                         }
  29.                                 }
  30.                         }
  31.                 }
  32.                 System.out.println("这样的数的个数有"+count);
  33.                 System.out.println("这些数是:");
  34.                 for (int i = 0; i < count; i++) {
  35.                         System.out.print(newnums[i]+"\t");
  36.                 }        
  37.         }
  38. }
复制代码
这样的数的个数有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        


评分

参与人数 1技术分 +3 收起 理由
Just_Only + 3 很给力!

查看全部评分

回复 使用道具 举报
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);
                }
        }




       
}
回复 使用道具 举报
第五题
  1. /*
  2. 5.将一个正整数分解质因数,例如:输入参数90,打印出90=2*3*3*5;
  3. */
  4. public class Factor
  5. {
  6.         public static void main(String args[])
  7.         {
  8.                 int i;
  9.                 int n=16;                //输入语句给忘了、先直接赋值了
  10.                 System.out.print(n+"=");

  11.                 for(i=2;i<n;i++)        //分解质因数、从除1外最小的质数开始循环
  12.                 {
  13.                             while(n!=i)        //如果这个质数恰等于n,则说明分解质因数的过程已经结束,否则进行分解
  14.                             {
  15.                                       if(n%i==0)        //取i余0说明i是一个因数、输出该质因数
  16.                                       {
  17.                                         System.out.print(i+"x");
  18.                                         n=n/i;        //控制循环、操作与i相对的另一个因数是否是质数、不是质数即循环进行分解
  19.                                       }
  20.                                       else
  21.                                         break;
  22.                             }
  23.                 }       
  24.                 System.out.print(n);                //输出使循环结束的质因数
  25.         }
  26. }
复制代码

评分

参与人数 1技术分 +1 收起 理由
Just_Only + 1 很好,补全了。。。

查看全部评分

回复 使用道具 举报
再完成一个

/*
题目:有一个分数序列: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));//输出结果
        }
}


截图




评分

参与人数 1技术分 +1 收起 理由
Just_Only + 1 赞一个!

查看全部评分

回复 使用道具 举报
  1. package com.java.test;

  2. public class Age {

  3.         /**
  4.          * @param args
  5.          * 有五个人坐在一起,问第五个人是多少岁,他说比第四个人大两岁。问第四个人是多少岁,他说比第三个人大两岁。
  6.          * 问第三个人是多少岁,他又说比第二个人大两岁。问最后一个人,他只是说10岁,请问第五个人多大。
  7.          */
  8.         public static void main(String[] args) {
  9.                 // TODO Auto-generated method stub

  10.                 int age = 10;
  11.                 int i = 4;
  12.                 //每循环一次  i自减1 ,i不大于0时退出循环
  13.                 while(i-- >0)
  14.                 {
  15.                         //下个人的年龄
  16.                         age += 2;
  17.                 }
  18.                 System.out.println(age);
  19.         }
  20. }
复制代码
运行结果:18    就不用贴图了吧
话说 问题中少了一句 :第二个人比第一个人大两岁

评分

参与人数 1技术分 +1 收起 理由
Just_Only + 1 赞一个!

查看全部评分

回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马