（奖励3分题目--24小时后关闭此贴------算法题）

包晗 · 包晗

本帖最后由包晗于 2012-7-21 01:58 编辑

/*
100米落下的球,落地后跌回一半,求第10次落下时候,经过了多少米,反弹多高?
思路：x=100除以2.再赋予x
x/2 是第一次反弹 10次就是第10次落下后的反弹
因为初始化是球在100的高空处只要落下来就是第一次循环10次
落下经过多少米，设置一个SUM来记录 x的值。将
落下来1次经过了100米落下来两次经过了100+50+50 第三次是100+50+50+25+25 以此类推 x是第十落地后弹起来的值
要将其去除掉。
求经过多少米。理论上就是落下的米数+弹起来的米数。。。。。
通过FOR循环求出来的sum 要减去第十落地后弹起来的值再乘以2 外加第一次落下的100米
*/
class Boll
{
double x=100,sum;
public void show()
{
for (int i=1;i<=10 ;i++ )
{
x=x/2.0;
sum+=x;
}
sum=(sum-x)*2+100;//x是第十次弹起来的米数
System.out.println("第十次反弹为"+x+"米");
System.out.println("第十次反弹经过了"+sum+"米");
}
}
class BollDemo
{
public static void main(String[] args)
{
Boll o =new Boll();
o.show();
}
}

复制代码

对了吗？

三分啊，眼睛都绿了。结果思路程序都写着。。
黑马我想来

rslheima · rslheima

本帖最后由 rslheima 于 2012-7-21 02:06 编辑

大半夜的写这玩意，呵呵，滔哥，给分不？？？

package 滔哥答题;
class Ball{
double sum;
double temp;
double Height;
public static void main(String[] args){
Ball ball=new Ball();
ball.sum(100,10);//输入离地的高度100，经过几次反弹：10
}
public void sum(double initHeight,int times ){
int t=0;
Height=initHeight;
int n=times++;
while(initHeight>0&&t<times){
initHeight=bounce(initHeight,t);
t++;
if(t>1){
System.out.println("第"+(t-1)+"次的反弹的高度是"+initHeight+"米");
}
if(t<=n)
System.out.println("第"+t+"次落地时经过了"+sum+"米");
}
}
public double bounce(double initHeight,int t){
initHeight=Height/Math.pow(2,t);//此处用的是初始高度和反弹高度的关系定义的方法
if(t==0){sum+=initHeight;}
else{temp=initHeight*2;
sum+=temp;//计算经历的路程
}
return initHeight;//返回反弹的高度
}
}
结果：
第1次落地时经过了100.0米
第1次的反弹的高度是50.0米
第2次落地时经过了200.0米
第2次的反弹的高度是25.0米
第3次落地时经过了250.0米
第3次的反弹的高度是12.5米
第4次落地时经过了275.0米
第4次的反弹的高度是6.25米
第5次落地时经过了287.5米
第5次的反弹的高度是3.125米
第6次落地时经过了293.75米
第6次的反弹的高度是1.5625米
第7次落地时经过了296.875米
第7次的反弹的高度是0.78125米
第8次落地时经过了298.4375米
第8次的反弹的高度是0.390625米
第9次落地时经过了299.21875米
第9次的反弹的高度是0.1953125米
第10次落地时经过了299.609375米
第10次的反弹的高度是0.09765625米

复制代码

金_鑫 · 金_鑫

public class Test {
public static void main(String[] args) {
double i= 100;//设置高度100米
double j = i / 2; //第一次反弹
int w = 0;//初始化
for (w = 2;w<= 10;w ++){//循环
i = i+ j * 2; //第i次落地经过多少米
j = j / 2;//第i次反弹的高度
}

System.out.println(i+"米");
System.out.println(j"米");
}

}

运行结果如下：

王宝康 · 王宝康

