AtCoder高橋社長がLINEのコーディング試験を見て驚いた理由―。「競プロとこんなに違うとは……」

 1    #include <iostream>
 2    #include <algorithm>
 3    #include <string>
 4    #include <sstream>
 5    #include <vector>
 6    #include <queue>
 7    using namespace std;
 8    #define rep(i, n) for(int i=0;i<n;i++)
 9
 10  string time_convert(int n){
 11     int day = n/1440 + 1;
 12     int hour = (n - (day-1)*1440)/60;
 13     int minute = n%60;
 14     string ans = to_string(day) + " ";
 15     if(hour < 10) ans = ans + "0";
 16     ans = ans + to_string(hour) + ":";
 17     if(minute<10) ans = ans + "0";
 18     ans = ans + to_string(minute);
 19
 20     return ans;
 21   }
 22
 23
 24   int main(int argc, char *argv[]) {
 25
 26     string line, input;
 27     vector<string> data;
 28     while(1){ //入力の受け取り
 29       getline(cin, line);
 30       if(cin.eof()) break;
 31       stringstream ss{line};
 32       while(getline(ss, input, ' ')){
 33         data.push_back(input);
 34       }
 35     }
 36     //受け取った情報の分割
 37     queue<string> express, normal;
 38     vector<vector<string>> info(100, vector<string>(5, ""));
 39     int times = data.size() / 5;
 40     int cnt = 0;
 41     rep(i, times){
 42       rep(j, 5){
 43         info[i][j] = data[cnt];
 44         cnt++;
 45       }
 46     }
 47
 48     rep(i, times){
 49       rep(j, 5){
 50         if(info[i][j] == "EXPRESS") express.push(info[i][j+1]);
 51         else if(info[i][j] == "NORMAL") normal.push(info[i][j+1]);
 52       }
 53     }
 54
 55     queue<pair><int, pair<string, int>>> lst;//<cnttd_time, command>
 56       rep(i, times){
 57         int cnvtd_time = (stoi(info[i][0])-1) *1440 + stoi(info[i][1].substr(0, 2))* 60 + stoi(info[i][1].substr(3, 2));
 58         lst.push(make_pair(cnvtd_time, make_pair(info[i][3],2)));
 59       }
 60
 61     while(!lst.empty()){
 62       int command = lst.front().second.second;
 63       if(command == 1){
 64
 65       }
 66     }
 67   }

 1    import sys
 2
 3    # Judging time for deliver is valid.
 4    def time_judge(day,hour,minute,ID,time):
 5        if time > 120:
 6            return print(str(day)+ " " + str(hour) + ":" + str(minute) + " " + "ERROR: Deliverly time cannot exceed 120 minutes.")
 7        else:
 8            return print(str(day)+ " " + str(hour) + ":" + str(minute) + " " + "has been accepted.")
 9
 10    # time calculation during delivering
 11    def time_cal(now_time_day,now_time_hour,now_time_minute,time):
 12        after_time = 60 * now_time_hour + now_time_minute + time
 13        if after_time >= 1440:
 14            now_time_day += 1
 15            after_time -= 1440
 16        else:
 17            now_time_hour,now_time_minute = after_time // 60, after_time % 60
 18        return [now_time_day,now_time_hour,now_time_minute]
 19
 20    """
 21    If the value is equal to 0, the deliverer waits for the request.
 22    On the other hand, if the value is equal to 1, the deliverer is now delivering buggages.
 23    """
 24
 25    # input lines by standard input.
 26    array = [] # list of input lines by "str"
 27    for line in sys.stdin.readlines(): # input lines
 28        array.append(line.rstrip())
 29
 30    job_order = [] # the list of input lines by "str", "int" ordered one.
 31
 32    for i in range(len(array)):
 33        requested_job = [0 for k in range(6)] # the list of changing input lines from str to integers
 34        array_new_2 = list(array[i].split()) # the list of memorizing the array_new[i] data for changing integers in part of array_new data.
 35        for j in range(5):
 36            if j == 0:
 37                requested_job[j] = int(array_new_2[j])
 38            elif j == 1:
 39                requested_job[j] = int(array_new_2[j][0:2])
 40                requested_job[j+1] = int(array_new_2[j][3:])
 41            elif j == 2:
 42                if array_new_2[j] == "NORMAL":
 43                    requested_job[j+1] = 1
 44                elif array_new_2[j] == "EXPRESS":
 45                    requested_job[j+1] = 0
 46            elif j == 4:
 47                requested_job[j+1] = int(array_new_2[j])
 48            else:
 49                requested_job[j+1] = array_new_2[j]
 50        job_order.append(requested_job)
 51
 52    sorted(job_order) # sort requests by the order as follows: day, hour, minute, type, ID, and deliver time.
 53
 54    # present time for judging the request time before delivering. time = ["day","hour","minute"]. Initial time is the first valid request.
 55    original_time = [0,0,0]
 56
 57    deliver_time = 0 # first deliver rely only on the request time other than follwing requests
 58
 59    deliver_status = 0
 60
 61    request_time = 0
 62
 63    for i in range(len(job_order)):
 64        if deliver_time == 0:
 65            time_judge(job_order[i][0],job_order[i][1],job_order[i][2],job_order[i][4],job_order[i][5])
 66            if job_order[i][5] <= 120:
 67                print(str(job_order[i][0])+ " " + str(job_order[i][1]) + ":" + str(job_order[i][2]) + " "+ str(job_order[i][4])+ " " + "has been assigned.")
 68                original_time = [job_order[i][0],job_order[i][1],job_order[i][2]] # the start of delivering time.
 69                after_time = time_cal(original_time[0],original_time[1],original_time[2],job_order[i][5]) # the end of finishing delivering time.
 70                deliver_status = 1
 71                deliver_time += 1
 72        else:
 73            time_judge(job_order[i][0],job_order[i][1],job_order[i][2],job_order[i][4],job_order[i][5])
 

 1    #include <bits/stdc++.h>
 2    using namespace std;
 3    using ll = long long;
 4
 5    class Query
 6    {
 7    public:
 8        int date;
 9        string str_time;
 10      int int_time;
 11      string type;
 12      string id;
 13      int duration;
 14      int schedule;
 15      int deadline;
 16    };
 17
 18    string Int2StrTime(int time)
 19    {
 20      int date = time / 1440 + 1;
 21      int h = (time % 1440) / 60;
 22      int m = (time % 1440) % 60;
 23      string s = to_string(date) + " ";
 24      if (h < 10)
 25      {
 26        s += "0";
 27      }
 28      s += to_string(h) + ":";
 29      if (m < 10)
 30      {
 31        s += "0";
 32      }
 33      s += to_string(m);
 34      return s;
 35    }
 36
 37    int main()
 38    {
 39      queue<Query> qs;
 40      queue<Query> ns;
 41      queue<Query> es;
 42      Query q_now;
 43
 44      int date;
 45      while (cin >> date)
 46      {
 47        Query q;
 48
 49        string time;
 50        cin >> time;
 51        q.date = date;
 52        q.str_time = time;
 53        int h = stoi(time.substr(0, 2));
 54        int m = stoi(time.substr(3, 2));
 55        q.int_time = (date - 1)  * 1440 + h *  60 + m;
 56
 57        cin >> q.type >> q.id;
 58        if(q.type == "NORMAL" || q.type == "EXPRESS" || q.type == "SCHEDULED"){
 59          cin >> q.duration;
 60        }
 61        if(q.type == "SCHEDULED"){
 62          int s_date;
 63          string s_time;
 64          cin >> s_date >> s_time;
 65          int h = stoi(s_time.substr(0, 2));
 66          int m = stoi(s_time.substr(3, 2));
 67          q.deadline = (s_date - 1)  * 1440 + h *  60 + m;
 68          q.schedule = (s_date - 1)  * 1440 + h *  60 + m - q.duration;
 69        }
 70        qs.push(q);
 71      }
 72
 73      bool is_delivering;
 74      int time = 0; // 日付1の0時からの経過時間(分)
 75      int time_finish = -1;
 76      while (true)
 77      {
 78        if (time_finish == time)
 79        {
 80          cout << Int2StrTime(time) << " " << q_now.id << " has been delivered." << endl;
 81          is_delivering = false;
 82        }
 83
 84        if (qs.front().int_time == time)
 85        {
 86          Query q = qs.front();
 87          qs.pop();
 88          if (q.duration > 120)
 89          {
 90            cout << q.date << " " << q.str_time << " ERROR: Delivery time cannot exceed 120 minutes." << endl;
 91          }else{
 92            if (q.type == "EXPRESS")
 93            {
 94              es.push(q);
 95            }
 96            if (q.type == "NORMAL")
 97            {
 98              ns.push(q);
 99            }
 100           cout << Int2StrTime(time) << " " << q.id << " has been accepted." << endl;
 101          }
 102        }
 103
 104        if (!is_delivering)
 105        {
 106          if (!es.empty())
 107          {
 108            q_now = es.front();
 109            es.pop();
 110            cout << Int2StrTime(time) << " " << q_now.id << " has been assigned." << endl;
 111            is_delivering = true;
 112            time_finish = time + q_now.duration;
 113          }
 114          else if (!ns.empty())
 115          {
 116            q_now = ns.front();
 117            ns.pop();
 118            cout << Int2StrTime(time) << " " << q_now.id << " has been assigned." << endl;
 119            is_delivering = true;
 120            time_finish = time + q_now.duration;
 121          }
 122        }
 123
 124        if (!is_delivering && qs.empty())
 125        {
 126          break;
 127        }
 128
 129        time++;
 130      }
 131    }
 

 1    import sys
 2
 3
 4    def main(lines):
 5        # このコードは標準入力と標準出力を用いたサンプルコードです。
 6        # このコードは好きなように編集・削除してもらって構いません。
 7        # ---
 8        # This is a sample code to use stdin and stdout.
 9        # Edit and remove this code as you like.
 10
 11       for i, v in enumerate(lines):
 12            print("line[{0}]: {1}".format(i, v))
 13
 14    def parse(l):
 15        day, hm, type_, id_, duration = l.rstrip('\r\n').split(" ")
 16        h,m = map(int, hm.split(":"))
 17        t = Time(int(day),h,m)
 18        req = Request(t,type_,id_,int(duration))
 19        return req
 20
 21    class Request():
 22        def __init__(self, time, type_, id_, duration):
 23            self.time = time
 24            self.type_ = type_
 25            self.id_ = id_
 26            self.duration = duration
 27
 28        def valid(self):
 29            return True
 30
 31        def __repr__(self) -> str:
 32            return self.id_
 33
 34    class Postman:
 35        def __init__(self):
 36            self.item = None
 37
 38        def assign(self, req):
 39            self.item = req
 40
 41    class Queue:
 42        def __init__(self):
 43            self.lis = []
 44
 45        def search(self):
 46            for i,r in enumerate(self.lis):
 47                if r.valid():
 48                    self.lis.pop(i)
 49                    return r
 50            return None
 51
 52        def add(self, req):
 53            self.lis.append(req)
 54
 55    class System:
 56        def __init__(self):
 57            self.running = True
 58            self.postman = Postman()
 59            self.expqueue = Queue()
 60            self.normalqueue = Queue()
 61
 62        def add(self, req: Request):
 63            if self.check(req):
 64                print(f"{req.time} {req.id_} has been accepted.")
 65                self.running = True
 66                if req.type_ == "EXPRESS":
 67                    self.expqueue.add(req)
 68                elif req.type_ == "NORMAL":
 69                    self.normalqueue.add(req)
 70                else:
 71                    raise ValueError()
 72
 73            else:
 74                print(f"{req.time} ERROR: Delivery time cannot exceed 120 minutes.")
 75
 76        def is_complete(self):
 77            if not self.postman.item:
 78                return
 79
 80            if self.postman.item.comptime == globaltime:
 81                print(f"{globaltime} {self.postman.item.id_} has been delivered.")
 82                self.postman.item = None
 83
 84                if len(self.expqueue.lis) == 0 and len(self.normalqueue.lis) == 0:
 85                    system.running = False
 86
 87
 88        def assign(self):
 89            if self.postman.item:
 90                return
 91
 92            req = self.expqueue.search()
 93            if not req:
 94                req = self.normalqueue.search()
 95
 96            if req:
 97                print(f"{globaltime} {req.id_} has been assigned.")
 98                req.comptime = globaltime.add(req.duration)
 99                self.postman.assign(req)
 100
 101       def check(self, req):
 102            return req.duration <= 120
 103
 104    from functools import total_ordering
 105    @total_ordering
 106    class Time:
 107        def __init__(self,d,h,m):
 108            self.d = d
 109            self.h = h
 110            self.m = m
 111
 112        def __str__(self):
 113            return f"{self.d} {str(self.h).zfill(2)}:{str(self.m).zfill(2)}"
 114
 115        def step(self):
 116            self.m += 1
 117            if self.m == 60:
 118                self.m = 0
 119                self.h += 1
 120            if self.h == 24:
 121                self.h = 0
 122                self.d += 1
 123
 124        def minutes(self):
 125            return self.d  * 24* 60 + self.h * 60 + self.m
 126
 127        def __eq__(self, other):
 128            return self.d == other.d and self.h == other.h and self.m == other.m
 129
 130        def __lt__(self, other):
 131            return self.minutes() < other.minutes()
 132
 133        def __repr__(self) -> str:
 134            return str(self.minutes())
 135
 136        def add(self, minutes):
 137            time = Time(self.d, self.h, self.m)
 138            for _ in range(minutes):
 139                time.step()
 140            return time
 141
 142    if __name__ == '__main__':
 143        system = System()
 144        globaltime = Time(1,0,0)
 145        reqs = []
 146        for l in sys.stdin:
 147            req = parse(l)
 148            reqs.append(req)
 149        req = reqs[0]
 150        while system.running or len(reqs) > 0:
 151            system.is_complete()
 152            if req.time == globaltime:
 153                system.add(req)
 154                del reqs[0]
 155                if len(reqs) > 0:
 156                    req = reqs[0]
 157            system.assign()
 158            globaltime.step()