프로그래머스 레벨 1

준비운동 겸 자존감 높이는데 훌륭한 레벨 1 문제들

음양 더하기

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

int solution(vector<int> absolutes, vector<bool> signs) {
	int answer = 0;
	int size = absolutes.size();
	int i;

	for (i = 0; i < size; i++) {
		if (signs[i]) answer += absolutes[i];
		else answer -= absolutes[i];
	}
	return answer;
}

약수의 개수와 덧셈

문제

#include <iostream>
#include <vector>
#include <cmath> // sqrt
using namespace std;

int solution(int left, int right) {
	int answer = 0;
	int i;
	for (i = left; i <= right; i++) {
		int root = (int)sqrt(i);
		if (root * root == i) answer -= i;
		else answer += i;
	}
	return answer;
}

내적

문제

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

int solution(vector<int> a, vector<int> b) {
	int answer = 0;
	int n = a.size();
	for (int i = 0; i < n; i++)
		answer += (a[i] * b[i]);
	return answer;
}

두 정수 사이의 합

문제

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

long long solution(int a, int b) {
	long long answer = 0;
	int i;
	if (a < b) for (i = a; i <= b; i++) answer += i;
	else for (i = b; i <= a; i++) answer += i;
	return answer;
}

가운데 글자 가져오기

문제

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

string solution(string s) {
	string answer = "";
	int size = s.size();

	if (size % 2) answer += s[(size - 1) / 2];
	else {
		answer += s[size / 2 - 1];
		answer += s[size / 2];
	}
	return answer;
}

같은 숫자는 싫어

문제

벡터 관련 함수들 (back(), unique()) 연습

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

vector<int> solution(vector<int> arr)
{
	vector<int> answer;
	int i;

	answer.push_back(arr[0]);
	for (i = 1; i < arr.size(); i++) {
		if (arr[i] != answer.back()) answer.push_back(arr[i]);
	}
	return answer;
}

vector<int> solution2(vector<int> arr) {
	arr.erase(unique(arr.begin(), arr.end()), arr.end());

	vector<int> answer = arr;
	return answer;
}

나누어 떨어지는 숫자 배열

문제

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

vector<int> solution(vector<int> arr, int divisor) {
	vector<int> answer;
	int i;

	for (i = 0; i < arr.size(); i++) {
		if (arr[i] % divisor == 0) answer.push_back(arr[i]);
	}

	if (answer.size() == 0) answer.push_back(-1);
	else sort(answer.begin(), answer.end());

	return answer;
}

제일 작은 수 제거하기

문제

벡터에서 원소 없애는 연습 (erase, remove)

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

vector<int> solution(vector<int> arr) {
	vector<int> answer = arr;
	int i, size = arr.size();

	sort(arr.begin(), arr.end(), greater<int>());
	int minval = arr[arr.size() - 1];

	answer.erase(remove(answer.begin(), answer.end(), minval), answer.end());
	if (answer.size() == 0) answer.push_back(-1);
	return answer;
}

짝수와 홀수

문제

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

string solution(int num) {
	return (num % 2) ? "Odd" : "Even";
}

콜라츠 추측

문제

num의 값을 바꿔주기 때문에 else대신 else if로 처리해줘야 함

#include <iostream>
using namespace std;

int solution(int num) {
	int answer = 0;
	while (num != 1) {
		if (num % 2 == 0) num /= 2;
		else if (num % 2 == 1) num = num * 3 + 1;
		answer++;

		if (answer == 500) {
			answer = -1;
			break;
		}
	}
	return answer;
}

평균 구하기

문제

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

double solution(vector<int> arr) {
	double answer = 0;
	int i;
	for (i = 0; i < arr.size(); i++) answer += arr[i];
	return answer / arr.size();
}

하샤드 수

문제

#include <iostream>
using namespace std;

bool solution(int x) {
	int tmp = x;
	int digit = 0;

	while (tmp / 10) {
		digit += tmp % 10;
		tmp /= 10;
	}
	digit += tmp % 10;

	if (x % digit == 0) return true;
	else return false;
}

x만큼 간격이 있는 n개의 숫자

문제

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

vector<long long> solution(int x, int n) {
	vector<long long> answer;
	long long i;
	for (i = 1; i <= n; i++) {
		answer.push_back(x*i);
	}
	return answer;
}

