2021 카카오 인턴 코테 문제

5시간을 잡고 실전처럼 진행하였으며 코드의 최적화나 알고리즘은 정확하지 않음.


코딩테스트 연습 - 표 편집 | 프로그래머스 (programmers.co.kr)

 

코딩테스트 연습 - 표 편집

8 2 ["D 2","C","U 3","C","D 4","C","U 2","Z","Z"] "OOOOXOOO" 8 2 ["D 2","C","U 3","C","D 4","C","U 2","Z","Z","U 1","C"] "OOXOXOOO"

programmers.co.kr


3번문제 였으며 3시간 정도 걸렸다.

이상하게 1, 2번이 너무 쉽다 했더니 3번이 복병이었다.

정확도 / 효율성으로 나뉜 문제였으며 정확도는 빠르게 해결하였으나 아무리 해도 효율성이 모두 통과되지 않았다.

문제 자체는 어렵진 않고 그냥 구현문제였으나, 효율성을 해결할 방법이 떠오르지 않았다.

문제 조건을 다시 보니 C와 U가 반복해야하고 C나 Z는 1타임에 해결해야하는거 같았다.

그래서 양방향 linked list를 구현하였더니 풀렸다.

너무 오랜만에 이런 코드를 보니 바로바로 생각나지 않았다.

linked list만 구현하면 다른 전처리 없이 풀릴거같다.

#include <string>
#include <vector>
#include <stdlib.h>

using namespace std;

typedef struct list {
    int num;
    list* prev;
    list* next;
}list;

list* start = NULL;
list* cur = NULL;
list* last_node = NULL;

void push_back_node(int n)
{
    list* temp = (list*)malloc(sizeof(list));
    temp->num = n;
    temp->next = NULL;
    temp->prev = last_node;

    if (start == NULL)
        start = temp;

    if (last_node != NULL)
        last_node->next = temp;

    last_node = temp;
}

void delete_node()
{
    if (cur->prev == NULL)
    {
        cur->next->prev = NULL;
        start = cur->next;
        cur = cur->next;
    }
    else if (cur->next == NULL)
    {
        cur->prev->next = NULL;
        last_node = cur->prev;
        cur = cur->prev;
    }
    else
    {
        cur->prev->next = cur->next;
        cur->next->prev = cur->prev;
        cur = cur->next;
    }
}

void append_node(list* node)
{
    int n = node->num;

    if (n < start->num)
    {
        node->next = start;
        node->prev = NULL;
        start->prev = node;
        start = node;
    }
    else if (n > last_node->num)
    {
        push_back_node(n);
    }
    else
    {
        if (n > cur->num)
        {
            for (list* temp = cur; temp->next != NULL; temp = temp->next)
                if (temp->next->num > n)
                {
                    node->prev = temp;
                    node->next = temp->next;

                    temp->next->prev = node;
                    temp->next = node;
                    break;
                }
        }
        else
        {
            for (list* temp = cur; temp->prev != NULL; temp = temp->prev)
                if (temp->prev->num < n)
                {
                    node->prev = temp->prev;
                    node->next = temp;

                    temp->prev->next = node;
                    temp->prev = node;
                    break;
                }
        }
    }
}

string solution(int n, int k, vector<string> cmd) {
    string answer = "";
    int size = n - 1;
    vector<list*> deleted;
    //vector<int> deleted;

    for (int i = 0; i < n; i++)
    {
        answer += "X";
        push_back_node(i);
        if (i == k)
            cur = last_node;
    }

    int cnt = 0;
    int end_ind = cmd.size() - 1;
    for (int i = cmd.size() - 1; i >= 0; i--)
    {
        char opt = cmd[i][0];
        if (opt == 'C')
        {
            if (cnt == 0)
            {
                end_ind = i;
                break;
            }
            else
                cnt--;
        }
        else if (opt == 'Z')
            cnt++;
    }

    for (int i = 0; i <= end_ind; i++)
    {
        cnt = 0;
        char opt = cmd[i][0];
        if (opt == 'U')
        {
            int num = stoi(cmd[i].substr(2, cmd[i].size() - 2));
            for (int j = 0; j < num; j++)
                cur = cur->prev;
        }
        else if (opt == 'D')
        {
            int num = stoi(cmd[i].substr(2, cmd[i].size() - 2));
            for (int j = 0; j < num; j++)
                cur = cur->next;
        }

        else if (opt == 'C')
        {
            deleted.push_back(cur);
            delete_node();
        }
        else if (opt == 'Z')
        {
            list* recovered = deleted[deleted.size() - 1];
            deleted.pop_back();
            append_node(recovered);
        }
    }

    for (list* temp = start; temp != NULL; temp = temp->next)
        answer[temp->num] = 'O';

    for (list* temp = start->next; temp != NULL; start = temp, temp = start->next)
        free(start);
    free(start);

    return answer;
}

 

