idea8590 님의 블로그

LCK 고인물 테스트

idea8590 — Sat, 7 Feb 2026 13:21:32 +0900

안녕하세요.

LCK 퀴즈 챌린지를 만들었습니다.

쉬움, 중간, 어려움, 매우 어려운 문제도 존재해 LCK를 잘 아는 사람도 어려운 문제 몇 개 있을 거라고 생각합니다.

2012 ~ 2026 lck 및 선수에 관한 20문제를 만들었습니다.(국제대회는 X)

선수 커리어, 팀 커리어, 아래 문제와 같은 개그 문제도 만들어봤습니다.

문제는 모두 4지선다를 구분되었으며 AI 문제가 아닌 제가 하나하나 체크한 50문제 중 랜덤으로 20문제가 나오게끔 설정했습니다. 재밌게 즐겨주세요~

다음과 같은 창으로 시작합니다.

LCK 퀴즈 챌린지 2026

0 / 20 이미지 저장 링크 복사

harmonious-frangollo-670503.netlify.app

우주 사과게임 추억의 사과게임이 '우주급' 퀄리티로 돌아왔습니다

idea8590 — Thu, 5 Feb 2026 23:15:38 +0900

혹시 기억하시나요? 최근 다시 유튜버들 사이에서 유행했던 그 전설의 '사과게임'.

드래그해서 합이 10이 되면 사과가 톡톡 터지던 그 단순한 게임이, 세상에서 가장 세련된 디자인과 몽환적인 사운드를 입고 돌아왔습니다.

오늘 소개할 앱은, 단순함 속에 우주를 담은 [우주사과게임]입니다.

다음과 같이 원하는 시간대로 설정 가능합니다. (1분, 2분, 3분)

1. 3초면 배우고, 30분 순삭당합니다.

Cosmic Sums 10

polite-belekoy-5ce29e.netlify.app

기존사과게임에 더해 여러가지 기능들, 멋진 음악 점수표(각 시간마다 다르게 적용) 까지 있습니다.

망치, 판 뒤집기, 돋보기 등 다양한 기능들이 있습니다.

규칙은 설명할 것도 없습니다. "드래그해서 합이 10을 만드세요."

2 + 8 = 10 (성공!)
1 + 3 + 6 = 10 (성공!)
2 x 5개 = 10 (초대박!)

너무 쉽다고요? 막상 타이머가 돌아가기 시작하면 손가락이 뇌보다 먼저 움직여야 합니다. 단순한 덧셈이 이렇게 쫄깃할 수 있다는 걸 처음 알게 되실 거예요.

2. 왜 이 게임에 빠져들까? (매력 포인트 3가지)

✨ 첫째, "광고 보다가 흐름 끊길 일이 없어요"

요즘 게임들, 한 판 하고 광고 보고 지치시죠? Cosmic Sums는 집요할 정도로 '경험'에만 집중합니다. 덕지덕지 붙은 배너 광고도, 복잡한 과금 유도도 없습니다. 오직 숫자와 시간, 그리고 나만의 집중력 싸움입니다. 이거 진짜 귀합니다.

둘째, "게임인데 명상하는 기분"

보통 퍼즐 게임은 머리가 아픈데, 이건 묘하게 힐링이 됩니다. 우주를 유영하는 듯한 배경음악, 블록이 터질 때의 타격감... 퇴근길 지하철이나 잠들기 전 10분, 복잡한 머릿속을 비우기에 이보다 완벽한 도구는 없습니다.

셋째, "당신의 뇌지컬은 상위 몇 %입니까?"

게임이 끝나면 잔인하고도 정확한 성적표가 나옵니다. "당신은 상위 0.1%입니다" 라는 문구를 보기 위해 저도 모르게 '다시 하기'를 누르고 있는 자신을 발견하게 될 겁니다.

3. 이런 분들에게 강력 추천합니다

학창 시절 '사과게임' 만렙이셨던 분 (그 실력, 아직 살아있나요?)
복잡한 RPG, 숙제 같은 게임에 지치신 분
짧고 굵게 몰입할 수 있는 '킬링타임' 앱을 찾는 분
내 두뇌 회전 속도가 녹슬지 않았는지 확인하고 싶은 분

플레이 팁 (고득점 비법)

무조건 눈앞의 10을 지우지 마세요! "큰 그림"을 봐야 합니다. 지금 이 블록을 지웠을 때, 위에서 떨어지는 블록들이 어떻게 합쳐질지 예측해야 '콤보'가 터집니다.

지금 바로 도전해 보세요. 당신의 뇌는 생각보다 빠르고 똑똑합니다.

[CodeUp] C언어 기초 100제 풀이 (1097번 ~ 1099번)

idea8590 — Thu, 5 Feb 2026 06:08:26 +0900

CodeUp 기초 100제: 2차원 배열 완전 정복 (1097 ~ 1099)

이 구간은 프로그래밍 기초의 꽃이라 불리는 2차원 배열과 시뮬레이션을 다룹니다. 격자판 위에서 데이터를 조작하고, 물체를 이동시키는 로직을 구현하며 알고리즘적 사고력을 완성하는 단계입니다.

1097 : [기초-2차원배열] 바둑알 십자 뒤집기

문제 설명

바둑판(19 * 19)에 흰 돌(1) 또는 검은 돌(0)이 모두 꽉 채워져 놓여있다. n개의 좌표를 입력받아 그 좌표에 있는 돌을 중심으로 가로 줄과 세로 줄의 색을 모두 뒤집는 프로그램을 작성해보자.

뒤집는다는 것은 1을 0으로, 0을 1로 바꾼다는 뜻이다.
입력되는 좌표(x, y)를 기준으로 x행 전체와 y열 전체의 색을 반전시켜야 한다.

입력

첫 줄부터 19줄에 걸쳐 현재 바둑판의 상태(0 또는 1)가 공백을 두고 입력된다.
20번째 줄에 십자 뒤집기 횟수(n)가 입력된다.
그 다음 줄부터 n개의 좌표(x, y)가 입력된다. (좌표는 1부터 19까지이다.)

출력

십자 뒤집기 결과를 출력한다. (각 줄의 숫자는 공백으로 구분)

소스 코드

#include <stdio.h>

int main() {
    int board[20][20]; // 1~19 인덱스를 사용하기 위해 20x20 선언
    int n, i, j, x, y;

    // 1. 현재 바둑판 상태 입력 받기 (19x19)
    for(i = 1; i <= 19; i++) {
        for(j = 1; j <= 19; j++) {
            scanf("%d", &board[i][j]);
        }
    }

    // 2. 뒤집기 횟수 입력
    scanf("%d", &n);

    // 3. 횟수만큼 좌표를 입력받아 뒤집기 실행
    for(i = 1; i <= n; i++) {
        scanf("%d %d", &x, &y);
        
        // 십자 뒤집기 로직
        for(j = 1; j <= 19; j++) {
            // 가로 줄(x행) 뒤집기: 0이면 1, 1이면 0
            if(board[x][j] == 0) board[x][j] = 1;
            else board[x][j] = 0;

            // 세로 줄(y열) 뒤집기: 0이면 1, 1이면 0
            if(board[j][y] == 0) board[j][y] = 1;
            else board[j][y] = 0;
        }
    }

    // 4. 최종 결과 출력
    for(i = 1; i <= 19; i++) {
        for(j = 1; j <= 19; j++) {
            printf("%d ", board[i][j]);
        }
        printf("\n");
    }

    return 0;
}

입력 예시

(복사하여 테스트하세요. 19줄의 바둑판 상태, 횟수 1, 좌표 10 10 입니다.)

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
1
10 10

출력 예시

(10행과 10열이 뒤집힌 상태)

0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 
0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0

문제 해설

토글(Toggle): 값을 반전시키는 것을 말합니다. if(val==0) val=1; else val=0; 구문을 사용해 구현합니다.
행과 열의 순회: 입력받은 좌표 (x, y)에 대해, board[x][j]를 반복하면 가로줄 전체를, board[j][y]를 반복하면 세로줄 전체를 접근할 수 있습니다.
중복 처리: 이 알고리즘대로라면 중심점 (x, y)는 가로 검사 때 한 번, 세로 검사 때 한 번, 총 두 번 뒤집히게 되어 원래 색상으로 돌아옵니다. 문제 의도상 이는 정상적인 동작입니다.

1098 : [기초-2차원배열] 설탕과자 뽑기

문제 설명

