한 일상

Programmers - 행렬의 곱셈, 피보나치 수, 최솟값 만들기

HI2 — Sun, 5 Sep 2021 19:39:59 +0900

#include <string>
#include <vector>

using namespace std;

vector<vector<int>> solution(vector<vector<int>> arr1, vector<vector<int>> arr2)
{
    vector<vector<int>> answer;
    //
    int a_row = arr1.size();
    int a_col = arr1[0].size();
    int b_col = arr2[0].size();
    // 연산
    for(int r = 0; r < a_row; ++r)
    {
        vector<int> tmp;
        for(int c = 0; c < b_col; ++c)
        {
            int val = 0;
            for(int k = 0; k < a_col; ++k)
                val += arr1[r][k] * arr2[k][c];
            //
            tmp.push_back(val);
        }
        answer.push_back(tmp);
    }
    //
    return answer;
}

# 행렬? -> 3중 for문

[ 피보나치 수 ] : < LV2 >

#include <string>
#include <vector>

using namespace std;

int solution(int n)
{
    int answer = 0;
    // 피보나치 상수 정의 : f(0) = 0, f(1) = 1
    int fibo = 1, prev = 1, pprev = 0;
    for(int i = 2; i < n; ++i)
    {
        pprev = prev;
        prev = fibo;
        // mod 연산의 성질
        fibo = (prev + pprev) % 1234567;
    }
    //
    answer = fibo;
    //
    return answer;
}

# 최종값에 mod연산시 overflow 발생
-> mod 연산의 성질에 따라 연산 중간결과에 mod 적용
※ (a+b)%c = ((a%c)+(b%c))%c

[ 최솟값 만들기 ] : < LV2 >

#include <vector>
#include <algorithm>

using namespace std;

int solution(vector<int> A, vector<int> B)
{
    int answer = 0;
    //
    sort(A.begin(), A.end());
    sort(B.begin(), B.end());
    //
    int sum = 0;
    int cnt = A.size();
    for(int i = 0; i < cnt; ++i)
    {
        int max, min;
        if(A.back() > B.back())
        {
            max = A.back();
            min = B.front();
            //
            sum += (max) * (min);
            //
            A.pop_back();
            B.erase(B.begin());
        }
        else
        {
            max = B.back();
            min = A.front();
            //
            sum += (max) * (min);
            //
            A.erase(A.begin());
            B.pop_back();
        }
    }
    //
    answer = sum;
    //
    return answer;
}

# STL vector
  - 처음/끝 iterator : v. begin() / v.end()
  - 처음/끝 data : v.front() / v.back()
  - v.end()는 마지막 데이터 [바로 다음]의 iterator(종료)
    -> 마지막 원소 제거 : v.erase(v.end() -1) //or// v.pop_pack()

Programmers - JadenCase 문자열 만들기, N개의 최소공배수

HI2 — Sat, 4 Sep 2021 17:25:23 +0900

[ JadenCase 문자열 만들기 ] : < LV2 / 7220명 >

#include <string>
#include <vector>

using namespace std;

string solution(string s)
{
    string answer = "";
    bool flag = true;
    //
    for(char& c : s)
    {
        // 공백문자 패스
        if(c == ' ')
        {
            flag = true;
            continue;
        }
        // 공백 이후 첫번째 문자
        if(flag == true)
        {
            flag = false;
            c = toupper(c); 
        }
        else
            c = tolower(c); 
    }
    //
    answer = s;
    return answer;
}

# 시행착오 : sstream 사용해서 단어 단위로 분리해서 첫글자 변환

(주어진 문장에 공백이 2개 이상 있는 경우가 존재!)

# 해결 : 한글자씩 조건 검사

[ N개의 최소공배수 ] : < LV2 / 7722명 >

#include <string>
#include <vector>

using namespace std;

int GCD(int a, int b)
{ // 유클리드 호제법
    if(b == 0)
        return a;
    else 
        return GCD(b, a % b);
    //
    return -1;
}

int LCM(int a, int b)
{
    int result = (a * b) / GCD(a, b);
    //
    return result;
}

int solution(vector<int> arr)
{
    int answer = arr[0];
    //
    for(int i : arr)
        answer = LCM(i, answer);
    //
    return answer;
}

# 유클리드 호제법을 사용한 gcd(최대공약수) 계산 (mod연산 특성에 의해 매개변수 대소비교 불필요)