package exercise;
public class SeekHeight {
/**
* @author Wangbaokang
* @param args height 球每次弹起的高度；time，第几次弹起，sum，球弹起过程中一共走过的路程
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
SeekHeight(10);
}
public static void SeekHeight(int time){
double height =100,sum = height;
for ( int i =1; i <= time ; i++) {
sum += height;
height = height * 0.5;
sop("第"+i+"次跳起"+height+"米 "+"第"+i+"次反弹后落地，第"+(i+1)+"次弹起前共经过"+sum+"米");
}
}
public static void sop(Object obj){
System.out.println(obj);
}
}

复制代码

刚才只是计算的跳起的总高度，现在修改了下代码，

应文 · 应文

本帖最后由应文于 2012-7-21 03:25 编辑

/**
下上下上 下上 下 上 下 上 --- 上 球的轨迹：
100 50 50 25 25 12.5 12.5 6.25 6.25 3.125 --- 100/(x^x/2)
| 50 | 25 | 12.5 | 6.25 | 3.125 --- 100/(x^x/2)
| 2 | 4 | 8 | 16 | 32 --- x^x/2
| >2次 | >4 | >6 | >8 | >10 --- >20次
100 50 25 12.5 6.25 ---
1 2 4 8 16 ---
x=1次 >3 >5 >7 >9 ---
*/
class Sum100
{
public static void main(String[] args)
{
// double sum_jishu= 0; //初始基数经过的米数和sum
// double sum_oushu= 0; //初始偶数经过的米数和sum
 double sum = 0; //初始经过的米数总和sum
 double sum_ago = 0; //初始前9次经过的米数和sum
 double sum_last = 0; //初始第十次经过的米数和sum
 double height = 100; //高度
 int order = 20;
 for(int x=1; x<=order; x++)
 {
 /**
这个是第五次弹起时的情况
if(x%2==0&& x!=10)
{
sum_oushu=sum_oushu+high/Math.pow(2,x/2);
}
if(x%2!=0&& x!=10)
{
sum_jishu=sum_jishu+height/Math.pow(2,x/2);
}
if(x==10)
{
sum_qian=height/Math.pow(2,x/2);
sum=sum_jishu+sum_oushu;
}
*/
if(x == 20) //第十次弹起即第20次上下运动
{
sum_last = height/Math.pow(2,x/2); //计算第十次反弹的高度
}
else
sum_ago = sum_ago + height/Math.pow(2,x/2); //计算前19次共进过的米数和
 }
 sum = sum_ago ; //落地时一共进过的米数=前19次共进过的米数和
 System.out.println("小球落地时共经过了："+sum+"米");
 System.out.println("第十次反弹了："+sum_last+"米");
}
}

新手学习中。。

何旭栋 · 何旭栋

本帖最后由何旭栋于 2012-7-21 03:27 编辑

复制代码

class fallingDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
falling(100, 10);
}
public static void falling(int height, int times) {
// TODO Auto-generated constructor stub
String h = ""+height;
/*
* 假设球无限弹，那么总共经过高度为：h = 100+(50+50)+(25+25)+(12.5+12.5)+....
* 如果times是无限，那么h就无限接近300，那么总高度为300减去最后一次弹起的高度乘以2
* 总高度循环相加可能造成精度损失，所以用300减去最后一次弹起的高度的两倍来计算更准确
*/
double sumHeight = 300d;
String upspring = h;
for (int i=1; i<=times; i++){
System.out.println("第"+i+"次落地时共经过："+
(sumHeight-Double.parseDouble(upspring)*2)+" 米");//总高度为300减去最后一次弹起的高度两倍
upspring = half(upspring);
System.out.println("第"+i+"次弹起的高度："+upspring);
}
}
// 如果弹起次数过多直接double计算高度必然造成精度损失，所以转换字符串计算更加精确
public static String half(String height){
int num = 0;
int previous = 0;
StringBuilder sb = new StringBuilder();
if (!height.contains(".")){
num = Integer.parseInt(height);
previous = num;
num = num>>1;
sb.append(num);
if(previous%2 != 0){
sb.append('.');
sb.append(5);
}
}
else{
int index = height.indexOf(".");
num = Integer.parseInt(height.substring(0, index));
char[] chs = height.substring(index+1).toCharArray();
previous = num;
num = num>>1;
sb.append(num);
sb.append('.');
for (char ch : chs){
num = Integer.parseInt(""+ch);
if(previous%2 != 0)
num += 10;
previous = num;
num = num>>1;
sb.append(num);
}
if(previous%2 != 0)
sb.append(5);
}
return sb.toString();
}
}

复制代码

睡觉前看到，不能放过

rioy1 · rioy1

看看题目

rioy1 · rioy1

double height=10000;
double sum=0;
for(int i=1;i<11;i++)
{
sum+=height;
height/=2;
System.out.println(height);
}
System.out.println(sum);

rioy1 · rioy1

