공부흔적

문제 링크

풀이 )

  세로를 x축, 가로를 y축으로 사용했다.

  먼저 입력된 숫자의 좌표를 cx, cy에 넣었다.

• 1, 4, 7(numbers[i]%3 == 1)인 경우 'L'을 출력하고 왼손을 현재 숫자의 좌표로 옮긴다.
• 3, 6, 9(numbers[i] > 0 && numbers[i]%3 == 0)인 경우 'R'을 출력하고 오른손을 현재 숫자의 좌표로 옮긴다.
• 나머지에 대해서는 현재 양 손의 위치와 숫자의 거리를 측정하여
  • 더 가까운 손이 있는 경우, 더 가까운 손으로 입력을 하고
  • 두 손의 거리가 같은 경우, 왼손잡이는 왼손으로, 오른손잡이는 오른손으로 입력한다.

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

using namespace std;

int lx = 3, ly = 0, rx = 3, ry = 2;
int cx, cy, dl, dr;
string answer;

void rHand(void){
    answer += 'R';
    rx = cx; ry = cy;
}

void lHand(void){
    answer += 'L';
    lx = cx;
    ly = cy;
}

string solution(vector<int> numbers, string hand) {
    int len = numbers.size();
    for(int i = 0; i < len; ++i){
        if(numbers[i] == 0){
            cx = 3;
            cy = 1;
        }
        else{
            cx = (numbers[i]-1)/3;
            cy = (numbers[i]-1)%3;
        }
        
        if(numbers[i]%3 == 1)
            lHand();
        else if(numbers[i] && numbers[i]%3 == 0)
            rHand();
        else{
            dl = abs(cx-lx)+abs(cy-ly);
            dr = abs(cx-rx)+abs(cy-ry);
            if(dl < dr)
                lHand();
            else if(dl > dr)
                rHand();
            else{
                if(hand == "left")
                    lHand();
                else
                    rHand();
            }
        }
    }
    return answer;
}

주의 )

  키패드에서 0에 대한 처리

문제 링크

풀이 )

  각 행에 대해서 주어진 값에 대해서 비트연산 OR를 한 후 2진법으로 바꿔

  '1'자리에 '#', '0'자리에 ' '을 각각 넣어준다.

#include <string>
#include <vector>

using namespace std;

vector<string> solution(int n, vector<int> arr1, vector<int> arr2) {
    vector<string> answer;
    for(int i = 0; i < n; ++i){
        int tmp = arr1[i]|arr2[i];
        string str;
        for(int i = 0; i < n; ++i){
            str = (tmp%2?'#':' ') + str;
            tmp/=2;
        }
        answer.push_back(str);
    }
    return answer;
}

문제 링크

풀이1 )

  세 명의 규칙을 찾아서 1번부터 answers.size()까지 각 세명의 답(vc[][])을 채워넣는 배열을 만들고 이후 채점을 한다.

  세 명의 규칙은 다음과 같다.

1. 1 2 3 4 5 반복
2. 홀수번째는 2, 짝수번째는 1 3 4 5 반복
3. 3 1 2 4 5가 각각 2번씩 반복

  세 명의 점수(col) 중 가장 큰 점수(*max_element())를 찾고 가장 큰 점수와 비교하여 같으면 정답 배열에 집어넣는다.

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

using namespace std;

vector<int> solution(vector<int> answers) {
    vector<int> answer;
    vector<int> vc[3];
    vector<int> input(3);
    vector<int> col(3);
    int len = answers.size();
    
    for(int i = 0; i < len; ++i){
        input[0] = i%5+1;
        if(i%2)
            input[1] = i/2%4 + (i/2%4 ? 2 : 1);
        else
            input[1] = 2;
        switch(i/2%5){
            case 0:
                input[2] = 3;
                break;
            case 1:
                input[2] = 1;
                break;
            case 2:
                input[2] = 2;
                break;
            case 3:
                input[2] = 4;
                break;
            case 4:
                input[2] = 5;
                break;
        }
        
        for(int j = 0; j < 3; ++j)
            vc[j].push_back(input[j]);
    }
    
    for(int i = 0; i < len; ++i){
        for(int j = 0; j < 3; ++j){
            if(vc[j][i] == answers[i])
                col[j]++;
        }
    }

    int top = *max_element(col.begin(), col.end());
    for(int i = 0; i < 3; ++i)
        if(col[i] == top)
            answer.push_back(i+1);
    return answer;
}

풀이2)

  정답코드에서 더 구현에 쉬운 방법을 보고 다시 구현해봤다.

  세 명의 정답을 보면 특정 주기로 답이 반복되므로 반복되는 부분을 배열로 저장한 후 %연산자를 활용한다.

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

using namespace std;


vector<int> solution(vector<int> answers) {
    vector<int> answer;
    vector<int> one = {1, 2, 3, 4, 5};
    vector<int> two = {2, 1, 2, 3, 2, 4, 2, 5};
    vector<int> thr = {3, 3, 1, 1, 2, 2, 4, 4, 5, 5};

    vector<int> col(3);
    int len = answers.size();
    for(int i = 0; i < len; ++i) {
        if(answers[i] == one[i%one.size()])
            col[0]++;
        if(answers[i] == two[i%two.size()])
            col[1]++;
        if(answers[i] == thr[i%thr.size()])
            col[2]++;
    }
    
    int top = *max_element(col.begin(), col.end());
    for(int i = 0; i < 3; ++i) 
        if(col[i] == top)
            answer.push_back(i+1);
    return answer;
}

