Queue- a Server Banner Behavior - c++

Question

This Question is from Edx-UCSanDiegoX: ALGS201x Data Structure
Fundamentals Programming Challenge 1-3: Network packet processing
simulation
Hi Everyone, I have a very long question, I sincerely appreciate anyone who spend his/her precious time. Only Response Process(const Request &request) implementation is asked in the question, rest is given.
I having difficulty why Failing Test Case, I found the same answer with trying paper and pen :), maybe I made a silly mistake. Thank You.
Problem Description Task:
You are given a series of incoming network packets and your task is to simulate their processing. Packets arrive in some order. For each packet i , you know when it arrived Ai and the time it takes the processor to process it Pi (both in milliseconds). There is only one processor, and it processes the incoming packets in the order of their arrival. Of the processor started to process some packet, it doesn’t interrupt or stop until it finishes the processing of this packet, and the processing of packet I takes exactly Pi milliseconds.
The computer processing the packets has a network buffer of fixed size S. When packets arrive, they are stored in the buffer before being processed. However, if the buffer is full when a packet arrives (there are S packets which are arrived before this packet, and the computer hasn’t finished processing any of them), it is dropped and won’t be processed at all. If several packets arrive at the same time, they are all stored in the buffer (some of them may dropped because of their arrival, and it starts processing the next available packet from the buffer as soon as it finishes processing the previous one. If at some point the computer is not busy, and there are no packets in the buffer, the computer just waits for the next packet to arrive. Note that a packet leaves the buffer and free the space in the buffer as soon as computer finishes processing it.
Input Format:
The First line of input contains the size S of the buffer and the number n of incoming network packets. Each of the next n lines contains two numbers I-th line contains the time of arrival Ai and processing tine Pi (both in ms) of the the I-th packet. It is guaranteed that the sequence of arrival times is non-decreasing. (However, it can contain the exact same times of arrival in milliseconds in this case the packet which is earlier in the input is considered to have arrived earlier.
Output Format: For each packet output either the moment of the time when the processor began processing it or -1 if the packet was dropped. (output is same order as input packets are given)
Sample Runs
Sample 1
Input:
1 0
Output:
If there are no packets, you should not output anything
Sample 2
Input:
1 1
0 0
Output:
0
The only packet arrived at time 0. And computer started processing it.
Sample 3
Input:
1 2
0 1
0 1
Output:
0
1
The first packet arrived at time 0. the second packet also arrived at time 0 , but was dropped. Because the network buffer has size 1 and it was full with first packet already. The first packet started processing at time 0 , second was not processed at all.
Sample 4
Input :
1 2
0 1
1 1
Output:
0
1
The first packet arrived at time 0 , the computer started processing it immediately and finished at time 1 .The second packet arrived at time 1 and the computer started processing it immediately.
Failing Test Case:
Inputs:
3 6
0 2
1 2
2 2
3 2
4 2
5 2
My Output:
0
2
4
-1
6
-1
Correct Output:
0
2
4
6
8
-1
The Code
#include <iostream>
#include <queue>
#include <vector>
struct Request {
Request(int arrival_time, int process_time) :
arrival_time(arrival_time),
process_time(process_time)
{}
int arrival_time;
int process_time;
};
struct Response {
Response(bool dropped, int start_time) :
dropped(dropped),
start_time(start_time)
{}
bool dropped;
int start_time;
};
class Buffer {
public:
Buffer(int size) :
size_(size),
finish_time_()
{}
Response Process(const Request &request)
{
while (!finish_time_.empty() && finish_time_.front() <= request.arrival_time)
finish_time_.pop();
if (finish_time_.empty())
{
finish_time_.push(request.arrival_time + request.process_time);
return Response(false, request.arrival_time);
}
else
{
if (size_> (finish_time_.back() - request.arrival_time))
{
int before = finish_time_.back();
finish_time_.push(before + request.process_time);
return Response(false, before);
}
else
{
return Response(true, 5);
}
}
}
private:
int size_;
std::queue <int> finish_time_;
};
std::vector <Request> ReadRequests()
{
std::vector <Request> requests;
int count;
std::cin >> count;
for (int i = 0; i < count; ++i) {
int arrival_time, process_time;
std::cin >> arrival_time >> process_time;
requests.push_back(Request(arrival_time, process_time));
}
return requests;
}
std::vector <Response> ProcessRequests(const std::vector <Request> &requests, Buffer *buffer)
{
std::vector <Response> responses;
for (int i = 0; i < requests.size(); ++i)
responses.push_back(buffer->Process(requests[i]));
return responses;
}
void PrintResponses(const std::vector <Response> &responses)
{
for (int i = 0; i < responses.size(); ++i)
std::cout << (responses[i].dropped ? -1 : responses[i].start_time) << std::endl;
}
int main() {
int size;
std::cin >> size;
std::vector <Request> requests = ReadRequests();
Buffer buffer(size);
std::vector <Response> responses = ProcessRequests(requests, &buffer);
PrintResponses(responses);
return 0;
}