부모님과 함께 놀러간 영일이는 설탕과자(설탕을 녹여 물고기 등의 모양을 만든 것) 뽑기를 보게 되었다. 길이가 다른 막대 여러 개를 격자판에 놓는데, 격자판의 세로(h), 가로(w), 막대의 개수(n), 각 막대의 길이(l), 방향(d), 좌표(x, y)를 입력받아 막대를 놓는 프로그램을 작성해 보자.

막대가 놓인 곳은 1, 없는 곳은 0으로 채운다.
방향(d): 0은 가로 방향, 1은 세로 방향이다.

입력

첫 줄에 격자판의 세로(h), 가로(w)가 공백을 두고 입력된다. (1 <= h, w <= 100)
두 번째 줄에 놓을 막대의 개수(n)가 입력된다. (1 <= n <= 10)
세 번째 줄부터 각 막대의 길이(l), 방향(d), 좌표(x, y)가 n줄 입력된다.

출력

막대가 놓인 후의 격자판의 상태를 출력한다.

소스 코드

#include <stdio.h>

int main() {
    int h, w, n, l, d, x, y;
    int board[101][101] = {0}; // 격자판 최대 크기가 100이므로 101로 넉넉히 초기화
    int i, j;

    // 1. 격자판 크기 및 막대 개수 입력
    scanf("%d %d", &h, &w);
    scanf("%d", &n);

    // 2. 막대 정보 입력 및 배치
    for(i = 1; i <= n; i++) {
        scanf("%d %d %d %d", &l, &d, &x, &y);

        for(j = 0; j < l; j++) { // 막대 길이(l)만큼 반복
            if(d == 0) { 
                // 가로 방향(d=0): 행(x)은 고정, 열(y)이 증가
                board[x][y + j] = 1;
            }
            else { 
                // 세로 방향(d=1): 열(y)은 고정, 행(x)이 증가
                board[x + j][y] = 1;
            }
        }
    }

    // 3. 결과 출력
    for(i = 1; i <= h; i++) {
        for(j = 1; j <= w; j++) {
            printf("%d ", board[i][j]);
        }
        printf("\n");
    }

    return 0;
}

입력 예시

출력 예시

문제 해설

방향에 따른 좌표 변화:
- 가로(d=0): 오른쪽으로 길어지므로 열 번호(y)가 1씩 증가합니다. -> board[x][y+j] = 1
- 세로(d=1): 아래쪽으로 길어지므로 행 번호(x)가 1씩 증가합니다. -> board[x+j][y] = 1
반복문 범위: 길이를 l이라고 할 때, j를 0부터 l-1까지 반복시켜 시작점부터 끝점까지 정확하게 채웁니다.

1099 : [기초-2차원배열] 성실한 개미

문제 설명

개미는 오른쪽(→) 또는 아래쪽(↓)으로만 움직일 수 있다. 미로 상자(10 * 10)에 개미(좌표 2, 2에서 시작)가 이동한 경로를 9로 표시하여 출력해보자.

0: 갈 수 있는 곳
1: 벽 또는 장애물
2: 먹이 (먹이에 도착하면 멈춘다)
개미는 오른쪽으로 갈 수 있다면 오른쪽으로 먼저 가고, 오른쪽에 벽이 있으면 아래쪽으로 간다.
먹이를 찾거나, 더 이상 움직일 수 없으면 이동을 멈춘다.

입력

10 * 10 크기의 미로 상자 구조가 입력된다.

출력

개미가 이동한 경로를 9로 표시해 출력한다.

소스 코드

#include <stdio.h>

int main() {
    int map[11][11]; // 10x10 미로
    int i, j;
    int x = 2, y = 2; // 개미의 시작 좌표는 (2, 2)로 고정됨

    // 1. 미로 정보 입력
    for(i = 1; i <= 10; i++) {
        for(j = 1; j <= 10; j++) {
            scanf("%d", &map[i][j]);
        }
    }

    // 2. 개미 이동 시뮬레이션 (무한 루프)
    while(1) {
        // 경우 1: 현재 위치가 먹이(2)인 경우
        if(map[x][y] == 2) { 
            map[x][y] = 9;   // 먹은 자리를 표시하고
            break;           // 종료
        }

        map[x][y] = 9; // 현재 위치를 9(방문함)로 변경

        // 경우 2: 오른쪽 이동 가능 여부 확인
        if(map[x][y + 1] != 1) { // 오른쪽이 벽(1)이 아니라면 (0이거나 2)
            y++; // 오른쪽으로 한 칸 이동 (열 증가)
        }
        // 경우 3: 오른쪽은 막혔고, 아래쪽 이동 가능 여부 확인
        else if(map[x + 1][y] != 1) { // 아래쪽이 벽(1)이 아니라면
            x++; // 아래쪽으로 한 칸 이동 (행 증가)
        }
        // 경우 4: 오른쪽, 아래쪽 모두 막힌 경우
        else {
            break; // 더 이상 갈 곳이 없으므로 종료
        }
    }

    // 3. 최종 미로 상태 출력
    for(i = 1; i <= 10; i++) {
        for(j = 1; j <= 10; j++) {
            printf("%d ", map[i][j]);
        }
        printf("\n");
    }

    return 0;
}

입력 예시

1 1 1 1 1 1 1 1 1 1
1 0 0 1 0 0 0 0 0 1
1 0 0 1 1 1 0 0 1 1
1 0 0 0 0 0 0 1 0 1
1 0 0 0 0 0 0 1 0 1
1 0 0 0 0 1 0 1 0 1
1 0 0 0 0 1 2 1 0 1
1 0 0 0 0 1 0 0 0 1
1 0 0 0 0 0 0 0 0 1
1 1 1 1 1 1 1 1 1 1

출력 예시

1 1 1 1 1 1 1 1 1 1 
1 9 9 1 0 0 0 0 0 1 
1 0 9 1 1 1 0 0 1 1 
1 0 9 9 9 9 9 1 0 1 
1 0 0 0 0 0 9 1 0 1 
1 0 0 0 0 1 9 1 0 1 
1 0 0 0 0 1 9 1 0 1 
1 0 0 0 0 1 0 0 0 1 
1 0 0 0 0 0 0 0 0 1 
1 1 1 1 1 1 1 1 1 1

문제 해설

우선순위 로직: 문제의 핵심은 "오른쪽을 먼저 본다"는 것입니다. if문으로 오른쪽(y+1)을 먼저 검사하고, 그것이 불가능할 때 else if로 아래쪽(x+1)을 검사해야 합니다.
종료 조건의 위치: 먹이(2)를 만났을 때 바로 종료하는 것이 아니라, 해당 위치를 9로 표시한 직후에 종료해야 합니다.
좌표 관리: 개미의 위치를 나타내는 변수 x, y를 계속 갱신하면서 2차원 배열을 탐색하는 전형적인 시뮬레이션 문제입니다.

결론 요약 (CodeUp 기초 100제 완주)

완전 정복: 1097~1099번은 2차원 배열의 인덱스 조작, 좌표 이동, 조건에 따른 시뮬레이션을 모두 포함하는 종합 문제입니다.
좌표계 이해: 행(x)과 열(y)의 개념, 그리고 방향(가로/세로)에 따라 어떤 인덱스가 변하는지를 정확히 이해해야 합니다.
로직 구현력: "오른쪽 우선, 안 되면 아래"와 같은 말로 된 규칙을 if-else 코드로 정확히 옮기는 능력이 길러졌습니다.
기초 완성: 여기까지 스스로 풀 수 있다면 C언어의 문법(변수, 조건문, 반복문, 배열) 활용 능력은 충분히 갖춰졌습니다.
다음 단계: 이제 자료구조(스택, 큐)나 더 복잡한 알고리즘(탐색, 정렬)을 학습하며 실력을 확장해 나갈 차례입니다. 고생하셨습니다!

[CodeUp] C언어 기초 100제 풀이 (1093번 ~ 1096번)

idea8590 — Wed, 4 Feb 2026 22:35:43 +0900

1093 : [기초-1차원배열] 이상한 출석 번호 부르기 1

문제 설명 정보 선생님은 수업을 시작하기 전에 이상한 출석을 부른다. 선생님은 출석부상에 있는 학생들의 번호를 무작위(랜덤)로 부르는데, 각 번호(1 ~ 23)가 불린 횟수를 각각 출력해보자.

(참고: 학생 번호는 1번부터 23번까지 있고, 선생님은 같은 번호를 여러 번 부를 수 있다.)

입력 첫 번째 줄에 출석 번호를 부른 횟수 n이 입력된다. (1 <= n <= 10000) 두 번째 줄에 무작위로 부른 n개의 번호(1 ~ 23)가 공백을 두고 순서대로 입력된다.