# lcm = a * b * gcd(a, b)

Programmers - 숫자 문자열과 영단어, 위클리 챌린지 1주차, 2주차, 4주차, 5주차

HI2 — Wed, 1 Sep 2021 18:37:34 +0900

[ 숫자 문자열과 영단어 ] : < LV1 / 5286명 >

#include <string>
#include <vector>

using namespace std;

void ReplaceAll(string& text, string pattern, string replace)
{
    int pos = 0, offset = 0;
    while(true)
    {
        pos = text.find(pattern, offset);
        if(pos == string::npos)
            break;
        //
        text.replace(text.begin() + pos,
                     text.begin() + pos + pattern.size(),
                     replace);
        offset = pos + replace.size();
    }
}

int solution(string s)
{
    int answer = 0;
    //
    string val = s;
    vector v = {"zero", "one", "two", "three", "four",
                "five", "six", "seven", "eight", "nine"};
    //
    for(int i = 0; i < v.size(); ++i)
        ReplaceAll(val, v[i], to_string(i));
    //
    answer = stoi(val);
    //
    return answer;
}

# string, replace, replaceAll

[ 1주차 ] : < LV1 / 6494명 >

using namespace std;

long long solution(int price, int money, int count)
{
    long long answer = 0;
    //
    long long cost = 0, m = money, c = count;
    //
    for(int i = 1; i < count+1; ++i)
        cost += price * i;
    //
    answer = cost - money;
    if(answer < 0)
        answer = 0;
    //
    return answer;
}

# 반환값 자료형 int -> longlong

[ 2주차 ] : < LV1 / 3729명 >

#include <string>
#include <vector>
#include <algorithm> // sort

using namespace std;

string solution(vector<vector<int>> scores)
{
    string answer = "";
    //
    float score;
    int selfScore, sum;
    char grade;
    //
    int count = scores.size();
    for(int i = 0; i < count; ++i)
    {
        // 변수 초기화
        score = selfScore = sum = grade = 0;
        // 개인 점수 종합
        vector<int> v;
        for(int j = 0; j < count; ++j)
            v.push_back(scores[j][i]);
        // 본인 평가 분리
        selfScore = v[i];
        v.erase(v.begin() + i);
        /* 평균 점수 계산 */
        // 총점
        for(int score : v)
            sum += score;
        // 최고점, 최저점
        sort(v.begin(), v.end());
        int min = *v.begin();
        int max = *(v.end()-1);
        // 유일한 최고점 or 유일한 최저점이 아니면
        if(min <= selfScore &&  selfScore <= max)
            score = ((float)(sum + selfScore) / count);
        else
            score = ((float)sum / (count - 1));
        // 평점 -> 학점 변환
        if(score >= 90.0f)
            grade = 'A';
        else if(score >= 80.0f)
            grade = 'B';
        else if(score >= 70.0f)
            grade = 'C';
        else if(score >= 50.0f)
            grade = 'D';
        else
            grade = 'F';
        //
        answer += grade;
    }
    //
    return answer;
}

# vector.erase() 사용법 2가지 : 단일(iterater), 범위(beginIndex(이상), endIndex(미만))

# vector.end() iterator는 null이므로 마지막 값을 얻으려면 '-1'

[ 4주차 ] : < LV1 / 2173명 >

#include <string>
#include <vector>
#include <map>
#include <algorithm>

using namespace std;
//===============================================//
typedef pair<string, int> si;
//===============================================//
bool cmp(const si& a, const si& b)
{
    if(a.second == b.second)
        return a.first < b.first;
    //
    return a.second > b.second;
}
//===============================================//
string solution(vector<string> table, vector<string> languages, vector<int> preference)
{
    string answer = "";
    // 계산된 결과를 저장할 map(언어이름 : key, 점수 : value)
    map<string, int> result;
    for(string s : table)
    {
        // table string을 ' ' 단위로 분해, vector에 저장
        vector<string> v;
        while(!s.empty())
        {
            string tmp = s.substr(0, s.find(' '));
            s.erase(0, tmp.length() + 1);
            //
            v.push_back(tmp);
        }
        // map에 언어별 점수 입력
        map<string, int> jobScore;
        int max = v.size() - 1;
        for(int i = 0; i < max; ++i)
            jobScore[v[i+1]] = max - i;
        // 사용언어 점수조회 & 선호도 계산
        for(int i = 0; i < languages.size(); ++i)
        {
            int langValue = 0;
            if(jobScore.count(languages[i]) != 0)
                langValue = jobScore[languages[i]];

            // 직업군별 계산된 결과 저장
            result[v[0]] += langValue * preference[i];
        }
    }
    // 고득점 순으로 정렬(내림차순), 동점시 직군명 사전순
    vector<si> v(result.begin(), result.end());
    sort(v.begin(), v.end(), cmp);
    //
    answer = v[0].first;
    //
    return answer;
}

