๋ณธ๋ฌธ ๋ฐ”๋กœ๊ฐ€๊ธฐ
๊ฐœ๋ฐœ/์•Œ๊ณ ๋ฆฌ์ฆ˜

[์•Œ๊ณ ๋ฆฌ์ฆ˜ ๋ฌธ์ œ ํ•ด์„ค] ํŒŒํŠธ1~3

by - ์˜คํŠธ - 2021. 1. 22.

programmers.co.kr/learn/courses/18

 

์•Œ๊ณ ๋ฆฌ์ฆ˜ ๋ฌธ์ œ ํ•ด์„ค

ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค์˜ ๋ชจ์˜ํ…Œ์ŠคํŠธ๋Š” ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค์˜ ์‹œ์Šคํ…œ์— ์ต์ˆ™ํ•ด์ง€๊ธฐ ์œ„ํ•œ ํ…Œ์ŠคํŠธ์ด๋ฉฐ, ๋ฌธ์ œ ์ž์ฒด๋Š” 2018 1ST KAKAO BLIND RECRUITMENT์™€ ์ „ํ˜€ ๊ด€๊ณ„์—†์Šต๋‹ˆ๋‹ค. ๋‹ค๋งŒ ๋ชจ์˜ํ…Œ์ŠคํŠธ์˜ ํ’€์ด์— ๋Œ€ํ•œ ์š”์ฒญ์ด ์žˆ์–ด

programmers.co.kr

* ๊ฐ•์˜ ๋งํฌ๋Š” ์œ„์— ์žˆ์Šต๋‹ˆ๋‹ค

 

ํŒŒํŠธ1. ์ž๋ฆฟ์ˆ˜ ๋”ํ•˜๊ธฐ ๋ฌธ์ œ 

๊ฐ ์ž๋ฆฟ์ˆ˜์˜ ํ•ฉ ๊ตฌํ•˜๋Š” ๋ฐฉ๋ฒ• : 1์˜ ์ž๋ฆฌ๋ฅผ ๊ตฌํ•จ -> 1์˜ ์ž๋ฆฌ๋ฅผ ์ œ๊ฑฐ(๋‚˜๋ˆ„๊ธฐ 10)ํ•˜๊ณ  ๋‚˜๋จธ์ง€ ์ˆซ์ž๋“ค์„ ์˜ค๋ฅธ์ชฝ์œผ๋กœ ํ•œ ์นธ์”ฉ ์ด๋™ -> ์ด๋™์‹œํ‚ฌ ์ˆซ์ž๊ฐ€ ์—†์„ ๋•Œ ๊นŒ์ง€ ๋ฐ˜๋ณต

ex) 123 : 123 % 10 = 3, 123 / 10 = 12 ->  12 % 10 = 2, 12 / 10 = 1 -> 1 % 0 = 1, 1 / 10 = 0

#include <iostream>

using namespace std;
int solution(int n)
{
    int sum = 0;
    while(n>0)
    {
        sum += n % 10;
        n /= 10;
    }
    return sum;
}

*์ž…๋ ฅ๋ฐ›์€ n์ด 0๋ณด๋‹ค ํฐ ๋™์•ˆ ๊ฐ ์ž๋ฆฟ์ˆ˜์˜ ํ•ฉ ๊ตฌํ•˜๋Š” ๋ฐฉ๋ฒ•(sum += n %10; n /= 10;)์„ ์ด์šฉํ•ด ์ฝ”๋“œ๋ฅผ ๊ตฌํ˜„


ํŒŒํŠธ2. ์ˆœ์—ด ๊ฒ€์‚ฌ ๋ฌธ์ œ

์ค‘๋ณต ์—†๋Š” ๋ฐฐ์—ด

1. ๋ฒ”์œ„๋ฅผ ๋ฒ—์–ด๋‚˜๋Š” ๊ฐ’์ด ์žˆ๋Š”์ง€ ํ™•์ธํ•ด๋ณด๊ธฐ

2. ๋ฒ”์œ„๋ฅผ ๋ฒ—์–ด๋‚˜์ง€ ์•Š๋Š” ๊ฐ’์ด ๋ช‡ ๋ฒˆ ๋“ฑ์žฅํ•˜๋Š”์ง€ ์ฒดํฌํ•˜๊ธฐ

1) ๋ฐฐ์—ด ์ด์šฉ

#include <vector>
#include <iostream>
using namespace std;

int chk[100001] = {0};
bool solution(vector<int> arr)
{
    int n = arr.size();
    for(int i = 0; i < n; ++i){
        if(arr[i] < 1 || arr[i] > n)
            return false;
        chk[arr[i]]++;
    }
    for(int i = 1; i <= n; ++i)
        if(chk[i] != 1)
            return false;
    return true;
}

*์ž…๋ ฅ๋ฐ›์€ ๋ฐฐ์—ด์˜ ๊ธธ์ด๋ฅผ n์— ์ €์žฅ

์ฒซ๋ฒˆ์งธ for๋ฌธ : ๋ฐฐ์—ด์˜ ๊ฐ ์›์†Œ๋ฅผ ์ˆœํšŒํ•˜๋ฉด์„œ ๋งŒ์•ฝ ๋ฒ”์œ„๋ฅผ ๋ฒ—์–ด๋‚˜๋Š” ์ˆซ์ž(n๋ณด๋‹ค ํฌ๊ฑฐ๋‚˜, 1๋ณด๋‹ค ์ž‘๊ฑฐ๋‚˜)๊ฐ€ ์žˆ๋‹ค๋ฉด false ๋ฆฌํ„ด

