BLOG-3

一．前言

知识点：

（1）第六次题目集：不同电话计费的书写。元素筛取用于求和。对不同输入的计算。非法输入判断。

（2）第七次题目集：对不同方式的电话计费的书写，同时加深了相关计算的难度。对非法输入字符串的判断。将特殊的字符串进行基本类型的转换。

2.题量和难度

总体来说，题目的量并不是很大，难点在于相关算法的选择以及非法输入的判定，在第六次题目集中，主要是对题目的理解以及对算法的设计，这个对于第七次的题目有很重要的作用，在第七次题目中，主要是对第六次题目的更加了解以及深入。

二．设计与分析。

题目集6（7—1）

实现一个简单的电信计费程序：
假设南昌市电信分公司针对市内座机用户采用的计费方式：
月租20元，接电话免费，市内拨打电话0.1元/分钟，省内长途0.3元/分钟，国内长途拨打0.6元/分钟。不足一分钟按一分钟计。
南昌市的区号：0791，江西省内各地市区号包括：0790~0799以及0701。

输入格式

输入信息包括两种类型
1、逐行输入南昌市用户开户的信息，每行一个用户，
格式：u-号码计费类型（计费类型包括：0-座机 1-手机实时计费 2-手机A套餐）
例如：u-079186300001 0
座机号码除区号外由是7-8位数字组成。
本题只考虑计费类型0-座机计费，电信系列2、3题会逐步增加计费类型。
2、逐行输入本月某些用户的通讯信息，通讯信息格式：
座机呼叫座机：t-主叫号码接听号码起始时间结束时间
t-079186330022 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:11
以上四项内容之间以一个英文空格分隔，
时间必须符合"yyyy.MM.dd HH:mm:ss"格式。提示：使用SimpleDateFormat类。
以上两类信息，先输入所有开户信息，再输入所有通讯信息，最后一行以“end”结束。
注意：
本题非法输入只做格式非法的判断，不做内容是否合理的判断（时间除外，否则无法计算），比如：
1、输入的所有通讯信息均认为是同一个月的通讯信息，不做日期是否在同一个月还是多个月的判定，直接将通讯费用累加，因此月租只计算一次。
2、记录中如果同一电话号码的多条通话记录时间出现重合，这种情况也不做判断，直接计算每条记录的费用并累加。
3、用户区号不为南昌市的区号也作为正常用户处理。

输出格式:

根据输入的详细通讯信息，计算所有已开户的用户的当月费用（精确到小数点后2位，
单位元）。假设每个用户初始余额是100元。
每条通讯信息单独计费后累加，不是将所有时间累计后统一计费。
格式：号码+英文空格符+总的话费+英文空格符+余额
每个用户一行，用户之间按号码字符从小到大排序。

（1）源代码：

