반응형
✅ 15. C언어
- 절차 지향적인 프로그래밍 언어로 컴퓨터가 실행해야 하는 순서대로 프로그램을 작성한다.
- 다양한 데이터 타입과 연산자를 제공하며, 메모리 관리에 대한 직접적인 제어가 가능하다.
- 운영체제, 임베디드 시스템, 네트워크, 게임 등 다양한 분야에서 활용한다.
💡 자료형
메모리에 데이터가 저장되는 형식이다.
정수형
- char: %c, 1바이트, -128 ~ 127
- short: %d, 2바이트, -32,768 ~ 32,767
- int: %d, 4바이트, -2,147,483,648 ~ 2,147,483,647
- long: 4바이트, -2,147,483,648 ~ 2,147,483,647
- long long: 8바이트, -9,223,372,036,854,775,808 ~ +9,223,372,036,854,775,807
실수형
- float: %f, 4바이트, ±3.4x10^-37 ~ ±3.4x10^38
- double: %lf, 8바이트, ±1.7x10^-307 ~ ±3.4x10^308
- long double: 8바이트
서식문자(Conversion Specifier)
출력하고자 하는 변수의 출력 형태를 지정한다.
- %d: 10진 정수형 출력
%u: 부호 없는 10진 정수형 출력
%o: 8진 정수형 출력
%x: 16진 정수형 출력 - %c: 문자 출력
%s: 문자열 출력 - %f: 실수형 출력
%e: 지수형 출력
%g: e와 f 중에서 출력할 자리를 덜 차지하는 형태로 출력 - %p: 포인터의 주소값 출력
💡 식별자 Identifier
- 변수, 상수, 함수 등에 이름을 부여한다.
- 첫 글자는 문자나 언더바()로 시작한다.
- 대소문자를 구분하며, 길이 제한은 없다.
#include <stdio.h>
int main() {
int my_variable = 10;
int _my_variable = 20;
int myVariable = 30;
printf("%d\n", my_variable);
printf("%d\n", _my_variable);
printf("%d\n", myVariable);
return 0;
}
💡 변수 Variable
- 값을 저장하는 공간이다.
- 선언과 동시에 초기화할 수 있다.
- 포인터(pointer) 변수를 통해 메모리 주소를 직접 다룬다.
#include <stdio.h>
int main() {
int num1 = 10;
int num2 = num1;
int* num_ptr = &num1;
printf("num1의 값: %d\n", num1);
printf("num2의 값: %d\n", num2);
printf("num1의 주소: %p\n", &num1);
printf("num2의 주소: %p\n", &num2);
printf("num_ptr이 가리키는 값: %d\n", *num_ptr);
printf("num_ptr의 주소: %p\n", &num_ptr);
return 0;
}
💡 표준 입출력 함수
- scanf() 함수: 사용자로부터 입력을 받기 위해 사용되며, 형식 지정자를 이용하여 입력받을 값의 형식을 지정한다.
- printf() 함수: 출력을 위해 사용되며, 형식 지정자를 이용하여 출력할 값의 형식을 지정한다.
#include <stdio.h>
int main() {
int num;
char str[100];
printf("정수를 입력하세요: ");
scanf("%d", &num);
printf("입력한 정수는 %d입니다.\n", num);
printf("문자열을 입력하세요: ");
scanf("%s", str);
printf("입력한 문자열은 %s입니다.\n", str);
return 0;
}
💡 연산자 Operator
- 값을 연산하는 데 사용되는 기호이다.
- 산술 연산자: +, -, *, /, %
- 비교 연산자: >, >=, <, <=, ==, !=
- 논리 연산자: &&, ||, !
#include <stdio.h>
int main() {
int a = 10;
int b = 3;
int result1 = a + b;
int result2 = a - b;
int result3 = a * b;
int result4 = a / b;
int result5 = a % b;
printf("a + b = %d\n", result1);
printf("a - b = %d\n", result2);
printf("a * b = %d\n", result3);
printf("a / b = %d\n", result4);
printf("a %% b = %d\n", result5);
int c = 5;
int d = ++c;
int e = c++;
printf("c = %d, d = %d, e = %d\n", c, d, e);
return 0;
}
💡 조건문 Conditional
- 특정 조건에 따라 다른 코드를 실행한다.
- 조건문에 대한 괄호가 필수가 아니며, 중첩된 if문을 사용할 수 있다.
#include <stdio.h>
int main() {
int num;
printf("정수를 입력하세요: ");
scanf("%d", &num);
if (num > 0) {
printf("입력한 수는 양수입니다.");
} else if (num < 0) {
printf("입력한 수는 음수입니다.");
} else {
printf("입력한 수는 0입니다.");
}
return 0;
}
💡 반복문 Loop
- 특정한 조건이 만족하는 동안 코드를 반복한다.
#include <stdio.h>
int main() {
int i;
for (i = 1; i <= 5; i++) {
printf("%d\n", i);
}
i = 1;
while (i <= 5) {
printf("%d\n", i);
i++;
}
i = 1;
do {
printf("%d\n", i);
i++;
} while (i <= 5);
return 0;
}
💡 배열 Array
- 동일한 자료형의 데이터를 하나의 변수로 저장한다.
- 인덱스(index)를 이용하여 각 원소에 접근한다.
- 배열의 크기는 선언 시 명시하거나 초기화 시에 결정한다.
#include <stdio.h>
int main() {
int arr1[5] = {1, 2, 3, 4, 5};
int arr2[] = {1, 2, 3, 4, 5};
int arr3[5];
for (int i = 0; i < 5; i++) {
arr3[i] = i + 1;
}
printf("arr1[0] = %d, arr1[1] = %d, arr1[2] = %d, arr1[3] = %d, arr1[4] = %d\n", arr1[0], arr1[1], arr1[2], arr1[3], arr1[4]);
printf("arr2[0] = %d, arr2[1] = %d, arr2[2] = %d, arr2[3] = %d, arr2[4] = %d\n", arr2[0], arr2[1], arr2[2], arr2[3], arr2[4]);
printf("arr3[0] = %d, arr3[1] = %d, arr3[2] = %d, arr3[3] = %d, arr3[4] = %d\n", arr3[0], arr3[1], arr3[2], arr3[3], arr3[4]);
return 0;
}
💡 문자열 String
- 문자의 배열로 표현한다.
- 널(null) 문자('\0')로 문자열의 끝을 나타낸다.
#include <stdio.h>
#include <string.h>
int main() {
char str1[10] = "Hello";
char str2[] = "World";
char str3[20];
strcpy(str3, str1);
strcat(str3, str2);
printf("str1: %s\n", str1);
printf("str2: %s\n", str2);
printf("str3: %s\n", str3);
printf("str3의 길이: %ld\n", strlen(str3));
return 0;
}
💡 구조체 Structure
- 다른 자료형의 변수들을 묶어 하나의 자료형으로 정의한다.
- 멤버(member)를 이용하여 각 원소에 접근한다.
#include <stdio.h>
struct Student {
char name[10];
int age;
int score;
};
int main() {
struct Student s1 = {"John", 20, 90};
struct Student s2 = {"Mary", 21, 95};
printf("%s의 나이는 %d이고, 성적은 %d점입니다.\n", s1.name, s1.age, s1.score);
printf("%s의 나이는 %d이고, 성적은 %d점입니다.\n", s2.name, s2.age, s2.score);
return 0;
}
💡 함수 Function
- 특정한 작업을 수행하는 코드 블록으로, 호출(call)하여 사용한다.
- 코드의 재사용성을 향상한다.
#include <stdio.h>
int add(int x, int y) {
return x + y;
}
int main() {
int a = 5, b = 3, result;
result = add(a, b);
printf("%d + %d = %d\n", a, b, result);
return 0;
}
💡 포인터 Pointer
- 변수의 주소를 저장하는 변수입니다.
- 메모리 상의 값을 직접 조작할 수 있다.
- 동적 메모리 할당과 함수 호출에서 사용한다.
- * 연산자를 이용하여 해당 주소에 접근한다.
- & 연산자를 이용하여 변수의 주소를 얻는다.
#include <stdio.h>
int main() {
int num = 5;
int *p;
p = #
printf("num의 값: %d\n", num);
printf("num의 메모리 주소: %p\n", &num);
printf("p가 가리키는 변수의 값: %d\n", *p);
printf("p가 가리키는 변수의 메모리 주소: %p\n", p);
return 0;
}
💡 기출
[단답형] 2020년 1회
다음은 C언어 소스 코드이다. 출력 결과를 쓰시오.
#include <stdio.h>
void main()
{
int i, j, temp;
int a[5] = {95, 75, 85, 100, 50};
// 버블 정렬 알고리즘 적용
for (i = 0; i < 4; i++)
{
for (j = 0; j < 4 - i; j++)
{
if (a[j] > a[j + 1])
{
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
// 정렬된 배열 출력
for (i = 0; i < 5; i++)
{
printf("%d ", a[i]);
}
return 0;
}- 50 75 85 95 100
[해설]
버블 정렬(Bubble Sort)
- 배열을 순차적으로 탐색하며 인접한 두 요소를 비교하여 큰 값을 뒤로 보내는 과정을 반복한다.
- 한 번의 탐색에서 가장 큰 값이 맨 뒤에 위치하게 되며, 이를 제외한 배열을 다시 탐색하여 정렬을 완료한다.
// 버블정렬 함수 정의
void bubble_sort(int arr[], int size) {
int temp, i, j;
// 외부 반복문은 정렬할 배열의 길이에서 1을 뺀 만큼 반복
for(i = 0; i < size - 1; i++) {
// 내부 반복문은 현재 위치와 이후 위치의 원소를 비교하여 정렬
for(j = 0; j < size - i - 1; j++) {
if(arr[j] > arr[j + 1]) {
// 크기가 작은 원소를 왼쪽으로 이동
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}[단답형] 2020년 3회
다음은 C언어 소스 코드이다. 출력 결과를 쓰시오.
#include <stdio.h>
void main()
{
int i = 0, c = 0; // 변수 i와 c를 선언하고, 0으로 초기화
while (i < 10) // i가 10보다 작은 동안 반복
{
i++; // i를 1씩 증가
c *= i; // c에 i를 곱한 값을 저장
}
printf("%d", c); // c의 값을 출력
}- 0
[단답형] 2020년 3회
다음은 C언어 소스 코드이다. 출력 결과를 쓰시오.
#include <stdio.h>
int r1() // 4를 반환하는 함수
{
return 4;
}
int r10() // 30 + r1()의 결과를 반환하는 함수
{
return (30 + r1());
}
int r100() // 200 + r10()의 결과를 반환하는 함수
{
return (200 + r10());
}
int main()
{
printf("%d\n", r100()); // r100()의 결과를 출력
return 0;
}- 234
[약술형] 2020년 3회
헝가리안 표기법(Hungarian Case)에 대해서 서술하시오.
- 식별자 표기 시 접두어에 자료형을 붙이는 표기법이다.
[해설]
- 헝가리안 표기법(Hungarian Notation)
- 변수나 함수의 이름에 해당 변수나 함수의 데이터 타입 정보를 포함하는 표기법
- 예를 들어, iCount와 같이 i로 정수형 변수임을 표기한다.
- 카멜 표기법(Camel Case)
- 변수나 함수의 이름을 대문자로 시작하는 단어와 소문자로 시작하는 단어를 번갈아가며 사용하는 표기법
- 예를 들어, firstName, lastName와 같이 첫 번째 단어는 소문자로, 이후 단어는 대문자로 표기한다.
- 파스칼 표기법(Pascal Case)
- 변수나 함수의 이름을 모든 단어의 첫 글자를 대문자로 표기하는 표기법
- 예를 들어, FirstName, LastName와 같이 모든 단어의 첫 글자를 대문자로 표기한다.
- 스네이크 표기법(Snake Case)
- 변수나 함수의 이름을 밑줄(_)로 구분하는 표기법
- 예를 들어, first_name, last_name과 같이 단어 사이를 밑줄로 구분한다.
[단답형] 2020년 4회
다음은 C언어 소스 코드이다. 출력 결과를 쓰시오.
#include <stdio.h>
void main()
{
char *p = "KOREA"; // 문자열 포인터 p를 "KOREA"로 초기화
printf("%s\n", p); // 문자열 포인터 p가 가리키는 문자열 전체를 출력
printf("%s\n", p + 3); // 문자열 포인터 p가 가리키는 문자열에서 4번째 문자부터 끝까지 출력
printf("%c\n", *p); // 문자열 포인터 p가 가리키는 문자열의 첫 번째 문자를 출력
printf("%c\n", *(p + 3)); // 문자열 포인터 p가 가리키는 문자열의 네 번째 문자를 출
printf("%c\n", p + 2); // 문자열 포인터 p가 가리키는 문자열의 세 번째 문자를 출력
}- KOREA
- EA
- K
- E
- M
[단답형] 2021년 1회
다음은 C언어 소스 코드이다. 출력 결과를 쓰시오.
#include <stdio.h>
struct sugoring // sugoring 구조체를 정의
{
char name[10]; // 이름을 저장하는 문자열 변수
int age; // 나이를 저장하는 정수형 변수
};
void main()
{
struct sugoring s[] = {"Kim", 28, "Lee", 38, "Seo", 50, "Park", 35}; // sugoring 구조체를 배열로 초기화
struct sugoring *p; // sugoring 구조체를 가리키는 포인터 변수 p를 선언
p = s; // 포인터 p가 s 배열을 가리킴
p++; // 포인터 p를 다음 구조체로 이동
printf("%s\n", p->name); // 포인터 p가 가리키는 구조체의 이름을 출력
printf("%d\n", p->age); // 포인터 p가 가리키는 구조체의 나이를 출력
}- Lee
- 38
[해설]
구조체
- 서로 다른 데이터 타입을 가진 변수를 하나의 논리적 단위로 묶는 자료형이다.
- 변수들을 그룹화하고, 해당 그룹에 대한 연산을 쉽게 처리한다.
#include <stdio.h>
// student 구조체를 정의
struct student
{
char name[20]; // 이름
int age; // 나이
double height; // 키
double weight; // 몸무게
};
int main()
{
// student 구조체 변수를 선언
struct student s1 = {"John", 20, 175.0, 65.0};
// 구조체 변수의 멤버에 접근하여 값을 출력
printf("Name: %s\n", s1.name);
printf("Age: %d\n", s1.age);
printf("Height: %.1f\n", s1.height);
printf("Weight: %.1f\n", s1.weight);
return 0;
}[단답형] 2021년 2회
다음은 C언어 소스 코드이다. 출력 결과를 쓰시오.
#include <stdio.h>
void main()
{
int ary[3] = {1}; // 크기가 3인 int형 배열을 선언하고, 첫 번째 요소를 1로 초기화
int s = 0; // 합을 저장하는 변수를 선언하고, 0으로 초기화
int i - 0; // int형 변수 i를 선언하고, 0으로 초기화
ary[1] = *(ary + 0) + 2; // 두 번째 요소에 첫 번째 요소에 2를 더한 값을 대입
ary[2] = *ary + 3; // 세 번째 요소에 첫 번째 요소에 3을 더한 값을 대입
for (int i = 0; i < 3; i++) // 배열의 모든 요소를 더함
{
s = s + ary[i];
}
printf("%d", s); // 합을 출력
}- 8
[단답형] 2021년 2회
다음은 C언어 소스 코드이다. 출력 결과를 쓰시오.
#include <stdio.h>
int sugoring(int base, int exp)
{
int i, result = 1; // 변수 i와 result를 선언하고, result를 1로 초기화
for (i = 0; i < exp; i++) // exp번 반복
{
result *= base; // result에 base를 곱한 값을 저장
}
return result; // result 값을 반환
}
void main()
{
printf("%d", sugoring(2, 10)); // 2의 10승을 계산하여 출력
}- 1024
[단답형] 2021년 3회
다음은 C언어 소스 코드이다. 출력 결과를 쓰시오.
#include <stdio.h>
void main()
{
int *arr[3]; // int형 포인터 배열을 선언
int a = 12, b = 24, c = 36; // int형 변수 a, b, c를 선언하고 초기값을 설정
arr[0] = &a; // arr[0]에 변수 a의 주소를 저장
arr[1] = &b; // arr[1]에 변수 b의 주소를 저장
arr[2] = &c; // arr[2]에 변수 c의 주소를 저장
printf("%d\n", *arr[1] + **arr + 1); // arr[1]이 가리키는 변수와 arr[0]이 가리키는 변수의 값을 더하고, 1을 더한 값을 출력
}- 37
[단답형] 2021년 3회
다음은 C언어 소스 코드이다. 출력 결과를 쓰시오.
#include <stdio.h>
struct sugoring
{
char name[20]; // 이름
int os, db, hab1, hab2; // 과목별 성적과 합계
};
void main()
{
struct sugoring s[3] = {{"데이터1", 95, 88}, {"데이터2", 84, 91}, {"데이터3", 86, 75}}; // 구조체 배열을 선언하고 초기값을 설정
struct sugoring *p; // 구조체 포인터를 선언
p = &s[0]; // 구조체 포인터에 배열의 첫 번째 요소의 주소를 대입
(p + 1)->hab1 = (p + 1)->os + (p + 2)->db; // 구조체 포인터를 사용하여 배열의 요소에 접근하고, 합계를 계산하여 저장
(p + 1)->hab2 = (p + 1)->hab1 + p->os + p->db; // 구조체 포인터를 사용하여 배열의 요소에 접근하고, 합계를 계산하여 저장
printf("%d\n", (p + 1)->hab1 + (p + 1)->hab2); // 구조체 포인터를 사용하여 배열의 요소에 접근하고, 합계를 계산하여 출력
}- 501
[단답형] 2022년 1회
다음 소스 코드에 입력 값이 5가 들어왔을 때 출력 값을 쓰시오.
#include <stdio.h>
// 재귀함수를 이용하여 팩토리얼을 계산하는 함수
int sugoring(int a)
{
if (a <= 1) // 종료조건: a가 1 이하일 경우 1을 반환
return 1;
return a * sugoring(a - 1); // a * (a-1)의 팩토리얼을 반환
}
void main()
{
int a;
scanf("%d", &a); // 입력받은 정수를 변수 a에 저장
printf("%d", sugoring(a)); // sugoring 함수를 호출하고 결과값을 출력
}- 120
[단답형] 2022년 1회
빈칸에 연산자를 써서 정수를 역순으로 출력하는 프로그램을 완성하시오. 예를 들어 1234의 역순은 4321이다. 단, 1230처럼 0으로 끝나는 정수는 고려하지 않는다.
#include <stdio.h>
void main()
{
int number = 1234; // 변환할 10진수 정수
int div = 10; // 10진수를 8진수로 변환할 때 나눌 수
int result = 0; // 변환된 8진수를 저장할 변수
while (number ① 0) // number가 0이 아닐 때까지 반복
{
result = result * div; // 기존에 계산된 결과값에 div를 곱하여 자리수를 늘림
result = result + number ② div; // number를 div로 나눈 나머지를 result에 더함
number = number ③ div; // number를 div로 나눈 몫을 새로운 number로 저장
}
printf("%d", result); // 변환된 8진수를 출력
}- > 또는 !=
- %
- /
[단답형] 2022년 1회
다음은 C언어 소스 코드이다. 출력 결과를 쓰시오.
#include <stdio.h>
// 소수 여부를 판별하는 함수
int isPrime(int number)
{
int i;
for (i = 2; i < number; i++) // 2부터 number-1까지 반복하여 나누어 떨어지는 수가 있는지 검사
{
if (number % i == 0) // 나누어 떨어지는 수가 있으면 소수가 아니므로 0을 반환
return 0;
}
return 1; // 나누어 떨어지는 수가 없으면 소수이므로 1을 반환
}
void main()
{
int number = 13195; // 소인수분해할 숫자
int max_div = 0; // 가장 큰 소인수를 저장할 변수
int i;
for (i = 2; i < number; i++) // 2부터 number-1까지 반복하여 소인수를 찾음
{
if (isPrime(i) == 1 && number % i == 0) // i가 소수이고 number가 i로 나누어 떨어지면
max_div = i; // i를 가장 큰 소인수로 저장
}
printf("%d", max_div); // 가장 큰 소인수를 출력
return 0;
}- 29
[단답형] 2022년 1회
다음은 C언어 소스 코드이다. 실행 결과를 쓰시오.
#include <stdio.h>
// 구조체 student를 정의
struct student
{
int n; // 학생 번호
int g; // 학생 성적
};
int main()
{
struct student st[2]; // student 구조체 타입의 배열 선언
int i = 0; // 반복문에서 사용할 변수 i 초기화
for (i = 0; i < 2; i++) // 0부터 1까지 반복하여 배열 요소 초기화
{
st[i].n = i; // i를 학생 번호로 사용
st[i].g = i + 1; // 학생 성적은 i+1로 설정
}
printf("%d", st[0].n + st[1].g); // 첫 번째 학생 번호와 두 번째 학생 성적을 더한 결과 출력
return 0; // 프로그램 종료
}- 2
[단답형] 2022년 2회
다음은 C언어 소스 코드이다. 실행 결과를 쓰시오.
#include <stdio.h>
// 문자열의 길이를 계산하는 함수
int len(char *p)
{
int r = 0; // 결과값을 저장할 변수 r 초기화
while (*p != '\0') // 문자열의 끝까지 반복
{
p++; // 다음 문자를 가리키도록 포인터 증가
r++; // 문자열 길이 1 증가
}
return r; // 문자열의 길이 반환
}
int main()
{
char *p1 = "2022"; // 첫 번째 문자열
char *p2 = "202207"; // 두 번째 문자열
printf("%d", len(p1) + len(p2)); // 두 문자열의 길이를 더한 결과를 출력
return 0;
}- 10
[단답형] 2022년 2회
다음은 C언어 소스 코드이다. 실행 결과를 쓰시오.
#include <stdio.h>
void main()
{
int a[4] = {0, 2, 4, 8}; // 크기가 4인 배열 a 선언하고 초기화
int b[3]; // 크기가 3인 배열 b 선언
int *p1; // int형 포인터 p1 선언
int i, j; // 반복문에서 사용할 변수 i, j 선언
int sum = 0; // 합계를 저장할 변수 sum 초기화
for (i = 1; i < 4; i++) // 1부터 3까지 반복
{
p1 = a + i; // 포인터 p1에 a+i의 주소를 저장
b[i - 1] = *p1 - a[i - 1]; // b[i-1]에 *(a+i)-a[i-1]의 결과를 저장
sum = sum + a[i] + b[i - 1]; // sum에 a[i]+b[i-1]의 결과를 누적
}
printf("%d", sum); // sum 출력
}- 22
[단답형] 2022년 3회
다음은 C언어 소스 코드이다. 실행 결과를 쓰시오.
#include <stdio.h>
// 폭과 높이, 좌표 i, j를 인자로 받아 필드 내에 존재하는 좌표인지 검사하는 함수
int calc(int w, int h, int j, int i)
{
if (i >= 0 && i < h && j >= 0 && j < w) // i, j가 필드의 범위 내에 있으면
return 1; // 1 반환
return 0; // 아니면 0 반환
}
int main()
{
int field[4][4] = {{0, 1, 0, 1}, {0, 0, 0, 1}, {1, 1, 1, 0}, {0, 1, 1, 1}}; // 지뢰와 지뢰가 아닌 영역을 나타내는 2차원 배열
int mines[4][4] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}; // 지뢰 개수를 저장할 2차원 배열
int w = 4, h = 4; // 필드의 폭과 높이
int i, j, k, l; // 반복문에서 사용할 변수 i, j, k, l
for (l = 0; l < h; l++) // 0부터 h-1까지 반복
{
for (k = 0; k < w; k++) // 0부터 w-1까지 반복
{
if (field[l][k] == 0) // 해당 위치가 지뢰가 아닌 경우
continue; // 다음 반복으로 건너뜀
for (i = l - 1; i <= l + 1; i++) // l-1부터 l+1까지 반복
{
for (j = k - 1; j <= k + 1; j++) // k-1부터 k+1까지 반복
{
if (calc(w, h, j, i) == 1) // (i, j)가 필드 내에 있는 경우
{
mines[i][j] += 1; // 해당 위치의 지뢰 개수를 1 증가시킴
}
}
}
}
}
for (l = 0; l < h; l++) // 0부터 h-1까지 반복
{
for (k = 0; k < w; k++) // 0부터 w-1까지 반복
{
printf("%d", mines[l][k]); // 해당 위치의 지뢰 개수를 출력
}
printf("\n"); // 줄바꿈
}
return 0; // 프로그램 종료
}- 1 1 3 2
- 3 4 5 3
- 3 5 6 4
- 3 5 5 3
[단답형] 2022년 2회
다음은 C언어 소스 코드이다. 실행 결과를 쓰시오.
#include <stdio.h>
void main()
{
int n, k, s;
int el = 0; // 완전수의 개수를 저장할 변수 el 초기화
for (n = 6; n <= 30; n++) // 6부터 30까지 반복
{
s = 0; // 약수의 합을 저장할 변수 s 초기화
k = n / 2; // n의 반까지만 약수를 구하면 됨
for (int j = 1; j <= k; j++) // 1부터 k까지 반복
{
if (n % j == 0) // j가 n의 약수인 경우
{
s = s + j; // s에 j를 더함
}
}
if (s == n) // s가 n과 같으면 (n이 완전수인 경우)
{
el++; // 완전수의 개수를 1 증가시킴
}
}
printf("%d", el); // 완전수의 개수를 출력
}- 2
✅ 16. 자바 Java
💡 자바 기본 구조
- 클래스(class) 단위로 프로그래밍이 이루어지며, 각 클래스는 자체적으로 변수(variable)와 메서드(method)를 가진다.
- main() 메서드는 프로그램의 진입점(entry point)으로 사용된다.
- 클래스와 객체(object)의 개념을 중심으로 코드를 작성하는 객체지향 프로그래밍(OOP) 언어이다.
- 상속(inheritance)과 다형성(polymorphism) 등을 활용한다.
💡 자료형
- 변수가 저장할 수 있는 값의 종류이다.
- 기본 자료형(primitive data type)과 참조 자료형(reference data type)이 있다.
// 기본 자료형 예시
int number = 10; // 정수형 변수
double pi = 3.14; // 실수형 변수
boolean isTrue = true; // 논리형 변수
// 참조 자료형 예시
String text = "Hello, world!"; // 문자열 변수
💡 변수 Variable
- 값을 저장하기 위한 메모리 공간이다.
- 변수의 타입에 따라 저장할 수 있는 값의 범위와 형태가 결정된다.
// 기본 자료형 변수 선언
int number = 10; // 정수형 변수
double pi = 3.14; // 실수형 변수
boolean isTrue = true; // 논리형 변수
// 참조 자료형 변수 선언
String text = "Hello, world!"; // 문자열 변수
💡 배열 Array
- 동일한 자료형의 값을 여러 개 저장할 수 있는 구조이다.
// 정수형 배열 생성
int[] numbers = new int[5];
// 배열에 값 할당
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;
numbers[3] = 40;
numbers[4] = 50;
// 배열 값 출력
for (int i = 0; i < numbers.length; i++) {
System.out.println(numbers[i]);
}
💡 표준입출력 함수
- System 클래스의 표준입출력 함수를 제공하여, 콘솔 창에서 사용자 입력을 받고 출력한다.
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// 사용자 입력 받기
System.out.print("이름을 입력하세요: ");
String name = scanner.nextLine();
// 출력하기
System.out.println("안녕하세요, " + name + "님!");
}
}
💡 연산자 Operator
- 값을 연산하거나 비교한다.
int a = 10;
int b = 5;
// 산술 연산자 (+, -, *, /, %)
int result1 = a + b;
int result2 = a - b;
int result3 = a * b;
int result4 = a / b;
int result5 = a % b;
// 비교 연산자 (==, !=, >, <, >=, <=)
boolean isEqual = (a == b);
boolean isNotEqual = (a != b);
boolean isGreater = (a > b);
boolean isLess = (a < b);
boolean isGreaterOrEqual = (a >= b);
boolean isLessOrEqual = (a <= b);
// 논리 연산자 (&&, ||, !)
boolean isTrue1 = (a > 0 && b > 0);
boolean isTrue2 = (a > 0 || b > 0);
boolean isFalse = !(a > 0);
💡 반복문 Loop
- 코드 블록을 여러 번 실행하여 반복 작업을 수행한다.
- for문, while문, do-while문을 제공한다.
// for문을 활용한 반복문 예시
for (int i = 1; i <= 5; i++) {
System.out.println("반복문을 실행 중입니다. i의 값은 " + i + "입니다.");
}
// while문을 활용한 반복문 예시
int count = 0;
while (count < 5) {
System.out.println("반복문을 실행 중입니다. count의 값은 " + count + "입니다.");
count++;
}
// do-while문을 활용한 반복문 예시
int num = 0;
do {
System.out.println("반복문을 실행 중입니다. num의 값은 " + num + "입니다.");
num++;
} while (num < 5);
💡 메서드 Method
- 특정한 기능을 수행하는 코드 블록이다.
- 메서드를 호출하여 코드의 중복을 줄이고 코드의 가독성을 향상한다.
public class Main {
public static void main(String[] args) {
int a = 10;
int b = 5;
// 메서드 호출
int result = add(a, b);
// 결과 출력
System.out.println("두 수의 합은 " + result + "입니다.");
}
// 메서드 정의
public static int add(int x, int y) {
int sum = x + y;
return sum;
}
}
💡 클래스 Class
- 변수와 메서드를 포함한 데이터 타입이다.
- 객체(object)의 설계도이다.
// 클래스 정의
public class Car {
// 필드(인스턴스 변수)
String model;
int year;
// 메서드
public void startEngine() {
System.out.println("시동을 켭니다.");
}
}
// 객체 생성 및 사용
public class Main {
public static void main(String[] args) {
// 객체 생성
Car myCar = new Car();
// 필드 값 설정
myCar.model = "Sonata";
myCar.year = 2022;
// 메서드 호출
myCar.startEngine();
}
}
💡 클래스 상속
- 이미 정의된 클래스의 필드와 메서드를 다른 클래스에서도 재사용한다.
- 기존 클래스의 속성을 유지하면서 새로운 클래스를 만든다.
// 부모 클래스
public class Animal {
public void eat() {
System.out.println("먹이를 먹습니다.");
}
}
// 자식 클래스
public class Dog extends Animal {
public void bark() {
System.out.println("멍멍!");
}
}
// 객체 생성 및 사용
public class Main {
public static void main(String[] args) {
// 객체 생성
Dog myDog = new Dog();
// 부모 클래스의 메서드 호출
myDog.eat();
// 자식 클래스의 메서드 호출
myDog.bark();
}
}
💡 추상 클래스
- 인스턴스를 생성할 수 없는 클래스이다.
- 추상메서드(abstract method)를 포함할 수 있다.
- 추상클래스를 상속하는 자식 클래스는 반드시 추상메서드를 오버라이딩하여 구현한다.
// 추상클래스 정의
public abstract class Animal {
// 추상메서드
public abstract void makeSound();
// 일반 메서드
public void eat() {
System.out.println("먹이를 먹습니다.");
}
}
// 추상클래스 상속받는 자식 클래스
public class Dog extends Animal {
// 추상메서드 구현
public void makeSound() {
System.out.println("멍멍!");
}
}
// 객체 생성 및 사용
public class Main {
public static void main(String[] args) {
// 추상클래스는 인스턴스를 생성할 수 없음
// Animal myAnimal = new Animal();
// 자식 클래스의 객체 생성
Dog myDog = new Dog();
// 추상메서드 구현 결과 출력
myDog.makeSound();
// 일반 메서드 호출
myDog.eat();
}
}
💡 인터페이스 Interface
- 추상메서드와 상수 필드만을 가지는 추상클래스 역할이다.
- 구현된 메서드를 가지지 않으며, 다른 클래스에서 구현할 메서드를 정의한다.
- 클래스에서는 implements 키워드를 사용하여 구현한다.
// 인터페이스 정의
public interface Animal {
// 추상메서드
public void makeSound();
// 상수 필드
public static final int LEGS = 4;
}
// 인터페이스 구현하는 클래스
public class Dog implements Animal {
// 추상메서드 구현
public void makeSound() {
System.out.println("멍멍!");
}
}
// 객체 생성 및 사용
public class Main {
public static void main(String[] args) {
// 인터페이스는 인스턴스를 생성할 수 없음
// Animal myAnimal = new Animal();
// 인터페이스를 구현하는 클래스의 객체 생성
Dog myDog = new Dog();
// 추상메서드 구현 결과 출력
myDog.makeSound();
// 상수 필드 호출
System.out.println("다리 개수: " + Animal.LEGS);
}
}
💡 스레드 Thread
- 프로세스 내에서 실행되는 작은 실행 단위이다.
- 하나의 프로세스 내에서 동시에 여러 작업을 수행할 수 있다.
public class MyThread extends Thread {
public void run() {
for (int i = 1; i <= 5; i++) {
System.out.println("스레드 실행 중입니다. i의 값은 " + i + "입니다.");
}
}
}
public class Main {
public static void main(String[] args) {
// 스레드 객체 생성
MyThread myThread = new MyThread();
// 스레드 실행
myThread.start();
for (int i = 1; i <= 5; i++) {
System.out.println("메인 실행 중입니다. i의 값은 " + i + "입니다.");
}
}
}
💡 컬렉션 Collection
- 데이터를 저장하고 관리한다.
- 배열과 유사하지만, 크기를 동적으로 조절할 수 있다.
- 다양한 메서드를 제공하여 데이터를 추가, 삭제, 검색할 수 있다.
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
// ArrayList 객체 생성
ArrayList<String> myArrayList = new ArrayList<String>();
// 데이터 추가
myArrayList.add("사과");
myArrayList.add("바나나");
myArrayList.add("오렌지");
// 데이터 출력
System.out.println(myArrayList);
// 데이터 삭제
myArrayList.remove("바나나");
// 데이터 수정
myArrayList.set(1, "포도");
// 데이터 검색
if (myArrayList.contains("사과")) {
System.out.println("사과가 포함되어 있습니다.");
} else {
System.out.println("사과가 포함되어 있지 않습니다.");
}
// 데이터 출력
System.out.println(myArrayList);
}
}
💡 예외 처리 Exception Handling
- 예외 상황이 발생하였을 때, 프로그램이 비정상 종료되는 것을 방지한다.
public class Main {
public static void main(String[] args) {
try {
int[] myArray = new int[3];
myArray[3] = 10;
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("배열 인덱스 범위를 벗어났습니다.");
}
}
}
💡 기출
[단답형] 2020년 1회
다음은 자바 소스 코드이다. 출력 결과를 쓰시오.
public class Main {
public static void main(String[] args) {
int i; // 반복문에서 사용할 변수 i 선언
int a[] = {0, 1, 2, 3}; // 크기가 4인 배열 a 선언하고 초기화
for (i = 0; i < 4; i++) { // 0부터 3까지 반복
System.out.print(a[i] + " "); // a[i]의 값을 출력하고 공백을 추가
}
}
}- 0 1 2 3
[단답형] 2020년 1회
다음은 자바 소스 코드이다. 출력 결과를 쓰시오.
public class Main {
public static void main(String[] args) {
int i = 3; // 변수 i를 3으로 초기화
int k = 1; // 변수 k를 1로 초기화
switch(i) { // 변수 i를 기준으로 switch 문 실행
case 0:
case 1:
case 2:
case 3: // i가 0, 1, 2, 3 중 하나인 경우
k = 0; // k에 0을 대입
case 4: // i가 4인 경우
k += 3; // k에 3을 더함
case 5: // i가 5인 경우
k -= 10; // k에서 10을 뺌
default: // i가 0부터 5까지의 범위에 속하지 않는 경우
k--; // k에서 1을 뺌
}
System.out.print(k); // 변수 k의 값을 출력
}
}- -8
[단답형] 2020년 2회
다음은 자바 코드이다. 다음 밑줄에 들어갈 키워드를 쓰시오.
class Parent { // 부모 클래스 Parent 선언
public void show() { // 메소드 show() 선언
System.out.println("Parent"); // "Parent" 출력
}
}
class Child extends Parent { // 자식 클래스 Child 선언
public void show() { // 메소드 show() 오버라이딩
System.out.println("Child"); // "Child" 출력
}
}
public class Main {
public static void main(String[] args) {
Parent pa = ① Child(); // 부모 클래스의 참조 변수에 자식 클래스의 인스턴스를 생성하여 대입
pa.show(); // 메소드 show() 호출. 실행 결과 "Child" 출력
}
}- new
[단답형] 2020년 3회
다음은 자바 소스 코드이다. 출력 결과를 쓰시오.
class A {
private int a; // 멤버 변수 a 선언
public A(int a) { // 생성자 A 선언
this.a = a; // a 멤버 변수에 인자로 전달된 값 대입
}
public void display() { // 메소드 display() 선언
System.out.println("a = " + a); // a 멤버 변수의 값을 출력
}
}
class B extends A { // A 클래스를 상속받은 B 클래스 선언
public B(int a) { // 생성자 B 선언
super(a); // 상위 클래스의 생성자를 호출하여 인자로 전달된 값을 초기화
super.display(); // 상위 클래스의 display() 메소드 호출
}
public void display() { // 메소드 display() 오버라이딩
System.out.println("a = " + a); // a 멤버 변수의 값을 출력
}
}
public class Main {
public static void main(String[] args) {
B obj = new B(10); // B 클래스의 인스턴스를 생성하고 초기화
}
}- a = 10
[단답형] 2020년 3회
다음은 자바 소스 코드이다. 출력 결과를 쓰시오.
public class Main {
public static void main(String[] args) {
int i = 0; // 변수 i를 0으로 초기화
int sum = 0; // 변수 sum을 0으로 초기화
while (i < 10) { // i가 10보다 작은 동안 반복
i++; // i를 1씩 증가시킴
if (i % 2 == 1) // i가 홀수인 경우 continue문을 실행하고 반복문의 다음 반복으로 이동
continue;
sum += i; // i가 짝수인 경우 sum에 i를 더함
}
System.out.print(sum); // sum 출력
}
}- 30
[단답형] 2020년 3회
다음은 자바 소스 코드이다. 출력 결과를 쓰시오.
// 추상 클래스 Vehicle 선언
abstract class Vehicle {
String name; // 문자열 멤버 변수 name 선언
// 추상 메소드 getName(String val) 선언
abstract public String getName(String val);
// getName() 메소드 구현
public String getName() {
return "Vehicle name: " + name;
}
// setName() 메소드 구현
public void setName(String val) {
name = val;
}
}
// Vehicle 클래스를 상속받은 Car 클래스 선언
class Car extends Vehicle {
// Car 클래스의 생성자
public Car(String val) {
setName(val); // 상위 클래스의 setName() 메소드를 호출하여 인자로 전달된 값을 name 멤버 변수에 저장
}
// getName(String val) 메소드 오버라이딩
public String getName(String val) {
return "Car name: " + val; // "Car name: "와 인자로 전달된 val을 합쳐서 문자열 반환
}
}
public class Main {
public static void main(String[] args) {
Vehicle obj = new Car("Spark"); // Car 클래스의 인스턴스를 생성하고 초기화하여 Vehicle 클래스의 참조 변수에 대입
System.out.printf(obj.getName()); // obj의 getName() 메소드를 호출하여 반환된 문자열을 출력
}
}- Vehicle name: Spark
[약술형] 2020년 3회
C++에서 생성자란 무엇인지 쓰시오.
- 해당 클래스의 객체가 생성될 때 자동으로 호출되는 특수한 종류의 메서드이다.
[단답형] 2020년 4회
다음은 n이 10일 때, 10을 이진수로 변환하는 자바 소스 코드이다. ①, ②에 알맞은 값을 적으시오.
public class Main {
public static void main(String[] args) {
int a[] = new int[8]; // 크기가 8인 정수형 배열 a 선언
int i = 0; // 반복문에서 사용할 변수 i 초기화
int n = 10; // 10진수로 표현된 수 n 초기화
while ( ① ) { // n이 0보다 큰 동안 반복
a[i++] = ②; // 2로 나눈 나머지를 배열 a의 i번째 인덱스에 저장하고 i를 1 증가
n /= 2; // n을 2로 나눈 몫으로 갱신
}
for (i = 7; i >= 0; i--) { // i를 7부터 0까지 1씩 감소시키며 반복
System.out.printf("%d", a[i]); // 배열 a의 i번째 인덱스를 출력
}
}
}- n > 0 또는 n >= 1 또는 i < 8 또는 i <= 7
- n % 2
[단답형] 2020년 4회
다음은 자바 소스 코드이다. 출력 결과를 보고, ①, ②에 알맞은 값을 적으시오.
1 4 7 10 13
2 5 8 11 14
3 6 9 12 15public class Main {
public static void main(String[] args) {
int a[][] = new int[①][②]; // 3행 5열의 2차원 정수형 배열 a 선언
for (int i = 0; i < 3; i++) { // i를 0부터 2까지 1씩 증가시키며 반복
for (int j = 0; j < 5; j++) { // j를 0부터 4까지 1씩 증가시키며 반복
a[i][j] = j * 3 + (i + 1); // a[i][j]에 j*3+(i+1)의 결과를 저장
}
System.out.println(); // 줄바꿈 출력
}
}
}- 3
- 5
[단답형] 2020년 4회
다음은 자바 소스 코드이다. 출력 결과를 쓰시오.
class Parent {
public int compute(int num) {
if (num <= 1)
return num;
return compute(num - 1) + compute(num - 2);
}
}
class Child extends Parent {
public int compute(int num) {
if (num <= 1)
return num;
return compute(num - 1) + compute(num - 3);
}
}
public class Main {
public static void main(String[] args) {
Parent obj = new Child(); // Parent 타입의 obj 변수에 Child 객체를 할당
System.out.print(obj.compute(4)); // obj의 compute 메소드 호출하여 출력
}
}- 1
[단답형] 2021년 1회
다음은 자바 소스 코드이다. 출력 결과를 쓰시오.
public class Main {
public static void main(String[] args) {
// 2차원 배열 arr을 선언하고 초기화
int arr[][] = new int[][] { { 45, 50, 75 }, { 89 } };
// arr[0]의 길이(3) 출력
System.out.println(arr[0].length);
// arr[1]의 길이(1) 출력
System.out.println(arr[1].length);
// arr[0][0] 출력
System.out.println(arr[0][0]);
// arr[0][1] 출력
System.out.println(arr[0][1]);
// arr[1][0] 출력
System.out.println(arr[1][0]);
}
}- 3
- 1
- 45
- 50
- 89
[단답형] 2021년 1회
다음은 자바 소스 코드이다. 출력 결과를 쓰시오.
public class Main {
public static void main(String[] args) {
int i, j; // 두 개의 정수형 변수 i와 j를 선언
for (i = 0, j = 0; i <= 5; i++) { // i와 j를 0으로 초기화하고 i가 5보다 작거나 같은 동안 반복
j += i; // j에 i를 누적하여 더함
System.out.print(i); // i 출력
if (i == 5) { // i가 5일 경우
System.out.print(" = "); // "=" 출력
System.out.print(j); // j 출력
} else { // i가 5가 아닐 경우
System.out.print(" + "); // "+" 출력
}
}
}
}- 0 + 1 + 2 + 3 + 4 + 5 = 15
[단답형] 2021년 2회
다음은 자바 소스 코드이다. 출력 결과를 쓰시오.
public class ovr1 {
public static void main(String[] args) {
// ovr1 클래스의 객체 생성
ovr1 a1 = new ovr1();
// ovr2 클래스의 객체 생성
ovr2 a2 = new ovr2();
// a1 객체의 san 메소드와 a2 객체의 san, sun 메소드의 결과를 출력
System.out.println(a1.san(3, 2) + a2.san(3, 2));
}
// 두 개의 정수를 더한 값을 반환하는 san 메소드
int san(int x, int y) {
return x + y;
}
}
// ovr1 클래스를 상속받는 ovr2 클래스 정의
class ovr2 extends ovr1 {
// 두 개의 정수를 뺀 값과 ovr1 클래스의 san 메소드를 더한 값을 반환하는 sun 메소드
int sun(int x, int y) {
return x - y + super.san(x, y);
}
}- 11
[단답형] 2021년 3회
다음은 자바 소스 코드이다. 출력 결과를 쓰시오.
// Singleton 클래스 정의
class Singleton {
// Singleton 클래스의 인스턴스(instance) 변수를 null로 초기화
private static Singleton instance = null;
// Singleton 클래스의 count 변수를 0으로 초기화
private int count = 0;
// Singleton 클래스의 인스턴스를 반환하는 정적 메소드 get() 정의
static public Singleton get() {
// 인스턴스 변수가 null일 경우 인스턴스 생성
if (instance == null) {
instance = new Singleton();
}
// 인스턴스 반환
return instance;
}
// count 값을 증가시키는 메소드 count() 정의
public void count() {
count++;
}
// count 값을 반환하는 메소드 getCount() 정의
public int getCount() {
return count;
}
}
// Main 클래스 정의
public class Main {
public static void main(String[] args) {
// Singleton 클래스의 인스턴스 생성 및 count 값 증가
Singleton s1 = Singleton.get();
s1.count();
// Singleton 클래스의 인스턴스 생성 및 count 값 증가
Singleton s2 = Singleton.get();
s2.count();
// Singleton 클래스의 인스턴스 생성 및 count 값 증가
Singleton s3 = Singleton.get();
s3.count();
// s1의 getCount() 메소드를 호출하여 count 값 출력
System.out.print(s1.getCount());
}
}- 3
[단답형] 2021년 2회
다음은 자바 코드이다. 밑줄 친 곳에 들어갈 키워드를 쓰시오.
// Main 클래스 정의
public class Main {
// main 메소드 정의
public static void main(String[] args) {
// check 메소드의 결과를 출력
System.out.print(Main.check(1));
}
// 입력된 정수가 양수인지 음수인지 판별하여 문자열로 반환하는 check 메소드 정의
① String check(int num) {
// 삼항 연산자를 사용하여 입력된 정수가 0 이상인 경우 "positive", 그렇지 않은 경우 "negative"를 반환
return (num >= 0) ? "positive" : "negative";
}
}- static
[해설]
- 객체 생성 없이 메서드를 사용하기 위해서는 static 키워드를 사용하여 정적 메서드(static method)를 정의한다.
- static 키워드가 사용된 메서드는 객체 생성 없이 클래스 이름을 통해 바로 호출할 수 있다.
[단답형] 2021년 3회
다음은 자바 소스 코드이다. 출력 결과를 쓰시오.
// Main 클래스 정의
public class Main {
// main 메소드 정의
public static void main(String[] args) {
// 정수 변수 a, b, c, d를 초기화
int a = 3, b = 4, c = 3, d = 5;
// 복합 조건식을 사용하여 조건을 판단
if ((a == 2 | a == c) & !(c > d) & (1 == b ^ c != d)) {
// 조건이 참인 경우 변수 a를 b + c로 변경
a = b + c;
// 다시 복합 조건식을 사용하여 조건을 판단
if (7 == b ^ c != a) {
// 조건이 참인 경우 변수 a를 출력
System.out.println(a);
} else {
// 조건이 거짓인 경우 변수 b를 출력
System.out.println(b);
}
} else {
// 조건이 거짓인 경우 변수 a를 c + d로 변경
a = c + d;
// 다시 복합 조건식을 사용하여 조건을 판단
if (7 == c ^ d != a) {
// 조건이 참인 경우 변수 a를 출력
System.out.println(a);
} else {
// 조건이 거짓인 경우 변수 d를 출력
System.out.println(d);
}
}
}
}- 7
[단답형] 2022년 1회
다음은 자바 소스 코드이다. 출력 결과를 쓰시오.
// A 클래스 정의
class A {
// 정수형 인스턴스 변수 a와 b 정의
int a;
int b;
}
// Main 클래스 정의
public class Main {
// A 클래스의 인스턴스를 받아서 a를 10배로 증가시키는 func1 메소드 정의
static void func1(A m) {
m.a *= 10;
}
// A 클래스의 인스턴스를 받아서 a에 b를 더하는 func2 메소드 정의
static void func2(A m) {
m.a += m.b;
}
// main 메소드 정의
public static void main(String[] args) {
// A 클래스의 인스턴스 생성
A m = new A();
// m 인스턴스의 a 값을 100으로 초기화
m.a = 100;
// func1 메소드 호출하여 m 인스턴스의 a 값을 1000으로 변경
func1(m);
// m 인스턴스의 b 값을 m 인스턴스의 a 값인 1000으로 초기화
m.b = m.a;
// func2 메소드 호출하여 m 인스턴스의 a 값을 2000으로 변경
func2(m);
// m 인스턴스의 a 값을 출력
System.out.printf("%d", m.a);
}
}- 2000
[단답형] 2022년 1회
다음은 스레드에 관한 코드이다. 다음 빈칸에 알맞은 한 단어를 쓰시오.
// Car 클래스 정의
class Car implements Runnable {
// 인스턴스 변수 a 정의
int a;
// run 메소드 구현
public void run() {
// ...
}
}
// Main 클래스 정의
public class Main {
// main 메소드 구현
public static void main(String[] args) {
// Car 클래스의 인스턴스를 생성하여 Runnable 인터페이스를 구현하는 쓰레드 생성
Thread t1 = new Thread(new ①());
// 쓰레드 시작
t1.start();
}
}- Car
[단답형] 2022년 1회
다음은 자바 소스 코드이다. 출력 결과를 쓰시오.
// Main 클래스 정의
public class Main {
// 인스턴스 변수 a 정의
int a;
// 생성자 정의
public Main(int a) {
this.a = a;
}
// func 메소드 정의
int func() {
// 지역 변수 b를 1로 초기화
int b = 1;
// for 문을 사용하여 a번 반복
for (int i = 1; i < a; i++) {
// b 값을 a * i + b로 변경
b = a * i + b;
}
// a + b 값을 반환
return a + b;
}
// main 메소드 정의
public static void main(String[] args) {
// Main 클래스의 인스턴스 obj 생성
Main obj = new Main(3);
// obj 인스턴스의 a 값을 5로 변경
obj.a = 5;
// obj 인스턴스의 func 메소드를 호출하여 b 값을 구함
int b = obj.func();
// obj 인스턴스의 a 값과 b 값을 더한 값을 출력
System.out.print(obj.a + b);
}
}[단답형] 2022년 3회
다음은 자바 소스 코드이다. 출력 결과를 쓰시오.
// Main 클래스 정의
public class Main {
// main 메소드 정의
public static void main(String[] args) {
// 정수형 배열 result와 arr 정의
int result[] = new int[5];
int arr[] = { 77, 34, 10, 99, 50 };
// i를 0부터 4까지 반복하는 for 문
for (int i = 0; i < 5; i++) {
// result 배열의 i번째 값을 1로 초기화
result[i] = 1;
// j를 0부터 4까지 반복하는 for 문
for (int j = 0; j < 5; j++) {
// arr 배열의 i번째 값이 arr 배열의 j번째 값보다 작을 경우,
// result 배열의 i번째 값을 1 증가
if (arr[i] < arr[j])
result[i]++;
}
}
// k를 0부터 4까지 반복하는 for 문
for (int k = 0; k < 5; k++) {
// result 배열의 k번째 값을 출력
System.out.print(result[k]);
}
}
}- 24513
[단답형] 2022년 3회
다음은 자바 소스 코드이다. 출력 결과를 쓰시오.
// Main 클래스 정의
public class Main {
// MakeArray 메소드 정의
static int[] MakeArray() {
// 길이가 4인 정수형 배열 tempArr 정의
int[] tempArr = new int[4];
// for 문을 사용하여 tempArr 배열의 모든 요소에 i 값을 저장
for (int i = 0; i < tempArr.length; i++) {
tempArr[i] = i;
}
// tempArr 배열 반환
return tempArr;
}
// main 메소드 정의
public static void main(String[] args) {
// intArr 배열 정의
int[] intArr;
// MakeArray 메소드 호출하여 반환값을 intArr 배열에 저장
intArr = MakeArray();
// for 문을 사용하여 intArr 배열의 모든 요소를 출력
for (int i = 0; i < intArr.length; i++) {
System.out.print(intArr[i]);
}
}
}- 0123
[단답형] 2022년 3회
다음은 자바 소스 코드이다. 출력 결과를 쓰시오.
// Main 클래스 정의
public class Main {
// main 메소드 정의
public static void main(String[] args) {
// a 변수를 0으로 초기화
int a = 0;
// for 문을 사용하여 1부터 998까지 반복
for (int i = 1; i < 999; i++) {
// i가 3의 배수이면서 2의 배수가 아닐 경우,
// a 값을 i로 변경
if (i % 3 == 0 && i % 2 != 0)
a = i;
}
// a 값을 출력
System.out.print(a);
}
}- 993
✅ 17. 파이썬 Python
💡 파이썬 기본 구조
- 들여 쓰기를 이용하여 코드 블록을 구분하는 인터프리터 언어이다.
💡 자료형
- 정수형, 실수형, 문자열, boolean 등 다양한 자료형이 있다.
# 정수형(integer) 변수
num1 = 10
# 실수형(float) 변수
num2 = 3.14
# 문자열(string) 변수
str1 = "Hello, world!"
# 불리언(boolean) 변수
bool1 = True
# 리스트(list) 변수
list1 = [1, 2, 3, 4, 5]
# 튜플(tuple) 변수
tuple1 = (1, 2, 3, 4, 5)
# 딕셔너리(dictionary) 변수
dict1 = {'name': 'John', 'age': 30}
💡 입출력
- input() 함수를 사용하여 사용자로부터 입력을 받는다.
- print() 함수를 사용하여 출력한다.
# 사용자로부터 이름을 입력받아 출력하는 예시
name = input("이름을 입력하세요: ")
print("당신의 이름은", name, "입니다.")
# 숫자를 입력받아 계산한 결과를 출력하는 예시
num1 = int(input("첫 번째 숫자를 입력하세요: "))
num2 = int(input("두 번째 숫자를 입력하세요: "))
print(num1, "+", num2, "=", num1 + num2)
💡 연산자 Operator
- 산술 연산자, 비교 연산자, 논리 연산자 등 다양한 연산자가 있다.
# 산술 연산자 예시
num1 = 10
num2 = 3
print(num1 + num2) # 덧셈
print(num1 - num2) # 뺄셈
print(num1 * num2) # 곱셈
print(num1 / num2) # 나눗셈
print(num1 // num2) # 정수 나눗셈
print(num1 % num2) # 나머지 연산
print(num1 ** num2) # 거듭제곱 연산
# 비교 연산자 예시
a = 10
b = 20
print(a == b) # 같은지 비교
print(a != b) # 다른지 비교
print(a > b) # 큰지 비교
print(a < b) # 작은지 비교
print(a >= b) # 크거나 같은지 비교
print(a <= b) # 작거나 같은지 비교
# 논리 연산자 예시
x = True
y = False
print(x and y) # 논리 곱(and)
print(x or y) # 논리 합(or)
print(not x) # 논리 부정(not)
💡 조건문 Conditional
- 조건에 따라 프로그램의 흐름을 제어한다.
- if, elif, else 키워드를 사용하여 조건문을 구성한다.
# if문 예시
num = int(input("숫자를 입력하세요: "))
if num > 0:
print("입력한 숫자는 양수입니다.")
# if-else문 예시
num = int(input("숫자를 입력하세요: "))
if num > 0:
print("입력한 숫자는 양수입니다.")
else:
print("입력한 숫자는 양수가 아닙니다.")
# if-elif-else문 예시
score = int(input("점수를 입력하세요: "))
if score >= 90:
print("A학점입니다.")
elif score >= 80:
print("B학점입니다.")
elif score >= 70:
print("C학점입니다.")
elif score >= 60:
print("D학점입니다.")
else:
print("F학점입니다.")
💡 반복문 Loop
- 반복문을 사용하여 코드를 반복해서 실행한다.
- for문은 주로 시퀀스 자료형을 다룰 때 사용한다.
- while문은 조건에 따라 반복할 때 사용한다.
# for문 예시
fruits = ['사과', '바나나', '딸기']
for fruit in fruits:
print(fruit)
# while문 예시
i = 1
while i <= 10:
print(i)
i += 1
💡 함수
- def 키워드를 사용하여 함수를 정의하고, 함수의 인자와 반환값을 지정한다.
# 함수 예시
def add_numbers(a, b):
return a + b
# 함수 호출 예시
result = add_numbers(10, 20)
print(result)
💡 예외 처리 Exception Handling
- try, except, finally 키워드를 사용한다.
# 예외 처리 예시
try:
num1 = int(input("첫 번째 숫자를 입력하세요: "))
num2 = int(input("두 번째 숫자를 입력하세요: "))
result = num1 / num2
print("나눗셈 결과:", result)
except ValueError:
print("정수를 입력해주세요!")
except ZeroDivisionError:
print("0으로 나눌 수 없습니다!")
finally:
print("프로그램을 종료합니다.")
💡 클래스 Class
- 데이터와 데이터를 처리하는 메서드를 하나의 단위로 묶는다.
# 클래스 예시
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def say_hello(self):
print("안녕하세요, 저는", self.name, "입니다.")
# 객체 생성 예시
person1 = Person("John", 30)
person2 = Person("Jane", 25)
# 메서드 호출 예시
person1.say_hello()
person2.say_hello()
💡 클래스 상속
- 이미 정의된 클래스의 속성과 메서드를 물려받아 새로운 클래스를 정의한다.
# 클래스 상속 예시
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
raise NotImplementedError("구현되지 않음")
class Dog(Animal):
def speak(self):
return "멍멍!"
class Cat(Animal):
def speak(self):
return "야옹!"
# 객체 생성 및 메서드 호출 예시
dog = Dog("댕댕이")
cat = Cat("냥냥이")
print(dog.name, ":", dog.speak())
print(cat.name, ":", cat.speak())
💡 기출
[단답형] 2020년 2회
다음은 파이썬 코드이다. 출력 결과를 쓰시오.
# a 리스트 정의
a = {'일본', '중국', '한국'}
# a 집합에 '베트남' 요소를 추가
a.add('베트남')
# a 집합에 '중국' 요소를 추가하더라도 중복된 값은 추가되지 않음
a.add('중국')
# a 집합에서 '일본' 요소를 제거
a.remove('일본')
# a 집합에 { '홍콩', '한국', '태국'} 요소를 추가
a.update({'홍콩', '한국', '태국'})
# a 집합을 출력
print(a)- {'홍콩', '태국', '한국', '중국', '베트남'}
[단답형] 2020년 4회
다음은 파이썬 코드이다. 출력 결과를 쓰시오.
# lol 리스트 정의
lol = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
# lol 리스트의 첫 번째 요소를 출력
print(lol[0])
# lol 리스트의 세 번째 요소의 두 번째 값을 출력
print(lol[2][1])
# for 문을 사용하여 lol 리스트를 반복
for sub in lol:
# for 문을 사용하여 각 하위 리스트를 반복
for item in sub:
# 각 요소를 출력
print(item, end='')
# 줄바꿈
print()- [1, 2, 3]
- 7
- 123
- 45
- 6789
[단답형] 2021년 1회
다음은 파이썬 코드이다. 출력 결과를 쓰시오.
# sugoring 클래스 정의
class sugoring:
# li 리스트 정의
li = ["Seoul", "Kyeonggi", "Inchon", "Daejeon", "Daegu", "Pusan"]
# sugoring 클래스의 인스턴스 생성
s = sugoring()
# 빈 문자열 str01을 정의
str01 = ''
# for 문을 사용하여 s.li 리스트를 반복하면서 각 요소의 첫 번째 문자를 str01 문자열에 추가
for i in s.li:
str01 = str01 + i[0]
# str01 문자열을 출력
print(str01)- SKIDDP
[단답형] 2021년 2회
다음은 파이썬 코드이다. 출력 결과를 쓰시오.
# a 변수에 100을 할당
a = 100
# i 변수를 0으로 초기화
i = 0
# result 변수를 0으로 초기화
result = 0
# for 문을 사용하여 i를 1부터 2까지 반복
for i in range(1, 3):
# a를 i 비트 오른쪽으로 시프트한 결과에 1을 더한 값을 result 변수에 할당
result = a >> i
result += 1
# result 값을 출력
print(result)- 26
[단답형] 2021년 3회
다음은 파이썬 코드이다. 출력 결과를 쓰시오.
# a 변수에 100을, b 변수에 200을 할당
a, b = 100, 200
# a와 b를 비교하여 같은지 여부를 출력
print(a == b)- False
[단답형] 2022년 1회
다음은 파이썬 코드이다. 출력 결과를 쓰시오.
# func 함수 정의
def func(num1, num2=2):
# 인자로 받은 num1과 num2 값을 출력
print('a = ', num1, 'b = ', num2)
# func 함수 호출. 인자로 num1에는 20을 전달하고, num2는 기본값으로 2를 가짐
func(20)- a = 20 b = 2
[단답형] 2022년 1회
다음은 리스트와 관련된 파이썬 함수이다. 각 항목에 해당하는 함수를 보기에서 골라서 쓰시오.
- 리스트 확장, 여러 값을 한 번에 추가할 수 있음 extend()
- 마지막 또는 지정 요소를 삭제하고 그 값을 반환함 pop()
- 역순으로 뒤집음 reverse()
[해설]
- append(): 리스트 마지막 요소 뒤에 값을 추가
- insert(): 리스트의 인덱스 위치에 값을 삽입
- remove(): 리스트에서 해당하는 값을 제거
[단답형] 2022년 2회
다음은 파이썬 코드이다. 출력 결과를 쓰시오.
# 문자열 a를 정의
a = "REMEMBER NOVEMBER"
# b에 a의 0~2번째 글자와 12~15번째 글자를 이어붙인 문자열을 할당
b = a[:3] + a[12:16]
# c에 "R AND STR" 문자열을 할당
c = "R AND %s" % "STR"
# b와 c를 이어붙인 문자열을 출력
print(b+c)- REMEMBER AND STR
[단답형] 2022년 3회
다음은 파이썬 코드이다. 출력 결과를 쓰시오.
# 리스트 l을 정의
l = [1, 2, 3, 4, 5]
# map 함수와 lambda 함수를 사용하여 l의 각 요소에 100을 더한 결과를 리스트로 변환하여 l에 할당
l = list(map(lambda num: num + 100, l))
# l을 출력
print(l)- [101, 102, 103, 104, 105]
반응형