# string 분할 by split(' ')

-> sstream 사용하는 방법도 좋다

# map value로 정렬, value같을시 key값 사전순 정렬

[ 5주차 ] : < LV2 / 1192명 >

#include <string>
#include <vector>
#include <algorithm>

using namespace std;

vector<string> v;
vector<int> wordSize = { 1, 2, 3, 4, 5 };
vector<char> chars = { 'A', 'E', 'I', 'O', 'U' };

void repeatPermutation(int depth, string str, int size)
{
    if(depth == size)
    {
        v.push_back(str);
        return;
    }
    //
    for(int i = 0; i < chars.size(); ++i)
    {
        str[depth] = chars[i];
        repeatPermutation(depth + 1, str, size);
    }
}

int solution(string word)
{
    int answer = 0;
    //
    for(int i = 1; i <= wordSize.size(); ++i)
    {
        string str(i, ' ');
        repeatPermutation(0, str, i);
    }
    //
    sort(v.begin(), v.end());
    //
    auto it = find(v.begin(), v.end(), word);
    if(it == v.end())
        return -1;
    //
    answer = it - v.begin() + 1;
    //
    return answer;
}

# 재귀를 이용한 중복순열 생성

Programmers - 게임 맵 최단거리, 괄호 변환, 메뉴 리뉴얼

HI2 — Thu, 24 Jun 2021 16:56:05 +0900

[ 게임 맵 최단거리 ] : < LV2 / 2374명 >

#include <vector>
#include <queue>

using namespace std;

struct V2
{
    int x, y;
    V2(int _x, int _y)
    {
        x = _x;
        y = _y;
    }
};

int solution(vector<vector<int>> maps)
{
    int answer = 0;
    //
    const int height = maps.size();
    const int width = maps[0].size();
    //
    vector<vector<bool>> open(height, vector<bool>(width, true));
    vector<vector<int>> dist(height, vector<int>(width, -1));
    // left, right, up, down
    vector<V2> dir { V2(-1, 0) , V2(+1, 0) , V2(0, -1) , V2(0, +1) };
    // begin
    queue<V2> q;
    q.push(V2(0, 0));
    open[0][0] = false;
    dist[0][0] = 1;
    while(q.empty() == false)
    {
        V2 cur = q.front();
        q.pop();
        //
        for(int j = 0; j < dir.size(); ++j)
        {
            V2 pos = V2(cur.x + dir[j].x, cur.y + dir[j].y);
            int x = pos.x, y = pos.y;
            bool inRange =  ((0 <= x && x < width) && (0 <= y && y < height));

            if(inRange && maps[y][x] && open[y][x])
            {
                q.push(V2(x, y));
                open[y][x] = false;
                dist[y][x] = dist[cur.y][cur.x] + 1;
            }
        }
    }
    //
    return dist[height-1][width-1];
}

# bfs(breadth-first search) : queue, struct

# 참고 : https://ansohxxn.github.io/programmers/114/

[ 괄호 변환 ] : < LV2 / 8396명 >

#include <string>
#include <vector>
#include <map>

using namespace std;

string Reversed(string s)
{
    string tmp = s.substr(1, s.size() - 2);
    //
    map<char, char> m;
    m['('] = ')';
    m[')'] = '(';
    //
    for(int i = 0; i < tmp.size(); ++i)
        tmp[i] = m[tmp[i]];
    //
    return tmp;
}

bool IsCorrect(string s)
{
    int pos = 0;
    while(true)
    {
        int pos = s.find("()");
        if(pos != string::npos)
            s.erase(pos, 2);
        else
            break;
    }
    //
    return s.empty();
}

bool IsBalanced(string s)
{
    map<char, int> m;
    //
    for(int i = 0; i < s.size(); ++i)
        ++m[s[i]];
    //
    return (m['('] == m[')']);
}

