Simple in Complex with Simple

7. CodeSignal Course Certificate Advanced Built-In Data Structures and their Usage in C++

포츈맨 — Sun, 1 Dec 2024 23:05:25 +0900

https://learn.codesignal.com/certificates/cm3pl1qya0061qqpgr069mcz9/courses/573?utm_source=linkedin&utm_medium=social&utm_campaign=certificate

Course certificate for Advanced Built-In Data Structures and their Usage in C++

Embark on your journey of mastering advanced built-in data structures such as sorted maps, linked lists/queues, and stacks. This course will lay the foundational knowledge required to effectively manipulate these advanced data structures.

learn.codesignal.com

6. Browsing system for Deque

포츈맨 — Sat, 30 Nov 2024 23:34:58 +0900

Point

1. Browsing system 알고리즘 원리

2. Deque의 주요 함수 (push_back, push_front, pop_back, pop_front, front, back)

Problem

With what you've learned about deques, it's time to apply your knowledge to create a more advanced data structure — a BrowserHistory management system. This system will enable users to visit new URLs, navigate backward and forward through their browsing history, and efficiently manage these operations using deques to handle past and future navigations. Your challenge is to implement the three methods that drive this functionality:

void visit(const std::string& url) — Adds a new URL to the browsing history and clears any forward history.
std::string back(int steps) — Moves back in history by the specified number of steps, if possible, and updates the forward history. Returns the current URL after the update.
std::string forward(int steps) — Moves forward in history by the specified number of steps, if possible, and updates the current browsing history. Returns the current URL after the update.
Example:

visit("codesignal.com") - Visits codesignal.com; current history: ["codesignal.com"].
visit("learn.codesignal.com") - Visits learn.codesignal.com; current history: ["codesignal.com", "learn.codesignal.com"].
visit("learn.codesignal.com/course-paths") - Visits learn.codesignal.com/course-paths; current history: ["codesignal.com", "learn.codesignal.com", "learn.codesignal.com/course-paths"].
back(2) - Moves back 2 steps; current history: ["codesignal.com"]. Returns codesignal.com.
forward(1) - Moves forward 1 step; current history: ["codesignal.com", "learn.codesignal.com"]. Returns learn.codesignal.com.

#include "solution.hpp"
#include <algorithm>

void BrowserHistory::visit(const std::string &url) {
    // TODO: Add the visited URL to the history and clear the future
    history_.push_back(url);
    future_.clear();
}

std::string BrowserHistory::back(int steps) {
    // TODO: Move the specified number of steps back in the history, if possible, and update the future accordingly
    // std::rotate(history_.rbegin(), history_.rbegin()+steps, history_.rend());
    // Return the current URL after updating
    
    if (history_.empty()) {
        return "No back";
    }
    
    for (int index = 0; index < steps; ++index) {
        std::string current = history_.back();
        future_.push_front(current);
        history_.pop_back();
        
        if (history_.empty()) {
            return "No back";
        }
    }
    
    return history_.front();
}

std::string BrowserHistory::forward(int steps) {
    // TODO: Move the specified number of steps forward in the history, if possible, and update the history accordingly
    // Return the current URL after updating
    if (future_.empty()) {
        return "No back";
    }

    for (int index = 0; index < steps; ++index) {
        std::string current = future_.front();
        history_.push_back(current);
        future_.pop_back();
        
        if (future_.empty()) {
            return "No back";
        }
    }
    
    return history_.back();
}

int main() {
    BrowserHistory browser;

    // TODO: Use the BrowserHistory class to simulate visiting some URLs, then going back and forward in the history, printing the resulting URL after each move
    
    browser.visit("codesignal.com");
    browser.visit("learn.codesignal.com");
    browser.visit("learn.codesignal.com/course-paths");
    
    std::cout << browser.back(2) << std::endl;
    std::cout << browser.forward(1) << std::endl;
    
    return 0;
}

5. Map using custom object key

포츈맨 — Fri, 29 Nov 2024 22:55:29 +0900

Point

1. operator< 오버로딩

전역으로는 두 객체를 받아 비교하지만 클래스 내부에서는 첫 번째 멤버는 this로 고정이므로 하나의 매개변수를 받는다.

2. 범위형 반복문에서 객체를 const로 선언한다면 getter도 const 선언이 되어야 한다.

