객체지향프로그래밍1 1번
"Hello1"은 10번 출력됩니다. 이 때, sum1은 0 + 1 + 2 + ... + 9로 계산되어 총 45가 됩니다.
"Hello2"는 11번 출력됩니다. 이 때, sum2는 0 + 1 + 2 + ... + 10로 계산되어 총 55가 됩니다.
"Hello3"은 10번 출력됩니다. 이 때, sum3은 1 + 2 + ... + 10로 계산되어 총 55가 됩니다.
따라서 "Hello1"은 10번, "Hello2"는 11번, "Hello3"은 10번 출력되며, sum1은 45, sum2와 sum3은 각각 55입니다.
객체지향프로그래밍 1 2번
정답 : 8
1부터 시작하여 2를 곱해가면서 i의 값이 128보다 작거나 같은 경우에만 반복문이 실행됩니다. 따라서 i 는 1, 2, 4, 8, 16, 32, 64, 128이 됩니다. 이는 2의 제곱수들을 나타냅니다. 따라서 반복문은 총 8번 실행되며, count의 값은 8이 됩니다. 따라서 출력 결과는 8이 됩니다.
정답 : 4
초기에 변수 i는 9384로 설정됩니다. 그리고 i가 0보다 큰 동안에, 매 반복마다 i를 10으로 나누어 줄입니다. 이는 i의 값이 각 자릿수를 차례로 탐색하는 과정입니다. 따라서 9384를 나누어 줄 때마다 count는 1씩 증가하게 됩니다. 이 과정을 통해 총 4번의 나눗셈이 이루어지므로 count의 값은 4가 됩니다. 따라서 출력 결과는 4가 됩니다.
출력 결과 : 10 5 3 2 1 (1무한대)
초기에 i는 10으로 설정됩니다. 그리고 매 반복마다 i를 2로 나누어주며 출력합니다.
i가 10일 때, 출력 후에 i가 1 증가하여 11이 됩니다.
i가 11일 때, 2로 나누면 5가 되며, 출력 후에 i가 1 증가하여 6이 됩니다.
i가 6일 때, 2로 나누면 3이 되며, 출력 후에 i가 1 증가하여 4가 됩니다.
i가 4일 때, 2로 나누면 2가 되며, 출력 후에 i가 1 증가하여 3이 됩니다.
i가 3일 때, 2로 나누면 1이 되며, 출력 후에 i가 1 증가하여 2가 됩니다.
i가 2일 때, 2로 나누면 1이 되며, 출력 후에 i가 1 증가하여 3이 됩니다.
i가 3일 때, 2로 나누면 1이 되며, 출력 후에 i가 1 증가하여 4가 됩니다.
...
위 과정이 무한히 반복됩니다.
따라서 이 코드는 무한 루프에 빠지게 됩니다.
객체지향프로그래밍 3번
(a)와 (b)는 완전히 동일한 의미를 갖습니다. 즉, i가 0부터 시작하여 9까지 증가하면서 반복됩니다. 각 반복에서 i는 1씩 증가하게 되며, 반복 조건을 평가하기 전에 i가 증가되기 때문에 동일한 결과를 얻습니다.
(c)는 다른 의미를 갖습니다. 이 경우 반복문의 조건식은 i++ < 10으로 설정되어 있습니다. 이는 후위 증가 연산자를 사용하여 i를 증가시킨 후에 그 결과를 평가하는 것을 의미합니다. 따라서 초기에 i는 0입니다. 조건식이 참이면서 i가 1씩 증가합니다. 그러나 이러한 증가는 반복문의 내부에서 이뤄지기 때문에 조건식 평가 시에는 이미 증가된 값이 반영됩니다. 이렇게 되면 반복문의 내부에서는 i가 1부터 시작하여 10까지 증가하게 되지만, 반복 조건식은 0부터 시작하여 9까지 증가하므로 조건이 항상 참이 되어 무한 루프에 빠지게 됩니다.
or
(a)와 (b)는 완전히 동일한 동작을 수행합니다. 두 경우 모두 i를 0부터 시작하여 10보다 작을 때까지 반복하고, 반복이 한 번 실행될 때마다 i를 증가시킵니다. 따라서 두 루프는 모두 0부터 9까지의 값을 반복적으로 출력합니다.
(c)의 경우는 for 루프의 증감식 부분에 후치 증가 연산자를 사용합니다. 이는 루프가 실행된 후에 i가 증가됩니다. 따라서 루프가 처음 실행될 때 i는 0이며, 루프가 종료될 때까지 i는 9입니다. 그러나 루프 내에서 i가 증가되지 않기 때문에 루프가 실행될 때마다 i 값이 출력되지 않습니다. 따라서 (c)는 반복하는 동안 i 값을 출력하지 않고 10번 반복하게 됩니다.
객체지향프로그래밍 4번
(a) then 키워드는 C++에서 사용되지 않습니다. 제거해야 합니다.
수정: if (a > b) c = 0;
(b) 조건문을 {}로 감싸야 합니다.
수정: if (a > b) { c = 0; }
(c) 올바른 문법입니다.
(d) c = 0 뒤에 세미콜론을 붙여야 한다.
수정: if (a > b) c = 0; else b = 0;
(e) if 문 안에서는 단일 조건을 평가해야 합니다. a < b < c는 C++에서 올바른 방식이 아닙니다. 대신 두 개의 비교 연산자를 사용하여 각각의 조건을 분리해야 합니다.
수정: if (a < b && b < c) center = b
객체지향프로그래밍 5번
if (age >= 13 && age <= 19)
teenager = true;
else
teenager = false;
객체지향프로그래밍 6번
if (i > j) {
if (i > k)
result = i;
else
result = k;
} else {
if (j > k)
result = j;
else
result = k;
}
cout << result << endl;
위 코드는 다음과 같은 로직을 가집니다:
i가 j보다 크면:
만약 i가 k보다 크면 result에 i를 할당합니다.
그렇지 않으면(i가 k보다 작거나 같으면) result에 k를 할당합니다.
그렇지 않으면(즉, i가 j보다 작거나 같으면):
만약 j가 k보다 크면 result에 j를 할당합니다.
그렇지 않으면(j가 k보다 작거나 같으면) result에 k를 할당합니다.
결과적으로 result에는 i, j, k 중에서 가장 큰 값이 할당됩니다
객체지향프로그래밍 7번
if (i > j && i > k)
result = i;
else if (j > k)
result = j;
else
result = k;
cout << result << endl;
객체지향프로그래밍 8번
#include <iostream>
using namespace std;
int main()
{
int y1, m1, d1, y2, m2, d2;
cin >> y1 >> m1 >> d1;
cin >> y2 >> m2 >> d2;
if ((y1 < y2) || (y1 == y2 && m1 < m2) || (y1 == y2 && m1 == m2 && d1 < d2))
cout << -1 << endl;
else if ((y1 > y2) || (y1 == y2 && m1 > m2) || (y1 == y2 && m1 == y2 && d1 > d2))
cout << 1 << endl;
else
cout << 0 << endl;
return 0;
}
객체지향프로그래밍 9번
#include <iostream>
using namespace std;
int main()
{
int score;
cin >> score;
if (score >= 90)
cout << "A" << endl;
else if (score >= 80)
cout << "B" << endl;
else if (score >= 70)
cout << "C" << endl;
else if (score >= 60)
cout << "D" << endl;
else
cout << "F" << endl;
return 0;
}
객체지향프로그래밍 10번
#include <iostream>
#include <vector>
using namespace std;
int main()
{
int a, b, c;
cin >> a >> b >> c;
if ((a + b) > c && (b + c) > a && (c + a > b) )
cout << "Yes" << endl;
else
cout << "No" << endl;
}
객체지향프로그래밍 11번
#include <iostream>
using namespace std;
int main()
{
int value;
cin >> value;
if (value >= 20000000)
cout << 100000 + value * 0.0022 << endl;
else if (value >= 6250000)
cout << 76000 + value * 0.0032 << endl;
else if (value >= 2500000)
cout << 56000 + value * 0.0066 << endl;
else
{
int result = 30000 + value * 0.017;
if (result >= 39000)
cout << result << endl;
else
cout << 39000 << endl;
}
}
객체지향프로그래밍 12번
#include <iostream>
using namespace std;
int main()
{
int a, b, c, d;
cin >> a >> b >> c >> d;
if ((b >= c && b <= d) || (a >= c && a <= d))
cout << "yes" << endl;
else
cout << "no" << endl;
}za, b, c, d를 입력으로 받습니다.
if 문에서는 두 구간이 겹치는지를 판단합니다. 만약 두 구간 중 하나의 끝점이 다른 구간 안에 위치하면 겹치는 것으로 간주합니다.
b >= c && b <= d는 구간 [a, b]의 끝점이 구간 [c, d] 안에 있는지를 검사합니다.
a >= c && a <= d는 구간 [c, d]의 시작점이 구간 [a, b] 안에 있는지를 검사합니다.
두 경우 중 하나라도 참이면 "yes"를 출력하고, 그렇지 않으면 "no"를 출력합니다.
즉, 코드는 두 구간이 겹치면 "yes"를 출력하고, 그렇지 않으면 "no"를 출력합니다.
객체지향프로그래밍 13번
#include <iostream>
using namespace std;
int main()
{
int i = -5;
while (i <= 5)
{
if (i >= 0)
break;
else
{
i++;
continue;
}
cout << "Hello" << endl;
}
}이 코드에서는 i가 -5부터 시작하여 while 루프를 통해 5까지 증가하면서 반복됩니다. 그러나 if 문에서 i가 0 이상이면 루프를 빠져나가는 break 문이 있기 때문에 i가 0 이상인 경우 루프가 종료됩니다.
따라서 cout << "Hello" << endl; 부분은 i가 0 미만인 경우에만 실행됩니다. 즉, -5, -4, -3, -2, -1의 경우에만 "Hello"가 출력됩니다. 그 이후에는 i가 0보다 크거나 같아서 break 문에 의해 루프가 종료되기 때문에 "Hello"가 출력되지 않습니다.
"Hello"는 출력되지 않습니다. 왜냐하면 i가 0보다 크거나 같을 때 루프가 종료되므로 cout << "Hello" << endl; 부분이 실행되지 않기 때문입니다.
객체지향프로그래밍 14번
#include <iostream>
using namespace std;
int main()
{
int i = 3;
while (i--)
{
int i = 100;
i--;
cout << i << endl;
}
}내부 루프의 int i = 100;에서 변수 i는 외부 루프의 i와는 다른 지역 변수입니다. 내부 루프가 실행될 때마다 100으로 초기화되고, 그 후에 i--가 실행되므로 출력되는 값은 항상 99입니다. 그래서 indeed, 99가 3번 출력됩니다.
객체지향프로그래밍 15번
#include <iostream>
using namespace std;
int main()
{
int N;
cin >> N;
int i = 1;
while (i * i <= N) {
cout << i * i << " ";
i++;
}
cout << endl;
return 0;
}이 코드는 사용자로부터 하나의 양의 정수를 입력받은 후, 그 정수보다 작거나 같은 모든 제곱수를 출력합니다.
먼저 사용자로부터 정수 N을 입력받습니다. 그리고 변수 i를 1로 초기화합니다. 그런 다음, while 루프를 사용하여 i의 제곱이 N 이하인 동안 반복합니다.
반복할 때마다 i의 제곱을 출력하고, i를 1씩 증가시킵니다. 이를 통해 N 이하의 모든 제곱수를 출력할 수 있습니다.
코드 실행 결과는 사용자가 입력한 정수 N 이하의 모든 제곱수가 출력됩니다.
객체지향프로그래밍 16번
#include <iostream>
using namespace std;
int main()
{
int n = 123456789;
int m = 0;
while (n > 0)
{
m = (10 * m) + (n % 10);
n = n / 10;
}
cout << m << " " << n;
return 0;
}이 코드는 주어진 정수 n을 역순으로 바꾸는 기능을 수행합니다.
주어진 정수 n이 123456789일 때, while 루프를 통해 n이 0보다 클 때까지 반복합니다.
반복할 때마다 m에는 기존의 m을 10배한 값에 n을 10으로 나눈 나머지를 더해줍니다. 이를 통해 m에는 n의 역순이 저장됩니다.
n은 10으로 나누어 자릿수를 하나씩 줄여가며 역순으로 된 m을 만들기 위해 사용됩니다.
코드 실행 결과는 m에는 n의 역순이 저장되고, n은 0이 됩니다. 따라서 출력은 m인 987654321과 n인 0이 됩니다.
객체지향프로그래밍 17번 *
N이 1 이상인 경우, v를 2씩 곱해가며 N/2 이하의 2의 거듭제곱 수를 계산합니다. (맞음)
N이 1 이상인 경우, v를 2씩 곱해가며 N/2 이하의 2의 거듭제곱 수를 계산합니다. (틀림: for 루프의 조건식이 세미콜론(;)으로 끝나므로 루프가 한 번 실행된 후 종료됩니다.)
N이 1 이상인 경우, v를 2씩 곱해가며 N/2 이하의 2의 거듭제곱 수를 계산합니다. (맞음)
객체지향프로그래밍 18번
#include <iostream>
using namespace std;
int main()
{
int n;
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
cout << "hello1" << endl;
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++)
cout << "hello2" << endl;
for (int i = 0; i < n; i++)
for (int j = 0; j < i; j++)
cout << "hello3" << endl;
for (int i = n - 1; i >= 0; i--)
for (int j = 0; j <= i; j++)
cout << "hello4" << endl;
}첫 번째 루프: n * n번 출력됩니다.
두 번째 루프: (n^2 + n) / 2번 출력됩니다.
세 번째 루프: (n^2 - n) / 2번 출력됩니다.
네 번째 루프: (n^2 + n) / 2번 출력됩니다.
첫 번째 루프(i와 j 모두 0에서 n까지 증가): "hello1"을 출력합니다. 총 n*n번 출력됩니다.
두 번째 루프(i가 0부터 n까지, j가 i부터 n까지 증가): "hello2"를 출력합니다. i가 증가함에 따라 출력되는 "hello2"의 수가 줄어듭니다.
세 번째 루프(i가 0부터 n까지, j가 0부터 i-1까지 증가): "hello3"을 출력합니다. i가 증가할수록 출력되는 "hello3"의 수가 늘어납니다.
네 번째 루프(i가 n-1부터 0까지 감소, j가 0부터 i까지 증가): "hello4"를 출력합니다. i가 감소함에 따라 출력되는 "hello4"의 수가 줄어듭니다.
객체지향프로그래밍 19번
이 프로그램은 세 개의 반복문을 사용하여 1부터 limit까지의 세 개의 수를 각각 i, j, k에 할당합니다. 그런 다음 이들 수의 합이 10의 배수인 경우 count를 증가시킵니다.
첫 번째 반복문에서는 i를 1부터 limit까지 반복하며, 두 번째 반복문에서는 j를 i+1부터 limit까지 반복합니다. 세 번째 반복문에서는 k를 j+1부터 limit까지 반복합니다. 이들 반복문을 통해 모든 가능한 세 개의 수를 조합합니다. 그런 다음 i, j, k의 합이 10의 배수인 경우 count가 증가됩니다.
즉, 세 개의 수를 조합하여 합이 10의 배수인 경우의 수를 찾고, 그 경우의 수를 count에 저장하고 출력합니다.
객체지향프로그래밍 20번
#include <iostream>
using namespace std;
int main() {
for (int a = 1; a <= 1000; ++a) {
for (int b = 1; b <= 1000; ++b) {
int c = 1;
for (int i = 0; i < b; ++i) {
c *= a;
if (c > 1000)
break;
}
if (c <= 1000)
cout << a << "^" << b << " = " << c << endl;
else
break;
}
}
return 0;
} 프로그램은 이중 반복문을 사용하여 1부터 1000까지의 모든 양의 정수 a와 b에 대해 a^b 값을 계산하고 출력합니다.
바깥쪽 반복문은 a를 1부터 1000까지 증가시키며, 안쪽 반복문은 b를 1부터 1000까지 증가시킵니다. 이때 안쪽 반복문에서는 a를 b번 곱한 값을 c에 저장합니다. 그러나 c가 1000을 초과하는 경우 안쪽 반복문을 종료합니다.
안쪽 반복문이 종료된 후에는 c가 1000 이하인 경우에만 a^b의 값을 출력합니다. 그렇지 않으면 바깥쪽 반복문을 종료하고 프로그램을 종료합니다.
객체지향프로그래밍 21번
#include <iostream>
using namespace std;
int main() {
int a[10];
for (int i = 0; i < 10; i++)
a[i] = 9 - i;
for (int i = 0; i < 10; i++)
a[i] = a[a[i]];
for (int i = 0; i < 10; i++)
cout << a[i] << " ";
}이 코드는 다음과 같은 순서로 동작합니다:
먼저 크기가 10인 정수형 배열 a를 선언합니다.
첫 번째 반복문에서는 배열 a에 값을 초기화합니다. a[i]에는 9 - i의 값이 저장됩니다. 따라서 a 배열에는 9부터 0까지의 값이 역순으로 저장됩니다.
두 번째 반복문에서는 배열 a를 더 복잡하게 수정합니다. a[i]의 값을 다시 a[a[i]]로 바꿉니다. 이 때, a[i]는 현재 반복에서 9부터 0까지의 값이 순서대로 들어있으므로, a[a[i]]는 a[9-i]의 값이 됩니다.
세 번째 반복문에서는 수정된 a 배열을 출력합니다.
따라서 출력 결과는 다음과 같습니다:
Copy code
0 1 2 3 4 4 3 2 1 0
첫 번째 반복문에서 a 배열에는 9, 8, 7, ..., 0이 저장됩니다.
두 번째 반복문에서 a 배열의 값을 a[a[i]]로 바꾸면서, a 배열의 값을 역순으로 채워넣습니다.
세 번째 반복문에서 수정된 a 배열의 값을 출력합니다.
객체지향프로그래밍 22번
프로그램에서 발생하는 오류는 배열 b에 배열 a를 할당하는 부분입니다. C++에서는 배열의 할당이나 복사를 위해 배열 전체를 대입하는 방식을 사용할 수 없습니다.
배열을 복사하기 위해서는 루프나 라이브러리 함수를 사용해야 합니다. 여기서는 루프를 사용하여 배열 a의 각 요소를 배열 b에 복사해야 합니다.
수정된 코드는 다음과 같습니다.
#include <iostream>
using namespace std;
int main() {
int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int b[10];
// 배열 a의 각 요소를 배열 b에 복사
for (int i = 0; i < 10; i++)
b[i] = a[i];
// 배열 b의 값을 출력
for (int i = 0; i < 10; i++)
cout << b[i] << " ";
cout << endl;
return 0;
}
객체지향프로그래밍 23번
#include <iostream>
using namespace std;
int main() {
int a[100];
a[0] = 1;
a[1] = 1;
for (int i = 2; i < 100; i++)
a[i] = a[i - 1] + a[i - 2];
}주어진 프로그램은 피보나치 수열을 계산하는 것입니다. 피보나치 수열은 처음 두 항이 1이고, 그 뒤의 항은 바로 앞의 두 항을 더한 값으로 이루어지는 수열입니다. 주어진 프로그램은 배열 a에 피보나치 수열의 각 항을 계산하여 저장하는 역할을 합니다. 처음 두 항은 1이고, 그 이후의 항은 바로 앞의 두 항을 더한 값으로 계속해서 배열에 저장됩니다.
단순히 100개의 요소를 가진 배열을 사용하여 피보나치 수열의 처음 100개의 항을 계산하고 있습니다. 처음 두 항은 각각 1이며, 그 이후의 항들은 바로 앞의 두 항을 더한 값입니다. 이러한 과정을 통해 배열 a에는 피보나치 수열의 처음 100개의 항이 저장됩니다.
객체지향프로그래밍 24번
주어진 프로그램은 배열 b에 저장된 실수들을 역순으로 뒤집는 것입니다. temp라는 임시 변수를 사용하여 값을 교환하는 방식으로 역순으로 뒤집습니다. 앞쪽에 있는 요소와 뒤쪽에 있는 요소를 교환하여 배열을 역순으로 만듭니다. 그러나 프로그램에 오타가 있습니다. b[N-l-i]를 b[N-i-1]로 수정해야 합니다.
배열 b에 저장된 실수들을 역순으로 뒤집는 것입니다. 처음 절반의 요소와 마지막 절반의 요소를 교환하여 배열을 역순으로 만듭니다. 다만, 주의할 점은 b[N-l-i]에서 오타가 발견되었습니다. 올바른 표현은 b[N-i-1]입니다.
객체지향프로그래밍 25번
#include <iostream>
#include <cstdlib> // rand(), srand()
#include <ctime> // time()
using namespace std;
int main() {
srand(time(NULL));
const int size = 6;
int prize_money[size] = { 100000000, 50000000, 10000000, 5000000, 1000000, 500000 };
double prob[size] = { 0.000001, 0.00001, 0.0001, 0.001, 0.01, 0.1 };
double result = 0;
for (int i = 0; i < 6; i++)
{
result += (prize_money[i] * prob[i]);
}
cout << result << endl;
return 0;
}
객체지향프로그래밍 26번
주어진 프로그램은 정수 배열 data의 첫 번째 요소를 저장한 후, 배열의 각 요소를 한 칸씩 왼쪽으로 이동시키고, 마지막 요소에는 처음에 저장한 값을 대입하는 것입니다. 이를 통해 배열의 모든 요소가 왼쪽으로 한 칸씩 이동하게 됩니다.
#include <iostream>
using namespace std;
const int MAX = 100;
int main() {
int N;
int data[MAX]; // 충분히 크다고 가정한다.
// 배열 data에는 data[0]에서 data[N-1]까지 N개의 정수가 저장되어 있다고 가정한다.
int tmp = data[0]; // 첫 번째 요소의 값을 tmp에 저장
// 배열의 각 요소를 한 칸씩 왼쪽으로 이동
for (int i = 1; i < N; i++)
data[i - 1] = data[i];
data[N - 1] = tmp; // 처음에 저장한 값을 마지막 요소에 대입
return 0;
}
객체지향프로그래밍 27번
#include <iostream>
using namespace std;
const int MAX = 100;
int main() {
int N;
int num[MAX];
// 배열 num에는 num[0]에서 num[N-1]까지 N개의 정수가 저장되어 있다고 가정한다.
// 맨 마지막 정수를 저장하기 위한 변수 temp
int temp = num[N - 1];
// 배열의 모든 요소를 한 칸씩 뒤로 이동
for (int i = N - 1; i > 0; --i) {
num[i] = num[i - 1];
}
// 맨 마지막 정수를 배열의 맨 앞으로 이동
num[0] = temp;
return 0;
}이 코드는 주어진 배열 num의 모든 요소를 한 칸씩 뒤로 이동한 후, 맨 마지막 정수를 배열의 맨 앞으로 이동시킵니다.
객체지향프로그래밍 28번
#include <iostream>
using namespace std;
const int MAX = 100;
int main() {
int N;
int a[MAX];
// 배열 a에는 a[0]에서 a[N-1]까지 N개의 정수들이 오름차순으로 정렬되어 저장되어 있다고 가정한다.
// 서로 다른 정수의 개수를 저장하기 위한 변수 count
int count = 1;
// 배열의 첫 번째 요소부터 마지막 요소까지 반복하면서 서로 다른 정수의 개수를 센다
for (int i = 1; i < N; ++i) {
if (a[i] != a[i - 1]) {
++count;
}
}
// 서로 다른 정수의 총 개수 출력
cout << count << endl;
return 0;
}
객체지향프로그래밍 29번
주어진 프로그램은 두 개의 오름차순으로 정렬된 배열 A와 B를 비교하여 중복된 정수를 찾아서 배열 C에 저장하는 것입니다. 여기서 각 배열에는 중복된 정수가 없다고 가정합니다.
프로그램의 동작은 다음과 같습니다:
배열 A와 B를 순서대로 탐색하면서 현재 위치의 값을 비교합니다.
만약 A[i]가 B[j]보다 작으면 배열 A의 다음 요소로 이동합니다. 이는 배열 A에서 현재 위치의 값이 배열 B의 현재 위치의 값보다 작으므로 배열 A의 값이 더 작은 것으로 중복된 값이 될 수 없습니다.
만약 A[i]가 B[j]보다 크면 배열 B의 다음 요소로 이동합니다. 마찬가지로 이는 배열 B에서 현재 위치의 값이 배열 A의 현재 위치의 값보다 작으므로 배열 B의 값이 더 작은 것으로 중복된 값이 될 수 없습니다.
만약 A[i]와 B[j]가 같다면, 이 값은 중복된 값으로 간주되어 배열 C에 저장됩니다. 그리고 배열 A와 B의 다음 요소로 이동합니다.
이러한 과정을 배열 A나 B 중 하나의 끝에 도달할 때까지 반복합니다.
결과적으로 배열 C에는 배열 A와 B에서 중복된 값만 저장되게 됩니다.
객체지향프로그래밍 30번
#include <iostream>
const int MAX = 100;
int main()
{
int i = 0, j = 0, k = 0;
while (i < M && j < N)
{
if (A[i] < B[j])
{
c[k++] = A[i];
i++;
}
else if (A[i] > B[j])
j++;
else
{
i++, j++;
}
}
cout << k << endl;
}#include <iostream>
using namespace std;
const int MAX = 1000;
int main() {
int A[MAX], B[MAX], C[MAX];
int M, N;
cin >> M; // 배열 A의 크기 입력
for (int i = 0; i < M; ++i)
cin >> A[i]; // 배열 A의 요소들 입력
cin >> N; // 배열 B의 크기 입력
for (int i = 0; i < N; ++i)
cin >> B[i]; // 배열 B의 요소들 입력
int count = 0; // 중복되지 않는 정수들의 개수를 저장할 변수
int i = 0, j = 0, k = 0; // 배열 A, B, C의 인덱스 변수
while (i < M && j < N) { // 배열 A와 B의 끝까지 순회
if (A[i] < B[j]) // 배열 A의 현재 요소가 배열 B의 현재 요소보다 작으면
++i; // 배열 A의 다음 요소로 이동
else if (A[i] > B[j]) // 배열 A의 현재 요소가 배열 B의 현재 요소보다 크면
++j; // 배열 B의 다음 요소로 이동
else { // 배열 A와 B의 현재 요소가 같으면
C[k++] = A[i]; // 배열 C에 중복되지 않는 정수로 추가
++i; // 배열 A의 다음 요소로 이동
++j; // 배열 B의 다음 요소로 이동
++count; // 중복되지 않는 정수의 개수 증가
}
}
// 배열 A나 B 중 하나의 끝까지 도달한 경우에는 나머지 배열의 요소들은 모두 중복되지 않는 정수이므로 추가
while (i < M) {
C[k++] = A[i++];
++count;
}
while (j < N) {
C[k++] = B[j++];
++count;
}
// 배열 C에 저장된 중복되지 않는 정수들의 개수 출력
cout << count << endl;
return 0;
}이 프로그램은 입력으로 받은 배열 A와 B를 오름차순으로 탐색하면서 두 배열에 동시에 존재하는 정수를 찾습니다. 동시에 존재하는 정수가 발견되면 배열 C에 저장하고 중복되지 않는 정수의 개수를 세는 방식으로 작동합니다.
객체지향프로그래밍 31번
이 문제는 주어진 사탕의 개수와 학생의 수에 따라 사탕을 나눠주는 방법을 찾는 것입니다. 사탕의 개수가 서로 다른 봉지에 분배되어야 하므로, 학생들에게 사탕을 나눠주는 방식에 따라 최소한의 차이를 만들어야 합니다.
가장 많은 사탕을 받는 학생과 가장 적은 사탕을 받는 학생 사이의 차이를 최소화하기 위해서는, 가능한 한 공평하게 사탕을 분배해야 합니다. 이를 위해 사탕을 봉지별로 정렬하고, 사탕의 개수가 적은 봉지부터 학생들에게 사탕을 나눠줍니다. 이렇게 하면 처음에는 사탕의 수가 적은 봉지를 가진 학생들이 사탕을 받게 되고, 그 후에는 사탕의 수가 많은 봉지를 가진 학생들이 사탕을 받게 됩니다.
이러한 방식으로 사탕을 나눠줄 경우, 사탕을 받는 학생들 간의 사탕 개수 차이를 최소화할 수 있습니다. 이는 학생들이 가장 적게나 가장 많이 사탕을 받는 경우의 차이를 최소로 만들어줍니다.
객체지향프로그래밍 32번
#include <iostream>
#include <array>
using namespace std;
int a[4][4] = {
{0, 5, -17, -12},
{-23, 6, 9, -2},
{0, 13, -1, 7},
{-18, 2, -25, 6}
};
int main()
{
int N = 4;
for (int i = 0; i < N; i++)
{
if (i % 2 == 0)
{
for (int j = 0; j < N; j++)
{
cout << a[i][j] << ' '; // 여기서 개행 문자 대신에 공백을 넣습니다.
}
}
else
{
for (int j = N-1; j >= 0; j--)
{
cout << a[i][j] << ' '; // 여기서 개행 문자 대신에 공백을 넣습니다.
}
}
cout << '\n'; // 한 행이 끝날 때마다 개행 문자를 넣습니다.
}
return 0;
}객체지향프로그래밍 33번
(a)와 (b)는 올바른 배열 초기화 방법입니다. 배열의 크기가 명시되어 있고, 초기화 값도 충분히 제공되었습니다.
(c)는 잘못된 문법입니다. 배열의 두 번째 차원의 크기를 생략할 수 없습니다.
(d)도 잘못된 문법입니다. 배열의 크기를 모두 생략할 수는 없습니다.
'IT 프로그래밍 > 객체지향프로그래밍' 카테고리의 다른 글
| 객체지향프로그래밍 3과 그룹액티비티 총정리 (0) | 2024.04.21 |
|---|---|
| 객체지향프로그래밍 2과 그룹액티비티 총정리 (0) | 2024.04.21 |
| 객체지향프로그래밍 1번, 2번, 3번, 4번, 5번, 6번 (0) | 2024.04.20 |
| 객체지향 프로그래밍 25번 , 26번, 28번, 29번, 30번, 31번, 32번, 33번 (0) | 2024.04.20 |
| 객체지향프로그래밍 16번, 17,번, 18번, 19번, 22번, 23번, 24번 (0) | 2024.04.20 |