import java.util.Scanner;
import java.util.ArrayList;
import java.util.regex.Pattern;
import java.util.regex.Matcher;
public class Main {
ArrayList<String> list = new ArrayList<String>();
ArrayList<User> listUser = new ArrayList<User>();
ArrayList<Integer>listSize=new ArrayList<Integer>();
private static String regEx1 = "u-\\d{11,12}\\s0";
private static String regEx2 = "t-\\d{11,12}\\s\\d{11,12}\\s\\d{4}.\\d{1}.\\d{1}\\s[012][0-9]:[0-6][0-9]:[0-6][0-9]\\s\\d{4}.\\d.\\d\\s[0-2][0-9]:[0-6][0-9]:[0-6][0-9]";
public void add(String str) {
list.add(str);
}

public void addUser(User user) {
listUser.add(user);
}
public void addSize(int s) {
listSize.add(s);
}
public static boolean isRegularRptCode(String rptCode) {

Pattern p1 = Pattern.compile(regEx1);

Pattern p2 = Pattern.compile(regEx2);

Matcher m1 = p1.matcher(rptCode);

Matcher m2 = p2.matcher(rptCode);

boolean rs1 = m1.matches();

boolean rs2 = m2.matches();

return rs1 || rs2;

}
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
Main main = new Main();
User user = new User(100);
for (;;) {
String str = input.nextLine();
if (str.equals("end")) {
break;
} else {
main.add(str);
}
}
for(int i=0;i<main.list.size();i++) {
String str=main.list.get(i);
if(!isRegularRptCode(str)&&!str.equals("end")) {
main.addSize(i);
}
}
for(int i=0;i<main.listSize.size();i++) {
int ert=main.listSize.get(i);
main.list.remove(ert-i);
}
for (int i=0;i<main.list.size();i++) {
int judge=1;
if (main.list.get(i).subSequence(0, 1).equals("u")) {
String[] array = main.list.get(i).split(" ");
for(int j=0;j<main.listUser.size();j++) {
if(array[0].substring(2).equals(main.listUser.get(j).getNumber())) {
judge=0;
break;
}
}
if(judge==1) {
main.addUser(new User(100, array[0].substring(2)));
}
}
if (main.list.get(i).subSequence(0, 1).equals("t")) {
String[] array1 = main.list.get(i).split(" ");
for (User s : main.listUser) {
if (array1[0].substring(2).equals(s.getNumber())) {
s.addCallRecord(new CallRecord(array1[3], array1[5], array1[0].substring(2, 6),
array1[1].substring(0, 4)));
}
}
}
}
User[] array = main.listUser.toArray(new User[0]);
for (int i = 0; i < array.length - 1; i++) {
for (int j = 0; j < array.length - 1; j++) {
if (Long.parseLong(array[j].getNumber()) > Long.parseLong(array[j + 1].getNumber())) {
User a = array[j];
array[j] = array[j + 1];
array[j + 1] = a;
}
}
}
for (User q : array) {
System.out.printf("%s %.1f %.1f", q.getNumber(), q.getNum(), q.getBalance());
System.out.println();
}
}
}

class CallRecord {
private String startTime;
private String endTime;
private String callingNumber;
private String answerNumber;
private double num;

public CallRecord(String startTime, String endTime, String callingNumber, String answerNumber) {
this.startTime = startTime;
this.endTime = endTime;
this.callingNumber = callingNumber;
this.answerNumber = answerNumber;
}

public String getStartTime() {
return startTime;
}

public void setStartTime(String startTime) {
this.startTime = startTime;
}

public String getEndTime() {
return endTime;
}

public void setEndTime(String endTime) {
this.endTime = endTime;
}

public String getCallingNumber() {
return callingNumber;
}

public void setCallingNumber(String callingNumber) {
this.callingNumber = callingNumber;
}

public String getAnswerNumber() {
return answerNumber;
}

public void setAnswerNumber(String answerNumber) {
this.answerNumber = answerNumber;
}

public double getTime() {
String[] array = startTime.split(":");
double start = Double.parseDouble(array[0]) * 60 + Double.parseDouble(array[1]);
String[] array1 = endTime.split(":");
double end = Double.parseDouble(array1[0]) * 60 + Double.parseDouble(array1[1]);
if (Double.parseDouble(array[2]) >= Double.parseDouble(array1[2])) {
return end - start;
} else {
return (end - start + 1);
}
}
}


class User {
ArrayList<CallRecord> listCallRecord = new ArrayList<CallRecord>();

public static double balance = 100;
private String number;
public static double mode1 = 0.1;
public static double mode2 = 0.3;
public static double mode3 = 0.6;

public User(double balance) {
this.balance = balance;
}

public User(double balance, String number) {
this.balance = balance;
this.number = number;
}


public String getNumber() {
return number;
}

public void addCallRecord(CallRecord callRecord) {
listCallRecord.add(callRecord);
}

public double getNum() {
double sum = 0;
for (CallRecord s : listCallRecord) {
if (s.getCallingNumber().equals(s.getAnswerNumber())) {
sum += mode1 * s.getTime();
continue;
}
if ((Integer.parseInt(s.getAnswerNumber()) > 790 && Integer.parseInt(s.getAnswerNumber()) < 799)
|| Integer.parseInt(s.getAnswerNumber()) == 701) {
sum += mode2 * s.getTime();
continue;
} else {
sum += mode3 * s.getTime();
continue;
}
}
return sum;
}

public double getBalance() {
return balance - getNum() - 20;
}
}

