-๋ฐฐ์ด : ํ์ฐ์ ๋ฑ๋ฑ -์ฐ๊ฒฐ๋ฆฌ์คํธ : ๋์ ๋ฉ๋ชจ๋ฆฌ์ ํ ๋น๋, ๋งํฌ์ ์ํด ์ฐ๊ฒฐ๋ ์ ํ ๊ฐ์์ ๋ฐ์ดํฐ์์ ๋ ธ๋๋ค -์ข ๋ฅ : ๋จ์ผ์ฐ๊ฒฐ๋ฆฌ์คํธ ์ด์ค์ฐ๊ฒฐ๋ฆฌ์คํธ ์ํ์ฐ๊ฒฐ๋ฆฌ์คํธ ํค๋ ๋ฐ ํธ๋ ์ผ๋ฌ ์ฐ๊ฒฐ๋ฆฌ์คํธ ์ด๋ค์ ๋ณตํฉ 1. ๋จ์ผ์ฐ๊ฒฐ๋ฆฌ์คํธ -์ฐ์ ๋ ธ๋๋ก ๊ตฌ์ฑ๋ ๊ฐ์ฅ ๋จ์ํ ์ฐ๊ฒฐ ๋ฐ์ดํฐ๊ตฌ์กฐ ๋ ธ๋์ ์ ์ฅ๋ด์ฉ : ๋ฐ์ดํฐ์์, ๋งํฌ(๋ค์๋ ธ๋์ ์ฃผ์) ์ ๊ทผ์ :์ฒซ ๋ ธ๋ ์ฆ, ํค๋๋ ธ๋์ ์ฃผ์ 2. ์ด์ค์ฐ๊ฒฐ๋ฆฌ์คํธ -์ถ๊ฐ ๋งํฌ๋ฅผ ์ฌ์ฉํ์ฌ ์ญ๋ฐฉํฅ ์ํ๋ ๊ฐ๋ฅํ ๋ ธ๋์ ์ ์ฅ๋ด์ฉ : ์์(element), ๋งํฌ(๋ค์ ๋ ธ๋์ ์ฃผ์), ๋งํฌ(์ด์ ๋ ธ๋์ ์ฃผ์) ์ ๊ทผ์ :ํค๋๋ ธ๋, ํ ์ผ๋ ธ๋ 3. ์ํ์ฐ๊ฒฐ๋ฆฌ์คํธ -๋ง์ง๋ง ๋ ธ๋์ ๋งํฌ๊ฐ ํค๋๋ ธ๋์ ์ฃผ์ ์ ๊ทผ์ :ํค๋๋ ธ๋์ ์ฃผ์ 4. ํค๋์ ํธ๋ ์ผ๋ฌ -ํค๋๋ ธ๋ ๋ฐ๋ก ์์ ํน๋ณํ ํค๋(header)๋ ธ..

๋๋จธ์ง์ฐ์ฐ ๋ฌธ์ : ์ฝ๋: #include int modulo(int a, int b) { int t; t = a % b; return t; } int main() { int a, b; scanf("%d %d", &a, &b); printf("%d", modulo(a, b)); } ๋นํธํ๋ ฌ ๋ฌธ์ : ์ ์ถ๋ ฅ ํ์: 1) ์ ๋ ฅ: main ํจ์๋ ๋ค์ ๊ฐ๋ค์ ํ์ค์ ๋ ฅ๋ฐ๋๋ค. - ์ฒซ ๋ฒ์งธ ๋ผ์ธ: ์ ์ n (n ร n ํ๋ ฌ์์ n ๊ฐ, ๋จ n โค 100์ผ๋ก ์ ์ ํจ) - ๋ ๋ฒ์งธ ์ดํ ๋ผ์ธ: n ร n ๋นํธ ํ๋ ฌ ์์๋ค(ํ์ฐ์ ์์) 2) ์ถ๋ ฅ: main ํจ์๋ 1์ด ๊ฐ์ฅ ๋ง์ ํ ๋ฒํธ๋ฅผ ์ถ๋ ฅํ๋ค. ๋จ, ์ฒซ ๋ฒ์งธ ํ ๋ฒํธ๋ 0์ด๋ค. ์ ๋ ฅ ์์ 1 ์ถ๋ ฅ ์์ 2 8 โฆ n = 8 (8 ร 8 ํ๋ ฌ) 1 1 1 1 0 0..

