出租车问题

最新推荐文章于 2023-03-16 17:38:59 发布

lnd_wangchen

最新推荐文章于 2023-03-16 17:38:59 发布

阅读量472

点赞数

分类专栏：日常编程文章标签：软件

本文链接：https://blog.csdn.net/lnd_wangchen/article/details/78259449

版权

日常编程专栏收录该内容

5 篇文章 0 订阅

订阅专栏

出租车问题

在未来，出租汽⻋公司已经采⽤⾃动驾驶汽⻋来开展出租⻋业务。哒哒出⾏就是这样⼀家公司，为了提⾼⽤
户体验，公司需要设计⼀款软件来统计提醒⻋辆保养情况。汽⻋保养分为每⼀万公⾥保养和定期保养两种，
另外汽⻋除保养之外，达到⼀定条件，则会进⼊报废。
每1万公⾥保养提醒规则如下：
汽⻋每跑1万公⾥(含)就要保养⼀次，距离1万公⾥还差500公⾥(含)的时候就要开始提醒
为了简化规则，不需考虑未及时保养或者重复保养的场景，以及不需考虑上次实际保养时间和⼤修时间

定期保养提醒规则如下：

3年以下⻋辆每12个⽉定期保养⼀次
3年及以上⻋辆每6个⽉定期保养⼀次
若⻋辆有⼤修，则每3个⽉就需要定期保养⼀次
定期保养全部提前⼀个⽉开始提醒，直到需要保养的那天(含)为⽌
在计算⽉份时，只需考虑⽉份，不需考虑⽇期，如07⽉31⽇和8⽉1⽇之间也差⼀个⽉，在计算年份时，
只需要考虑年份，不需考虑⽉和⽇，如2016年12⽉31⽇和2017年1⽉1⽇也认为相差⼀年。
为了简化规则，不需考虑未及时保养或者重复保养的场景，以及不需考虑上次实际保养时间和⼤修时间

车辆报废规则如下：

⼀般⻋辆6年（据购买⽇期加6*365=2190天）开始报废
若⻋辆有⼤修，报废年限降为3年（据购买⽇期加3*365=1095天）
报废⻋辆提前⼀个⽉开始提醒（提前⼀个⽉提醒，不需要考虑⽇，⽐如 03⽉28⽇⻋辆报废，那
么 02⽉01⽇即可开始提醒）
ThoughtWorks2018校园招聘作业题⽬——出租⻋
说明
家庭作业部分

注意：

如果⻋辆已经开始提醒报废或已经报废，则⽆需保养
如果⻋辆同时需要每1万公⾥保养和定期保养，则按每1万公⾥保养计
请编写程序，提醒公司相关⼈员需要保养和报废的⻋辆。
程序输⼊为字符串，其格式严格规定如下：
⽂本的第⼀⾏表示提交⽇期，识别⻋辆状况时以该⽇期作为当前⽇期。该⾏格式
为 SubmitDate: {提交⽇期 yyyy-MM-dd} ，如 SubmitDate: 2030/09/01
随后每⼀⾏代表⼀辆汽⻋。汽⻋的各种信息使⽤ | 字符进⾏分隔，其排列顺序为
{⻋牌号}|{购买⽇期}|{品牌名称}|{⽬前运⾏公⾥数}|{有⽆⼤修} ；
购买⽇期的格式为 yyyy/MM/dd （如 2026/02/18 ）；
⽬前运⾏公⾥数为整数，不带有除数字之外的其他符号；
有⽆⼤修的格式为 ‘T’ 或者 ‘F’ ，前者表示有⼤修，后者表示⽆⼤修；

范例：

SubmitDate: 2030/09/01
CAR0001|2025/04/05|Porsche|10000|F
CAR0002|2029/10/14|Porsche|9000|F
CAR0003|2026/08/17|Porsche|13000|F
CAR0004|2027/11/01|BYD|23000|T
CAR0005|2027/01/11|BYD|19500|F
CAR0006|2029/07/01|Audi|10001|T
CAR0007|2028/04/19|Ford|9800|F
CAR0008|2027/07/10|Ford|15000|T
CAR0009|2024/10/22|Ford|90300|F
对于前⾯的输⼊，相应的输出范例为：
程序输⼊
程序输出