string Program(string p)
{
    if(p == "" || IsCorrect(p))
        return p;
    //
    string u = "", v = "";
    //
    int len = p.size();
    for(int i = 0; i < len; ++i)
    {
        u += p[i];
        if(IsBalanced(u))
        {
            v = p.substr(i+1, len-i-1);
            if(IsCorrect(u))
            {
                u += Program(v);
                return u;
            }
            else
            {
                string tmp = "";
                tmp += "(";
                tmp += Program(v);
                tmp += ")";
                tmp += Reversed(u);
                return tmp;
            }
        }
    }
    //
    return "";
}

string solution(string p)
{
    string answer = "";
    //
    answer = Program(p);
    //
    return answer;
}

# stl string class

- void erase(pos, count)

- string substr(pos, count)

[ 메뉴 리뉴얼 ] : < LV2 / 3602명 >

#include <string>
#include <vector>
//
#include <algorithm>
#include <map>
//
using namespace std;
// ========================================================== //
typedef pair<string, int> si;
// ========================================================== //
bool cmp(const si& a, const si& b)
{ // 내림차순
    return a.second > b.second;
}
// ========================================================== //
void findOrderPattern(map<string, int>& m, int courseSize, string order)
{
    sort(order.begin(), order.end());
    //
    int len = order.length();
    vector<bool> comb(len, false);
    //
    for(int i = 0; i < courseSize; ++i)
        comb[i] = true;
    //
    do
    {
        string pattern = "";
        for(int i = 0; i < len; ++i)
            if(comb[i])
                pattern += order[i];
        //
        m[pattern]++;
    } while(prev_permutation(comb.begin(), comb.end()));
}
// ========================================================== //
vector<string> solution(vector<string> orders, vector<int> course)
{
    vector<string> answer;
    //
    for(int menuCount : course)
    {
        map<string, int> m;
        // 주문패턴 저장
        for(string order : orders)
            findOrderPattern(m, menuCount, order);
        // 주문횟수 내림차순 정렬
        vector<si> v(m.begin(), m.end());
        sort(v.begin(), v.end(), cmp);
        // 2회 미만 주문 제외
        int maxCount = v.begin()->second;
        if(maxCount < 2)
            continue;
        else
        { // 최다주문 메뉴 추출
            auto iter = v.begin(), end = v.end();
            for(; iter != end; ++iter)
                if(iter->second == maxCount)
                    answer.push_back(iter->first);
        }
    }
    //
    sort(answer.begin(), answer.end());
    // 중복제거
    answer.erase(unique(answer.begin(), answer.end()), answer.end());
    //
    return answer;
}

# brute force 방식

# combination : comparator, prev_permutation

# STL vector : unique

# ETC : map, sort

Programmers - 전화번호 목록, 소수 찾기, 예상 대진표

HI2 — Sat, 19 Jun 2021 17:44:09 +0900

[ 전화번호 목록 ] : < LV2 / 27125명 >

#include <string>
#include <vector>
#include <algorithm> // sort()

using namespace std;

bool solution(vector<string> phone_book)
{
    bool answer = true;
    //
    sort(phone_book.begin(), phone_book.end());
    //
    int cnt = phone_book.size();
    for(int i = 0; i < cnt-1; ++i)
    {
        if(phone_book[i+1].find(phone_book[i]) == 0)
            return false;
    }
    //
    return answer;
}

# sort(사전식 정렬)의 특성에 의해 현재 문자열이 다음 문자열의
접두어가 아니면 이후의 모든 문자열을 확인할 필요가 없다.

# str_val.find(str_cmp) 함수는 해당 문자열이 있는 위치를 반환하므로

반환값이 0일 때 str_val은 str_cmp로 시작한다 // startsWith

[ 소수 찾기 ] : < LV2 / 13655명 >

#include <string>
#include <vector>
//
#include <map> // m.size() // count of key
#include <cmath> // sqrt
#include <algorithm> // next_permutation

using namespace std;

bool IsPrime(int num)
{
    if(num == 0 || num == 1)
        return false;
    //
    for(int i = 2; i <= sqrt(num); ++i)
        if(num % i == 0)
            return false;
    //
    return true;
}