rioy1 发表于 2012-7-21 04:10
double height=10000;
double sum=0;
for(int i=1;i

这种题目提高自信啊

朱云坤 · 朱云坤

看一下~

全海波 · 全海波

路过，！！！！！！

朱云坤 · 朱云坤

class Test
{
public static void main(String[] args)
{
double high=100.0;//定义初始高度
double sum=0;//定义一个sum用来记录总路程
for(int a=1;a<=3;a++)
{
sum+=high+(high/2.0);//high+(high/2.0)每次小球从落地到弹起的路程
high=high/2.0;//小球下一次落地的初始高度
}
System.out.println("sum="+(sum-high));//小球第十次落地反弹后的总路程减去
//第十次弹起的路程即为第十次落地时走过的总路程
System.out.println("high"+high);//小球第十次弹起的高度
}
}

复制代码

朱云坤 · 朱云坤

class Test
{
public static void main(String[] args)
{
double high=100.0;//定义初始高度
double sum=0;//定义一个sum用来记录总路程
for(int a=1;a<=10;a++)
{
sum+=high+(high/2.0);//high+(high/2.0)每次小球从落地到弹起的路程
high=high/2.0;//小球下一次落地的初始高度
}
System.out.println("sum="+(sum-high));//小球第十次落地反弹后的总路程减去
//第十次弹起的路程即为第十次落地时走过的总路程
System.out.println("high"+high);//小球第十次弹起的高度
}
}

复制代码

上面的测试忘了改数值
加最终结果补上
C:\Documents and Settings\Administrator\桌面

朱云坤 · 朱云坤

朱云坤发表于 2012-7-21 05:00
上面的测试忘了改数值
加最终结果补上

程潇 · 程潇

看题目~~~~~~~~~~~~

张_涛 · 张_涛

看题目来了

王超 · 王超

{:soso_e145:}

程潇 · 程潇

本帖最后由程潇于 2012-7-21 08:17 编辑

/*
* 题目：
一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？
*
* 思路：
* 假设高度为height，反弹高度为fantan，下落次数num，共经过的路程为distance
*
* 分析每一次下落过程各变量的变换情况：
* 每次下落时一共经过的路程，应该是已经经过的路程，上一次下落后反弹的高度和本次下落的高度之和，即distance=distance+fantan+height
* 下落后反弹高度为原高度的一半fantan=height/2，同时也是下次下落的高度height=fantan，下落后次数增加1次，
*
* 每次下落，重复以上过程，直到次数增加到num，再执行一次下落，即可结束
* 因此可以通过循环实现整个下落反弹的过程，下落次数作为循环终止条件，上述下落过程作为循环体，实现代码如下。
*
* */

package test;

public class Ball {

 public static void fall(double height, int num) {

 double fantan = 0.0d;
 double distance = 0.0d;

 for (int i = 0; i < num; i++) {
 distance = distance + fantan + height;
 fantan = height / 2;
 height = fantan;
 }

 System.out.println("第 " + num + " 次落地时，共经过 " + distance + " 米," + "第 "
 + num + " 次反弹高度 " + fantan + " 米");
 }

 public static void main(String[] args) {

 // 这里为了查看整个下落过程，通过循环，把每次下落后经过的路程和反弹的高度都打印出来
 // 如果要直接得到最终结果，可将以下语句直接写为fall(100,10);
 for (int i = 1; i <= 10; i++)
 fall(100, i);
 }

}

运行结果：
第 1 次落地时，共经过 100.0 米,第 1 次反弹高度 50.0 米
第 2 次落地时，共经过 200.0 米,第 2 次反弹高度 25.0 米
第 3 次落地时，共经过 250.0 米,第 3 次反弹高度 12.5 米
第 4 次落地时，共经过 275.0 米,第 4 次反弹高度 6.25 米
第 5 次落地时，共经过 287.5 米,第 5 次反弹高度 3.125 米
第 6 次落地时，共经过 293.75 米,第 6 次反弹高度 1.5625 米
第 7 次落地时，共经过 296.875 米,第 7 次反弹高度 0.78125 米
第 8 次落地时，共经过 298.4375 米,第 8 次反弹高度 0.390625 米
第 9 次落地时，共经过 299.21875 米,第 9 次反弹高度 0.1953125 米
第 10 次落地时，共经过 299.609375 米,第 10 次反弹高度 0.09765625 米

张_涛 · 张_涛

本帖最后由张_涛于 2012-7-21 07:25 编辑

/**
* 题目：一球从100米高度自由落下，每次落地后反弹回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高?
*/
public class ReboundTest {
public static void main(String[] args) {
// 定义初次落下的高度
float height = 100;
// 定义变量i记录一共反弹的次数
int i = 10;
// 定义变量count记录正在反弹的次数
int count = 1;
// 定义一个float数组记录每次反弹的高度(同时也是下次落下的高度)
float[] reboundArr = new float[i];
rebound(reboundArr, height, i, count);
float sum = countSum(reboundArr) + height - reboundArr[reboundArr.length - 1];
System.out.println("第10次（最后一次）落地时经过的总距离为：" + sum);
System.out.println("第10次（最后一次）反弹的高度为：" + reboundArr[reboundArr.length - 1]);
}
//将每次反弹的高度记录到arr数组当中
public static void rebound(float[] arr, float height, int i, int count) {
arr[count - 1] = height / 2;
count++;
if (count <= i) {
rebound(arr, arr[count - 2], i, count);
}
}
//统计反弹的总高度
public static float countSum(float[] reboundArr) {
float sum = 0;
for (int i = 0; i < reboundArr.length; i++) {
sum += 2 * reboundArr[i];
System.out.println(reboundArr[i]);
}
return sum;
}
}
/*
算法思路：
1. 根据每次落下反弹，因为其都是反弹落下距离的一半，因此多次反弹具有相同的原理，由此想到使用递归算法。
在递归时，通过判断总弹起次数与当前弹起次数控制递归结束。
2. 使用rebound方法记录每次反弹的高度，即为落下高度的一半，存放到数组当中。
3. 而第10次落地时的距离包括第一次落下的距离，不包括第10次弹起的距离。而每次弹起，下次落下的距离是相等的，因此将其乘以2加入总距离当中。
4. 综上，即可得出所求。
*/
运行结果:
第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次（最后一次）落地时经过的总距离为：299.70703
第10次（最后一次）反弹的高度为：0.09765625

复制代码

张凯 · 张凯

看看再说

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

（奖励3分题目--24小时后关闭此贴------算法题）

评分

评分

评分

评分

评分

评分

评分

评分

评分