say repository

https://programmers.co.kr/learn/courses/30/lessons/17684

출처 : 프로그래머스

def solution(msg):
    answer = []
    dic = dict()
    for i in range(ord('A'), ord('Z')+1):
        dic[chr(i)] = i - ord('A') + 1
    start, end = 0, 1
    print(dic)
    idx = 27 # dic 처음의 다음 인덱스
    
    while end < len(msg)+1:
        w = msg[start:end]
        if w in dic:
            end += 1
        else:
            answer.append(dic[w[:-1]])
            dic[w] = idx # 인덱스 삽입
            idx += 1
            start = end -1   
    answer.append(dic[w])
    return answer

풀이

영어 대문자 문자열로 조건에 맞게 비교하며 슬라이싱하는 문제이다.

슬라이싱 인덱싱이 조금 헷갈린다..

알파벳에 맞는 색인 문자를 같이 입력해야하니까

알파벳 사전을 dict() 으로 구현한다.

   dic = dict()
    for i in range(ord('A'), ord('Z')+1):
        dic[chr(i)] = i - ord('A') + 1

이는 많이 나오니까 알아두자.

https://programmers.co.kr/learn/courses/30/lessons/12951#

출처 : 프로그래머스

출처 : 프로그래머스

def solution(s):
    answer = ''
    s = s.split(" ") # 공백이 연속해서 나올 수 있다.
    print(s)
    for ss in s:
        if ss == "": # 연속한 공백
            answer += " "
            continue # 다음 ss
            
        for i in range(len(ss)):
            if i == 0:
                a = ss[i].upper()
                answer += a
            else:
                b = ss[i].lower()
                answer += b
        answer += " " # 기존 단어 사이 띄어쓰기
        
    return answer[:-1] # 마지막 단어 뒤에도 공백 있어서 제거하기

풀이

공백이 연속해서 나올 수 있다는 조건 때문에 계속 틀렸다. 

조건을 반드시 확인하자.

그래서 s.split()으로 단어를 분리하지 않고, s.split(" ")으로 분리해서 공백도 리스트에 분리되어 넣어지게끔 했다.

https://programmers.co.kr/learn/courses/30/lessons/43164

출처 : 프로그래머스

from collections import defaultdict
def solution(tickets):
    answer = []
    dic = defaultdict(list) # 유사 딕셔너리 생성
    
    for a,b in tickets:
        dic[a].append(b)
    for k in dic.keys():
        dic[k].sort(reverse = True) # 위에 있는 걸 먼저 내보내야해서 reverse
    print(dic)
    
    #dfs
    stack = ['ICN']
    while stack:
        top = stack[-1]
        if not dic[top]: # dic에 없으면 pop
            answer.append(stack.pop())
        else:
            stack.append(dic[top].pop())
            
    return answer[::-1]

풀이

defaultdict(list) : list 타입의 유사 딕셔너리 생성됨.

출발지를 key로 하고 sort()에서 reverse = True을 한다.

이 이유는 stack에서 가장 top에 있는 것으로 비교를 해서 pop() 연산을 할 것인데 여기서 더 편하게 하기 위함이다.

dfs 진행은 첫 시작 stack에 'ICN' 을 넣어주고 시작한다.

stack은 가는 경로라고 생각하면 된다.

dic[top] 의 값이 모두 stack에 들어가서 없어졌을 때, 모든 경로를 다 돈 것이다.

이제 이 stack 경로에 있는 원소들을 pop() 해서 answer에 넣어준다.

이때, 원하는 답과 거꾸로 얻어지기 때문에 최종적으로 뒤집어줘야 한다. -> answer [::-1]

https://programmers.co.kr/learn/courses/30/lessons/42885

출처 : 프로그래머스