int solution(string numbers)
{
    int answer = 0;
    //
    map<int, int> m;
    vector<bool> v;
    string temp = "";

    int count = numbers.size();
    for(int i = 1; i <= count; ++i)
    {
        v.clear();
        //
        for(int j = 0; j < i; ++j)
            v.push_back(true);
        for(int j = 0; j < count - i; ++j)
            v.push_back(false);
        //
        sort(v.begin(), v.end());
        do
        {
            temp = "";
            //
            for(int i = 0; i < count; ++i)
                if(v[i] == true)
                    temp += numbers[i];
            //
            sort(temp.begin(), temp.end());
            do
            {
                int num = stoi(temp);
                if(IsPrime(num) == true)
                    ++m[num];
            } while (next_permutation(temp.begin(), temp.end()));
        } while (next_permutation(v.begin(), v.end()));
    }
    //
    return m.size();
}

# prime number

# permutation, combination

[ 예상 대진표 ] : < LV2 / 4400명 >

#include <algorithm> // swap

using namespace std;

int solution(int n, int a, int b)
{
    int answer = 1;
    //
    if(a > b)
        swap(a, b);
    //
    while(true)
    {
        if(a % 2 == 1 && (b - a) == 1)
            break;
        else
            ++answer;
        //
        a += (a % 2);
        a /= 2;
        //
        b += (b % 2);
        b /= 2;
    }
    //
    return answer;
}

# a = 2n-1, b = 2n인 경우 루프 종료

Programmers - 카카오프렌즈 컬러링북, 수식 최대화, 튜플

HI2 — Wed, 16 Jun 2021 01:05:40 +0900

[ 카카오프렌즈 컬러링북 ] : < LV2 / 4129명 >

#include <vector>
#include <map>
#include <algorithm> // min, max

using namespace std;

// global variables
static int index;
static map<int, int> areas;

void CheckArea(int x, int y, int m, int n, int color, vector<vector<int>>& pic)
{
    int val = pic[y][x];
    if(val == 0 || val != color)
        return;
    //
    ++areas[index];
    // set checked
    pic[y][x] = 0;
    // Recursive
    CheckArea(x, min(max(0, y-1), m-1), m, n, color, pic); // U
    CheckArea(x, min(max(0, y+1), m-1), m, n, color, pic); // D
    CheckArea(min(max(0, x-1), n-1), y, m, n, color, pic); // L
    CheckArea(min(max(0, x+1), n-1), y, m, n, color, pic); // R
}

vector<int> solution(int m, int n, vector<vector<int>> picture)
{
    // initialize global variables
    index = 0;
    areas.clear();
    //
    int number_of_area = 0;
    int max_size_of_one_area = 0;
    //
    int color = 0;
    for(int y = 0; y < m; ++y)
    {
        for(int x = 0; x < n; ++x)
        {
            color = picture[y][x];
            if(color != 0)
            {
                ++index;
                CheckArea(x, y, m, n, color, picture);
            }
        }
    }
    //
    number_of_area = areas.size();
    //
    auto iter = areas.begin(), end = areas.end();
    for(; iter != end; ++iter)
    {
        if(iter->second > max_size_of_one_area)
            max_size_of_one_area = iter->second;
    }
    //
    vector<int> answer(2);
    answer[0] = number_of_area;
    answer[1] = max_size_of_one_area;
    return answer;
}

# recursive

# min(max(0, value), arrSize-1)

[ 수식 최대화 ] : < LV2 / 4181명 >

#include <string>
#include <vector>
#include <cmath> // abs
#include <algorithm> // next_permutation

using namespace std;

vector<string> CutString(string s)
{
    vector<string> res;
    //
    int i = 0;
    while(true)
    {
        // end
        if(i == s.size())
        {
            res.push_back(s);
            break;
        }
        //
        if('0' <= s[i] && s[i] <= '9')
        {
            ++i;
            continue;
        }
        else
        {
            // add number
            res.push_back(s.substr(0, i));
            s = s.substr(i, s.size());
            // add operator
            res.push_back(s.substr(0, 1));
            s = s.substr(1, s.size());
            //
            i = 0;
        }
    }
    //
    return res;
}

long long Operation(string a, string b, string op)
{
    long long result = 0;
    //
    long long la = stoll(a);
    long long lb = stoll(b);
    //
    switch(op[0])
    {
        case '+':
            result = la + lb;
            break;
        case '-':
            result = la - lb;
            break;
        case '*':
            result = la * lb;
            break;
    }
    //
    return result;
}