-์ข์ ์๊ณ ๋ฆฌ์ฆ์ด๋? : ์๊ณ ๋ฆฌ์ฆ๊ณผ ๋ฐ์ดํฐ๊ตฌ์กฐ ์์ ์ ์์๋๋ ์คํ์๊ฐ, ๊ธฐ์ต์ฅ์ ์ฌ์ฉ๋์ด ๊ฒฐ์ -์คํ์๊ฐ : ์คํ์ ๋ฐฉ๋ฒ, ์ด๋ก ์ ๋ฐฉ๋ฒ(์์ฌ์ฝ๋๋ก ํํ๋ ์๊ณ ๋ฆฌ์ฆ ์ฌ์ฉ) -์์ฌ์ฝ๋ : ์ปดํจํฐ๊ฐ ์๋, ์ธ๊ฐ์๊ฒ ์ฝํ๊ธฐ ์ํด ์์ฑ๋จ.

์ฐ์ ์์ ํ๋ฅผ ์ด์ฉํ ์ ๋ ฌ : ๋น๊ต ๊ฐ๋ฅํ ์์ ์งํฉ์ ์ ๋ ฌํ๋๋ฐ ์ฐ์ ์์ ํ ์ด์ฉ ๊ฐ๋ฅ 1. ์ ํ ์ ๋ ฌ - ์ฐ์ ์์ ํ๋ฅผ ๋ฌด์๋ฆฌ์คํธ๋ก ๊ตฌํ (์ฐ์ ์์ ํ์ ํญ๋ชฉ๋ค์ ๋ฆฌ์คํธ์ ์์ ์์๋ก ์ ์ฅ) - ์คํ์๊ฐ : O(n^2) (์ฐ์ ์์ ํ์ ์ฝ์ ํ๋๋ฐ O(n)์๊ฐ ์์ + ์ ๋ ฌ์์๋ก ์ญ์ ํ๋๋ฐ n+(n-1)+(N-2)+... ์๊ฐ ์์) 2. ์ฝ์ ์ ๋ ฌ - ์ฐ์ ์์ ํ๋ฅผ ์์๋ฆฌ์คํธ๋ก ๊ตฌํ (์ฐ์ ์์ ํ์ ํญ๋ชฉ๋ค์ ๋ฆฌ์คํธ์ ํค ์ ๋ ฌ ์์๋ก ์ ์ฅ) - ์คํ์๊ฐ : O(n^2) (์ฐ์ ์์ ํ์ ์ฝ์ ํ๋๋ฐ n+(n-1)+(N-2)+... ์๊ฐ ์์ + ์ ๋ ฌ์์๋ก ์ญ์ ํ๋๋ฐ O(n)์๊ฐ ์์) 3. ์ ์๋ฆฌ ์ ๋ ฌ -๋ฆฌ์คํธ ์์ฒด๋ฅผ ์ํ ๊ณต๊ฐ ์ด์ธ์ O(1) ๊ณต๊ฐ ๋ง์ ์ฌ์ฉํ๋ค๋ฉด, ์ด๋ฅผ "์ ์๋ฆฌ(in-place)"์์ ..
[ ๋ฌธ์ 2-2 ] (100์ ) ๊ณต๋ฐฑ์ด ํฌํจ ๋ N๊ฐ์ ๋ฌธ์์ด์ ์ ๋ ฅ๋ฐ์, ๊ฐ ๋ฌธ์์ด์ M1๋ฒ์งธ ๋ฌธ์๋ถํฐ M2๋ฒ์งธ ๋ฌธ์๊น์ง์ ๋ฌธ์๋ค ์ค์ ์์ด๋๋ฌธ์๊ฐ ๋ช ๊ฐ ํฌํจ๋๋์ง ์ธ์ด (M1๋ฒ์งธ ๋ฌธ์์ M2๋ฒ์งธ ๋ฌธ์ ํฌํจ), ์์ด ๋๋ฌธ์๋ฅผ ๊ฐ์ฅ ์ ๊ฒ ํฌํจํ๋ ๋ฌธ์์ด์ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์๋์ check_u ํจ ์๋ฅผ ์ฌ์ฉํ์ฌ ์์ฑํ์์ค. ๋จ, ๋ฌธ์์ด์ ์ต๋ ๊ธธ์ด๋ 100์ด๊ณ , ์์ด๋๋ฌธ์๋ฅผ ํ๋๋ ํฌํจํ์ง ์ ์ ๋ฌธ์์ด์ ์ถ๋ ฅ์์ ์ ์ธํ๋ค. (N์ ์ต๋ 20 ์ด๋ค. ๋์ ํ ๋น๋ฌธ์ ๊ฐ ์๋. 2์ฐจ์ ๋ฐฐ์ด์ด ํ์ ์ ๋ ๋ฌธ์ ์ด๋ค) - ์ ์ N๊ณผ M1, M2๋ฅผ ์ ๋ ฅ๋ฐ๊ณ , ๊ณต๋ฐฑ์ด ํฌํจ๋ N๊ฐ์ ๋ฌธ์์ด์ ์ ๋ ฅ ๋ฐ๋๋ค. - M1๊ณผ M2๋ 0๋ถํฐ ํ์๋์ด ๋ฌธ์์ด๋ด์ ๊ฐ ๋ฌธ์์ ์์น๋ฅผ ๋ํ๋ธ๋ค. M1 ๊ฐ์ด ๋ฌธ์์ด์ ๊ธธ์ด ๋ณด๋ค ํฐ ๊ฒฝ์ฐ..
[ ๋ฌธ์ 3-1 ] (50์ ) ๋์ ํ ๋น ๋ฌธ์ ๊ฐ ์๋๊ณ ๋ฌธ์์ด ๋ฌธ์ ์ด๋ค. (1) ์ฒซ ๋ฒ์งธ ์ค์์, N๊ฐ์ ๋จ์ด๋ฅผ ํฌํจํ๋ ๋ฌธ์์ด A๋ฅผ ์ ๋ ฅ๋ฐ๊ณ (2) ๋ ๋ฒ์งธ ์ค์์, M๊ฐ์ ๋จ์ด๋ฅผ ํฌํจํ๋ ๋ฌธ์์ด B๋ฅผ ์ ๋ ฅ๋ฐ์ (3) ๋ ๋ฌธ์์ด ๋ชจ๋์ ํฌํจ๋ ๋จ์ด์ ์๋ฅผ ํ๋ฉด์ ์ถ๋ ฅํ๊ณ , (4) ๋ ๋ฌธ์์ด ๋ชจ๋์ ํฌํจ๋ ๋จ์ด ์ค ๊ฐ์ฅ ๊ธธ์ด๊ฐ ๊ธด ๋จ์ด๋ฅผ ํ๋ฉด์ ์ถ๋ ฅํ์์ค. ๋ง์ฝ, ๋ ๋ฌธ์์ด ๋ชจ๋์ ํฌํจ๋ ๋จ์ด ์ค ๊ฐ์ฅ ๊ธธ์ด๊ฐ ๊ธด ๋จ์ด๊ฐ ๋ ๊ฐ ์ด์ ์กด์ฌํ๋ฉด, ์ฌ์ ์์ ์ ์์ ๋จ์ด๋ฅผ ์ถ๋ ฅํ๋ค. (์์ฝ) ๋ ๋ฌธ์์ด ๋ชจ๋์ ํฌํจ๋ ๋จ์ด ์ค --- ๊ฐ์ฅ ๊ธธ์ด๊ฐ ๊ธด ๋จ์ด --- ์ฌ์ ์์ ์ ์์ ๋จ์ด - ๋ฌธ์์ด A์ B์ ์ต๋ ๊ธธ์ด๋ 100์ด๊ณ , N๊ณผ M์ 20๋ณด๋ค ํฌ์ง ์๋ค. - ๋จ์ด๋ ์ํ๋ฒณ ์๋ฌธ์๋ก๋ง ๊ตฌ์ฑ๋๋ฉฐ, ๋ฌธ์์ซ์..
[ ๋ฌธ์ 1-2 ] (100์ ) N๋ช ํ์์ ์ด๋ฆ๊ณผ 1์ฐจ, 2์ฐจ ์ํ ์ ์๋ฅผ ์ ๋ ฅ ๋ฐ์ ์ธ์ฆ์ํ ์ ์ฒด ํ๊ท ์ ์์ ํ๊ท ์ ์ ์ดํ์ธ ํ์์ ์๋ฅผ ์ถ๋ ฅ ํ ํ, ํ๊ท ์ ์ ์ดํ์ธ ํ์์ ์ด๋ฆ๊ณผ ์ ์๋ฅผ ์ ๋ ฅ๋ ์์๋ก ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์๋์ ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ์์ฑํ์์ค. ๋จ, Nโค100์ด๊ณ , ๊ฐ ํ์ ์ ์ํ ํ๊ท ์ ์๋ 1์ฐจ ์ํ ์ ์์ 40%์ 2์ฐจ ์ํ ์ ์์ 60%์ ํฉ์ผ๋ก ๊ณ์ฐ ํ๋ค. - insertData ํจ์ โฆ ํจ์์ํ : void insertData(struct student_info *s, int N) โฆ N๋ช ํ์์ ์ด๋ฆ๊ณผ ํ์ ๋น ๋ ๋ฒ์ ์ํ ์ ์๋ฅผ ์ ๋ ฅ ๋ฐ๊ณ , ํ์์ ์ํ ํ๊ท ์ ์๋ฅผ ๊ณ์ฐํ์ฌ ๊ตฌ์กฐ์ฒด ๋ฐฐ์ด์ ์ ์ฅํ๋ค. โฆ ํ์์ ์ด๋ฆ์ ๊ณต๋ฐฑ์ ํฌํจํ์ง ์๋ ์ต๋ 10๊ฐ ์์ด ๋ฌธ์์ด๋ค...
๋ฌธ์ : 2์ฐจ ๋ฐฉ์ ์์ ๊ฐ์ n๊ณผ ๊ฐ ๋ฐฉ์ ์์ ์ ์ ๊ณ์ a, b, c๋ฅผ ์ ๋ ฅํ๋ฉด ๋ฐฉ์ ์์ ํด๋ฅผ ํ๋ณํ์ฌ๋ผ. ์กฐ๊ฑด: ๋ค๋ฅด๋ฉด single, ์ค๊ทผ์ด๋ฉด double, ์ค๊ทผ์ด ์์ผ๋ฉด none ์ถ๋ ฅ ์ฝ๋: #include #include struct equation { int a; // 2์ฐจ ํญ์ ์ ์ ๊ณ์ int b; // 1์ฐจ ํญ์ ์ ์ ๊ณ์ int c; // ์์ ํญ์ ์ ์ char det[7]; // ํ๋ณ๊ฒฐ๊ณผ }; // 2์ฐจ ๋ฐฉ์ ์ ax2 + bx + c = 0 void root(struct equation* p); int main() { struct equation eq[100]; struct equation* p = &eq[100]; int n; scanf("%d", &n); for (int i = 0;..
๋ฌธ์ : ๋ ๊ฐ์ ๋ณต์์๋ฅผ ์ ๋ ฅ ๋ฐ๊ณ , ๋ ๋ณต์์๋ฅผ ๋ํ ๊ฒฐ๊ณผ๊ฐ์ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ์กฐ๊ฑด: ๊ตฌ์กฐ์ฒด ์ ์, add ํจ์ ์ ์, main ํจ์์์ ์ ๋ ฅ ๋ฐ ์ถ๋ ฅ ์ฝ๋: #include #include #include struct complex { //๋ณต์์ ๊ตฌ์กฐ์ฒด ์ ์ double sil, huh; //๋ณต์์์ ์ค์๋ถ์ ํ์๋ถ }; struct complex add(struct complex a, struct complex b); //ํจ์ ์ํ ์ ์ธ, ๊ตฌ์กฐ์ฒด ํจ์๋ก ์ค์ ํ๊ธฐ ์ฃผ์** int main() { struct complex a, b, c; scanf("%lf %lf", &a.sil, &a.huh); scanf("%lf %lf", &b.sil, &b.huh); c = add(a, b); ..
๋ฌธ์ : ์ฒซ ๋ฒ์งธ ์ ๋ ฅ๋ฐ์ ๋ฌธ์์ด์ ์๋ ๋จ์ด๋ค ์ค์์, ๋ ๋ฒ์งธ ์ ๋ ฅ๋ฐ์ ๋จ์ด๋ณด๋ค ์ฌ์ ์์ผ๋ก ์์ ํด๋นํ๋ ๋จ์ด๋ฅผ ์์์๋ถํฐ ์ฐจ๋ก๋๋ก ๋ชจ๋ ์ถ๋ ฅํ๊ณ , ๊ทธ ๋ค์ ์ค์ ์ฌ์ ์์ผ๋ก ๋ค์ ํด๋นํ๋ ๋จ์ด๋ฅผ ์์์๋ถํฐ ์ฐจ๋ก๋๋ก ๋ชจ๋ ์ถ๋ ฅํ์์ค. ์ฝ๋: #include #include int main() { char str1[150]; char str2[10]; char x[15][100]; //๋จ์ด ๊ณต๋ฐฑ ๋จ์๋ก ์งค๋ผ์ ์ ์ฅํ ๋ฐฐ์ด gets(str1); gets(str2); int i = 0, j, s, k = 0; int cnt = 0; for (i = 0; i < str1[i]; i++) {//str1 ๋ฌธ์์ด์ด ๋ ๋ฌธ์๊ฐ ๋์ฌ ๋๊น์ง ๋๋ฆฌ๊ธฐ if (str1[i] != ' ') { //๊ณต๋ฐฑ์ด ์๋๋ผ๋ฉด for (j ..
- Total
- Today
- Yesterday
- AI์ปจํผ๋ฐ์ค
- ๋ ผ๋ฌธ์ฝ๊ธฐ
- ๋๋ฆผ๋ถ์ค
- Gaussian Splatting
- gs๋ ผ๋ฌธ
- ํ ํฌ์๋ฐ
- AIRUSH
- dreambooth
- ์ปดํจํฐ๋น์
- gan
- lgaimers
- Paper review
- ์ฝ๋ฉ์๋ฌ
- SQL
- ํ์ด์ฌ์ฝํ
- CLOVAX
- ํ๋ก๊ทธ๋๋จธ์ค
- 3d-gs
- C์ธ์ด
- ์คํ ์ด๋ธ๋ํจ์
- ํ์ด์ฌ
- SKTECHSUMMIT
- ๋ ผ๋ฌธ๋ฆฌ๋ทฐ
- ์ฝ๋ฉ๊ณต๋ถ
- 2d-gs
- ๋ ผ๋ฌธ
- AIRUSH2023
- ์ฝํ ์ค๋น
- Aimers
- MYSQL
์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | 3 | 4 | 5 | ||
6 | 7 | 8 | 9 | 10 | 11 | 12 |
13 | 14 | 15 | 16 | 17 | 18 | 19 |
20 | 21 | 22 | 23 | 24 | 25 | 26 |
27 | 28 | 29 | 30 |