龟兔赛跑java
packagep1;
importjava.util.Scanner;
/**
*龟兔赛跑
*
*@authoryugi
*/
publicclassTortoiseHare
{
publicstaticfinalStringT="T";
publicstaticfinalStringR="R";
publicstaticfinalStringD="D";
privatestaticvoidrace(intv1,intv2,intt,ints,intl,
intstart1,intstart2,ints1,ints2,inttime,
booleanrest)
{
if(
v1<0||v2<0||t<0||s<0||l<0
||v1>100||v2>100||t>300||s>10||l>10000
||l%v1!=0||l%v2!=0
)
{
try
{
thrownewException("参数输入不合标准!");
}
catch(Exceptione)
{}
}
else
{
//兔子或乌龟已经到达终点
if(s1>=l||s2>=l)
{
if(s1>s2)
{
System.out.println(R);
System.out.println(time+start1);
}
elseif(s1<s2)
{
System.out.println(T);
System.out.println(start2);
}
else
{
System.out.println(D);
System.out.println(start2);
}
return;
}
//兔子开始休息
if(!rest&&s1-s2>=t)
{
rest=true;
time+=s;
}
//兔子休息了s秒(不包括s秒,第s秒开始行动,题目意思不是s秒之后)
if(rest&&start2-start1>=s)
{
//开始跑了(不休息)
rest=false;
}
//兔子不休息的时候跑
if(!rest)
{
start1++;
s1=v1*start1;
}
//乌龟总在跑
start2++;
s2=v2*start2;
//递归调用
race(v1,v2,t,s,l,start1,start2,s1,s2,time,rest);
}
}
publicstaticvoidmain(String[]args)
{
System.out.println("输入只有一行，包含用空格隔开的五个正整数v1，v2，t，s，l，"+
" 其中(v1,v2<=100;t<=300;s<=10;l<=10000且为v1,v2的公倍数)"+
" 退出输入n/N,否则继续:");
Scannerscanner=newScanner(System.in);
Stringline=null;
Stringreg="^([1-9]\d*|\d)\s+([1-9]\d*|\d)\s+([1-9]\d*|\d)\s+([1-9]\d*|\d)\s+([1-9]\d*|\d)$";
while(scanner.hasNextLine())
{
line=scanner.nextLine().trim();
if("n".equalsIgnoreCase(line))
{
break;
}
if(!line.matches(reg))
{
System.err.println("输入不对,重新输入:");
}
else
{
String[]input=line.split("\s+");
intv1=Integer.parseInt(input[0]);
intv2=Integer.parseInt(input[1]);
intt=Integer.parseInt(input[2]);
ints=Integer.parseInt(input[3]);
intl=Integer.parseInt(input[4]);
race(v1,v2,t,s,l,0,0,0,0,0,false);
System.out.println("退出输入n/N,否则继续:");
}
}
scanner.close();
}
}
⑵ 用java模拟龟兔赛跑，能设置比赛距离。在任意时间段内兔子的速度是随机的,乌龟的速度是恒定的。
package test;
import java.util.Observable;
import java.util.Observer;
import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.stream.Stream;
public class Running {
public static int distance;
private static final CountDownLatch CDL = new CountDownLatch(1);
public static final void start(Animal...animals) {
if (animals != null && animals.length > 0) {
Stream.of(animals).forEach(a -> {
Thread th = new Thread(a);
th.start();
});
// register observers to each animal
for (Animal a: animals) {
for (Animal a2: animals) {
a.addObserver(a2);
}
}
CDL.countDown();
System.out.println("Go!!!!!!");
}
}
public static abstract class Animal extends Observable implements Runnable, Observer {
protected final String name;
protected int speed; // m/s
protected boolean randomSpeed;
private int remaining;
private int speedLimitation;
private Random ran;
private ScheledExecutorService es = Executors.();
protected Animal(final String name, final int speedLimitation) {
this.randomSpeed = true;
this.speedLimitation = speedLimitation;
this.ran = new Random();
this.name = name;
}
protected Animal(final int speed, final String name) {
this.name = name;
this.speed = speed;
}
@Override
public void run() {
try {
CDL.await();
} catch (InterruptedException e) {
}
es.scheleAtFixedRate(() -> {
if (randomSpeed) {
int currentSpeed = ran.nextInt(speedLimitation);
if (currentSpeed > speed) {
System.out.println(name + " 开始加速.");
} else if (speed < currentSpeed) {
System.out.println(name + " 慢了下来.");
} else {
System.out.println(name + " 继续前进.");
}
speed = currentSpeed;
}
if (remaining == 0) {
remaining = distance - speed;
} else {
remaining -= speed;
}
System.out.println(name + " 距离终点还有" + remaining + "米.");
if (remaining <= speed) {
setChanged();
notifyObservers(name);
}
}, 0, 1, TimeUnit.SECONDS);
}
@Override
public void update(Observable o, Object arg) {
String name = (String) arg;
es.shutdownNow();
if (!this.name.equals(name))
System.out.println(name + " 停止了继续奔跑.");
else
System.out.println(name + " 赢得了比赛！");
}
}
public static void main(String[] args) {
Running.distance = 100;
Running.start(new Rabbit("小兔兔", 5), new Rabbit("小龟龟", 2));
}
}
class Rabbit extends Running.Animal {
protected Rabbit(String name, int speedLimitation) {
super(name, speedLimitation);
}
}
class Tortoise extends Running.Animal {
protected Tortoise(int speed, String name) {
super(speed, name);
}
}
⑶ java 用多线程模拟龟兔赛跑：
public class TortoiseAndHareRace {
public static void main(String[] args) {
Runnable vs=new Race();
Thread hare=new Thread(vs,"Hare");
Thread tortoise =new Thread(vs,"Tortoise");
System.out.println("Ready!GO!");
hare.start();
tortoise.start();
}
}
class Race implements Runnable{
private static final int S=1000;
@Override
public void run() {
if(Thread.currentThread().getName().equals("Hare")){
int sHare=0;
while(sHare<=S){
sHare+=5;
if(sHare%20==0)
try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}
}
}else{
int sTortoise=0;
while(sTortoise<=S){
sTortoise++;
if(sTortoise%100==0)
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
⑷ 求龟兔赛跑Java代码
import java.applet;
import java.awt;
class RunningAnimal extends Thread {
int distance;
int speed;
int sleeptime;
int length;
List list;
String name;
public void run() {
while (distance < length){
distance+=speed;
try {
sleep(sleeptime);
}
catch (InterruptedException e) {
}
list.addItem(name+":"+distance);
}
list.addItem(name+" arrives.");
}
RunningAnimal(String aname,int alldistance
,int aspeed,int asleeptime,List alist)
{
name=aname;
length=alldistance;
speed=aspeed;
sleeptime=asleeptime;
distance=0;
list=alist;
}
}
public class TestThread extends Applet {
RunningAnimal turtle;
RunningAnimal rabit;
public void init() {
setLayout(new BorderLayout());
List lList=new List();
add("Center",lList);
turtle=new RunningAnimal("Turtle",500,20,20,lList);
turtle.setPriority(7);
turtle.start();
rabit=new RunningAnimal("Rabit",500,300,500,lList);
rabit.setPriority(3);
rabit.start();
}
}
⑸ java模拟龟兔赛跑问题用多线程实现
import java.util.Date;
public class Test extends Thread{ private int tortoise_walk = 0; // 乌龟已跑长度存放变量
private int rabbit_walk = 0; // 兔子已跑长度存放变量
private int finish = 1000; // 终点
private volatile boolean hasWinner = false;// 胜利者诞生 /**
*
* @ClassName: Tortoise_Run
* @Description: TODO(乌龟奔跑线程)
* @author guotingchao
* @date 2012-3-6 上午10:20:45
*
*/
class Tortoise_Run implements Runnable {
@Override
public void run() {
try {
while (!hasWinner) {
if (tortoise_walk % 100 == 0 && (tortoise_walk != 0||tortoise_walk>=finish)) { //乌龟每100米休息500毫秒
System.out.println("乌龟休息中………………");
Thread.sleep(500);
}
tortoise_walk++;
System.out.println("乌龟已跑"+tortoise_walk+"米");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} /**
*
* @ClassName: Rabbit_Run
* @Description: TODO(兔子奔跑线程)
* @date 2012-3-6 上午10:25:10
* @author guotingchao
*/
class Rabbit_Run implements Runnable {
@Override
public void run() {
try {
while (!hasWinner) {
if (rabbit_walk % 20 == 0 && (rabbit_walk != 0||rabbit_walk>=finish)) { //兔子每20米休息500毫秒
System.out.println("兔子休息中………………");
Thread.sleep(500);
}
rabbit_walk=rabbit_walk+5; //每秒跑5步
System.out.println("兔子已跑"+rabbit_walk+"米");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
@Override
public void run(){
new Thread(new Rabbit_Run()).start();
new Thread(new Tortoise_Run()).start();
}
/**
* @Title: main
* @Description: TODO(
* 赛程1000米，兔子跑5米，乌龟跑1米，兔子每20米休息500毫秒，乌龟每100米休息500毫秒。谁先到终点就结束程序
* ，并显示获胜方。)
* @param @param args
* @param @throws Exception 设定文件
* @author guotingchao
* @return void 返回类型
* @throws
*/
public static void main(String[] args) throws Exception {
long temp_actionTime=System.currentTimeMillis();
System.out.println("比赛开始："+new Date(temp_actionTime)+"毫秒");
Test t=new Test();
new Thread(t).start();
while(true){
if(t.tortoise_walk>=t.finish||t.rabbit_walk>=t.finish){
t.hasWinner=true;
break;
}
}
String winnnerName=t.tortoise_walk>t.rabbit_walk?"乌龟":"兔子";
long temp_lastTime=System.currentTimeMillis();
System.out.println(winnnerName+"胜利");
System.out.println("比赛结束："+new Date(temp_lastTime)+"毫秒");
System.out.println("所耗时间："+(temp_lastTime-temp_actionTime)+"毫秒");
System.out.println("兔子="+t.rabbit_walk+" 乌龟="+t.tortoise_walk);
}
}
//不知道兔子和乌龟的步长时间是否按每秒。 这里程序只考虑依次递增频率
⑹ Java的龟兔赛跑多线程问题
publicclassCompetition{
=false;//用来标记是否有人到达终点，到达终点后游戏结束
//乌龟的实现方式
{
privatevolatileinttotal=0;//用来记录当前已经前行了多少距离
@Override
publicvoidrun(){
while(!gameOver){
intstep=(int)(Math.random()*5+1);//产生1-5的随机数
total+=step;
try{
Thread.sleep(200);
}catch(InterruptedExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}
}
publicintgetTotal(){
returntotal;
}
}
//兔子的实现方式
{
privatevolatileinttotal=0;
@Override
publicvoidrun(){
while(!gameOver){
intstep=(int)(Math.random()*5+1);
total+=step;
try{
Thread.sleep(200);
}catch(InterruptedExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}
}
publicintgetTotal(){
returntotal;
}
}
/**
*@paramargs
*/
publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
finalTortoisetortoise=newTortoise();
finalRabbitrabbit=newRabbit();
newThread(tortoise).start();
newThread(rabbit).start();
//下面多起了一个线程，相当于比赛的时候的裁判员，他每隔一段时间就看一下是否有人到达终点，若有人到达则宣判该人获胜，游戏结束
newThread(newRunnable(){
@Override
publicvoidrun(){
//TODOAuto-generatedmethodstub
while(!gameOver){
inttorLen=tortoise.getTotal();//获得乌龟前行的距离
intrabLen=rabbit.getTotal();//获得兔子前行的距离
System.out.println("乌龟:"+torLen+",兔子"+rabLen);
if(torLen>=100&&rabLen<100){
System.out.println("乌龟获胜!!!");
gameOver=true;
}elseif(rabLen>=100&&torLen<100){
System.out.println("兔子获胜!!!");
gameOver=true;
}elseif(rabLen>=100&&torLen>=100){//这里有可能两人同时到达终点
System.out.println("同时到达终点!!!");
gameOver=true;
}
try{
Thread.sleep(210);
}catch(InterruptedExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}
}
}).start();
}
⑺ java中龟兔赛跑问题结果为什么出现小数点后好多位
这是浮点数运算误差造成的，在所有计算机程序设计语言中都会出现的，不可避免，具体原因这里三言两语说不清，自己网络。解决办法就是尽量改用整数运算，比如0.1米可以改为1分米，然后用整型变量来储存和运算，最后输出的时候如果要用米为单位，再把结果除以10即可。
⑻ 用JAVA多线程实现龟兔赛跑
程序如下：
/**
*
* GuiTuSaiPao.java
* @author Antonio
* 2009年9月2日20:16:33
* 实现Runnable接口中的run方法
*
*/
public class GuiTuSaiPao implements Runnable {
private String name;
private int length=0;
public GuiTuSaiPao(){}
public GuiTuSaiPao(String name){
this.name=name;
}
public void run(){
while(true){
//每次停500毫秒
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
//向前跑十米
length+=10;
System.out.println(name+"已跑了"+length+"米.");
//到达终点
if(length>=100){
System.out.println(name+",已经到达终点!");
//结束赛跑,break
break;
}
}
}
public static void main(String[] args) {
GuiTuSaiPao wugui=new GuiTuSaiPao("乌龟");
GuiTuSaiPao tuzi=new GuiTuSaiPao("兔子");
Thread thread=new Thread(wugui);
Thread thread2=new Thread(tuzi);
//启动线程
thread.start();
thread2.start();
}
}
输出结果：（不一定每次都一样！）
乌龟已跑了10米.
兔子已跑了10米.
兔子已跑了20米.
乌龟已跑了20米.
乌龟已跑了30米.
兔子已跑了30米.
兔子已跑了40米.
乌龟已跑了40米.
兔子已跑了50米.
乌龟已跑了50米.
乌龟已跑了60米.
兔子已跑了60米.
乌龟已跑了70米.
兔子已跑了70米.
乌龟已跑了80米.
兔子已跑了80米.
兔子已跑了90米.
乌龟已跑了90米.
兔子已跑了100米.
兔子,已经到达终点!
乌龟已跑了100米.
乌龟,已经到达终点!
完全看rp，这就是线程！
给分吧，哈哈
⑼ JAVA编程题龟兔赛跑
class Animal {
public double speed;
public void run(int length) {
System.out.println(length/this.speed);
}
}
class Rabbit extends Animal {
Rabbit(int speed) {
super.speed = speed;
}
@Override
public void run(int length) {
System.out.println("Rabbit time = "+length/this.speed +" seconds");
}
}
class Tortoise extends Animal {
Tortoise(int speed) {
super.speed = speed;
}
@Override
public void run(int length) {
System.out.println("Tortoise time = "+length/this.speed +" seconds");
}
}
public class Match {
public static int length = 100;
private static void begin(Rabbit r,Tortoise t) {
r.run(length);
t.run(length);
}
public static void main(String[] args) {
Rabbit r = new Rabbit(20);
Tortoise t = new Tortoise(5);
begin(r,t);
}
}