직사각형 별찍기

문제

#include <iostream>
using namespace std;

int main(void) {
	int a, b, i, j;

	cin >> a >> b;

	for (i = 0; i < b; i++) {
		for (j = 0; j < a; j++) cout << '*';
		cout << endl;
	}
	return 0;
}

행렬의 덧셈

문제

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

vector<vector<int>> solution(vector<vector<int>> arr1, vector<vector<int>> arr2) {
	vector<vector<int>> answer;
	int i, j;
	for (i = 0; i < arr1.size(); i++) {
		vector<int> tmp;
		for (j = 0; j < arr1[i].size(); j++) tmp.push_back(arr1[i][j] + arr2[i][j]);
		answer.push_back(tmp);
	}
	return answer;
}

예산

문제

#include <iostream>
#include <string>
#include <vector>
#include <algorithm> // sort
using namespace std;

int solution(vector<int> d, int budget) {
	int answer = 0;
	int i = 0;
	int size = d.size();

	sort(d.begin(), d.end());

	while (budget >= d[i] && i < size) {
		budget -= d[i];
		answer++;
		i++;
	}

	return answer;
}

정수 제곱근 판별

문제

powl이라는 것이 있다

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

long long solution(long long n) {
	long long answer = -1;
	long long i;
	for (i = 0; i <= ((long long)sqrt(n) + 1); i++) {
		if (i * i == n) return (i + 1) * (i + 1);
	}
	return answer;
}

long long solution2(long long n) {
	long long answer = sqrt(n);
	return (powl(answer, 2) == n) ? (powl(answer + 1, 2)) : -1;
}

문자열 내 p와 y의 개수

문제

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

bool solution(string s)
{
	bool answer = true;
	int pcnt = 0, ycnt = 0, i;

	for (i = 0; i < s.size(); i++) {
		if (s[i] == 'p' || s[i] == 'P') pcnt++;
		else if (s[i] == 'y' || s[i] == 'Y') ycnt++;
	}
	if (pcnt == ycnt) answer = true;
	else answer = false;
	return answer;
}

문자열 내림차순으로 배치하기

문제

comparator 연습. sort(s.begin(), s.end(), greater<char>()); 이렇게 할 수도 있구나..

#include <string>
#include <vector>
#include <algorithm> // sort
using namespace std;

bool comp(char a, char b) {
	if (a > b) return true;
	else return false;
}
string solution(string s) {
	string answer = "";
	vector<char> v;
	int i, size = s.size();

	for (i = 0; i < size; i++) v.push_back(s[i]);

	sort(v.begin(), v.end(), comp);

	for (i = 0; i < size; i++) answer += v[i];

	return answer;
}

string solution2(string s) {
	sort(s.begin(), s.end(), greater<char>());
	return s;
}

핸드폰 번호 가리기

문제

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

string solution(string phone_number) {
	string answer = "";
	int i = 0;
	for (i; i < phone_number.size() - 4; i++) answer += '*';
	for (i; i < phone_number.size(); i++) answer += phone_number[i];
	return answer;
}

3진법 뒤집기

문제

#include <iostream>
#include <string>
#include <stack> 
#include <cmath> // pow
using namespace std;

int solution(int n) {
	int answer = 0;
	int i = 0;
	stack<int> st;

	// 3진법
	while (n) { 	
		st.push(n % 3);
		n /= 3;
	}

	while (!st.empty()) {
		answer += st.top() * pow(3, i);
		st.pop();
		i++;
	}

	return answer;
}

2016년

문제

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

string day[7] = { "THU", "FRI", "SAT", "SUN", "MON", "TUE", "WED" };
int month[12] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

string solution(int a, int b) {
	string answer = "";
	int days = 0;
	int i;
	for (i = 0; i < a - 1; i++) days += month[i];
	days += b;

	return day[days % 7];
}

최대공약수와 최소공배수

문제

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

int gcd(int a, int b) {
	int r;
	while (b) {
		r = a % b;
		a = b;
		b = r;
	}
	return a;
}

int lcm(int a, int b) {
	int c = gcd(a, b);
	return a * b / c;
}

vector<int> solution(int n, int m) {
	vector<int> answer;
	answer.push_back(gcd(n, m));
	answer.push_back(lcm(n, m));
	return answer;
}

