초이의 끄적끄적

프로그래머스 2021 KAKAO BLIND RECRUITMENT

# 신규 아이디 추천

• Point. 단계별로 차근차근 짜기
• 실패1 ) 테케 3,4,5,11,15 실패 -> step4에서 if-else로 작성해서 접두어 접미어 둘 중 하나만 적용됨 -> if, if로 변경

def solution(new_id):
    # 1
    str1 = new_id.lower()
    
    # 2
    str2 = ''
    for i in str1:
        if i.isalnum():
            str2+=i
        else:
            if i in ('-','_','.'):
                str2+=i
    
    # 3
    str3 = ''
    m_count = 0
    for i in str2:
        if i == '.':
            m_count+=1
            if m_count == 1:
                str3+=i
        else:
            str3+=i
            m_count=0
            
    # 4
    if str3.startswith('.'):
        str3 = str3[1:]
    if str3.endswith('.'):
        str3 = str3[:-1]
    
    # 5
    if len(str3)==0:
        str3 += "a"
    
    # 6
    if len(str3) >= 16:
        str3 = str3[:15]
        if str3[-1] == '.':
            str3 = str3[:-1]
    
    # 7
    if len(str3) < 3:
        c = 3-len(str3)
        str3 = str3 + str3[-1]*c

    return str3

프로그래머스 2020 카카오 인턴십

# 키패드 누르기

• Point. 키패드의 좌표를 딕셔너리에 저장해 거리를 구할 수 있도록 한다.

1. 왼손(*)과 오른손(#) 초기값 설정
2. 숫자 1,4,7 의 경우, 왼손 & 왼손 위치 저장
3. 숫자 3,6,9 의 경우, 오른손 & 오른손 위치 저장
4. 숫자 2,5,8,0 의 경우
   1. 현재 위치와 왼손, 오른손간의 거리 구하기
   2. 오른손이 가까우면 오른손 & 오른손 위치 저장
   3. 왼손이 가까우면 왼손 & 왼손 위치 저장
   4. 위치가 같으면 hand에서 왼손잡이와 오른손잡이를 확인해
      1. 왼손잡이면 왼손 & 왼손 위치 저장
      2. 오른손잡이면 오른손 & 오른손 위치 저장

def solution(numbers, hand):
    answer = ''
    l_x,l_y = (3,0)
    r_x,r_y = (3,2)
    dic = {1 : (0,0),
          2 : (0,1),
          3: (0,2),
          4 : (1,0),
          5 : (1,1),
          6 : (1,2),
          7 : (2,0),
          8: (2,1),
          9 : (2,2),
          0 : (3,1)}
    
    for i in numbers:
        if i in [1,4,7]:
            answer+="L"
            l_x,l_y = dic[i]
        elif i in [3,6,9]:
            answer +="R"
            r_x,r_y = dic[i]
        else:
            c_x,c_y = dic[i]
            l = abs(c_x - l_x) + abs(c_y - l_y)
            r = abs(c_x - r_x) + abs(c_y - r_y)
            
            if l>r:
                answer += "R"
                r_x,r_y = c_x,c_y
            elif l<r:
                answer += "L"
                l_x,l_y = c_x,c_y
            else:
                if hand == "right":
                    answer += "R"
                    r_x,r_y = c_x,c_y
                else:
                    answer += "L"
                    l_x,l_y = c_x,c_y
            
    return answer

프로그래머스 - 탐욕법(Greedy)

# 큰 수 만들기 (Level 2)

• Point. 앞자리가 높은 수가 되게 뽑으면, 무조건 높은 숫자가 된다 (참고)

1. 스택을 생성한다
2. number을 순회한다
   • 스택에 원소가 존재하고 마지막 원소가 순회 수보다 작고 k가 0보다 크다면
     • 마지막 원소를 빼고 k를 1줄인다
   • 스택에 순회 수를 추가한다
3. k가 0보다 크면 (ex) 앞 원소가 추가할 원소보다 커서 k 숫자가 안작아질 때)
   • k개수를 뺀 나머지를 스택에 저장한다
