0๋ถํฐ 9๊น์ง์ ์ซ์๊ฐ ํ์๋ ์นด๋๋ฅผ ๊ฐ์ง๊ณ ๋ ์ฌ๋ A์ B๊ฐ ๊ฒ์์ ํ๋ค. A์ B์๊ฒ๋ ๊ฐ๊ฐ 0์์ 9๊น์ง์ ์ซ์๊ฐ ํ๋์ฉ ํ์๋ 10์ฅ์ ์นด๋๋ญ์น๊ฐ ์ฃผ์ด์ง๋ค. ๋ ์ฌ๋์ ์นด๋๋ฅผ ์์์ ์์๋ก ์์ ํ ์ซ์๊ฐ ๋ณด์ด์ง ์๊ฒ ์ผ๋ ฌ๋ก ๋์ด๋๊ณ ๊ฒ์์ ์์ํ๋ค. ๋จ, ๊ฒ์ ๋์ค ์นด๋์ ์์๋ฅผ ๋ฐ๊ฟ ์๋ ์๋ค. A์ B ๊ฐ๊ฐ์ด ๋์ด๋์ ์นด๋๋ฅผ ๋ค์ง์ด์ ํ์๋ ์ซ์๋ฅผ ํ์ธํ๋ ๊ฒ์ ํ ๋ผ์ด๋๋ผ๊ณ ํ๋ค. ๊ฒ์์ ์ฒซ ๋ฒ์งธ ๋์ธ ์นด๋๋ถํฐ ์์ํ์ฌ ์์๋๋ก 10๋ฒ์ ๋ผ์ด๋๋ก ์งํํ๋ค. ๊ฐ ๋ผ์ด๋์์๋ ๊ณต๊ฐ๋ ์ซ์๊ฐ ๋ ํฐ ์ฌ๋์ด ์น์๊ฐ ๋๋ค. ์น์์๊ฒ๋ ์น์ 3์ ์ด ์ฃผ์ด์ง๊ณ , ํจ์์๊ฒ๋ ์น์ ์ด ์ฃผ์ด์ง์ง ์๋๋ค. ๋ง์ฝ ๊ณต๊ฐ๋ ๋ ์ซ์๊ฐ ๊ฐ์์ ๋น๊ธฐ๊ฒ ๋๋ฉด, A์ B ๋ชจ๋์๊ฒ ์น์ 1์ ์ด ์ฃผ์ด์ง๋ค. 10๋ฒ์ ๋ผ์ด๋๊ฐ ๋ชจ..
A, B ๋ ์ฌ๋์ด ๊ฐ์๋ฐ์๋ณด ๊ฒ์์ ํฉ๋๋ค. ์ด N๋ฒ์ ๊ฒ์์ ํ์ฌ A๊ฐ ์ด๊ธฐ๋ฉด A๋ฅผ ์ถ๋ ฅํ๊ณ , B๊ฐ ์ด๊ธฐ๋ฉด B๋ฅผ ์ถ๋ ฅํ๋ค. ๋น๊ธฐ๋ฉด D๋ฅผ ์ถ๋ ฅํ๋ค. ๊ฐ์ ๋ฐ์ ๋ณด๋ 1 2 3์ผ๋ก ์ ํ๋ค. ๋ ์ฌ๋์ ๊ฐ ํ์ ๊ฐ์๋ฐ์๋ณด ์ ๋ณด๊ฐ ์ฃผ์ด์ง๋ฉด ๊ฐ ํ๋ฅผ ๋๊ฐ ์ด๊ฒผ๋์ง ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์. ์
๋ ฅ ์ฒซ ์ค์ N ๋ ๋ฒ์งธ ์ค์ A์ ์ ๋ณด N๊ฐ ์ธ ๋ฒ์งธ ์ค์ B์ ์ ๋ณด N๊ฐ 5 2 3 3 1 3 1 1 2 2 3 ์ถ๋ ฅ ๊ฐ ํ์ ์น์ ์ถ๋ ฅ, ๋น๊ฒผ์ ๊ฒฝ์ฐ D ์ถ๋ ฅ A B A B D 1ํธ (์ฑ๊ณต) ๋ง๊ธฐ๋ ํ๋ฐ ๋ณต์กํ๊ฐ? ๐ #include using namespace std; int main(void){ freopen("input.txt", "rt", stdin); int n, a, b; cin >> n; int a..
ํ ์ค์ ์์ํค ์ ๋ณด๊ฐ ์ฃผ์ด์ง๋ฉด ๋ท์ฌ๋ ๋ชจ๋์ ์์ผ๋ฅผ ๊ฐ๋ ค ์ํ ์์ฒญ์ด ๋ถ๊ฐ๋ฅํ๊ฒ ํ๋ ๋ถ๋
ธ์ ๋ฐ์๊ฐ ๊ทธ ์ค์ ๋ช ๋ช
์ด ์๋์ง ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์. ์
๋ ฅ ์ฒซ ์ค์ ํ ์ค์ ์์ ํ์ ์๊ฐ ์ฃผ์ด์ง๋ค. ๋ ๋ฒ์งธ ์ค์ N๋ช
์ ์์ ํค ์ ๋ณด๊ฐ ์ ์๋ฆฌ ํ์๋ถํฐ ์ฐจ๋ก๋๋ก ์ฃผ์ด์ง๋ค (45~100) 10 56 46 55 76 65 53 52 53 55 50 ์ถ๋ ฅ ์์ ์ ๋ท ์ฌ๋ ๋ชจ๋๋ฅผ ์์ฒญ๋ฐฉํดํ๋ ํ์ ์๋ฅผ ์ถ๋ ฅ 3 1ํธ (์คํจ) #include using namespace std; int main(void){ freopen("input.txt", "rt", stdin); int n, height, count = 0; cin >> n; int h[n]; for(int i = 0; i < n; ++i){ cin..
์ํํธ ๋ด ์ง๋์ผ์ ์กด์ฌ. ์ธต๊ฐ ์ง๋์์ ์ธก์ ์น๋ฅผ ์ด๋จ์๋ก ์ํํธ ๊ด๋ฆฌ์ค์ ์ค์๊ฐ์ผ๋ก ์ ์ก. ํ ์ธ๋์ ์ธก์ ์น๊ฐ M๊ฐ์ ์ ๋์ผ๋ฉด ์ธ๋ํธ์์ ์์ ๊ฒฝ๋ณด์์ด ๊ด๋ฆฌ์ค ๋ชจ๋ํฐ์์ ์ธ๋ฆฐ๋ค. ํ ์ธ๋์ N์ด ๋์์ ์ค์๊ฐ ์ธก์ ์น๊ฐ ์ฃผ์ด์ง๋ฉด ์ต๋ ์ฐ์์ผ๋ก ๊ฒฝ๋ณด์์ด ์ธ๋ฆฐ ์๊ฐ์ ๊ตฌํ๋ผ. ๊ฒฝ๋ณด์์ด ์์ผ๋ฉด -1์ ์ถ๋ ฅํ๋ค. ์
๋ ฅ ์ฒซ ์ค์ ์์ฐ์ N๊ณผ M์ด ์ฃผ์ด์ง๋ค. ๋ ๋ฒ์งธ ์ค์ N๊ฐ์ ์ธก์ ๊ฐ(1000 ์ดํ)์ด ์ด ์์๋๋ก ์
๋ ฅ๋๋ค. 10 90 23 17 120 34 112 136 123 23 25 113 ์ถ๋ ฅ ์ต๋ ์ฐ์ ๊ฒฝ๋ณด์์ด ์ธ๋ฆฐ ์๊ฐ์ ์ถ๋ ฅํ์ธ์ 3 1ํธ (๊ฐ์ ํ์ด) max = -2147000000 ์ฌ์ฉ ๋ฐฉ๋ฒ ๊น๋จน์.. ํ์ด๋ณด๋๊น ์ถฉ๋ถํ ํ ์ ์์๋ค.. #include using namespace std; i..
ํ์๋ค ๋ฐ์ ํ์์ด N๋ช
์๋ค. ๊ฐ ํ์๋ค์๊ฒ ์ซ์๊ฐ ์ ํ ์นด๋๋ฅผ ์คฌ๋ค. ๊ฐ ํ์๋ค์ 1๋ถํฐ ์๊ธฐ ์นด๋์ ์ ํ ์ซ์๊น์ง์ ํฉ์ ๊ตฌํด์ผ ํ๋ค. ์๋ ์ฑ์ ํ๋ ํ๋ก๊ทธ๋จ์ ๋ง๋ค์ด๋ผ. ์
๋ ฅ ๋ฐ ํ์ ์ (๊ฐ ํ์๋ค์ 1๋ถํฐ N๊น์ง ๋ฒํธ๊ฐ ๋ถ์ฌ๋์ด ์๋ค ๊ฐ์ ) ์นด๋์ ์์ ์ ๋ต 3 10 55 20 350 100 5050 ์ถ๋ ฅ ์ ๋ต์ด๋ฉด YES, ํ๋ฆฌ๋ฉด NO YES NO YES 1ํธ ์ฑ๊ณต #include using namespace std; int GetSum(int num){ int sum = 0; for(int i = 1; i > num; string answer[num]; int a, b; for(int i = 0; i > a; cin >> b; sum = GetSum(a); a..
Anagram์ด๋ ๋ ๋ฌธ์์ด์ด ์ํ๋ฒณ์ ๋์ด ์์๋ฅผ ๋ค๋ฅด์ง๋ง ๊ทธ ๊ตฌ์ฑ์ด ์ผ์นํ๋ฉด ๋ ๋จ์ด๋ ์๋๊ทธ๋จ์ด๋ผ ํ๋ค. ์๋ฅผ ๋ค์ด AbaAeCe ์ baeeACA๋ ์ํ๋ฒณ์ ๋์ด ์์๋ ๋ค๋ฅด์ง๋ง ๊ทธ ๊ตฌ์ฑ์ ์ดํด๋ณด๋ฉด ์ํ๋ฒณ๊ณผ ๊ทธ ๊ฐ์๊ฐ ๋ชจ๋ ์ผ์นํ๋ค. A(2), a(1), b(1), c(1), e(2). ์ฆ ์ด๋ ํ ๋จ์ด๋ฅผ ์ฌ๋ฐฐ์ดํ๋ฉด ์๋ํธ ๋จ์ด๊ฐ ๋ ์ ์๋ ๊ฒ์ ์๋๊ทธ๋จ์ด๋ผ ํ๋ค. ๊ธธ์ด๊ฐ ๊ฐ์ ๋ ๊ฐ์ ๋จ์ด๊ฐ ์ฃผ์ด์ง๋ฉด ๋ ๋จ์ด๊ฐ ์๋๊ทธ๋จ์ธ์ง ํ๋ณํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์. ์๋๊ทธ๋จ ํ๋ณ์ ๋์๋ฌธ์๊ฐ ๊ตฌ๋ถ๋ฉ๋๋ค. ์
๋ ฅ ์ฒซ ์ค์ ์ฒซ ๋ฒ์งธ ๋จ์ด๊ฐ ์
๋ ฅ๋๊ณ , ๋ ๋ฒ์งธ ์ค์ ๋ ๋ฒ์งธ ๋จ์ด๊ฐ ์
๋ ฅ๋๋ค. ๋จ์ด์ ๊ธธ์ด๋ 100์ ๋์ง ์๋๋ค. ์ถ๋ ฅ YES/NO 1ํธ (์คํจ) ์๊ฐ์ด๊ณผ & ๋ต ๋์ถ ์คํจ ์ ๋ฐ๋ณต๋ฌธ์ '\0' ๋ฃ..
์์ฐ์ N์ด ์
๋ ฅ๋๋ฉด 1๋ถํฐ N๊น์ง์ ์์์ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์. ๋ง์ฝ 20์ด ์
๋ ฅ๋๋ฉด 1๋ถํฐ 20๊น์ง์ ์์๋ 2 3 5 7 11 13 17 19๋ก ์ด 8๊ฐ ์
๋๋ค. ์ ํ์๊ฐ์ 1์ด์
๋๋ค. ์
๋ ฅ 20 ์ถ๋ ฅ 8 1ํธ (์ฑ๊ณต) ๋ฐ์ดํฐ๊ฐ ํฌ๋ฉด ์ ํ์๊ฐ์ ๋ง์ถ์ง ๋ชปํ๋ค. #include using namespace std; bool isPrime(int x){ bool isPrime = true; for(int i = 2; i > n; for(int i = 2; i
N๊ฐ์ ์์ฐ์๊ฐ ์
๋ ฅ๋๋ฉด ๊ฐ ์์ฐ์๋ฅผ ๋ค์ง์ ํ ๊ทธ ๋ค์ง์ ์๊ฐ ์์์ด๋ฉด ๊ทธ ์๋ฅผ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์. ์๋ฅผ ๋ค์ด 32๋ฅผ ๋ค์ง์ผ๋ฉด 23์ด๊ณ , 23์ ์์์ด๋ค. ๊ทธ๋ฌ๋ฉด 23์ ์ถ๋ ฅํ๋ค. ๋จ 910์ ๋ค์ง์ผ๋ฉด, 19๋ก ์ซ์ํํด์ผํ๋ค. ์ฒซ ์๋ฆฌ๋ถํฐ์ ์ฐ์๋ 0์ ๋ฌด์ํ๋ค. ๋ค์ง์ ํจ์์ธ int reverse(int x)์ ์์์ธ์ง ํ์ธํ๋ ํจ์ bool isPrime(int x)๋ฅผ ๋ฐ๋์ ์์ฑํ๋ค. ์
๋ ฅ 5 32 55 62 3700 250 ์ถ๋ ฅ 23 73 #include using namespace std; int reverse(int x){ int res, tmp; while(x>0){ tmp = x % 10; res = res * 10 + tmp; x = x / 10; } return res; }..
N์๋ฆฌ์ ์์ฐ์๊ฐ ์
๋ ฅ๋๋ฉด ์
๋ ฅ๋ ์์ฐ์์ ์๋ฆฟ์ ์ค ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋ ์ซ์๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์. ์๋ฅผ๋ค์ด 1230565625๋ผ๋ ์์ฐ์๊ฐ ์
๋ ฅ๋๋ฉด 5๊ฐ 3๋ฒ ์ฌ์ฉ๋์ด ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋ ์ซ์์
๋๋ค. ๋ต์ด ์ฌ๋ฌ ๊ฐ์ผ ๊ฒฝ์ฐ ๊ทธ ์ค ๊ฐ์ฅ ํฐ ์๋ฅผ ์ถ๋ ฅํ์ธ์. ์
๋ ฅ ์ฒซ ์ค์ ์์ฐ์๊ฐ ์
๋ ฅ๋ฉ๋๋ค. ์์ฐ์์ ๊ธธ์ด๋ 100์ ๋์ง ์์ต๋๋ค. 1230565625 ์ถ๋ ฅ ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋ ์๋ฆฟ์๋ฅผ ์ถ๋ ฅํฉ๋๋ค. 5 #include using namespace std; int ch[10]; // 0~9๊น์ง ์นด์ดํธ int main(void){ int i, digit, res, max = -2147000000; char a[101]; // 100์๋ฆฌ ์์ฐ์ cin >> a; for(int i = 0; a[i] != ..
์์ฐ์ n์ด ์
๋ ฅ๋๋ฉด 1๋ถํฐ n๊น์ง์ ์์ฐ์๋ฅผ ์ข
์ด์ ์ ์ ๋, ๊ฐ ์ซ์๋ ๋ช ๊ฐ ์ฐ์์๊น์? ์๋ฅผ ๋ค์ด 1~15๊น์ง๋ ์ด 21๊ฐ๊ฐ ์ฐ์์์ ์ ์ ์์ต๋๋ค. ์์ฐ์ n์ด ์
๋ ฅ๋๋ฉด 1๋ถํฐ n๊น์ง ๊ฐ์ซ์๋ ๋ช ๊ฐ๊ฐ ์ฌ์ฉ๋์๋์ง๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์. ์
๋ ฅ ์ฒซ ๋ฒ์งธ ์ค์๋ ์์ฐ์ n์ด ์ฃผ์ด์ง๋ค. 15 ์ถ๋ ฅ ์ฒซ ๋ฒ์งธ ์ค์ ์ซ์์ ์ด ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ค. 21 ๊ฐ์ ํ์ด #include using namespace std; int main(void){ int n, sum = 0, c = 1, d = 9, res = 0; cin >> n; while(sum+d < n){ res = res + (c*d); sum = sum + d; c++; d = d*10; } res = res + ((n-sum) * c);..
์์ฐ์ n์ด ์
๋ ฅ๋๋ฉด 1๋ถํฐ n๊น์ง์ ์์ฐ์๋ฅผ ์ข
์ด์ ์ ์ ๋ ๊ฐ ์ซ์๋ ๋ช ๊ฐ ์ฐ์ฌ์์๊ฐ์? ์๋ฅผ ๋ค์ด 1~15๊น์ง๋ 1 2 3 4 5 6 7 8 9 1 0 1 1 1 2 1 3 1 4 1 5์ผ๋ก ์ด 21๊ฐ๊ฐ ์
๋ ฅ๋๋ค. ์์ฐ์ n์ด ์
๋ ฅ๋๋ฉด 1๋ถํฐ n๊น์ง ๊ฐ ์ซ์๋ ๋ช ๊ฐ๊ฐ ์ฌ์ฉ๋์๋์ง๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์. ์
๋ ฅ ์ฒซ ๋ฒ์งธ ์ค์๋ ์์ฐ์ N(3 num; for(int i = 1; i 0){ tmp = tmp / 10; cnt++; } } cout
N๊ฐ์ ์์ฐ์๊ฐ ์
๋ ฅ๋๋ฉด ๊ฐ ์์ฐ์์ ์๋ฆฟ์์ ํฉ์ ๊ตฌํ๊ณ , ๊ทธ ํฉ์ด ์ต๋์ธ ์์ฐ์๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์. ๊ฐ ์์ฐ์์ ์๋ฆฟ์์ ํฉ์ ๊ตฌํ๋ ํจ์๋ฅผ int digit_sum(int x)๋ฅผ ๊ผญ ์์ฑํด์ ํ๋ก๊ทธ๋๋ฐํ์ธ์. ์
๋ ฅ ์ฒซ ์ค์ ์์ฐ์์ ๊ฐ์๊ฐ ์ฃผ์ด์ง๊ณ , ๊ทธ ๋ค์์ค์ N๊ฐ์ ์์ฐ์๊ฐ ์ฃผ์ด์ง๋ค. ๊ฐ ์์ฐ์์ ํฌ๊ธฐ๋ 10,000,000๋ฅผ ๋์ง ์๋๋ค. 5 125 15232 79 1325 97 ์ถ๋ ฅ ์๋ฆฟ์์ ํฉ์ด ์ต๋์ธ ์์ฐ์๋ฅผ ์ถ๋ ฅํ๋ค. ์๋ฆฌ์์ ํฉ์ด ์ต๋์ธ ์์ฐ์๊ฐ ์ฌ๋ฌ ๊ฐ์ธ ๊ฒฝ์ฐ ๊ทธ ์ค ๊ฐ์ด ๊ฐ์ฅ ํฐ ๊ฐ์ ์ถ๋ ฅํ๋ค. 97 1ํธ (๊ฐ์ ํ์ด) #include using namespace std; int digit_sum(int x){ int tmp, sum = 0; while(x > 0){ ..