Posts
Q&A
linear independence์ด๋ผ๋ฉด ์ one-to-one์ธ๊ฐ์?
Matrix A์ Column๋ค์ด linearly independent ํ๋ค๋ ๊ฒ์ if and only if A๊ฐ one-to-one mapping์ ๋๋ค. ์ฆ๋ช ์ ์ฌ๋ฌ ๊ฐ์ง๋ก ๋ง์ด ์๊ฐ๋์ด์์ผ๋ ์ง์ ์ฐพ์๋ณด์๋ฉด ๋๊ฒ ์ต๋๋ค. ์ ๊ฐ ์ด ๋์น๋ฅผ ์ง๊ด์ ์ผ๋ก ์ดํดํ๋ ๋ฐฉ๋ฒ์ ์๋์ ๊ฐ์ต๋๋ค. ์ฐ์ one-to-one์ linear mapping์์์ ์ง๊ด์ ์๋ฏธ๋ถํฐ ๋์๊ฒจ๋ด ์๋ค. A๊ฐ one-to-one mapping์ด๋ผ๋ ๊ฒ์ Ax = b์์ ์๋ก ๋ค๋ฅธ x๊ฐ ๊ฐ๊ฐ ์๋ก ๋ค๋ฅธ b๋ก mapping ๋๋ค๋ ๋ป์ ๋๋ค. ์ฌ๊ธฐ์ Column๋ค์ linear independence ์ linear mapping ์์์ ์๋ฏธ๋ฅผ ๋์๊ฒจ๋ด ์๋ค. Column๋ค์ linear independence๋ A์ Column๋ค ์ค ์ด๋๊ฒ๋ ์๋ก ๋ค๋ฅธ column๋ค์ linear combination์ผ๋ก ํํ๋ ์ ์๋ค๋ ๋ป์ ๋๋ค. ๋ฐ๋๋ก, column ๋ค์ด linearly dependentํ๋ค๋ฉด, ์ด๋ค column์ ๋ค๋ฅธ column๋ค์ linear combination์ผ๋ก ํํ๋ฉ๋๋ค. ์ฌ๊ธฐ์, i๋ฒ์งธ column์ด vector x์ i๋ฒ์งธ element ๋ฅผ mapping ํ๋ ๊ฒ์์ ์๊ธฐํด๋ณด๋ฉด (1.8 ๊ฐ์ standard matrix ๋ถ๋ถ์ ๋ณด์๋ฉด ๋ฉ๋๋ค), linearly dependent ํ๋ค๋ฉด, vector x์ '์ด๋ค element k'๊ฐ mapping๋๋ ๊ฒฐ๊ณผ๋ vector x์ ๋ค๋ฅธ element๊ฐ mapping ๋ ๊ฒ์ ์กฐํฉ์ผ๋ก ํํ๋ฉ๋๋ค. ๋ฐ๋ผ์, element k๋ ์ด๋ป๊ฒ ๊ฒฐ์ ๋์ด๋ ์๊ด์๋ free variable์ด๊ฒ ๋ฉ๋๋ค. ๋ฐ๋ผ์, one-to-one์ด์ง ์์ต๋๋ค. ์ด์ ๋์ฐ๋ก, one-to-one์ด๋ฉด linearly independentํ๊ฒ ๋ฉ๋๋ค. ์กฐ๊ธ roughํ๊ฒ ์ ์ด์ ์๋ฐํ ์ค๋ช ์ ์๋๋๋ค๋ง, linear independence์ one-to-one์ด linear map์์ ์ด๋ค ๊ด๊ณ๊ฐ ์๋์ง ์ดํดํ์๋๋ฐ์ ๋์์ด ๋์์ผ๋ฉด ํฉ๋๋ค :)
- 0
- 2
- 532
Q&A
1.6 {u,v,w} in R^3 ์ง๋ฌธ๋๋ฆฝ๋๋ค
์ ์๊ฐ๋ณด๋ค ๊ฐ๋จํ ๊ฑฐ์๋ค์ ใ ใ ์ดํด๋์ต๋๋ค. ๊ฐ์ฌํฉ๋๋ค!
- 1
- 2
- 254
Q&A
while (scanf(
๋ถ์กฑํ ์ ์ค๋ช ์ด ๋์์ด ๋๋ค๋ ๋คํ์ ๋๋ค :)
- 2
- 8
- 1.3K
Q&A
์ง๋ฌธ์์ต๋๋ค!
IDE๋ง๋ค ๋ฌ๋ผ์ง ์ ์๊ฒ ์ผ๋, ๋ณดํต ์ฃผ์์ ํฌ๊ธฐ๋ 32bit ํ๊ฒฝ์์ 4byte, 64bit ํ๊ฒฝ์์ 8byte์ ๋๋ค. 64bit๋ก ์คํํ์ ๊ฒ ์๋๊น ์ถ์ธกํด๋ด ๋๋ค :)
- 1
- 1
- 422
Q&A
while (scanf(
**์ค๋ฅ ๋ฐ๊ฒฌ ์ ์ง์ ๋ถํ๋๋ฆฝ๋๋ค.** ์กฐ๊ธ ๊น๋ค๋ก์ด ๋ถ๋ถ์ธ๋ฐ, ์ต๋ํ ์ดํด๋๋๋ก ์ค๋ช ํด๋ณด๊ฒ ์ต๋๋ค. scanf("%[^\n]%*c", input) ์์ ๋น ์ํฐ๋ฅผ ์ ๋ ฅํ๋ฉด %[^\n]์ ์ํด scanf๋ ์๋ฌด๊ฒ๋ ์ฝ์ด๋ค์ด์ง ์์ต๋๋ค. \n ์ ๊น์ง ์ฝ์ด์ผํ๋๋ฐ, ์ฒซ ๋ฌธ์๊ฐ \n์ด๋ ์๋ํ์ง ์๋๊ฑฐ์ฃ . ๋ฐ๋ผ์, while ๋ฌธ ๊ฒ์ฌ์์ ๊ณ์ ๋น ์ํฐ๋ฅผ ๋ง์ฃผ์น๋, %[^\n]์ ์ํด scanf๊ฐ ์๋ฌด๊ฒ๋ ์ฝ์ด๋ค์ด์ง ์๊ณ , ๊ทธ๋ ๊ธฐ์ ์ ์ด์ %*c ์๋์ผ๋ก ์ด์ด์ง์ง ์๋ ๊ฒ๋๋ค. ๊ทธ๋ ๋ค๋ฉด, %*c๋ ๋๋์ฒด ์ ํ์ํ ๊น? ์๋์ ๋จ์ํ ์ฝ๋๋ฅผ ์คํํด๋ด ์๋ค. #define _CRT_SECURE_NO_WARNINGS #include int main() { char input1[10]; scanf("%[^\n]", input1); printf("%s checked", input1); } ๋ถ๋ช ์ด ์ฝ๋์์๋ scnaf ์์ %*c๊ฐ ์์ต๋๋ค. ๊ทธ๋ฌ๋ %*c๊ฐ ์๋ ์ฝ๋์ ๋์ผํ๊ฒ ๋์ํฉ๋๋ค. scanf ์์ ๋ฐ๊ฟ๊ฐ๋ฉด์ ์คํํด๋ณด์ธ์ ๊ทธ๋ฐ๋ฐ ์๋์ ์ฝ๋๋ฅผ ์คํํด๋ณด์๋ฉด, %*c๊ฐ ์๊ณ ์์์ ๋ฐ๋ผ ๊ฒฐ๊ณผ๊ฐ ๋ฌ๋ผ์ง๋๋ค #define _CRT_SECURE_NO_WARNINGS #include int main() { char input1[10]; char input2[10]; scanf("%[^\n]", input1); scanf("%[^\n]", input2); printf("%s checked", input1); printf("%s checked", input2); } ์ด ์ฝ๋์์ abc๋ฅผ ์ ๋ ฅํ๋ฉด ์๋์ ๊ฐ์ ๊ฒฐ๊ณผ๊ฐ ๋์ต๋๋ค (์ฌ์ง) ์ด๋ ๋๋ฒ๊ฑฐ๋ก ์ฃผ์๋ฅผ ํ์ธํด๋ณด๋ฉด ์๋์ ๊ฐ์ ์ํ๊ฐ ๋ฉ๋๋ค (์ฌ์ง) ์ฆ, input1์ ๋ฐ๊ณ ๋์ ๋ฒํผ์ ๋จ์ \n ๋๋ฌธ์ input2๋ฅผ ๋ฐ๋ scanf๊ฐ ์ ๋๋ก ์คํ๋์ง ์๊ณ ์ถ๋ ฅ์์ input1์ ์ ์์ ์ผ๋ก ์ถ๋ ฅ๋์ง๋ง input2๋ฅผ ์ถ๋ ฅํ๋ ค๊ณ ํ๋ ๋ฌธ์์ด ๋์ \0 ์ด ์๊ณ ์ฐ๋ ๊ธฐ ๊ฐ์ ๊ณ์ ์ถ๋ ฅํ๋ค๊ฐ input1์ ๋ฉ๋ชจ๋ฆฌ๊น์ง ์นจ๋ฒํด์ input1 ๋์ \0์ ๋ง๋์์ผ printf๊ฐ ๋๋๋ ๋ชจ์์์ ๋๋ค ์ด ์ฝ๋์์ ์๋์ ๊ฐ์ด %[^\n]%*c ๋ฅผ ์ฌ์ฉํ๋ฉด, input1 input2 ๋ชจ๋ ์ ์์ ์ผ๋ก ์ ๋ ฅ๋ฐ์ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ ์ ๋ฆฌํ์๋ฉด ์ด๋ ์ต๋๋ค %*c๋ ๋ฒํผ์ ๋จ์์๋ \n์ ๋น์์ฃผ๋ ์ญํ ์ด ๋ง๋ค. ์ ํํ๋, ๋ง์ง๋ง ๋ฌธ์์ธ \n์ ๋ฒํผ๋ก๋ถํฐ ์ฝ์ด๋ค์ด์ง๋ง, ์๋์ ์น๊ณ ๋ฌธ์์ด์๋ ์ ๋ ฅํด์ฃผ์ง ์๋ ๊ฒ์ ๋๋ค. ๊ทธ๋ฌ๋, [Enter]๋ง ์ ๋ ฅํ์ ๊ฒฝ์ฐ &[^\n]์ ์ํด scanf๊ฐ ์ ์ด์ ์ฝ์ด๋ค์ด์ง ์์ผ๋ฏ๋ก %*c๊ฐ ์๋ํ์ง ์์๋ค๋ ๊ฒ์ ๋๋ค. -๋ต๋ณ์ด ๋์์ด ๋์ จ๋ค๋ฉด ์ข์์๋ฅผ ๋๋ฌ์ฃผ์ธ์!-
- 2
- 8
- 1.3K
Q&A
countํจ์์์ ๋ฒํผ๋น์ฐ๊ธฐ ํ์ํ ์ด์ ?
**์ค๋ฅ ๋ฐ๊ฒฌ ์ ์ง์ ๋ถํ๋๋ฆฝ๋๋ค.** ๋ต ๋จผ์ ์ฒซ๋ฒ์งธ ์ง๋ฌธ์ ๋ต๋ณ๋๋ฆฌ๊ฒ ์ต๋๋ค. ์ ๊ฐ ํ์ ๋ชจ ๊ต์๋์ด ํ๋ก๊ทธ๋จ์ ์ค๊ณํ์ ์๋๋ฅผ ๋ค ์ ์๋ ์์ง๋ง, ์ด ํ๋ก๊ทธ๋จ์ ๊ฒฝ์ฐ c๋ฅผ ์ ๋ ฅํ๋ฉด count๋ผ๋ ๊ธฐ๋ฅ์ด ๋์ํ๋๋ก ๋์ด์์ต๋๋ค. count๋ฅผ ๋์์ํค๊ธฐ ์ํด get_integer ๋ผ๋ ํจ์๋ฅผ ์ฌ์ฉํด์ integer ํ๋๋ฅผ ์ ๋ ฅ๋ฐ๋ ๊ฒ์ด๊ตฌ์. get_integer ๋ด๋ถ์์๋ ์ ์๊ฐ ์ ๋ ฅ๋ ๊ฒ ๋ง๋์ง ํ์ธํ๊ณ , ๋ง๋ค๋ฉด return ํ๋ ์์ผ๋ก ๋์ํ๋ ๊ฑฐ์ฃ . (count ๊ธฐ๋ฅ์ ๋ด๋ถ๊ธฐ๋ฅ์ผ๋ก get_integer ๊ธฐ๋ฅ) ์ด๋ ์ ๊ฐ ๋๋ฆฐ 2๋ฒ ์ง๋ฌธ์ฒ๋ผ '๋ง์ฝ์ get_integer ์์ scanf ์์ input์ด ์ ์์ ์ผ๋ก ์ ๋ ฅ๋์ผ๋, ๋ฒํผ์ ๋จ๋ ๊ฐ์ด ์๊ธด๋ค๋ฉด?' ์ด๋ผ๋ ๊ฐ์ ์ ํด๋ด ์๋ค. ์ด ๊ฐ์ ์ ๋ง๋ input ๊ฐ์ "123 k" ์ ๊ฐ์ input์ผ ๊ฒ์ ๋๋ค. "123 k" ๋ฅผ ์ ๋ ฅํ๋ฉด scanf๊ฐ ๊ณต๋ฐฑ๋ฌธ์ ์ ๊น์ง ์ ๋ ฅ์ ๋ฐ์ 123์ด ์ ์์ ์ผ๋ก ์ ๋ ฅ๋์ง๋ง, " k"๊ฐ ๋ฒํผ์ ๋จ๊ฒ ๋ฉ๋๋ค. ๋ฐ๋ผ์ count ํจ์๋ ๋ฒํผ์ ๋จ์์์ง ๋ชจ๋ฅผ ๊ฐ์ ๋น์์ค์ผ ํฉ๋๋ค (๋ฌผ๋ก get_integer ์์ input์ return ํ๊ธฐ์ ์ ๋ฒํผ๋ฅผ ๋น์์ค๋ ๋ฌธ์ ์๊ฒ ์ต๋๋ค) count ํจ์๊ฐ ๋๋๋ฉด ๋ค์ ์ฌ์ฉ์์ ์ ํ (a, b, c, q) ์ ์ ๋ ฅ๋ฐ์ํ ๋ฐ, ๋ฒํผ์ ๊ฐ์ด ๋จ์ผ๋ฉด ์ค๋์์ด ๋ฐ์ํ๊ฒ ๋๋๊น์. while (getchar() != '\n') continue; ๋ฅผ ์ฃผ์์ฒ๋ฆฌ ํด๋๊ณ "123 k" ์ ๊ฐ์ ๊ฐ์ ์ ๋ ฅํด๋ณด์๋ฉด ์ด๋ค ์์ผ๋ก ์๋ํ๋์ง๊ฐ ์ดํด๋์ค ๊ฑฐ๋ผ๊ณ ์๊ฐํฉ๋๋ค ๋๋ฒ์งธ ์ง๋ฌธ์ ๋ํ ๋ต์ ์๊ฐํ์ ๋๋ก๊ฐ ๋ง์ต๋๋ค. ๊ทธ๋ฌ๋, getchar()์ ๋ฒํผ์ scanf ๋ฒํผ๊ฐ ๋ฐ๋ก ์๋ ๊ฒ์ด ์๋๋๋ค. ์ ๋ ฅ(ํค๋ณด๋)์ ๋ํ ๋ฒํผ๊ฐ ์๊ณ , ์ ๋ ฅ์์ ๊ทธ ๋ฒํผ์์ ๊ฐ์ ์์๋ก ๋ฐ์๋์๋ค๊ฐ ํ๋ฒ์ ์ฎ๊ธฐ๋ ๊ฒ์ ๋๋ค. ๋ฐ๋ผ์ getchar ๋ฅผ ์ด์ฉํด ์ ์ถ๋ ฅ ๋ฒํผ๋ฅผ ๋น์ฐ๋ ๊ฒ ๊ฐ๋ฅํ ๊ฒ์ ๋๋ค. (์ถ๊ฐ ์ค๋ช ) ์ฐธ๊ณ : https://jhi93.github.io/category/os/2019-11-25-operatingsystem-02-1/ ์ฐธ๊ณ ๋ก ์ฌ๋ ค๋๋ฆฐ ์ฌ์ดํธ์ ์ฒซ๋ฒ์งธ ๊ทธ๋ฆผ์ ๋ณด์๋ฉด, ํค๋ณด๋์ ๋ง์ฐ์ค์ local buffer๊ฐ ์๋ ๋ชจ์ต์ ๋ณด์ค ์ ์์ต๋๋ค ์ด ๋ถ๋ถ์ ์ ์ญ์ ๊ณต๋ถ์ค์ธ ๋ถ๋ถ์ด๋ผ ๋ ์ ํํ๊ฒ ์ค๋ช ๋๋ฆฌ๊ธฐ๊ฐ ์กฐ๊ธ ์ด๋ ต๋ค์ -๋ต๋ณ์ด ๋์์ด ๋์ จ๋ค๋ฉด ์ข์์๋ฅผ ๋๋ฌ์ฃผ์ธ์!-
- 0
- 3
- 498
Q&A
while (scanf(
**์ค๋ฅ ๋ฐ๊ฒฌ ์ ์ง์ ๋ถํ๋๋ฆฝ๋๋ค.** ๋ต ๋ง์ํ์ ๋๋ก ๋ฒํผ ๋๋ฌธ์ด ๋ง์ต๋๋ค. ํ์ ๋ชจ ๊ต์๋๊ป์ ์ ์ฝ๋๋ฅผ ์ ๋ ๊ฒ ์ฐ์ จ๋์ง๋ ๋ชจ๋ฅด๊ฒ ์ผ๋, ์๋ง ์ํฐ๋ง ๋ค์ด์ฌ ๊ฒฝ์ฐ๋ฅผ ๊ฐ์ ํ์ง ์๊ณ ์์ฑํ์ ๊ฒ ์๋๊น์? scanf๊ฐ ์๋ํ๋ ๋ฐฉ์์ ์๊ฐํด๋ด ์๋ค. "%[^\n]%*c"์ ๋ฐ๋ผ \n์ ๋ง๋ ๋ ๊น์ง([^\n]) ์ฝ์ด๋ค์ด๊ณ , ๋ง์ง๋ง์ ๋ฌธ์๋ ๋ฌด์(*c)ํฉ๋๋ค. ์ด๋ [Enter]๋ง ์ ๋ ฅํ๋ฉด? ๋จผ์ ๋ฒํผ์ \n์ด ์ฐ์ฌ์ง ๊ฒ๋๋ค. ๋์์, scanf๊ฐ ๊ณต๋ฐฑ๋ฌธ์๋ฅผ ๋ง๋ฌ์ผ๋ฏ๋ก ์๋ํ๊ธฐ ์์ํฉ๋๋ค. ์ด๋ scanf๋ format specifier ์ ๋ฐ๋ผ \n ๋ง๋๊ธฐ ์ ๊น์ง ์ฝ๊ณ , ๋ง์ง๋ง ๋ฌธ์๋ฅผ ๋ฌด์ํฉ๋๋ค. ์ด๋ \n ๋ง๋๊ธฐ ์ ๊น์ง ์ฝ๋๋ค๋ ๊ฒ์, \n์ ์ฝ๋๋ค๋ ๊ฒ์ผ๊น์, ๋ฒํผ์ ๋จ๊ฒจ๋๋ ๊ฒ์ผ๊น์? #define _CRT_SECURE_NO_WARNINGS #include int main() { char input[10]; char ch; scanf("%[^'k']%*c", input); printf("%s\n", input); ch = getchar(); printf("%c\n", ch); } ์ด๋ฐ ์ฝ๋๋ฅผ ์์๋ก ์คํํด๋ด ๋๋ค. ์ ๋ ฅ์ abck๋ฅผ ๋ฃ์ผ๋ฉด, abc๊ฐ ๋จผ์ ์ถ๋ ฅ๋๊ณ , ํ์ค์ ๋์ด ํ k๊ฐ ์ถ๋ ฅ๋ฉ๋๋ค ์ฆ, ๋ฒํผ์๋ k๊ฐ ๋จ์ต๋๋ค. k ๋์ \n ์ผ๋ก ์คํํด๋ ๋ง์ฐฌ๊ฐ์ง์ ๋๋ค. ์๋ ์ฝ๋๋ก ๋์๊ฐ, while ์กฐ๊ฑด ๊ฒ์ฌ ์ดํ printf๊ฐ ์คํ๋๊ณ , ๋ค์ while๋ฌธ์ ์กฐ๊ฑด ๊ฒ์ฌ๋ฅผ ํ๋๋ฐ, ์์ ๋๊ฐ์ ์ผ์ด ๋ฐ๋ณต๋ฉ๋๋ค. ๋ฒํผ์ ์๋ ๊ฑด \n ๋ฟ์ธ๋ฐ, [^\n]์ผ๋ก ์ธํด \n์ ๋ฒํผ์ ๋จ๊ธฐ๊ณ ์ฝ์ผ๋ ๋ฐํ๊ฐ์ ๊ณ์ 0์ด๊ณ ๋ฌดํ๋ฃจํ๋ฅผ ๋ ์ ๋ฐ์ ์์ต๋๋ค ํด๊ฒฐ์ฑ ์, while ๋ฌธ์์ ๋ฒํผ๋ฅผ ์ง์ฐ๋ ์ฝ๋๋ฅผ ์ถ๊ฐํ๋ฉด ๋ฉ๋๋ค. -๋ต๋ณ์ด ๋์์ด ๋์ จ๋ค๋ฉด ์ข์์๋ฅผ ๋๋ฌ์ฃผ์ธ์!-
- 2
- 8
- 1.3K
Q&A
countํจ์์์ ๋ฒํผ๋น์ฐ๊ธฐ ํ์ํ ์ด์ ?
1. scanf ๋ ๊ณต๋ฐฑ์ ๊ธฐ์ค์ผ๋ก ๋๋ ์ ์ ๋ ฅ๋ฐ์ต๋๋ค. ๋ฐ๋ผ์, ๋ฒํผ์ ๋จ๋ ๊ฐ์ด ์๊ธธ ์ ์์ต๋๋ค 2. '๋ง์ฝ์ get_integer ์์ scanf ์์ input์ด ์ ์์ ์ผ๋ก ์ ๋ ฅ๋์ผ๋, ๋ฒํผ์ ๋จ๋ ๊ฐ์ด ์๊ธด๋ค๋ฉด?' ์ด๋ผ๋ ๊ฐ์ ์ ํด๋ด ์๋ค. ์ด๋ค ์ ๋ ฅ์ ๋ฃ์ผ๋ฉด ์์ ๊ฐ์ ๋๋ก ์งํ๋ ๊น์? 3. 2์์ ๋ฒํผ์ ๊ฐ์ด ๋จ์์ฑ๋ก count ์, while (getchar() != '\n') continue; ๊ฐ ์๋ค๋ฉด? ํด๋น ์ฝ๋๋ง ์ฃผ์์ฒ๋ฆฌ ํด๋๊ณ 2์์ ์ฐพ์ ์ ๋ ฅ๊ฐ์ ๋ฃ์ด๋ณด์ธ์. ๋ชป ์ฐพ์ผ์๊ฒ ์ผ๋ฉด ๋ค์ ์ง๋ฌธ ์ฃผ์๋ฉด ์๋ ค๋๋ฆฌ๊ฒ ์ต๋๋ค :) -๋ต๋ณ์ด ๋์์ด ๋์ จ๋ค๋ฉด ์ข์์๋ฅผ ๋๋ฌ์ฃผ์ธ์!-
- 0
- 3
- 498
Q&A
ํ์์ง์ ์ ํฌ๊ธฐ์ ์๋ฃํ์ ๋ํ ์ง๋ฌธ์ ๋๋ค.
**100% ์ ํํ ์ค๋ช ์ด ์๋ ์ ์์ต๋๋ค. ์ค๋ฅ ๋ฐ๊ฒฌ ์ ์ง์ ๋ถํ๋๋ฆฝ๋๋ค.** ๋จผ์ format specifier ๋ ๋ณ์๋ฅผ ์ด๋ป๊ฒ ์ฝ์ด๋ผ ๊ฒ์ธ์ง ์๋ ค์ฃผ๋ parameter ์ ๋๋ค. ์ฆ, %lld๋ char c๋ฅผ long long int ์ฒ๋ผ ์ฝ์ด๋ด๊ฒ ๋ค๋ ๋ป์ด์ง, char c ๊ฐ long long int ๊ฐ ๋๋ ๊ฒ์ด ์๋๋๋ค. ๋ฐ๋ผ์ ์์ ์ฝ๋์์ c๋ฅผ long long int ๋ก ์บ์คํ ํ๊ณ %lld๋ก ์ฝ์ด๋ด๋ฉด ํด๋น ๋ฌธ์ ๊ฐ ์ฌ๋ผ์ง๋๋ค ์๋์ ๋ด์ฉ์ ์กฐ๊ธ ๋ ์ฌํ๋ ์ค๋ช ์ ๋๋ค ( ์ฐธ๊ณ ํ ๊ธ https://operatingsystems.tistory.com/entry/Kernel-printf-%ED%95%A8%EC%88%98 ) ๋ท๋ถ๋ถ ํจ์, ํฌ์ธํฐ ๋ฑ์ ๊ฐ์๋ฅผ ๋ฃ๊ณ ๋ค์ ์ฝ์ผ์๋ฉด ์กฐ๊ธ ๋ ์ดํด๋์ค ๊ฒ ๊ฐ์ต๋๋ค (์ฌ์ง) ์ฒซ ์ค๋ง ์คํํ์ ๋์ ๊ฒฐ๊ณผ๊ฐ์ ๋๋ค (์ฌ์ง) ๋๋ฒ๊ฑฐ์์ ํด๋น๋๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฝ์์ ๋์ ์บก์ณ ์ฌ์ง์ ๋๋ค ์ด ๋ด์ฉ์ ์ดํดํ์๋ ค๋ฉด ์คํ์ ๋ํ ์ดํด๊ฐ ํ์ํ๋ฐ ํ์ฌ ๋ฉ๋ชจ๋ฆฌ์ ์คํ์ c, s ui, l, ll ์ด ์์ฌ์์ต๋๋ค. c๋ char ์๋ฃํ์ผ๋ก 1 byte๋ฅผ ์ฌ์ฉํ๊ณ , 16์ง์๋ก ํํ๋ c์ ์์คํค ์ฝ๋ ๊ฐ์ 41์ ๋๋ค. ๊ทธ๋ฆฌ๊ณ ๋ฌธ์ ์ %lld์ ์ฐ๋ ๊ธฐ๊ฐ์ด ๋์ค๋ ๋ถ๋ถ์ด ๋ณํ ์น ๋ถ๋ถ์ ๋๋ค ์๋จ์ ์ฒจ๋ถํด๋๋ฆฐ ์ ๊ฒฐ๊ณผ๊ฐ์ ๋ณด์๋ฉด, %lld๋ก ์ถ๋ ฅํ์ ๋์ ์ญ์ง์ ๊ฐ์ 14,094,884,369,596,481์ ๋๋ค ์ด๋ฅผ 16์ง์๋ก ๋ฐ๊พธ๋ฉด 0032 1339 0000 0041 ์ด๊ณ , ๊ทธ๊ฒ ๋ฐ๋ก ๋ณํ ์น ๋ถ๋ถ์ ๊ฐ์ ๋๋ค ๊ทธ๋ผ ์ ์ด๋ฌํ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋๋ ์ฌ๊ธฐ์๋ถํฐ๋ ์ฌ์ค๊ณผ ์ถ์ธก์ด ์์ธ ๋ต๋ณ์ด๋, ์ฐธ๊ณ ํ์๊ณ ๋ฐ์๋ค์ด์๊ธฐ ๋ฐ๋๋๋ค ๋ณํ์น ๋ถ๋ถ์ ์ฐ์ธก์ ?๊ฐ ๊ฐ๋ํ ์ฐฝ์ ๋ณด์๋ฉด, A๊ฐ ์ฌ๋ฌ ๋ฒ ์ ํ์๋ ๊ฒ์ ์ ์ ์์ต๋๋ค. ์ด๋ c์ ๊ฐ์ธ 65๋ก์, printf๊ฐ ํธ์ถ๋๋ฉฐ ํจ๊ป ํธ์ถ๋ ๊ฒ์ ๋๋ค. ์์ธํ ์ด์ ๋ ๋ชจ๋ฅด๊ฒ ์ผ๋, A... 5๋ฒ ๋ฐ๋ณต๋๋ ๊ฒ์ผ๋ก ๋ณด์, char, short ํ ๊ฒ ์์ด ๋ชจ๋ 4byte ์ฉ ๊ณต๊ฐ์ ์ฐจ์งํ๊ณ ์์ต๋๋ค (printf ์์ ์คํ์ ์ฃผ์๊ฐ์ ์ฌ๋ฆฌ๋ ๊ฒ๊ณผ, x64์์๋ A.......์ผ๋ก 8byte๋ฅผ ๊ฐ๋ ๊ฒ์ผ๋ก ์ถ์ธกํด๋ณด๋ฉด, ์ฃผ์์ ํฌ๊ธฐ๋งํผ ๊ณต๊ฐ์ ์ฐจ์งํ๋ ๊ฒ์ผ๋ก ๋ณด์ ๋๋ค) ์ด๋ ๋ง์ง๋ง์ %lld๋ก ์ฝ์ด๋ค์ด๋ฉด, ์ค์ ๋ณ์๊ฐ ๊ฐ๋ ๊ฐ๋ณด๋ค ๋ ํฐ ๊ณต๊ฐ์ ์ฝ์ด๋ค์ด๊ฒ ๋ฉ๋๋ค. ์ด๋ garbage value ๊ฐ ์ถ๋ ฅ๋๋ ๊ฒ์ ๋๋ค. (printf ๋ด์์ %lld๋ฅผ ๋งจ ์์ผ๋ก ์ฎ๊ฒจ๋ณด๋ฉด, ๋งจ ๋ง์ง๋ง์ format specifier ์์๋ ๋ฐ์ดํฐ๊ฐ ๋ฐ๋ฆฌ๋ ์ค๋ฅ๊ฐ ๋ฐ์ํจ์ ์ ์ ์์ต๋๋ค. ์ด๋์ ๊ฐ์ 10์ง์๋ก 279,172,874,305์ด ์ถ๋ ฅ๋๋๋ฐ 16์ง์ ๊ฐ์ผ๋ก๋ A๊ฐ ์กด์ฌํ๋ 4byte ๊ณต๊ฐ ๋๊ฐ๋ฅผ ๋ถ์ธ 0000 0041 0000 0041 ์์ ์ ์ ์์ต๋๋ค.) ์ ๋ฆฌํ์๋ฉด, ์ด๋ฐ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ ๊ฒ์ %lld๊ฐ ๋ณ์๋ฅผ ์ฝ์ด๋ด๋ ๋ฐฉ์์ ๋ถ๊ณผํ๊ธฐ ๋๋ฌธ์ ๋๋ค. ์ค์ ๋ณ์๊ฐ ์ฐจ์งํ๋ ๊ณต๊ฐ๋ณด๋ค ํฐ ๊ณต๊ฐ์ ์ฝ์ด๋ค์ด๊ธฐ ๋๋ฌธ์ ๋ฌธ์ ๊ฐ ๋ฐ์ํฉ๋๋ค. -๋ต๋ณ์ด ๋์์ด ๋์ จ๋ค๋ฉด ์ข์์๋ฅผ ๋๋ฌ์ฃผ์ธ์!-
- 0
- 1
- 459
Q&A
while (scanf(
์ํฐ๋ฅผ ์ ๋ ฅํ์ ๋ scanf("%[^\n]%*c", input) ์์ ๋ฐํ๊ฐ์ด ์ด๋ป๊ฒ ๋ ๊น์? ๊ทธ๋ฆฌ๊ณ ๊ทธ ๋ฐํ๊ฐ์ ๋ฐ๋ฅธ while๋ฌธ์ ์กฐ๊ฑด์ํ๋?
- 2
- 8
- 1.3K




