์ ํ ๊ฒ์ ์์์ ๋ฐฐ์ด์์ ์ํ๋ ๋ฐ์ดํฐ๋ฅผ ์ฐพ๋ ์๊ณ ๋ฆฌ์ฆ '์์์'์ธ ์ด์ ๋ ํฌ๊ธฐ ์์๋๋ก ์ ๋ ฌ๋ ๋ฐฐ์ด์ด๋ผ๋ฉด '์ด์ง ๊ฒ์'์ ์ฌ์ฉํ๋ ๊ฒ์ด ๋ซ๋ค. ์์ ๋ฌด์์. ๋ฐฐ์ด์ ์์์๋ถํฐ ๋ฐ์ดํฐ๋ฅผ ํ์ธํ๋ค. ๊ณ์ฐ ์๊ฐ์ O(n) ์) ์ง์ ํ ๊ฐ๊ณผ ๋ฐฐ์ด์ ๊ฐ์ด ๊ฐ์ ๊ฒฝ์ฐ ์ข
๋ฃ. ๋ฐฐ์ด์ ๊ฐ์ ๊ฐ์ด ์ค๋ณต์ผ๋ก ์์ ๊ฒฝ์ฐ์๋, ์ฒ์ ๋ฐ๊ฒฌ๋ ์์ ์ ์ข
๋ฃํ๋ค. x=68์ธ ๊ฒฝ์ฐ, '1' ์ํ๋ ๊ฐ์ด ๋ฐ๊ฒฌ๋์ง ์์ ๊ฒฝ์ฐ '-1'์ ํ์ํ๋ค. -1์ ์ธ๋ฑ์ค๋ก ์ฌ์ฉํ ์ ์๋ ๊ฐ์ด๊ธฐ ๋๋ฌธ #include #define LENGTH 10 int main(void) { int x = 0; int pos = -1; int a[] = { 72, 68, 92, 88, 41, 53, 97, 84, 39, 55 }; printf("์
๋ ฅํ ์ซ์ ..
๐ฉ๐ป ํ๋ก๊ทธ๋๋ฐ
n+1๊ฐ์ ํ์ ์ด๋ํ๋ ค ํ ๋, ๊ฐ์ฅ ํฐ ์๋ฐ์ ๋ฌด์ํ๊ณ , n๊ฐ๋ฅผ b๋ก ์ด๋ ์ํจ๋ค. ๊ฐ์ฅ ํฐ ์๋ฐ์ c๋ก ์ด๋์ํจ ๋ค ์ด๋์ํค๋ฉด ๋๋ค. ์ฒ์์ b๋ก n๊ฐ์ ํ์ ์ด๋์ํฌ ๋, c์ ๋๋์ด์ ์ด๋์์ผ์ผ ํ๊ธฐ ๋๋ฌธ์ ๊ณ์ฐ์ ์ผ๋ก ํด์ผํ๋ค. n๊ฐ ํ ๋ฌธ์ ๋ n-1 ํ ๋ฌธ์ ๋ฅผ ํ์ฉํ๋ฉด ๋๊ณ , n-1์ n-2๋ฅผ ํ์ฉํ๋ฉด ๋๊ธฐ ๋๋ฌธ์ ์ฌ๊ท์ ์๊ณ ๋ฆฌ์ฆ์ด๋ค. ๊ณ์ฐ ์๊ฐ n-1๊ฐ๋ฅผ A์์ B๋ก ์ด๋์ํฌ ๋, n-1 ๊ฐ์ฅ ํฐ ์๋ฐ์ C๋ก ์ด๋์ํฌ ๋, 1 B์ ์๋ n-1๊ฐ๋ฅผ C๋ก ์ด๋์ํฌ ๋, n-1์ด ํ์ํ๋ฏ๋ก T(n) = 2T(n-1) + 1 = 2^n - 1
๐ ์์๋ 1๊ณผ ์์ ์ด์ธ๋ ์ฝ์๋ก ๊ฐ์ง์ง ์๋ 1๋ณด๋ค ํฐ ์์ฐ์์ด๋ค. ๐ฉ ํ๋ฅด๋ง ํ
์คํธ = ํ๋ฅ ์ ์์ ํ๋ณ๋ฒ ์ด๋ค ์๊ฐ '์์์ผ ๊ฐ๋ฅ์ฑ์ด ๋์์ง'๋ฅผ ํ๋ณํ๋ ๊ฒ 1. ํด๋น ์๋ณด๋ค ์์ ์๋ฅผ ํด๋น ์๋งํผ ์ ๊ณฑํ๋ค. ์)5 -> 1^5 ~ 4^5 2. ๊ฐ๊ฐ์ ์ซ์๋ฅผ mod ์ฐ์ฐ์ ์ด์ฉํด ํด๋น ์๋ก ๋๋๋ค. ์) 1^5 = 1 mod 5 = 1 3. ์๋ ์์ ๋๋จธ์ง ๊ฐ์ด ๋ชจ๋ ์ผ์นํ๋ฉด, ์์์ด๋ค. ํ๋ฅด๋ง์ ์์ ๋ฆฌ๋ฅผ ๋ง์กฑํ๋์ง๋ฅผ ์์ ํ๋ณ์ ํ๋ ๋ฐฉ๋ฒ์ด 'ํ๋ฅด๋ง ํ
์คํธ' ์ผ์นํ๋์ง ํ์ธํ๋ ํ์๋ฅผ ๋๋ฆด์๋ก ์์์ผ ํ์ค์ฑ์ด ๋์์ง๋ค. ๋จ p๋ณด๋ค ์์ ๋ชจ๋ ์๋ฅผ ํ์ธํ๋ ค๋ฉด ๋งค์ฐ ์ค๋ ์๊ฐ์ด ๊ฑธ๋ฆฐ๋ค. ์ค์ ๋ก๋ ๋ช ๊ฐ์ ์๋ง ํ์ธํด์ ์์์ผ ๊ฐ๋ฅ์ฑ์ด ๋งค์ฐ ๋๋ค๊ณ ํ๋จํ ์ ์์ผ๋ฉด '์๋ง๋ ์์'๋ผ๊ณ ํ์ ํ๊ณ ์๋ค..
์๊ณ ๋ฆฌ์ฆ ํจ์จ์ฑ ๋ถ์ 1. ๊ณต๊ฐ ๋ณต์ก๋ ๋ฉ๋ชจ๋ฆฌ์ ์ = ์ ์ ๊ณต๊ฐ + ๋์ ๊ณต๊ฐ 2. ์๊ฐ ๋ณต์ก๋ ์ํ์๊ฐ = ์๊ณ ๋ฆฌ์ฆ์ ์คํ์์๋ถํฐ ์๋ฃ๊น์ง ๊ฑธ๋ฆฌ๋ ์๊ฐ = ๊ฐ ๋ฌธ์ฅ(์ฐ์ฐ)์ด ์ํ๋๋ ํ์ ๐ ์
๋ ฅ ํฌ๊ธฐ (๋ฐ์ดํฐ์ ๊ฐฏ์) ์) ๋ฆฌ์คํธ์ ์์ ๊ฐ์, ํ๋ ฌ ํฌ๊ธฐ, ๊ทธ๋ํ ์ ์ ์ ์ ๐ ์
๋ ฅ ๋ฐ์ดํฐ์ ์ํ ์ ๊ทผ์ฑ๋ฅ : ๋ฐ์ดํฐ์ ๊ฐ n์ด ๋ฌดํํ ์ปค์ง์ ๋ฐ๋ผ ๊ฒฐ์ ๋๋ ์ฑ๋ฅ ์๊ฐ๋ณต์ก๋ ๊ตฌํ๊ธฐ ์๊ณ ๋ฆฌ์ฆ์ ๋ชจ๋ ๋ฌธ์ฅ์ด ์๋ ๋ฃจํ์ ๋ฐ๋ณต ํ์๋ง์ ์กฐ์ฌํ์ฌ ์ต๊ณ ์ฐจ์๋ฅผ ์๊ฐ ๋ณต์ก๋๋ก ์ทจํจ
'์'์ ๋ํ '๋ฌธ์ ๋ฅผ ํธ๋ ๋ฐฉ๋ฒ' ์ปดํจ์ด ๋ถ์ผ์์๋ '๊ณต์ํ๋', '๋จ๊ณ์ '์ด๋ผ๋ ์กฐ๊ฑด ์ ๋งค๋ชจํธํ๋ฉฐ ์ธ์ ๋๋ ์ง ๋ชจ๋ฅด๋ ์ ์ฐจ๋ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ๋ถ๋ฅผ ์ ์๋ค. ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ ๋ ์ ์์ ์ต๋๊ณต์ฝ์๋ฅผ ๊ตฌํ๋ ์๊ณ ๋ฆฌ์ฆ 1. ๋ ์ ์์ ํฐ ์ชฝ - ์์ ์ชฝ, ์์ชฝ์ด ๊ฐ์์ง ๋๊น์ง ๋ฐ๋ณตํ๋ค. 2. ๊ฐ์์ง ๊ฐ์ด ์ต๋๊ณต์ฝ์๊ฐ ๋๋ค. ์) 50๊ณผ 30์ ์ต๋๊ณต์ฝ์ = 10 30 30 30-20=10 10 50 50-30=20 20 20-10=10 cf. ๋๋จธ์ง๋ก ์ต๋๊ณต์ฝ์ ๊ตฌํ๊ธฐ ๋๋ณด๊ธฐ ํฐ ์ชฝ์์ ์์ ์ชฝ์ ๋๋ ๋๋จธ์ง๋ฅผ ๊ณ์ ๊ตฌํ๋ค. ๋๋จธ์ง ๊ฐ์ด 0์ด ๋๋ ๋ชซ์ ์ต๋๊ณต์ฝ์๋ผ ํ๋ค. ์) 50๊ณผ 15์ ์ต๋๊ณต์ฝ์ = 5 1. 15 50 % 15 = 5 (50 -> 5) 2. 5 15 % 5 ..
ํ์ผ์ ์ฝ๊ณ ์ธ ๋๋ fputs(), fgets() ํจ์์ fprintf(), fscanf() ํจ์๋ฅผ ์ฌ์ฉ. ํ ์์ผ๋ก ์ด๋ฃจ์ด์ง ํ์ผ์์ ๋ฐ์ดํฐ๋ฅผ ์ฝ๊ณ ์ธ ๋๋ ๋จผ์ fopen() ํจ์๋ก ํ์ผ์ ์ด์ด์ ํ์ผ ํฌ์ธํฐ๋ฅผ ์ป์ด์ผ ํ๋ค. ํ์ผ ํฌ์ธํฐ๋ fopen() ํจ์๋ฅผ ํตํด ๋ฌด์จ ํ์ผ์ ์ด์๋์ง, ํ์ผ์ ์ด๋๊น์ง ์ฝ์๋์ง, ํ์ผ์ ๋์ ๋๋ฌํ๋์ง ๋ฑ์ ์ ๋ณด๋ฅผ ๋ด๋๋ค. ํ์ผ ํฌ์ธํฐ๋ฅผ ์ป๋ ๋ฐฉ๋ฒ FILE * ํฌ์ธํฐ๋ช
= fopen(ํ์ผ๋ช
, ํ์ผ๋ชจ๋); ํ์ผ ๋ชจ๋ : r ์ฝ๊ธฐ ์ ์ฉ, w ์ฐ๊ธฐ ์ ์ฉ, a ์ด์ด ์ฐ๊ธฐ ์ฝ๊ธฐ, ์ฐ๊ธฐ ์ ์ฉ ๋ค์๋ t์ b๋ฅผ ๋ถ์ผ ์ ์๋๋ฐ, t๋ ํ
์คํธ๋ฅผ ์๋ฏธ, b๋ ๋ฐ์ด๋๋ฆฌ ๋ฐ์ดํฐ๋ฅผ ์๋ฏธ ํ
์คํธ = ์ฌ๋์ด ์ฝ์ ์ ์๋ ๋ฌธ์์ด, ๋ฐ์ด๋๋ฆฌ ๋ฐ์ดํฐ = ์ปดํจํฐ๊ฐ ์ฝ์ ์ ์๋ 0๊ณผ 1๋ก ๋ ..
struct ๊ตฌ์กฐ์ฒด๋ช
{ ์๋ฃํ1 ๋ณ์๋ช
1; ์๋ฃํ2 ๋ณ์๋ช
2; ์๋ฃํ3 ๋ณ์๋ช
3; ... }; ๊ตฌ์กฐ์ฒด๋ ๋ณดํต ์ ์ญํจ์์ ๋ง์ฐฌ๊ฐ์ง๋ก main() ํจ์ ์ ์ ์ญ ์์น์ ์ ์ํ๋ค. ์ฌ์ฉ์ ์ ์ ์๋ฃํ struct GameInfo { char* name; int year; int price; char* company; }; ๊ตฌ์กฐ์ฒด ์ ์ธ : struct ๊ตฌ์กฐ์ฒด๋ช
๋ณ์๋ช
; struct GameInfo gameInfo1; typedef๋ก ๊ตฌ์กฐ์ฒด ์ ์ธํ๊ธฐ ๋๋ณด๊ธฐ typedef : ์๋ฃํ์ ์๋ก ์ด๋ฆ์ ๋ถ์ผ ๋ ์ฌ์ฉ int i = 1; typedef int ์ ์; // int == ์ ์ ์ ์ ์ ์๋ณ์ = 3; // int i = 3; typedef float ์ค์; ์ค์ ์ค์๋ณ์ = 3.23f; // float f =..
int arr[2][5]; = ์๋ฃํ ๋ฐฐ์ด๋ช
[์ธ๋กํฌ๊ธฐ][๊ฐ๋กํฌ๊ธฐ]; 5๊ฐ์ ์ฐ์๋ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ๊ฐ์ง 1์ฐจ์ ๋ฐฐ์ด์ด 2๊ฐ ์๋ค. ์ด ์์๋ 5 x 2 =10๊ฐ 2์ฐจ์ ๋ฐฐ์ด์ 1์ฐจ์ ๋ฐฐ์ด์ ์๋ฏธํ๋ ๋๊ดํธ์ ๋๊ดํธ๊ฐ ํ๋ ๋ ์ถ๊ฐ๋๋ค. 2์ฐจ์ ๋ฐฐ์ด์ด 2๊ฐ ์ด์ ์ฐ์๋๋ฉด, 3์ฐจ์ ๋ฐฐ์ด int arr[3][3][3]; 3๊ฐ์ ์ฐ์๋ ๊ณต๊ฐ์ ๊ฐ์ง 1์ฐจ์ ๋ฐฐ์ด์ด 3๊ฐ ์๊ณ , ์ด๋ฐ 2์ฐจ์ ๋ฐฐ์ด์ด ๋ค์ 3๊ฐ ์๋ค๋ ๋ป ์ฆ, 3 x 3ํฌ๊ธฐ์ 2์ฐจ์ ๋ฐฐ์ด์ด 3๊ฐ ์์ผ๋ฉฐ, ์ด ์์๋ 3 x 3 x 3 = 27๊ฐ์ด๋ค. ์ธ๋ก ํฌ๊ธฐ๋ ์๋ต ๊ฐ๋ฅ int arr[][2]; ๊ฐ์ ๋ชจ์์ ์นด๋ ๋ง์ถ๊ธฐ ๊ฒ์ ๋๋ณด๊ธฐ #include #include #include int arrayAnimal[4][5]; char* strAnimal[10..
int ์ฒ ์ = 1; ๋ฉ๋ชจ๋ฆฌ์ ์ฒ ์๋ผ๋ ๊ณต๊ฐ์ด ์๊ธด๋ค. ๊ทธ๋ฆฌ๊ณ ์ฒ ์๋ผ๋ ๊ณต๊ฐ์ ์์น๋ฅผ ๋ํ๋ด๋ ์ฃผ์๊ฐ ์๋ค. ์ฐ๋ฆฌ๋ 101ํธ๋ผ๊ณ ์ฝ์ง๋ง, ์ค์ ๋ฉ๋ชจ๋ฆฌ์์๋ ์ด๋ค ๊ฐ์ผ์ง ๋ชจ๋ฅธ๋ค. ์ฃผ์๊ฐ์ ์์๋ด๋ ค๋ฉด ๋ณ์๋ช
์์ &๋ฅผ ๋ถ์ฌ ์ถ๋ ฅํ๋ฉด ๋๋ค. ์ฃผ์๊ฐ์ ์ถ๋ ฅํ๊ณ ์ถ๋ค๋ฉด ์์์ง์ ์ %d ๋์ %p (ํฌ์ธํฐ)๋ฅผ ์ฌ์ฉํ๋ค. ๊ทธ๋ฌ๋ฉด ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ 16์ง์ ํํ๋ก ์ถ๋ ฅํ๋ค. #include int main(void) { int ์ฒ ์ = 1; int ์ํฌ = 2; int ๋ฏผ์ = 3; printf("์ฒ ์๋ค ์ฃผ์ : %p, ์ํธ : %d\n", &์ฒ ์, ์ฒ ์); printf("์ํฌ๋ค ์ฃผ์ : %p, ์ํธ : %d\n", &์ํฌ, ์ํฌ); printf("๋ฏผ์๋ค ์ฃผ์ : %p, ์ํธ : %d\n", &๋ฏผ์, ๋ฏผ์); return..
๋ฐฐ์ด : ๋์ผํ ์๋ฃํ์ ๊ฐ ์ฌ๋ฌ ๊ฐ๋ฅผ ์ ์ฅํ๋ ์ฐ์๋ ๊ณต๊ฐ ์๋ฃํ ๋ฐฐ์ด๋ช
[๋ฐฐ์ด ํฌ๊ธฐ]; int subway_array[3]; ์์ : ๋ฐฐ์ด์์ ๋ณ์ ํ๋์ ํด๋นํ๋ ๊ณต๊ฐ, ์ธ๋ฑ์ค๋ก ๊ตฌ๋ถ #include int main(void) { int subway[3]; subway[0] = 30; // [30][][] subway[1] = 40; // [30][40][] subway[2] = 50; // [30][40][50] for (int i = 0; i < 3; ++i) { printf("์งํ์ฒ %dํธ์ฐจ์ %d๋ช
์ด ํ๊ณ ์์ต๋๋ค \n", i + 1, subway[i]); } return 0; } int size = 10; int array[size]; // ๋ถ๊ฐ๋ฅ. ์์๋ง ๊ฐ๋ฅ int array[10]; /..
ํจ์ : ๊ฐ์ ์
๋ ฅ๋ฐ์ ์ด๋ค ์์
์ ํ ํ ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํ๋ ๊ฒ ๋ฐํํ ํจ์๋ช
(์ ๋ฌ๊ฐ); // ํจ์ ์ ์ธ int main(void){ ํจ์๋ช
(์ ๋ฌ๊ฐ); // ํจ์ ํธ์ถ } ๋ฐํํ ํจ์๋ช
(์ ๋ฌ๊ฐ){ // ํจ์ ์ ์ // ์ํํ ๋ฌธ์ฅ } ์์น ์ฃผ์. main ์ ์๋๋ก ๋๋๋ค. ์ฌ์น์ฐ์ฐ ์์ #include void p(int num); int main(void) { int num = 2; p(num); num += 3; p(num); num -= 1; p(num); num *= 3; p(num); num /= 6; p(num); return 0; } void p(int num) { printf("num์ %d ์
๋๋ค.\n", num); } ํจ์๋ฅผ ์ฌ์ฉํ๋ ์ด์ 2๊ฐ์ง 1. ์ฝ๋ ์ค๋ณต์ ๋ฐฉ์งํ๊ณ ํจ์จ์ ์ผ๋ก..
break for๋ฌธ์ ์ํํ๋ค๊ฐ break ๋ง๋๋ฉด for๋ฌธ ํ์ถ. ๋ฐ๋ก ๋ฐ๋ณต๋ฌธ ํ์ถ ์ด์ค for๋ฌธ์ผ ๊ฒฝ์ฐ, break๊ฐ ์๋ for๋ฌธ๋ง ํ์ถ #include int main(void) { for (int i = 1; i = 6) { printf("๋๋จธ์ง ํ์์ ์ง์ ๊ฐ์ธ์ \n"); break; } printf("%d๋ฒ ํ์ ๋ฐํ\n", i); } return 0; } continue ์ด๋ฒ ๋ฐ๋ณต๋ฌธ๋ง ์ข
๋ฃํ๊ณ , ๋ค์ ๋ฐ๋ณต๋ฌธ์ผ๋ก ๋์ด๊ฐ. ๋ฐ๊นฅ์ชฝ if๋ฌธ์ ์ํ๋ printf()๋ฌธ์ ์ํํ์ง ์๊ณ i++์ ์ํํ ํ ๋ค์ ๋ฐ๋ณต์ผ๋ก ๋์ด๊ฐ #include int main(void) { for (int i = 1; i 0) { coffee = 3500; } printf("์ฃผ๋ฌธํ์ ๋ฉ๋ด์ ์ด ๊ธ์ก์ %d ์
๋๋ค.",..