from collections import deque
def solution(people, limit):
    answer = 0
    people.sort()
    q = deque(people)
    print(q)
    while q:
        if len(q) == 1: # 혼자면 끝
            answer += 1
            break
        elif q[0] + q[-1] <= limit: # 가장 작은 것, 큰 것을 제거하는게 효율적임
            answer += 1
            q.pop()
            q.popleft()
        else:
            q.pop() # 무거운 사람 먼저 나가기
            answer += 1
    return answer

풀이

어떻게 하면 최소의 보트에 두 명씩 구출할 수 있을지 생각했다.

우선 몸무게가 뒤죽박죽이니 오름차순으로 정렬해서 큐에 넣었다.

가벼운 사람부터 비교하는건 효율적이지 못하다.

가장 무거운 사람과 가장 가벼운 사람 두 명의 몸무게 합이 limit 이하면 최적의 조합이다.

이렇게 해서 큐에서 조건을 만족하면 pop() 한다.

2명의 조건이 맞지 않는다면 혼자라도 구명보트에 태워야 하는데,

이때, 무거운 사람부터 구출해야 탐욕적이다.

https://programmers.co.kr/learn/courses/30/lessons/17677

출처 : 프로그래머스

from collections import Counter
import math
def solution(str1, str2):
    answer = 0
    # 모두 대문자로 통일
    str1 = str1.upper()
    str2 = str2.upper()
    print(str1,str2)
    
    # 문자열로만 구성된 2글자 배열에 삽입
    tmp1 = []
    tmp2 = []
    for s1 in range(len(str1)-1):
        if str1[s1].isalpha() and str1[s1+1].isalpha():
            tmp1.append(str1[s1]+str1[s1+1])
    for s2 in range(len(str2)-1):
        if str2[s2].isalpha() and str2[s2+1].isalpha():
            tmp2.append(str2[s2]+str2[s2+1])

    # Counter 객체
    counter1 = Counter(tmp1)
    counter2 = Counter(tmp2)
    
    # 교집합과 합집합
    interset_set = list((counter1 & counter2).elements())
    union_set = list((counter1 | counter2).elements())
    
    if len(union_set) == 0:
        return 65536
    
    return math.floor((len(interset_set) /len(union_set))*65536)

풀이

대소문자 구분을 하지 않으니 모두 대문자로 통일시켜서 시작했다.

또한, 2개씩 문자열을 나눠서 배열에 넣을 때, 쪼갠 2개가 문자열이 맞는지 isalpha()로 확인해서 배열에 넣었다.

그리고 Counter() 를 사용해 객체를 만들어냈다.

Counter()는 set()처럼 교집합 & , 합집합 | 을 만들수 있다.

Counter().elements() 를 사용하면 요소(값) 만 뽑을 수 있다.

vscode

git init

git add ~~

+ 버튼 눌러서 all commit

( git remote rm origin )

commit message 남기기 / git commit -m "first commit"

git branch -m main

get remote -v (확인)

git remote add origin "repo 복사"

git push origin main

git push origin main --force

rm -rf .git 

git rebase --continue

https://programmers.co.kr/learn/courses/30/lessons/42584

출처 : 프로그래머스

def solution(prices):
    answer = []
    for i in range(len(prices)):
        cnt = 0
        for j in range(i+1,len(prices)):
            if prices[i] <= prices[j]:
                cnt += 1
            else:
                cnt += 1
                break
        answer.append(cnt)
        cnt = 0
    return answer

풀이 1 

이중포문을 사용해서 효율성은 떨어진다.

문제 카테고리에 맞게 스택/큐를 사용해봐야겠다.

from collections import deque

def solution(prices):
    answer = []
    prices = deque(prices)
    while prices:
        p = prices.popleft()
        cnt = 0
        for pq in prices:
            if p > pq:
                cnt += 1
                break
            cnt += 1
        answer.append(cnt)
    return answer

풀이 2

큐를 이용해 풀이했다.

prices 배열을 큐로 변환해서 풀이한거 말고는 이중반복문이랑 비슷하다.