칠판에 붙여진 단어들이 주어질 때, 영석이가 세로로 읽은 순서대로 글자들을 출력하는 프로그램을 작성하시오. 총 다섯줄의 입력이 주어진다. 각 줄에는 최소 1개, 최대 15개의 글자들이 빈칸 없이 연속으로 주어진다. 주어지는 글자는 영어 대문자 ‘A’부터 ‘Z’, 영어 소문자 ‘a’부터 ‘z’, 숫자 ‘0’부터 ‘9’ 중 하나이다. 각 줄의 시작과 마지막에 빈칸은 없다.

문자열 배열로 입력을 한줄 씩 받고 getline(cin, word[i]) 해당 단어 길이를 벗어나지 않으면 세로 방향으로 읽는다.

#include<iostream>
#include<string>

using namespace std;

int main() {

    string word[5];

    for (int i = 0; i < 5; i++) {
        getline(cin, word[i]);
    }

    for (int i = 0; i < 15; i++) {

        for (int j = 0; j < 5; j++) {

            if(i<word[j].length())
                cout << word[j].at(i);
        }
    }

}

9093번 단어 뒤집기

문장이 주어졌을 때, 단어를 모두 뒤집어서 출력하는 프로그램을 작성하시오. 단, 단어의 순서는 바꿀 수 없다. 단어는 영어 알파벳으로만 이루어져 있다. 첫째 줄에 테스트 케이스의 개수 T가 주어진다. 각 테스트 케이스는 한 줄로 이루어져 있으며, 문장이 하나 주어진다. 단어의 길이는 최대 20, 문장의 길이는 최대 1000이다. 단어와 단어 사이에는 공백이 하나 있다.

이 문제를 통해서 문자열 자르기 split 방식과 사용자 입력을 받는 cin, getline의 차이점에 대해서 알게되었다. C++은 split함수가 따로 없기 때문에 내가 만드는 방법을 숙지하고 있는 것이 좋다.

stringstream 문자열에서 작동하는 스트림 클래스. 이 클래스 객체는 일련의 문자를 포함하는 문자열 버퍼를 사용하고 있습니다. 문자열에서 내가 원하는 자료형의 데이터를 추출할 때 사용합니다. sstream 헤더파일을 포함해야함

getline(stringstream, string, delimeter) stringstream에서 구분자 문자가 나올 때까지 읽는다. delimeter은 char자료형으로 공백단위로 읽고 싶다면 ' '을 인수로 주면된다.

getline(cin, string) 줄단위로 입력을 받아 string 변수에 저장한다. 개행문자\n까지 읽는다. 그리고 처음 나오는 \n 역시 읽으므로 입력버퍼에 \n가 남아있는 경우 뒤에 남아있는 문자열을 읽지않는 의도치않은 상황이 발생할 수 있어서 cin>> 으로 입력받은 후 getline으로 \n을 지워줘야한다.

cin 공백단위로 입력을 받고 개행문자\n 전까지만 읽는다. 그리고 다시 cin으로 입력을 받을시 입력버퍼에 남아있는 \n를 무시한다.

#include<iostream>
#include<string>
#include<vector>
#include<sstream> 
#include<algorithm>

using namespace std;

vector<string> split(string str, char delimiter);

int main() {

    int n;
    cin >> n;
    vector<vector<string>> vec(n);
    string input;

    getline(cin, input);
    //cin로 한번 읽고 난 다음 getline로 읽으면 4를 읽고 \n이 남아있는 상태라서 getline을 한번 더 수행해 줘야 된다. 
    //그 다음부터 getline을 실행해야 원하는 대로 값을 넣을 수 있다. 아니면 처음부터 getline으로 값을 읽어줘도 된다.

    for (int i = 0; i < n; i++) {
        getline(cin, input);
        vec[i] = split(input,' ');
    }

    for (vector<string> strArr: vec) {
        for (string str : strArr) {
            reverse(str.begin(), str.end());
            cout << str<<' ';
        }
        cout << endl;
    }
}

vector<string> split(string input, char delimiter) {
    vector<string> output;
    stringstream ss(input);
    string buffer;

    while (getline(ss, buffer, delimiter)) {

        output.push_back(buffer);
    }

    return output;
}

11655번 ROT13

ROT13은 카이사르 암호의 일종으로 영어 알파벳을 13글자씩 밀어서 만든다. 예를 들어, "Baekjoon Online Judge"를 ROT13으로 암호화하면 "Onrxwbba Bayvar Whqtr"가 된다. 문자열이 주어졌을 때, "ROT13"으로 암호화한 다음 출력하는 프로그램을 작성하시오.

스멀스멀 암호화 방식 중 대칭키가 떠올랐는 문제 (오늘난 네트워크보안과블락체인을 드랍했다고 한다. 덕분에 다음학기때 1학점짜리 전공을 들으러 학교를 다녀야겠지만..아무렴어때 선택과 집중이 필요한 4학년이다.)

대충 아스키코드 검색해서 나오는 그림보고 문제를 풀었다.

#include<iostream>
#include<string>

using namespace std;