2021 카카오 인턴 코테 문제

5시간을 잡고 실전처럼 진행하였으며 코드의 최적화나 알고리즘은 정확하지 않음.


코딩테스트 연습 - 거리두기 확인하기 | 프로그래머스 (programmers.co.kr)

 

코딩테스트 연습 - 거리두기 확인하기

[["POOOP", "OXXOX", "OPXPX", "OOXOX", "POXXP"], ["POOPX", "OXPXP", "PXXXO", "OXXXO", "OOOPP"], ["PXOPX", "OXOXP", "OXPOX", "OXXOP", "PXPOX"], ["OOOXX", "XOOOX", "OOOXX", "OXOOX", "OOOOO"], ["PXPXP", "XPXPX", "PXPXP", "XPXPX", "PXPXP"]] [1, 0, 1, 1, 1]

programmers.co.kr


2번 문제 였으며, 30분 정도 소요되었다.

크게 어려운건 없었으나 처음에 BFS로 풀다가 DFS로 바꿔 풀었다.

무작정 2차원 배열을 확인할때 BFS로 푸는 습관은 버려야겠다.

전형적인 DFS문제 였으며 다만 2차원 배열에서의 DFS를 이용한 완전탐색 문제였다.

#include <string>
#include <vector>

using namespace std;

int N = 5;
vector<vector<string>> map;

int ROTATE_X[] = { -1, 0, 0, 1 };
int ROTATE_Y[] = { 0, -1, 1, 0 };

bool visited[5][5][5] = { false };

bool DFS(int ind, int row, int col, int cnt)
{
    visited[ind][row][col] = true;

    if (cnt != 0)
    {
        if (map[ind][row][col] == 'P')
            return false;
        if (cnt == 2)
            return true;
    }
    for (int i = 0; i < 4; i++)
    {
        int next_row = row + ROTATE_X[i];
        int next_col = col + ROTATE_Y[i];

        if (next_row < 0 || next_col < 0 || next_row >= N || next_col >= N || visited[ind][next_row][next_col])
            continue;

        if (!DFS(ind, next_row, next_col, cnt + 1))
            return false;
    }

    return true;
}

bool IS_OK(int ind)
{
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            if (map[ind][i][j] == 'X')
                visited[ind][i][j] = true;

    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            if (map[ind][i][j] == 'P')
            {
                if (!DFS(ind, i, j, 0))
                    return false;
            }
    return true;
}

vector<int> solution(vector<vector<string>> places) {
    vector<int> answer;
    map = places;

    for (int i = 0; i < N; i++)
    {
        if (IS_OK(i))
            answer.push_back(1);
        else
            answer.push_back(0);
    }

    return answer;
}

2021 카카오 인턴 코테 문제

5시간을 잡고 실전처럼 진행하였으며 코드의 최적화나 알고리즘은 정확하지 않음.


코딩테스트 연습 - 숫자 문자열과 영단어 | 프로그래머스 (programmers.co.kr)

 

코딩테스트 연습 - 숫자 문자열과 영단어

네오와 프로도가 숫자놀이를 하고 있습니다. 네오가 프로도에게 숫자를 건넬 때 일부 자릿수를 영단어로 바꾼 카드를 건네주면 프로도는 원래 숫자를 찾는 게임입니다. 다음은 숫자의 일부 자

programmers.co.kr


1번 문제이며, 약 20분 소요되었다.

크게 어려운 것은 없으며 map을 이용하여 풀었다. 파이썬의 dict이 더 편할지 모르겠다.

다만 string 처리가 귀찮았다.

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

using namespace std;

int solution(string s) {
    int answer = 0;
    string num = "";
    string temp = "";
    map<string, string> m;
    m["zero"] = "0";
    m["one"] = "1";
    m["two"] = "2";
    m["three"] = "3";
    m["four"] = "4";
    m["five"] = "5";
    m["six"] = "6";
    m["seven"] = "7";
    m["eight"] = "8";
    m["nine"] = "9";

    for (int i = 0; i < s.size(); i++)
    {
        if (isdigit(s[i]))
            num += s[i];
        else
        {
            temp += s[i];
            if (m[temp]  != "")
            {
                num += m[temp];
                temp = "";
            }
        }
    }

    answer = stoi(num);

    return answer;
}

