๐ฌ ๋ฌธ์ ์ค๋ช
: ๋๋์ด ๋จ์ด์ง๋ ์ซ์ ๋ฐฐ์ด
array์ ๊ฐ element ์ค divisor๋ก ๋๋์ด ๋จ์ด์ง๋ ๊ฐ์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ ๋ฐฐ์ด์ ๋ฐํํ๋ ํจ์, solution์ ์์ฑํด์ฃผ์ธ์.
divisor๋ก ๋๋์ด ๋จ์ด์ง๋ element๊ฐ ํ๋๋ ์๋ค๋ฉด ๋ฐฐ์ด์ -1์ ๋ด์ ๋ฐํํ์ธ์.
๐ ์ ํ ์ฌํญ
- arr์ ์์ฐ์๋ฅผ ๋ด์ ๋ฐฐ์ด์ ๋๋ค.
- ์ ์ i, j์ ๋ํด i ≠ j ์ด๋ฉด arr[i] ≠ arr[j] ์ ๋๋ค.
- divisor๋ ์์ฐ์์ ๋๋ค.
- array๋ ๊ธธ์ด 1 ์ด์์ธ ๋ฐฐ์ด์ ๋๋ค.
๐ก ๋์ ํ์ด
def solution(arr, divisor):
answer = []
for a in arr:
if ((a % divisor)==0):
answer.append(a)
if len(answer) == 0:
answer.append(-1)
else:
answer.sort()
return answer
* Array์ ๊ณต์งํฉ์ ํํํ ๋์๋ len์ด 0์ด๋ ๊ฒ์ ์ฌ์ฉํ๋ค.
๐๐ป ๋ฌธ์ ๋ฐ๋ก๊ฐ๊ธฐ
๐ฌ ๋ฌธ์ ์ค๋ช : ๋ชจ์๊ณ ์ฌ
์ํฌ์๋ ์ํ์ ํฌ๊ธฐํ ์ฌ๋์ ์ค๋ง์
๋๋ค. ์ํฌ์ ์ผ์ธ๋ฐฉ์ ๋ชจ์๊ณ ์ฌ์ ์ํ ๋ฌธ์ ๋ฅผ ์ ๋ถ ์ฐ์ผ๋ ค ํฉ๋๋ค. ์ํฌ์๋ 1๋ฒ ๋ฌธ์ ๋ถํฐ ๋ง์ง๋ง ๋ฌธ์ ๊น์ง ๋ค์๊ณผ ๊ฐ์ด ์ฐ์ต๋๋ค.
1๋ฒ ์ํฌ์๊ฐ ์ฐ๋ ๋ฐฉ์: 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, ...
2๋ฒ ์ํฌ์๊ฐ ์ฐ๋ ๋ฐฉ์: 2, 1, 2, 3, 2, 4, 2, 5, 2, 1, 2, 3, 2, 4, 2, 5, ...
3๋ฒ ์ํฌ์๊ฐ ์ฐ๋ ๋ฐฉ์: 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, ...
1๋ฒ ๋ฌธ์ ๋ถํฐ ๋ง์ง๋ง ๋ฌธ์ ๊น์ง์ ์ ๋ต์ด ์์๋๋ก ๋ค์ ๋ฐฐ์ด answers๊ฐ ์ฃผ์ด์ก์ ๋, ๊ฐ์ฅ ๋ง์ ๋ฌธ์ ๋ฅผ ๋งํ ์ฌ๋์ด ๋๊ตฌ์ธ์ง ๋ฐฐ์ด์ ๋ด์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
๐ ์ ํ ์ฌํญ
- ์ํ์ ์ต๋ 10,000 ๋ฌธ์ ๋ก ๊ตฌ์ฑ๋์ด์์ต๋๋ค.
- ๋ฌธ์ ์ ์ ๋ต์ 1, 2, 3, 4, 5์ค ํ๋์ ๋๋ค.
- ๊ฐ์ฅ ๋์ ์ ์๋ฅผ ๋ฐ์ ์ฌ๋์ด ์ฌ๋ฟ์ผ ๊ฒฝ์ฐ, returnํ๋ ๊ฐ์ ์ค๋ฆ์ฐจ์ ์ ๋ ฌํด์ฃผ์ธ์.
๐ก ๋์ ํ์ด
def solution(answers):
answer = []
# ์ ๋ต ์ฌ์ดํด
a1 = [1,2,3,4,5] #5๊ฐ ๋ฐ๋ณต
a2 = [2,1,2,3,2,4,2,5] #8๊ฐ ๋ฐ๋ณต
a3 = [3,3,1,1,2,2,4,4,5,5] #10๊ฐ ๋ฐ๋ณต
score1 = 0
score2 = 0
score3 = 0
#๋ฌธ์ ๋ฅผ ๋ง์ท๋์ง ํ์ธ, ๋ง์ท์ ๋ ์ ์ +1
for i in range (0,len(answers)):
b1 = i%5
b2 = i%8
b3 = i%10
# i๋ฒ์งธ ๋ฌธํญ์ ์ฐ์ ๋ต
if a1[b1] == answers[i]:
score1 += 1
if a2[b2] == answers[i]:
score2 += 1
if a3[b3] == answers[i]:
score3 += 1
winner = max(score1, score2, score3)
if winner == score1:
answer.append(1)
if winner == score2:
answer.append(2)
if winner == score3:
answer.append(3)
return answer
๐๐ป ๋ฌธ์ ๋ฐ๋ก๊ฐ๊ธฐ
๐ฌ ๋ฌธ์ ์ค๋ช
: ์์ฃผํ์ง ๋ชปํ ์ ์
์๋ง์ ๋ง๋ผํค ์ ์๋ค์ด ๋ง๋ผํค์ ์ฐธ์ฌํ์์ต๋๋ค. ๋จ ํ ๋ช
์ ์ ์๋ฅผ ์ ์ธํ๊ณ ๋ ๋ชจ๋ ์ ์๊ฐ ๋ง๋ผํค์ ์์ฃผํ์์ต๋๋ค.
๋ง๋ผํค์ ์ฐธ์ฌํ ์ ์๋ค์ ์ด๋ฆ์ด ๋ด๊ธด ๋ฐฐ์ด participant์ ์์ฃผํ ์ ์๋ค์ ์ด๋ฆ์ด ๋ด๊ธด ๋ฐฐ์ด completion์ด ์ฃผ์ด์ง ๋, ์์ฃผํ์ง ๋ชปํ ์ ์์ ์ด๋ฆ์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
๐ ์ ํ ์ฌํญ
- ๋ง๋ผํค ๊ฒฝ๊ธฐ์ ์ฐธ์ฌํ ์ ์์ ์๋ 1๋ช ์ด์ 100,000๋ช ์ดํ์ ๋๋ค.
- completion์ ๊ธธ์ด๋ participant์ ๊ธธ์ด๋ณด๋ค 1 ์์ต๋๋ค.
- ์ฐธ๊ฐ์์ ์ด๋ฆ์ 1๊ฐ ์ด์ 20๊ฐ ์ดํ์ ์ํ๋ฒณ ์๋ฌธ์๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค.
- ์ฐธ๊ฐ์ ์ค์๋ ๋๋ช ์ด์ธ์ด ์์ ์ ์์ต๋๋ค.
๐ก ๋์ ํ์ด
def solution(participant, completion):
answer = ''
for c in completion:
participant.remove(c)
participant = ''.join(participant)
return participant
์๊ฐ ์ด๊ณผ ^-ใ
* 2์คํฌ๋ฌธ์ผ๋ก ํ์๋๋ ํจ์จ์ฑ์์ ์ ๋ถ ์คํจ ํ์๋ค. ์ด๋ ์ ํ์ฌํญ์ ๊ฑธ๋ฆฌ๊ธฐ ๋๋ฌธ์ด๋ค. 2์คํฌ๋ฌธ์ ์๊ฐ๋ณต์ก๋ N^2 ์ด๋ค. ์ ํ์ฌํญ์ ์ฐธ์ฌํ ์ ์๋ 1๋ช
์ด์ 10๋ง๋ช
์ดํ์ธ๋ฐ 10๋ง์ N์ ๋์
ํ๋ฉด 100์ต์ด ๋๋ค. 100์ต์ด๋ฉด ๋ฌด์กฐ๊ฑด ์๊ฐ ์ด๊ณผ๋ก ํ
์คํธ์ ํต๊ณผํ์ง ๋ชปํ๋ค๊ณ ๋ณด๋ฉด ๋๋ค. ๋ง์ง๋
ธ์ ์ 1์ต์ด๋ผ ์๊ฐํด์ผ ํ๋ค.
* sort๋ฅผ ์ด์ฉํ์ฌ ํ์๋ค. sort๋ ์๊ฐ๋ณต์ก๋๋ก nlogn์ด๋ค. ๊ทธ๋ฆฌ๊ณ for๋ฌธ ํ๋๊ฐ ์๋ for๋ฌธ์ ์๊ฐ ๋ณต์ก๋ n. ๊ทธ๋์ ๋น O๋ก ๋ดค์๋ ์ด ์๊ฐ ๋ณต์ก๋๋ nlogn์ด ๋๋ค. n์ 10๋ง์ ๋์ ํด๋ณด๋ฉด 50๋ง์ด๋ค. ์ถฉ๋ถํ ์๊ฐํจ์จ์ฑ์์ ํต๊ณผ ํ ์ ์๋ ๊ฐ์ด๋ค.
* ์ด ๋ฌธ์ ๋ ํด์๋ก ํ์ด์ผ ํ๋ค๊ณ ํจ. ํด์๋ ๋์ค์ ๋ฐฐ์์ ํ์ด๋ณด๋๊ฑธ๋ก
--------
ํ์ด์ฌ์์ ๊ถ์ฅํ์ง ์๋ ํจํด์
๋๋ค.
>>> s = [1, 3, 5]
>>> for i in range(len(s)):
... print(s[i])
...
1
3
5
- ํ์ด์ฌ์์ ๊ถ์ฅํ๋ ํจํด
>>> for v in s:
... print(v)
...
- ๋ฆฌ์คํธ.remove(๊ฐ)
์ด ๋ฐฉ๋ฒ์ removeํจ์์ ๊ฐ์ ๋๊ฒจ์ฃผ๋ฉด ๋ฆฌ์คํธ์์ ๊ฐ์ ๊ฐ์ ๊ฐ์ง๋ ์์๋ฅผ ์ง์์ค๋๋ค. ํ์ง๋ง ๋ชจ๋ ๊ฐ๋ค์ ์ง์์ฃผ์ง๋ ์๊ณ ๊ฐ์ฅ ๋จผ์ ๋ฐ๊ฒฌ๋ ์์๋ฅผ ์ง์์ค๋๋ค.
๐ก ๋ค๋ฅธ ํด์ค
def solution(participant, completion):
answer = ''
participant.sort()
completion.sort()
for i in range (len(completion)):
if participant[i] != completion[i]:
return participant[i]
return participant[-1]
1. ์ฐ์ ์ ๋ ฌ์ ํ ํ
2. ๊ฐ ์ธ๋ฑ์ค์ ์์นํ๋ ๊ฐ์ด ์ผ์นํ๋์ง ํ์ธํ ํ, ๋ถ์ผ์น ์ ํด๋น ๊ฐ์ ๋ฆฌํด
3. ๋ง์ง๋ง ๋ฆฌํด๋ฌธ์, completion๊ณผ participant ๋ง์ง๋ง๊น์ง ๋น๊ตํด๋ ๊ฐ์ด ๋ชจ๋ ๊ฐ์๋ค๋ฉด ์ ์ผ ๋ง์ง๋ง ์ ๋ ฌ์ ์ฐธ๊ฐ์๊ฐ ์์ฃผ๋ชปํ๋ค๋ ์๋ฏธ๊ฐ ๋๋ฏ๋ก, ์ ์ผ ๋ ์์๋ฅผ ๋ฆฌํดํด์ฃผ๋ ๊ฒ.
* ๋๋ ๋น์ฐํ particpant ๊ฐ์๋ก for ๋ฌธ์ ๋๋ ค์ผ ํ๋ค๊ณ ์๊ฐํ๋๋ฐ, ๊ทธ๋ ๊ฒ๋๋ฉด completion์ ์ธ๋ฑ์ค๋ณด๋ค ์ซ์๊ฐ ์ผ์ ธ์ ์๋ฌ๊ฐ ๋จ๋๋ผ๋!
์ถ์ฒ: https://deftkang.tistory.com/164 [deftkang์ IT ๋ธ๋ก๊ทธ]
๐๐ป ๋ฌธ์ ๋ฐ๋ก๊ฐ๊ธฐ
๐ฌ ๋ฌธ์ ์ค๋ช
: 2016๋
2016๋
1์ 1์ผ์ ๊ธ์์ผ์
๋๋ค. 2016๋
a์ b์ผ์ ๋ฌด์จ ์์ผ์ผ๊น์? ๋ ์ a ,b๋ฅผ ์
๋ ฅ๋ฐ์ 2016๋
a์ b์ผ์ด ๋ฌด์จ ์์ผ์ธ์ง ๋ฆฌํดํ๋ ํจ์, solution์ ์์ฑํ์ธ์. ์์ผ์ ์ด๋ฆ์ ์ผ์์ผ๋ถํฐ ํ ์์ผ๊น์ง ๊ฐ๊ฐ SUN,MON,TUE,WED,THU,FRI,SAT ์
๋๋ค. ์๋ฅผ ๋ค์ด a=5, b=24๋ผ๋ฉด 5์ 24์ผ์ ํ์์ผ์ด๋ฏ๋ก ๋ฌธ์์ด "TUE"๋ฅผ ๋ฐํํ์ธ์.
๐ ์ ํ ์ฌํญ
- 2016๋ ์ ์ค๋ ์ ๋๋ค.
- 2016๋ a์ b์ผ์ ์ค์ ๋ก ์๋ ๋ ์ ๋๋ค. (13์ 26์ผ์ด๋ 2์ 45์ผ๊ฐ์ ๋ ์ง๋ ์ฃผ์ด์ง์ง ์์ต๋๋ค)
๐ก ๋์ ํ์ด
def solution(a, b):
if (a == 1 or a == 4 or a == 7):
index = 4
elif (a == 3 or a == 11):
index = 1
elif (a == 5):
index = 6
elif (a == 6):
index = 2
elif (a == 9 or a == 12):
index = 3
elif a == 10:
index = 5
day_temp = index + b
if day_temp%7 == 1:
result = 'MON'
elif day_temp%7 == 2:
result = 'TUE'
elif day_temp%7 == 3:
result = 'WED'
elif day_temp%7 == 4:
result = 'THU'
elif day_temp%7 == 5:
result = 'FRI'
elif day_temp%7 == 6:
result = 'SAT'
elif day_temp%7 == 0:
result = 'SUN'
return result
์๋ณ๋ก ๊ณ ์ ๊ฐ์ ์ฃผ๊ณ ,
ํด๋น ๊ณ ์ ๊ฐ + ๋ ์ง ํด์ ๋๋จธ์ง๋ก ์์ผ์ ๊ตฌํ๋๋ฐ, ๋ ๋ฐํ์ ์๋ฌ๊ฐ ๋ฌ๋ค....
* python or ๊ตฌ๋ฌธ์ ์ธ ๋,
a == 1 or 2 or 3 ์ด๋ ๊ฒ ์ฐ๋ฉด X
a == 1 or a == 2 or a == 3 ์ด๋ฐ์์ผ๋ก ์จ์ผ O
๐ก ๋ค๋ฅธ ํด์ค
def solution(a, b):
months = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
days = ['THU', 'FRI', 'SAT', 'SUN', 'MON', 'TUE', 'WED']
return days[(sum(months[:a-1])+b)%7]
๋ฐฐ์ด์ ์์ฒญ ๋๋ํ๊ฒ ํ์ฉํ๋ค.
๐๐ป ๋ฌธ์ ๋ฐ๋ก๊ฐ๊ธฐ
'Coding > Code in the Morning' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
220105_Code in the morning (0) | 2022.01.05 |
---|---|
211230_Code in the morning(์์์ฐพ๊ธฐ, ์๋ผํ ์คํ ๋ค์ค์ ์ฒด) (0) | 2021.12.30 |
211228_Code in the morning (0) | 2021.12.28 |
211227_Code in the morning (0) | 2021.12.27 |
211224_Code in the morning (0) | 2021.12.24 |