<๋ฌธ์ >
twoSumํจ์์ ์ซ์ ๋ฆฌ์คํธ์ 'ํน์ ์'๋ฅผ ์ธ์๋ก ๋๊ธฐ๋ฉด,๋ํด์ 'ํน์ ์'๊ฐ ๋์ค๋ index๋ฅผ ๋ฐฐ์ด์ ๋ด์ returnํด ์ฃผ์ธ์.nums: ์ซ์ ๋ฐฐ์ด
target: ๋ ์๋ฅผ ๋ํด์ ๋์ฌ ์ ์๋ ํฉ๊ณ
return: ๋ ์์ index๋ฅผ ๊ฐ์ง ์ซ์ ๋ฐฐ์ด
์๋ฅผ ๋ค์ด,
nums์ [4, 9, 11, 14]
target์ 13
nums[0] + nums[1] = 4 + 9 = 13 ์ด์ฃ ?
๊ทธ๋ฌ๋ฉด [0, 1]์ด return ๋์ด์ผ ํฉ๋๋ค.
(target์ผ๋ก ๋ณด๋ด๋ ํฉ๊ณ์ ์กฐํฉ์ ๋ฐฐ์ด ์ ์ฒด ์ค์ 2๊ฐ ๋ฐ์ ์๋ค๊ณ ๊ฐ์ ํ๊ฒ ์ต๋๋ค.)
์ฒ์์ ๋ฐ๋ก
๊ฐ ์ธ์๋ฅผ ์๋ก ๋น๊ตํ ์ ์๊ฒ for loop๋ฅผ ์ฐ๊ณ ๊ทธ ์์ ๋ค์ for loop๋ฅผ ๋ฃ์๊ณ ์๊ฐํ๋ค.
def two_sum(nums, target):
for i in nums:
for j in nums:
if i + j == target and i != j:
print(nums.index(i),nums.index(j))
์ฒ์์ ๋ง๋ ์์ธ๋ฐ ์ดํ ๋ํ๋๋ ๊ฒฐ๊ณผ๋
tow_sum([4,9,11,14],18)์ ๊ฒฝ์ฐ
0,3
3,0
์ผ๋ก ์ ๋ง ๋ง๊ทธ๋๋ก ํ๋ํ๋ ๋์
ํ ๊ฒฐ๊ณผ๊ฐ ๋์๋ฒ๋ ธ๋ค ใ
ใ
์ฌ์ง์ด ๋ฆฌ์คํธํํ๋ ์๋๋ค...ใ
ใ
def two_sum(nums, target):
index = 0
for n in range(index,len(nums)):
for i in range(index+1,len(nums)):
if nums[n] + nums[i] == target:
return [n,i]
์ธ๋ฑ์ค๋ฅผ ์ด์ฉํด, range๋ฅผ ์ฌ์ฉํด์ ์ฒ๋ฆฌํ๋ ๋ฒ์ผ๋ก ์ ๊ทผํ๋ค.
index์ range๊ทธ๋ฆฌ๊ณ ๋ณ์๋ฅผ ์ง์ ํ๋ ๋ฒ์ด ์์ง ์ต์์น ์์๋ฐ, ์ ๋ง์ ๋ง ๋ง์ด ์ฐ์ด๋๊ฑฐ ๊ฐ์ ๊ผญ ์ต์ํด์ก์ผ๋ฉด ํ๋ค...
(๊ฐ์ ์ธ๋ฑ์ค๋ฒํธ๋ฅผ ์ฐพ๋๊ฒ๋ณด๋ค, ์ธ๋ฑ์ค๋ฒํธ๋ฅผ ์ด์ฉํด ๊ฐ์ ๋ถ๋ฌ๋ด๋๊ฒ ๋ ํธํ๊ฑธ ์์ง ๋ง์!! ๋งจ๋ ๋ฐ๋๋กํ๋์ค)
def two_sum(nums, target):
index_map = {}
for i in range(len(nums)):
num = nums[i]
pair = target - num
if pair in index_map:
return [index_map[pair], i]
index_map[num] = i
return None
๋์
๋๋ฆฌ๋ฅผ ์ฌ์ฉํ ๋ฐฉ๋ฒ์ด์๋ค..
์ผ๋จ for loops์ ์์์ ์ญ์ range๋ก ์์ pair๋ผ๋ ์๋ก์ด ๋ณ์๋ฅผ ์ฌ์ฉํด ์ฒ๋ฆฌํ๋ ์ ๋ฐํ(?)๋ฐฉ๋ฒ์ด๋ค...
์ฒ์์๋ ๋ญ ์ด๋ ๊ฒ ์ด๋ ค์? ๋ผ๊ณ ์๊ฐํ๋๋ฐ ํ๋ฒ ๋ณด๋ ๋๋ฌด๋ ์๋ฒฝ...๐
๋ญ์ผ๋ฌด์์, ๊ทผ๋ฐ ๋๋ ์ด๋ ๊ฒ ์๊ฐํด๋ณด๊ณ ์ถ๋ค...
<๋ฌธ์ >
reverse ํจ์์ ์ ์์ธ ์ซ์๋ฅผ ์ธ์๋ก ๋ฐ์ต๋๋ค.๊ทธ ์ซ์๋ฅผ ๋ค์ง์ด์ returnํด์ฃผ์ธ์.
x: ์ซ์
return: ๋ค์ง์ด์ง ์ซ์๋ฅผ ๋ฐํ!์๋ฅผ ๋ค์ด,
- x: 1234 -> return: 4321
- x: -1234 ->return: -4321
- x: 1230 ->return: 321
์์์ ๊ฒฝ์ฐ ๊ทธ๋ฅ reverseํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ๋์ง๋ง, ์์์ ๊ฒฝ์ฐ์๋ -๋ฅผ๋ ์ ๋๊ฐ์ ๋ง๋ค์ด์ฃผ๋ฉด ๋์ง ์์๊น?๋ผ๊ณ ์๊ฐํ๋ค.
๊ทธ ํ ์์๋ฅผ ์์๋ก ๋ณํํด์ฃผ๋ ํจ์๋ฅผ ์ฐพ์๋ณด์!๋ก ์ ๊ทผํด๋ณด์๋ค
def reverse(number):
if number == 0:
return 0
else:
if number < 0:
a =int(str(abs(number))[::-1])
return -a
else:
a =int(str(abs(number))[::-1])
return a
1.์์๋ ์์๋์๋ 0์ ๊ฑฐ๊พธ๋กํด๋ 0์ด๋ฏ๋ก ๋จผ์ ์์ฑ์ ํด์ฃผ์๋ค.
2.์์์ ๊ฒฝ์ฐ๋ฅผ ๊ฐ์ ํด์ฃผ์๋ค. ์ซ์๋ฅผ ์ ๋๊ฐ์ผ๋ก ๋ณ๊ฒฝํด์ค๋ค ์ด๊ฑธ ๋ณ๊ฒฝํ ์ ์์๊น? ํ๊ณ ๊ตฌ๊ธ๋ง์ ํด๋ณด๋ [::-1]
๋ผ๋ ๋ฌธ์์ด์ ๋ค์ง์ด์ฃผ๋ ๋งค์๋๋ฅผ ๋ฐ๊ฒฌํ์ฌ ์ด๊ฑธ ์ฌ์ฉํ๊ฒ ๋์๋ค.
return๊ฐ์ ์๋๋๋ก ์์๊ฐ ๋์ด์ผ ํ๋ฏ๋ก -๋ฅผ ๋ถ์ฌ์ฃผ์๋ค.
3.์์๋ ๋ฐ๋ก ๋ค์ง์๋ค ๋ฐ๋ก returnํด์ฃผ์๋ค.
def reverse(number):
string = str(number)
if string[0] == '-':
string = string[::-1]
new_string = string[-1]+string[:-1]
return int(new_string)
string = string[::-1]
return int(string)
์๋? ์ผ๋ฐ์ ์ผ๋ก ์๊ฐํ๋ฉด ์ซ์, ๊ทธ๋ฅ reverseํ๋ฉด ๋ ๊ฑฐ๊ฐ์๋๋ฐ, ์๋๋ผ๊ณ ..? ๋ฌธ์์ด๋ก๋ณ๊ฒฝ->๋ค์ง๊ณ ->๋ค์ ์ซ์ํ์ผ๋ก ๋ณ๊ฒฝ..
์ซ์์ธ ์ํ๋ก ๋ณ๊ฒฝํ๋ ๋ฐฉ๋ฒ์ด ์์๊น? ํ๋ ๋ง์์ ์ข๋ ๊ตฌ๊ธ๋ง ํด๋ณด์๋ค.(์ด๋ ๊ฒ ์ด๋ ต๋ค๋...?)
Algorithm
Input Integer: number
- Initialize variable revs_number = 0
- Loop while number > 0
- Multiply revs_number by 10 and add remainder of number
divide by 10 to revs_number
revs_number = revs_number*10 + number%10;- Divide num by 10
- Return revs_number
์ค์ ์ฌ์ฉ์์๋ ์ฌ๊ธฐ์ ํ์ธ...
์์์ ๊ฒฝ์ฐ, ์์ ๋งํฌ์ฒ๋ผ....ใ
ใ
(๋
ธ๊ฐ๋ค)์๋นํ ๋จผ๊ธธ์ ๋์๊ฐ์ผํ๋ค... ์ฌ์ง์ด ์์์ ๊ฒฝ์ฐ ๋ถ๊ฐ๋ฅํ๊ฑด ์๋์ง๋ง, ์ฝ๋ฉ์ธ์ด์ ๋ฐ๋ผ ๊ทธ ๊ฒฐ๊ณผ๊ฐ์ด ์ ๊ฐ๊ฐ์ผ ๊ฐ๋ฅ์ฑ์ด ์์ด์ ๋ฐฐ์ ํ๋๊ฒ ๋์๊ฒ ๊ฐ๋ค.(์ ํํ๊ฒ์ ์๋์ง๋ง, ๊ฒ์ํด์ ์์๋ณธ ๊ฒฐ๊ณผ 100ํผ์ผํธ ๊ฐ๋ค๋ ๊ฒฐ๋ก ์ ๋์ค์ง ์์.. ์ ์ค๋ช
ํด์ฃผ์ ๋ธ๋ก๊ทธ)
๊ทธ๋ฌ๋.. ๊ทธ๋ฅ ๊ฐ๋จํ ์ซ์๋ฅผ ๋ค์ง๋๊ฑฐ๋ผ๋ฉด.. ๊ทธ๋ฅ ๋ฌธ์ํ์ผ๋ก ์ฒ๋ฆฌํ๋๊ฒ ์ ์ผ ๋น ๋ฅผ๋ฏ..ใ
ใ