int main() {

    //아스키 코드 A~Z 65~90  a~z 97~122

    string input;
    getline(cin, input);

    for (int i = 0; i < input.length(); i++) {

        char c = input[i];
        if (65 <= c && c <= 90) {
            input[i] = 65 + ((c - 65 + 13) % 26);
        }
        else if (97 <= c && c <= 122) {
            input[i] = 97 + ((c - 97 + 13) % 26);
        }
    }
    cout << input;
}

2740번 행렬 곱셈

N x M크기의 행렬 A와 M x K크기의 행렬 B가 주어졌을 때, 두 행렬을 곱하는 프로그램을 작성하시오.

아니 행렬의 곱은 어째서 볼 때마다 방법이 헷갈리는지 모르겠다. 학교 수업들으면서 한두번 본게 아닐텐데 볼때마다 구글링한다. 출처: https://j1w2k3.tistory.com/575

이차원배열 두개를 만들어 입력을 받고 첫번째 입력받은 행렬(matrix1)은 가로로 이동을 하고 두번째 행렬(matrix2)은 세로로 이동을 하면서 방문한 원소를 곱한 뒤 합을 구한다. 총 합을 결과 행렬(result)의 matrix1의 행, matrix2의 열 위치에 집어넣는다.

#include<iostream>
#include<string>

using namespace std;

int main() {

    int n, m;
    cin >> n >> m;

    int matrix1[100][100];

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++)
            cin >> matrix1[i][j];
    }

    int k;
    cin >> m >> k;

    int matrix2[100][100];
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < k; j++) {
            cin >> matrix2[i][j];
        }
    }

    int result[100][100];

    for (int i = 0; i < n; i++) {

        for (int r = 0; r < k; r++) {

            int sum = 0;
            for (int j = 0; j < m; j++) {

                sum+=matrix1[i][j] * matrix2[j][r];
            }
            result[i][r] = sum;
        }
    }

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < k; j++)
            cout << result[i][j]<<' ';
        cout << endl;
    }

}

이렇게 일주일동안 브론즈 맛보기 후 실버 단계로 넘어갈 계획이었는데 중간에 벨로그 업로드도하고 학교 졸작관련 신경도 쓰고.. 이것저것 병행하다보니 시간이 더 흘러버렸다.

2학년 여름방학때 별생각없이 쳤었던 컴활1급 필기가 있다. 2년이 지나면 실기를 칠 수 있는 자격이 만료되는데 벌써 시간이 그렇게 흘러버렸다. 2학년 겨울방학때 실기쳤음 딱 맞았을 것 같은뎅,,왜 안했었을까 사실 정처기가 있으면 컴활은 크게 필요없다고 다들 말해서 그냥 날리는게 맞지않을까 싶어서 손을 놓았었다. 하지만 생각할수록 계륵 그 자체여서 일단은 4월 6일날 시험날짜를 잡아두긴했다. 아마도 그때까진 컴활준비를 바짝 할 예정이다. 아무래도 정처기 실기 접수 전까진 공부를 안 할 내자신이 눈에 보이기에,,

2차원 배열이 주어졌을 때 (i, j) 위치부터 (x, y) 위치까지에 저장되어 있는 수들의 합을 구하는 프로그램을 작성하시오. 배열의 (i, j) 위치는 i행 j열을 나타낸다. 첫째 줄에 배열의 크기 N, M(1 ≤ N, M ≤ 300)이 주어진다. 다음 N개의 줄에는 M개의 정수로 배열이 주어진다. 배열에 포함되어 있는 수는 절댓값이 10,000보다 작거나 같은 정수이다. 그 다음 줄에는 합을 구할 부분의 개수 K(1 ≤ K ≤ 10,000)가 주어진다. 다음 K개의 줄에는 네 개의 정수로 i, j, x, y가 주어진다(1 ≤ i ≤ x ≤ N, 1 ≤ j ≤ y ≤ M).

#include<iostream>

using namespace  std;

int main() {

    int n, m;
    cin >> n >> m;

    int arr[300][300];

    for (int i = 0; i < n; i++) {

        for (int j = 0; j < m; j++) {
            cin >> arr[i][j];
        }
    }

    int testCase, i, j, x, y;
    cin >> testCase;


    for (int k = 0; k < testCase; k++) {

        cin >> i >> j >> x >> y;
        int sum = 0;

        for (int r = i - 1; r < x; r++) {
            for (int c = j - 1; c < y; c++) {
                sum += arr[r][c];
            }
        }
        cout << sum<<endl;

    }


}

1977번 완전제곱수

M과 N이 주어질 때 M이상 N이하의 자연수 중 완전제곱수인 것을 모두 골라 그 합을 구하고 그 중 최솟값을 찾는 프로그램을 작성하시오. 예를 들어 M=60, N=100인 경우 60이상 100이하의 자연수 중 완전제곱수는 64, 81, 100 이렇게 총 3개가 있으므로 그 합은 245가 되고 이 중 최솟값은 64가 된다.

입력값의 범위가 10000이하의 자연수로 제한되어 있어 10000이하의 완전 제곱수를 모두 구해 벡터에 넣었다. 그후 입력받는 값의 범위 안에 있는 완전제곱수의 합을 구하고 첫번째의 완전 제곱수만 min변수에 저장하여 출력한다.

#include<iostream>
#include <vector>

using namespace  std;