（2）输入，输出实例

输入：

u-079186300001 0
t-079186300001 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:25
end

输出：

079186300001 3.0 77.0

输入：

u-079186300001 0 t-079186300001 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:26 end

输出：

079186300001 3.6 76.4

输入：

u-079186300001 0 u-079186300002 0 t-079186300001 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:25 t-079186300002 058686330022 2022.1.3 11:00:25 2022.1.3 11:05:25 t-079186300001 079186300001 2022.1.3 12:00:25 2022.1.3 12:05:25 end

输出：

079186300001 3.5 76.5 079186300002 3.0 77.0

（3）思路与分析：

1.首先了解类图的基本结构，然后由类图写出相关的类。

2.根据实例写出相关的正则表达式。

3.最后写出相关的代码，并进行相关的调试。

(4)解释与心得。

对正则表达式有更加深刻的认识，同时对由类图写出代码更加熟悉并且在了解相关的结构后对代码的生成更加快捷。

题目集7（7—1）：

实现南昌市电信分公司的计费程序，假设该公司针对手机和座机用户分别采取了两种计费方案，分别如下：
1、针对市内座机用户采用的计费方式（与电信计费系列1内容相同）：
月租20元，接电话免费，市内拨打电话0.1元/分钟，省内长途0.3元/分钟，国内长途拨打0.6元/分钟。不足一分钟按一分钟计。
假设本市的区号：0791，江西省内各地市区号包括：0790~0799以及0701。
2、针对手机用户采用实时计费方式：
月租15元，市内省内接电话均免费，市内拨打市内电话0.1元/分钟，市内拨打省内电话0.2元/分钟，市内拨打省外电话0.3元/分钟，省内漫游打电话0.3元/分钟，省外漫游接听0.3元/分钟，省外漫游拨打0.6元/分钟；
注：被叫电话属于市内、省内还是国内由被叫电话的接听地点区号决定，比如以下案例中，南昌市手机用户13307912264在区号为020的广州接听了电话，主叫号码应被计算为拨打了一个省外长途，同时，手机用户13307912264也要被计算省外接听漫游费：
u-13307912264 1
t-079186330022 13307912264 020 2022.1.3 10:00:25 2022.1.3 10:05:11

输入格式：

输入信息包括两种类型
1、逐行输入南昌市用户开户的信息，每行一个用户，含手机和座机用户
格式：u-号码计费类型（计费类型包括：0-座机 1-手机实时计费 2-手机A套餐）
例如：u-079186300001 0
座机号码由区号和电话号码拼接而成，电话号码包含7-8位数字，区号最高位是0。
手机号码由11位数字构成，最高位是1。
本题在电信计费系列1基础上增加类型1-手机实时计费。
手机设置0或者座机设置成1，此种错误可不做判断。
2、逐行输入本月某些用户的通讯信息，通讯信息格式：
座机呼叫座机：t-主叫号码接听号码起始时间结束时间
t-079186330022 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:11
以上四项内容之间以一个英文空格分隔，
时间必须符合"yyyy.MM.dd HH:mm:ss"格式。提示：使用SimpleDateFormat类。
输入格式增加手机接打电话以及收发短信的格式，手机接打电话的信息除了号码之外需要额外记录拨打/接听的地点的区号，比如：
座机打手机：
t-主叫号码接听号码接听地点区号起始时间结束时间
t-079186330022 13305862264 020 2022.1.3 10:00:25 2022.1.3 10:05:11
手机互打：
t-主叫号码拨号地点接听号码接听地点区号起始时间结束时间
t-18907910010 0791 13305862264 0371 2022.1.3 10:00:25 2022.1.3 10:05:11

输出格式：