3. 비교 연산이 < 일 경우 오름차순, > 일 경우 내림차순이다. STD 컨테이너는 기본적으로 오름차순이다.

Problem

In this exercise, you will implement a small inventory management system using C++ with Product objects as keys in a std::map. Each Product should have an id (integer) and a name (string). The std::map should automatically sort Product objects by their id using custom sorting logic by overloading the < operator.

Here's what you need to accomplish:

Define the Product class: Include id and name attributes, and overload < to enable sorting by id.

Create and populate the inventory: Define a std::map<Product, int> named inventory where the key is a Product and the value is the stock quantity. Add several Product objects with different id and name values and their respective stock quantities.

Implement product search: Write a findProductById function to search for a Product by id in the inventory. It should find the first product with an id not less than the specified search value and return its name and stock quantity. If no match is found, return a message indicating that the product was not found.

Display the result: Use findProductById to find and print a product by id without removing it from the map.

This task combines object-oriented programming with sorted data structures in C++, focusing on custom sorting and efficient map search. Follow the steps and structure your code accordingly.

#include "solution.hpp"

// TODO: Define a Product class with attributes id (integer) and name (string). 
// Implement operator< for sorting by id.
class Product {
  
private:
    int id;
    std::string name;
    
public:
    Product(int id, std::string name) {
        this->id = id;
        this->name = name;
    }

    bool operator<(const Product& other) const {
        return this->id < other.id;
    }
    
    int getId() const {
        return this->id;
    }
    
    std::string getName() const {
        return this->name;
    }
};

std::string findProductById(const std::map<Product, int>& inventory, int id) {
    std::string result;
    
    for (const auto& pair : inventory) {
        if (pair.first.getId() >= id) {
            result = pair.first.getName() + ", " + std::to_string(pair.second);
        }
    }
    
    if (result.empty()) {
        return "The product was not found";    
    } else {
        return result;   
    }
}

int main() {
    // TODO: Create an instance of std::map named inventory.
    std::map<Product, int> inventory;

    // TODO: Add some Product objects to inventory with different ids and names,
    // associating each Product with an integer stock quantity.
    inventory.insert(std::make_pair(Product(1, "Ice"), 5));
    inventory.insert(std::make_pair(Product(2, "Cream"), 3));
    inventory.insert(std::make_pair(Product(3, "Cookie"), 7));
    inventory.insert(std::make_pair(Product(6, "Snack"), 4));

    // TODO: Implement and use a function to find the first Product object with 
    // an id not less than a specified value, then print it without removing.
    std::cout << findProductById(inventory, 5) << std::endl;

    return 0;
}

4. Multimap to Map

포츈맨 — Thu, 28 Nov 2024 23:07:55 +0900

Point

1. return {};

요즘 Modern C++의 추세.

초기화된 객체를 반환.

반환 타입에 따라 빈 컨테이너, 기본값, 기본 생성자 호출이 이뤄짐

2. .find()는 기본적으로 iterator를 반환하며 iterator는 기본적으로 const

Problem

Your journey with std::multimap in C++ has equipped you with the skills to manipulate and traverse multiple key-value pairs efficiently. It's time to apply this knowledge! Imagine you're keeping track of participants' scores in a riveting quiz competition. Your task is to create a std::multimap in C++ to record these scores, possibly with multiple entries per participant. Then, write a function that aggregates all scores for each participant into a std::map, where each participant maps to a vector of scores they received. Your goal is to transform this multimap into a map, encapsulating all scores in a single vector for each participant.

For example, given the input multimap:

Copy to clipboard
{
    {"Olivia", 85},
    {"Liam", 92},
    {"Emma", 95},
    {"Noah", 90},
    {"Olivia", 88},
    {"Liam", 75},
    {"Emma", 89}
}
The output map should be:

Copy to clipboard
{
    {"Olivia", [85, 88]},
    {"Liam", [92, 75]},
    {"Emma", [95, 89]},
    {"Noah", [90]}
}
Embark on this challenge and effectively utilize std::multimap and std::map!

#include "solution.hpp"