두 개 뽑아서 더하기

문제

정렬한 다음 unique를 쓸 생각을 하면서 뿌듯해하고 있었는데 set으로 푼 사람도 있었다 ㄷㄷ 중복된 원소가 없다는 성질을 이렇게 써먹다니.. 오늘도 배우고 갑니다

#include <iostream>
#include <string>
#include <vector>
#include <algorithm> // sort
#include <set>
using namespace std;

vector<int> solution(vector<int> numbers) {
	vector<int> answer;
	int i, j, size;
	size = numbers.size();

	for (i = 0; i < size - 1; i++) {
		for (j = i + 1; j < size; j++) {
			answer.push_back(numbers[i] + numbers[j]);
		}
	}

	sort(answer.begin(), answer.end());
	answer.erase(unique(answer.begin(), answer.end()), answer.end());
	return answer;
}

vector<int> solution(vector<int> numbers) {
	vector<int> answer;
	vector<int> st;
	int i, j, size;
	size = numbers.size();

	for (i = 0; i < size - 1; i++) {
		for (j = i + 1; j < size; j++) {
			st.insert(numbers[i] + numbers[j]);
		}
	}
	
	answer.assign(st.begin(), st.end());
	return answer;
}

문자열 내 마음대로 정렬하기

문제

#include <iostream>
#include <string>
#include <vector>
#include <algorithm> // sort
using namespace std;

int idx;

bool comp(string a, string b) {
	if (a[idx] == b[idx]) return a < b;
	else return a[idx] < b[idx];
}

vector<string> solution(vector<string> strings, int n) {
	idx = n;
	sort(strings.begin(), strings.end(), comp);
	return strings;
}

완주하지 못한 선수

문제

시퀀스 컨테이너만 거의 쓰다보니 map이나 set같은 연관 컨테이너에 대한 경험이나 공부가 부족하다는 걸 느꼈다

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

string solution(vector<string> participant, vector<string> completion) {
	string answer = "";
	unordered_map<string, int> umap;
	for (string name : participant) umap[name]++; // umap[name] = 1;
	for (string name : completion) umap[name]--; // umap[name] = 0;
	for (string name : participant) {
		if (umap[name] == 1) answer = name;
	}
	return answer;
}

크레인 인형뽑기 게임

문제

행과 열에 주의할 것,,,

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

int solution(vector<vector<int>> board, vector<int> moves) {
	int answer = 0;
	int now = 0;
	int i;
	stack<int> st;
	st.push(0);

	for (int move : moves) {
		for (i = 0; i < board.size(); i++) {
			now = board[i][move - 1];
			if (now) {
				if (now == st.top()) {
					st.pop();
					answer += 2;
				}
				else {
					st.push(now);
				}
				board[i][move - 1] = 0;
				break;
			}
		}
	}
	return answer;
}

실패율

문제

#include <iostream>
#include <string>
#include <vector>
#include <algorithm> // sort
#define MAX 501
using namespace std;

long long enteredPlayers[MAX]; // 각 스테이지에 도전한 플레이어의 수
long long failedPlayers[MAX]; // 각 스테이지 별 클리어하지 못한 플레이어의 수

bool comp(int a, int b) {
	if (enteredPlayers[a] * failedPlayers[b] == enteredPlayers[b] * failedPlayers[a]) {
		return a < b;
	}
	else {
		return enteredPlayers[a] * failedPlayers[b] < enteredPlayers[b] * failedPlayers[a];
	}
}

vector<int> solution(int N, vector<int> stages) {
	vector<int> answer;
	int size, cnt, i;
	size = stages.size();

	sort(stages.begin(), stages.end());

	cnt = 0;
	for (i = 0; i <= N; i++) enteredPlayers[i] = N; // init
	for (i = 0; i < size; i++) failedPlayers[stages[i]]++; // init
	for (i = 1; i <= N; i++) { // 각 스테이지에 도전한 플레이어의 수 계산
		enteredPlayers[i] = size - cnt;
		cnt += failedPlayers[i]; // cnt: 스테이지에 실패한 플레이어의 누적 합
	}

	for (i = 1; i <= N; i++) answer.push_back(i); // 각 스테이지의 번호를 정렬해야 하기 떄문에..!

	sort(answer.begin(), answer.end(), comp);
	return answer;
}

