CodeKata

SQL

LeetCode: Department Highest Salary

• 작성한 쿼리

with salary_rank as (
    select
      d.name as department
      , e.name as employee
      , e.salary
      , rank() over (partition by departmentId order by e.salary desc) as rnk
    from
      Employee e
      left join Department d
      on e.departmentId = d.id
)
select
  department
  , employee
  , salary
from 
  salary_rank
where
  rnk = 1
;

참고할 만한 다른 풀이

with table1 as (
select name, salary, departmentId,
dense_rank() over(partition by departmentId order by salary desc) as ranking
from Employee
)
select t2.name as Department, t1.name as Employee, t1.salary as Salary
from table1 t1
left join Department t2
on t1.departmentId = t2.id
where t1.ranking = 1;

Python

84. 괄호 회전하기

• 작성한 코드

def solution(s):
    answer = 0
    s = list(s)
    for _ in range(len(s)):
        stack = []
        for i in range(len(s)):
            if len(stack) > 0:
                if stack[-1] == '[' and s[i] == ']':
                    stack.pop()
                elif stack[-1] == '{' and s[i] == '}':
                    stack.pop()
                elif stack[-1] == '(' and s[i] == ')':
                    stack.pop()
                else:
                    stack.append(s[i])
            else:
                stack.append(s[i])
        if len(stack) == 0:
            answer += 1
        s.append(s.pop(0))
    return answer

스택을 이용한 문제로 이중 반복문으로 s를 검사
1. 만약 스택이 비어있다면, 해당 글자를 스택에 저장
2. 스택이 비어있지 않다면, 스택에 마지막으로 저장되어 있는 괄호와 현재 검사하는 s 글자를 매치하여 매칭되면 스택에서 pop
3. s 검사 후, 스택이 비어있다면 +1
4. s 첫 글자를 마지막 글자로 옮김

참고할 만한 다른 풀이

from collections import deque
def solution(s):
    flag  = False   # 올바른 문자열 확인 플래그
    count = 0      # 올바른 문자열 카운트
    stack = []     # 올바른 문자열 확인을 위한 스택
    queue = deque(s) # 문자열 큐로 변환
    
    # 문자열 큐 길이 만큼 for loop
    for i in range(len(queue)):
        # 괄호 문자열 하나씩 확인하는 for loop
        for el in queue:
            # 괄호 여는 문자열이면 스택에 저장
            if el == '[' or el == '{' or el == '(':
                stack.append(el)
            # 괄호 닫는 문자열이면 스택 마지막 값과 확인
            else:
                # 스택에 값이 있고 괄호 문자열이 완성되면 제거 후 플래그 True
                if stack:
                    if stack[-1] == '[' and el == ']':
                        stack.pop()
                        flag = True
                    elif stack[-1] == '{' and el == '}':
                        stack.pop()
                        flag = True
                    elif stack[-1] == '(' and el == ')':
                        stack.pop()
                        flag = True
        
        # 올바른 문자열이 만들어졌고 스택이 비어있다면 카운트 1씩 증가
        if flag and not stack: count += 1
        
        # 스택, 플래그 초기화, 문자열 회전
        stack = []
        flag = False        
        queue.append(queue.popleft())
        
    # 올바른 문자열 카운트 반환
    return count

해결 과정
(1) 올바른 문자열 확인을 위한 플래그, 반환할 올바른 문자열 카운트 그리고 스택과 큐를 선언해 줍니다.
(2) 선언한 문자열 큐의 길이만큼 for loop을 돌려 회전해 줍니다.
(3) 회전된 문자열을 for loop을 돌려 하나씩 확인해 줍니다.
(4) 괄호를 여는 문자열이면 스택에 저장, 괄호를 닫는 문자열이면 스택의 마지막 값과 확인합니다.
(5) 스택에 값이 있고 괄호 문자열이 완성되면 제거 후 플래그를 True로 업데이트해 줍니다.
(6) 올바른 문자열이 만들어졌고 스택이 비어있다면 반환할 카운트를 1씩 증가시켜 줍니다.
(7) 스택과 플래그를 초기화해 주고 문자열을 회전이 끝날 때까지 3번부터 반복해 줍니다.

# 리팩토링 코드
from collections import deque

def check(s):
    while True:
        if "()" in s: s = s.replace("()","")
        elif "{}" in s: s = s.replace("{}","")
        elif "[]" in s: s = s.replace("[]","")
        else: return False if s else True       

def solution(s):
    count = 0
    queue = deque(s)

    for i in range(len(s)):
        if check(''.join(queue)): count+=1
        queue.rotate(-1)
    return count

def bracket(s):
        stack = []
        for i in s:
            if len(stack) == 0: stack.append(i)
            else:
                if i == ")" and stack[-1] == "(":   stack.pop()
                elif i == "]" and stack[-1] == "[":   stack.pop()
                elif i == "}" and stack[-1] == "{":   stack.pop()
                else: stack.append(i)
        return 1 if len(stack) == 0 else 0
        
def solution(s):
    answer = 0
    
    for i in range(len(s)):
        if bracket(s):  answer +=1
        s = s[1:] + s[:1]
    return answer

def solution(test):
  answer= 0
  n=len(test)
  for i in range(n):
    stack = [ ]
    for j in range(n): # test를 회전하기 위해 이중 for문사용
      c = test[(i+j)%n]   
      if c == "(" or c == "{" or c == "[":
        stack.append(c) #스택에 푸시
      else:
        if not stack: #짝이 맞지 않는 경우는 break
          break
        if c == ")" and stack[-1] == "(":
          stack.pop()
        elif c == "]" and stack[-1] == "[":
          stack.pop()
        elif c == "}" and stack[-1] == "{":
          stack.pop()
        else:
          break
    else: # break에 걸리지 않고 끝까지 수행한 경우
        if not stack:
          answer +=1        
  return answer

데이터 파이프라인 구축

5회차

최종 프로젝트

• 시즌 5와 시즌 6의 주요 지표 비교
  • 전체 데이터 EDA
    • ERD
      
    • API 호출 및 데이터 수집 과정
      
    • 데이터셋 요약
    • 이상치, 결측치 처리(간단하게만)
    • 주요 컬럼별 분포(시각화) → 5개 ~ 10개 정도?
    • 상관관계(쁠마 0.7 이상의 관계를 리스트업하여 설명) → 특정 컬럼을 지정해서
  • 주요 지표 비교
    • 시즌별 매치 수
    • 시즌별 티어 분포
    • 시즌별 몬스터별 처치비중(신규 몬스터 처치비중)
    • 시즌별 순위 및 랭크 포인트 → 매치 후 RP 획득량 평균
    • 주요 결정 요인 (상관관계)
  • 캐릭터 및 팀 조합 분석
    • 시즌별 영웅픽률 비교
    • 시즌별 조합 픽률 비교
    • 시즌별 스탯 비교(공격, 방어 hp, sp등)
    • 시즌별 직업별 레벨 비교
  • 클러스터링
    • 전체 데이터를 클러스터링 → 클러스터 번호를 붙인 다음에 시즌 번호로 groupby → 비교
      (시즌별로 클러스터링 하면 절대 안 됨!)
  • (시간이 남으면)시즌별 직업별 주요사용스킬 비교
  • 크레딧 활용
  • 게임 성과 간의 관계 분석

회고

• 집에 손님도 오시고 해서 집중이 잘 안 된 하루였다…