std::map<std::string, std::vector<int>> aggregateScores(const std::multimap<std::string, int>& scores) {
    // TODO: Implement the aggregateScores function which takes a multimap of participant names (string) to scores (int)
    // and returns a map where each participant maps to a vector of their scores.
    
    std::map<std::string, std::vector<int>> map;
    
    for (const auto& score : scores) {
        // IsExist?
        auto it = map.find(score.first);
        if (it != map.end()) {
            // Exist
            it->second.push_back(score.second);
        } else {
            // Not Exist
            std::vector<int> number;
            number.push_back(score.second);
            map.emplace(std::make_pair(score.first, number));
        }
    }
    
    //return {};
    return map;
}

int main() {
    std::multimap<std::string, int> participantScores = {
        {"Olivia", 85},
        {"Liam", 92},
        {"Emma", 95},
        {"Noah", 90},
        {"Olivia", 88},
        {"Liam", 75},
        {"Emma", 89}
    };

    std::map<std::string, std::vector<int>> aggregatedScores = aggregateScores(participantScores);
    
    for (const auto& entry : aggregatedScores) {
        std::cout << "Participant: " << entry.first << " - Scores: ";
        for (int score : entry.second) {
            std::cout << score << " ";
        }
        std::cout << std::endl;
    }

    return 0;
}

1. 왜 우리 회사에 지원했니?

포츈맨 — Tue, 26 Nov 2024 23:37:21 +0900

Q: Why do you want to work as a software engineer at our company?

A: I admire your innovative tech solutions and collaborative culture. My skills in software development and passion for creating efficient code align perfectly with your company’s mission, and I’m eager to contribute to your team’s success.

Q: Can you describe your software development process?

A: I gather requirements, design architecture, develop, test, iterate based on feedback, and ensure high-quality deliverables through reviews and testing.

3. Map & Multimap

포츈맨 — Tue, 26 Nov 2024 22:23:50 +0900

Principle: Red-Black Tree

Header: #include <map>

Methods: find(), count(), empty(), equal_rage()

Associated: std::next(), std::prev(), std::distance()

Feature: Map's key must be unique, multimap's key can be duplicated.

Code example:

#include "solution.hpp"
#include <iostream>
#include <map>

bool checkMultipleOccurrences(const std::string& fruit) {
    // Create a multimap with fruits as keys and their counts as values
    std::multimap<std::string, int> fruitMap = {
        {"apple", 5},
        {"banana", 2},
        {"apple", 3},
        {"orange", 4},
        {"apple", 4}
    };

    // TODO: Determine if the given fruit has multiple values and return true or false
    /*
    if (fruitMap.count(fruit) > 1) {
        return true;
    } else {
        return false;
    }
    */
    
    auto range = fruitMap.equal_range(fruit);
    if (std::distance(range.first, range.second) > 1) {
        return true;
    } else {
        return false;
    }
}

int main() {
    bool result = checkMultipleOccurrences("apple");
    if (result) {
        std::cout << "Multiple occurrences found." << std::endl;
    } else {
        std::cout << "No multiple occurrences." << std::endl;
    }
    return 0;
}

#include "solution.hpp"

std::map<std::string, int> count_event_frequency(const std::multimap<std::string, std::string>& events) {
    // TODO: Implement logic to return the frequency count of each date in the multimap.
    std::map<std::string, int> map;
    
    // multimap에서 꺼내서 map의 키를 검사 후 넣어
    for (const auto& event : events) {
        int count = map.count(event.first);
        if (map.count(event.first) != 0) {
            map.erase(event.first);
        }
        
        map.insert({event.first, count+1});   
    }
    
    return map;
}

int main() {
    // Create a multimap containing dates and their respective events
    std::multimap<std::string, std::string> events = {
        {"2023-06-11", "Seminar"},
        {"2023-06-11", "Workshop"},
        {"2023-06-21", "Concert"},
        {"2023-07-12", "Conference"},
        {"2023-07-12", "Meeting"}
    };

    // Get the frequency count of events on each date
    std::map<std::string, int> frequency_count = count_event_frequency(events);

    // Display the frequency count of events
    for (const auto& date : frequency_count) {
        std::cout << date.first << ": " << date.second << std::endl;
    }
    
    return 0;
}

기술 스택 점검

포츈맨 — Sat, 23 Nov 2024 23:43:28 +0900

경력: 8년

언어: C++(중급-고급), C# 4년(초급-중급), JAVA 1년(중급), JAVA Script 6개월(초급-중급), Shell Script 2년(초급-중급)

