2024-2, CSE103-00 - 오프라인 수업
아래의 main 함수가 설명과 같이 동작하도록, Fn1~Fn7 함수를 한 개의 소스 파일(학번.cpp)로 작성하고(main 포함), 소스 파일을 upload하고, 답안지에 작성된 코드의 설명을 작성하여 제출한다. (문제지, cheating sheet 모두 제출)
[코드 작성 조건]
1. 전역 변수 및 static 변수 사용 금지
2. 모든 문제에는 한 개의 함수만 정의 (function overloading 불가, 추가적인 사용자 함수를 정의할 수 없음)
3. 6번을 제외하고 표준함수를 사용할 수 없음, vector의 method는 사용 가능, 6번은 cos 함수만 사용 가능
4. 7번을 제외하고 recursive call을 사용할 수 없음
[채점 기준]
1. 실행되지 않으면 0점 처리, 주석 처리된 것은 채점하지 않음
2. 주어진 제한 조건을 위반하면 0점 처리
3. 문제(main 함수의 내용)를 수정하면 0점 처리, 동작을 확인하기 위하여 주석 처리는 가능
4. 일반적인 동작이 불가능한 경우 0점 처리 또는 감점(일반적인 입력에 대한 처리 등)
5. 연산자의 사용이 부정확한 경우 감점(예, &&를 사용할 위치에 &를 사용 등)
6. 필요 없는 파라메터나 반환이 있으면 감점
7. 답안지에 코드 동작에 대한 설명이 없으면 0점 처리
int main() {
std::cout << "### 1 ###" << std::endl;
// 두 인수의 나눗셈이 출력("첫번째 인수"/"두번째 인수", 두번째 인수가 0이면 0 출력)
std::cout << Fn1(3, 2) << " " << Fn1(3, 0) << " " << Fn1(9, 4) << std::endl;
// 출력: 1 0 2
std::cout << "\n### 2 ###" << std::endl;
int x1 = 2, x2 = 5;
int* p = nullptr;
// 두 인수(x1과 x2)에서 큰 값을 가지는 변수의 주소를 p에 저장, 같은 경우 x2
p = Fn2(&x1, &x2);
std::cout << *p << " " << p << " " << Fn2(&x1, &x2) << std::endl;
// 출력: 5 000000F3447FEA84 000000F3447FEA84 (두 주소는 값에 상관없이 같음)
std::cout << "\n### 3 ###" << std::endl;
int sum = 0, sum1 = 0, sum2 = 0;
// 두 인수[1,100] 범위 정수의 짝수합은 sum1, 홀수합은 sum2, 전체합은 sum에 저장
// 공식을 사용하지 않고 반복문 처리
sum = Fn3(1, 100, sum1, &sum2);
std::cout << sum1 << " " << sum2 << " " << sum << std::endl;
// 출력: 2550 2500 5050
sum = Fn3(4, 10, sum1, &sum2);
// 두 인수[4,10] 범위 정수의 짝수합은 sum1, 홀수합은 sum2, 전체합은 sum에 저장
std::cout << sum1 << " " << sum2 << " " << sum << std::endl;
// 출력: 28 21 49
std::cout << "\n### 4 ###" << std::endl;
const std::vector<int> v1{1, 3, 4, 3, 6};
// 순서대로 v1 (첫번째 인수)의 2, 3, 4 (두번째 인수)의 개수가 출력
std::cout << Fn4(v1, 2) << " " << Fn4(v1, 3) << " " << Fn4(v1, 4) << std::endl;
// 출력: 0 2 1
std::cout << "\n### 5 ###" << std::endl;
std::vector<std::vector<int>> v2{ {1, 2, 3, -1, 7}, {}, {3, 5}, { 19 }, {3, -2, 7} };
// v2의 요소(1차원 vector)가 역순으로 변경
Fn5(&v2);
Print(v2);
// 출력:
3, -2, 7, [\n]
19, [\n]
3, 5, [\n]
[\n]
1, 2, 3, -1, 7,
std::cout << "\n### 6 ###" << std::endl;
// 출력되는 vector는 (아래 수식), f[x]는 크기가 N인 인수로 전달된 벡터이고,
// π는 3.14159로 계산
const std::vector<int> v3{ 8, 16, 24, 31, 40, 48, 56, 64 };
Print(Fn6(v3));
// 출력: 287, -103.272, 0.923407, -10.2192, -0.707614, -4.04538, 0.382091, 0.170189,
std::cout << "\n### 7 ###" << std::endl;
std::vector<int> v4;
// 첫번째 인수의 16진수 값(0~15)이 v4 벡터의 요소에 저장하도록 recursive call 함수로 작성
// 함수에서는 한 자리만 벡터의 요소로 저장 가능
v4.clear();
Fn7(255, v4);
PrintHex(v4);
// 출력: FF
v4.clear();
Fn7(65536, v4);
PrintHex(v4);
// 출력: 10000
}
2024-2, CSE103-02 - 온라인 수업
아래의 main 함수가 설명과 같이 동작하도록, Fn1~Fn7 함수를 한 개의 소스 파일(학번.cpp)로 작성하고(main 포함), 소스 파일을 upload하고, 답안지에 작성된 코드의 설명을 작성하여 제출한다. (문제지, cheating sheet 모두 제출)
[코드 작성 조건]
1. 전역 변수 및 static 변수 사용 금지
2. 모든 문제에는 한 개의 함수만 정의 (function overloading 불가, 추가적인 사용자 함수를 정의할 수 없음)
3. 표준함수를 사용할 수 없음, vector의 method는 사용 가능
4. 7번을 제외하고 recursive call을 사용할 수 없음
[채점 기준]
1. 실행되지 않으면 0점 처리, 주석 처리된 것은 채점하지 않음
2. 주어진 제한 조건을 위반하면 0점 처리
3. 문제(main 함수의 내용)를 수정하면 0점 처리, 동작을 확인하기 위하여 주석 처리는 가능
4. 일반적인 동작이 불가능한 경우 0점 처리 또는 감점(일반적인 입력에 대한 처리 등)
5. 연산자의 사용이 부정확한 경우 감점(예, &&를 사용할 위치에 &를 사용 등)
6. 필요 없는 파라메터나 반환이 있으면 감점
7. 답안지에 코드 동작에 대한 설명이 없으면 0점 처리
int main() {
std::cout << "### 1 ###" << std::endl;
// 두 인수의 합을 출력
std::cout << Fn1(3, 2) << " " << Fn1(3, 0) << " " << Fn1(9, 4) << std::endl;
// 출력: 5 3 13
std::cout << "\n### 2 ###" << std::endl;
int x1 = 2, x2 = 5;
// 두 인수에서 큰 값을 1 증가, 같으면 모두 변화 없음
Fn2(&x1, &x2);
std::cout << x1 << " " << x2 << std::endl; // 출력: 2 6
x1 = 10; x2 = 5;
Fn2(&x1, &x2);
std::cout << x1 << " " << x2 << std::endl; // 출력: 11 5
x1 = x2 = 5;
Fn2(&x1, &x2);
std::cout << x1 << " " << x2 << std::endl; // 출력: 5 5
std::cout << "\n### 3 ###" << std::endl;
int sum = 0, cnt = 0;
// 두 인수[10, 100] 범위 정수의 양수 합이 sum에 저장, 범위에 음수가 있으면 음수의 개수가 cnt에 저장
cnt = Fn3(10, 100, sum);
std::cout << cnt << " " << sum << std::endl;
// 출력: 0, 5005
cnt = Fn3(-4, 10, sum);
std::cout << cnt << " " << sum << std::endl;
// 출력: 4, 55
std::cout << "\n### 4 ###" << std::endl;
std::vector<int> v1{1, 5, 4, 3, 6};
// v1의 요소를 역순으로 변경
Fn4(v1);
Print(v1);
// 출력: 6, 3, 4, 5, 1,
std::cout << "\n### 5 ###" << std::endl;
const std::vector<int> a1{1, 3, 45, 2, 7};
const std::vector<int> a2{3, 4, 52, 1};
std::vector<std::vector<int>> v2;
// a1과 a2를 요소로 하는 v2 생성
v2 = Fn5(a1, a2);
Print(v2);
// 출력:
1, 3, 45, 2, 7,
3, 4, 52, 1,
std::cout << "\n### 6 ###" << std::endl;
// 출력되는 vector는 (아래 수식), f[x]는 크기가 N인 인수로 전달된 벡터
// 즉, 출력되는 벡터의 첫번째 요소는 (8*0 + 16*0 + 24*0 + 31*0 + 40*0 + 48*0 + 56*0 + 64*0)/8
// 두번째 요소는 (8*1 + 16*1 + 24*1 + 31*1 + 40*1 + 48*1 + 56*1 + 64*1)/8
// 세번째 요소는 (8*2 + 16*2 + 24*2 + 31*2 + 40*2 + 48*2 + 56*2 + 64*2)/8
const std::vector<double> v3{ 8, 16, 24, 31, 40, 48, 56, 64 };
Print(Fn6(v3));
// 출력: 0, 35.875, 71.75, 107.625, 143.5, 179.375, 215.25, 251.125,
std::cout << "\n### 7 ###" << std::endl;
// 인수를 8진수로 출력하는 recursive call 함수 작성, 함수에서는 한 자리의 출력만(cout) 가능
Fn7(255);
출력: 377
std::cout << std::endl;
Fn7(65536);
출력: 200000
}
2024-1, CSE103-00 - 오프라인 수업
/* Object-Oriented Programming, Midterm exam (2024-1, CSE103-00) */
#include <iostream>
#include <vector>
// 답안 코드 (함수) 작성 영역
void Print(const std::vector<int>& v) {
for (auto x : v)
std::cout << x << ", ";
std::cout << std::endl;
}
void Print(const std::vector<std::vector<int>>& v) {
for (auto row : v) {
for (auto x : row)
std::cout << x << ", ";
std::cout << std::endl;
}
std::cout << std::endl;
}
void Print(const std::vector<std::vector<int> *>& v) {
for (auto pRow : v) {
for (auto x : *pRow)
std::cout << x << ", ";
std::cout << std::endl;
}
std::cout << std::endl;
}
int main() {
// 전역 변수 및 static 변수 사용 금지
// 채점 기준: 1. 실행되지 않으면 0점 처리
// 2. 주어진 제한 조건을 위반하면 0점 처리
// 3. 문제(main 함수의 내용)를 수정하면 0점 처리
// 4. 일반적인 동작이 불가능한 경우 0점 처리 또는 감점(일반적인 입력에 대한 처리 등)
// 5. 연산자의 사용이 부정확한 경우 감점(예, &&를 사용할 위치에 &를 사용 등)
// 6. 필요없는 파라메터나 반환이 있으면 감점
// 7. 답안지에 코드 동작에 대한 설명이 없으면 0점 처리
/**********
1. 모든 문제는 한 개의 함수만 정의(function overloading 불가, 추가적인 사용자 함수를 정의할 수 없음)
2. 모든 문제에서 표준 함수는 사용할 수 없음, vector의 method는 사용가능
3. 모든 문제에서 recursive call 사용할 수 없음
**********/
// 1. 아래 코드에서 두 번째 인수로 첫 번째 인수를 나눈 결과가 출력되도록 Ex1 함수를 정의하라.
// 두 번째 인수가 0이면 0을 출력, 인수가 실수인 경우도 정수 부분만 전달되며, 나눗셈은 실수 나눗셈이다.
// if문을 사용할 수 없으며, 조건 연산자(conditional operator, ?:) 등과 같은 연산자만을 이용하여 한 개의 return 문장으로 작성하라.
std::cout << "\n### 1 ###" << std::endl;
//////// std::cout << Ex1(1, 3) << ", " << Ex1(1, 0) << ", " << Ex1(7.2, 7) << ", " << Ex1(3.9, 2.5) << ", " << std::endl;
// Print: 0.333333, 0, 1, 1.5,
// 2. 아래의 코드에서 앞의 두 인수(자연수)의 최대 공약수(gcd)와 공약수의 개수가 출력되도록 Ex2 함수를 정의하라.
// 앞의 두 인수가 자연수가 아니면(1보다 작으면), 모두 0을 출력한다.
std::cout << "\n### 2 ###" << std::endl;
int cdCnt = 0, gcd = 0;
//////// Ex2(4, 16, &gcd, cdCnt);
std::cout << "(" << gcd << ", " << cdCnt << "), "; // Print: (4, 3),
//////// Ex2(0, 15, &gcd, cdCnt);
std::cout << "(" << gcd << ", " << cdCnt << "), "; // Print: (0, 0),
//////// Ex2(12, 0, &gcd, cdCnt);
std::cout << "(" << gcd << ", " << cdCnt << "), "; // Print: (0, 0)
//////// Ex2(24, 36, &gcd, cdCnt);
std::cout << "(" << gcd << ", " << cdCnt << ")" << std::endl;; // Print: (12, 6)
// 3. 아래의 코드에서 인수의 cosine값이 출력되도록 Ex3 함수를 정의하라.
// sine(x) = x - (x*x*x/3!) + (x*x*x*x*x/5!) - (x*x*x*x*x*x*x/7!) + ...의 수식을 사용하며, 더해주는 항의 절댓값이 1.E-15보다 클때까지 계산한다. 인수는 [0, 2pi] 범위만 입력된다고 가정.
// Hint 1: 분자, 분모를 구분하여 계산, 누적 계산
// Hint 2: sign * = -1을 이용하여 덧샘항의 부호 판별
std::cout << "\n### 3 ###" << std::endl;
//////// std::cout << Ex3(30 * 3.14159 / 180.) << ", " << Ex3(60 * 3.14159 / 180.) << ", " << Ex3(90 * 3.14159 / 180.) << ", " << Ex3(180 * 3.14159 / 180.) << std::endl;
std::cout << sin(30 * 3.14159 / 180.) << ", " << sin(60 * 3.14159 / 180.) << ", " << sin(90 * 3.14159 / 180.) << ", " << sin(180 * 3.14159 / 180.) << std::endl;
// Print: 0.5, 0.866025, 1, 2.65359e-06
// 0.5, 0.866025, 1, 2.65359e-06
// 4. 아래의 코드에서 앞의 두 인수(양의 정수, [0, 0xFF] 범위)를 비트 단위 연산자(bitwise operator)를 이용하여 비트 단위로 연결하여 아래와 같이 출력되도록 한 개의 Ex4 함수를 정의하라.
// 세 번째 인수가 없거나 0이면 첫 번째 인수가 상위 16-9비트로 되어 결합되며, 0이 아니면 두 번째 인수가 상위 16-9비트로 결합된다.
// + 와 - 연산자는 사용할 수 없다.
// std::hex와 std::dec는 각각 16진수 출력과 10진수 출력을 지정한다.
std::cout << "\n### 4 ###" << std::endl;
//////// std::cout << std::hex << Ex4(0xFF1, 0xF9A) << ", "<< Ex4(0xF1, 0x9A, 1) << ", " << Ex4(0xF1, 0x9A, 0) << std::dec << std::endl;
// Print: f19a, 9af1, f19a
// Hint: (0xFF1, 0xF9A) -> (0xF1, 0x9A) -> (0xF100, 0x9A) -> 0xF19A
// 5. 아래의 코드에서 인수로 전달된 벡터(std::vector<int>)에서 양수인 요소만 출력하도록 Ex5 함수를 정의하라.
std::cout << "\n### 5 ###" << std::endl;
std::vector<int> v1{ 10, 3, 0, -2, -30 }, v2{ 1, -3, 0, 2, -30 };
std::vector<std::vector<int>> v0;
//////// v0 = Ex5(v1, v2);
Print(v0);
// Print: 10, 3,
// 1, 2,
//////// v0 = Ex5(std::vector<int>{1, 4, -4, -2, 7}, std::vector<int>{-2, -3, 4, -2, 9});
Print(v0);
// Print: 1, 4, 7,
// 4, 9,
//////// v0 = Ex5(std::vector<int>{-1, -4, -4, -2, -7}, std::vector<int>{-2, -3, 4, -2, 9});
Print(v0);
// Print: [blank]
// 4, 9,
// 6. 아래의 코드에서 인수로 전달된 2차원 벡터(std::vector<std::vector<int>>)의 2차원 요소(int)가 제곱으로 출력되도록 Ex6함수를 정의하라.
std::cout << "\n### 6 ###" << std::endl;
std::vector<std::vector<int>> v3{{1, 2, 3, -1, 7}, {9, -4, 2}, {3, -2, 9}};
//////// Ex6(&v3);
Print(v3);
// Print: 1, 4, 9, 1, 49,
// 81, 16, 4,
// 9, 4, 81,
// 7. 아래의 코드에서 인수로 전달된 2차원 벡터(std::vector<std::vector<int>>)의 요소(std::vector<int>)의 개수가 출력되도록 Ex7 함수를 정의하라.
// 단, 요소가 없는 1차원 벡터는 출력되지 않는다.
std::cout << "\n### 7 ###" << std::endl;
const std::vector<std::vector<int>> v4{ {1, 2, 3, -1, 7}, {}, {19}, {3, -2, 7} };
std::vector<int> v5;
//////// v5 = Ex7(v4);
Print(v5);
// Print: 5, 1, 3,
// 8. 아래 코드에서 std::vector<int>의 포인터(pointer)가 요소인 벡터에 두 개의 std::vector<int>의 주소를 저장하는 Ex8 함수를 정의하라.
std::cout << "\n### 8 ###" << std::endl;
std::vector <std::vector<int> *> v6;
std::vector<int> row1{ 1, 2, 3, 4 };
std::vector<int> row2{ 5, 6, 7, 8 };
//////// Ex8(&v6, &row1, &row2);
Print(v6);
// Print: 1, 2, 3, 4,
// 5, 6, 7, 8,
row2.push_back(9);
Print(v6);
// Print: 1, 2, 3, 4,
// 5, 6, 7, 8, 9,
}
2024-1, CSE103-01 - 온라인 수업
/* Object-Oriented Programming, Midterm exam (2024-1, CSE103-01) */
// 학과: 학번: 이름:
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <vector>
// 답안 작성 영역
void Print(const std::vector<int>& v) {
for (const auto &x : v)
std::cout << x << ", ";
std::cout << std::endl;
}
void Print(const std::vector<std::vector<double>>& v) {
for (const auto &r : v) {
for (const auto &x : r) {
std::cout << x << ", ";
}
std::cout << std::endl;
}
std::cout << std::endl;
}
int main() {
// 전역 변수 및 static 변수 사용 금지
// 채점 기준: 1. 실행되지 않으면 0점 처리
// 2. 주어진 제한 조건을 위반하면 0점 처리
// 3. 문제(main 함수의 내용)를 수정하면 0점 처리
// 4. 일반적인 동작이 불가능한 경우 0점 처리 또는 감점(일반적인 입력에 대한 처리 등)
// 5. 연산자의 사용이 부정확한 경우 감점(예, &&를 사용할 위치에 &를 사용 등)
// 6. 필요없는 파라메터나 반환이 있으면 감점
// 7. 답안지에 코드 동작에 대한 설명이 없으면 0점 처리
/**********
1. 각 문항별 //실행 확인//을 제거하고, 함수의 동작을 확인
2. 모든 문제는 한 개의 함수만 정의(function overloading 불가, 추가적인 사용자 함수를 정의할 수 없음)
3. 1-7번 문제에서 표준 함수는 사용할 수 없음 (8번은 사용 가능), vector의 method는 사용가능
4. 모든 문제에서 recursive call 사용할 수 없음
**********/
srand(static_cast<unsigned>(time(nullptr)));
// 1. 아래 코드에서 두 인수의 큰 값이 출력되도록 Mid1 함수를 정의하라.
// if문을 사용할 수 없으며, 조건 연산자(conditional operator, ?:)만을 이용하여 한 개의 return 문장으로 작성하라.
std::cout << "\n### 1 ###" << std::endl;
//실행 확인//std::cout << Mid1(-0.1, 0.5) << ", " << Mid1(10.5, 0.2) << ", " << Mid1(256., 256.) << std::endl;
// 출력: 0.5, 10.5, 256
// 2. 아래의 코드에서 두 인수 범위의 정수의 합을 출력하도록 Mid2 함수를 정의하라.
// 출력의 예와 같이, 합을 구하는 범위는 작은 수부터 큰 수까지의 합을 계산한다.
std::cout << "\n### 2 ###" << std::endl;
int sum = 0;
//실행 확인//Mid2(1, 10, sum);
std::cout << sum << std::endl; // [1, 10]의 합, 출력: 55
//실행 확인//Mid2(-3, 5, sum);
std::cout << sum << std::endl; // [-3, 5]의 합, 출력: 9
//실행 확인//Mid2(10, 1, sum);
std::cout << sum << std::endl; // [1, 10]의 합, 출력: 55
//실행 확인//Mid2(10, 10, sum);
std::cout << sum << std::endl; // [10, 10]의 합, 출력: 10
// 3. 아래의 코드에서 두 인수(문자)를 비교한 결과를 출력되도록 Mid3 함수를 정의하라.
// 두 인수는 대/소문자 알파벳에 관계없이 두 개가 같으면 0, 앞의 인수가 빠르면 1, 그렇지 않으면 -1이다.
// 알파벳의 제외한 다른 문자에 대해서는 고려하지 않는다.
std::cout << "\n### 3 ###" << std::endl;
//실행 확인//std::cout << Mid3('A', 'A') << ", " << Mid3('A', 'B') << ", " << Mid3('a', 'B') << ", " << Mid3('b', 'a') << std::endl;
// 출력: 0, 1, 1, -1
// 4. 아래의 코드에서 앞의 두 인수(자연수)의 공약수의 개수와 최대공약수가 출력되도록 Mid4 함수를 정의하라.
// 음수의 입력에 대해서 고려하지 않는다.
std::cout << "\n### 4 ###" << std::endl;
int nN = 0;
//실행 확인//std::cout << Mid4(18, 24, &nN) << ", "; // 최대 공약수 출력: 6
std::cout << nN << std::endl; // 공약수의 개수 출력: 4
//실행 확인//std::cout << Mid4(36, 52, &nN) << ", "; // 최대 공약수 출력: 4
std::cout << nN << std::endl; // 공약수의 개수 출력: 3
// 5. 아래의 코드에서 인수의 합이 출력되도록 한 개의 Mid5 함수를 정의하라.
// Function overloading을 사용하면 0점 처리
std::cout << "\n### 5 ###" << std::endl;
//실행 확인//std::cout << Mid5(1, 4) << ", " << Mid5(5, 2, 3) << ", " << Mid5(5, 2, 0) << std::endl;
// 출력: 5, 10, 7
// 6. 아래의 코드에서 v1의 요소가 절대값을 출력하도록 Mid6 함수를 정의하라.
// 표준함수를 사용하면 0점 처리
std::cout << "\n### 6 ###" << std::endl;
std::vector<int> v1{ 3, 4, 6, -1, 8 };
//실행 확인//Mid6(v1);
Print(v1); // 출력: 3, 4, 6, 1, 8,
// 7. 아래의 코드에서 인수로 전달된 2차원 벡터(std::vector<std::vector>)를 1차원으로 분해해서 출력하도록 Mid7 함수를 정의하라.
std::cout << "\n### 7 ###" << std::endl;
std::vector<int> v2(5);
const std::vector<std::vector<int>> v3{ {13, 2, 24, 5}, { -5, 22, -2, 4, 36, 34 } };
//실행 확인//v2 = Mid7(v3);
Print(v2); // 출력: 13, 2, 24, 5, -5, 22, -2, 4, 36, 34,
//실행 확인//v2 = Mid7(std::vector<std::vector<int>>{ {12, 3, 7, 12}, {}, { 123 }, { 45, 23 }});
Print(v2); // 출력: 12, 3, 7, 12, 123, 45, 23,
// 8. 아래의 코드에서 두 인수(rows와 cols)에 대해서 cols 크기의 벡터(std::vector)를 요소로 하는 벡터(std::vector)를 생성하여 출력하도록 Mid8 함수를 정의하라.
// 2차원 벡터의 요소는 [0, 1] 범위의 난수가 저장된다.
// 음수의 전달은 고려하지 않은다.
std::cout << "\n### 8 ###" << std::endl;
std::vector<std::vector<double>> v4;
int rows = 3, cols = 4;
//실행 확인//v4 = Mid8(rows, cols);
Print(v4);
// 출력 예: 0.00125126, 0.563585, 0.193304, 0.808741,
// 0.585009, 0.479873, 0.350291, 0.895962,
// 0.82284, 0.746605, 0.174108, 0.858943,
rows = 5, cols = 3;
//실행 확인//v4 = Mid8(rows, cols);
Print(v4);
// 출력 예: 0.710501, 0.513535, 0.303995,
// 0.0149846, 0.0914029, 0.364452,
// 0.147313, 0.165899, 0.988525,
// 0.445692, 0.119083, 0.00466933,
// 0.0089114, 0.37788, 0.531663,
rows = 0, cols = 3;
//실행 확인//v4 = Mid8(rows, cols);
Print(v4);
// 출력 없음
}
2023-2, CSE103-00 - 오프라인 수업
/* Object-Oriented Programming, Midterm exam (2023-2, CSE103-00) */
#include <iostream>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <vector>
#include <cmath>
// 답안 함수 작성 영역
void Print(const std::vector<int>& v) {
for (auto x : v)
std::cout << x << ", ";
std::cout << std::endl;
}
void Print(const std::vector<std::vector<int>>& v) {
for (auto row : v) {
for (auto x : row)
std::cout << x << ", ";
std::cout << std::endl;
}
std::cout << std::endl;
}
int main() {
// 전역 변수 및 static 변수 사용 금지
// 채점 기준: 1. 실행되지 않으면 0점 처리
// 2. 주어진 제한 조건을 위반하면 0점 처리
// 3. 문제(main 함수의 내용)를 수정하면 0점 처리
// 4. 일반적인 동작이 불가능한 경우 0점 처리 또는 감점(일반적인 입력에 대한 처리 등)
// 5. 연산자의 사용이 부정확한 경우 감점(예, &&를 사용할 위치에 &를 사용 등)
// 6. 필요없는 파라메터나 반환이 있으면 감점
// 7. 답안지에 코드 동작에 대한 설명이 없으면 0점 처리
// 1. 아래 코드에서 첫 번째 인수가 두 번째 인수보다 크면 1을, 작으면 -1을, 같으면 0이 출력되도록 Ex1 함수를 정의하라.
// 표준함수를 사용할 수 없으며, 두 개의 조건 연산자(conditional operator)만을 사용한다.
std::cout << "\n### 1 ###" << std::endl;
//std::cout << Ex1(1, 3) << ", " << Ex1(1, -3) << ", " << Ex1(7, 7) << ", " << Ex1(9, 2) << ", " << std::endl;
// 출력: -1, 1, 0, 1,
// 2. 아래의 코드에서 앞의 두 인수(정수)의 범위의 짝수의 합과 홀수의 합이 출력되도록 Ex2 함수를 정의하라.
// 표준함수를 사용할 수 없다.
// [첫 번째 인수, 두 번째 인수]
std::cout << "\n### 2 ###" << std::endl;
int sum1 = 0, sum2 = 0;
//Ex2(7, 10, sum1, &sum2);
std::cout << "(" << sum1 << ", " << sum2 << "), "; // 출력: (18, 16),
//Ex2(10, 15, sum1, &sum2);
std::cout << "(" << sum1 << ", " << sum2 << "), "; // 출력: (36, 39),
//Ex2(-4, 2, sum1, &sum2);
std::cout << "(" << sum1 << ", " << sum2 << "), "; // 출력: (-4, -3)
//Ex2(4, 2, sum1, &sum2);
std::cout << "(" << sum1 << ", " << sum2 << ")" << std::endl;; // [4,2] 범위의 정수가 없으므로 모두 0, 출력: (0, 0)
// 3. 아래의 코드에서 인수의 cosine값이 출력되도록 Ex3 함수를 정의하라.
// fabs 함수를 제외한 표준함수 및 추가 사용자 함수를 사용할 수 없다.
// cosine(x) = 1 - (x*x/2!) + (x*x*x*x/4!) - (x*x*x*x*x*x/6!) + ...의 수식을 사용하며, 더해주는 항의 절댓값이 1.E-15보다 클때까지 계산한다.
// 힌트 1: 분자, 분보를 구분하여 계산, 누적 계산
// 힌트 2: sign * = -1을 이용하여 덧샘항의 부호 판별
std::cout << "\n### 3 ###" << std::endl;
//std::cout << Ex3(30 * 3.14159 / 180.) << ", " << Ex3(60 * 3.14159 / 180.) << ", " << Ex3(90 * 3.14159 / 180.) << ", " << Ex3(180 * 3.14159 / 180.) << std::endl;
std::cout << cos(30 * 3.14159 / 180.) << ", " << cos(60 * 3.14159 / 180.) << ", " << cos(90 * 3.14159 / 180.) << ", " << cos(180 * 3.14159 / 180.) << std::endl;
// 출력: 0.866026, 0.500001, 1.32679e-06, -1
// 0.866026, 0.500001, 1.32679e-06, -1
// 4. 아래의 코드에서 앞의 두 인수(양의 정수, [0, 0xFF] 범위)를 비트 단위 연산자(bitwise operator)를 이용하여 비트 단위로 연결하여 아래와 같이 출력되도록 Ex4 함수 한 개를 정의하라.
// 세 번째 인수가 없거나 0이면 첫 번째 인수가 상위 16-9비트로 되어 결합되며, 0이 아니면 두 번째 인수가 상위 16-9비트로 결합된다.
// 표준함수는 사용할 수 없다.
// Function overloading을 사용할 수 없다.
// std::hex와 std::dec는 각각 16진수 출력과 10진수 출력을 지정한다.
std::cout << "\n### 4 ###" << std::endl;
//std::cout << std::hex << Ex4(0xF1, 0x9A) << ", "<< Ex4(0xF1, 0x9A, 1) << ", " << Ex4(0xF1, 0x9A, 0) << std::dec << std::endl;
// 출력: f19a, 9af1, f19a
// 힌트: (0xF1, 0x9A) -> (0xF100, 0x9A) -> 0xF19A
// 5. 아래의 코드에서 인수로 전달된 벡터(std::vector<int>)의 요소가 양수인 경우에만 1의 자리 값이 출력되도록 Ex5 함수를 정의하라.
// Function overloading을 사용할 수 없다.
std::cout << "\n### 5 ###" << std::endl;
std::vector<int> v1{10, 3, 0, -2, -30}, v2;
//v2 = Ex5(v1);
Print(v2); // 출력: 0, 3,
//v2 = Ex5(std::vector<int>{1, 23, -4, -32, 79});
Print(v2); // 출력: 1, 3, 9,
// 6. 아래의 코드에서 인수로 전달된 2차원 벡터(std::vector<std::vector<int>>)의 2차원 요소(int)의 부호가 변경되어 출력되도록 Ex6함수를 정의하라.
// 표준함수를 사용할 수 없다.
std::cout << "\n### 6 ###" << std::endl;
std::vector<std::vector<int>> v3{{1, 2, 3, -1, 7}, {9, -4, 2}, {3, -2, 9}};
//Ex6(v3);
Print(v3);
// 출력: -1, -2, -3, 1, -7,
// -9, 4, -2,
// -3, 2, -9,
// 7. 아래의 코드에서 인수로 전달된 2차원 벡터(std::vector<std::vector<int>>)의 요소(std::vector<int>)의 최대 요소(int)가 출력되도록 Ex7 함수를 정의하라.
std::cout << "\n### 7 ###" << std::endl;
const std::vector<std::vector<int>> v4{ {1, 2, 3, -1, 7}, {19, -4, 2}, {3, -2, 7} };
std::vector<int> v5;
//v5 = Ex7(v4);
Print(v5);
// {1, 2, 3, -1, 7}의 최댓값 7, {19, -4, 2}의 최댓값 19, {3, -2, 7}의 최댓값 7이 출력됨, 출력: 7, 19, 7,
// 8). 아래 코드에서 인수를 16진수로 출력하는 Ex8 함수를 recursive call을 이용하여 정의하라.(가능한 효율적이고 간단하게 작성, 음수는 고려하지 않음)
// 표준함수를 사용할 수 없다.
// 힌트 1: 27 -> 27%16 = 11(B), 27/16 = 1
// 힌트 2: (char)('A' + 2) -> 'C'
std::cout << "\n### 8 ###" << std::endl;
//Ex8(27); // 출력: 1B
std::cout << std::endl;
//Ex8(0x1F3); // 출력: 1F3
std::cout << std::endl;
}
2023-2, CSE103-02 - 온라인 수업
/* Object-Oriented Programming, Midterm exam (2023-2, CSE103-02) */
#include <iostream>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <vector>
void Print(std::vector<char> v) {
for (auto x : v)
std::cout << x << ", ";
std::cout << std::endl;
}
void Print(std::vector<int> v) {
for (auto x : v)
std::cout << x << ", ";
std::cout << std::endl;
}
int main() {
// 전역 변수 및 static 변수 사용 금지
// 채점 기준: 1. 주어진 제한 조건을 위반하면 0점 처리
// 2. 문제(main 함수의 내용)를 수정하면 0점 처리
// 3. 일반적인 동작이 불가능한 경우 0점 처리 또는 감점(일반적인 입력에 대한 처리 등)
// 4. 연산자의 사용이 부정확한 경우 감점(예, &&를 사용할 위치에 &를 사용 등)
// 5. 필요없는 파라메터나 반환이 있으면 감점
// 6. 답안지에 코드 동작에 대한 설명이 없으면 0점 처리
// 1. 아래 코드에서 인수의 범위가 [0, 255]까지는 인수 값을 0보다 작으면 0을 255보다 크면 255를 출력하도록 Mid1 함수를 정의하라.
// 표준함수를 사용할 수 없으며, 두 개의 조건 연산자(conditional operator)만을 사용한다.
std::cout << "\n### 1 ###" << std::endl;
//std::cout << Mid1(-0.1) << ", " << Mid1(10.5) << ", " << Mid1(256.) << std::endl;
// 출력: 0, 10.5, 255
// 2. 아래의 코드에서 앞의 두 인수의 작은 값과 큰 값을 출력하도록 Mid2 함수를 정의하라.
// 표준함수를 사용할 수 없으며, 한 개의 if - else 문을 사용한다.
std::cout << "\n### 2 ###" << std::endl;
int x, y, min = 0, max = 0;
x = 10, y = 20;
//Mid2(x, y, min, &max);
std::cout << min << ", " << max << std::endl; // 출력: 10, 20
x = 35, y = 2;
//Mid2(x, y, min, &max);
std::cout << min << ", " << max << std::endl; // 출력: 2, 35
// 3. 아래의 코드에서 두 인수(정수) 범위의 짝수의 합을 출력하도록 Mid3 함수를 정의하라.
std::cout << "\n### 3 ###" << std::endl;
//std::cout << Mid3(1, 2) << ", " << Mid3(3, 2) << ", " << Mid3(1, 10) << ", " << Mid3(-10, 12) << std::endl;
// 출력: 2, 0, 30, 12
// 4. 아래의 코드에서 인수(양의 정수)에 하위 16비트에서 9비트까지의 8비트를 추출하는 Mid4 함수를 정의하라.
// 표준함수는 사용할 수 없으며, 비트 단위 연산자(bitwise operator)와 할당 연산자(assignment operator)를 사용한다.
// std::hex와 std::dec는 각각 16진수 출력과 10진수 출력을 지정한다.
std::cout << "\n### 4 ###" << std::endl;
//std::cout << std::hex << Mid4(0x00F2F7A8) << ", " << std::hex << Mid4(0x00028328) << std::dec << std::endl;
// 출력: f7, 83
// 힌트: 0x00F2F7A8 -> 0x0000F2F7 -> 0x000000F7, 0x00028328 -> 0x00000283 -> 0x00000083
// 5. 아래의 코드에서 첫번째와 두번째 호출은 앞의 두 인수의 합을 마지막 호출에서는 앞의 두 인수의 곱을 반환하는 함수를 1개 정의하라.
// Function overloading을 사용할 수 없다.
std::cout << "\n### 5 ###" << std::endl;
//std::cout << Mid5(1, 4) << ", " << Mid5(5, 2, 0) << ", " << Mid5(5, 2, 1) << ", " << std::endl;
// 출력: 5, 7, 10,
// 6. 아래의 코드에서 v1의 요소가 알파벳 소문자이면 대문자로 변환되어 출력하도록 Mid6 함수를 정의하라.
// 표준함수를 사용할 수 없다.
std::cout << "\n### 6 ###" << std::endl;
std::vector<char> v1{ '?', 'a', 'B', 'c', '9' };
//Mid6(v1);
Print(v1); // 출력: ?, A, B, C, 9,
// 7. 아래의 코드에서 인수로 전달된 벡터(std::vector)의 요소가 10보다 같거나 크면, 10의 자리를 요소로 가지는 벡터를 반환하는 Mid7 함수를 정의하라.
std::cout << "\n### 7 ###" << std::endl;
std::vector<int> v2(5);
const std::vector<int> v3{ 13, 2, 632, 24, 5 };
//v2 = Mid7(v3);
Print(v2); // 출력: 1, 3, 2,
//v2 = Mid7(std::vector<int>{128, 3, 7, 12});
Print(v2); // 출력: 2, 1
// 8. 아래의 코드에서 인수(양의 정수)의 역방향 출력과 순방향 출력을 수행하는 Mid8 함수를 정의하라.
// Mid8 함수는 한 번의 recursive call을 가지며, 최대한 간단히 코드가 작성되어야 한다.
std::cout << "\n### 8 ###" << std::endl;
//Mid8(123); std::cout << ", "; Mid8(752); std::cout << ", " << std::endl;
// 출력: 321123, 257752,
}