long long solution(string expression)
{
    long long answer = 0;
    //
    string s = expression;
    vector<long long> res{};
    vector<string> expCut{};
    vector<string> v{};
    vector<string> ops = {"+", "-", "*"};
    vector<int> order = {0, 1, 2};
    //
    expCut = CutString(s);
    //
    do
    {
        v.clear();
        v = expCut;
        long long val = 0;
        //
        for(int j = 0; j < ops.size(); ++j)
        {
            auto pos = v.begin();
            for(; pos != v.end(); ++pos)
            {
                if(*pos == ops[order[j]])
                {
                    val = Operation(*(pos-1), *(pos+1), *pos);
                    --pos;
                    v.erase(pos, pos + 3);
                    v.insert(pos, to_string(val));
                }
            }
        }
        //
        val = abs(stoll(v[0]));
        res.push_back(val);

    } while(next_permutation(order.begin(), order.end()));
    //
    long long max = 0;
    for(int i = 0; i < res.size(); ++i)
        if(res[i] > max)
            max = res[i];
    //
    answer = max;
    return answer;
}

# string to long long : stoll(string)

# next_permutation

[ 튜플 ] : < LV2 / 6401명 >

#include <string>
#include <vector>
#include <map>
#include <algorithm> // remove

#define pii pair<int,int>

using namespace std;

bool cmp(const pii& a, const pii& b)
{
    if(a.second == b.second)
        return a.first > b.first;
    //
    return a.second > b.second;
}

vector<int> solution(string s)
{
    vector<int> answer;
    // erase '{', '}'
    s.erase(remove(s.begin(), s.end(), '{'), s.end());
    s.erase(remove(s.begin(), s.end(), '}'), s.end());
    // parse data split by ',' & add to map<int, int>
    map<int, int> m;
    int pos = 0;
    string temp;
    while(pos != string::npos)
    {
        pos = s.find(',');
        temp = s.substr(0, pos);
        s = s.substr(pos+1, s.size());
        ++m[stoi(temp)];
    }
    // sort map by value, descending order
    // typedef pii : pair<int, int>
    vector<pii> vec(m.begin(), m.end());
    sort(vec.begin(), vec.end(), cmp);
    /* ver. lamda
    sort(vec.begin(), vec.end(),
         [](pii a, pii b) { return a.second > b.second; });
    */
    for(auto v : vec)
        answer.push_back(v.first);
    //
    return answer;
}

# remove char in string : s.erase(remove(s.begin(), s.end(), ch), s.end()) // algorithm

# parse string : string to int, stoi(str)

# sort map by value(define, cmp, lamda) : vector<pair<T, T>>

Programmers - 문자열 압축, 타겟 넘버, 오픈 채팅방

HI2 — Tue, 15 Jun 2021 14:56:38 +0900

[ 문자열 압축 ] : < LV2 / 11968명 >

#include <string>
#include <vector>
#include <iostream>

using namespace std;

int Compress(string s, int unit)
{
    vector<string> v;
    string res = "";
    int i = 0, count = 1;
    //
    while(true)
    {
        v.push_back(s.substr(i, unit));
        i += unit;
        if(i >= s.size())
            break;
    }
    //
    for(int j = 0; j < v.size(); ++j)
    {
        if(j == v.size()-1)
        {
            if(v[j-1] == v[j])
                res += to_string(count) + v[j];
            else
                res += v[j];
            //
            break;
        }
        //
        if(v[j] == v[j+1])
            ++count;
        else
        {
            if(count > 1)
                res += to_string(count) + v[j];
            else
                res += v[j];
            //
            count = 1;
        }
    }
    //
    return res.size();
}

int solution(string s)
{
    int answer = 0; // min length
    //
    int length = s.size();
    int maxUnit = length / 2;
    int compLength = length;
    //
    for(int i = 1; i <= maxUnit; ++i)
    {
        compLength = Compress(s, i);
        if(compLength < length)
            length = compLength;
    }
    answer = length;
    //
    return answer;
}

[ 타겟 넘버 ] : < LV2 / 18093명 >

#include <string>
#include <vector>
#include <deque>
#include <cmath>

using namespace std;