4. 스택을 이어붙여 하나의 문자열로 만든다

def solution(number, k):
    stack = []

    for num in number:
        while len(stack)>0 and stack[-1] < num and k > 0:
            stack.pop()
            k -= 1
        stack.append(num)
    
    if k>0:
        stack = stack[:-k]

    return ''.join(stack)

🍤🍔 와사비 새우버거로 유명한 제스티살룬 🍤🍔

주말 웨이팅 3시간을 했다는 친구 말을 듣고

평일에 도전해보았습니다 👍

※ 월요일 휴무입니다 ※

( 1시쯤 도착해서 웨이팅 입력했는데 제 앞에 20팀... 예상시간 60분

실제로는 한시간 반 기다려서 2시 반쯤 들어갔어요 )

포장은 계단 중앙에 있는 태블릿에 입력하면 됩니다

날씨가 좋으면 포장해서 서울숲에서 먹는것도 좋을 것 같아요 👍

메뉴판은 아래와 같습니다

저는 제스티 갈릭 더블, 와사비 쉬림프, 콘샐러드, 감자튀김은 갈릭치즈를 주문했습니다

주문은 계산대에서 하면 번호표를 주십니다

한 시간 반 웨이팅을 한 결과물....

미친 비쥬얼.... 츄륩

와.... 이 단면을 보십쇼......

탱글탱글한 새우랑 와사비소스의 조합이라니....

웨이팅 시간이 아깝지 않은 맛입니다 👍

중간중간 양파절임도 올려먹으면 맛있어요

다음은 제스티 갈릭 버거

또 한국인은 갈릭 못참즤

저는 일행과 반씩 나눠먹었는데 둘 다 너무 맛있었어요 👍

갈릭 치즈 소스 너무 맛있어요

웨이팅만 아니면 진짜 매일 먹고싶은데

다음에는 포장해서 서울숲에서 먹어야겠어요

맛은 있으니... 포기 못해....★

제스티살룬 위치 :

데이터 개수를 셀 때 유용한 파이썬의 collections 모듈의 Counter 클래스 사용법 ( 참고자료 ) 

* Counter() : 데이터 개수 세서 딕셔너리 형태로 반환

from collections import Counter

word_count = Counter('hello world') 
print(word_count)
>>> Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})

for key,value in word_count.items():
    print(key,':',value)
>>> h : 1
>>> e : 1
>>> l : 3

* Counter의 내부 메소드

• most_common() : Counter()에서 가장 빈도수가 높은 순으로 정렬

from collections import Counter

# 데이터의 개수가 많은 순으로 정렬된 배열 리턴
Counter('hello world').most_common() 
>>>[('l', 3), ('o', 2), ('h', 1), ('e', 1), (' ', 1), ('w', 1), ('r', 1), ('d', 1)]

# 가장 개수가 많은 k개의 데이터 리턴
Counter('hello world').most_common(1)
>>> [('l', 3)]

순열(permutations) nPr

• 순서 고려해서 나열한 경우의 수
• itertools.permutations( items , r ) : 리스트에서 r개의 원소를 골라 순열 결과를 리턴

import itertools