출력 1번부터 23번까지 각 번호가 불린 횟수를 순서대로 공백으로 구분하여 한 줄로 출력한다.

소스 코드

#include <stdio.h>

int main() {
    int n, i, t;
    int a[24] = {0}; // 1번~23번 인덱스를 편하게 쓰기 위해 크기를 24로 잡고 0으로 초기화

    scanf("%d", &n); // 부른 횟수 입력

    for(i = 1; i <= n; i++) {
        scanf("%d", &t); // 부른 번호를 입력받음
        a[t] = a[t] + 1; // 해당 번호(t)의 카운트를 1 증가
    }

    for(i = 1; i <= 23; i++) {
        printf("%d ", a[i]); // 1번부터 23번까지 불린 횟수 출력
    }

    return 0;
}

예시 입력 / 출력

[입력]
10
1 3 2 2 5 6 7 4 5 9

[출력]
1 2 1 1 2 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0

문제 해설 '빈도수 세기' 문제입니다.

입력받은 번호 자체를 **배열의 인덱스(주소)**로 사용하는 것이 핵심입니다.
scanf("%d", &t)로 번호 t를 입력받으면, a[t] 값을 증가시켜서 그 번호가 몇 번 나왔는지 기록합니다.

1094 : [기초-1차원배열] 이상한 출석 번호 부르기 2

문제 설명 정보 선생님은 수업을 시작하기 전에 이상한 출석을 부른다. 학생들의 얼굴과 이름을 빨리 익히기 위해 번호를 무작위(랜덤)로 부르는데, 영일이는 선생님이 부른 번호들을 기억하고 있다가 거꾸로 불러보는 것을 해보고 싶어졌다.

출석 번호를 n번 무작위로 불렀을 때, 부른 번호를 거꾸로 출력해 보자.

입력 첫 번째 줄에 번호를 부른 횟수 n이 입력된다. (1 <= n <= 10000) 두 번째 줄에 n개의 랜덤 번호(1 ~ 23)가 공백을 두고 순서대로 입력된다.

출력 출석을 부른 번호 순서를 바꾸어 공백을 두고 출력한다.

소스 코드

#include <stdio.h>

int main() {
    int n, i;
    int k[10000]; // 번호를 최대 10000개까지 부를 수 있으므로 넉넉하게 선언

    scanf("%d", &n); // 횟수 입력

    // 1. 번호 순서대로 배열에 저장
    for(i = 1; i <= n; i++) {
        scanf("%d", &k[i]);
    }

    // 2. 뒤에서부터 거꾸로 출력
    for(i = n; i >= 1; i--) { // i를 n부터 1까지 줄여나감
        printf("%d ", k[i]);
    }

    return 0;
}

예시 입력 / 출력

[입력]
10
10 4 2 3 6 6 7 9 8 5

[출력]
5 8 9 7 6 6 3 2 4 10

문제 해설 '배열의 역순 출력' 문제입니다.

데이터를 입력받는 즉시 출력하는 것이 아니라, 일단 배열에 모두 저장해야 합니다.
저장이 끝난 후, 반복문의 인덱스 i를 n(마지막)에서 시작하여 1(처음)까지 감소시키며(i--) 출력합니다.

1095 : [기초-1차원배열] 이상한 출석 번호 부르기 3

문제 설명 정보 선생님은 오늘도 이상한 출석을 부른다. 영일이는 오늘도 다른 생각을 하다가 선생님이 부른 번호 중 가장 빠른 번호가 무엇이었는지 깨닫지 못했다.

출석 번호를 n번 무작위로 불렀을 때, 가장 빠른 번호를 출력해 보자.

입력 첫 번째 줄에 번호를 부른 횟수 n이 입력된다. (1 <= n <= 10000) 두 번째 줄에 n개의 랜덤 번호(1 ~ 23)가 공백을 두고 순서대로 입력된다.

출력 가장 빠른 번호를 출력한다.

소스 코드

#include <stdio.h>

int main() {
    int n, i, t;
    int min = 24; // 가장 빠른 번호(최솟값)를 찾기 위해, 나올 수 없는 큰 수로 초기화

    scanf("%d", &n);

    for(i = 1; i <= n; i++) {
        scanf("%d", &t);
        
        // 입력받은 번호(t)가 현재 알고 있는 최솟값(min)보다 작으면 갱신
        if(t < min) {
            min = t;
        }
    }

    printf("%d", min);

    return 0;
}

예시 입력 / 출력

[입력]
10
10 4 2 3 6 6 7 9 8 5

[출력]
2

문제 해설 '최솟값(Minimum Value) 찾기' 문제입니다.

min 변수를 처음에 아주 큰 값(여기선 24)으로 설정해 둡니다.
새로운 번호가 들어올 때마다 min과 비교하여, 더 작은 숫자가 나타나면 그 숫자를 min에 저장합니다.
반복문이 끝나면 min에는 가장 작은 숫자만 남게 됩니다.

1096 : [기초-2차원배열] 바둑판에 흰 돌 놓기

문제 설명 기숙사 생활을 하는 학교에서 어떤 금요일(전원 귀가일)에는 모두 집으로 귀가를 한다. 오랜만에 집에 간 영일이는 아버지와 함께 두던 바둑을 다시 두고 싶어졌다. 하지만 바둑판은 19줄 * 19줄이고, 바둑알은 너무 많아 챙기기가 귀찮았다.

낯선 바둑판을 준비해 둔 아버지는, 바둑판(19 * 19)에 n개의 흰 돌을 놓는다고 할 때, n개의 흰 돌이 놓인 오목판의 상태를 출력하는 프로그램을 작성해보자.

(참고: 바둑판은 가로, 세로 19줄로 되어 있다. 좌표는 (1, 1)부터 (19, 19)까지이다.)

입력 바둑판에 올려 놓을 흰 돌의 개수(n)가 첫 줄에 입력된다. 둘째 줄 부터 n+1 번째 줄까지 힌 돌을 놓을 좌표(x, y)가 n줄 입력된다. (n은 10이하의 자연수, x, y 좌표는 1 ~ 19 사이의 정수)

출력 흰 돌이 올려진 바둑판의 상황을 출력한다. 흰 돌이 있는 곳은 1, 없는 곳은 0으로 출력하고, 각 줄의 숫자는 공백으로 띄워 출력한다.

소스 코드

#include <stdio.h>

int main() {
    int n, i, j, x, y;
    int board[20][20] = {0}; // 1~19 인덱스를 쓰기 위해 20x20 크기로 선언 (0으로 초기화)

    scanf("%d", &n); // 놓을 돌의 개수

    // 1. 돌 놓기 (입력받은 좌표를 1로 변경)
    for(i = 1; i <= n; i++) {
        scanf("%d %d", &x, &y);
        board[x][y] = 1; 
    }

    // 2. 바둑판 전체 출력 (19x19)
    for(i = 1; i <= 19; i++) {       // 행 반복
        for(j = 1; j <= 19; j++) {   // 열 반복
            printf("%d ", board[i][j]);
        }
        printf("\n"); // 한 줄 출력이 끝나면 줄바꿈
    }

    return 0;
}

예시 입력 / 출력

[입력]
5
1 1
2 2
3 3
4 4
5 5

[출력] (실제로는 19줄이 출력됨)
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
... (이하 생략)

문제 해설 **'2차원 배열'**을 활용하는 문제입니다.

board[20][20]으로 선언하여 19x19 격자를 만듭니다.
입력받은 좌표 (x, y)에 해당하는 배열의 위치 board[x][y]에 1을 저장합니다.
출력할 때는 이중 반복문(Double Loop)을 사용하여 i는 1~19(세로줄), j는 1~19(가로줄)를 순회하며 바둑판의 상태를 출력합니다.

[CodeUp] C언어 기초 100제 풀이 (1089번 ~ 1092번)

idea8590 — Wed, 4 Feb 2026 22:04:07 +0900

CodeUp 기초 100제 중 1089번부터 1092번까지는 수열(Sequence)의 규칙성을 구현하고, 반복문을 활용해 최소공배수(LCM)와 같은 수학적 문제를 해결하는 구간입니다.

이 단계에서는 단순히 반복하는 것을 넘어, 숫자가 변하는 규칙(등차, 등비)을 코드로 옮기고, 숫자가 급격히 커질 때 자료형(long long)을 선택하는 감각을 익혀야 합니다.

1089 : [기초-종합] 수 나열하기1 (등차수열)

