龜兔賽跑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);
}
}