2020 카카오 인턴 코테 문제

5시간을 잡고 실전처럼 진행하였으며 코드의 최적화나 알고리즘은 정확하지 않음.


코딩테스트 연습 - 경주로 건설 | 프로그래머스 (programmers.co.kr)

 

코딩테스트 연습 - 경주로 건설

[[0,0,0,0,0,0,0,1],[0,0,0,0,0,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,1,0,0,0],[0,0,0,1,0,0,0,1],[0,0,1,0,0,0,1,0],[0,1,0,0,0,1,0,0],[1,0,0,0,0,0,0,0]] 3800 [[0,0,1,0],[0,0,0,0],[0,1,0,1],[1,0,0,0]] 2100 [[0,0,0,0,0,0],[0,1,1,1,1,0],[0,0,1,0,0,0],[1,0,0,1,0,1],[

programmers.co.kr


4번문제였으며, 남은 1시간 30분 모두 빡빡하게 썻다.

bfs로 풀었다. 다만 여기선 전의 방향이 추가로 필요하였다.

#include <iostream>

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

using namespace std;

typedef struct pos {
    int x;
    int y;
    int cost;
    int dir;
}pos;

int ROTATE_X[] = { -1, 0, 1, 0 };
int ROTATE_Y[] = { 0, 1, 0, -1 };

int solution(vector<vector<int>> board) {
    int answer = 987654321;
    int N = board.size();
    queue<pos> q;
    vector<vector<vector<int>>> map(4, vector<vector<int>>(N, vector<int>(N, 987654321)));
    q.push({ 0, 0, 0, 1 });
    q.push({ 0, 0, 0, 2 });
    map[1][0][0] = 0;
    map[2][0][0] = 0;
    pos cur;
    

    while (!q.empty())
    {
        cur = q.front();
        q.pop();

        if (cur.x == N - 1 && cur.y == N - 1)
        {
            answer = min(answer, cur.cost);
            continue;
        }

        for (int i = 0; i < 4; i++)
        {
            int next_row = cur.x + ROTATE_Y[i];
            int next_col = cur.y + ROTATE_X[i];

            if (next_row < 0 || next_col < 0 || next_row >= N || next_col >= N || board[next_row][next_col] == 1)
                continue;

            int cur_cost;
            if (cur.dir == i)
                cur_cost = cur.cost + 100;
            else
                cur_cost = cur.cost + 600;

            if (map[i][next_row][next_col] >= cur_cost)
            {
                map[i][next_row][next_col] = cur_cost;
                q.push({ next_row, next_col, cur_cost, i });
            }

        }
    }
    return answer;
}

2020 카카오 인턴 코테 문제

5시간을 잡고 실전처럼 진행하였으며 코드의 최적화나 알고리즘은 정확하지 않음.


코딩테스트 연습 - 보석 쇼핑 | 프로그래머스 (programmers.co.kr)

 

코딩테스트 연습 - 보석 쇼핑

["DIA", "RUBY", "RUBY", "DIA", "DIA", "EMERALD", "SAPPHIRE", "DIA"] [3, 7]

programmers.co.kr


3번 문제였으며 효율성과 정확도가 나뉜 문제이다. 약 두시간정도 걸렸다.

투포인터 문제였으며, 일반적인 투포인터 문제이다.

투포인터로 푸는건 알았으나 바로 접근방법이 떠오르지 않아 시간이 많이 걸렸다.

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

using namespace std;

vector<int> solution(vector<string> gems) {
    vector<int> answer(2, 0);
    map<string, int> gem;

    for (auto& i : gems)
        gem[i] = 0;

    int start = 0, end = 0;
    int gem_size = gem.size();
    int gem_cnt = 0;
    int min_len = 100001;
    while (1)
    {
        if (gem_cnt == gem_size)
        {
            if (end - start < min_len)
            {
                answer[0] = start + 1;
                answer[1] = end;
                min_len = end - start;
            }

            if (gem[gems[start]] <= 1)
                gem_cnt--;
            gem[gems[start]]--;
            start++;
        }
        else
        {
            if (end == gems.size())
                break;

            if (gem[gems[end]] == 0)
                gem_cnt++;
            gem[gems[end]]++;
            end++;
        }
    }

    return answer;
}

+ Recent posts