๐ฌ ๋ฌธ์ ์ค๋ช
: ์์ฐ์ ๋ค์ง์ด ๋ฐฐ์ด๋ก ๋ง๋ค๊ธฐ
์์ฐ์ n์ ๋ค์ง์ด ๊ฐ ์๋ฆฌ ์ซ์๋ฅผ ์์๋ก ๊ฐ์ง๋ ๋ฐฐ์ด ํํ๋ก ๋ฆฌํดํด์ฃผ์ธ์. ์๋ฅผ๋ค์ด n์ด 12345์ด๋ฉด [5,4,3,2,1]์ ๋ฆฌํดํฉ๋๋ค.
๐ ์ ํ ์ฌํญ
- ์์ฐ์ n์ ๋ค์ง์ด ๊ฐ ์๋ฆฌ ์ซ์๋ฅผ ์์๋ก ๊ฐ์ง๋ ๋ฐฐ์ด ํํ๋ก ๋ฆฌํดํด์ฃผ์ธ์. ์๋ฅผ๋ค์ด n์ด 12345์ด๋ฉด [5,4,3,2,1]์ ๋ฆฌํดํฉ๋๋ค.
๐ก ๋์ ํ์ด
def solution(n):
answer = []
lst = list(str(n))
lst.sort(reverse = True)
answer = list(map(int,lst))
return answer
---- ํ๋ ธ๋๋ฐ ์ ํ๋ ธ๋์ง ๋ชจ๋ฅด๊ฒ ๋ค? ใ ใ --
* ์๊ณ ๊ฐ๋ฉด ์ข์ ๊ฒ
Python Array ์ฉ๋ฒ
Arr[์ฌ๊ธฐ๋ถํฐ : ์ฌ๊ธฐ๊น์ง : ์นธ ๊ฐ๊ฒฉ]
>> arr = range(10)
>> arr
[0,1,2,3,4,5,6,7,8,9]
>> arr[::2] # ์ฒ์๋ถํฐ ๋๊น์ง ๋ ์นธ ๊ฐ๊ฒฉ์ผ๋ก
[0,2,4,6,8]
>> arr[1::2] # index 1 ๋ถํฐ ๋๊น์ง ๋ ์นธ ๊ฐ๊ฒฉ์ผ๋ก
[1,3,5,7,9]
>> arr[::-1] # ์ฒ์๋ถํฐ ๋๊น์ง -1์นธ ๊ฐ๊ฒฉ์ผ๋ก ( == ์ญ์์ผ๋ก)
[9,8,7,6,5,4,3,2,1,0]
>> arr[::-2] # ์ฒ์๋ถํฐ ๋๊น์ง -2์นธ ๊ฐ๊ฒฉ์ผ๋ก ( == ์ญ์, ๋ ์นธ ๊ฐ๊ฒฉ์ผ๋ก)
[9,7,5,3,1]
>> arr[3::-1] # index 3 ๋ถํฐ ๋๊น์ง -1์นธ ๊ฐ๊ฒฉ์ผ๋ก ( == ์ญ์์ผ๋ก)
[3,2,1,0]
>> arr[1:6:2] # index 1 ๋ถํฐ index 6 ๊น์ง ๋ ์นธ ๊ฐ๊ฒฉ์ผ๋ก
[1,3,5]
* map ํจ์
ํ์ด์ฌ์ ๋ด์ฅ ํจ์์ธ map()๋ ์ฌ๋ฌ ๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ํ ๋ฒ์ ๋ค๋ฅธ ํํ๋ก ๋ณํํ๊ธฐ ์ํด์ ์ฌ์ฉ๋ฉ๋๋ค. ๋ฐ๋ผ์, ์ฌ๋ฌ ๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ๋ด๊ณ ์๋ list๋ tuple์ ๋์์ผ๋ก ์ฃผ๋ก ์ฌ์ฉํ๋ ํจ์์ ๋๋ค.
์ฌ์ฉ ๋ฐฉ๋ฒ์ ๋งค์ฐ ๊ฐ๋จํ๋ฐ์… ๊ธฐ๋ณธ ๋ฌธ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
map(๋ณํ ํจ์, ์ํ ๊ฐ๋ฅํ ๋ฐ์ดํฐ)
map() ํจ์๋ ๋๋ฒ์งธ ์ธ์๋ก ๋์ด์จ ๋ฐ์ดํฐ๊ฐ ๋ด๊ณ ์๋ ๋ชจ๋ ๋ฐ์ดํฐ์ ๋ณํ ํจ์๋ฅผ ์ ์ฉํ์ฌ ๋ค๋ฅธ ํํ์ ๋ฐ์ดํฐ๋ฅผ ๋ฐํํฉ๋๋ค.
๐ก ๋ค๋ฅธ ํด์ค
def solution(n):
answer = []
reverseN = list(str(n))[::-1]
answer = list(map(int,reverseN))
return answer
๐๐ป ๋ฌธ์ ๋ฐ๋ก๊ฐ๊ธฐ
๐ฌ ๋ฌธ์ ์ค๋ช
: ํธ๋ํฐ ๋ฒํธ ๊ฐ๋ฆฌ๊ธฐ
ํ๋ก๊ทธ๋๋จธ์ค ๋ชจ๋ฐ์ผ์ ๊ฐ์ธ์ ๋ณด ๋ณดํธ๋ฅผ ์ํด ๊ณ ์ง์๋ฅผ ๋ณด๋ผ ๋ ๊ณ ๊ฐ๋ค์ ์ ํ๋ฒํธ์ ์ผ๋ถ๋ฅผ ๊ฐ๋ฆฝ๋๋ค.
์ ํ๋ฒํธ๊ฐ ๋ฌธ์์ด phone_number๋ก ์ฃผ์ด์ก์ ๋, ์ ํ๋ฒํธ์ ๋ท 4์๋ฆฌ๋ฅผ ์ ์ธํ ๋๋จธ์ง ์ซ์๋ฅผ ์ ๋ถ *์ผ๋ก ๊ฐ๋ฆฐ ๋ฌธ์์ด์ ๋ฆฌํดํ๋ ํจ์, solution์ ์์ฑํด์ฃผ์ธ์.
๐ ์ ํ ์ฌํญ
- s๋ ๊ธธ์ด 4 ์ด์, 20์ดํ์ธ ๋ฌธ์์ด์ ๋๋ค.
๐ก ๋์ ํ์ด
def solution(phone_number):
answer = ''
num = str(phone_number)
answer = '*' * len(num[:-4]) + num[-4:]
return answer
string์ผ๋ก ๊ผญ ์๋ฐ๊ฟ๋ ๋๋๊ตฌ๋..
len์ ๊ตฌํ ๋, ๊ผญ ์ฌ๊ธฐ๋ถํฐ ์ฌ๊ธฐ๊น์ง ์ซ์ ์ธ๊ธฐ๊ฐ ์๋๋ผ, ๊ทธ๋ฅ ๋ท ์๋ฆฌ 4๊ฐ ๋นผ๋ ๋๋๊ฑด๋ฐ ์ด ๊ฐ๋จํ๊ฒ ์ ์๊ฐ์ด ์๋ฌ์๊น
๊ทธ๋๋ ์ฒ์๋ณด๋จ ์๊ฐ์ด ๋จ์ถ๋๊ณ ์๋ ๊ฒ ๊ฐ์ ๊ธฐ๋ถ์ด ์ข๋ค.
๐ก ๋ค๋ฅธ ํด์ค
def hide_numbers(s):
return "*"*(len(s)-4) + s[-4:]
๐๐ป ๋ฌธ์ ๋ฐ๋ก๊ฐ๊ธฐ
๐ฌ ๋ฌธ์ ์ค๋ช
: K๋ฒ์งธ์
๋ฐฐ์ด array์ i๋ฒ์งธ ์ซ์๋ถํฐ j๋ฒ์งธ ์ซ์๊น์ง ์๋ฅด๊ณ ์ ๋ ฌํ์ ๋, k๋ฒ์งธ์ ์๋ ์๋ฅผ ๊ตฌํ๋ ค ํฉ๋๋ค.
์๋ฅผ ๋ค์ด array๊ฐ [1, 5, 2, 6, 3, 7, 4], i = 2, j = 5, k = 3์ด๋ผ๋ฉด
array์ 2๋ฒ์งธ๋ถํฐ 5๋ฒ์งธ๊น์ง ์๋ฅด๋ฉด [5, 2, 6, 3]์
๋๋ค.
1์์ ๋์จ ๋ฐฐ์ด์ ์ ๋ ฌํ๋ฉด [2, 3, 5, 6]์
๋๋ค.
2์์ ๋์จ ๋ฐฐ์ด์ 3๋ฒ์งธ ์ซ์๋ 5์
๋๋ค.
๋ฐฐ์ด array, [i, j, k]๋ฅผ ์์๋ก ๊ฐ์ง 2์ฐจ์ ๋ฐฐ์ด commands๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, commands์ ๋ชจ๋ ์์์ ๋ํด ์์ ์ค๋ช
ํ ์ฐ์ฐ์ ์ ์ฉํ์ ๋ ๋์จ ๊ฒฐ๊ณผ๋ฅผ ๋ฐฐ์ด์ ๋ด์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
๐ ์ ํ ์ฌํญ
- array์ ๊ธธ์ด๋ 1 ์ด์ 100 ์ดํ์ ๋๋ค.
- array์ ๊ฐ ์์๋ 1 ์ด์ 100 ์ดํ์ ๋๋ค.
- commands์ ๊ธธ์ด๋ 1 ์ด์ 50 ์ดํ์ ๋๋ค.
- commands์ ๊ฐ ์์๋ ๊ธธ์ด๊ฐ 3์ ๋๋ค.
๐ก ๋์ ํ์ด
def solution(array, commands):
answer = []
#1. commands์ ์๋ command ์ถ์ถ
for command in commands:
#2. ๋ฌธ์ ์ฌ๋ผ์ด์ฑ
new_array = array[ command[0] -1 : command[1] ]
#3. ์ ๋ ฌ
new_array.sort()
#4. ์ซ์ ์ถ์ถ
number = new_array[command[2]-1]
answer.append(number)
return answer
๐ก ๋ค๋ฅธ ํด์ค
def solution(array, commands):
answer = []
for command in commands:
i,j,k = command
answer.append(list(sorted(array[i-1:j]))[k-1])
return answer
commands๊ฐ ์ธ ์ซ์๋ก ๊ตฌ์ฑ์ด ๋์ด์๋ค๋ฉด,
์ด๋ ๊ฒ i, j, k ๋ก ๋ฐ๋ก ๋ฐ์ ์ ์๊ตฌ๋ญ.... ๋ ์ ๊ธฐ..
ํ์ด์ฌ์ ์๋ฉด ์์๋ก ์ ๋ง ์ธ๊ฐ์ ์ธ์ด๋ฅผ ๋ฎ์์๋ค๋ ์๊ฐ์ ํ๋ค.
๊ฐ์ ๋ง๋ ์ฐ๋ ๋ฌธ์ฅ์ ๋ฐ๋ผ ๊ทธ ๋ง์ ๋ง์ด ๋ฌ๋ผ์ง๋ฏ, ์ฝ๋๋ ๊ทธ ๋ง์ด ์๋ค,,
๋ฌผ๋ก ๋๋ ์ง๊ธ ๋น ๋ฅด๊ณ ํจ์จ์ ์ธ ์ฝ๋๋ฅผ ๋ง์ถ๋ ๊ฒ๋ณด๋ค ์ ์งํ ์ฝ๋๋ฅผ ๋ง์ถฐ๊ฐ๋๋ฐ ๋ ํฐ ํฌ์ด์ ๋๋ผ๊ธด ํ์ง๋ง.
๐๐ป ๋ฌธ์ ๋ฐ๋ก๊ฐ๊ธฐ
๐ฌ ๋ฌธ์ ์ค๋ช
: ํ์ค๋ ์
์์ ์ ์ x๊ฐ ํ์ค๋ ์์ด๋ ค๋ฉด x์ ์๋ฆฟ์์ ํฉ์ผ๋ก x๊ฐ ๋๋์ด์ ธ์ผ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด 18์ ์๋ฆฟ์ ํฉ์ 1+8=9์ด๊ณ , 18์ 9๋ก ๋๋์ด ๋จ์ด์ง๋ฏ๋ก 18์ ํ์ค๋ ์์ ๋๋ค. ์์ฐ์ x๋ฅผ ์ ๋ ฅ๋ฐ์ x๊ฐ ํ์ค๋ ์์ธ์ง ์๋์ง ๊ฒ์ฌํ๋ ํจ์, solution์ ์์ฑํด์ฃผ์ธ์.
๐ ์ ํ ์ฌํญ
- x๋ 1 ์ด์, 10000 ์ดํ์ธ ์ ์์ ๋๋ค.
๐ก ๋์ ํ์ด
def solution(x):
divisor = 0
for i in range (0, len(str(x))):
divisor += int(str(x)[i])
if (x % divisor == 0):
return True
else:
return False
1. divisor๋ฅผ ๋จผ์ ๊ตฌํ๋ค.
x๋ฅผ ์ฐ์ string์ผ๋ก ๋ณํํด์ ๊ฐ ์ซ์๋ฅผ ๋ํ ๊ฐ์ divisor ๊ฐ์ ๊ตฌํจ
2. ๋๋จธ์ง๊ฐ 0์ธ์ง ํ์ธํ๋ค
์ด๊ฑฐ ๋ง๊ณ 10์์๋ฆฌ ๋๋์ ์ผ๋ก๋ ํ ์ ์์ ๊ฒ ๊ฐ๋ค๋ ์๊ฐ์ด ๋ค์ด, ๋ ๋ฒ์งธ ํ์ด์ ๋์ ! ํ์๋ค๊ฐ ์ ์๋๋์ง ์ดํด๊ฐ ์๋๋ ์ํฉ์ ์ง๋ฉด...์์ผ๊น,,,??? ๋ ผ๋ฆฌ์ ์ผ๋ก๋ ๋ง๋๋ฐ..?
โ ํ๋ฆฐ ์ฝ๋ โ
def solution(x):
divisor = 0
# x ๋ ๋ช์๋ฆฌ ์?
for i in range(0, len(str(x))):
if (10**(len(str(x))-1-i))>=1:
quotient = x // 10**(len(str(x))-1-i)
x = x - (quotient * 10**(len(str(x))-1-i))
elif (10**(len(str(x))-1-i))<1:
quotient = x
divisor += quotient
if (x % divisor == 0):
return True
else:
return False
๐ก ๋ค๋ฅธ ํด์ค
def Harshad(n):
# n์ ํ์ค๋ ์ ์ธ๊ฐ์?
return n % sum([int(c) for c in str(n)]) == 0
์ ๋ฐ์์ผ๋ก ์ฐ๋๊ฒ๋ ๊ฐ๋ฅํ๊ตฌ๋.. c๋ ๋ฐ๋ก ๋ช ์ ์ํด์ค๋ ๋๋๊ฑด๊ฐ..?
์ ๊ธฐํ๋ค
๐๐ป ๋ฌธ์ ๋ฐ๋ก๊ฐ๊ธฐ
'Coding > Code in the Morning' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
211230_Code in the morning(์์์ฐพ๊ธฐ, ์๋ผํ ์คํ ๋ค์ค์ ์ฒด) (0) | 2021.12.30 |
---|---|
211229_Code in the morning (0) | 2021.12.29 |
211227_Code in the morning (0) | 2021.12.27 |
211224_Code in the morning (0) | 2021.12.24 |
211222_Code in the morning (0) | 2021.12.23 |