[Hackerrank] 34. Messages Order

34. Messages Order

[ 난이도: Medium | 분야: Debugging ]

1. 과제

실생활 어플리케이션과 시스템에서, 흔히 사용하는 것 중 하나가 메시지이다.

아이디어는 전송하는 자가 메시지를 수신자에게 보내는 것이다. 메시지는 네트워크를 통해 전달된다.

하지만, 몇몇 네트워크 프로토콜은 보낸 메시지의 순서를 보존하는 것을 보장하지 않는다. 

예를 들어, 어떤 사람이 hello, hi 와 what's up이라는 메시지를 보낼 때, 그들은 순서대로 what's up, hello, hi를 받을 것이다.

많은 시스템에서 예상되는 행동은 순서를 보존하여 송수신한 메시지의 순서를 일치하게 하는 것이다.

이 문제에서는, 해야할 것은 임의의 순서대로 메시지를 보내고 있는 네트워크 프로토콜의 최상층보다 위에 있는 소프트웨어 레이어를 implement하는 것이다.

아래의 탬플릿 코드에서는, Recipient와 Network 클래스를 implementation한다.

이번 챌린지에서 해야할 것은 Message 클래스와 MessageFactor 클래스를 아래의 세부 지침에 따라 implement 하는 것이다:

Message 클래스는 문자열 형식의 텍스트를 저장하는 것을 요구하고 이 텍스트를 반환하는 const string& get_text()를 public getter로서 제공한다. 이와 동시에 받은 메시지의 순서를 고치는 fix_order() 메소드에서 사용하는 < 연산자를 implement하라.

다른 메소드와 class/instance 변수들을 사용해도 된다. 특정적으로, 다른 추가적인 constructors를 사용해도 되지만, empty constructor를 제공해야 한다.

MessageFactory 클래스는 empty constructor를 요구하고, Message create_message(const string& text) 메소들을 implement 한다. (여기서 Message 객체는 text 인지를 가지고 있다.)

이 클래스의다른 메소드나 class/instance 변수들을 추가할 수 있다.

잠겨있는 코드 탬플릿은 아래와 같이 동작한다. 첫째, message_factory와 recipient라는 객체를 생성한다.

이 객체들은 MessageFactory와 Recipient 형식이다. 그 다음, 표준 입력으로부터 메시지를 읽고 제공된 Network 클래스에서 recipient에게 메시지를 보내는 것을 시뮬레이팅한다.

Network 클래스는 통과하는 메시지들을 랜덤하게 섞고 recipient에게 recipient.receive(const Message&)를 통해 통과시킨다.

모든 메시지가 전송된 후에 수신자(recipient)는 그것의 고유 메소드인 print_message를 사용하여 받은 모든 메시지들을 standard output을 통해 출력한다. 그리고 그 이전에 fix_order 메소드를 통해 메시지를 수정하여 순서를 바꾼다.

이 기능을 수행하기 위해, sort() 알고리즘을 활용하여 받은 메시지들의 vector를 정렬하고 이것은 Message 클래스가 < 연산자를 제공하는 이유다.

 

입력 형식

잠겨 있는 제공된 코드 탬플릿을 통해 입력을 읽는다. 그것은 들어온 순서대로 여러 줄의 텍스트 메시지를 가지고 있다.

 

제약 사항

입력에는 대부분 10 줄이다.

각 라인은 최대 20자를 포함한다.

 

출력 형식

출력은 제공된 잠겨있는 코드 탬플릿에 의해 제공되고 각 지문의 세부설명을 기술하고 있다.

Expected order of printed messages is the same as the one in the input.

출력 메시지의 예상 순서는 입력과 동일하다.

 

입력 예시0

Alex
Hello Monique!
What's up?
Not much :(

 

출력 형식0

Alex
Hello Monique!
What's up?
Not much ;(

 

문제

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

class Message {
public: 
    Message() {}
    const string& get_text() {
        
    }
};

class MessageFactory {
public:
    MessageFactory() {}
    Message create_message(const string& text) {
        
    }
};

class Recipient {
public:
    Recipient() {}
    void receive(const Message& msg) {
        messages_.push_back(msg);
    }
    void print_messages() {
        fix_order();
        for (auto& msg : messages_) {
            cout << msg.get_text() << endl;
        }
        messages_.clear();
    }
private:
    void fix_order() {
        sort(messages_.begin(), messages_.end());
    }
    vector<Message> messages_;
};

class Network {
public:
    static void send_messages(vector<Message> messages, Recipient& recipient) {
    // simulates the unpredictable network, where sent messages might arrive in unspecified order
        random_shuffle(messages.begin(), messages.end());         
        for (auto msg : messages) {
            recipient.receive(msg);
        }
    }
};



int main() {
    MessageFactory message_factory;
    Recipient recipient;
    vector<Message> messages;
    string text;
    while (getline(cin, text)) {
        messages.push_back(message_factory.create_message(text));
    }
    Network::send_messages(messages, recipient);
    recipient.print_messages();
}

정답

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

class Message {
    private:
        string text;
        static int id;
        int current_id;
public: 
    Message() { current_id = ++id;}
    Message(string t) { current_id = ++id; text=t;}
    const string& get_text() {
        return text;
    }
    bool operator<(const Message& M2) {
        if(current_id < M2.current_id) return true;
        else return false;
    }
};
int Message::id = 0;

class MessageFactory {
public:
    MessageFactory() {}
    Message create_message(const string& text) {
        Message m = Message(text);
        return m;
    }
};

class Recipient {
public:
    Recipient() {}
    void receive(const Message& msg) {
        messages_.push_back(msg);
    }
    void print_messages() {
        fix_order();
        for (auto& msg : messages_) {
            cout << msg.get_text() << endl;
        }
        messages_.clear();
    }
private:
    void fix_order() {
        sort(messages_.begin(), messages_.end());
    }
    vector<Message> messages_;
};

class Network {
public:
    static void send_messages(vector<Message> messages, Recipient& recipient) {
    // simulates the unpredictable network, where sent messages might arrive in unspecified order
        random_shuffle(messages.begin(), messages.end());         
        for (auto msg : messages) {
            recipient.receive(msg);
        }
    }
};



int main() {
    MessageFactory message_factory;
    Recipient recipient;
    vector<Message> messages;
    string text;
    while (getline(cin, text)) {
        messages.push_back(message_factory.create_message(text));
    }
    Network::send_messages(messages, recipient);
    recipient.print_messages();
}

 

 

 

 

 

 

©️Hackerrank. All Rights Reserved.