int main() {

    vector<int> perfectNum;

    for (int i = 1;; i++) {

        int square = i * i;
        if (square > 10000) {
            break;
        }
        perfectNum.push_back(square);
    }

    int n,m;
    cin >> m >> n;

    int sum = 0;
    int min;
    bool flag = true;

    for (int sqr : perfectNum) {

        if (sqr >= m && sqr <= n) {
            sum += sqr;
            if (flag)
                min = sqr;
            flag = false;
        }

    }

    if (sum == 0)
    {
        cout << -1;
        return 0;
    }

    cout << sum << endl;
    cout << min << endl;

}

2563번 색종이

나에게 많은 빡침을 준 색종이 문제.. 처음에 단순하게 입력 색종이의 총면적을 구한뒤 겹치는 부분을 빼면 될 것이라 생각해서 문제를 풀었다. '틀렸습니다'가 떴고 여러 예제를 돌려보니 세번 이상 겹치기 시작하면 틀린다는 것을 알게되었다. 그래서 합집합에 대해 구하는 공식을 찾아보니 아래 그림을 발견하였다. (출처: https://m.blog.naver.com/galaxyenergy/222007107188)

그래요 세번 겹치는 것까지는 어째저째 만들 것 같은데 그 이상으로 겹치는건 어떻게 해야할지 모르겠더라. 그래도 꾸역꾸역 코드를 보완해서 다시 돌렸는데 이젠 네번이상 겹치는 것에서 문제가 생기는 것인지 9프로에서 틀렸습니다가 뜬다. 뭔가 얄팍한 내 지식으로는 수학적으로 풀지 못했다.

다른 사람의 코드를 찾아보니 도화지 입장의 100*100배열을 만들고 색종이가 해당위치에 있으면 표시를 해서 표시된 도화지 넓이를(배열 원소개수)를 구하더라. 이렇게 단순하게 접근하는 것이 답인 듯 했다.

#include<iostream>
using namespace  std;

int main() {

    bool paper[100][100];

    for (int i = 0; i < 100; i++) {
        for (int j = 0; j < 100; j++)
            paper[i][j] == 0;
    }

    int n;
    cin >> n;

    for (int i = 0; i < n; i++) {

        int x, y;
        cin >> x >> y;

        //fillPaper(x, y);
        for (int i = x; i < x + 10; i++)
        {
            for (int j = y; j < y + 10; j++)
            {
                paper[i][j] = 1;
            }
        }
    }

    int sum = 0;
    for (int i = 0; i < 100; i++) {
        for (int j = 0; j < 100; j++)
            if (paper[i][j] == 1)
                sum++;
    }

    cout << sum;
}

아래는 삽질한 코드이다. 아마도 색종이가 최대 4개까지 나온다면? 정답일 수도 있다.. Overlap: 겹치는 영역에 대한 정보를 저장할 수 있는 클래스

• leftX: 왼쪽 아래 X좌표
• leftY: 왼쪽 아래 Y좌표
• rightX: 오른쪽 위 X좌표
• rightY: 오른쪽 위 Y좌표

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

class Overlap {

public:
int leftX; int leftY; int rightX; int rightY;

public: Overlap(int x, int y, int x1, int y1) { this->leftX = x; this->leftY = y; this->rightX = x1; this->rightY = y1; } };

int main() {

vector<Overlap> overlap;
int n;
cin >> n;

vector<pair<int, int>> confetti(n);
for (int i = 0; i < n; i++) {
    cin >> confetti[i].first >> confetti[i].second;
}

int totalArea = n * 100;

for (int i = 0; i < n-1; i++) {

    overlap.clear();

    for (int j = i + 1; j < n; j++) {

        if (abs(confetti[i].first - confetti[j].first) <= 9
            && abs(confetti[i].second - confetti[j].second) <= 9)
        {

            int ix= confetti[i].first;
            int iy=confetti[i].second;

            int jx=confetti[j].first;
            int jy=confetti[j].second;

            int leftX = max(ix, jx);
            int leftY = max(iy, jy);

            int rightX = min(ix + 10, jx + 10);
            int rightY = min(iy + 10, jy + 10);

            int lenX = rightX - leftX;
            int lenY = rightY - leftY;


            if (overlap.size() == 0) {

                totalArea -= lenX*lenY ;
            }
            else {

                for (int i = 0; i < overlap.size();i++) {

                    Overlap area = overlap[i];

                    if ((area.leftX <= leftX && leftX <= area.rightX)
                        && (area.leftY <= leftY && leftY <= area.rightY))
                    {

                        int overLenX = min(rightX, area.rightX) - max(leftX, area.leftX);
                        int overLenY = min(rightY, area.rightY) - max(leftY, area.leftY);

                        //cout << overLenX << endl << overLenY<<endl;
                        totalArea -= lenX * lenY - overLenX * overLenY;
                    }
                }
            }
            overlap.push_back(Overlap(leftX, leftY, rightX, rightY));

        }
    }
}
cout << totalArea;

}

## 10988번 팰린드롬인지 확인하기
알파벳 소문자로만 이루어진 단어가 주어진다. 이때, 이 단어가 팰린드롬인지 아닌지 확인하는 프로그램을 작성하시오.

팰린드롬이란 앞으로 읽을 때와 거꾸로 읽을 때 똑같은 단어를 말한다. 
level, noon은 팰린드롬이고, baekjoon, online, judge는 팰린드롬이 아니다.

말그래도 단어위 위치를 앞뒤로 바꾸었을 때 원래 입력값과 동일하면 팰린드롬 단어라고 판단했다. 단어길이의 반 만큼만 반복문을 돌리고 그 안에서 처음단어와 끝단어를 계속 swap하면 어렵지 않게 구할 수 있다. 이전에 풀었던 팰린드롬숫자도 정수형이 아닌 문자열로 입력받아 같은 방식으로 푼 사람이 있었다. 

#include #include

using namespace std;

int main() {

string word, cpy;
getline(cin, word); 

cpy = word;        //깊은 복사라 word값 변경되어도 cpy에는 영향 안미침

int len = word.length();

for (int i = 0; i <len/2; i++) {

    char temp = word[i];
    word[i] = word[len - 1 - i];
    word[len - 1 - i] = temp;

}

if (word == cpy)
    cout << 1;
else
    cout << 0;

}

입력 받은 대로 출력하는 프로그램을 작성 입력은 최대 100줄로 이루어져 있고, 알파벳 소문자, 대문자, 공백, 숫자로만 이루어져 있다. 각 줄은 100글자를 넘지 않으며, 빈 줄이 주어질 수도 있고, 각 줄의 앞 뒤에 공백이 있을 수도 있다.

EOF까지 입력받아 출력하여야 하는 문제였다. 윈도우에서 EOF는 콘솔창에 ctrl+z를 입력하면 된다. 해당문제가 입력 최대 100줄이라 i<100 조건을 넣었다.

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

int main(void) {

    string str;
    string res;

    for (int i = 0; i<100 && !cin.eof(); i++)
    {
        getline(cin, str);

        if (i > 0)
            res += "\n";
        res += str;
    }
    cout << res;
}

cin.eof()

입력값의 범위를 주어지지 않은 경우 파일이 종료될 때까지 입력을 받아라는 의미이므로 cin.eof()를 이용하면 된다. bool 타입으로 EOF를 읽게 되면 true값을 가지게 된다.

while (!cin.eof()) {    //EOF를 만날때까지 무한 입력
        cin >> n;
    }

2748번 피보나치 수2

피보나치 수는 0과 1로 시작한다. 0번째 피보나치 수는 0이고, 1번째 피보나치 수는 1이다. 그 다음 2번째 부터는 바로 앞 두 피보나치 수의 합이 된다. 이를 식으로 써보면 Fn = Fn-1 + Fn-2 (n ≥ 2)가 된다. n=17일때 까지 피보나치 수를 써보면 다음과 같다. 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597 n이 주어졌을 때, n번째 피보나치 수를 구하는 프로그램을 작성. n은 90보다 작거나 같은 자연수이다.

int의 표현범위를 벗어나서, 90번째 피보나치수를 체크하지 않아서 두 번 틀렸던 문제이다.

자료형

int : *–2,147,483,648 ~ 2,147,483,647 *unsigned int : 0 ~ 4,294,967,295 long long : -9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807

int는 4바이트이고 long long은 8바이트라고 한다. 보통 long long *자료형은 *int 연산에서 초과되는 범위를 다룰 때 사용한다. 참고로 double 역시 8바이트이지만 소수점 아래 표현을 더 많이 할 수 있어 소수를 구해야 하는 연산에서는** double** 자료형이 적절하다.

90번째 피보나치 수는 0번째부터 시작한 90번째 숫자이다. fibo[90]이므로 배열은 91개의 원소를 가져야한다. 이 문제는 1학년 시절 예전에 순환함수를 이용해서 푼 예제를 본적이 있었다. 그래도 90개의 피보나치 수를 미리 저장해놓는게 더 쉽다고 생각하여 배열을 만들어넣고 저장을 하였다.

#include<iostream>
using namespace std;

int main(void) {

    long long fibo[91] = {0,1};

    for (int i = 2; i < 91; i++) {
        fibo[i] = fibo[i - 1] + fibo[i - 2];
    }
    int n;
    cin >> n;
    cout << fibo[n];
}

11050번 이항계수1

자연수 n과 정수k가 주어졌을 때 이항계수 nCk를 구하는 프로그램을 작성. n,k는 최대 10으로 제한되어있다.

사담이지만 약간 피보나치문제부터 이항계수 문제는 추억 돋았다. 1학년 시절 C언어에 함수부분 배울 때 하도 책예제로 자주 등장했기 때문이다,, 그럼에도 불구하고 이항계수? 식이 생각나질 않았다. 시간이 지나면 수능을 쳐도 다 소용이 없구만 싶었다. (내머리 인증이요 빡빡)

#include<iostream>
using namespace std;

int factorial(int);

int main(void) {

    int n, k;
    cin >> n >> k;

    cout << (double)factorial(n) / (factorial(n - k) * factorial(k));
}

int factorial(int num) {

    int result=1;
    for (int i = num; i >= 1; i--) {
        result *= i;
    }
    return result;
}

1259번 팰린드롬수

수의 숫자들을 뒤에서부터 읽어도 같다면 그 수는 팰린드롬수다. 121, 12421 등은 팰린드롬수다. 123, 1231은 뒤에서부터 읽으면 다르므로 팰린드롬수가 아니다. 입력은 여러줄 입력의 마지막은 0이다. 팰린드롬수이면 yes 아니면 no를 출력한다.

이렇게 여러줄을 입력받고 결과를 출력하는 문제들을 보면 나는 백준 예제와 동일해야한다고 생각하여서 입력값과 출력값을 모두 배열 혹은 벡터에 저장했었다. 근데 다른 사람들의 코드가 궁금해서 보니 그렇지 않고 입력받자마자 결과를 출력하더라. 동일하게 채점이 되는 듯하다. 괜히 코드만 길어진 것 같아 조금 그랬지만, 이보다 중요한건 팰림드롬수를 구하는 방식의 차이이다.

방법의 차이는 다음과 같다.

1. char[6] 으로 입력받고 (\0포함이어서 6) 팰린드롬 글자를 판별하듯이 자리를 swap하여 결과를 비교하는 방식
2. 문자열 string 으로 입력을 받고 reverse한 결과와 비교하는 방식
3. 뒤집은 숫자의 값과 입력 받은 값이 동일한지 비교하는 방식. 나는 개인적으로 이 방식이 숫자의 특성을 잘 활용했고 깔끔해 보였다.

/*3번 방식 코드
  n/=10 을 하고 %10을 하면 끝자리 하나만 나온다.
  그 전에 구해진 수를 *10 해서 자릿수를 하나씩 올리고 끝자리 하나를 합친다. 
  이를 반복하면 입력된 숫자 n의 역방향의 숫자를 구할 수있다. */

while(1) {
        scanf("%d", &n);
        if(n == 0) {
            break;
        }
        m = n;
        l = 0;
        while(n > 0) {
            l = l * 10 + n % 10;
            n /= 10;
        }
        printf(l == m ? "yes\n" : "no\n");
    }

나는 왜 /= 대입 연산자가 생각이 안났던 것인가.. 나는 입력값에 자리 제한이 없어도 팰림드롬수 판별이 가능하며 같아야 하는 숫자의 자리를 모두 비교하는 방식을 생각했다.

12321처럼 다섯자리 숫자면? 만의 자리 vs 일의 자리, 천의 자리 vs 십의 자리를 비교하는 것이다.

식으로 표현하면 다음과 같다.(n=10000)
                num/n     vs           num%10
        num/(n/10)%10    vs    (num/10)%10
---------------------------------------------------------------
#include<iostream>
#include<vector>
using namespace std;

int main(void) {

    int n;
    vector<int> input;
    vector<string> result;

    do {
        cin >> n;
        if(n!=0)
            input.push_back(n);
    } while (n != 0);


    for (int number : input) {

        int n = 1;        //이 숫자의 자릿수 값 저장 변수

        for (; ;) {            
            if (number / n <= 9)        //나눈 몫의 범위가 1~9 사이이면 자릿수까지 곱해진 것이다
                break;
            else
                n *= 10;
        }

        bool flag;

        for (int i = 1; ; i*=10) {

            if (n / i == 0) {    // 몫이 0이면 자릿수를 벗어난 것이므로 break
                break;
            }

            if ((number / (n / i)) % 10 == (number / i) % 10)
                flag = true;
            else {
                flag = false;    //하나라도 틀린게 있으면 break 팰린드롬이 아니다
                break;
            }
        }

        if (flag == true)
            result.push_back("yes");
        else
            result.push_back("no");
    }

    for (string str : result){
        cout << str <<endl;
    }
}

보다시피 코드가 좀 조악하다. 숫자의 특성을 이용해 3번 방식처럼 합을 구했다면 더 간단했을 것이다. 그냥 이렇게 생각하는 사람이 있구나 하고 보면 될듯하다. 테스트를 해보니 int형이어서 9자릿수로 제한되었고 long long 으로 만들었다면 더 큰 자릿수로 테스트할 수 있을 것이다.

1032번 명령 프롬프트

이 문제는 검색 결과가 먼저 주어졌을 때, 패턴으로 뭘 쳐야 그 결과가 나오는지를 출력하는 문제이다. 패턴에는 알파벳과 "." 그리고 "?"만 넣을 수 있다. 가능하면 ?을 적게 써야 한다. 그 디렉토리에는 검색 결과에 나온 파일만 있다고 가정하고, 파일 이름의 길이는 모두 같다. ?가 와일드키처럼 어떤 알파벳도 올 수있는 것이고 위치만 일치하면 된다.

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

int main() {

    int n;
    cin >> n;

    vector<string> fname(n);

    for (int i = 0; i < n; i++) {
        cin >> fname[i];
    }

    if (n == 1) {
        cout << fname[0];
        return 0;
    }

    int fnameLen = fname[0].length();
    char result[51] = {'\0'};        //최대 50개인거 유의 뒤에  널문자 넣어야해서 [51]

    //앞에서부터 비교하다 모두 같으면 넣고 하나라도 다르면 물음표 표시
    //입력값이 하나이면 그대로

    for (int i = 0; i < fnameLen; i++) {

        char before;
        char now= fname[0][i];

        for (int j = 1; j < n; j++) {

            before = now;
            now = fname[j][i];

            if (now != before) {
                result[i] = '?';
                break;
            }
            else
                result[i] = now;
        }
    }
    cout << result;
}

N개의 수가 주어졌을 때, 이를 오름차순으로 정렬하는 프로그램을 작성하시오. 정렬 알고리즘을 구현하자니 찾아보기 귀찮아서 (너무 솔직한가) sort()를 사용했다.

#include<iostream>
#include<vector>
#include<algorithm>

using namespace std;

int main(void) {

    int n;
    cin >> n;

    vector<int> num(n);

    for (int i = 0; i < n; i++) {
        cin >> num[i];
    }

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

    for (int n : num) {
        cout << n <<endl;
    }
}

2689번 달팽이는 올라가고 싶다

땅 위에 달팽이가 있다. 이 달팽이는 높이가 V미터인 나무 막대를 올라갈 것이다. 달팽이는 낮에 A미터 올라갈 수 있다. 하지만, 밤에 잠을 자는 동안 B미터 미끄러진다. 또, 정상에 올라간 후에는 미끄러지지 않는다. 달팽이가 나무 막대를 모두 올라가려면, 며칠이 걸리는지 구하는 프로그램을 작성하시오

이 문제는 처음에 while문을 이용해 올라갔다 내려갔다를 반복해 day를 구하는 코드로 제출했는데 우아 시간 초과가 되었다. 음 이게 아니구나 싶어서 경우의 수를 나누어서 해보다가 계속 틀렸다. 세번 정도 틀렸고 생각보다 시간이 많이 흘렀다.

생각해보니 뭔가 낯익은 느낌이 중딩 시절 방정식 느낌이 스멀스멀나 day를 X로 생각하고 식을 간단하게 구했다. 어쨌든 3일이 걸리면 두 밤은 잤다는 이야기고 4일이 걸리면 세밤은 이미 잤다는 이야기이다.

위의 식과 같이 X의 최소값을 구할 수 있다. 예를 들어 우변이 2.22라면 X는 최소 정수값이어야 하므로 3이 된다. 그래서 ceil()함수를 이용해 올림을 해주었다. 새삼 이 문제를 보면서 무작정 코드를 치면 안된다는 것을 느꼈고 너무 간단해서 어이가 없었다.

#include<iostream>
#include<cmath>

using namespace std;

int main(void) {

    int a, b, v;
    cin >> a;
    cin >> b;
    cin >> v;

    int day;

    day = ceil( (double)(v - b) / (a - b));
    cout << day;

}

1924번 2007년

오늘은 2007년 1월 1일 월요일이다. 그렇다면 2007년 x월 y일은 무슨 요일일까? 이를 알아내는 프로그램을 작성하시오. 참고로 2007년에는 1, 3, 5, 7, 8, 10, 12월은 31일까지, 4, 6, 9, 11월은 30일까지, 2월은 28일까지 있다.

1월1일 부터 입력받은 일까지 총합을 구해서 (월~금)7로 나머지 연산을 하면 요일이 튀어나올 것이다. 그래서 달마다 총 몇일인지 저장하는 배열과 출력을 위한 요일 배열을 두개 만들었다. 생각해보니 12월은 저장할 필요가 없는데 그냥 예의상 넣어줬다.

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

int main(void) {

    vector<int> lastDay = { 31,28,31,30,31,30,31,31,30,31,30,31 };
    vector<string>day = { "SUN","MON","TUE", "WED", "THU", "FRI", "SAT" };

    int month;
    int date;

    cin >> month;
    cin >> date;

    int sumDate = 0;


    for (int i = 0; i < month-1; i++) {
        sumDate += lastDay[i];

    }
    sumDate += date;

    cout << day[sumDate % 7];

}

1193번 분수찾기

지그재그 방향별로 나오는 분수들을 나열해서 적어보니 필요한 변수들이 눈에 보였다. 먼저 방향이 바뀔때마다 방향에 포함되는 분수가 한 개씩 많아진다. 범위를 나타내는 range 변수 범위 안에서 입력된 X가 몇 번째 분수인지 알기 위한 idx 변수 범위의 시작과 끝을 저장하는 start, end변수 (=전체 나열에서 몇 번째인지) 그리고 대각선 위로 올라가는 방향이면 범위가 짝수 대각선 아래로 내려가는 방향이면 범위는 홀수이다. 두 경우로 구분해 x번째 분수를 출력한다.

#include<iostream>
using namespace std;

int main(void) {

    int start = 1;
    int end = 1;
    int range = 1;

    int input;
    cin >> input;

    while (1) {

        if (start <= input && input <= end) {

            int idx = input - start;
            if (range % 2 == 0) {
                cout << 1 + idx << "/" << range - idx;
            }
            else {
                cout << range - idx << "/" << 1 + idx;
            }
            break;
        }
        range++;
        start = end + 1; 
        end = start + range-1; 
    }
}

2775번 부녀회장이 될테야

이 아파트에 거주를 하려면 조건이 있는데, “a층의 b호에 살려면 자신의 아래(a-1)층의 1호부터 b호까지 사람들의 수의 합만큼 사람들을 데려와 살아야 한다” 는 계약 조항을 꼭 지키고 들어와야 한다.

아파트에 비어있는 집은 없고 모든 거주민들이 이 계약 조건을 지키고 왔다고 가정했을 때, 주어지는 양의 정수 k와 n에 대해 k층에 n호에는 몇 명이 살고 있는지 출력하라. 단, 아파트에는 0층부터 있고 각층에는 1호부터 있으며, 0층의 i호에는 i명이 산다.해당 집의 거주민 수를 구해라 순환함수를 이용해야하나 했지만 반복문으로 푸는게 실행시간이 빠를 것 같아서 반복문으로 풀었다. 처음에 호와 층에 개수 제한이 있는지 몰라서 아예 아파트 구조를 만들어 놓기엔 어려움이 있다고 생각을 했다. 나중에 확인해보니 14층 14호로 제한이 있었다. 순환 함수보단 스택에 넣고 푸시팝을 하는게 덜 오래걸릴 것이라 생각했는데 이 또한 돌려보니 엄청나게 오래걸렸다. 그렇게 좋은 방법은 아닌 듯하다. 10층만 넘어서도 엄청 오래걸렸다.(사실 코드 자체도 순환함수로 구현한 사람이 더 간단해보였다.)

이문제에 가장 적절한건 아파트 구조를 미리 만들어 놓는 것으로 추측해본다. 문제 제한 사항을 주의깊게 읽어보는 것을 놓치지 말자.

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

using namespace std;

int main(void) {


    //testcase 개수
    int t;    
    cin >> t;

    vector<pair<int, int>> testCase(t);

    //testcase입력 받음
    for (int i = 0; i < t; i++) {
        cin >> testCase[i].first;
        cin >> testCase[i].second;
    }

    for (int i = 0; i < t; i++) {

        int k = testCase[i].first;
        int n = testCase[i].second;

        vector<pair<int, int>> position;
        position.push_back(make_pair(k, n));

        int people = 0;

        while (position.size()) {

            int tempK = position.back().first;
            int tempN = position.back().second;

            //cout << tempK << "층" << tempN << "호" << endl;;

            position.pop_back();

            if (tempN == 1) {
                people++;
            }
            else if (tempK == 0) {
                people += tempN;
            }
            else {
                position.push_back(make_pair(tempK, tempN - 1));
                position.push_back(make_pair(tempK - 1, tempN));
            }
        }

        cout << people << endl;

    }
}

pair<int,int>

두 자료형의 쌍을 저장할 수 있는 구조이다. 처음에 vector<int,int> 이런걸 검색해보다가 발견하였다. 허허 무지하다. 이 문제처럼 층과 호수를 같이 입력받고 사용해야할 때 괜찮아 보인다.

#include<utility>
pair<int, int> p = make_pair(2, 3); 
cout << p.first << endl;    //2출력
cout << p.second << endl;    //3출력

브론즈1에서 사람들이 많이 풀어본 순서대로 24문제 정도를 풀어보았다. C++ 을 사용하였는데 2학년1학기때(2년전) 프로그래밍언어 과목으로 해당 언어를 다루어 본 이후로 처음이었다. 정말로 전형적인 문법 외에 머리에 있는게 없어서 문법을 알기 위해 구글링을 하면서 풀었다.. 이 시기동안은 딱히 문제를 푸는 능력이 향상되고 이런건 없고 언어에 익숙해져 가는 과정이라고 생각한다. _수행기간: 3/10~3/17 _

1110번 더하기 사이클

26부터 시작한다. 2+6 = 8이다. 새로운 수는 68이다. 6+8 = 14이다. 새로운 수는 84이다. 8+4 = 12이다. 새로운 수는 42이다. 4+2 = 6이다. 새로운 수는 26이다. 위의 예는 4번만에 원래 수로 돌아와서 사이클의 길이는 4이다.

예시를 그대로 따라 갔다. 두자리 숫자를 10의 자리(op1)와 1의 자리(op2)로 나누고 합을 구해 새로운 숫자(result)를 만든다. 그전 숫자의 1의 자리(op2)를 op1으로 변경해준 후, result의 1의 자리(op2)를 구한다. 이 과정을 계속 반복해 사이클을 체크한다.

#include<iostream>
using namespace std;

int main(void) {

    int input;
    cin >> input;

    int op1 = input / 10;
    int op2 = input % 10;
    int cycle = 0;
    int result;

    while (1) {
        cycle++;
        result = op1 + op2;

        op1 = op2;
        op2 = result % 10;

        if ((op1 * 10 + op2) == input) {
            cout << cycle;
            break;
        }
    }
}

1546번 평균

시험 평균 조작 문제. 모든 과목의 점수를 점수/최고점*100 으로 바꾸고 다시 평균을 구하는 문제다.

#include<iostream>
#include<vector>
#include<algorithm>

using namespace std;

int main(void) {

    int n;
    cin >> n;

    vector<double> input(n);

    for (int i = 0; i < n; i++) {
        cin >> input[i];
    }

    int max = *max_element(input.begin(), input.end());
    double sum = 0;

    for (int i = 0; i < input.size(); i++)
    {
        input[i] = input[i] / max * 100;
        sum += input[i];
    }

    cout << (sum / input.size());
}

max_element() 함수 이용. max인 요소의 주소를 반환함

#include<algorithm>
int max_idx = max_element(cnt.begin(), cnt.end()) - cnt.begin(); 
//벡터에서 최대값인 인덱스 구하기

int max= *max_element(cnt.begin(), cnt.end())
//벡터에서 최대값 구하기

sort()함수

sort(v.begin(), v.end());    //오름차순
sort(v.rbegin(), v.rend());  //내림차순

2839번 설탕 배달

주어진 숫자를 최대한 적은 3또는 5로 만들어 보라는 문제였다. 만약 3 또는 5로 만들 수 없는 숫자라면 -1을 출력한다.
5로 나눌 수있는 범위 안에서 반복한다. 5의 배수를 뺀 숫자(n_temp)가 3으로 완전히 나누어지면 그때의 5의 개수(i)와 3의 개수(j)의 합을 비교해서 최소값(min)을 출력한다.

#include<iostream>
#include<vector>
#include<algorithm>

using namespace std;

int main(void) {

    int n;
    cin >> n;

    int bag1 = 3;
    int bag2 = 5;

    int quo1 = n / bag1;
    int quo2 = n / bag2;

    int min = n;

    if (quo2 > 0 || quo1 > 0) {

        for (int i = 0; i <= quo2; i++) {

            int j = 0;
            int n_temp = n - bag2 * i;

            if (n_temp % bag1 == 0) {
                j = n_temp / bag2;
                if (min > i + j) {
                    min = i + j;
                }
            }
        }
        if (min == n)
            cout << -1;
        else
            cout << min;
    }
    else {
        cout << -1;
    }

}

4344번 평균은 넘겠지

한 줄의 점수들(케이스)마다 평균을 넘는 학생들의 비율을 반올림하여 소수점 셋째 자리까지 출력하는 문제.

#include<iostream>
#include<vector>
#include<cmath>

using namespace std;

int main(void) {

    int r1;
    cin >> r1;

    vector<double> ratio(r1);

    for (int i = 0; i < r1; i++) {

        int r2;
        cin >> r2;

        vector<int> score(r2);
        int sum = 0;

        for (int j = 0; j < r2; j++) {

            cin >> score[j];
            sum += score[j];
        }

        double avg= sum / r2;

        int people = 0;

        for (int sc : score) {
            if (sc > avg)
                people++;
        }

        ratio[i] = round(((double)people / r2 * 100.0)*1000)/1000;

    }

    for (double rt : ratio) {

        printf("%.3f%%\n", rt);
    }

}

round()함수

#include<cmath>
round((n)*1000)/1000; //넷째 자리에서 반올림 -> 소수점 셋째 자리까지 구해짐
round((n)*100)/100;      //셋째 자리에서 반올림 -> 소수점 둘째 자리까지 구해짐

출력format 정하기

printf("%.3f%%\n", rt); //.3f  소수점 셋째 자리까지 출력. (ex) 2.2 -> 2.200 
                        // % 문자를 출력하기 위해선 %% 쓰면됨 

1157번 단어 공부

알파벳 대소문자로 된 단어가 주어지면, 이 단어에서 가장 많이 사용된 알파벳이 무엇인지 알아내는 프로그램을 작성. 단, 대문자와 소문자를 구분하지 않음, 가장 많이 사용된 알파벳이 여러개 존재하는 경우 ?출력함

아스키코드 값 AZ =6590 az =97122

반복문을 돌면서 소문자이던 대문자이던 간에 같은 위치에 cnt[i]++; cnt 벡터에서 가장 큰 원소의 인덱스를 구하고 반복문을 돌며 cnt[max_idx]의 값과 동일한 원소가 하나라도 있으면 ?를 출력하고 break; 만약 cnt를 모두 검사하고 마지막 반복문까지 돌아오는 경우라면(i==26) 대문자 알파벳으로 출력한다. 알파벳은 총 26개이므로 이를 끝까지 보고 가장 많이 사용된 알파벳을 출력하는걸 간단하게 만들려고 그냥 한번 더 반복을 해줬다. for(int i=0;i<27;i++)

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

using namespace std;

int main(void) {

    string str;
    cin >> str;

    vector<int> cnt(26, 0);

    for (char a : str) {

        for (int i = 0; i < 26; i++) {

            if (a == 65 + i || a == 97 + i) {
                cnt[i]++;
            }
        }
    }

    int max_idx = max_element(cnt.begin(), cnt.end()) - cnt.begin();


    for (int i = 0; i < 27; i++) {
        if (i == max_idx)
            continue;

        if (i == 26) {
            printf("%c", max_idx + 65);
        }
        else if (cnt[max_idx] == cnt[i]){
            cout << "?";
            break;
        }

    }

}

• 전공 과목 시험대비 정리안
• 전공 과목 눈물났던 과제들
• 학부 연구생 활동
• 국가 우수 이공계 장학생

대외활동으로 얻은 경험

• 대회 참가 및 수상
• 공모전
• 봉사활동
• 아르바이트

앞으로의 목표와 계획

• 알고리즘 문제 풀이 요약기록
• 정보처리기사 실기
• SQLD 5월중
• 컴퓨터활용능력 1급 실기
• OPIC IH목표