SWLUG/ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค ์Šค์ฟจ (C)

[C] ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค ์Šค์ฟจ_6์ฃผ์ฐจ ๋ฌธ์ œ 2: ์ค‘๋ณต๋œ ์ˆซ์ž ๊ฐœ์ˆ˜

waterproof 2023. 8. 11. 21:58

 

 

 


[1] ๋ฌธ์ œ

 

๋ฌธ์ œ ์„ค๋ช…

์ •์ˆ˜๊ฐ€ ๋‹ด๊ธด ๋ฐฐ์—ด array์™€ ์ •์ˆ˜ n์ด ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ์ฃผ์–ด์งˆ ๋•Œ, array์— n์ด ๋ช‡ ๊ฐœ ์žˆ๋Š” ์ง€๋ฅผ return ํ•˜๋„๋ก solution ํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•ด๋ณด์„ธ์š”.

 

์ œํ•œ์‚ฌํ•ญ

  • 1 ≤ array์˜ ๊ธธ์ด ≤ 100
  • 0 ≤ array์˜ ์›์†Œ ≤ 1,000
  • 0 ≤ n ≤ 1,000

 

์ž…์ถœ๋ ฅ ์˜ˆ

array n result
[1, 1, 2, 3, 4, 5] 1 2
[0, 2, 3, 4] 1 0

 

์ž…์ถœ๋ ฅ ์˜ˆ ์„ค๋ช…

์ž…์ถœ๋ ฅ ์˜ˆ #1

  • [1, 1, 2, 3, 4, 5] ์—๋Š” 1์ด 2๊ฐœ ์žˆ์Šต๋‹ˆ๋‹ค.

 

์ž…์ถœ๋ ฅ ์˜ˆ #2

  • [0, 2, 3, 4] ์—๋Š” 1์ด 0๊ฐœ ์žˆ์Šต๋‹ˆ๋‹ค.

 

 

 


[2] ์ •๋‹ต ๋ฐ ํ•ด์„

 

#.1 ์ •๋‹ต ์ฝ”๋“œ

 

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
 
// array_len์€ ๋ฐฐ์—ด array์˜ ๊ธธ์ด์ž…๋‹ˆ๋‹ค.
int solution(int array[], size_t array_len, int n) {
    int answer = 0;
    for(int i = 0; i < array_len; i++) {
        if(array[i]==n) {
            answer++;
        }
    }        
    return answer;
}
cs

 

#.2 ํ•ด์„

 

์ด C ์ฝ”๋“œ๋Š” ์ฃผ์–ด์ง„ ๋ฐฐ์—ด์—์„œ ํŠน์ • ์ˆซ์ž n๊ณผ ์ผ์น˜ํ•˜๋Š” ์›์†Œ์˜ ๊ฐœ์ˆ˜๋ฅผ ์„ธ๋Š” ํ•จ์ˆ˜์ด๋‹ค.

 

 

1
#include <stdio.h>
cs

 

์ด ์ค„์€ stdio.h ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ์ด๋‹ค. ์ด ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋Š” C ์–ธ์–ด์—์„œ ํ‘œ์ค€ ์ž…์ถœ๋ ฅ ํ•จ์ˆ˜์ธ printf์™€ scanf๋ฅผ ์‚ฌ์šฉํ•˜๊ธฐ ์œ„ํ•ด ํ•„์š”ํ•œ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ์ด๋‹ค.

 

 