输出：
根据输入的详细通讯信息，计算所有已开户的用户的当月费用（精确到小数点后2位，单位元）。假设每个用户初始余额是100元。
每条通讯、短信信息均单独计费后累加，不是将所有信息累计后统一计费。
格式：号码+英文空格符+总的话费+英文空格符+余额
每个用户一行，用户之间按号码字符从小到大排序。

import java.util.Scanner;
import java.util.ArrayList;
import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Main {
private static String regEx1 = "[u]\\-(\\d{11,12})\\s([0-1])";
private static String regEx2 = "[t]\\-(\\d{11,12})\\s(\\d{11,12})\\s\\d{4}\\.\\d{1,2}\\.\\d{1,2}\\s([0-6][0-9]\\:[0-6][0-9]\\:[0-6][0-9])\\s\\d{4}\\.\\d{1,2}\\.\\d{1,2}\\s([0-6][0-9]\\:[0-6][0-9]:[0-6][0-9])";
private static String regEx3 = "[t]\\-(\\d{11,12})\\s(\\d{11,12})\\s(\\d{3,4})\\s\\d{4}\\.\\d{1,2}\\.\\d{1,2}\\s([0-6][0-9]\\:[0-6][0-9]\\:[0-6][0-9])\\s\\d{4}\\.\\d{1,2}\\.\\d{1,2}\\s([0-6][0-9]\\:[0-6][0-9]\\:[0-6][0-9])";
private static String regEx4 = "[t]\\-(\\d{11,12})\\s(\\d{3,4})\\s(\\d{11,12})\\s(\\d{3,4})\\s\\d{4}\\.\\d{1,2}\\.\\d{1,2}\\s([0-6][0-9]\\:[0-6][0-9]\\:[0-6][0-9])\\s\\d{4}\\.\\d{1,2}\\.\\d{1,2}\\s([0-6][0-9]\\:[0-6][0-9]\\:[0-6][0-9])";
private static String regEx5="[t]\\-(\\d{11,12})\\s(\\d{3,4})\\s(\\d{11,12})\\s\\d{4}\\.\\d{1,2}\\.\\d{1,2}\\s([0-6][0-9]\\:[0-6][0-9]\\:[0-6][0-9])\\s\\d{4}\\.\\d{1,2}\\.\\d{1,2}\\s([0-6][0-9]\\:[0-6][0-9]\\:[0-6][0-9])";
ArrayList<String> list = new ArrayList<String>();
ArrayList<Integer> listSize = new ArrayList<Integer>();

public void add(String str) {
list.add(str);
}

public void addSize(int s) {
listSize.add(s);
}

public static void main(String[] args) {
ArrayList<CallRecord> listCallRecord = new ArrayList<CallRecord>();
ArrayList<User> listUser = new ArrayList<User>();
Scanner input = new Scanner(System.in);
Main main = new Main();
for (;;) {
String str = input.nextLine();
if (str.equals("end")) {
break;
} else {
main.add(str);
}
}
Pattern p1 = Pattern.compile(regEx1);
Pattern p2 = Pattern.compile(regEx2);
Pattern p3 = Pattern.compile(regEx3);
Pattern p4 = Pattern.compile(regEx4);
Pattern p5=Pattern.compile(regEx5);
Matcher m1 = null;
Matcher m2 = null;
Matcher m3 = null;
Matcher m4 = null;
Matcher m5=null;
Matcher m = null;
for (int i = 0; i < main.list.size(); i++) {
String str = main.list.get(i);
m1 = p1.matcher(str);
m2 = p2.matcher(str);
m3 = p3.matcher(str);
m4 = p4.matcher(str);
m5=p5.matcher(str);
if (!(m1.find() || m2.find() || m3.find() || m4.find()||m5.find()) && !str.equals("end")) {
main.addSize(i);
}
} // 查找非法字符串

for (int i = 0; i < main.listSize.size(); i++) {
int ert = main.listSize.get(i);
main.list.remove(ert - i);
} // 删除非法字符串

for (int i = 0; i < main.list.size(); i++) {
int judge = 1;
if (main.list.get(i).subSequence(0, 1).equals("u")) {
m1 = p1.matcher(main.list.get(i));
if (m1.find()) {
for (int j = 0; j < listUser.size(); j++) {
if (m1.group(1).equals(listUser.get(j).getNumber())) {
judge = 0;
break;
}
}
if (judge == 1) {
listUser.add(new User(100, m1.group(1), m1.group(2)));
}
}

}
if (main.list.get(i).subSequence(0, 1).equals("t")) {
m2 = p2.matcher(main.list.get(i));
m3 = p3.matcher(main.list.get(i));
m4 = p4.matcher(main.list.get(i));
m5=p5.matcher(main.list.get(i));
if (m2.find()) {
listCallRecord.add(new CallRecord(m2.group(3), m2.group(4), m2.group(1), m2.group(2)));
} else if (m3.find()) {

listCallRecord.add(new CallRecord(m3.group(4), m3.group(5), m3.group(1), m3.group(2), m3.group(3)));
} else if (m4.find()) {
listCallRecord.add(new CallRecord(m4.group(5), m4.group(6), m4.group(1), m4.group(2), m4.group(3),
m4.group(4)));
}
else if(m5.find()) {
CallRecord qwe=new CallRecord();
qwe.CallRecord1(m5.group(4),m5.group(5),m5.group(1),m5.group(2),m5.group(3));
listCallRecord.add(qwe);
}
}
} // 添加合法字符串
User[] array = listUser.toArray(new User[0]);
for (int i = 0; i < array.length - 1; i++) {
for (int j = 0; j < array.length - 1; j++) {
if (array[j].getNumber().compareTo(array[j+1].getNumber())>0){
User a = array[j];
array[j] = array[j + 1];
array[j + 1] = a;
}
}
}
for (User user : listUser) {
for (CallRecord callRecord : listCallRecord) {
user.getNum(callRecord);
}
}
for (User user : array) {
System.out.printf("%s %.1f %.1f", user.getNumber(), user.getSum(), user.getBalance());
System.out.println();
}
}
}

 

