์ค๋ณต๋ ์ซ์ ๊ฐ์ ๐ข
Q. ์ ์๊ฐ ๋ด๊ธด ๋ฐฐ์ด `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 |
A.
def solution(array, n):
answer = 0
for a in array:
if a == n:
answer += 1
return answer
์ง๊ธ๋ถํฐ ์ด ๋ฌธ์ ์ ์ฝํ ์์ฃผ ์ฌํ ์ด์ผ๊ธฐ๋ฅผ ํด๋ณด๊ฒ ์ด์,,?
์ค๋ต๋ ธํธ ๋ค์ด๊ฐ๊ธฐ ์ ์,,, โฟ
์ฒ์์ ์ง๋ฌธ์ ์ฝ์ ๋๋ ์ต๋น๊ฐ๊ณผ ๊ด๋ จ๋ ๋ฌธ์ ๋ผ ์๊ฐ์ ํ๊ณ ๋ฌธ์ ๋ฅผ ํ์์ต๋๋ค,,
์ค! ํ ์คํธ ์ผ์ด์ค ํต๊ณผํ์ด!
์ ์ด ๋ ๋๋ ํด๋น ์ฝ๋๋ฅผ ์ ์ถํด๋ด ๋๋ค^__^
ํ์ง๋ง?
?????
์ด๋ฐ,, ํ๋ ค๋ฒ๋ฆฌ๊ณ ๋ง์๊ตฐ์,, ์ ๊ฐ ๋ญ๊ฐ๋ฅผ ๋์น๊ณ ์์๋๋ด ๋๋ค,,
๋ ์ผ์ด์ค์์ ๋ถํต์ด ๋ผ๋ฒ๋ฆฌ๊ณ ๋ง๊ฒ์,,
๊ทธ๋์?
์, ์ต๋น๊ฐ์ด ํ ๊ฐ๊ฐ ์๋ ๊ฒฝ์ฐ์ ์ผ์ด์ค์์ ๋น ๊พธ๋ฅผ ๋จน์๊ฑด๊ฐ?
๊ทธ๋ ๋ค๋ฉด ๋ฐ๋ณต๋ฌธ์ผ๋ก ์ ๊ทผ์ ํด๋ณผ๊น? ์ถ์ด์ ์ ๋๊ฒ for๋ฌธ ์ ์
????? ๋ ์๋๋ผ๋ค,,,
์ฒ์ ์ฝ๋์ ์ฝ๊ฐ์ ๋ฏธ๋ จ์ด ์์๋ ๋๋
์์ฃผ ์ฝ๋ฑ์ง๋งํผ ์์ ํด์ ๊ธฐ๋๋ฉํ๋ฅผ ํด๋ณด์์ด์
๊ทธ๋ฌ๋ ๋ ๋ฆฌ๊ฐ ์์ง ใ
mode = [v for k,v in countarr.items() if v == maxarr]
if mode[0] > 1:
return mode[0]
else:
return answer
๊ผด๋ ์ด๋ถ๋ถ ์กฐ๊ธ ๋ฐ๊ฟ์ ํต๊ณผ๋ ๊ฒ ๊ฐ์์ผ๋ฉด ์ฒ์ ์ฝ๋๊ฐ ์ํ๋ ธ๊ฒ ์ง,,ใ
๋์ฒด ๋ญ๊ฐ ๋ฌธ์ ์ง???? ํ๊ณ ๋์๊ฐ๋์ ๋ฌธ์ ๋ง ๋ ธ๋ ค๋ณด๋ค๊ฐ^^
ํด๊ฒฐ์ด ์๋ผ์ ์งํผํฐ์ ๋์์ ๋ฐ์์ต๋๋ค^^,,
์ค๋ต๋ ธํธ โ๏ธ
์ผ๋จ ์งํผํฐ๊ฐ ์๋ ค์ค ์ฝ๋๋ ์ด๋ฌ์ด์.
def solution(array, n):
"""
์ฃผ์ด์ง ๋ฐฐ์ด์์ ํน์ ์ ์์ ๊ฐ์๋ฅผ ์ธ๋ ํจ์์
๋๋ค.
Args:
array: ์ ์ ๋ฐฐ์ด.
n: ๊ฐ์๋ฅผ ์ธ๊ณ ์ ํ๋ ์ ์.
Returns:
๋ฐฐ์ด์์ ์ ์ n์ ๊ฐ์.
"""
count = 0
for num in array:
if num == n:
count += 1
return count
# ํ
์คํธ ์ผ์ด์ค
print(solution([1, 1, 2, 3, 4, 5], 1)) # ์ถ๋ ฅ: 2
print(solution([0, 2, 3, 4], 1)) # ์ถ๋ ฅ: 0
์๋ ๊ทผ๋ฐ ์ด๋์ ๋ง์ด ๋ณธ ๊ตฌ์กฐ์ธ๋ฐ???
def solution(array, n):
answer = 0
for a in array:
if a == n:
answer += 1
return answer
๋ค,, ์ ๊ฐ ๋๋ฒ์งธ๋ก ์ ์ถํ๋ ์ฝ๋์์ return์ ์์น๋ง ๋ฐ๋ ์ฝ๋์์ด์,,
๋ฆฌํด์ ์์น์ ๋ฐ๋ผ ์คํ๊ฒฐ๊ณผ๊ฐ ๋ฐ๋๋ค๋~!~!
์ด๋ฐ ์ฌ์ค์กฐ์ฐจ ๋ชจ๋ฅด๋ฉด์ ์ฝํ ๋ฅผ ํ๊ณ ์์๋ค๋
์์ง ๊ฐ ๊ธธ์ด ในใ ๋ฉ๋๋ค^^,,,
๊ทธ๋ ๋ค๋ฉด ์,,,
q. return์ ์์น์ ๋ฐ๋ผ ๊ฒฐ๊ณผ๊ฐ ๋ฐ๋๋์ง??
๋ง์ํ์ ์ฝ๋๊ฐ ์ค๋ต์ผ๋ก ์ฒ๋ฆฌ๋๋ ์ด์ ๋ return answer ๊ตฌ๋ฌธ์ด for ๋ฃจํ ๋ด๋ถ์ ์๊ธฐ ๋๋ฌธ์ ๋๋ค.
์ด ์ฝ๋๋ ๋ฐฐ์ด์์ ์ฒ์์ผ๋ก n๊ณผ ๊ฐ์ ์ซ์๋ฅผ ๋ง๋๋ฉด answer๋ฅผ 1 ์ฆ๊ฐ์ํค๊ณ ,
์ฆ์ ํจ์๋ฅผ ์ข ๋ฃํ๋ฉด์ ๊ทธ ๊ฐ์ ๋ฐํํฉ๋๋ค.
์ฆ, ๋ฐฐ์ด์์ n๊ณผ ๊ฐ์ ์ซ์๊ฐ ์ฌ๋ฌ ๋ฒ ๋ํ๋๋๋ผ๋ ์ฒ์ ๋ฐ๊ฒฌ๋ ์ซ์๋ง ์ธ๊ณ ๋๋๋ฒ๋ฆฝ๋๋ค.
๋ฌธ์ ๋ถ์
๋ฌธ์ ๋ ๋ฐฐ์ด์ n์ด ๋ช ๊ฐ ์๋์ง ๋ชจ๋ ์ธ์ด์ ๊ทธ ๊ฐ์๋ฅผ ๋ฐํํ๋ ๊ฒ์
๋๋ค.
ํ์ง๋ง ์์ฑํ์ ์ฝ๋๋ ์ฒ์ ๋ฐ๊ฒฌ๋๋ ํ๋์ n๋ง ์ธ๊ณ ๋๋๋ฏ๋ก, ์
๋ ฅ ๋ฐฐ์ด์ n์ด ์ฌ๋ฌ ๊ฐ ์๋ ๊ฒฝ์ฐ ์ค๋ต์ด ๋ฉ๋๋ค.
- ์์:
- ๋ง์ฝ ์
๋ ฅ์ด array = [1, 1, 2, 3, 4, 5], n = 1 ์ด๋ผ๋ฉด:
- ์ฒ์ a๋ 1์ด๋ฏ๋ก a == n ์กฐ๊ฑด์ด ์ฐธ์ด ๋ฉ๋๋ค.
- answer๋ 1์ด ๋ฉ๋๋ค.
- return answer ๋ฌธ์ฅ์ด ์คํ๋๋ฉด์ ํจ์๊ฐ ์ข ๋ฃ๋๊ณ , ๊ฒฐ๊ณผ๋ก 1์ด ๋ฐํ๋ฉ๋๋ค.
- ํ์ง๋ง ์ค์ ๋ก๋ ๋ฐฐ์ด์ 1์ด 2๊ฐ ์์ผ๋ฏ๋ก ์ ๋ต์ 2์ ๋๋ค.
- ๋ง์ฝ ์
๋ ฅ์ด array = [1, 1, 2, 3, 4, 5], n = 1 ์ด๋ผ๋ฉด:
- ์์ ๋ ์ฝ๋:
- ์ ํํ ๊ฒฐ๊ณผ๋ฅผ ์ป๊ธฐ ์ํด์๋ return answer ๊ตฌ๋ฌธ์ for ๋ฃจํ ๋ฐ์ผ๋ก ์ด๋์์ผ์ผ ํฉ๋๋ค.
์ฆ, ๋ฐฐ์ด์ ๋ชจ๋ ์์๋ฅผ ํ์ธํ ํ์ ์ต์ข ์ ์ธ answer ๊ฐ์ ๋ฐํํด์ผ ํฉ๋๋ค.
- ์ ํํ ๊ฒฐ๊ณผ๋ฅผ ์ป๊ธฐ ์ํด์๋ return answer ๊ตฌ๋ฌธ์ for ๋ฃจํ ๋ฐ์ผ๋ก ์ด๋์์ผ์ผ ํฉ๋๋ค.
def solution(array, n):
answer = 0
for a in array:
if a == n:
answer += 1
return answer
- ์์ ๋ ์ฝ๋ ์ค๋ช
:
- answer๋ฅผ 0์ผ๋ก ์ด๊ธฐํํฉ๋๋ค.
- for ๋ฃจํ๋ฅผ ์ฌ์ฉํ์ฌ array์ ๋ชจ๋ ์์๋ฅผ ์ํํฉ๋๋ค.
- ๊ฐ ์์ a๊ฐ n๊ณผ ๊ฐ๋ค๋ฉด answer๋ฅผ 1์ฉ ์ฆ๊ฐ์ํต๋๋ค.
- for ๋ฃจํ๊ฐ ์ข ๋ฃ๋ ํ, ์ต์ข ์ ์ผ๋ก ๋์ ๋ answer ๊ฐ์ ๋ฐํํฉ๋๋ค.
- ์ด์ ์ด ์์ ๋ ์ฝ๋๋ ๋ฐฐ์ด์ ๋ชจ๋ ์์๋ฅผ ๊ฒ์ฌํ๊ณ n๊ณผ ๊ฐ์ ๋ชจ๋ ์ซ์๋ฅผ ์ธ๊ธฐ ๋๋ฌธ์, ์ํ๋ ๊ฒฐ๊ณผ๋ฅผ ์ ํํ๊ฒ ๋ฐํํฉ๋๋ค.
- ํต์ฌ:
- return ๋ฌธ์ ํจ์ ์คํ์ ์ฆ์ ์ข ๋ฃ์ํค๊ณ ๊ฐ์ ๋ฐํํฉ๋๋ค. ๋ฐ๋ผ์ ๋ฃจํ ๋ด๋ถ์์ return์ ์ฌ์ฉํ๋ฉด ๋ฃจํ๋ฅผ ์์ ํ ์ํํ์ง ๋ชปํ๊ณ ์ค๊ฐ์ ์ข ๋ฃ๋ ์ ์๋ค๋ ์ ์ ์ฃผ์ํด์ผ ํฉ๋๋ค.
๊ทธ๋ ๋ค๋ฉด, ์ ๋ ๋ ๋ค๋ฅธ ๊ถ๊ธ์ฆ์ด ์๊ฒจ๋ฒ๋ฆฌ์ฃ ?
q. ์ด๋ค ๊ฒฝ์ฐ๋ return์ด for ๋ฃจํ ๋ฐ์ ์์ ๊ฒฝ์ฐ, ์คํ์ด ์๋๋๋ฐ ๋ฌด์จ ์ฐจ์ด์ผ?
return ๋ฌธ์ด for ๋ฃจํ ์์ ์๋๋ ๋ฐ์ ์๋๋์ ๋ฐ๋ผ
์ฝ๋์ ์คํ ํ๋ฆ๊ณผ ๊ฒฐ๊ณผ๊ฐ ๋ฌ๋ผ์ง๋ ๊ฒ์
ํจ์ ๋ด์์์ ์คํ ๋งฅ๋ฝ๊ณผ return ๋ฌธ์ ์ญํ ๋๋ฌธ์ ๋๋ค.
1. return ๋ฌธ์ด for ๋ฃจํ ๋ด๋ถ์ ์๋ ๊ฒฝ์ฐ:
- ์คํ ํ๋ฆ:
- or ๋ฃจํ๋ ์ฃผ์ด์ง ์ปฌ๋ ์ (๋ฆฌ์คํธ, ํํ, ๋ฌธ์์ด ๋ฑ)์ ๊ฐ ์์์ ๋ํด ๋ฐ๋ณต์ ์ผ๋ก ์ฝ๋๋ฅผ ์คํํฉ๋๋ค.
- return ๋ฌธ์ด for ๋ฃจํ ๋ด๋ถ์ ์๋ค๋ฉด, ๋ฃจํ์ ๋ฐ๋ณต ๊ณผ์ ์ค์ return ๋ฌธ์ด ํ ๋ฒ์ด๋ผ๋ ์คํ๋๋ ์๊ฐ ํจ์๋ ์ฆ์ ์ข ๋ฃ๋ฉ๋๋ค.
- return ๋ฌธ์ ํจ์์ ์คํ์ ์ข ๋ฃ์ํค๊ณ , ์ง์ ๋ ๊ฐ์ ํจ์ ํธ์ถ์์๊ฒ ๋ฐํํฉ๋๋ค.
- ์ฃผ์ ํน์ง:
- ๋ฃจํ์ ์ ์ฒด ๋ฐ๋ณต์ ์๋ฃํ์ง ๋ชปํ๊ณ ์ค๊ฐ์ ํจ์๊ฐ ์ข ๋ฃ๋ ์ ์์ต๋๋ค.
- ์ฃผ๋ก ํน์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ์์๋ฅผ ์ฐพ๊ฑฐ๋, ํน์ ์กฐ๊ฑด์ ๋ง์กฑํ์ง ์์ผ๋ฉด ํจ์๋ฅผ ์ข
๋ฃํ๊ณ ์ถ์ ๋ ์ฌ์ฉํฉ๋๋ค.
- ์์: (์ด์ ์ค๋ต์ฝ๋)
- ์ด ์ฝ๋๋ ์ฒ์ n์ ๋ง๋๋ฉด ๋ฐ๋ก ์ข ๋ฃ๋๊ธฐ ๋๋ฌธ์ ๋ฐฐ์ด์ n์ด ์ฌ๋ฌ ๊ฐ ์์ด๋ ๋ชจ๋ ์ธ์ง ๋ชปํฉ๋๋ค.
- ์์: (์ด์ ์ค๋ต์ฝ๋)
def solution(array, n):
answer = 0
for a in array:
if a == n:
answer += 1
return answer # ์ฒ์ ๋ง๋๋ n๋ง ์ธ๊ณ ํจ์ ์ข
๋ฃ
- ์ ์ ํ ์ฌ์ฉ ์:
- ๋ฆฌ์คํธ์์ ํน์ ๊ฐ์ ์ฐพ๋ ๊ฒฝ์ฐ (์ฒ์ ๋ฐ๊ฒฌ๋ ๊ฐ๋ง ํ์ํ ๋)
- ํน์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ฉด ๋ฐ๋ก ํจ์๋ฅผ ์ข ๋ฃํด์ผ ํ๋ ๊ฒฝ์ฐ
def find_first_even(numbers):
for num in numbers:
if num % 2 == 0:
return num # ์ฒ์ ๋ฐ๊ฒฌ๋ ์ง์๋ฅผ ๋ฐํํ๊ณ ์ข
๋ฃ
return None # ์ง์๋ฅผ ์ฐพ์ง ๋ชปํ๋ฉด None ๋ฐํ
2. return ๋ฌธ์ด for ๋ฃจํ ์ธ๋ถ์ ์๋ ๊ฒฝ์ฐ:
- ์คํ ํ๋ฆ:
- for ๋ฃจํ๋ ์ฃผ์ด์ง ์ปฌ๋ ์ ์ ๋ชจ๋ ์์๋ฅผ ์ํํ๋ฉฐ ๋ฐ๋ณต์ ์ผ๋ก ์ฝ๋๋ฅผ ์คํํฉ๋๋ค.
- return ๋ฌธ์ด for ๋ฃจํ ์ธ๋ถ์ ์๋ค๋ฉด, ๋ฃจํ๊ฐ ์์ ํ ์ข ๋ฃ๋ ํ์ ํ ๋ฒ ์คํ๋ฉ๋๋ค.
- ์ด ๊ฒฝ์ฐ, ๋ฃจํ ๋ด๋ถ์์ ๊ณ์ฐ๋ ๊ฐ์ ๋ฐํํ๊ฑฐ๋ ๋ฃจํ ์ ์ฒด์ ๋ํ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๊ฒ ๋ฉ๋๋ค.
- ์ฃผ์ ํน์ง:
- ๋ฃจํ์ ์ ์ฒด ๋ฐ๋ณต์ ์๋ฃํ ํ ํจ์๊ฐ ์ข ๋ฃ๋ฉ๋๋ค.
- ๋ฃจํ ์ ์ฒด์ ๋ํ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๊ณ ์ถ์ ๋ ์ฌ์ฉํฉ๋๋ค.
- ์์: (์์ ๋ ์ ๋ต ์ฝ๋)
- ์ด ์ฝ๋๋ ๋ฐฐ์ด์ ์๋ ๋ชจ๋ n์ ๋ค ์ธ๊ณ ์ด ๊ฐ์๋ฅผ ๋ฐํํฉ๋๋ค.
- ์์: (์์ ๋ ์ ๋ต ์ฝ๋)
def solution(array, n):
answer = 0
for a in array:
if a == n:
answer += 1
return answer # ๋ชจ๋ n์ ์ธ๊ณ ์ด ๊ฐ์๋ฅผ ๋ฐํ
- ์ ์ ํ ์ฌ์ฉ ์:
- ๋ฆฌ์คํธ์ ๋ชจ๋ ์์๋ฅผ ํฉ์ฐํ๊ฑฐ๋ ํ๊ท ์ ๊ณ์ฐํ๋ ๊ฒฝ์ฐ
- ๋ฆฌ์คํธ์์ ํน์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ์์์ ๊ฐ์๋ฅผ ์ธ๋ ๊ฒฝ์ฐ
- ๋ฆฌ์คํธ์ ๋ชจ๋ ์์์ ๋ํด ์ด๋ค ์ฒ๋ฆฌ๋ฅผ ํ ํ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๋ ๊ฒฝ์ฐ
์ ๋ฆฌ ๐งน
ํน์ง | return ๋ฌธ์ด for ๋ฃจํ ๋ด๋ถ | return ๋ฌธ์ด for ๋ฃจํ ์ธ๋ถ |
์คํ ํ๋ฆ | ๋ฃจํ ์ค๊ฐ์ ํจ์ ์ข ๋ฃ ๊ฐ๋ฅ | ๋ฃจํ ์๋ฃ ํ ํจ์ ์ข ๋ฃ |
์ฃผ์ ์ฉ๋ | ํน์ ์กฐ๊ฑด ๋ง์กฑ ์ ์ฆ์ ์ข ๋ฃ | ๋ฃจํ ์ ์ฒด์ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํ |
์ฝ๋ ์์ | find_first_even, ์ด์ ์ค๋ต ์ฝ๋ | solution ์์ ๋ ์ฝ๋ |
์ค๋ 2์๊ฐ์ ํฌ์ํด์ ๋ฐฐ์ด ๊ฒ:
return ๋ฌธ์ ์์น๋ ํจ์์ ๋์ ๋ฐฉ์์ ํฐ ์ํฅ์ ๋ฏธ์น๋ฏ๋ก,
์ฝ๋์ ์๋์ ์คํ ํ๋ฆ์ ์ ํํ ์ดํดํ๊ณ ์ ์ ํ ์์น์ ๋ฐฐ์นํ๋ ๊ฒ์ด ์ค์ํ๋ค~!
+) ์ถ๊ฐ๋ก,,,
# ์ด ์ฝ๋๋ ์ ํ๋ ธ์๊น
from collections import Counter
def solution(array, n):
answer = 0
countarr = Counter(array)
maxarr = max(countarr.values())
mode = [k for k,v in countarr.items() if v == maxarr]
"""
์ฝ๋ ๋ถ์:
1.Counter ๊ฐ์ฒด ์์ฑ: countarr = Counter(array)๋ array์ ๊ฐ ์์์ ๋ฑ์ฅ ํ์๋ฅผ ์ธ์ด countarr์ ์ ์ฅํฉ๋๋ค. ์๋ฅผ ๋ค์ด array = [1, 1, 2, 3]์ด๋ฉด countarr = {1: 2, 2: 1, 3: 1}์ด ๋ฉ๋๋ค.
2.์ต๋๊ฐ ์ฐพ๊ธฐ: maxarr = max(countarr.values())๋ countarr์ ์ ์ฅ๋ ๋ฑ์ฅ ํ์ ์ค์์ ๊ฐ์ฅ ํฐ ๊ฐ์ maxarr์ ์ ์ฅํฉ๋๋ค. ์์ ์์์์๋ maxarr = 2๊ฐ ๋ฉ๋๋ค.
3.์ต๋น๊ฐ ์ฐพ๊ธฐ: mode = [k for k, v in countarr.items() if v == maxarr]๋ countarr์์ ๋ฑ์ฅ ํ์๊ฐ maxarr์ ๊ฐ์ ํค(์์)๋ค์ ๋ชจ์ mode ๋ฆฌ์คํธ์ ์ ์ฅํฉ๋๋ค. ์์ ์์์์๋ mode = [1]์ด ๋ฉ๋๋ค. (๋ง์ฝ ์ต๋น๊ฐ์ด ์ฌ๋ฌ ๊ฐ๋ฉด ์ฌ๋ฌ ๊ฐ์ ๊ฐ์ด mode์ ๋ค์ด๊ฐ๊ฒ ๋ฉ๋๋ค.)
4.์กฐ๊ฑด๋ถ ๋ฐํ:
if mode[0] == n:: mode ๋ฆฌ์คํธ์ ์ฒซ ๋ฒ์งธ ์์(์ต๋น๊ฐ ์ค ํ๋)๊ฐ n๊ณผ ๊ฐ์์ง ํ์ธํฉ๋๋ค. ๋ง์ฝ ๊ฐ๋ค๋ฉด maxarr(์ต๋น๊ฐ์ ๋ฑ์ฅ ํ์)์ ๋ฐํํฉ๋๋ค.
else:: ๋ง์ฝ mode ๋ฆฌ์คํธ์ ์ฒซ ๋ฒ์งธ ์์๊ฐ n๊ณผ ๊ฐ์ง ์๋ค๋ฉด answer(์ด๊ธฐ๊ฐ์ด 0)๋ฅผ ๋ฐํํฉ๋๋ค.
"""
์ค๋ต ์ด์ :
- ์ด ์ฝ๋๋ ์ต๋น๊ฐ์ด n๊ณผ ๊ฐ์ ๊ฒฝ์ฐ์๋ง ์ต๋น๊ฐ์ ๋ฑ์ฅ ํ์๋ฅผ ๋ฐํํ๊ณ , ๊ทธ๋ ์ง ์์ ๊ฒฝ์ฐ์๋ ํญ์ 0์ ๋ฐํํฉ๋๋ค.
๋ฌธ์ ์์ ์๊ตฌํ๋ ๊ฒ์ ๋ฐฐ์ด์์ n์ด ๋ช ๋ฒ ๋ฑ์ฅํ๋์ง๋ฅผ ๋ฐํํ๋ ๊ฒ์ด๋ฏ๋ก, ์ฝ๋์ ๋ ผ๋ฆฌ๊ฐ ๋ฌธ์ ์ ์๊ตฌ์ฌํญ๊ณผ ์ผ์นํ์ง ์์ต๋๋ค.
ํต์ฌ ๋ฌธ์ ์ :
- ์ต๋น๊ฐ์๋ง ์ง์ค: ์ฝ๋๋ ๋ฐฐ์ด์์ n์ ๋ฑ์ฅ ํ์๋ฅผ ์ง์ ์ธ์ง ์๊ณ , ์ต๋น๊ฐ๊ณผ n์ ๋น๊ตํ๋ ๋ฐ์๋ง ์ง์คํฉ๋๋ค.
- ์กฐ๊ฑด๋ถ ๋ฐํ ์ค๋ฅ: ์ต๋น๊ฐ์ด n์ด ์๋ ๊ฒฝ์ฐ์๋ ํญ์ 0์ ๋ฐํํ๊ธฐ ๋๋ฌธ์, n์ด ๋ฐฐ์ด์ ์กด์ฌํ๋๋ผ๋
์ต๋น๊ฐ์ด ์๋๋ฉด 0์ ๋ฐํํ๊ฒ ๋ฉ๋๋ค.- ์์ ๋ ์ฝ๋:
from collections import Counter
def solution(array, n):
countarr = Counter(array)
return countarr[n]
์์ ๋ ์ฝ๋ ์ค๋ช :
- Counter ๊ฐ์ฒด ์์ฑ: countarr = Counter(array)๋ ๋์ผํ๊ฒ ๋ฐฐ์ด์ ์์ ๋ฑ์ฅ ํ์๋ฅผ ์ ๋๋ค.
- n์ ๋ฑ์ฅ ํ์ ๋ฐํ: return countarr[n]์ countarr์์ ํค๊ฐ n์ธ ๊ฐ (์ฆ, ๋ฐฐ์ด์์ n์ด ๋ฑ์ฅํ ํ์)์ ์ง์ ๋ฐํํฉ๋๋ค.
ํต์ฌ ์์ ์ฌํญ:
- ์ต๋น๊ฐ์ ์ฐพ๋ ๋ก์ง ๋์ Counter์์ n์ ๋ฑ์ฅ ํ์๋ฅผ ์ง์ ์ฐธ์กฐํ๋๋ก ๋ณ๊ฒฝํ์ต๋๋ค.
- ๋ถํ์ํ ์กฐ๊ฑด๋ฌธ๊ณผ ๋ณ์๋ฅผ ์ ๊ฑฐํ๊ณ ์ฝ๋๋ฅผ ๊ฐ๊ฒฐํ๊ฒ ๋ง๋ค์์ต๋๋ค.
์ ๋ฆฌ:
์ด์ ์ฝ๋๋ ์ต๋น๊ฐ์ ๊ธฐ์ค์ผ๋ก ๊ฒฐ๊ณผ๋ฅผ ํ๋จํ๋ ค๊ณ ํ์ง๋ง, ๋ฌธ์ ์์ ์๊ตฌํ๋ ๊ฒ์ n์ ๋ฑ์ฅ ํ์์์ต๋๋ค.
์์ ๋ ์ฝ๋๋ Counter ๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ์ฌ n์ ๋ฑ์ฅ ํ์๋ฅผ ์ง์ ๊ตฌํ์ฌ ์ ํํ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํฉ๋๋ค.
์ฝ๋ฉ ํ
์คํธ์์๋ ๋ฌธ์ ๋ฅผ ์ ํํ ์ดํดํ๊ณ ์๊ตฌ์ฌํญ์ ๋ง๋ ์ฝ๋๋ฅผ ์์ฑํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค.
์ค๋๋ ํํค์นจ ๋นํด๋ฒ๋ ธ๋ค ๋์ ๋ฌธ์ ์ดํด๋ฅ๋ ฅ~!~!
์ค๋๋ ๊ฐ๋ ๊ธธ์ด ์ฝ์ง์๋ค^^,,,
'[SPARTA] AI 9 (24.11 ~ 25.03) ๐๐ปโโ๏ธ > ๋ฌธ์ ํ์ด ๐ฏ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[250108] ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ฉํ ์คํธ ์ ๋ฌธ ๋ฌธ์ (0) | 2025.01.08 |
---|---|
[250106] ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ฉํ ์คํธ ์ ๋ฌธ ๋ฌธ์ (1) | 2025.01.06 |
[241227] ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ฉํ ์คํธ SQL ๋ฌธ์ (1) | 2024.12.27 |
[241223] ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ฉํ ์คํธ ์ ๋ฌธ ๋ฌธ์ (0) | 2024.12.23 |
[241220] ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ฉํ ์คํธ ์ฝ๋ฉ ๊ธฐ์ด ํธ๋ ์ด๋ ๋ฌธ์ (1) | 2024.12.20 |