프레임워크: WPF (중급), Spring Boot (초급 - 중급)

OS: Windows, Ubuntu22.04, CentOS7, Rockylinux8.9

DB: Oracle11g -> 19c, PostgreSQL14

도구: Visual Studio, Visual Code, Git, GitLab, Jenkins, DBeaver, WSL, Docker + ELK or PG

OpenSource: ARIA, JSON

인프라 경험: AWS에 컨테이너 서비스 배포

수행 프로젝트: 인증 시스템 설계 및 개발, OOXML, WPF View, MachineID, ARIA, SentinelSDK DLL

2. Queue and Deque

포츈맨 — Sat, 23 Nov 2024 23:21:11 +0900

Principle: FIFO (First In First Out)

Header: <queue>, <deque>

Methods: push(), pop(), front(), empty(), push_front(), push_back(), pop_front(), pop_back(), end(), rend()

Associated: std::rotate() - deque

Example:

In this exercise, you will develop a simple coffee shop order management system using a deque in C++. You will perform the following tasks:

Initialize a deque to manage coffee shop orders with initial drinks: 'Latte', 'Espresso', and 'Cappuccino'.
Add a new order 'Mocha' to the end of the deque.
Simulate a customer's change of mind by moving 'Latte' from the front to the back of the deque.
Serve (remove and print) the first order in the deque, which should be 'Espresso'.
Your goal is to demonstrate effective use of deque operations to simulate line management in a coffee shop.

#include "solution.hpp"

int main() {
    // TODO: Create a deque for coffee shop orders with initial orders 'Latte', 'Espresso', 'Cappuccino'
    std::deque<std::string> orders = {"Latte", "Espresso", "Cappuccino"};

    // TODO: A new customer orders a 'Mocha', add it to the end of the deque
    orders.push_back("Mocha");

    // TODO: A customer wants their 'Latte' order moved to the end of the deque. Implement it.
    std::rotate(orders.rbegin(), orders.rbegin()+1, orders.rend());

    // TODO: Process (remove and print) the first order in the deque. Which drink is it?
    std::string order = orders.front();
    orders.pop_front();
    std::cout << order << std::endl;
    
    return 0;
}

1. Stack

포츈맨 — Sat, 23 Nov 2024 22:44:04 +0900

Principle: LIFO (First In First Out)

Header: <stack>

Methods: push(), pop(), top()

Examples: Check balance for Parenthesis (), Braces {}, Brackets []

You've learned how to use stacks in C++ for various applications. Now, put your knowledge to the test by evaluating an expression in Reverse Polish Notation (also known as postfix notation), where operands precede the operator. In other words, the operator comes after the two numbers on which it is supposed to operate.

Your task is to write a function that processes such an expression and returns the result. Remember, in a Reverse Polish Notation expression like "1 2 + 4 -", the operation is performed from left to right. This means you first add 1 and 2, and then subtract 4 from the result, getting -1 as a final result.

Assume the expression only includes + and - operators. Hint: you can use std::stoi to convert a (numeric) string into an integer value.

#include "solution.hpp"

#include <climits>

int evaluate_reverse_polish_notation(const std::string &expression) {
    // TODO: processe a RPN expression and return the result
    std::stack<int> value;
    
    for (const auto& ch : expression) {
        if (ch != ' ') {
            if (ch == '+') {
                if (value.size() < 2) {
                    return INT_MIN;
                }
                
                int back = value.top();
                value.pop();
                int front = value.top();
                value.pop();
                
                value.push(back+front);
            } else if (ch == '-') {
                if (value.size() < 2) {
                    return INT_MIN;
                }
                
                int back = value.top();
                value.pop();
                int front = value.top();
                value.pop();
                
                value.push(front - back);
            } else {
                value.push(ch - '0');
            }
        }
    }
    
    if (value.size() == 1) {
        return value.top();
    } else {
        return INT_MIN;
    }
}


int main() {
    // The expression "1 2 + 4 -" is "(1 + 2) - 4"
    std::cout << evaluate_reverse_polish_notation("1 2 + 4 -") << std::endl; // Expected output: -1
    return 0;
}

AWS에서 EC2, Docker(ECS), EKS 비교

포츈맨 — Thu, 21 Nov 2024 21:38:12 +0900