문제 링크

풀이 ) 

  문자열을 앞에서부터 한 문자씩 읽는다.

  숫자 3개를 저장할 배열을 만들고 숫자가 나올때마다 인덱스를 늘려 각 배열에 넣는다.

  1이 오는 경우 뒤에 0이 와서 10이 되는 경우가 있기 때문에 뒤에 0이 오는지 확인하고 0이 오면 배열에 10을 저장하고 문자열에서 한 문자만큼 더 이동시킨다.

  S D T에 대해서, S가 오는 경우 건너뛰고, D가 오는 경우 제곱, T가 오는 경우 세제곱해준다.

  #이 오는 경우 해당 숫자에 -1을 곱하고, 마지막으로 *이 오는 경우 가장 앞에 오는 경우가 아니면 앞 숫자까지 2를 곱해준다.

  마지막으로 배열에 저장된 3개의 값을 더해주어 답을 구한다.

#include <string>
#include <iostream>

using namespace std;

int solution(string dartResult) {
    int answer = 0;
    int score[3] = {0, };
    int len = dartResult.size();
    int idx_score = -1;
    
    for(int i = 0; i < len; ++i){
        if(dartResult[i] == '1'){
            idx_score++;
            if(dartResult[i+1] == '0'){
                score[idx_score] = 10;
                i++;
            }
            else{
                score[idx_score] = 1;
            }
        }
        else if('0' <= dartResult[i] && dartResult[i] <= '9'){
            idx_score++;
            score[idx_score] = dartResult[i]-'0';
        }
        else if(dartResult[i] == 'S')
            continue;
        else if(dartResult[i] == 'D')
            score[idx_score] *= score[idx_score];
        else if(dartResult[i] == 'T')
            score[idx_score] *= score[idx_score] * score[idx_score];
        else if(dartResult[i] == '#')
            score[idx_score] *= -1;
        else{
            if(idx_score > 0){
                score[idx_score-1] *= 2;
            }
            score[idx_score] *= 2;
        }
    }
    answer = score[0] + score[1] + score[2];
    return answer;
}

주의점 )

• 10이 나오는 경우

문제 링크

풀이 )

  처음 stages 배열을 한바퀴 돌아 각 스테이지에서 실패한 인원을 저장한 배열 fail에 저장을 한다.

  이후 각 스테이지에서의 실패율을 계산한다.

  이 때 현재 스테이지에 올라온 인원을 저장하는 변수 clear에 저장하고 실패한 인원 수 만큼 매번 빼준다.

  이후 실패율을 내림차순으로 정렬하여 실패율이 높은 순서대로 스테이지를 answer 벡터에 집어넣는다.

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

using namespace std;

vector<int> solution(int N, vector<int> stages) {
    vector<int> answer;
    vector<int> fail(N, 0);
    vector<pair<int, double>> rate;
    int clear = stages.size();
    
    for(vector<int>::iterator it = stages.begin(); it != stages.end(); ++it){
        if(*it == N+1)
            continue;
        fail[(*it)-1]++;
    }   // 각 스테이지 실패 인원 수
    
    int stage = 1;
    for(vector<int>::iterator it = fail.begin(); it != fail.end(); ++it){
        rate.push_back(make_pair(stage++, clear == 0 ? 0 : ((double)*it)/clear));
        clear -= *it;
    }   // 각 스테이지 실패율
    
    sort(rate.begin(), rate.end(), [](auto &left, auto &right){
        if(left.second == right.second)
            return left.first < right.first;
        return left.second > right.second;
    }); // 실패율 정렬
    
    for(vector<pair<int, double>>::iterator it = rate.begin(); it != rate.end(); ++it)
        answer.push_back((*it).first);
    return answer;
}

주의점 )

• 클리어한 인원 수가 0일 때, 0으로 나눌 수 없기 때문에 실패율은 0
• 실패율을 정렬할 때 실패율이 같은 경우 스테이지 정렬

문제 링크

풀이 )

• 바구니(basket)가 비어있는 경우 선택된 인형(picked)을 그대로 넣고
• 바구니가 비어있지 않은 경우 basket에서 가장 위에 있는 인형(basket.back())과 인형을 비교해서
  • 같은 경우 선택된 인형과 가장 위의 인형을 제거 하기 위해서 basket.pop_back()을 하고 답에 2를 더하고
  • 다른 경우 선택된 인형을 바구니에 넣는다. basket.push_back(picked)

#include <string>
#include <vector>

using namespace std;

int solution(vector<vector<int>> board, vector<int> moves) {
    int answer = 0;
    int len_moves = moves.size();
    int len_board = board.size();
    int picked;
    vector<int> basket;

    for(int i = 0; i < len_moves; ++i){
        int crain = moves[i]-1;
        for(int j = 0; j < len_board; ++j){
            if(picked = board[j][crain]){
                board[j][crain] = 0;
                if(basket.empty()){
                    basket.push_back(picked);
                    break;
                }
                if(basket.back() == picked){
                    basket.pop_back();
                    answer += 2;
                }
                else
                    basket.push_back(picked);
                break;
            }
        }
    }
    return answer;
}

주의점 )

• 인형을 뽑은 이후 board에서의 값을 0으로 변경
• 인형을 고른 후 작업을 마친 다음 break