class CallRecord {
private String startTime;
private String endTime;
private String callingNumber;
private String answerNumber;
private String answerAdress;
private String callingAdress;
private String num;

public CallRecord() {

}
public CallRecord(String startTime, String endTime, String callingNumber, String answerNumber) {
this.startTime = startTime;
this.endTime = endTime;
this.callingNumber = callingNumber;
this.answerNumber = answerNumber;
}

public CallRecord(String startTime,String endTime,String callingNumber,String answerNumber,String answerAdress) {
this.startTime=startTime;
this.endTime=endTime;
this.callingNumber=callingNumber;
this.answerNumber=answerNumber;
this.answerAdress=answerAdress;
}

public CallRecord(String startTime,String endTime,String callingNumber,String callingAdress,String answerNumber,String answerAdress) {
this.startTime=startTime;
this.endTime=endTime;
this.callingNumber=callingNumber;
this.callingAdress=callingAdress;
this.answerNumber=answerNumber;
this.answerAdress=answerAdress;
}
public void CallRecord1(String startTime,String endTime,String callingNumber,String callingAdress,String answerNumber) {
this.startTime=startTime;
this.endTime=endTime;
this.callingNumber=callingNumber;
this.callingAdress=callingAdress;
this.answerNumber=answerNumber;
}
public String getStartTime() {
return startTime;
}

public void setStartTime(String startTime) {
this.startTime = startTime;
}

public String getEndTime() {
return endTime;
}

public void setEndTime(String endTime) {
this.endTime = endTime;
}

public String getCallingNumber() {
return callingNumber;
}

public void setCallingNumber(String callingNumber) {
this.callingNumber = callingNumber;
}

public String getAnswerNumber() {
return answerNumber;
}

public void setAnswerNumber(String answerNumber) {
this.answerNumber = answerNumber;
}

public String getCallingAdress() {
return callingAdress;
}

public String getAnswerAdress() {
return answerAdress;
}

public double getTime() {
double start=0;
double end=0;
String[] array = startTime.split(":");
start = Double.parseDouble(array[0]) * 60 + Double.parseDouble(array[1]);
String[] array1 = endTime.split(":");
if(array1[0].equals("00")) {
end =( Double.parseDouble(array1[0])+24) * 60 + Double.parseDouble(array1[1]);
}
else {
end =Double.parseDouble(array1[0]) * 60 + Double.parseDouble(array1[1]);
}
if (Double.parseDouble(array[2]) >= Double.parseDouble(array1[2])) {
return end - start;
} else {
return (end - start + 1);
}
}

}