chk[arr[i]]++; : array์˜ i๋ฒˆ์งธ ์›์†Œ๊ฐ€ chk์˜ ์ธ๋ฑ์Šค๋กœ ๋“ค์–ด๊ฐ€์„œ ํ•ด๋‹น ๊ฐ’์ด ๋ช‡ ๋ฒˆ ๋‚˜ํƒ€๋‚ฌ๋Š”์ง€ ์ฒดํฌ

๋‘๋ฒˆ์งธ for๋ฌธ : chk ๋ฐฐ์—ด์˜ ๊ฐ’์ด ๋ชจ๋‘ 1์ด๋ผ๋ฉด(๋ชจ๋“  ๊ฐ’์ด ๊ณ ๋ฅด๊ฒŒ ๋“ค์–ด๊ฐ”๋‹ค๋ฉด) true ๋ฆฌํ„ด

 

2) ์ •๋ ฌ ์ด์šฉ

#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

bool solution(vector<int> arr)
{
    sort(arr.begin(), arr.end());
    for(int i = 0; i < arr.size(); ++i)
        if(arr[i] != i + 1)
            return false;
    
    return true;
}

*์ •๋ ฌ์„ ์ด์šฉํ•˜๊ธฐ ์œ„ํ•ด์„œ๋Š” #include <algorithm> ํ—ค๋” ํŒŒ์ผ ํ•„์š”

์ž…๋ ฅ๋ฐ›์€ ๋ฐฐ์—ด์„ ์ •๋ ฌํ•œ ํ›„์— for๋ฌธ์„ ์ด์šฉํ•˜์—ฌ chk ๋ฐฐ์—ด์˜ ๊ฐ’์ด ๋ชจ๋‘ 1์ด๋ผ๋ฉด(๋ชจ๋“  ๊ฐ’์ด ๊ณ ๋ฅด๊ฒŒ ๋“ค์–ด๊ฐ”๋‹ค๋ฉด) true ๋ฆฌํ„ด


ํŒŒํŠธ3. ๋‚˜๋จธ์ง€ ํ•œ ์  ๋ฌธ์ œ

์ง์‚ฌ๊ฐํ˜• ์ขŒํ‘œ : (x1, y1), (x2, y1), (x1, y2), (x2, y2) -> x1, x2, y1, y2 ๊ฐœ์ˆ˜๊ฐ€ ๊ฐ๊ฐ 2๊ฐœ์”ฉ

1) ์กฐ๊ฑด๋ฌธ

2) ํ•ด์‹œ

3) xor ์ด์šฉ(๊ฐ„๋‹จํ•˜๊ฒŒ ๊ตฌํ˜„ ๊ฐ€๋Šฅ)

A xor A  = 0

(A xor A) xor B = B

#include <iostream>
#include <vector>
using namespace std;

vector<int> solution(vector<vector<int>> v) { // ๊ธฐ๋ณธ์ ์ธ 2์ฐจ์› ๋ฒกํ„ฐ์˜ ์„ ์–ธ ๋ฐฉ์‹
    vector<int> ans = {0,0}; // ์ดˆ๊ธฐํ™”
    
    for(int i = 0; i < 3; ++i){
        ans[0] ^= v[i][0];
        ans[1] ^= v[i][1];
    }
    return ans;
}

*๋จผ์ € 3๊ฐœ์˜ ์ ์„ ๋ชจ๋‘ ์ž…๋ ฅ์„ ๋ฐ›์Œ

for๋ฌธ์„ ์ด์šฉํ•ด 3๋ฒˆ ๋ฐ˜๋ณต(3๊ฐœ์˜ ์ )

ans[0] : x์ขŒํ‘œ, ans[1] : y์ขŒํ‘œ

v[0][0]๋ถ€ํ„ฐ v[3][0]๊นŒ์ง€ 3๊ฐœ์˜ ์ ์„ xor ์—ฐ์‚ฐ(^)์„ ์‚ฌ์šฉํ•ด์„œ ๋‚˜๋จธ์ง€ ํ•œ์ ์˜ x์ขŒํ‘œ๋ฅผ ๊ตฌํ•จ

v[0][1]๋ถ€ํ„ฐ v[3][1]๊นŒ์ง€ 3๊ฐœ์˜ ์ ์„ xor ์—ฐ์‚ฐ(^)์„ ์‚ฌ์šฉํ•ด์„œ ๋‚˜๋จธ์ง€ ํ•œ์ ์˜ y์ขŒํ‘œ๋ฅผ ๊ตฌํ•จ

 

์กฐ๊ฑด๋ฌธ์„ ์ด์šฉํ•ด์„œ ์ž‘์„ฑํ•˜๋Š” ๊ฒƒ๋ณด๋‹ค xor ์—ฐ์‚ฐ์„ ์ด์šฉํ•˜๋Š” ๊ฒƒ์ด ๋” ์ฝ”๋“œ๊ฐ€ ์งง์•„์ง€๋Š” ๊ฒƒ์„ ์•Œ ์ˆ˜ ์žˆ์—ˆ๋‹ค