시작 값(a), 등차(d), 몇 번째인지(n)가 주어질 때, n번째 수를 구하는 문제입니다. (예: 1, 4, 7, 10... 처럼 3씩 커지는 수열)

소스 코드

#include <stdio.h>

int main() {
    int a, d, n;
    int result;

    scanf("%d %d %d", &a, &d, &n);

    // 공식 활용: 시작값 + (등차 * (n-1번))
    result = a + d * (n - 1); 

    printf("%d", result);

    return 0;
}

예시 입력 / 출력

[입력]
1 3 5

[출력]
13

문제 해설 두 가지 방법으로 풀 수 있습니다.

반복문 사용: for문을 n-1번 돌면서 계속 d를 더해주는 방법.
수학 공식 사용(권장): 등차수열의 일반항 공식을 사용하면 반복문 없이 한 번에 계산할 수 있어 훨씬 효율적입니다.
- 공식: 시작값 + 등차 * (횟수 - 1)
- n-1을 곱하는 이유는 첫 번째 숫자는 이미 정해져 있고, 두 번째 숫자부터 d가 더해지기 때문입니다.

1090 : [기초-종합] 수 나열하기2 (등비수열)

시작 값(a), 등비(r), 몇 번째인지(n)가 주어질 때, n번째 수를 구하는 문제입니다. (예: 2, 4, 8, 16... 처럼 2배씩 커지는 수열)

소스 코드

#include <stdio.h>

int main() {
    long long a, r, n; // 등비수열은 값이 기하급수적으로 커지므로 long long 필수
    int i;

    scanf("%lld %lld %lld", &a, &r, &n);

    for(i = 1; i < n; i++) { // n-1번 반복
        a = a * r; // 계속해서 r을 곱해나감
    }

    printf("%lld", a);

    return 0;
}

예시 입력 / 출력

[입력]
2 3 7

[출력]
1458

문제 해설 이 문제의 핵심은 자료형의 선택입니다.

등비수열은 숫자가 아주 빠르게 커집니다. 예를 들어 2를 30번만 곱해도 10억이 넘고, 조금만 더 커지면 int형 범위(약 21억)를 가볍게 초과합니다.
따라서 반드시 long long 자료형을 사용해야 오버플로우(Overflow) 오류 없이 정답을 맞힐 수 있습니다.
n-1번 반복하며 값을 계속 곱해줍니다.

1091 : [기초-종합] 수 나열하기3 (혼합 수열)

이전 수에 m을 곱하고 d를 더하는 규칙을 가진 수열의 n번째 수를 구하는 문제입니다. (예: 값 = 값 * m + d)

소스 코드

#include <stdio.h>

int main() {
    long long a, m, d, n; // 계산 결과가 커질 수 있으므로 long long 사용
    int i;

    scanf("%lld %lld %lld %lld", &a, &m, &d, &n);

    for(i = 1; i < n; i++) {
        a = a * m + d; // 문제에서 제시한 공식 그대로 적용
    }

    printf("%lld", a);

    return 0;
}

예시 입력 / 출력

[입력]
1 -2 1 8

[출력]
-85

문제 해설 1090번의 심화 버전입니다. 곱하기와 더하기가 섞여 있어 수학 공식으로 한 번에 풀기는 까다롭습니다.

이럴 때는 반복문을 사용하는 것이 가장 확실합니다.
시작 값 a에 대해 m을 곱하고 d를 더하는 과정을 n-1번 반복해서 갱신하면 됩니다.
이 문제 역시 값이 매우 커질 수 있으므로 long long 사용이 필수입니다.

1092 : [기초-종합] 함께 문제 푸는 날

세 명의 학생이 각각 3일마다, 7일마다, 9일마다 방문한다고 할 때, 세 명이 동시에 방문하는 날은 며칠 뒤인지 구하는 문제입니다. (최소공배수 문제)

소스 코드

#include <stdio.h>

int main() {
    int a, b, c;
    int day = 1; // 1일차부터 시작해서 하루씩 증가시킬 예정

    scanf("%d %d %d", &a, &b, &c);

    // 세 명 모두의 주기로 나누어 떨어질 때까지 반복 (하나라도 안 나누어 떨어지면 계속)
    while(day % a != 0 || day % b != 0 || day % c != 0) {
        day++; // 날짜를 하루 증가
    }

    printf("%d", day);

    return 0;
}

예시 입력 / 출력

[입력]
3 7 9

[출력]
63

문제 해설 수학적으로는 최소공배수(LCM)를 구하는 문제입니다. 하지만 코딩에서는 브루트 포스(Brute Force, 무식하게 다 해보기) 방식으로 아주 쉽게 풀 수 있습니다.

day를 1부터 시작합니다.
while문의 조건: "셋 중 한 명이라도 방문하지 않는 날이면 계속해라"
- || (OR 연산자)를 사용합니다.
- day % a != 0: a가 안 오는 날 또는
- day % b != 0: b가 안 오는 날 또는
- day % c != 0: c가 안 오는 날
이 반복문이 깨지는(false) 순간은 셋 다 나머지가 0인 날(모두 오는 날) 뿐입니다. 그때의 day가 정답입니다.

핵심 요약

등차수열 (1089): 일정한 수를 더하는 규칙. **공식(a + (n-1)*d)**을 쓰면 빠릅니다.
등비수열 (1090): 일정한 수를 곱하는 규칙. 값이 폭발적으로 커지므로 long long 자료형이 필수입니다.
수열의 구현: 복잡한 규칙이 있다면, for문을 이용해 변수 값을 차근차근 갱신(update)해 나가는 시뮬레이션 방식이 좋습니다.
최소공배수 (1092): 1부터 1씩 증가시키며 모든 수로 나누어떨어지는지 확인하는 while 반복문으로 해결할 수 있습니다.

[CodeUp] C언어 기초 100제 풀이 (1085번 ~ 1088번)

idea8590 — Wed, 4 Feb 2026 06:42:51 +0900

CodeUp 기초 100제 중 1085번부터 1088번까지는 데이터의 저장 용량을 계산하는 실생활 응용 문제와, 반복문의 흐름을 강제로 제어하는 제어문(break, continue)을 익히는 구간입니다.

앞선 문제들이 반복문을 '어떻게 돌리느냐'에 집중했다면, 이번 단계에서는 큰 데이터를 처리할 때의 자료형 선택과 반복문을 중간에 멈추거나 건너뛰는 정교한 제어를 배울 수 있습니다.

1085 : [기초-종합] 소리 파일 저장용량 계산하기

소리를 저장할 때 필요한 저장 공간(MB)을 계산하는 문제입니다. CD 음질(44.1KHz, 16bit, 2channel) 등의 오디오 데이터 크기를 직접 계산해 봅니다.

소스 코드

#include <stdio.h>

int main() {
    long long h, b, c, s; // 입력값이 곱해지면 매우 커지므로 long long 사용 권장
    double total_mb;      // 최종 결과는 소수점이므로 double형 사용

    scanf("%lld %lld %lld %lld", &h, &b, &c, &s);

    // 비트(bit) 단위 총합 계산 후 -> 바이트(8) -> 킬로바이트(1024) -> 메가바이트(1024)로 나눔
    // 나눗셈을 위해 8.0 등으로 나누어 실수 연산 유도
    total_mb = (h * b * c * s) / 8.0 / 1024 / 1024;

    printf("%.1lf MB", total_mb); // 소수점 첫째 자리까지 출력

    return 0;
}

예시 입력 / 출력

[입력]
44100 16 2 10

[출력]
1.7 MB

문제 해설

이 문제의 핵심은 단위 변환과 자료형의 범위(Overflow) 이해입니다.

계산 공식: h * b * c * s를 모두 곱하면 전체 '비트(bit)' 수가 나옵니다.
단위 변환:
- 8 bit = 1 Byte
- 1024 Byte = 1 KB
- 1024 KB = 1 MB 따라서 전체 비트를 8 * 1024 * 1024로 나누어야 MB 단위가 됩니다.
자료형 주의: 입력된 네 수를 곱하면 int의 범위를 넘어설 수 있습니다. 따라서 안전하게 long long을 사용하거나, 계산 과정에서 double로 캐스팅해야 정확한 값을 얻을 수 있습니다.

1086 : [기초-종합] 그림 파일 저장용량 계산하기

1085번과 유사하게, 이번에는 이미지 파일의 해상도(가로, 세로)와 비트 깊이를 이용해 저장 용량을 계산합니다.

소스 코드

#include <stdio.h>