class User {
public static double balance = 100;
private double sum = 0;
private String number;
public static double mode1 = 0.1;
public static double mode2 = 0.3;
public static double mode3 = 0.6;
private String type;

public User(double balance, String number, String type) {
this.balance = balance;
this.number = number;
this.type = type;
}

 

public String getNumber() {
return number;
}

public String getType() {
return type;
}

public void getNum(CallRecord callRecord) {
if (callRecord.getCallingNumber().equals(getNumber())) {
if (this.getType().equals("0") && callRecord.getAnswerNumber().subSequence(0, 1).equals("0")) {
if (callRecord.getAnswerNumber().subSequence(0, 4).equals("0791")) {
sum += mode1 * callRecord.getTime();
} else if (!(callRecord.getAnswerNumber().subSequence(0, 4).equals("0791"))
&& Integer.parseInt((String) callRecord.getAnswerNumber().subSequence(0, 4)) >= 790
&& Integer.parseInt((String) callRecord.getAnswerNumber().subSequence(0, 4)) <= 799
|| Integer.parseInt((String) callRecord.getAnswerNumber().subSequence(0, 4)) == 701) {
sum += mode2 * callRecord.getTime();
} else {
sum += mode3 * callRecord.getTime();
}
}
if (this.getType().equals("0") && callRecord.getAnswerNumber().subSequence(0, 1).equals("1")) {
if (callRecord.getAnswerAdress().equals("0791")) {
sum += mode1 * callRecord.getTime();
} else if (!(callRecord.getAnswerAdress().equals("0791"))
&& Integer.parseInt(callRecord.getCallingAdress()) >= 790
&& Integer.parseInt(callRecord.getCallingAdress()) <= 799
|| Integer.parseInt(callRecord.getAnswerAdress()) == 701) {
sum += mode2 * callRecord.getTime();
} else {
sum += mode3 * callRecord.getTime();
}
}
if (this.getType().equals("1") && callRecord.getAnswerNumber().subSequence(0, 1).equals("1")) {
if (callRecord.getCallingAdress().equals("0791")) {
if (callRecord.getAnswerAdress().equals("0791")) {
sum += 0.1 * callRecord.getTime();
} else if (!(callRecord.getAnswerAdress().equals("0791"))
&& Integer.parseInt(callRecord.getAnswerAdress()) >= 790
&& Integer.parseInt(callRecord.getAnswerAdress()) <= 799
|| Integer.parseInt(callRecord.getAnswerAdress()) == 701) {
sum += 0.2 * callRecord.getTime();
} else {
sum += 0.3 * callRecord.getTime();
}
} else if (!(callRecord.getCallingAdress().equals("0791"))
&& Integer.parseInt(callRecord.getCallingAdress()) >= 790
&& Integer.parseInt(callRecord.getCallingAdress()) <= 799
|| Integer.parseInt(callRecord.getCallingAdress()) == 701) {
sum += 0.3 * callRecord.getTime();
} else {
sum += 0.6 * callRecord.getTime();
}
}
if (this.getType().equals("1") && callRecord.getAnswerNumber().subSequence(0, 1).equals("0")) {
if (callRecord.getCallingAdress().equals("0791")) {
if (callRecord.getAnswerNumber().subSequence(0, 4).equals("0791")) {
sum += 0.1 * callRecord.getTime();
} else if (!(callRecord.getAnswerNumber().subSequence(0, 4).equals("0791"))
&& Integer.parseInt((String) callRecord.getAnswerNumber().subSequence(0, 4)) >= 790
&& Integer.parseInt((String) callRecord.getAnswerNumber().subSequence(0, 4)) <= 799
|| Integer.parseInt((String) callRecord.getAnswerNumber().subSequence(0, 4)) == 701) {
sum += 0.2 * callRecord.getTime();
} else {
sum += 0.3 * callRecord.getTime();
}
} else if (!(callRecord.getCallingAdress().equals("0791"))
&& Integer.parseInt((String) callRecord.getAnswerNumber().subSequence(0, 4)) >= 790
&& Integer.parseInt((String) callRecord.getAnswerNumber().subSequence(0, 4)) <= 799
|| Integer.parseInt((String) callRecord.getAnswerNumber().subSequence(0, 4)) == 701) {
sum += 0.3 * callRecord.getTime();
} else {
sum += 0.6 * callRecord.getTime();
}
}
}
if (this.getNumber().equals(callRecord.getAnswerNumber())) {
if (this.getNumber().subSequence(0, 1).equals("1")) {
if (!callRecord.getCallingAdress().equals("0791")) {
if (Integer.parseInt(callRecord.getAnswerAdress()) < 790
|| Integer.parseInt(callRecord.getAnswerAdress()) > 799
|| Integer.parseInt(callRecord.getAnswerAdress()) != 701) {
sum += 0.3 * callRecord.getTime();
}
}

}
}
}

public double getSum() {
return sum;
}

public double getBalance() {
if (this.getType().equals("0")) {
return balance - 20 - sum;
} else {
return balance - 15 - sum;
}
}
}