Reminder

Time-related maintenance coming soon…
Audi: 1 (CAR0006)
Porsche: 1 (CAR0002)
Distance-related maintenance coming soon…
BYD: 1 (CAR0005)
Ford: 1 (CAR0007)
Porsche: 1 (CAR0001)
Write-off coming soon…
BYD: 1 (CAR0004)
Ford: 1 (CAR0009)
其中
Time-related maintenance 指需要提醒定期保养的⻋辆
Distance-related maintenance 指需要提醒每1万公⾥保养的⻋辆
Write-off 指需要提醒报废的⻋辆
每⼀组中的⻋辆按照品牌升序排序（品牌第⼀个字⺟均为⼤写）
输⼊
SubmitDate: 2030/09/01
CAR0001|2025/04/05|Porsche|10000|F
CAR0002|2029/10/14|Porsche|9000|F
CAR0003|2026/08/17|Porsche|13000|F
CAR0004|2027/11/01|BYD|23000|T
CAR0005|2027/01/11|BYD|19500|F
CAR0006|2029/07/01|Audi|10001|T
CAR0007|2028/04/19|Ford|9800|F
CAR0008|2027/07/10|Ford|15000|T
CAR0009|2024/10/22|Ford|90300|F
输出
测试⽤例⼀

Reminder

Time-related maintenance coming soon…
Audi: 1 (CAR0006)
Porsche: 1 (CAR0002)
Distance-related maintenance coming soon…
BYD: 1 (CAR0005)
Ford: 1 (CAR0007)
Porsche: 1 (CAR0001)
Write-off coming soon…
BYD: 1 (CAR0004)
Ford: 1 (CAR0009)
输⼊
SubmitDate: 2050/05/01
CAR0001|2044/05/01|Volkswagen|65535|F
CAR0002|2044/05/03|BMW|100001|F
CAR0003|2047/05/02|Mercedes-Benz|37789|T
CAR0004|2047/05/03|Honda|59908|T
CAR0005|2049/12/10|Peugeot|49999|F
CAR0006|2046/11/15|Jeep|2000|F
CAR0007|2046/11/16|Jeep|5000|F
输出

Reminder

Time-related maintenance coming soon…
Jeep: 2 (CAR0006, CAR0007)
Distance-related maintenance coming soon…
Peugeot: 1 (CAR0005)
Write-off coming soon…
BMW: 1 (CAR0002)
Honda: 1 (CAR0004)
测试⽤例⼆

代码块

 * Created by misfortune on 2017/10/15.
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