int solution(vector<int> numbers, int target)
{
    int answer = 0;
    int count = numbers.size();
    // target을 구할 수 없는 경우 예외처리
    int max, min = 0;
    for(int i = 0; i < count; ++i)
    {
        max += numbers[i];
        min -= numbers[i];
    }
    if(target > max || target < min)
        return 0;
    else if(target == max || target == min)
        return 1;
    // 모든 경우의 수 계산
    deque<int> dq;
    dq.push_back(0);
    for(int i = 0; i < count; ++i)
    {
        for(int j = 0; j < pow(2, i); ++j)
        {
            int temp = dq.front();
            dq.pop_front();
            //
            dq.push_back(temp + numbers[i]);
            dq.push_back(temp - numbers[i]);
        }
    }
    // 원소 갯수는 2의 배수이고, [대칭구조]이므로
    // (size / 2) 까지만 탐색하고, -target인 경우도 포함시킨다.
    for(int i = 0; i < dq.size() / 2; ++i)
    {
        if(dq[i] == target || dq[i] == -target)
            ++answer;
    }
    //
    return answer;
}

# deque, pop_front()

[ 오픈 채팅방 ] : < LV2 / 10163명 >

#include <string>
#include <vector>
#include <map>

using namespace std;

vector<string> SplitSpace(string s)
{
    vector<string> result;
    //
    string space = " ";
    int pos = 0;
    while (pos != string::npos)
    {
        pos = s.find(space);
        result.push_back(s.substr(0, pos));
        s.erase(0, pos + space.length());
    }
    //
    return result;
}

vector<string> solution(vector<string> record)
{
    vector<string> answer;
    //
    map<string, string> mID; // key : id , value : name
    //
    vector<string> msg;
    for(int i = 0; i < record.size(); ++i)
    {
        msg.clear();
        msg = SplitSpace(record[i]);
        if(msg.size() > 2)
            mID[msg[1]] = msg[2];
    }
    //
    map<string, string> mAction;
    mAction["Enter"] = "들어왔습니다.";
    mAction["Leave"] = "나갔습니다.";
    //
    for(int i = 0; i < record.size(); ++i)
    {
        msg.clear();
        msg = SplitSpace(record[i]);
        if(msg[0] == "Enter" || msg[0] == "Leave")
        {
            string temp = mID[msg[1]] + "님이 " + mAction[msg[0]];
            answer.push_back(temp);
        }
    }

    return answer;
}

# 공백제거 : substr(pos, space(" ")), string::npos

# map

Programmers - 기능 개발, 짝지어 제거하기, 멀쩡한 사각형

HI2 — Wed, 9 Jun 2021 17:55:44 +0900

[ 기능 개발 ] : < LV2 / 22829명 >

#include <string>
#include <vector>

using namespace std;

vector<int> solution(vector<int> progresses, vector<int> speeds)
{
    vector<int> answer;
    //
    int totalRelease = progresses.size();
    int todayRelease = 0;
    int priority = 0;
    while(priority < totalRelease)
    {
        todayRelease = 0;
        // daily work
        for(int i = priority; i < progresses.size(); ++i)
            progresses[i] += speeds[i];
        // check release
        for(int i = priority; i < progresses.size(); ++i)
        {
            if(progresses[i] >= 100)
            {
                ++todayRelease;
                ++priority;
            }
            else
                break;
        }
        //
        if(todayRelease != 0)
            answer.push_back(todayRelease);
    }
    //
    return answer;
}

[ 짝지어 제거하기 ] : < LV2 / 5325명 >

#include <iostream>
#include <string>
#include <stack>

using namespace std;

int solution(string s)
{
    stack<char> res;
    // 
    if( (s.size() < 2) || (s.size() % 2 == 1) )
        return 0;
    //
    for(int i = 0; i < s.size(); ++i)
    {
        char c = s[i];
        //
        if(res.empty())
            res.push(c);
        else
        {
            if(res.top() == c)
                res.pop();
            else
                res.push(c);
        }
    }
    //
    return res.empty();
}

# STL::stack
# top 실행 전 empty 체크(Segmentation Fault)

[ 멀쩡한 사각형 ] : < LV2 / 8014 명 >

using namespace std;

long long GetGCD(long long a, long long b)
{
    long long mod = 0;
    //
    while(b != 0)
    {
        mod = a % b;
        a = b;
        b = mod;
    }
    //
    return a;
}

long long solution(int w,int h)
{
    long long answer = (long long)w * (long long)h;
    // GetGCD ( 유클리드 호제법 )
    long long gcd = GetGCD(w, h);
    // logic
    answer -= (w + h - gcd);
    //
    return answer;
}

# 최대공약수, gcd, 유클리드 호제법

# logic : (1 + (w' - 1) + (h' - 1)) * gcd => w + h - gcd