输入输出实例：

输入：

u-13811111111 1 u-13811111110 1 u-13811111111 1 t-13811111111 0791 13811111110 020 2022.1.3 08:00:00 2022.1.3 08:09:20

输出：

13811111110 3.0 82.0 13811111111 3.0 82.0

输入：

u-079186300001 0 u-13986300001 1 t-18907910010 0791 13986300001 0371 2022.1.3 10:00:25 2022.1.3 10:05:11 end

输出：

079186300001 0.0 80.0 13986300001 1.5 83.5

输入：

u-079186300001 0 u-13986300001 1 t-079186300001 13986300001 0371 2022.1.3 10:00:25 2022.1.3 10:05:11 end

输出：

079186300001 3.0 77.0 13986300001 1.5 83.5

思路与分析：

1 按照类图构建大致的结构。

2 由类图具体的内容对每一个类写出具体的内容。

3 由给出的实例写出正则表达式。

4 对代码进行调错

解释与心得

在这次试验后，对相关的类图分析更加精通，并且对相关的问题的研究更加熟悉。同时，也对正则表达式的书写更加熟悉。

题目集7（7—2）：
经过不懈的努力，C~K终于当上了班主任。

现在他要统计班里学生的名单，但是C~K在教务系统中导出班级名单时出了问题，发现会有同学的信息重复，现在他想把重复的同学信息删掉，只保留一个，
但是工作量太大了，所以找到了会编程的你，你能帮他解决这个问题吗？

输入格式:

第一行输入一个N，代表C~K导出的名单共有N行（N<100000）.

接下来的N行，每一行包括一个同学的信息，学号姓名年龄性别。

输出格式:

第一行输出一个n，代表删除重复名字后C~K的班级共有几人。