1
int solution(int array[], size_t array_len, int n) {
cs

 

์ด ๋ถ€๋ถ„์€ solution์ด๋ผ๋Š” ํ•จ์ˆ˜๋ฅผ ์ •์˜ํ•˜๊ณ  ์žˆ๋‹ค. ํ•จ์ˆ˜์˜ ๋ฐ˜ํ™˜ ๊ฐ’์€ int ํƒ€์ž…์ด๋ฉฐ, ํ•จ์ˆ˜์—๋Š” ์„ธ ๊ฐœ์˜ ๋งค๊ฐœ๋ณ€์ˆ˜๊ฐ€ ์ „๋‹ฌ๋œ๋‹ค.

1. array: ์ •์ˆ˜ํ˜• ๋ฐฐ์—ด์„ ๋‚˜ํƒ€๋‚ด๋Š” ํฌ์ธํ„ฐ์ด๋‹ค. ํ•จ์ˆ˜ ๋‚ด์—์„œ ๋ฐฐ์—ด์˜ ์›์†Œ์— ์ ‘๊ทผํ•˜๊ธฐ ์œ„ํ•ด ์‚ฌ์šฉ๋œ๋‹ค.

2. array_len: ๋ฐฐ์—ด array์˜ ๊ธธ์ด๋ฅผ ๋‚˜ํƒ€๋‚ด๋Š” size_t ํƒ€์ž…์˜ ๋ณ€์ˆ˜์ด๋‹ค.

3. n: ์ฐพ์œผ๋ ค๋Š” ์ˆซ์ž์ด๋‹ค.

 

1
int answer = 0;
cs

 

answer๋ผ๋Š” ์ด๋ฆ„์˜ ์ •์ˆ˜ํ˜• ๋ณ€์ˆ˜๋ฅผ ์„ ์–ธํ•˜๊ณ  0์œผ๋กœ ์ดˆ๊ธฐํ™”ํ•œ๋‹ค. ์ด ๋ณ€์ˆ˜๋Š” ๋ฐฐ์—ด์—์„œ n๊ณผ ์ผ์น˜ํ•˜๋Š” ์›์†Œ์˜ ๊ฐœ์ˆ˜๋ฅผ ์ €์žฅํ•  ์šฉ๋„๋กœ ์‚ฌ์šฉ๋œ๋‹ค.

 

1
for(int i = 0; i < array_len; i++) {
cs

 

๋ฐ˜๋ณต๋ฌธ์˜ ์‹œ์ž‘์„ ๋‚˜ํƒ€๋‚ด๋ฉฐ, i๋ผ๋Š” ์ •์ˆ˜ํ˜• ๋ณ€์ˆ˜๋ฅผ 0์œผ๋กœ ์ดˆ๊ธฐํ™”ํ•˜๊ณ  ๋ฐฐ์—ด์„ ๋ฐ˜๋ณตํ•˜๋ฉด์„œ ๊ฐ ์›์†Œ๋ฅผ ๊ฒ€์‚ฌํ•œ๋‹ค. i๋Š” ๋ฐฐ์—ด์˜ ์ธ๋ฑ์Šค๋ฅผ ๋‚˜ํƒ€๋‚ธ๋‹ค.

 

1
2
3
if(array[i]==n) {
    answer++;
}
cs

 

ํ˜„์žฌ ์ธ๋ฑ์Šค i์˜ ๋ฐฐ์—ด ์›์†Œ๊ฐ€ n๊ณผ ์ผ์น˜ํ•˜๋Š”์ง€ ํ™•์ธํ•œ๋‹ค. ๋งŒ์•ฝ ์ผ์น˜ํ•˜๋ฉด answer ๋ณ€์ˆ˜์˜ ๊ฐ’์„ 1 ์ฆ๊ฐ€์‹œ์ผœ์„œ n๊ณผ ์ผ์น˜ํ•˜๋Š” ์›์†Œ์˜ ๊ฐœ์ˆ˜๋ฅผ ์นด์šดํŠธํ•œ๋‹ค.

 

1
return answer;
cs

 

๋ฐ˜๋ณต๋ฌธ์ด ๋๋‚œ ํ›„, answer ๋ณ€์ˆ˜์— ์ €์žฅ๋œ n๊ณผ ์ผ์น˜ํ•˜๋Š” ์›์†Œ์˜ ๊ฐœ์ˆ˜๋ฅผ ๋ฐ˜ํ™˜ํ•œ๋‹ค.

 

 

 


[3] ํ’€์ด

 

โœ”๏ธ ๋ฐฐ์—ด์˜ ์ธ๋ฑ์Šค๋ฅผ ์‚ฌ์šฉํ•  ๋•Œ ์ธ๋ฑ์Šค๊ฐ€ ๋ฐฐ์—ด์˜ ๋ฒ”์œ„๋ฅผ ๋„˜์–ด๊ฐ€์ง€ ์•Š๋„๋ก ์ฃผ์˜ํ•ด์•ผ ํ•œ๋‹ค. ํ˜„์žฌ ์ฝ”๋“œ์—์„œ๋Š” ๋ฐฐ์—ด์˜ ์ธ๋ฑ์Šค๋ฅผ 0๋ถ€ํ„ฐ array_len - 1๊นŒ์ง€ ์‚ฌ์šฉํ•˜๊ณ  ์žˆ๋‹ค.

 

 

 


[4] ๋Š๋‚€ ์ 

 

1ํ•™๊ธฐ์— c์–ธ์–ด ๋ฐฐ์šธ ๋•Œ ๋ฐฐ์—ด ๋‹จ์›๋ถ€ํ„ฐ ๊ณต๋ถ€๋ฅผ ์†Œํ™€ํžˆ ํ–ˆ๋Š”๋ฐ ํ™•์‹คํžˆ ๊ฐœ๋…์„ ์ž˜ ๋ชจ๋ฅด๊ฒ ๋‹ค. ์—ฌ๋ฆ„ ๋ฐฉํ•™์— ๋ณต์Šตํ•˜๊ณ  ์žˆ์–ด์„œ ๋‹คํ–‰์ด๋‹ค.