๐ง ๋ฌธ์ N๋ช
์ ์ํ ์ฑ์ ์ด ์ฃผ์ด์ง๋ฉด ๊ทธ ์ค 3๋ฑ์ ํ ์ํ์ฑ์ ์ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์.๋ง์ฝ ํ์์ ์ ์๊ฐ 100์ ์ด 3๋ช
, 99์ ์ด 2๋ช
, 98์ ์ด 5๋ช
, 97์ ์ด 3๋ช
์ด๋ฐ์์ผ๋ก ์ ์๊ฐ ๋ถํฌ๋๋ฉด, 1๋ฑ์ 3๋ช
์ด๋ฉฐ, 2๋ฑ์ 2๋ช
์ด๋ฉฐ, 3๋ฑ์ 5๋ช
์ด ๋์ด, 98์ ์ด 3๋ฑ์ ํ ์ ์๊ฐ ๋๋ค. ๐ง ์
๋ ฅ์ฒซ ๋ฒ์งธ ์ค์ ์์ฐ์ n์ด ์ฃผ์ด์ง๋ค.๋ ๋ฒ์งธ ์ค์ n๊ฐ์ ์ํ์ฑ์ ์ ์๊ฐ ๊ณต๋ฐฑ์ ์ฌ์ด์ ๋๊ณ ์
๋ ฅ๋๋ค. ์ํ์ฑ์ ์ ์๋ 100์ ๋ง์ ๊ธฐ์ค์ผ๋ก ์
๋ ฅ๋๋ค. ๐ง ์ถ๋ ฅ3๋ฑ์ ํ ์ ์๋ฅผ ์ถ๋ ฅํ๋ค. ๐ง 1ํธ (์ฑ๊ณต)๋ด๋ฆผ์ฐจ์์ผ๋ก ํ๋ฉด ์ข ๋ ๊น๋?ํ๊ฒ ์ง๋ง, ์ค๋ฆ์ฐจ์๋ ๋ฌธ์ ์๋ ๊ฒ ๊ฐ๋ค.#include #include #includeusing namespace std;int main(void){ //freo..
๐ง ์ฝ๋ฉํ ์คํธ
๐ง ๋ฌธ์ N๊ฐ์ ์ซ์๊ฐ ์
๋ ฅ๋๋ฉด ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ์ฌ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์.์ ๋ ฌํ๋ ๋ฐฉ๋ฒ์ ์ ํ์ ๋ ฌ์
๋๋ค. ๐ง ์
๋ ฅ613 5 11 7 23 15 ๐ง ์ถ๋ ฅ5 7 11 13 15 23 ๐ง 1ํธ (๊ฐ์ ํ์ด)#include #include #includeusing namespace std;int main(void){ freopen("input.txt", "rt", stdin); int n; cin >> n; int a[n]; for(int i = 0; i > a[i]; } int index; for(int i = 0; i
๐ง ๋ฌธ์ ํ์(C)์ ์์(H)๋ก๋ง ์ด๋ฃจ์ด์ง ํํฉ๋ฌผ์ ํํ์์๋ผ ํ๋ค.ํ์ 1๊ฐ์ ์ง๋์ 12g, ์์ 1๊ฐ์ ์ง๋์ 1g์ด๋ค.์ํธ๋ (C2H4)์ ์ง๋์ 12 * 2 + 1 * 4 = 28g์ด๋ค.๋ฉํ(CH4)์ ์ง๋์ 12 * 1 + 1* 4 = 16g์ด๋ค.ํํ์์์์ด ์ฃผ์ด์ง๋ฉด ํด๋น ํํฉ๋ฌผ์ ์ง๋์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ๋ผ. ๐ง ์
๋ ฅC2H4 ๐ง์ถ๋ ฅ28 ๐ง 1ํธ ( ๊ฐ์ ํ์ด)#include #include #includeusing namespace std;int main(void){ freopen("input.txt", "rt", stdin); int sum = 0, c = 0, h = 0, pos , i; char a[10]; cin >> a; if(a[1] == 'H'){ c = 1; ..
29๋ฒ ๋ฌธ์ ์ ๋์ผ, time limit 1์ด ๐ง 1ํธ (๊ฐ์ ํ์ด)์๋ฆฟ์๋ง๋ค 3์ด ๋ฑ์ฅํ๋ ํ์ ์ฒดํฌ3๋ณด๋ค ํฐ ๊ฒฝ์ฐ, ๊ฐ์ ๊ฒฝ์ฐ, ์์ ๊ฒฝ์ฐ๋ก ๋ถ๋ฆฌ#include #include #includeusing namespace std;int main(void){ //freopen("input.txt", "rt", stdin); int n, lt = 1, cur, rt, k = 1, cnt = 0; cin >> n; while(lt != 0){ lt = n / (k * 10); rt = n % k; cur = (n / k) % 10; if (3
๐ง ๋ฌธ์ ์์ฐ์ n์ด ์
๋ ฅ๋๋ฉด 1๋ถํฐ n๊น์ง์ ์์ฐ์๋ฅผ ์ข
์ด์ ์ ์ ๋ ๊ฐ ์ซ์ ์ค 3์ ๊ฐ์๊ฐ ๋ช ๊ฐ์๋์ง ๊ตฌํ๋ ค๊ณ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด, 1๋ถํฐ 15๊น์ง๋ 3, ~ 1, 3 ~ ์ผ๋ก 3์ ๊ฐ์๊ฐ 2๊ฐ์ด๋ค. ๐ง ์
๋ ฅ 15 ๐ง ์ถ๋ ฅ 2 ๐ง 1ํธ (๊ฐ์ ํ์ด) #include #include #include using namespace std; int main(void){ //freopen("input.txt", "rt", stdin); int n, tmp, digit, cnt = 0; cin >> n; for(int i = 1; i 0){ digit = tmp % 10; if(digit == 3) cnt++; tmp = tmp / 10; } } cout
๐ง ๋ฌธ์ ์์ฐ์ N์ด ์
๋ ฅ๋๋ฉด N! ๊ฐ์์ ์ผ์ ์๋ฆฌ๋ถํฐ ์ฐ์์ ์ผ๋ก 0์ด ๋ช ๊ฐ ์๋์ง ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์. ๋ง์ฝ, 5! = 120 = ์ผ์ ์๋ฆฌ๋ถํฐ ์ฐ์์ ์ธ 0์ ๊ฐฏ์๋ 1๊ฐ์ด๋ค. ๋ง์ฝ, 12! = 479001600์ผ๋ก ์ผ์ ์๋ฆฌ๋ถํฐ ์ฐ์์ ์ธ 0์ ๊ฐฏ์๋ 2๊ฐ์ด๋ค. ๐ง ์
๋ ฅ 12 ๐ง ์ถ๋ ฅ 2 ๐ง 1ํธ (๊ฐ์ ํ์ด) 10์ด ์ผ๋ง๋ ์๋๊ฐ? ๋ฅผ ํ์ธํ๋ฉด ๋๋ค. ๐ 10 = 2 * 5 ์ด๋ฏ๋ก, ๊ฐ์ ์์ธ์๋ถํดํ์ฌ 2์ 5์ ๊ฐฏ์๋ฅผ ํ์ธํ๋ค. #include #include #include using namespace std; int main(void){ //freopen("input.txt", "rt", stdin); int n, j, tmp; int cnt1 = 0, cnt2 = 0; cin >>..
โ๏ธ ๋ฌธ์ ์์์ N์ ๋ํ์ฌ N!์ 1๋ถํฐ N๊น์ง์ ๊ณฑ์ ์๋ฏธํ๋ค. ์ด๋ฌํ ํฐ ์๋ฅผ ํํํ๋ ๋ฐฉ๋ฒ์ผ๋ก ์์๋ค์ ๊ณฑ์ผ๋ก ํํํ๋ ๋ฐฉ๋ฒ์ด ์๋ค. ์๋ฅผ๋ค์ด 825 = 0 1 2 0 1 ๋ก ํํ๊ฐ๋ฅํ๋ฐ, ์ด๋ 2๋ ์๊ณ , 3์ 1๋ฒ, 5๋ 2๋ฒ, 7์ ์๊ณ , 11์ 1๋ฒ์ ๊ณฑ์ด๋ผ๋ ์๋ฏธ์ด๋ค. ์ด์ ๊ฐ์ด ๋ณํํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์. ๐ง ์
๋ ฅ 5 ๐ญ ์ถ๋ ฅ 5! = 3 1 1 โจ 1ํธ (๊ฐ์ ํ์ด) ์์๋ฅผ ๋ฐฐ์ด๋ก ๋ง๋ค์ง, ๋ง๋ ๋ค๋ฉด ์
๋ ฅ๋ n๊น์ง์ ์์์ ๊ฐฏ์๋งํผ ๋ง๋ค์ด์ผํ ์ง? ๋ ๊ทธ๋ ๋ค๋ฉด, ๊ทธ ๋งํผ ์์ํ๋ณ๊ธฐ๋ฅผ ๊ตด๋ ค์ ํด์ผํ๋๋ฐ ์ด๊ฒ ํจ์จ์ ์ด์ง ์์ ๊ฒ ๊ฐ์. n๊น์ง์ ๋ชจ๋ ์๋ฅผ ๋ฐฐ์ด๋ก ๋ง๋๋ ๊ฒ ๊ฐ์ง ์์. ์์๋ง ์นด์ดํ
ํด์ผํ๋๊น. ์ด๋ป๊ฒ ํ์ด์ผํ ์ง ํ๋จ์ด ์์์ ๊ฐ์ํ์ด๋ฅผ ๋ณด๊ธฐ๋ก ํ์๋ค. ๊ฐ์ํ์ด ๐ ๋ฐฐ์ด์ ..
์ฅ๊ฑฐ๋ฆฌ ๋ฌ๋ฆฌ๊ธฐ ๋ํ๊ฐ ์งํ๋์ด ๋ชจ๋ ์ ์๊ฐ ๋ฐํ์ ์ ๋์๋ค. ~ ์ ์๋ค์ ์์ ์ด ์์ผ๋ก ์ป์ ์ ์๋ ์ต์ ์ ๋ฑ์๋ฅผ ๊ณ์ฐํ ์ ์๋ค. ๊ฐ ์ ์์ ํ์ ์ค๋ ฅ์ ์ ์๋ก ์ฃผ์ด์ง๋๋ฐ, ๋ ํฐ ๊ฐ์ด ๋ ์ข์ ์ค๋ ฅ์ ์๋ฏธํ๋ค. ๋ ํฐ ์๋ฅผ ๊ฐ๊ณ ์๋ ์ฌ๋๋ง ์์ง๋ฅด๊ธฐ ๊ฐ๋ฅํ๋ค. ์ ์๋ค์ ํ์ ์ค๋ ฅ์ ํ์ฌ ๋ฌ๋ฆฌ๊ณ ์๋ ์์๋๋ก ์
๋ ฅ ๋ฐ์ ๊ฐ ์ ์์ ์ต์ ์ ๋ฑ์๋ฅผ ๊ณ์ฐํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ์
๋ ฅ82 8 10 7 1 9 4 15 ์ถ๋ ฅ1 1 1 3 5 2 5 1 1ํธ (80์ )5๊ฐ์ง ๊ฒฝ์ฐ ์ค 1๊ฐ์ง ๊ฒฝ์ฐ์์ ํ์๋ฆฌ๋ฐ๐ vector์ ํฌ๊ธฐ๋ฅผ n+1๋ก ์ค์ ํด์ผ 1๋ถํฐ ๋ฐ์ดํฐ init์ ํ ๋, ์ค๋ฅ๊ฐ ๋ฐ์ํ์ง ์๋๋ค!#include #include using namespace std;int m..
N๋ช
์ ํ์์ ์ํ์ ์๊ฐ ์
๋ ฅ๋๋ฉด ๊ฐ ํ์์ ์์ฐจ๋ฅผ ์
๋ ฅ๋ ์์๋๋ก ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์. ์
๋ ฅ ์ฒซ ์ค์ N์ด ์
๋ ฅ๋๊ณ , ๋ ๋ฒ์งธ ์ค์ ์ํ์ ์๋ฅผ ์๋ฏธํ๋ N๊ฐ์ ์ ์๊ฐ ์
๋ ฅ๋๋ค. ๊ฐ์ ์ ์๊ฐ ์
๋ ฅ๋ ๊ฒฝ์ฐ ๋์ ์์ฐจ๋ก ๋์ผ ์ฒ๋ฆฌํ๋ค. ์ฆ ๊ฐ์ฅ ๋์ ์ ์๊ฐ 92์ ์ธ๋ฐ, 92์ ์ด 3๋ช
์กด์ฌํ๋ฉด, 1๋ฑ์ด 3๋ช
์ด๊ณ , ๊ทธ ๋ค์ ํ์์ 4๋ฑ์ด ๋๋ค. ์ ์๋ 100์ ์ด ๋ง์ ์ด๋ค ์ถ๋ ฅ ์ฒซ ์ค์ ์
๋ ฅ๋ ์์๋๋ก ์์ฐจ๋ฅผ ์ถ๋ ฅํ๋ค. 1ํธ (์ฑ๊ณต) #include #include using namespace std; int main(void){ //freopen("input.txt", "rt", stdin); int n; cin >> n; vector a(n); vector b(n); for(int i = 0; i ..
N๊ฐ์ ์ ์๋ก ์ด๋ฃจ์ด์ง ์์ด์ ๋ํด ์๋ก ์ธ์ ํด ์๋ ๋ ์์ ์ฐจ๊ฐ 1~N-1๊น์ง์ ๊ฐ์ ๋ชจ๋ ๊ฐ์ง๋ฉด ๊ทธ ์์ด์ ์ ์พํ ์ ํผ๋ผ๊ณ ๋ถ๋ฅธ๋ค. ์๋ฅผ ๋ค์ด ๋ค์๊ณผ ๊ฐ์ ์์ด์์ 1 4 2 3 ์ ๋ค์ ์๋ ์ซ์ ์ฐจ์ ์ ๋ ๊ฐ์ด ๊ฐ๊ฐ 3, 2, 1์ด๋ฏ๋ก ์ด ์์ด์ ์ ์พํ ์ ํผ๊ฐ ๋๋ค. ์ด๋ค ์์ด์ด ์ ์พํ ์ ํผ์ธ์ง ํ๋จํ ์ ์๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ๋ผ. ์
๋ ฅ ์ฒซ ๋ฒ์งธ ์ค์ ์์ฐ์ N์ด ์ฃผ์ด์ง๋ค. ๊ทธ ๋ค์ ์ค์ N๊ฐ์ ์ ์๊ฐ ์ฃผ์ด์ง๋ค. ์ ์์ ํฌ๊ธฐ๋ intํ ๋ฒ์ ์์ ์๋ค. ์ถ๋ ฅ YES/NO 1ํธ (๊ฐ์ ํ์ด) ์ด๋ป๊ฒ ํด์ผํ ์ง ๋ชจ๋ฅด๊ฒ ์์ใ
ใ
ํ์ด๋ณด๋๊น ๋ฐ๋ก ์ดํด๋จ #include #include #include using namespace std; int main(void){ freopen("input.txt", "..
N๊ฐ์ ์ซ์๊ฐ ๋์ด๋ ์์ด์ด ์ฃผ์ด์ง๋๋ค. ์ด ์์ด ์ค ์ฐ์์ ์ผ๋ก ์ฆ๊ฐํ๋ ๋ถ๋ถ ์์ด์ ์ต๋ ๊ธธ์ด๋ฅผ ๊ตฌํ์ฌ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์. ๋ง์ฝ N=9์ด๊ณ , 5 7 3 3 12 12 13 10 11์ด๋ฉด, "3 3 12 12 13" ๋ถ๋ถ์ด ์ต๋ ๊ธธ์ด ์ฆ๊ฐ์์ด์ด๋ฏ๋ก ๊ทธ ๊ธธ์ด์ธ 5์ ์ถ๋ ฅํฉ๋๋ค. ๊ฐ์ด ๊ฐ์ ๋๋ ์ฆ๊ฐํ๋ ๊ฑธ๋ก ์๊ฐํฉ๋๋ค. ์
๋ ฅ ์ฒซ ์ค์ ์์ฐ์์ ๊ฐฏ์๊ฐ ์ฃผ์ด์ง๋ค. ๋ ๋ฒ์งธ ์ค์ N๊ฐ์ ์ซ์์ด์ด ์ฃผ์ด์ง๋ค. ๊ฐ ์ซ์๋ 100,000 ์ดํ์ ์์ฐ์์ด๋ค. 9 5 7 3 3 12 12 13 10 11 ์ถ๋ ฅ ์ต๋ ๋ถ๋ถ ์ฆ๊ฐ์์ด์ ๊ธธ์ด๋ฅผ ์ถ๋ ฅํ์ธ์. 1ํธ (์ฑ๊ณต) cnt๋ฅผ 1๋ก ์ด๊ธฐํํ๋ ๊ฒ์ ์ฃผ์ํด์ผ ํ๋ค. #include #include using namespace std; int main(void){ f..
๋งค์ผ ์์นจ 9์์ ํ๊ต์์ ์ธก์ ํ ์จ๋๊ฐ ์ด๋ค ์ ์์ ์์ด๋ก ์ฃผ์ด์ก์ ๋, ์ฐ์์ ์ธ ๋ฉฐ์น ๋์์ ์จ๋์ ํฉ์ด ๊ฐ์ฅ ํฐ ๊ฐ์ ์์๋ณด๊ณ ์ ํ๋ค. ์๋ฅผ ๋ค์ด, ๋ค์๊ณผ ๊ฐ์ด 10์ผ ๊ฐ์ ์จ๋๊ฐ ์ฃผ์ด์ก์ ๋, 3 -2 -4 -9 0 3 7 13 8 -3 ๋ชจ๋ ์ฐ์์ ์ธ ์ดํ๊ฐ์ ์จ๋์ ํฉ์ ๋ค์๊ณผ ๊ฐ๋ค. ์ด๋, ์จ๋์ ํฉ์ด ๊ฐ์ฅ ํฐ ๊ฐ์ 21์ด๋ค. ๋งค์ผ ์ธก์ ํ ์จ๋๊ฐ ์ ์์ ์์ด๋ก ์ฃผ์ด์ก์ ๋, ์ฐ์์ ์ธ ๋ฉฐ์น ๋์์ ์จ๋์ ํฉ์ด ๊ฐ์ฅ ํฐ ๊ฐ์ ๊ณ์ฐํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ์
๋ ฅ ์ฒซ ์งธ ์ค์๋ ๋ ๊ฐ์ ์ ์ N๊ณผ K๊ฐ ํ ๊ฐ์ ๊ณต๋ฐฑ์ ์ฌ์ด์ ๋๊ณ ์์๋๋ก ์ฃผ์ด์ง๋ค. ์ฒซ ๋ฒ์งธ ์ ์ N์ ์จ๋๋ฅผ ์ธก์ ํ ์ ์ฒด ๋ ์ง์ ์์ด๋ค. N์ 2์ด์ 100,000 ์ดํ์ด๋ค. ๋ ๋ฒ์งธ ์ ์ K๋ ํฉ์ ๊ตฌํ๊ธฐ ์ํ ์ฐ์์ ์ธ ๋ ์ง์ ์์ด๋ค..