Programmers - 더 맵게, 단체사진 찍기, 124 나라의 숫자

HI2 — Sun, 6 Jun 2021 17:37:32 +0900

[ 더 맵게 ] : < LV2 / 14814명 >

#include <string>
#include <vector>
#include <queue>

using namespace std;

int solution(vector<int> scoville, int K)
{
    int answer = 0;
    // 우선순위 큐 생성(오름차순)
    priority_queue<int, vector<int>, greater<int>> pq;
    //
    int count = scoville.size();
    for(int i = 0; i < count; ++i)
        pq.push(scoville[i]);
    //
    while(pq.top() < K && pq.size() > 1)
    {
        int newSco = 0;
        newSco += pq.top();
        pq.pop();
        newSco += (pq.top() * 2);
        pq.pop();
        //
        if(newSco < K && pq.size() == 0)
            return -1;
        //
        pq.push(newSco);
        //
        ++answer;
	}
    //
    return answer;
}

# priority_queue ( Heap )

- push( data ) 후 정렬상태 유지 ( O(LogN) )

- top( ) : top에 저장된 data 반환, pop ( ) : top 제거

[ 단체사진 찍기 ] : < LV2 / 1343명 >

#include <string>
#include <vector>
#include <algorithm> // vector.find(), next_permutation()
#include <cmath> // abs()

using namespace std;

bool Check(vector<char> v, int n, vector<string> data)
{
    for(int i = 0; i < n; ++i)
    {
        char c1 = data[i][0];
        char c2 = data[i][2];
        char sign = data[i][3];
        int dist_condition = data[i][4] - '0';
        //
        int i1 = find(v.begin(), v.end(), c1) - v.begin();
        int i2 = find(v.begin(), v.end(), c2) - v.begin();
        int dist_value = abs(i1 - i2) - 1;
        //
        switch(sign)
        {
            case '=':
            {
                if(dist_value != dist_condition)
                    return false;
            }
            break;
            case '>':
            {
                if(dist_value <= dist_condition)
                    return false;
            }
            break;
            case '<':
            {
                if(dist_value >= dist_condition)
                    return false;
            }
            break;
        }
    }
    //
    return true;
}

int solution(int n, vector<string> data)
{
    int answer = 0;
    // Set Array
    vector<char> v = {'A', 'C', 'F', 'J', 'M', 'N', 'R', 'T'};
    // Get Combination & Check Condition
    do
    {
        if(Check(v, n, data) == true)
            ++answer;
    } while(next_permutation(v.begin(), v.end()));
    //
    return answer;
}

# algorithm

1. index 찾기

- vector.find(begin, end, value) - begin

- 반환값이 iterator이므로 begin과 연산

- 범위 내에 value가 없을 시 end 반환

2. next_permutation(begin, end) : 순열 생성

[ 124 나라의 숫자 ] : < LV2 / 12859명 >

#include <string>
#include <vector>
#include <algorithm> // reverse()

using namespace std;

string solution(int n)
{
    string answer = "";
    string s = "";
    while(n > 0)
    {
        int mod = n % 3;
        if(mod == 0)
            s += '4';
        else
            s += to_string(mod);
        //
        --n;
        n /= 3;
    }
    reverse(s.begin(), s.end());
    //
    answer = s;
    return answer;
}

Hackerrank - Poker Nim, XOR Strings, Smart Number

HI2 — Tue, 20 Apr 2021 20:35:59 +0900

[풀이 - Poker Nim] : <Easy / 85.46%>

string pokerNim(int k, vector<int> c)
{
    int sum = 0;
    for(int i = 0; i < c.size(); ++i)
        sum ^= c[i];
    //
    if(sum == 0)
        return "Second";
    else
        return "First";
}

# 기본 NimGame과 동일한 원리

# 'k' 가 결과에 영향을 주지 않는다

[풀이 - XOR Strings] : <Easy / 93.72%>

string strings_xor(string s, string t) {

    string res = "";
    for(int i = 0; i < s.size(); i++) {
        if(s[i] == t[i])
            res += '0';
        else
            res += '1';
    }

    return res;
}

# Debugging / 3줄만 수정

[풀이 - Smart Number] : <Easy / 83.82%>

bool is_smart_number(int num){
    int val = (int) sqrt(num);
    if(val * val == num)
        return true;
    return false;
}

# Debugging / 1줄만 수정