비밀지도

문제

비트셋으로 편하게 풀었다 😆

#include <iostream>
#include <string>
#include <vector>
#include <bitset>
#include <algorithm> // replace
#define MAX 16
using namespace std;

vector<string> solution(int n, vector<int> arr1, vector<int> arr2) {
	vector<string> answer;
	int i;

	for (i = 0; i < n; i++) {
		bitset<MAX> map(arr1[i] | arr2[i]);
		string str = map.to_string();
		str = str.substr(str.size() - n);
		replace(str.begin(), str.end(), '0', ' ');
		replace(str.begin(), str.end(), '1', '#');
		answer.push_back(str);
	}
	return answer;
}

신규 아이디 추천

문제

2021 카카오 블라인드 채용문제. 공식 해설 여기

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

string solution(string new_id) {
	string answer = "";
	vector<char> v;
	int i;

	for (i = 0; i < new_id.size(); i++) { // 1단계
		char now = new_id[i];
		if ('A' <= now && now <= 'Z') new_id[i] = tolower(now);
	}

	for (char now : new_id) { // 2단계
		if (('a' <= now && now <= 'z') || ('0' <= now && now <= '9') ||
			now == '-' || now == '_' || now == '.') v.push_back(now);
	}

	for (i = 1; i < v.size(); i++) { // 3단계
		if (v[i] == '.' && v[i - 1] == '.') {
			v.erase(v.begin() + i, v.begin() + i + 1);
			i--;
		}
	}

	if (v[0] == '.') v[0] = '`'; // 4단계	
	if (v.back() == '.') v.back() = '`';
	v.erase(remove(v.begin(), v.end(), '`'), v.end());

	if (v.size() == 0) v.push_back('a'); // 5단계

	if (v.size() > 15) { // 6단계
		if (v[14] == '.') v.erase(v.begin() + 14, v.end());
		else v.erase(v.begin() + 15, v.end());
	}

	if (v.size() < 3) { // 7단계
		char last = v.back();
		while (v.size() != 3) v.push_back(last);
	}

	for (i = 0; i < v.size(); i++) answer += v[i];
	return answer;
}

키패드 누르기

문제

2020 카카오 인턴십 문제. 공식 해설은 여기

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

int calcDist(int a, int b) {
	if (a == 0) a = 11;
	if (b == 0) b = 11;
	int dist = abs(a - b) / 3 + abs(a - b) % 3; // abs(a-b)/3: 세로로 이동, abs(a-b)%3: 가로로 이동

	return (dist > 0 ? dist : -dist);
}

string solution(vector<int> numbers, string hand) {
	string answer = "";
	int left = 10, right = 12;
	for (int number : numbers) {
		if (number % 3 == 1) { // 1, 4, 7
			left = number;
			answer += 'L';
		}
		else if (number % 3 == 0 && number != 0) { // 3, 6, 9
			right = number;
			answer += 'R';
		}
		else {
			int ldist = calcDist(left, number);
			int rdist = calcDist(right, number);
			if (ldist < rdist) {
				left = number;
				answer += 'L';
			}
			else if (ldist > rdist) {
				right = number;
				answer += 'R';
			}
			else { // ldist == rdist
				if (hand == "left") {
					left = number;
					answer += 'L';
				}
				else {
					right = number;
					answer += 'R';
				}
			}
		}
	}
	return answer;
}

다트 게임

문제

#include <iostream>
#include <string>
#include <cmath> // pow
#include <sstream> // stringstream
using namespace std;

int solution(string dartResult) {
	int answer = 0;
	int idx = -1;
	int size = dartResult.size();
	int arr[3] = { 0, 0, 0 };
	int i;

	for (i = 0; i < size; i++) {
		char now = dartResult[i];

		if (now == 'S' || now == 'D' || now == 'T') { // 보너스
			if (now == 'D') arr[idx] *= arr[idx];
			else if (now == 'T') arr[idx] = pow(arr[idx], 3);
		}
		else if (now == '*') { // 옵션 1: 스타상
			if (idx > 0) arr[idx - 1] *= 2;
			arr[idx] *= 2;
		}
		else if (now == '#') { // 옵션 2: 아차상
			arr[idx] *= -1;
		}
		else if ('0' <= now && now <= '9') { // 점수
			idx++;
			if (now == '1' && i < size - 1 && dartResult[i + 1] == '0') {
				arr[idx] = 10;
				i++;
			}
			else arr[idx] = now - '0';
		}
	}
	for (i = 0; i < 3; i++) answer += arr[i];
	return answer;
}