int main() {
    long long w, h, b; // 큰 수의 곱셈을 대비해 long long 선언
    double total_mb;

    scanf("%lld %lld %lld", &w, &h, &b);

    // 가로 * 세로 * 비트수 = 총 비트
    // 8로 나누면 Byte, 1024로 나누면 KB, 다시 1024로 나누면 MB
    total_mb = (w * h * b) / 8.0 / 1024 / 1024;

    printf("%.2lf MB", total_mb); // 소수점 둘째 자리까지 출력

    return 0;
}

예시 입력 / 출력

[입력]
1024 768 24

[출력]
2.25 MB

문제 해설

소리 파일 계산과 원리는 동일합니다. 가로($w$) $\times$ 세로($h$) 픽셀에 픽셀당 비트($b$)를 곱해 전체 용량을 구합니다.

1085번은 소수점 첫째 자리(%.1lf)까지, 1086번은 소수점 둘째 자리(%.2lf)까지 출력해야 한다는 출력 형식의 차이를 주의하세요.
나누기 연산 시 8이 아니라 8.0으로 나누거나, 변수 중 하나를 실수형으로 변환해야 소수점 아래 값이 잘리지 않고 계산됩니다.

1087 : [기초-종합] 여기까지! 이제 그만~

1, 2, 3... 순서대로 계속 더해나갈 때, 그 합이 입력된 정수보다 같거나 커지는 순간 멈추고 그때까지의 합을 출력하는 문제입니다.

소스 코드

#include <stdio.h>

int main() {
    int n;
    int i, sum = 0;
    
    scanf("%d", &n);

    for(i = 1; ; i++) { // 조건식이 비어있으면 무한 루프
        sum += i;       // sum에 i를 누적해서 더함
        if(sum >= n) {  // 합계가 입력값 n보다 크거나 같아지면
            break;      // 반복문을 즉시 탈출!
        }
    }

    printf("%d", sum);

    return 0;
}

예시 입력 / 출력

[입력]
57

[출력]
66

문제 해설

break 문의 활용이 핵심입니다.

for문의 조건식을 비워두거나 while(1)을 사용하면 무한히 반복합니다.
반복문 내부에서 if문을 사용하여 "합(sum)이 입력값(n) 이상이 되었는가?"를 검사합니다.
조건이 참(True)이 되면 break를 만나 반복문을 즉시 빠져나옵니다.
주의: 출력해야 하는 값은 마지막에 더해진 숫자 i가 아니라, 누적된 합계 sum입니다.

1088 : [기초-종합] 3의 배수는 통과?

1부터 입력받은 숫자까지 출력하되, 3의 배수인 경우에는 출력하지 않고 건너뛰는 문제입니다.

소스 코드

#include <stdio.h>

int main() {
    int n, i;
    scanf("%d", &n);

    for(i = 1; i <= n; i++) {
        if(i % 3 == 0) { // i가 3의 배수라면
            continue;    // 아래 코드를 실행하지 않고, 증감식(i++)으로 이동
        }
        printf("%d ", i);
    }

    return 0;
}

예시 입력 / 출력

[입력]
10

[출력]
1 2 4 5 7 8 10

문제 해설

continue 문의 활용이 핵심입니다.

break가 반복문을 아예 깨뜨리고 나가는 것이라면, continue는 **"이번 회차만 건너뛰고 다음 회차로 넘어가라"**는 명령입니다.
i가 3으로 나누어떨어질 때(i % 3 == 0) continue가 실행되면, 그 아래에 있는 printf 함수는 실행되지 않고 바로 i++로 넘어가게 됩니다.
결과적으로 3, 6, 9... 등 3의 배수는 화면에 출력되지 않습니다.

핵심 요약

큰 수의 연산 (Overflow 방지): 연산 결과가 int 범위(약 21억)를 넘을 것으로 예상될 때는 long long 자료형을 쓰거나 double 형변환을 적절히 사용해야 합니다.
단위 변환: 컴퓨터 저장 단위는 $1024$배씩 커진다는 점을 기억하세요 (Byte $\rightarrow$ KB $\rightarrow$ MB).
반복문 제어:
- break: 반복문을 완전히 종료하고 탈출합니다. (목표 달성 시 멈출 때 사용)
- continue: 남은 코드를 무시하고 다음 반복으로 넘어갑니다. (특정 조건만 제외할 때 사용)

[CodeUp] C언어 기초 100제 풀이 (1081번 ~ 1084번)

idea8590 — Tue, 3 Feb 2026 23:42:47 +0900

CodeUp 기초 100제 중 1081번부터 1084번까지는 중첩 반복문(Nested Loop)을 집중적으로 다루는 구간입니다. 이전 단계에서 변수 하나를 반복시키는 법을 배웠다면, 이번에는 '반복문 안에 또 다른 반복문'을 넣어 마치 시계 톱니바퀴처럼 여러 변수를 제어하는 기술을 익히게 됩니다.

1081 : [기초-종합] 주사위를 2개 던지면? 1부터 n까지, 1부터 m까지 숫자가 적힌 서로 다른 주사위 2개를 던졌을 때, 나올 수 있는 모든 경우의 수를 출력해보자.

소스 코드

#include <stdio.h>

int main() {
    int n, m;
    int i, j;
    scanf("%d %d", &n, &m);

    for(i = 1; i <= n; i++) {       // 첫 번째 주사위 (바깥쪽 반복문)
        for(j = 1; j <= m; j++) {   // 두 번째 주사위 (안쪽 반복문)
            printf("%d %d\n", i, j);
        }
    }

    return 0;
}

예시 입력 / 출력

[입력]
2 3

[출력]
1 1
1 2
1 3
2 1
2 2
2 3

문제 해설 이 문제는 중첩 반복문의 작동 원리를 이해하는 가장 기초적인 예제입니다. 바깥쪽 반복문의 변수 i가 1일 때, 안쪽 반복문의 변수 j는 1부터 m까지 모든 숫자를 순회합니다. j의 반복이 끝나면 비로소 i가 2가 되고, 다시 j는 1부터 시작합니다. 이렇게 서로 다른 두 개의 주기가 맞물려 돌아가며 모든 경우의 수(n * m가지)를 빠짐없이 출력하게 됩니다.

1082 : [기초-종합] 16진수 구구단? 16진수(0, 1, 2... 9, A, B, C, D, E, F)를 배운 뒤, 16진수 구구단 B단을 출력해보자. 입력은 16진수로 한 글자(A~F)가 입력된다.

소스 코드

#include <stdio.h>

int main() {
    int n, i;
    scanf("%X", &n); // 16진수 대문자 형태로 입력 받기

    for(i = 1; i < 16; i++) { // 16진수는 1부터 F(15)까지 곱함
        printf("%X*%X=%X\n", n, i, n * i); // 결과도 16진수 대문자로 출력
    }

    return 0;
}

예시 입력 / 출력

[입력]
B

[출력]
B*1=B
B*2=16
B*3=21
...
B*C=84
B*D=8F
B*E=9A
B*F=A5

문제 해설 16진수(Hexadecimal) 연산을 다룰 때 서식 지정자의 역할을 이해하는 것이 핵심입니다. 정수를 입력받을 때 %d 대신 %X를 사용하면 입력된 알파벳(A~F)을 자동으로 해당 정수 값(10~15)으로 변환하여 저장합니다. 출력할 때도 마찬가지로 %X를 사용하면 연산된 정수 값을 다시 16진수 대문자 형태로 보여줍니다. 반복문은 16진수의 끝인 15(F)까지 수행하면 됩니다.

1083 : [기초-종합] 3 6 9 게임의 왕이 되자 3 6 9 게임을 하던 영일이는 3 6 9 게임에서 잦은 실수로 계속해서 벌칙을 받게 되었다. 3 6 9 게임의 왕이 되기 위해 369 게임을 자동으로 해주는 프로그램을 작성해보자. (단, 10보다 작은 정수 1개가 입력된다.)

소스 코드

#include <stdio.h>

int main() {
    int n, i;
    scanf("%d", &n);

    for(i = 1; i <= n; i++) {
        if(i == 3 || i == 6 || i == 9) // 3 또는 6 또는 9인 경우
            printf("X ");
        else
            printf("%d ", i); // 그 외의 숫자는 그대로 출력
    }

    return 0;
}

예시 입력 / 출력

[입력]
9

[출력]
1 2 X 4 5 X 7 8 X

문제 해설 반복문 내에서 특정 조건에 따라 출력을 다르게 하는 분기 처리 문제입니다. 1부터 입력받은 n까지 숫자를 증가시키며 반복하되, if 조건문을 사용하여 현재 숫자 i가 3, 6, 9 중 하나라도 해당되는지 검사합니다. 이때 '또는'을 의미하는 논리 연산자 || (OR)를 사용하여 조건을 연결하는 것이 중요합니다. 조건이 참이면 "X"를, 거짓이면 숫자를 출력합니다.