최근 특정 기업의 채용 공고를 보는데 EC2에서 EKS로 넘어갔다고 했다. 나는 오래 전 AWS에서 EC2를 받아서 사용은 해봤지만 EKS는 처음 들었던 단어였기에 생소해서 AI에게 물어보았다. Docker는 조금 다른 개념이긴 하지만 그래도 내 생각으로는 EC는 클라우드 VM과 같은 존재여서 같이 껴넣어서 비교해달라고 했다. 답변을 보고 EKS로 넘어갔다는 것은 그 기업은 EC2를 활용한 인프라에서 쿠버네티스 위에 인프라를 구축했다는 의미라는 것을 알게 되었다.

1. EC2 (Elastic Compute Cloud)

개요

AWS가 제공하는 가상 서버.
사용자가 OS, 소프트웨어, 네트워크 등 모든 것을 직접 설정 및 관리.

특징

유연성: 완전한 서버 접근 권한. 원하는 대로 OS와 애플리케이션 설치 가능.
관리 부담: 패치, 스케일링, 장애 복구 등 모든 관리를 직접 해야 함.
운영 방식: 전통적인 서버 기반으로, 애플리케이션이 컨테이너화되지 않아도 동작.

장점

높은 커스터마이징 가능성.
다양한 워크로드 처리 가능 (웹 서버, DB 서버 등).
간단한 소규모 프로젝트에 적합.

단점

관리 복잡도 증가.
리소스 활용 비효율 가능 (서버 과잉 또는 부족).

2. Docker

개요

컨테이너화 기술로, 애플리케이션과 필요한 환경을 패키징하여 독립적으로 실행.
Docker 자체는 AWS 서비스가 아니라 컨테이너화 도구이며, AWS에서는 EC2나 EKS 같은 서비스를 통해 실행.

특징

이식성: 컨테이너는 어디서나 동일하게 실행.
경량화: 가상머신(VM)보다 리소스 사용이 적음.
EC2, ECS, EKS 같은 서비스에서 컨테이너를 실행할 수 있음.

장점

환경 독립성: 개발 환경과 운영 환경 차이를 최소화.
빠른 배포 및 스케일링.
인프라 활용 효율성 증가.

단점

컨테이너 환경 관리 필요.
단독으로는 클러스터링이나 확장 기능 부족 (ECS/EKS와 결합 필요).

3. EKS (Elastic Kubernetes Service)

개요

AWS의 쿠버네티스(Kubernetes) 관리 서비스.
컨테이너화된 애플리케이션을 관리하고 확장하며 배포하는 데 사용.

특징

자동화: 스케일링, 배포, 로드 밸런싱 등 컨테이너 클러스터 관리 자동화.
복잡성: EC2나 Docker보다 초기 설정과 운영이 복잡할 수 있음.
관리형 서비스: AWS가 쿠버네티스의 제어 플레인을 관리하므로 일부 부담 완화.

장점

고가용성과 자동화된 스케일링.
복잡한 멀티컨테이너 애플리케이션 배포에 적합.
클러스터 환경에서 리소스를 효율적으로 운영 가능.

단점

러닝 커브가 있음 (쿠버네티스 이해 필요).
소규모 프로젝트에는 과도한 솔루션일 수 있음.

4. 주요 차이점

기능/특징EC2Docker (단독)EKS

운영 방식	전통적인 서버 기반	컨테이너 기반	컨테이너 클러스터 기반
관리 범위	사용자 전담 (OS, 서버 등)	컨테이너 이미지 관리 필요	AWS가 제어 플레인 관리
자동화 수준	낮음	제한적 (컨테이너 스케줄링 없음)	높음 (스케일링, 로드 밸런싱 자동화)
스케일링	수동	제한적	자동 (노드/컨테이너 수준)
복잡성	낮음	중간	높음
적합한 환경	소규모/전통적 애플리케이션	컨테이너화된 애플리케이션	대규모 분산 애플리케이션

5. 결론

EC2: 서버를 완전히 관리해야 하는 상황에서 사용. 소규모 애플리케이션이나 초기 단계에서 적합.
Docker: 애플리케이션을 컨테이너화하여 이식성을 높이고 싶을 때 사용. 단일 Docker 실행은 EC2나 ECS에서.
EKS: 대규모, 복잡한 컨테이너화 애플리케이션을 효율적으로 관리하고 자동화하려면 사용.