items = ['A', 'B', 'C']
nPr = itertools.permutations(items, 2) # 리스트에서 2개의 원소를 골라 순서정해 나열
print(list(nPr))
>>> [('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]

# items의 모든 원소를 가지고 순열을 만든다
print(list(map(''.join, itertools.permutations(items))))
>>> ['ABC', 'ACB', 'BAC', 'BCA', 'CAB', 'CBA']

# 2개의 원소를 가지고 순열을 만든다
print(list(map(''.join, itertools.permutations(items, 2))))
>>> ['AB', 'AC', 'BA', 'BC', 'CA', 'CB']

+ 숫자 형태의 경우 map(str, 리스트명)의 과정이 추가로 들어가야 함

• str.join -> iterable iterable에서 문자열을 연결 한 문자열을 반환합니다
• 때문에 숫자를 문자로 변경하지 않으면 'TypeError: sequence item 0: expected str instance, int found' 발생

import itertools

# 숫자형태의 경우
nums=[3,1,2,4]
print(list(map(''.join, itertools.permutations(map(str,nums), 2))))
>>>	['31', '32', '34', '13', '12', '14', '23', '21', '24', '43', '41', '42']

조합(combination) nCr

• 순서 고려하지 않고 나열한 경우의 수 -> 뽑는 순서는 중요하지 않다
• itertools.combinations( items , r ) : 리스트에서 r개의 원소를 골라 조합 결과를 리턴

import itertools

items = ['A', 'B', 'C']
nCr = itertools.combinations(items, 2)
print(list(nCr))
>>> [('A', 'B'), ('A', 'C'), ('B', 'C')]

코테 풀면서 자주 쓰이는 파이썬 내장함수 정리 ( 참고자료 )

• abs(x) : 절댓값
• divmod(a,b) : a를 b로 나눈 몫과 나머지를 튜플 형태로 반환
• pow(x,y) : x의 y 제곱한 결과값
• round(x) : 반올림
• ceil(x) : 올림
• floor(x) : 내림
• map(f, iterable) : 입력받은 자료형의 각 요소를 함수 f가 수행한 결과를 묶어서 반환

# 숫자 자리수대로 분리
num = 12345
list(map(int, str(num))
>>> [1,2,3,4,5]

• enumerate : 인덱스 번호와 컬렉션의 원소를 tuple 형태로 반환

for i, name in enumerate(['body', 'foo', 'bar']):
     print(i, name)
>>> 0 body
>>> 1 foo
>>> 2 bar

• zip : 동일한 개수로 이루어진 자료형을 묶어주는 역할을 하는 함수 ( ※ 리스트의 길이가 같아야 함)
  • 동시에 여러 리스트에 접근하여 처리할 때 사용

numbers = [1, 2, 3]
letters = ["A", "B", "C"]
for pair in zip(numbers, letters):
     print(pair)
>>> (1, 'A')
>>> (2, 'B')
>>> (3, 'C')

Number = [1,2,3,4]
Name = ['hong','gil','dong','nim']
dic = {}
for number, name in zip(Number,Name): 
    dic[number] = name
print(dic)
>>> {1 : 'hong' , 2 : 'gil' , 3 : 'dong' , 4 : 'nim'}

+ 재귀 함수 최대 깊이 설정하기

• 재귀 함수의 경우 문제에 따라 1,000,000보다 작거나 같은 자연수 같이 범위가 주어질 때가 있다.
  최상단에 아래와 같은 코드를 넣는다

import sys 
sys.setrecursionlimit(10**6) # 0의 갯수만큼 늘려주면 됌. 10^6 == 1,000,000

+ 함수 이름이 생각나지 않을 때

• dir() : 객체가 자체적으로 가지고 있는 변수나 함수를 보여준다

a = []  # 리스트
print(dir(a))
>>> [ ..., 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 
'pop', 'remove', 'reverse', 'sort']

b = {}  # 딕셔너리
print(dir(b))
>>>[ ..., 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 
'setdefault', 'update', 'values']

프로그래머스 탐욕법(Greedy)

# 구명보트 (Level2)

• 정렬 후, 앞의 값과 뒤의 값의 합이 무게 제한을 넘는지 확인한다.
• 무게 제한을 넘지 않으면 앞 사람을 포함해 구명보트에 태운다 ( 앞 값의 인덱스를 +1 )
• 맨 뒤 값을 한 칸 앞으로 당겨준다

def solution(people, limit):
    answer = 0
    people.sort()
    s = 0
    e = len(people) -1
    
    while s<=e:
        answer+=1
        if people[s] + people[e] <= limit:
            s+=1
        e-=1
         
    return answer