1084 : [기초-종합] 빛 섞어 색 만들기 빨강(r), 초록(g), 파랑(b) 각 빛의 강약에 따른 가짓수(0 ~ n-1)가 주어질 때, 주어진 rgb 빛들을 다르게 섞어 만들 수 있는 모든 경우의 조합(r g b)과 총 가짓수를 계산해보자.

소스 코드

#include <stdio.h>

int main() {
    int r, g, b;
    int i, j, k;
    int count = 0; // 경우의 수를 세기 위한 변수 (초기화 필수)
    
    scanf("%d %d %d", &r, &g, &b);

    for(i = 0; i < r; i++) {          // 빨강(r) 루프
        for(j = 0; j < g; j++) {      // 초록(g) 루프
            for(k = 0; k < b; k++) {  // 파랑(b) 루프
                printf("%d %d %d\n", i, j, k);
                count++; // 출력이 일어날 때마다 카운트 증가
            }
        }
    }
    
    printf("%d", count); // 누적된 총 가짓수 출력

    return 0;
}

예시 입력 / 출력

문제 해설 반복문이 세 번 겹쳐 있는 '3중 for문' 문제입니다. 가장 안쪽에 있는 k 반복문이 가장 빠르게 회전하고, 그 다음 j, 가장 바깥쪽인 i 순서로 값이 변합니다. 이는 디지털 시계가 초, 분, 시 순서로 올라가는 원리와 완벽하게 동일합니다. 모든 색상의 조합을 출력할 때마다 count 변수를 1씩 증가시켜서, 반복문이 모두 끝난 뒤에 전체 경우의 수를 출력하면 됩니다.

핵심 요약

중첩 반복문의 흐름: 바깥쪽 루프가 1번 실행될 때, 안쪽 루프는 자신의 조건만큼 전체를 반복합니다.
서식 지정자의 활용: 16진수 입출력 시 %X를 사용하면 복잡한 변환 과정 없이 알파벳과 숫자를 매핑할 수 있습니다.
논리 연산자: 여러 조건 중 하나만 만족해도 될 때는 || (OR 연산자)를 사용하여 조건을 묶어줍니다.
카운팅(Counting): 반복문 안에서 특정 사건(출력 등)이 발생할 때마다 변수를 증가(count++)시키면 전체 횟수를 쉽게 구할 수 있습니다.

[CodeUp] C언어 기초 100제 풀이 (1076번 ~ 1080번)

idea8590 — Tue, 3 Feb 2026 23:24:17 +0900

CodeUp 기초 100제 중 1076번부터 1080번까지는 프로그래밍의 꽃이라 불리는 반복문(Iteration)의 심화 및 응용 단계입니다. 앞선 단계에서 단순한 반복을 배웠다면, 이번 구간에서는 문자(char)를 순서대로 나열하거나, 특정 조건에 도달할 때까지 합계(Sum)를 누적하는 등 보다 논리적이고 동적인 흐름 제어를 연습하게 됩니다.

컴퓨터가 인간보다 압도적으로 뛰어난 점은 지치지 않고 수만 번, 수억 번의 연산을 정확하게 반복할 수 있다는 것입니다. 이 구간의 문제들은 for, while, do-while 문을 상황에 맞게 골라 쓰는 능력을 기르고, 반복문 내부에서 if문과 break를 조합하여 원하는 시점에 정확히 멈추는 정교한 제어 능력을 키우는 데 목적이 있습니다. 알고리즘 문제 해결의 핵심인 '누적 연산'과 '임계값(Threshold) 판단'의 기초가 되므로 확실히 익혀두어야 합니다.

1076 : [기초-반복실행구조] 문자 1개 입력받아 알파벳 출력하기 영문자 1개(a ~ z)를 입력받아, 'a'부터 입력받은 문자까지 순서대로 공백을 두고 출력해보자.

소스 코드

#include <stdio.h>

int main() {
    char c, t = 'a'; // 시작 문자는 'a'로 초기화
    scanf("%c", &c);

    do {
        printf("%c ", t);
        t++; // 문자 값을 1 증가 (a -> b -> c ...)
    } while(t <= c); // 현재 문자가 입력된 문자보다 작거나 같을 동안 반복

    return 0;
}

예시 입력 / 출력

[입력]
f

[출력]
a b c d e f

문제 해설 컴퓨터 내부에서 문자(char)는 고유한 정수 값(아스키 코드)으로 저장되어 처리됩니다. 그렇기 때문에 문자 변수에도 숫자처럼 증감 연산자(t++)를 사용하여 다음 알파벳으로 넘길 수 있고, 비교 연산자(t <= c)를 통해 순서를 비교할 수도 있습니다. 이 코드는 do-while문을 사용하여 일단 문자를 먼저 출력하고 증가시킨 뒤, 입력받은 문자에 도달했는지 검사하여 반복 여부를 결정합니다.

1077 : [기초-반복실행구조] 정수 1개 입력받아 그 수까지 출력하기 정수 1개(n)를 입력받아 0부터 n까지의 정수를 한 줄에 하나씩 출력해보자.

소스 코드

#include <stdio.h>

int main() {
    int n, i;
    scanf("%d", &n);

    for(i = 0; i <= n; i++) { // i는 0부터 n까지 1씩 증가
        printf("%d\n", i);
    }

    return 0;
}

예시 입력 / 출력

[입력]
4

[출력]
0
1
2
3
4

문제 해설 반복의 시작점(0)과 끝점(n), 그리고 증가폭(1씩 증가)이 명확하게 정해져 있는 경우에는 for문을 사용하는 것이 가장 구조적이고 코드가 깔끔합니다. for(초기화; 조건식; 증감식)의 구조를 활용하여 변수 i가 0부터 시작해서 n이 될 때까지 1씩 커지며 내부의 출력문을 반복 실행하게 됩니다.

1078 : [기초-종합] 짝수 합 구하기 정수 1개를 입력받아 1부터 그 수까지 짝수의 합을 구해보자.

소스 코드

#include <stdio.h>

int main() {
    int n, i, sum = 0; // 합을 담을 변수는 반드시 0으로 초기화
    scanf("%d", &n);

    for(i = 1; i <= n; i++) {
        if(i % 2 == 0) { // i가 짝수라면
            sum += i;    // sum에 i를 더해서 누적
        }
    }
    
    printf("%d", sum);

    return 0;
}

예시 입력 / 출력

[입력]
5

[출력]
6

문제 해설 값을 계속해서 더해나가는 '누적 합(Accumulation)'을 구하는 문제입니다. 합계 결과를 담을 변수(sum)는 처음에 쓰레기 값이 들어있을 수 있으므로 반드시 선언과 동시에 0으로 초기화해야 합니다. 반복문 안에서 if(i % 2 == 0) 조건을 이용해 짝수일 때만 sum 변수에 현재 숫자 i를 더해주는 방식으로 짝수의 합만 골라낼 수 있습니다.

1079 : [기초-종합] 원하는 문자가 입력될 때까지 반복 출력하기 문자들이 공백으로 구분되어 입력될 때, 'q'가 입력될 때까지 입력된 문자를 줄을 바꿔 한 줄에 하나씩 출력하고, 'q'가 입력되면 그 문자까지 출력하고 종료해보자.

소스 코드

#include <stdio.h>

int main() {
    char c;
    
    while(1) { // 조건이 1(참)이므로 무한 루프
        scanf(" %c", &c); // 공백을 건너뛰고 문자 입력받기
        printf("%c\n", c);
        
        if(c == 'q') break; // 입력받은 문자가 'q'면 반복 종료
    }

    return 0;
}

예시 입력 / 출력

[입력]
x b k d l q g a c

[출력]
x
b
k
d
l
q

문제 해설 입력이 언제 끝날지 횟수를 알 수 없을 때는 while(1)을 사용하여 무한 루프를 만듭니다. 반복문 내부에서 입력을 받고 문자를 출력한 뒤, if(c == 'q') break; 문장을 통해 종료 조건이 충족되면 즉시 반복문을 탈출하도록 설계합니다. scanf 사용 시 %c 앞에 공백을 한 칸 넣어주면(" %c") 입력 버퍼에 남아있는 엔터나 공백을 무시하고 문자만 정확히 읽어올 수 있습니다.

