乌龟赛跑编程
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);
}
}
Ⅱ JAVA的程序设计，设计一个龟兔赛跑的线程类模拟参与赛跑。
感觉挺有趣的，试着写了个~
public static void main(String[] arg) {
new wugui().run();
new tuzi().run();
}
static class wugui {
final int su = 4;// 乌龟的速度是每秒4米
public static boolean hasEnd = false;// 是否已经跑到终点
public void run() {
new Thread() {
public void run() {
int distance = 0;
while (distance < 100) {
try {
Thread.sleep(1000);
distance += su;
System.out.println("小乌龟跑了" + distance + "米");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
hasEnd = true;
if (tuzi.hasEnd) {
System.out.println("呜呜，差一点点就赢了~");
} else {
System.out.println("胜利是属于有准备的人的，你的自大害了你！-------乌龟赢了");
}
}
}.start();
}
}
static class tuzi {
final int su = 5;// 兔子的速度是每秒5米
public static boolean hasEnd = false;// 是否已经跑到终点
public void run() {
new Thread() {
@Override
public void run() {
int distance = 0;// 跑了多少米
boolean hasXiuXi = false;// 是否休息过
while (distance < 100) {
try {
Thread.sleep(1000);
distance += su;
System.out.println("小兔子跑了" + distance + "米");
if (distance > 50 && !hasXiuXi) {
System.out.println("小兔子累了，决定休息一会儿~");
Thread.sleep((long) (10000 * Math.random()));
System.out.println("小兔子休息够了，又开始跑了，决一胜负吧！");
hasXiuXi = true;
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
hasEnd = true;
if (wugui.hasEnd) {
System.out.println("呜呜，早知道就不休息了~");
} else {
System.out.println("哇哈哈，你个战5渣也想赢我~~做梦去吧！！-------兔子赢了");
}
}
}.start();
}
}
Ⅲ 酷酷带你用scratch制作龟兔赛跑
【概述】
乌龟和兔子在舞台上折返跑，乌龟跑得慢，兔子跑得快。
【知识点】
学会放大和缩小角色学会添加和删除角色学会切换下一个造型学会调整运动的快慢和造型的切换速度【教学目标】
任意添加1个背景，删除小猫角色，添加1个乌龟角色和1和兔子角色。
【操作步骤】
任意添加1个背景，如下图：
在角色库的“动物”分类下，选中乌龟和兔子角色，点击“确定”按钮
拖动角色调整角色的位置，使用舞台区右上角的放大和缩小按钮来调整角色的大小。如下图：
选中乌龟，为乌龟添加折返跑的脚本，别忘了调整角色的旋转模式。然后把【移动10步】改成【移动1步】
写出兔子折返跑的脚本，注意旋转模式，并将兔子的移动速度设为10
加入【下一个造型】【等待0.2秒】，如下图：
兔子的移动变成了一卡一卡的，很不协调，兔子的卡顿是由于将【移动10步】跟【等待0.2】秒放在同一个【重复执行】中导致的，每跑10步都要等一下，肯定不流畅，
把不同功能的脚本分开，写入到不同的【重复执行】中去。
再新建一个【当绿旗被点击】和【重复执行】，将【下一个造型】【等待0.2秒】放进去，如下图
可以看到现在好多了。前边的乌龟之所以不卡顿，是因为移动速度比较慢，看不出来了
想要学习更多知识，记得关注酷酷哦
Ⅳ 用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.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);
}
}
//不知道兔子和乌龟的步长时间是否按每秒。 这里程序只考虑依次递增频率