// 출처: https://programmers.co.kr/learn/courses/30/lessons/17682/solution_groups?language=cpp
int solution2(string dartResult) {
	stringstream ss(dartResult); // 입력받은 문자열에서 ' '와 '\n'을 제외하고 머지 자료들 중 받는 데이터의 자료형으로 꺼내올 수 있도록 함

	int sum[3] = { 0, 0, 0 };
	int options[3] = { 1, 1, 1 };
	int i;

	for (i = 0; i < 3; i++) {
		int score;
		char bonus, option;

		ss >> score;

		bonus = ss.get(); // ss에서 bonus를 가져옴
		option = ss.get(); // ss에서 option을 가져옴

		if (option != '*' && option != '$') ss.unget(); // option을 다시 ss에 넣음

		switch (bonus) {
		case 'S':
			sum[i] += pow(score, 1);
			break;
		case 'D':
			sum[i] += pow(score, 2);
			break;
		case 'T':
			sum[i] += pow(score, 3);
			break;
		default:
			break;
		}

		switch (option) {
		case '*':
			if (i > 0 && options[i - 1]) options[i - 1] *= 2;
			options[i] *= 2;
			break;
		case '#':
			options[i] = -options[i];
			break;
		default:
			break;
		}
	}

	return sum[0] * options[0] + sum[1] * options[1] + sum[2] * options[2];
}

소수 만들기

문제

#include <vector>
#include <cstring> // memset
#define MAX 3000 // 1000 + 1000 + 1000
using namespace std;

bool isPrime[MAX + 1];

void findPrime() {
	int i, j;

	memset(isPrime, true, sizeof(isPrime));
	isPrime[0] = false;
	isPrime[1] = false;

	for (i = 2; i * i <= MAX; i++) {
		if (isPrime[i]) {
			for (j = 2; i * j <= MAX; j++) {
				isPrime[i * j] = false;
			}
		}
	}
}

int solution(vector<int> nums) {
	int answer = 0;
	int size = nums.size();
	int i, j, k;

	findPrime();

	for (i = 0; i < size; i++) {
		for (j = i + 1; j < size; j++) {
			for (k = j + 1; k < size; k++) {
				int n = nums[i] + nums[j] + nums[k];
				if (isPrime[n]) answer++;
			}
		}
	}

	return answer;
}

폰켓몬

문제

#include <vector>
#include <cstring> // memset
#define MAX 200001
using namespace std;

int solution(vector<int> nums) {
	bool hasType[MAX];
	int size = nums.size();
	int cnt = 0;
	int i;

	memset(hasType, false, sizeof(hasType));

	for (i = 0; i < size; i++) hasType[nums[i]] = true;
	for (i = 1; i < MAX; i++) {
		if (hasType[i]) cnt++;
	}

	return size / 2 > cnt ? cnt : size / 2;
}

로또의 최고 순위와 최저 순위

문제

#include <vector>
#include <algorithm> // sort
using namespace std;

int getRank(int n) {
	switch (n) {
	case 6:
		return 1;
	case 5:
		return 2;
	case 4:
		return 3;
	case 3:
		return 4;
	case 2:
		return 5;
	default:
		return 6;
	}
}

vector<int> solution(vector<int> lottos, vector<int> win_nums) {
	vector<int> answer;
	int lottoIdx = 0, winIdx = 0;
	int cnt = 0, zeros = 0;
	int i, j;
	sort(lottos.begin(), lottos.end());
	sort(win_nums.begin(), win_nums.end());

	for (i = 0; i < 6; i++) { // lottos
		if (lottos[i] == 0) zeros++;
		for (j = 0; j < 6; j++) { // win_nums
			if (lottos[i] == win_nums[j]) cnt++;
		}
	}

	answer.push_back(getRank(zeros + cnt));
	answer.push_back(getRank(cnt));

	return answer;
}