[1] ๋ฌธ์
๋ฌธ์ ์ค๋ช
์ ์ num1๊ณผ num2๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, num1์ num2๋ก ๋๋ ๊ฐ์ 1,000์ ๊ณฑํ ํ ์ ์ ๋ถ๋ถ์ return ํ๋๋ก soltuion ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- 0 < num1 ≤ 100
- 0 < num2 ≤ 100
์
์ถ๋ ฅ ์
num1 | num2 | result |
3 | 2 | 1500 |
7 | 3 | 2333 |
1 | 16 | 62 |
์ ์ถ๋ ฅ ์ ์ค๋ช
์ ์ถ๋ ฅ ์ #1
- num1์ด 3, num2๊ฐ 2์ด๋ฏ๋ก 3 / 2 = 1.5์ 1,000์ ๊ณฑํ๋ฉด 1500์ด ๋ฉ๋๋ค.
์ ์ถ๋ ฅ ์ #2
- num1์ด 7, num2๊ฐ 3์ด๋ฏ๋ก 7 / 3 = 2.33333...์ 1,000์ ๊ณฑํ๋ฉด 2333.3333.... ์ด ๋๋ฉฐ, ์ ์ ๋ถ๋ถ์ 2333์ ๋๋ค.
์ ์ถ๋ ฅ ์ #3
- num1์ด 1, num2๊ฐ 16์ด๋ฏ๋ก 1 / 16 = 0.0625์ 1,000์ ๊ณฑํ๋ฉด 62.5๊ฐ ๋๋ฉฐ, ์ ์ ๋ถ๋ถ์ 62์ ๋๋ค.
[2] ์ ๋ต
1 2 3 4 5 6 7 8 9 10 11 | #include <stdio.h> #include <stdbool.h> #include <stdlib.h> int solution(int num1, int num2) { float result = (float)num1 / num2 * 1000; int answer = (int)result; return answer; } | cs |
[3] ํด์
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | #include <stdio.h> #include <stdbool.h> #include <stdlib.h> int solution(int num1, int num2) { // num1์ num2๋ก ๋๋ ๊ฒฐ๊ณผ์ 1000์ ๊ณฑํ ๊ฐ์ ์ค์ํ ๋ณ์ result์ ์ ์ฅํฉ๋๋ค. float result = (float)num1 / num2 * 1000; // result๋ฅผ ์ ์ํ์ผ๋ก ํ๋ณํํ์ฌ ์์์ ์ดํ๋ฅผ ๋ฒ๋ฆฌ๊ณ ์ ์ ๊ฐ์ผ๋ก ์ ์ฅํฉ๋๋ค. int answer = (int)result; // ๊ฒฐ๊ณผ์ธ answer๋ฅผ ๋ฐํํฉ๋๋ค. return answer; } | cs |
์ด ์ฝ๋๋ C ์ธ์ด๋ก ์์ฑ๋ solution์ด๋ผ๋ ํจ์๋ฅผ ํฌํจํ๊ณ ์๋ค. ์ด ํจ์๋ ๋ ๊ฐ์ ์ ์ num1๊ณผ num2๋ฅผ ๋งค๊ฐ๋ณ์๋ก ๋ฐ์๋ค์ธ๋ค.
ํจ์ ๋ด๋ถ์์๋ ๋ค์๊ณผ ๊ฐ์ ์์ ์ ์ํํ๋ค:
- float ํ์์ ๋ณ์ result๋ฅผ ์ ์ธํ๊ณ , num1์ num2๋ก ๋๋ ํ์ 1000์ ๊ณฑํ ๊ฐ์ ์ ์ฅํ๋ค. ์ด ๋, num1๊ณผ num2๋ฅผ float๋ก ํ๋ณํํ์ฌ ์ ํํ ๋๋์ ์ด ์ด๋ฃจ์ด์ง๋๋ก ํ๋ค.
- result๋ฅผ int ํ์์ผ๋ก ํ๋ณํํ์ฌ answer๋ผ๋ ๋ณ์์ ์ ์ฅํ๋ค. ์ด๋ก์จ answer๋ ์์์ ์ดํ ๋ถ๋ถ์ด ๋ฒ๋ ค์ง ์ ์ ๊ฐ์ด ๋๋ค.
- answer๋ฅผ ๋ฐํํ๋ค.
์ด ํจ์๋ num1์ num2๋ก ๋๋ ํ์ 1000์ ๊ณฑํ ๊ฐ์ ์ ์ ๋ถ๋ถ์ ๋ฐํํ๋ ๊ธฐ๋ฅ์ ๊ฐ์ง๊ณ ์๋ค.
[4] ํ์ด ๋ฐ ์ค๋ต
โ๏ธ C ์ธ์ด์์ ๋ ๊ฐ์ ์ ์๋ฅผ ๋๋๋ฉด ๊ฒฐ๊ณผ๋ ์ ์๋ก ๊ณ์ฐ๋๋ค.
๋ด๊ฐ ์ฒ์์ ์ผ๋ ์ค๋ต:
1 2 3 4 5 6 7 8 9 10 11 | #include <stdio.h> #include <stdbool.h> #include <stdlib.h> int solution(int num1, int num2) { float i = 0; i = num1/num2 * 1000; int answer = 0; answer = (int)i; return answer; } | cs |
์ด ์ฝ๋์์ i = num1/num2 * 1000; ๋ผ์ธ์ num1์ num2๋ก ๋๋ ๊ฐ์ ๊ณ์ฐํ๊ณ , ๊ทธ ๊ฒฐ๊ณผ์ 1000์ ๊ณฑํ์ฌ i ๋ณ์์ ์ ์ฅํ๋ค.
๊ทธ๋ฌ๋ C ์ธ์ด์์ ๋ ๊ฐ์ ์ ์๋ฅผ ๋๋๋ฉด ๊ฒฐ๊ณผ๋ ์ ์๋ก ๊ณ์ฐ๋๋ค.
(๋๋ ๊ทธ ์ฌ์ค์ ๋ชฐ๋๊ณ , i๋ฅผ float๋ก ์ ์ธํด์ฃผ์๊ธฐ ๋๋ฌธ์ ์ ์๋ผ๋ฆฌ ๊ณ์ฐํ ๊ฐ์ด์ด๋ ์์์ ์ดํ๋ฅผ ๊ฐ์ง๋ฉด i์ ๋ฐ์์ด ๋ ๊ฒ์ด๋ผ๊ณ ์๊ฐํ๋ค.)
๋ฐ๋ผ์, num1์ num2๋ก ๋๋๋ ๊ฒฝ์ฐ, ๊ฒฐ๊ณผ๊ฐ ์์์ ์ดํ๋ฅผ ๊ฐ์ง ์ ์๋๋ฐ, ์ด ๋ถ๋ถ์ด ์๋ฆด ์ ์๋ค. ์๋ฅผ ๋ค์ด, 5๋ฅผ 2๋ก ๋๋๋ฉด ๊ฒฐ๊ณผ๋ 2.5์ง๋ง, ์ ์๋ก ๊ณ์ฐ๋๋ฏ๋ก 2๊ฐ ๋๋ค.
์ดํ i ๊ฐ์ int๋ก ํ๋ณํํ์ฌ answer์ ์ ์ฅํ๋ค. ์ด๋ก ์ธํด ์์์ ์ดํ๋ ๋ฒ๋ ค์ง๊ณ , ์ ์ ๋ถ๋ถ๋ง ๋จ๊ฒ ๋๋ค.
๋ฐ๋ผ์, ์ด ์ฝ๋์์๋ ์์์ ์ดํ ๊ฐ์ ์ ํํ ๊ณ์ฐํ๊ณ ์ ์งํ๊ธฐ ์ด๋ ค์ด ๋ฌธ์ ๊ฐ ์๋ค.
์ํ๋ ๊ฒฐ๊ณผ๋ฅผ ์ป๊ธฐ ์ํด์๋ ๋ค์๊ณผ ๊ฐ์ด ์์ ํ ์ ์๋ค:
1 2 | float result = (float)num1 / num2 * 1000; int answer = (int)result; | cs |
์์ ์ฝ๋๋ num1๊ณผ num2๋ฅผ ์ค์ํ์ผ๋ก ํ๋ณํํ์ฌ ๋๋์ ์ฐ์ฐ์ ์ํํ๊ณ , ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ์ค์ํ ๋ณ์ result์ ์ ์ฅํ๋ค.
๊ทธ๋ฐ ๋ค์ result๋ฅผ ์ ์ํ์ผ๋ก ํ๋ณํํ์ฌ answer์ ์ ์ฅํ๋ค. ์ด๋ ๊ฒ ํจ์ผ๋ก์จ ์์์ ์ดํ ๊ฐ์ ์ ํํ ๊ณ์ฐํ๊ณ ์ ์งํ ์ ์๋ค.
โ๏ธ ๋๋์ ์ฐ์ฐ์๊ฐ ํท๊ฐ๋ฆฐ๋ค. ('/'์ '%'์ ๊ธฐ๋ฅ์ด ํท๊ฐ๋ฆฐ๋ค.)
[5] ์ถ๊ฐ ํ์ต
C์ธ์ด ์ฐ์ฐ์ ๋ถ๋ถ์ ๊ณต๋ถํ ๋ด์ฉ์ ํฐ์คํ ๋ฆฌ์ ์ฌ๋ฆฌ๋ฉด ๋ค์ ๋งํฌ๋ฅผ ์ถ๊ฐํ๊ฒ ๋ค.
[6] ๋๋ ์
1-1 ์ค๊ฐ๊ณ ์ฌ ๋ ์ฐ์ฐ์๋ฅผ ๋ค๋ฃจ๋ ๋ฌธ์ ๊ฐ ๋์๋๋ฐ ๊ทธ ๋๋ ํ๋ ธ๋ ๊ธฐ์ต์ด ์๋ค. ๋ค์ ๋ณต์ตํ๊ฒ ๋์ด์ ๋คํ์ด๋ค.
'SWLUG > ํ๋ก๊ทธ๋๋จธ์ค ์ค์ฟจ (C)' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[C] ํ๋ก๊ทธ๋๋จธ์ค ์ค์ฟจ_2์ฃผ์ฐจ ๋ฌธ์ 3: ๋๋จธ์ง ๊ตฌํ๊ธฐ (2) | 2023.07.13 |
---|---|
[C] ํ๋ก๊ทธ๋๋จธ์ค ์ค์ฟจ_2์ฃผ์ฐจ ๋ฌธ์ 2: ๋ชซ ๊ตฌํ๊ธฐ (3) | 2023.07.13 |
[C] ํ๋ก๊ทธ๋๋จธ์ค ์ค์ฟจ_1์ฃผ์ฐจ ๋ฌธ์ 4: ๋ ์์ ๊ณฑ (0) | 2023.07.08 |
[C] ํ๋ก๊ทธ๋๋จธ์ค ์ค์ฟจ_1์ฃผ์ฐจ ๋ฌธ์ 3: ๋ ์์ ์ฐจ (0) | 2023.07.08 |
[C] ํ๋ก๊ทธ๋๋จธ์ค ์ค์ฟจ_1์ฃผ์ฐจ ๋ฌธ์ 2: ๋ ์์ ํฉ (0) | 2023.07.08 |