1080 : [기초-종합] 언제까지 더해야 할까? 1, 2, 3... 을 계속 더해 나갈 때, 그 합이 입력한 정수(target)보다 같거나 커지는 시점의 마지막 더한 숫자를 출력해보자.

소스 코드

#include <stdio.h>

int main() {
    int target, i = 0, sum = 0;
    scanf("%d", &target);

    while(sum < target) { // 합이 목표값보다 작은 동안 반복
        i++;       // 숫자 증가 (1, 2, 3...)
        sum += i;  // 합계 누적
    }

    printf("%d", i); // 합이 target 이상이 되었을 때의 마지막 숫자 출력

    return 0;
}

예시 입력 / 출력

[입력]
55

[출력]
10

문제 해설 조건에 따라 반복을 멈추는 '임계값(Threshold)' 처리 문제입니다. while(sum < target) 조건은 "합계가 아직 목표값보다 작다면 계속 더하라"는 의미입니다. 반복하다가 sum이 target과 같아지거나 커지는 순간 조건이 거짓이 되어 반복문이 종료됩니다. 이때 마지막으로 더했던 숫자가 i에 저장되어 있으므로, 반복 종료 후 i를 출력하면 정답이 됩니다.

핵심 요약

문자 연산: char 타입은 정수처럼 **증감(t++)이나 비교(t <= c) 연산이 가능하여 알파벳 순서대로 처리가 가능합니다.
초기화 필수: 합계를 구하는 누적 변수(sum)는 선언 시 반드시 0으로 초기화해야 엉뚱한 값이 더해지는 것을 막을 수 있습니다.
무한 루프와 break: 횟수를 모를 때는 while(1)을 쓰고, 내부에서 특정 조건(if) 만족 시 break;로 빠져나오는 패턴이 매우 중요합니다.
조건의 순서: 1080번 문제처럼 변수 증가(i++)와 합계 누적(sum += i)의 순서, 그리고 조건식(sum < target) 설정이 결과값에 큰 영향을 미치므로 논리적인 순서를 잘 따져야 합니다.

[CodeUp] C언어 기초 100제 풀이 (1071번 ~ 1075번)

idea8590 — Tue, 3 Feb 2026 22:45:00 +0900

CodeUp 기초 100제 중 1071번부터 1075번까지는 **반복문(Iteration Structure)**의 기초를 다룹니다. 특히 이 구간에서는 C언어의 초기 문법인 goto문을 통한 무조건 분기와, 보다 구조적인 while문의 사용법을 익히게 됩니다. 반복문은 프로그램이 특정 작업을 자동으로 되풀이하게 만드는 핵심 요소이므로, 조건 검사와 카운트다운 로직의 흐름을 머릿속으로 그려보는 것이 중요합니다.

1071 : [기초-반복실행구조] 0 입력될 때까지 무한 출력하기

정수가 순서대로 입력될 때, 0이 아니면 입력된 정수를 출력하고, 0이 입력되면 출력을 중단해보자. (이 문제는 goto 명령어를 익히기 위해 설계되었습니다.)

소스 코드

#include <stdio.h>

int main() {
    int n;
reload: // 레이블 정의: 이동할 위치를 표시
    scanf("%d", &n);
    
    if(n != 0) {
        printf("%d\n", n);
        goto reload; // reload 레이블로 이동하여 코드 다시 실행
    }

    return 0;
}

예시 입력 / 출력

[입력]
7 4 2 3 0 1 5

[출력]
7
4
2
3

문제 해설 goto문은 프로그램의 흐름을 지정된 '레이블(Label, 위 코드의 reload:)' 위치로 무조건 건너뛰게 만듭니다. scanf로 숫자를 받고, 그 숫자가 0이 아니라면 printf를 실행한 뒤 다시 reload 위치로 돌아가 입력을 받는 과정을 반복합니다. 0이 입력되면 if문의 조건이 거짓이 되어 goto를 만나지 않고 프로그램이 종료됩니다. (현대 프로그래밍에서는 가독성을 위해 goto 사용을 지양하지만, 반복의 원리를 이해하는 데 도움이 됩니다.)

1072 : [기초-반복실행구조] 정수 입력받아 계속 출력하기

입력받을 정수의 개수(n)가 주어지고, 그 뒤에 n개의 정수가 입력될 때, 입력된 정수들을 순서대로 출력해보자.

소스 코드

#include <stdio.h>

int main() {
    int n, m;
    scanf("%d", &n); // 정수의 개수 입력

reget: // 레이블
    scanf("%d", &m);
    printf("%d\n", m);
    
    if(--n != 0) goto reget; // n을 1씩 감소시키며 0이 아니면 반복

    return 0;
}

예시 입력 / 출력

[입력]
3
1 2 5

[출력]
1
2
5

문제 해설 반복 횟수가 정해져 있는 경우입니다. 처음에 개수 n을 입력받고, goto문을 이용해 숫자를 입력받고 출력하는 과정을 반복합니다. 핵심은 if(--n != 0) 부분인데, 이는 "n을 1 감소시킨 뒤 그 값이 0이 아니면"이라는 뜻입니다. 즉, 입력받은 개수만큼 반복을 수행한 뒤 n이 0이 되면 반복을 멈추게 됩니다.

1073 : [기초-반복실행구조] 0 입력될 때까지 무한 출력하기 2

0이 입력될 때까지 입력된 정수를 출력해보자. (1071번과 같지만, 이번에는 goto 대신 while문이나 for문을 사용하는 것이 일반적입니다.)

소스 코드

#include <stdio.h>

int main() {
    int n = 1; // 0이 아닌 초기값 설정 (반복 진입을 위해)
    
    while(n != 0) {
        scanf("%d", &n);
        if(n != 0) printf("%d\n", n);
    }

    return 0;
}

또는 더 간결한 방식:

#include <stdio.h>
int main() {
    int n;
    while(1) { // 무한 루프
        scanf("%d", &n);
        if(n == 0) break; // 0이면 반복문 탈출
        printf("%d\n", n);
    }
    return 0;
}

예시 입력 / 출력

[입력]
7 4 2 3 0 1 5

[출력]
7
4
2
3

문제 해설 while(조건식)은 조건식이 '참(True)'인 동안 {} 안의 내용을 계속 반복합니다. 첫 번째 방식은 변수 n이 0이 아닌 동안 계속 입력을 받는 방식이고, 두 번째 방식은 while(1)로 무한 루프를 만든 뒤, 입력값이 0일 때 break; 문을 사용하여 반복문을 즉시 빠져나오는 방식입니다. 실무에서는 break를 활용한 두 번째 방식이 자주 쓰입니다.

1074 : [기초-반복실행구조] 정수 1개 입력받아 카운트다운 출력하기 1

정수 1개(n)를 입력받아 n부터 1까지 1씩 줄여가며 한 줄에 하나씩 출력해보자. (예: 5 입력 → 5, 4, 3, 2, 1 출력)

소스 코드

#include <stdio.h>

int main() {
    int n;
    scanf("%d", &n);

    while(n > 0) { // n이 0보다 클 때만 반복
        printf("%d\n", n);
        n--; // n을 1 감소시킴
    }

    return 0;
}

예시 입력 / 출력

[입력]
5

[출력]
5
4
3
2
1

문제 해설 카운트다운의 기본 논리입니다. while(n > 0)을 통해 n이 1 이상일 때만 코드가 실행되도록 합니다. 중요한 것은 순서입니다. 먼저 현재의 n을 출력(printf)한 후에 n--(감소 연산자)를 수행해야 입력받은 수부터 1까지 차례대로 출력됩니다.

1075 : [기초-반복실행구조] 정수 1개 입력받아 카운트다운 출력하기 2

정수 1개(n)를 입력받아 (n-1)부터 0까지 1씩 줄여가며 한 줄에 하나씩 출력해보자. (예: 5 입력 → 4, 3, 2, 1, 0 출력)

소스 코드

#include <stdio.h>

int main() {
    int n;
    scanf("%d", &n);

    while(n > 0) {
        n--; // 출력을 하기 전에 먼저 감소
        printf("%d\n", n);
    }

    return 0;
}

예시 입력 / 출력

[입력]
5

[출력]
4
3
2
1
0

문제 해설 1074번과 유사하지만 출력되는 숫자의 범위가 다릅니다. 이번에는 입력된 수보다 1 작은 수부터 0까지 출력해야 하므로, 반복문 안에서 감소 연산(n--)을 출력(printf)보다 먼저 수행해야 합니다.

