**๋ฌธ์ **
๋ ์ ์ A์ B๋ฅผ ์
๋ ฅ๋ฐ์ ๋ค์, A+B๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
**์
๋ ฅ**
์ฒซ์งธ ์ค์ A์ B๊ฐ ์ฃผ์ด์ง๋ค. (0 < A,B < 10^10000)
**์ถ๋ ฅ**
์ฒซ์งธ ์ค์ A+B๋ฅผ ์ถ๋ ฅํ๋ค.
**์์ ์
๋ ฅ 1**
9223372036854775807 9223372036854775808
**์์ ์ถ๋ ฅ 1**
18446744073709551615
ํ์ด์ฌ ๊ฐ์ ์ธ์ด๋ 10,000์๋ฆฌ ์ ๋์ ์์ฐ์๋ ์์ ๋กญ๊ฒ ๋ค๋ฃฐ ์ ์์ต๋๋ค. ํ์ง๋ง C/C++์ด๋ผ๋ฉด ์ด ๋ฌธ์ ๋ฅผ ์ด๋ป๊ฒ ํ๊น์? C/C++ ์ฌ์ฉ์๊ฐ ์๋๋๋ผ๋ ๊ณ ๋ฏผํด ๋ณด๋ฉด ์ข์ ๊ฒ์ ๋๋ค. ํ์ด์ฌ์ ์ฌ์ฉํ๋ฉด ์ฝ๊ฒ ํ ์ ์๋ ๋ฌธ์ ์ด์ง๋ง C๋ก ํ๋ฒ ํ์ด๋ณด๊ฒ ๋ค.
#include <stdio.h>
int main(void)
{
int a, b;
scanf("%d %d", &a, &b);
printf("%d\n", a + b);
return 0;
}
์ ๋ฌธ์ ๋ฅผ C์์ ๊ฐ๋จํ๊ฒ ๊ตฌํํ๋ฉด ์์ฒ๋ผ ๊ตฌํํ ์ ์์ง๋ง, ์์ ์ ๋ ฅ์ธ 9223372036854775807 9223372036854775808๋ฅผ ๋ฃ์ผ๋ฉด -2๋ผ๋ ๊ธฐ๋ํ์ง ์์ ๊ฒฐ๊ณผ๊ฐ ์ถ๋ ฅ๋๋ค. C์์๋ int ์๋ฃํ์ ๋ด์ ์ ์๋ ์ต๋๊ฐ์ด 2,147,483,647์ด๊ธฐ ๋๋ฌธ์ ์ต๋๊ฐ์ ๋๊ธฐ๋ ์๋ฅผ ์ ๋ ฅํ๊ธฐ ๋๋ฌธ์ ์ค๋ฒํ๋ก์ฐ๊ฐ ๋ฐ์ํ ๊ฒ์ด๋ค.
์์ ๋ฌธ์ ๋๋ฌธ์ C์์๋ int ๋์ ๋ฌธ์์ด ๋ฐฐ์ด์ ์ด์ฉํ์ฌ ๋ฌธ์์ด๋ผ๋ฆฌ ๋ํ๋ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ๊ตฌํํด์ผํ๋ค.
A, B์ ์ต๋๊ฐ์ 10^10000 (10์ 10000์น)์ด๋ค. 10^1์ 10์ด๊ณ , 10^2๋ 100์ด๋ค. ์ด์ ๊ฐ์ด 10์ ์ง์๊ฐ 1์ฉ ์ฆ๊ฐํ ๋๋ง๋ค 10์ ๋ฐฐ์๊ฐ 1๊ฐ์ฉ ๋ ๋ถ๋๋ค.
๋ฐ๋ผ์ 10^3์ 1000, 10^4๋ 10000์ด ๋ ๊ฒ์ด๋ค. ์ด๋ฐ ๊ท์น์ ๋ฐ๋ผ ์น์ ๋ฐ๋ผ์ ๊ฐ ์๋ฆฟ์๋ฅผ ๊ตฌํ ์ ์๋ค.
-> ๊ฐ ์น์ ๋ฐ๋ผ +1์ ํ๋ฉด ์๋ฆฟ์๋ฅผ ๊ตฌํ ์ ์๋ค๋ ๊ฒ์ ์ ์ ์์
10์ 1์น -> 10 (2์๋ฆฌ)
10์ 2์น -> 100 (3์๋ฆฌ)
10์ 3์น -> 1000 (4์๋ฆฌ)
10์ 10000์น -> .. (10001์๋ฆฌ)
๋ฐ๋ผ์ A, B์ ์ต๋ ์๋ฆฌ์๋ 10001 ์๋ฆฌ๋ผ๋ ๊ฒ์ ์ ์ ์๋ค.
char A[10002] = {0};
char B[10002] = {0};
char res[10003] = {0};
10001 ์๋ฆฌ๋ฅผ ๋ด์ ์ ์๋ ๋ฐฐ์ด์ ์ ์ธํ๋ ค๋ฉด C์์๋ ๋ฌธ์์ด ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ๊ฒฐ์ ํ ๋ NULL๋ฌธ์๊น์ง ๊ณ ๋ คํด์ charํ ๋ฐฐ์ด์ ๋ง์ง๋ง์๋ NULL๋ฌธ์('\0')๋ฅผ ์ถ๊ฐํด์ผ ํ๋ฏ๋ก, ๋ฐฐ์ด ํฌ๊ธฐ๋ฅผ 10002๋ก ์ง์ ํ๋ค.
๋ฐฐ์ด์ ์ ์ธํ ๋ {0}์ผ๋ก ์ด๊ธฐํ๋ฅผ ํ๋ฉด, ๋ฐฐ์ด์ ๋ชจ๋ ์์๋ฅผ 0์ผ๋ก ์ด๊ธฐํํ ์ ์๋ค. ์ด๋ ๊ฒ ์ด๊ธฐํ๋ฅผ ํ๋ฉด, ๋ฐฐ์ด์ ๊ธธ์ด์ ๊ด๊ณ์์ด ๋ชจ๋ ์์๋ฅผ 0์ผ๋ก ์ด๊ธฐํํ ์ ์๊ธฐ ๋๋ฌธ์, ์๊ธฐ์น ์์ ๊ฒฐ๊ณผ๋ฅผ ๋ฐฉ์งํ ์ ์๋ค.
๋ฐ๋ฉด์, char A[10002];์ ๊ฐ์ด ๋ฐฐ์ด์ ์ด๊ธฐํํ์ง ์์ผ๋ฉด, ๋ฐฐ์ด ์์์ ์ด์ ์ ์ฌ์ฉ๋์๋ ๊ฐ์ด ๊ทธ๋๋ก ๋จ์์์ ์ ์๋ค. ์ด๋ ๋ฌธ์ ํด๊ฒฐ์ ์ํฅ์ ๋ผ์น ์ ์์ผ๋ฉฐ, ์๊ธฐ์น ์์ ๊ฒฐ๊ณผ๋ฅผ ์ด๋ํ ์ ์๋ค.
๋ฐ๋ผ์, char A[10002] = {0};์ ๊ฐ์ด ๋ฐฐ์ด์ ์ด๊ธฐํํ๋ ๊ฒ์ด ์์ ํ ๋ฐฉ๋ฒ์ ๋๋ค. ์ด๋ ๊ฒ ์ด๊ธฐํ๋ฅผ ํ๋ฉด, ๋ฐฐ์ด์ ๋ชจ๋ ์์๊ฐ 0์ผ๋ก ์ด๊ธฐํ๋๋ฏ๋ก, ๋ฐฐ์ด ์์์ ์ด์ ์ ์ฌ์ฉ๋์๋ ๊ฐ์ด ๊ทธ๋๋ก ๋จ์์์ ๊ฐ๋ฅ์ฑ์ ๋ฐฐ์ ํ ์ ์๋ค.
๋ฌธ์์ด์ ๋ํ๋ ๊ฒฝ์ฐ, ๋ ๋ฌธ์์ด์ ๊ธธ์ด์ ํฉ๋ณด๋ค ๊ฒฐ๊ณผ ๋ฌธ์์ด์ ๊ธธ์ด๊ฐ ์ต์ํ 1๋งํผ ๋ ์ปค์ง๊ฒ ๋๋ฏ๋ก ๊ฒฐ๊ณผ๊ฐ์ 10003 ํฌ๊ธฐ์ ๋ฐฐ์ด๋ก ์ ์ธํ๋ค.
๋ฌธ์์ด ๋ฐฐ์ด์ ๋ค์ด์๋ ๋ฌธ์๋ค์ ์๋ฆฟ์๋๋ก ์ธ๋ก๋ง์ ๋ฐฉ์๋๋ก ๋ํด์ค ๊ฑด๋ฐ, ์ธ๋ก ๋ง์ ์ ์งํํ ๋ ์ ๋ ฅ๋ฐ์ ์ซ์์ ์ผ์ ์๋ฆฌ๋ถํฐ ๋ํด๋๊ฐ๋ ๋ฐฉ์์ ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์ ์ญ์์ผ๋ก ์ ๋ ฌ๋ ์ ๋ ฅ๊ฐ์ ์ฌ์ฉํ๋ฉด ์ผ์ ์๋ฆฌ๋ถํฐ ์ฐจ๋ก๋๋ก ๋ํด๊ฐ๋ฉด์, ๋ค์ ์๋ฆฌ์์ ์ฌ๋ฆผ์๋ฅผ ๋ํด์ฃผ๊ธฐ ์ฉ์ดํด์ง๋ค.
#include <stdio.h>
#include <string.h>
void reverse(char arr[])
{
int len = strlen(arr);
for (int i = 0; i < len / 2; i++)
{
char temp = arr[i];
arr[i] = arr[len - 1 - i];
arr[len - 1 - i] = temp;
}
}
int main(void)
{
char A[10002];
char B[10002];
char res[10003];
int len;
// ์๋ฆฟ์
int carry = 0;
scanf("%s%s", A, B);
// ์ญ์์ ๋ ฌ์ ์ํด reverse ํจ์๋ฅผ ๊ตฌํํ๊ณ A, B๋ฅผ ์ญ์์ ๋ ฌํ ํ ์์ํ๋ค.
reverse(A);
reverse(B);
/*
์ญ์์ ๋ ฌ๋ ๋ฐฐ์ด์์ ๋ ์ A, B๋ฅผ ๋ํ ๋ ๋ ์ค ๋ ํฐ ์๋ฆฟ์๋๋ก
๋ง์
์ด ์ด๋ฃจ์ด์ ธ์ผ ํ๊ธฐ ๋๋ฌธ์ ๋ ํฐ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ len์ ์ ์ฅํ๋ค.
*/
if (strlen(A) > strlen(B))
len = strlen(A);
else
len = strlen(B);
for (int i = 0; i < len; i++)
{
/*
๋ฌธ์์ด ๋ฐฐ์ด๋ก ๋ ์๋ฅผ ๋ฐ์์์ผ๋ฏ๋ก ๋ฐฐ์ด์ ์ํํ ๋ ๋ฌธ์์ด์ ์ซ์๋ก ๋ฐ๊พธ๊ณ ๊ณ์ฐํ๋ค.
C์์๋ ๋ฌธ์์ ASCII ์ฝ๋ ๊ฐ์ด ์ ์๋ก ์ ์ฅ๋์ด ์์ผ๋ฏ๋ก
48์ ํด๋นํ๋ '0'์ ๋นผ์ฃผ๋ฉด ์ ์๊ฐ์ ์ป์ ์ ์๋ค.
*/
int sum = A[i] - '0' + B[i] - '0' + carry;
/*
sum์ด 0๋ณด๋ค ์์ผ๋ฉด ํ๋๊ฐ null๊ฐ์ด ๋ค์ด๊ฐ ๋ง์ด๋์ค ์๋ฆฌ๊ฐ
๋์๋ค๋ ๋ป์ด๋ฏ๋ก 0์ด ๋ ๋๊น์ง '0'์ ๋ํด์ค์ ์๋์ ๊ฐ์ผ๋ก ๋ง๋ค์ด์ค๋ค.
*/
while (sum < 0)
sum += '0';
// ๋ง์ฝ ๋ํ ์๊ฐ 9๋ฅผ ๋์ด๊ฐ๋ฉด ์๋ฆฟ์๋ฅผ ํ๋ ์ฌ๋ ค์ผํ๋ค.
if (sum > 9)
carry = 1;
else
carry = 0;
// ๋ํ ์๋ฅผ 10์ผ๋ก ๋๋ ๋๋จธ์ง๋ฅผ ๊ฒฐ๊ณผ์ ์ ์ฅํ๋ค.
res[i] = sum % 10 + '0';
}
// for๋ฌธ์ด ๋๋ ํ ๋ง์ง๋ง ์๋ฆฌ์์ ๋ฐ์์ฌ๋ฆผ ๋ฐ์ ์ ๋ฐฐ์ด์ ๋ง์ง๋ง์ 1์ถ๊ฐ
if (carry == 1)
res[len] = '1';
reverse(res);
printf("%s", res);
return 0;
}
์ฐธ๊ณ
'๐ง Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Python] ํน์ ๋จ์ด ๊ฐ์ ์ธ๊ธฐ (0) | 2021.04.07 |
---|---|
[Python] ์ง๋ขฐ์ฐพ๊ธฐ (0) | 2021.04.05 |
[JavaScript] ์๋ฐ์๋ฐ์๋ฐ์ (0) | 2021.01.30 |
[JavaScript] ๊น์๋ฐฉ ์ฐพ๊ธฐ (0) | 2021.01.23 |