class Taxi{
    private String carId;
    private String purchaseDate;
    private String brand;
    private int currentRunningKilometers;
    private boolean hasHeavyMaintenance;
    private int statment=7;
    Taxi(String str){
        String []sourceStrArray=str.split("\\|");
        carId=sourceStrArray[0];
        purchaseDate=sourceStrArray[1];
        brand=sourceStrArray[2];
        currentRunningKilometers=Integer.parseInt(sourceStrArray[3]);
        hasHeavyMaintenance=sourceStrArray[4].equals("T");
    }
    public String getCarId() {return carId;}
    public void setCarId(String carId) {this.carId = carId;}
    public String getPurchaseDate() {return purchaseDate;}
    public void setPurchaseDate(String purchaseDate) {this.purchaseDate = purchaseDate;}
    public String getBrand() {return brand;}
    public void setBrand(String brand) {this.brand = brand;}
    public int getCurrentRunningKilometers() {return currentRunningKilometers;}
    public void setCurrentRunningKilometers(int currentRunningKilometers) {this.currentRunningKilometers = currentRunningKilometers;}
    public boolean isHasHeavyMaintenance() {return hasHeavyMaintenance;}
    public void setHasHeavyMaintenance(boolean hasHeavyMaintenance) {this.hasHeavyMaintenance = hasHeavyMaintenance;}
    public int getStatment() {return statment;}
    public void setStatment(int statment) {this.statment = statment;}
    public void display(){
        System.out.println(getCarId()+"|"+getPurchaseDate()+"|"+getBrand()+"|"+getCurrentRunningKilometers()+"|"+isHasHeavyMaintenance()+"|"+statment);
    }
    public void isWriteOff(String currentTime)throws ParseException{
        //判断是否已经报废
        Calendar calendar1=Calendar.getInstance();
        Calendar calendar2=Calendar.getInstance();
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy/MM/dd");
            calendar1.setTime(sdf.parse(purchaseDate));
            calendar2.setTime(sdf.parse(currentTime));
        if(hasHeavyMaintenance!=false){
            calendar1.add(Calendar.DATE,+1095);
        }else calendar1.add(Calendar.DATE,+2190);
        if(calendar1.after(calendar2)){
            statment=6;//车辆状态为未报废，是否需要提醒保修、是否即将过期未知
        } else statment=0;//车辆状态为已报废
    }
    public void isWillWriteOff(String currentTime)throws ParseException{
        if(statment==6){
            Calendar calendar1=Calendar.getInstance();
            Calendar calendar2=Calendar.getInstance();
            SimpleDateFormat sdf=new SimpleDateFormat("yyyy/MM/dd");
            calendar1.setTime(sdf.parse(purchaseDate));
            calendar2.setTime(sdf.parse(currentTime));
            if(hasHeavyMaintenance!=false){
                calendar1.add(Calendar.DATE,+1095);
            }else calendar1.add(Calendar.DATE,+2190);
            if(calendar1.get(Calendar.YEAR)==calendar2.get(Calendar.YEAR)&&calendar1.get(Calendar.MONTH)==calendar2.get(Calendar.MONTH)){
                    statment=1;
            }else {
                calendar1.add(Calendar.MONTH,-1);
                if(calendar1.get(Calendar.YEAR)==calendar2.get(Calendar.YEAR)&&calendar1.get(Calendar.MONTH)==calendar2.get(Calendar.MONTH)){
                    statment=1;
                     }
                }
            }
        }
    public void timeRelated(String currentTime)throws ParseException{
        if(statment==6){
                Calendar calendar1=Calendar.getInstance();
                Calendar calendar2=Calendar.getInstance();
                SimpleDateFormat sdf=new SimpleDateFormat("yyyy/MM/dd");
                calendar1.setTime(sdf.parse(purchaseDate));
                calendar2.setTime(sdf.parse(currentTime));
                if(hasHeavyMaintenance!=false){
                    for(int i=0;i<12;i++){
                        calendar1.add(Calendar.MONTH,+2);
                        if(calendar1.get(Calendar.MONTH)==calendar2.get(Calendar.MONTH)){
                            statment=2;
                        }
                    }
                }else {
                    calendar1.add(Calendar.YEAR,+3);
                    if(calendar1.after(calendar2)){
                        calendar1.add(Calendar.YEAR,-3);
                        for(int i=0;i<6;i++){
                            calendar1.add(Calendar.MONTH,+12);
                            if(calendar1.get(Calendar.YEAR)==calendar2.get(Calendar.YEAR)){
                                calendar1.add(Calendar.MONTH,-1);
                                if(calendar1.get(Calendar.MONTH)==calendar2.get(Calendar.MONTH)){
                                    statment=2;
                                    break;
                                }
                            }
                        }
                    }else{
                        calendar1.add(Calendar.YEAR,-3);
                        for(int i=0;i<12;i++){
                            calendar1.add(Calendar.MONTH,+6);
                            if(calendar1.get(Calendar.YEAR)==calendar2.get(Calendar.YEAR)){
                                if(calendar1.get(Calendar.MONTH)==calendar2.get(Calendar.MONTH)&&calendar1.after(calendar2)){
                                    statment=2;
                                    break;
                                }else {
                                    calendar1.add(Calendar.MONTH,-1);
                                    if(calendar1.get(Calendar.MONTH)==calendar2.get(Calendar.MONTH)&&calendar1.after(calendar2)){
                                        statment=2;
                                        break;
                                    }
                                }

                            }
                        }
                    }
                }
            }
        }
    public void distanceRelated(){
        if (statment==6) {
            if(currentRunningKilometers%10000+500>=10000||currentRunningKilometers%10000==0)statment=3;
            //仅需要一万里公里保养提醒
        }else if(statment==2){
            if(currentRunningKilometers%10000+500>=10000||currentRunningKilometers%10000==0)statment=3;
            //当定期保养和一万里保养同时需要进行，按一万公里保养记
        }

    }
}
public class TaxiMaintenance {
    public static void main(String[] args)throws ParseException{
        Scanner sc=new Scanner(System.in);
        String currentTime=(sc.nextLine().replaceAll("SubmitDate: ",""));
        List<Taxi> taxiList=new ArrayList<Taxi>();
        String str=sc.nextLine();
        if(str.equals(""))sc.close();
        while(!str.equals("")){
            taxiList.add(new Taxi(str));
            str=sc.nextLine();
        }
        System.out.print(taxiList.size());
        Taxi []wait=new Taxi[taxiList.size()];
        String brand[]=new String[taxiList.size()];
        for(int i=0;i<wait.length;i++){
            wait[i]=taxiList.get(i);
            brand[i]=wait[i].getBrand();
            wait[i].isWriteOff(currentTime);
            wait[i].isWillWriteOff(currentTime);
            wait[i].timeRelated(currentTime);
            wait[i].distanceRelated();
            wait[i].display();
        }
        List list=Arrays.asList(brand);
        Set set=new HashSet(list);
        String brand1[]=(String[]) set.toArray(new String[0]);
        Arrays.sort(brand1,String.CASE_INSENSITIVE_ORDER);
        System.out.println("Reminder\n==================\n* Time-related maintenance coming soon...");
        for(int i=0;i<brand1.length;i++){
            int cout=0;
            String ot1=new String();
            String ot2=new String();
            String ot3=new String();
            String ot=new String();
            for(int j=0;j<wait.length;j++){
                if(wait[j].getBrand().equals(brand1[i])&&wait[j].getStatment()==2){
                    cout++;
                    if(cout==1) {
                        ot1 = brand1[i] + ": " ;
                        ot2=" (" + wait[j].getCarId();
                    }else if(cout>1){
                        ot3=","+wait[j].getCarId();
                    }

                }
                ot=ot1+cout+ot2+ot3;
            }
                if(!ot.equals("0"))System.out.println(ot+")");
        }

        System.out.println("* Distance-related maintenance coming soon...");
        for(int i=0;i<brand1.length;i++){
            int cout=0;
            String ot1=new String();
            String ot2=new String();
            String ot3=new String();
            String ot=new String();
            for(int j=0;j<wait.length;j++){
                if(wait[j].getBrand().equals(brand1[i])&&wait[j].getStatment()==3){
                    cout++;
                    if(cout==1) {
                        ot1 = brand1[i] + ": " ;
                        ot2=" (" + wait[j].getCarId();
                    }else if(cout>1){
                        ot3=","+wait[j].getCarId();
                    }

                }
                ot=ot1+cout+ot2+ot3;
            }
            if(!ot.equals("0"))System.out.println(ot+")");
        }
        System.out.println("* Write-off coming soon...");
        for(int i=0;i<brand1.length;i++){
            int cout=0;
            String ot1=new String();
            String ot2=new String();
            String ot3=new String();
            String ot=new String();
            for(int j=0;j<wait.length;j++){
                if(wait[j].getBrand().equals(brand1[i])&&wait[j].getStatment()==1){
                    cout++;
                    if(cout==1) {
                        ot1 = brand1[i] + ": " ;
                        ot2=" (" + wait[j].getCarId();
                    }else if(cout>1){
                        ot3=","+wait[j].getCarId();
                    }
                }
                ot=ot1+cout+ot2+ot3;
            }
            if(!ot.equals("0"))System.out.println(ot+")");
        }
        sc.close();
    }
}

lnd_wangchen

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
出租车问题

出租车问题在未来，出租汽⻋公司已经采⽤⾃动驾驶汽⻋来开展出租⻋业务。哒哒出⾏就是这样⼀家公司，为了提⾼⽤户体验，公司需要设计⼀款软件来统计提醒⻋辆保养情况。汽⻋保养分为每⼀万公⾥保养和定期保养两种，另外汽⻋除保养之外，达到⼀定条件，则会进⼊报废。每1万公⾥保养提醒规则如下：汽⻋每跑1万公⾥(含)就要保养⼀次，距离1万公⾥还差500公⾥(含)的时候就要开始提醒为了简化规则，不需考虑
复制链接

扫一扫