接下来的n行，输出每一个同学的信息，输出按照学号从小到大的顺序。
源码

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class Main {

public static void main(String[] args) {
ArrayList<Stu> list = new ArrayList<Stu>();
ArrayList<Integer> listInt = new ArrayList<Integer>();
Scanner input = new Scanner(System.in);
int a = input.nextInt();
for (int i = 0; i < a; i++) {
Stu stu = new Stu(input.next(), input.next(), input.nextInt(), input.next());
list.add(stu);
}
int size = list.size();
for (int i = 0; i < size - 1; i++) {
for (int j = i; j < size - 1;) {
if (list.get(i).getStuNum().equals(list.get(j + 1).getStuNum())) {
list.remove(j + 1);
size = size - 1;
} else {
j++;
}
}
}
System.out.println(list.size());
for (int i = 0; i < list.size(); i++) {
for (int j = 0; j < list.size() - 1 - i; j++) {
if (Integer.parseInt(list.get(j).getStuNum()) > Integer.parseInt(list.get(j + 1).getStuNum())) {
Stu qwe = new Stu();
qwe = list.get(j);
list.set(j, list.get(j + 1));
list.set(j + 1, qwe);
}
}

}
for (int i = 0; i < list.size(); i++) {
if (i == list.size() - 1) {
System.out.print(list.get(i).getStuNum() + " " + list.get(i).getName() + " " + list.get(i).getAge()
+ " " + list.get(i).getSex());
} else {
System.out.println(list.get(i).getStuNum() + " " + list.get(i).getName() + " " + list.get(i).getAge()
+ " " + list.get(i).getSex());

}

}
}
}

class Stu {
private String stuNum;
private String name;
private int age;
private String sex;

public Stu() {

}

public Stu(String stuNum, String name, int age, String sex) {
this.stuNum = stuNum;
this.name = name;
this.age = age;
this.sex = sex;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getStuNum() {
return stuNum;
}

public void setStuNum(String stuNum) {
this.stuNum = stuNum;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public String getSex() {
return sex;
}

public void setSex(String sex) {
this.sex = sex;
}
}

输入输出实例：

输入：

6
0001 MeiK 20 M
0001 MeiK 20 M
0002 sdk2 21 M
0002 sdk2 21 M
0002 sdk2 21 M
0000 blf2 22 F

输出：

0000 blf2 22 F
0001 MeiK 20 M
0002 sdk2 21 M

思路与分析；

1 有题目了解具体的要求。

2 在了解具体的需求后对相关的代码框架进行安排。

3 在以上都完成后，写代码在调试。

解释与心得：

对ArrayList的使用更加熟练，同时对于相关的继承更加熟悉。

踩坑心得：

一定对循环最后是否会越界进行深入的研究，一定要与自增的距离结合起来研究。

我在写循环自动截取符合条件的字符串时，不断出现越界的情况，我刚开始并没有结合自增的距离大小，只是片面增大缩小其截的长度，迟迟没有解决。我在分析，发现，是我的自增变量设置过大，导致在有限情况下，导致最终的会超出数组的边界，导致越界，但是唯有仅仅改变自增的距离，但是我发现仍然不能改变这种错误，于是我在最后的一次循环里进行特殊的讨论，才解决了有关越界的问题，我得出结论，在每次循环的最后一次一定要特殊讨论，及时是与以往几次相同的情况。

2.适当结合对象，即使题目中没有明说用对象会很大的简洁自己的代码。

在计算各种情况时，我每种情况，代码的重复率很高，导致代码冗杂，看起来很累赘。在对其中的各种操作以方法的形式写进里面最终会使我的代码变得十分简洁，明了。

改进建议：

在有循环的时候，将最后的一次循环当做一次单独的语句，然后进行讨论。
在求一个相对复杂的数学问题，一定要寻早最简便的算法，然后结合对应的注释，增加理解代码的速度。
在题目中有一个对象的相应的代码的重复率很高时，记得将其看做一个对象然后进行写代码。

总结

对于字符串的相关操作更加熟练。
对于已经碰到过的相关的诸如电信计费相关的问题，我已经掌握一大部分。
对于一些复杂的代码，进行合理的缩短和加上相应的注释，增加可读性。
在写一次循环之前，用笔先验算一遍最开始和最后的情况，一般最后的情况会更加特殊一点。对最后一种进行特殊讨论。

posted @ 2022-06-18 09:39 SystemOutPrint 阅读(63) 评论(0) 收藏举报

刷新页面返回顶部

BLOG-3

输出格式:

输入格式:

输出格式:

公告