1. 특정 합계를 만족하는 두 숫자의 인덱스 리턴

1-1. 문제

two_sum함수에 '숫자 배열'과 '특정 수'를 인자로 넘기면, 더해서 '특정 수'가 나오는 두 요소의 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개 밖에 없다고 가정하겠습니다.

1-2. 풀이

def two_sum(nums, target):
    for i in range(0,len(nums)):
        for j in range(i+1,len(nums)):
            if nums[i] + nums[j] == target:
                return [i, j]

• 배열의 요소 중 2개를 선택한다.

• 선택한 요소가 중복되면 안되기 때문에 중첩 for문에는 인덱스에 1을 더해준다.

• 선택한 두 요소의 합이 target을 만족하면 인덱스를 리턴한다.

🤔

• 인덱스+1을 하면 요소가 중복 안되는 것이 확실한가?
• for문을 중첩하지 않고 사용 가능한 메서드가 있는가?

2. 정수를 뒤집어서 리턴

2-1. 문제

reverse 함수에 정수인 숫자를 인자로 받습니다.
그 숫자를 뒤집어서 return해주세요.

x: 숫자
return: 뒤집어진 숫자를 반환!

예들 들어,

x: 1234
return: 4321

x: -1234
return: -4321

x: 1230
return: 321

2-2. 풀이

def reverse(number):

    str_num = str(number)

    if str_num[0] == "-":
        str_sli = "-" + str_num[-1:0:-1]
    else:
        str_sli = str_num[::-1]

    result = int(str_sli)

    return(result)

• 문자열로 변환해 슬라이스를 활용했다.

• 슬라이스 증가폭을 -1로 설정해 문자열의 마지막 인덱스부터 가져온다.

• 음수가 오는 경우 -를 따로 분리해 나중에 붙여준다.

• 처음엔 마지막 요소부터 빈배열에 넣고 join 메소드로 다시 하나로 합쳤다.

🤔

• -가 있는 음수인 경우에는 어쩔수 없이 if문으로 예외처리를 해야하나?

3. 🤯 중복되지 않은 알파벳으로 이루어진 제일 긴 단어의 길이 반환

3-1. 문제

String 형인 str 인자에서 중복되지 않은 알파벳으로 이루어진 제일 긴 단어의 길이를 반환해주세요.

str: 텍스트
return: 중복되지 않은 알파벳 길이 (숫자 반환)

예를 들어,

str = "abcabcabc"
return 은 3
=> 'abc' 가 제일 길기 때문

str = "aaaaa"
return 은 1
=> 'a' 가 제일 길기 때문


str = "sttrg"
return 은 3
=> 'trg' 가 제일 길기 때문

3-2. 풀이

def get_len_of_str(s):
  arr = []
  count = result = 0

  if s == '':
    return 0

  for str in s:
    if str not in arr:
      arr.append(str)
      count = len(arr)
      if result < count:
        result = count
    else:
      arr = arr[arr.index(str)+1:]
      arr.append(str)
      count = len(arr)

  return result

• 빈배열 arr는 중복되지 않는 알파벳을 담는 용도

• count는 arr 배열의 길이

• result는 count의 최대값

3.3 딕셔너리와 enumerate를 이용한 풀이

def get_len_of_str(s):
	dct = {}
	max_so_far = curr_max = start = 0
    
	for index, i in enumerate(s):
		if i in dct and dct[i] >= start:
			max_so_far = max(max_so_far, curr_max)
			curr_max = index - dct[i]
			start = dct[i] + 1
		else:
			curr_max += 1            
		dct[i] = index
        
	return max(max_so_far, curr_max)

• 딕셔너리로 해싱하고, enumerate로 인덱스와 요소를 순회하는 방법

• enumerate는 시퀀스 자료형의 인덱스와 요소를 함께 열거해서 반환한다.

• dct의 key는 문자열 요소, value는 인덱스

• max_so_far는 가장 긴 단어의 길이

• curr_max는 중복이 발견되면 문자열 길이 저장

• start는 중복된 요소의 인덱스

🤔

4. 정수 인자를 뒤집었을때 같은 모양인지 판단

4-1. 문제

숫자인 num을 인자로 넘겨주면, 뒤집은 모양이 num과 똑같은지 여부를 반환해주세요.

num: 숫자
return: true or false (뒤집은 모양이 num와 똑같은지 여부)

예를 들어,

num = 123
return false 
=> 뒤집은 모양이 321 이기 때문

num = 1221
return true 
=> 뒤집은 모양이 1221 이기 때문

num = -121
return false 
=> 뒤집은 모양이 121- 이기 때문

num = 10
return false 
=> 뒤집은 모양이 01 이기 때문

4-2. 풀이

def same_reverse(num):
    str_num = str(num)

    if str_num == str_num[::-1]:
      return True
    else:
      return False

• 문자열로 변환해서 슬라이스로 뒤집을 수 있다.

• 문자열과 뒤집은 문자열을 비교한다. (-까지 뒤집기 때문에 어렵지 않다.)

🤔

• reverse - list의 요소를 뒤집어 주는 메소드.
  -> 문자열을 list로 바꿔서 reverse한 다음 join으로 붙여줄 수 있다.
  
  
• reversed - 시퀀스 자료형의 요소를 뒤집어 주고 reversed 객체를 반환한다. (내장함수)
  -> 문자열을 reversed한 객체를 join으로 붙여줄 수 있다.

5. 🤯 공통된 시작단어 (prefix) 반환

5-1. 문제

strs은 단어가 담긴 배열입니다.
공통된 시작 단어(prefix)를 반환해주세요.

예를 들어

strs = ['start', 'stair', 'step']
return은 'st'

strs = ['start', 'wework', 'today']
return은 ''

5-2. 풀이

def get_prefix(strs):
    if len(strs) == 0:
        return ''

    empty = ''
    strs = sorted(strs)

    for i in strs[0]: 
        if strs[-1].startswith(empty+i): 
            empty += i 
        else:
            break
    return empty

• 빈 문자열이면 빈 문자열을 리턴한다.

• sorted 내장함수 - 오름차순 정렬된 새로운 리스트를 반환한다.
  -> List용 sort와 다르게 시퀀스 자료형은 모두 가능하다.

• str.startwith() - 문자열의 첫글자를 확인 가능하다.

• 정렬된 상태라면 첫번째 단어와 마지막 단어만 비교해서 겹치는 부분을 반환하면 된다. -> 겹치는 단어는 empty에 계속 담는다.

🤔

• sort - list의 요소를 오름차순 정렬해주는 메소드
  
  
• sorted - 시퀀스 자료형의 요소를 오름차순 정렬해주고 sorted 객체를 반환한다. (내장함수)