1074번: 출력 → 감소 (5 → 4 → ... → 1)
1075번: 감소 → 출력 (4 → 3 → ... → 0) 이처럼 코드 한 줄의 순서 차이가 결과에 큰 영향을 미치므로 실행 순서를 잘 파악해야 합니다.

핵심 요약

goto문: 레이블:과 goto 레이블;을 이용해 코드의 흐름을 자유롭게 이동시킵니다. 복잡하게 쓰면 코드가 꼬이는 '스파게티 코드'가 될 수 있어 주의해야 합니다.
while문: while(조건) 형식으로 조건이 참인 동안 코드를 반복합니다. 반복 횟수가 명확하지 않을 때(예: 0이 입력될 때까지) 주로 사용합니다.
증감 연산자(--): 반복문에서 카운트다운을 하거나 반복 횟수를 제어할 때 필수적입니다. n--는 n을 사용 후 감소, --n은 감소 후 사용의 의미를 가집니다.
반복 탈출(break): 무한 루프(while(1)) 안에서 특정 조건(if(n==0))을 만족할 때 break;를 사용하면 반복문을 즉시 종료할 수 있어 흐름 제어가 유연해집니다.

[CodeUp] C언어 기초 100제 풀이 (1066번 ~ 1070번)

idea8590 — Tue, 3 Feb 2026 22:21:19 +0900

CodeUp 기초 100제 중 1066번부터 1070번까지는 프로그램의 흐름을 제어하는 핵심 문법인 조건문(Selection Structure)을 다룹니다. if문을 사용하여 단순한 참/거짓을 판별하는 것부터, else if를 이용한 다중 분기, 그리고 switch문을 활용한 깔끔한 선택 구조까지 단계별로 연습하게 됩니다. 이 구간의 문제들은 알고리즘의 기초가 되는 논리력을 키우는 데 매우 중요하므로, 각 문법의 차이점과 사용 시기를 정확히 이해하는 것이 좋습니다.

1066 : [기초-조건/선택실행구조] 정수 3개 입력받아 짝/홀 출력하기

세 개의 정수 a, b, c를 입력받아 각 정수가 짝수(even)인지 홀수(odd)인지를 줄을 바꿔 출력해보자.

소스 코드

#include <stdio.h>

int main() {
    int a, b, c;
    scanf("%d %d %d", &a, &b, &c);

    if(a % 2 == 0) printf("even\n");
    else printf("odd\n");

    if(b % 2 == 0) printf("even\n");
    else printf("odd\n");

    if(c % 2 == 0) printf("even\n");
    else printf("odd\n");

    return 0;
}

예시 입력 / 출력

[입력]
1 2 8

[출력]
odd
even
even

문제 해설 세 개의 숫자는 서로 독립적인 값이므로, 하나의 if-else 문으로 묶지 않고 세 번의 if문을 각각 작성하여 개별적으로 판단해야 합니다. 나머지 연산자(%)를 사용하여 2로 나눈 나머지가 0이면 짝수, 아니면 홀수로 판별합니다. 각 결과를 출력한 후에는 줄 바꿈(\n)을 해주어야 출력 형식이 올바르게 유지됩니다.

1067 : [기초-조건/선택실행구조] 정수 1개 입력받아 분석하기

정수 1개를 입력받아 음(minus)/양(plus)과 짝(even)/홀(odd)을 분류하여 출력해보자.

소스 코드

#include <stdio.h>

int main() {
    int a;
    scanf("%d", &a);

    // 1. 음수/양수 판별
    if(a < 0) printf("minus\n");
    else printf("plus\n");

    // 2. 짝수/홀수 판별
    if(a % 2 == 0) printf("even\n");
    else printf("odd\n");

    return 0;
}

예시 입력 / 출력

[입력]
-2147483648

[출력]
minus
even

문제 해설 하나의 입력값에 대해 두 가지 속성(부호, 홀짝)을 모두 확인해야 하므로 조건문을 병렬로 두 번 배치합니다. 첫 번째 if문에서는 0보다 작은지(a < 0)를 확인하여 부호를 출력하고, 두 번째 if문에서는 2로 나눈 나머지(a % 2)를 확인하여 홀짝을 출력합니다. 조건을 중첩해서 쓰기보다는 이렇게 분리하는 것이 코드의 가독성을 높이고 로직을 명확하게 합니다.

1068 : [기초-조건/선택실행구조] 정수 1개 입력받아 평가 출력하기

점수(정수, 0 ~ 100)를 입력받아 평가 기준에 따라 등급(A, B, C, D)을 출력해보자. (90~100: A, 70~89: B, 40~69: C, 0~39: D)

소스 코드

#include <stdio.h>

int main() {
    int score;
    scanf("%d", &score);

    if(score >= 90) printf("A");
    else if(score >= 70) printf("B");
    else if(score >= 40) printf("C");
    else printf("D");

    return 0;
}

예시 입력 / 출력

[입력]
73

[출력]
B

문제 해설 여러 구간을 나누어 판단할 때는 if ~ else if ~ else 구조를 사용하며, 조건의 순서가 매우 중요합니다. 가장 큰 범위인 90점 이상부터 검사해야, 90점 미만인 값들만 다음 조건(70점 이상)으로 넘어가게 되어 논리 오류가 발생하지 않습니다. 마지막 else는 위의 모든 조건에 해당하지 않는 경우(40점 미만)를 처리하므로 별도의 조건식이 필요 없습니다.

1069 : [기초-조건/선택실행구조] 평가 입력받아 다르게 출력하기

영문자(A, B, C, D)를 하나 입력받아 평가 내용(best!!!, good!!, run!, slowly~)을 출력하고, 그 외의 문자는 what?을 출력해보자.

소스 코드

#include <stdio.h>

int main() {
    char grade;
    scanf("%c", &grade);

    switch(grade) {
        case 'A': printf("best!!!"); break;
        case 'B': printf("good!!"); break;
        case 'C': printf("run!"); break;
        case 'D': printf("slowly~"); break;
        default: printf("what?");
    }

    return 0;
}

예시 입력 / 출력

[입력]
A

[출력]
best!!!

문제 해설 입력값이 문자나 정수처럼 딱 떨어지는 값일 때는 if문보다 switch-case문을 사용하는 것이 훨씬 구조적이고 보기 좋습니다. 각 case 끝에는 break;를 넣어주어야 해당 코드 실행 후 switch 블록을 빠져나오게 됩니다. (없으면 아래 코드가 계속 실행됨) default:는 제시된 case 외의 모든 입력에 대해 실행되므로 예외 처리에 유용합니다.

1070 : [기초-조건/선택실행구조] 월 입력받아 계절 출력하기

월이 입력될 때 계절 이름이 출력되도록 해보자. (12, 1, 2: winter / 3, 4, 5: spring / 6, 7, 8: summer / 9, 10, 11: fall)

소스 코드

#include <stdio.h>

int main() {
    int month;
    scanf("%d", &month);

    switch(month) {
        case 12:
        case 1:
        case 2:
            printf("winter");
            break;
        case 3:
        case 4:
        case 5:
            printf("spring");
            break;
        case 6:
        case 7:
        case 8:
            printf("summer");
            break;
        case 9:
        case 10:
        case 11:
            printf("fall");
            break;
    }

    return 0;
}

예시 입력 / 출력

[입력]
12

[출력]
winter

문제 해설 switch문의 'Fall-through(흘러내림)' 기능을 활용하면 여러 입력값에 대해 동일한 결과를 간결하게 처리할 수 있습니다. case 12와 case 1에 실행 문장과 break가 없으므로, 해당 값이 입력되면 case 2까지 내려가서 "winter"를 출력하게 됩니다. 반복되는 코드를 줄일 수 있어 효율적이며, 계절 문제처럼 여러 값이 하나의 결과로 묶일 때 가장 적합한 방식입니다.

핵심 요약

나머지 연산자(%): 짝수/홀수 판별(n % 2 == 0)이나 배수 확인 등 조건문 문제에서 빈번하게 사용됩니다.
if문의 순서: 범위를 나눌 때(>=)는 큰 값부터 순차적으로 else if를 작성해야 논리적 오류를 방지할 수 있습니다.
switch문의 활용: 입력값이 명확한 정수나 문자일 때 if문보다 가독성이 좋으며, break 유무에 주의해야 합니다.
조건의 병렬 vs 중첩: 서로 독립적인 조건(부호, 짝홀)은 병렬로, 연관된 조건(점수 등급)은 중첩(else if)으로 처리합니다.
Fall-through: switch문에서 break를 생략하여 여러 조건을 하나의 실행 코드로 묶는 테크닉을 익혀두면 유용합니다.