1.编写一个程序，帮助小学生学习乘法表，利用Math.random产生两个一位正整数，该程序应在控制台中显示一个如下的问题：
6*7等于多少？
学生应在文本字段中输入答案，在程序中检查文本答案，如果答案正确，则在控制台中输出字符串“非常好！”然后提问另一个乘法问题。如果答错了，则在控制台中绘制字符串“错，请重试”然后让学生反复练习同样的问题直到回答正确位置，应当使用一个单独方法来产生每个新问题。当程序开始运行时，如果每次用户回答正确，则应调用该方法一次。输入-1代表退出.
public class Question {
public static int askQuestion()
{
//产生2个10以内随机整数（乘数和被乘数）
int a = (int)(Math.random() * 10);
Random random = new Random();
int b = random.nextInt(10);
System.out.println(a+"*"+b+"等于多少？");
return a*b;
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int answer = askQuestion();//答案
while (true)
{
System.out.println("输入-1退出程序");
int user_answer = scanner.nextInt();
if(user_answer == -1)
{
break;
}
if(answer == user_answer)
{
System.out.println("非常好");
answer = askQuestion();//答案
}
else//打错了，需要重新出刚才那道题
{
System.out.println("错，请重试");
}
}
System.out.println("程序退出");
}
}
2.计算机在教育中的应用称之为计算机辅助教学（CAI）。在开发CAI环境中遇到一个问题就是学生容易疲劳，可通过变换计算机的对话来保持学生的注意力，从而消除疲劳，修改练习1中的程序，为每个正确和不正确的答案打印各种评语，对正确的答案的评语如下所示：
Very good！
Excellent！
Nice work！
Keep up the good work!
对不正确的评语如下所以：
No.Pleasa try again.
Wrong.Try once more.
Don't give up!
Nn.keep trying.
利用随机产生器来选择1到4中的一个数，从而给出对于每个答案一个恰当评语，在paint方法中利用一个switch结构发出评语。
package com.company;
import java.util.Random;
import java.util.Scanner;
/**
* Created by ttc on 2018/1/2.
*/
//1.编写一个程序，帮助小学生学习乘法表，利用Math.random产生两个一位正整数，
该程序应在控制台中显示一个如下的问题：
//
// 6*7等于多少？
//
// 学生应在文本字段中输入答案，在程序中检查文本答案，如果答案正确，则在控制台中输出字符串“非常好！”
// 然后提问另一个乘法问题。如果答错了，则在控制台中绘制字符串“错，请重试”然后让学生反复练习同样的问题直到回答正确位置，
// 应当使用一个单独方法来产生每个新问题。当程序开始运行时，如果每次用户回答正确，则应调用该方法一次。输入-1代表退出.
//Very good！非常好
// Excellent！特别好
// Nice work！做的好
// Keep up the good work! 做的好，继续保持
// 对不正确的评语如下所以：
// No.Please try again. 错，请重试
// Wrong.Try once more. 错，再试试
// Don't give up! 别放弃
// Nn.keep trying. 保持尝试
// 利用随机产生器来选择1到4中的一个数，从而给出对于每个答案一个恰当评语。
public class Question {
static String[] good = {"非常好","特别好","做的好","做的好，继续保持"};
static String[] error = {"错，请重试","错，再试试","别放弃","保持尝试"};
public static int askQuestion()
{
//产生2个10以内随机整数（乘数和被乘数）
int a = (int)(Math.random() * 9)+1;
Random random = new Random();
int b = random.nextInt(9)+1;
System.out.println(a+"*"+b+"等于多少？");
return a*b;
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int answer = askQuestion();//答案
while (true)
{
System.out.println("输入-1退出程序");
int user_answer = scanner.nextInt();
if(user_answer == -1)
{
break;
}
if(answer == user_answer)
{
Random random = new Random();
int index = random.nextInt(4);
System.out.println(good[index]);
answer = askQuestion();//答案
}
else//打错了，需要重新出刚才那道题
{
Random random = new Random();
int index = random.nextInt(4);
System.out.println(error[index]);
}
}
System.out.println("程序退出");
}
}
- 编写一个程序，按照如下规则玩“猜数游戏”：在程序中，通过选择一个1——1000的整数之间随机数来确定要猜的数。程序在一个文本字段 旁显示提示：
猜一个1-1000之间的数
玩家在文本字段中输入第一个数并按下回车键。如果玩家猜错了，程序应当在状态栏中显示“太大了，再试”或者“太小了再试”，帮助玩家“接近”正确答案并清除文本字段，以便用用户能输入下一个猜测的数。当用户输入了正确答案后，就显示“祝贺你，猜对了”,在控制台中清除文本字段以便用户可以再次进行游戏。提示：这个问题种使用查找技术称为二分查找（binary search）。
ublic class GuessNumber {
public static void main(String[] args) {
Random random = new Random();
int guessnum = random.nextInt(1000)+1;//生成一个随机数，让用户猜
// System.out.println(guessnum);
int guessCount = 0;//记录用户猜了多少次
Scanner scanner = new Scanner(System.in);
System.out.println("请猜数");
int input = scanner.nextInt();//用户第一次输入答案
guessCount++;
while (input != guessnum)
{
if(input > guessnum)
{
System.out.println("太大了");
}
else
{
System.out.println("太小了");
}
guessCount++;
System.out.println("请猜数");
input = scanner.nextInt();//让用户再次输入答案
}
System.out.println("程序退出，一共用了"+ guessCount + "次");
}
}
4.（航空订票系统）一家小型航空公司刚购买一台计算机，用于其最新的自动订票系统，要求读者编写新的程序，为该公司唯一一架飞机（运量：10）的每次飞行安排座位，程序应当显示下列选项：
Please type 1 for "smoking"(吸烟区请安1)
Please type 2 for "nonsmoking"（无烟区请安2）
如果没人按下1，那么程序应当在吸烟舱（1——5）为其分配一个座位。如果某人按下2，那么程序应当在无烟舱为期分配一个座位（6——10）。在程序中应打印出一张登记卡，以表明此人的座号以及他在飞机的吸烟舱还是无烟舱。用一个单下标数组描述飞机的订票情况，将所有的数组元素初始化为0，表明所有座位都是空的。在分配一个座位后，设置数组的相应元素为1，则该座位不能再分配，
程序中当然不应分配已分配的座位。单吸烟舱客满后程序应当询问此人是否接受安排的无烟区，反之亦然。如果回答肯定，那么应当进行适当的座位安排。如果回答否定，那么打印消息“Next flight leaves in 3 hours.”（下次航班三小时后起飞）。
package com.company;
import java.util.Scanner;
/**
* Created by ttc on 2018/1/2.
*/
public class FlyOrderTicket {
public static void main(String[] args) {
int[] seats = new int[10];//代表10个空闲座位，其中1-5是吸烟区，6-10是无烟区
Scanner scanner = new Scanner(System.in);
while (true)
{
System.out.println("吸烟区请安1,无烟区请安2,退出按-1");
int command = scanner.nextInt();
if(command == -1)
{
break;
}
else if(command == 1)//在吸烟区给用户分配一个座位
{
int i;
for(i = 0; i < 5; i++)
{
//考察座位是否已经被分配出去了
if(seats[i] == 0)//当前座位可以分配
{
seats[i] = 1;//分配出去了该座位
System.out.println("你的座号是"+(i+1) + "在吸烟区");//打印登记卡
break;
}
}
if(i == 5)//没有在吸烟区找到空余座位
{
System.out.println("吸烟区无座位了，是否接受无烟区的座位？");
String answer = scanner.next();
if(answer.equals("是"))//在无烟区分配座位
{
int j;
for(j = 5; j < 10; j++)
{
//考察座位是否已经被分配出去了
if(seats[j] == 0)//当前座位可以分配
{
seats[j] = 1;//分配出去了该座位
System.out.println("你的座号是"+(j+1) + "在无烟区");//打印登记卡
break;
}
}
if(j==10)//无烟区也没有座位了
{
System.out.println("下次航班三小时后起飞");
}
}
else
{
System.out.println("下次航班三小时后起飞");
}
}
}
else if(command == 2)//在无烟区分配座位
{
int j;
for(j = 5; j < 10; j++)
{
//考察座位是否已经被分配出去了
if(seats[j] == 0)//当前座位可以分配
{
seats[j] = 1;//分配出去了该座位
System.out.println("你的座号是"+(j+1) + "在无烟区");//打印登记卡
break;
}
}
if(j==10)//无烟区没有座位了
{
System.out.println("无烟区无座位了，是否接受吸烟区的座位？");
String answer = scanner.next();
if (answer.equals("是"))//在无烟区分配座位
{
int i;
for (i = 0; i < 5; i++) {
//考察座位是否已经被分配出去了
if (seats[i] == 0)//当前座位可以分配
{
seats[i] = 1;//分配出去了该座位
System.out.println("你的座号是" + (i + 1) + "在吸烟区");//打印登记卡
break;
}
}
if (i == 5)//吸烟区也没有座位了
{
System.out.println("下次航班三小时后起飞");
}
}
}
}
}
System.out.println("谢谢使用");
}
}
第二种算法简单代码
public class FlyOrderTicket {
static int[] seats = new int[10];//代表10个空闲座位，其中1-5是吸烟区，6-10是无烟区
public static int allocSeats(int start, int end)
{
String strArea = "吸烟区";
if(end == 10)
{
strArea = "无烟区";
}
int i;
for(i = start; i < end; i++)
{
//考察座位是否已经被分配出去了
if(seats[i] == 0)//当前座位可以分配
{
seats[i] = 1;//分配出去了该座位
System.out.println("你的座号是"+(i+1) + "在" + strArea);//打印登记卡
break;
}
}
return i;
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (true)
{
System.out.println("吸烟区请安1,无烟区请安2,退出按-1");
int command = scanner.nextInt();
if(command == -1)
{
break;
}
else if(command == 1)//在吸烟区给用户分配一个座位
{
int i = allocSeats(0,5);
if(i == 5)//没有在吸烟区找到空余座位
{
System.out.println("吸烟区无座位了，是否接受无烟区的座位？");
String answer = scanner.next();
if(answer.equals("是"))//在无烟区分配座位
{
int j = allocSeats(5,10);
if(j==10)//无烟区也没有座位了
{
System.out.println("下次航班三小时后起飞");
}
}
else
{
System.out.println("下次航班三小时后起飞");
}
}
}
else if(command == 2)//在无烟区分配座位
{
int j = allocSeats(5,10);
if(j==10)//无烟区没有座位了
{
System.out.println("无烟区无座位了，是否接受吸烟区的座位？");
String answer = scanner.next();
if (answer.equals("是"))//在无烟区分配座位
{
int i = allocSeats(0,5);
if (i == 5)//吸烟区也没有座位了
{
System.out.println("下次航班三小时后起飞");
}
}
}
}
}
System.out.println("谢谢使用");
}
}
5.某个公司采用公用电话传递数据信息，数据是小于8位的整数，为了确保安全，5698234 --》 4328965 ---》9873410 -- 》 0873419
在传递过程中需要加密，加密规则如下：
首先将数据倒序，然后将每位数字都加上5，再用和除以10的余数代替该数字，
最后将第一位和最后一位数字交换。 请任意给定一个小于8位的整数，
然后，把加密后的结果在控制台打印出来。
package com;
import java.util.Scanner;
/**
* Created by ttc on 2018/1/2.
*/
public class JiaMi {
public static void main(String[] args) {
int index = 0; //数组当前的下标
int[] array = new int[8];
Scanner scanner = new Scanner(System.in);
System.out.println("请输入要加密的数");
int num = scanner.nextInt();//--》 4328965
//将数倒序，保存到数组中
while (num != 0)
{
array[index] = num % 10;
index++;
num = num / 10;
}
for(int i = 0; i < index; i++)
{
array[i] = (array[i] + 5) % 10; //每位数字都加上5，再用和除以10的余数代替该数字
}
//最后将第一位和最后一位数字交换
int temp = array[0];
array[0] = array[index - 1];
array[index - 1] = temp;
for(int i = 0; i < index; i++)
{
System.out.print(array[i]);
}
return;
}
}
6.工资支付系统
定义一个Employee抽象基类（name）
公司有以下几种员工：
开发人员：工资计算方式，每月固定工资
销售人员：底薪+提成
硬件工程师：生产零件，每个50元
小时工：按工作时间付工资，每小时30元
主类（测试类）
创建不同类型的6名员工对象，计算他们应付的月工资。
1.开发人员
package duotai;
/**
* Created by ttc on 2018/1/4.
*/
//开发人员
public class Developer extends Employee{
private int salary;
public Developer(String name, int salary)
{
super(name);
this.salary = salary;
}
@Override//方法重写注解
protected int paySalary() {
return salary;
}
}
2.老板
package duotai;
/**
* Created by ttc on 2018/1/4.
*/
public class Boss extends Employee {
public Boss(String name)
{
super(name);
}
@Override
protected int paySalary() {
return 200000;
}
}
3.抽象基类
package duotai;
/**
* Created by ttc on 2018/1/4.
*/
public abstract class Employee {
private String name;
public Employee(String name)
{
this.name = "@" + name + "@" ;
}
protected abstract int paySalary();
}
4.硬件工程师
package duotai;
/**
* Created by ttc on 2018/1/4.
*/
//硬件工程师
public class HardwareEngineer extends Employee {
private int productCount;//每月生产的零件数量
public HardwareEngineer(String name, int productCount)
{
super(name);
this.productCount = productCount;
}
@Override
protected int paySalary() {
return 50*productCount;
}
}
5.小时工
package duotai;
/**
* Created by ttc on 2018/1/4.
*/
//小时工
public class HourlyWorker extends Employee{
private int hours;//这个月工作了多少小时
public HourlyWorker(String name, int hours)
{
super(name);
this.hours = hours;
}
@Override
protected int paySalary() {
return 30*hours;
}
}
6.测试类
package duotai;
public class Main {
public static void main(String[] args) {
// write your code here
Employee[] employees = new Employee[6];
employees[0] = new Developer("张二",5000);
employees[1] = new Developer("张三",5000);
employees[2] = new SaleMan("李四", 2000, 500);
employees[3] = new HardwareEngineer("王五", 200);
employees[4] = new HourlyWorker("冯六",200);
employees[5] = new Boss("赵本山");
//计算总工资
int total = 0;
for(int i = 0; i < employees.length; i++)
{
total += employees[i].paySalary();
}
System.out.println("总共需要支付" + total);
}
}
7.销售人员
package duotai;
/**
* Created by ttc on 2018/1/4.
*/
//销售人员
public class SaleMan extends Employee{
private int salary;
private int comm;//提成
public SaleMan(String name, int salary, int comm)
{
super(name);
this.salary = salary;
this.comm = comm;
}
@Override
protected int paySalary() {
return salary + comm;
}
}
7.编写一个applet，将英语单词编码成pig Latin。pig Latin是一种常用于娱乐编码的语言形式，有许多方法用于组成pig Latin，简单来说可以使用下列算法：
为了从英语词组生成pig Latin，可以使用StringTokenizer类的对象来将词组分成单词。为了将每个英语单词翻译成一个pig Latin，可以将英语单词的第一个字母放在单词末尾并加上字母“ay”。这样单词“jump”变成了“umpjay”，单词“the”变成了“hetay”，单词“computer”变成了“omputercay”，单词之间的空格仍为空格。这里做如下决定：英语词组的单词有空格分开，没有标点符号，所有的单词有两个或更多的字母。应当使用printLatinWord方法显示每个单词，每个由nextToken返回的语法标记都传递给printLatinWord方法来打印pigLatin。该程序应读入用户输入的语句，并在文本区域中显示所有已转换的语句。
package lakei;
import java.util.Scanner;
/**
* Created by ttc on 18-1-5.
*/
public class pigLatin {
public static void main(String[] args) {
System.out.println("请输入一句英语");
Scanner scanner = new Scanner(System.in);
String strSentence = scanner.nextLine();
// System.out.println(strSentence);
String[] strWords = strSentence.split(" ");// 双引号里面"加空格"
for (int i = 0; i < strWords.length; i++) {
char c = strWords[i].charAt(0);
String strLast = strWords[i].substring(1);
strWords[i] = strLast + c + "ay";
}
for (int i = 0; i < strWords.length; i++) {
System.out.print(strWords[i]);
}
}
8.编写一个applet，利用随机数产生器来创建语句，使用称为article、noun、verb和preposition的4个数组，按照下列顺序从每个数组中选取随机的单词来创建一条语句：article、noun、verb、preposition、article、和noun。选出每个单词后，将其连接到语句中的前一个单词之后，单词之间应当由空格分开。输出最后的语句时，该语句应当以大写字母开头并以句点结尾。程序应当生成2语句并输出到一个文本区域中。
article数组应该包含冠词：the、a、one、some、any；
noun：数组应该包含名词：boy、girl、dog、town、car；
verb：数组应该包含动词：drove、jumped、ran、walked、skipped；
preposition：数组应该包含介词：to、from、over、under、on；
编写完上面的程序后，修改该程序以生成包含这几个句子的小故事
package aishuishui;
import java.util.Random;
// 编写一个程序，利用随机数产生器来创建语句，使用称为article、noun、verb和preposition的4个数组，
// 按照下列顺序从每个数组中选取随机的单词来创建一条语句：article、noun、verb、article、和noun。
// 选出每个单词后，将其连接到语句中的前一个单词之后，单词之间应当由空格分开。
// 输出最后的语句时，该语句应当以大写字母开头并以句点结尾。程序应当生成2语句并输出到一个文本区域中。
//
// article数组应该包含冠词：the、a、one、some、any；
//
// noun：数组应该包含名词：boy、girl、dog、town、car；
//
// verb：数组应该包含动词：drove、jumped、ran、walked、skipped；
//
//
// One boy ran a dog preposition.
public class Main {
public static String firstCharToUpper(String str)
{
char first = str.toUpperCase().charAt(0);//H
String strLast = str.substring(1);
String strFinal = first + strLast;
return strFinal;
}
public static void main(String[] args) {
// write your code here
String[] article = {"the","two","three","some","any"};
String[] noun={"男孩","女孩","狗","城镇","汽车"};
String[] verb={"驾驶","跳","跑","走","亲"};
//定义一个字符串数组来保存生成的句子
String[] sentence = new String[5];
int index = 0;//句子中下一个要保存的单词
//从article随机选出一个单词
Random random = new Random();
int nIndex = random.nextInt(5);
sentence[index] = article[nIndex];
index++;
//从noun随机选出一个单词
nIndex = random.nextInt(5);
sentence[index] = noun[nIndex];
index++;
//从noun随机选出一个单词
nIndex = random.nextInt(5);
sentence[index] = verb[nIndex];
index++;
//从article随机选出一个单词
nIndex = random.nextInt(5);
sentence[index] = article[nIndex];
index++;
//从noun随机选出一个单词
nIndex = random.nextInt(5);
sentence[index] = noun[nIndex];
String strSentence = "";
for(int i = 0; i <sentence.length; i++)
{
strSentence = strSentence + sentence[i];
}
strSentence = firstCharToUpper(strSentence);
System.out.println(strSentence + "。");
}
}
9.统计单词次数
一个文件(d:/article.txt)中，保存着以下一段文章，单词间以空格分隔。
Today I can complain because the weather is rainy or I can be thankful that the grass is getting watered for free Today I can fell sad that I don't have more money or I can be glad that my finances encourage me to plan my purchases wisely and guide me away from waste
要求统计该文章中各个单词出现的次数，并且按次数出现多少从多到少排序，将结果输出至d:/result.txt中。
I-----5
can-----4
that-----3
be-----2
me-----2
or-----2
is-----2
my-----2
the-----2
Today-----2
away-----1
thankful-----1
don't-----1
for-----1
getting-----1
fell-----1
rainy-----1
encourage-----1
grass-----1
and-----1
sad-----1
weather-----1
have-----1
from-----1
because-----1
free-----1
plan-----1
guide-----1
waste-----1
purchases-----1
more-----1
watered-----1
complain-----1
money-----1
glad-----1
to-----1
finances-----1
wisely-----1
代码：主类
package com.company;
import java.io.*;
import java.util.*;
/**
* Created by ttc on 2018/1/19.
*/
public class FileWordCount {
public static void main(String[] args) throws IOException {
//读取文件中的文章
FileReader fileReader = new FileReader("d:/article.txt");
BufferedReader bufferedReader = new BufferedReader(fileReader);
String strContent = bufferedReader.readLine();
StringBuilder stringBuilder = new StringBuilder();
while (strContent != null)//还有未曾读完的内容
{
stringBuilder.append(strContent);
//继续读取下一行
strContent = bufferedReader.readLine();
}
System.out.println(stringBuilder.toString());
//用空格分隔，打破成字符串数组
String[] words = stringBuilder.toString().split(" ");
System.out.println(words);
//定义一个map结构，key保存单词，值保存单词出现的次数
Map<String,Integer> word2Counts = new HashMap<>();
//将单词从数组结构，转换为map结构
for(String word : words)
{
//考察每个单词，如果单词出现在Map的key中，取出对应的值（也就是该单词已经出现的次数），
//将其加1，然后放回map
if(word2Counts.containsKey(word))
{
int count = word2Counts.get(word);
count++;
word2Counts.put(word,count);
}
else//否则，意味着该单词首次出现，那么将该单词放入map中，并且将次数设置为1
{
word2Counts.put(word,1);
}
}
FileWriter fileWriter = new FileWriter("d:/result.txt");
BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
//将单词信息，从map结构转换到list结构
List<WordInfo> wordInfoList = new ArrayList<WordInfo>();
for(Map.Entry<String, Integer> entry : word2Counts.entrySet())
{
WordInfo wordInfo = new WordInfo();
wordInfo.setWord(entry.getKey());
wordInfo.setCount(entry.getValue());
wordInfoList.add(wordInfo);
}
Collections.sort(wordInfoList);
for(WordInfo wordInfo : wordInfoList)
{
bufferedWriter.write(wordInfo.getWord()+ "-----");
bufferedWriter.write(String.valueOf(wordInfo.getCount()));
bufferedWriter.newLine();
}
bufferedWriter.flush();
fileReader.close();
fileWriter.close();
bufferedReader.close();
bufferedWriter.close();
}
}
副类代码
package com.company;
/**
* Created by ttc on 2018/1/19.
*/
public class WordInfo implements Comparable {
private String word;
private int count;
public String getWord() {
return word;
}
public void setWord(String word) {
this.word = word;
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
@Override
public int compareTo(Object o) {
// System.out.println("compareTo");
WordInfo wordInfo = (WordInfo)o;
return wordInfo.getCount()-this.count;
}
}
