내 인생 이대로 ㅈ될 수 없다

https://school.programmers.co.kr/learn/courses/30/lessons/92341

내 풀이

from collections import defaultdict
import math

def solution(fees,records):
    info = {}
    answer=defaultdict(int)
    result =[]
    max_time = 23 * 60 + 59
    for i in records:
        time,number,status = i.split()
        hour,minu = time.split(':')
        time = int(hour) * 60 + int(minu)
        if number in info:
            answer[number] += time - info[number]
            
            del(info[number])
            
            
        else:
            info[number]= time
    max_time = 23 * 60 + 59
    for num,t in info.items():
        answer[num] += max_time - t
    
    
    basic_t,basic_f,m_t,m_f = fees
    for num,time in answer.items():
        cost = basic_f
        if basic_t < time:
            cost += math.ceil ((time - basic_t)  / m_t)  * m_f
        result.append((num,cost))
    result.sort()
    
    return [i[1] for i in result]

진짜 오래걸렸다. 이유는 모르겠음 한 두시간은 푼거같다. 어렵지도 않았는데 말이지

다른사람의 풀이

from collections import defaultdict
from math import ceil

class Parking:
    def __init__(self, fees):
        self.fees = fees
        self.in_flag = False
        self.in_time = 0
        self.total = 0

    def update(self, t, inout):
        self.in_flag = True if inout=='IN' else False
        if self.in_flag:  self.in_time = str2int(t)
        else:             self.total  += (str2int(t)-self.in_time)

    def calc_fee(self):
        if self.in_flag: self.update('23:59', 'out')
        add_t = self.total - self.fees[0]
        return self.fees[1] + ceil(add_t/self.fees[2]) * self.fees[3] if add_t >= 0 else self.fees[1]

def str2int(string):
    return int(string[:2])*60 + int(string[3:])

def solution(fees, records):
    recordsDict = defaultdict(lambda:Parking(fees))
    for rcd in records:
        t, car, inout = rcd.split()
        recordsDict[car].update(t, inout)
    return [v.calc_fee() for k, v in sorted(recordsDict.items())]

https://school.programmers.co.kr/learn/courses/30/lessons/17680?language=python3 

내 풀이

from collections import deque

def solution(cacheSize, cities):
    time=0
    cache = deque()
    
    cities=[i.lower() for i in cities]
    
    
    for i in cities:
        if len(cache) <cacheSize:
            if i in cache:
                time +=1
                cache.append(i)
                cache.remove(i)
            else:
                cache.append(i)
                time+=5
        else:
            if i in cache:
                time+=1
                cache.append(i)
                cache.remove(i)
                
            else:
                cache.append(i)
                cache.popleft()
                time+=5
        
        
        
                
            
    return time

다른사람의 풀이

def solution(cacheSize, cities):
    import collections
    cache = collections.deque(maxlen=cacheSize)
    time = 0
    for i in cities:
        s = i.lower()
        if s in cache:
            cache.remove(s)
            cache.append(s)
            time += 1
        else:
            cache.append(s)
            time += 5
    return time

maxlen으로 길이를 정해줄수있다는것을 배웠다.

https://swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AWXRUN9KfZ8DFAUo 

내 풀이

def solution():
    answer=[]
    t = int(input())
   
    for i in range(t):
        n,k = map(int,input().split())
        m = input()
        answer.clear()
        for _ in range(n//3):
                    
            for j in range(0,len(m),n//4):
                answer.append(m[j:j+(n//4)])
            last_chr = m[-1]
            m=list(m)
            m[1:]=m[0:len(m)-1]
            m[0]=last_chr
            m =''.join(m)
        for p in range(len(answer)):
            answer[p]='0x' + answer[p]
        answer =list(set(answer))
        answer.sort(reverse=True)
        print(f'#{i+1}',int(answer[k-1],16))
        
    

        

solution()

최초에 문제풀 때 무조건 3번돌면 똑같은 값이 돌아온다고 생각해서 삽질했다..

다른사람의 풀이

T = int(input())
for t in range(T):
    N, K = map(int,input().split())
    pw = list(map(str,input()))
    cnt = N // 4 # 한 변당 번호 개수 = rotate수
    arr = [] # 회전 시킨 후 16진수 번호가 저장 될 리스트
    for i in range(cnt): # rotate 수 만큼 회전시킴
        pop = pw.pop() #리스트 끝 부분을 맨 앞으로 이동 시키면 한번 회전 완료됨
        pw.insert(0,pop)
        for j in range(0,N,cnt): # 리스트 내에서 각각 떨어져있는 요소를 하나의 번호로 합침 
            a = ''
            for k in range(j,j+cnt):
                a += pw[k]
            arr.append(a)
    new_arr = set(arr) # 중복을 허용치 않는 자료구조 set 활용
    answer = [] # 10진수로 변환된 숫자가 들어갈 리스트
    for num in new_arr: # 16진수 -> 10 진수로 변환
        answer.append(int(num,16))
    sorted_answer = sorted(answer,reverse=True) #내림차순 정렬
    print('#{} {}'.format(t+1,sorted_answer[K-1]))

https://epser.tistory.com/8

삼성 채용 시즌에 맞춰 풀어보기 시작한다.

https://www.acmicpc.net/problem/2589

내 풀이

from collections import deque
import sys

input = sys.stdin.readline

def solution():
    n,m = map(int,input().split())
    graph=[list(input().strip()) for _ in range(n)]
    
    dx = [1,-1,0,0]
    dy = [0,0,1,-1]
    
    def bfs(x,y):
        visit = [[0]* m for _ in range(n)]
        visit[x][y]=1
        q = deque([(x,y)])
        
        
        
        while q:
            x,y = q.popleft()
            for i in range(4):
                nx = x + dx[i]
                ny = y + dy[i]
                
                if 0>nx or nx>=n or 0>ny or m<=ny or graph[nx][ny]=='W' or visit[nx][ny]  :
                    continue
                
                visit[nx][ny] = visit[x][y] + 1             
                q.append((nx,ny))
        
        return visit[x][y]-1
    max_time=0  
    for i in range(n):
        for j in range(m):
            if graph[i][j]=='L':
                if 0<=i-1 and i+1<n:
                    if graph[i-1][j]=='L' and graph[i+1][j]=='L':
                        continue
                if 0<=j-1 and j+1<m:
                    if graph[i][j-1]=='L'and graph[i][j+1]=='L':
                        continue
                max_time=max(bfs(i,j),max_time)
    print(max_time)
                
solution()

문제 자체는 진짜 평이했는데 그놈의 시간초과가 나를 괴롭혔다.

당연히 pypy로 풀면 해결되지만 코딩테스트에서는 pypy를 지원하지 않는 경우가 많아서 꼭 파이썬으로 풀고 싶었다.

조건을 조금 더 생각해보니, 그래프에서 양 옆이 모두 육지인 경우는 절대 최대값일 수가 없었다.

가령

LLW

LWW

LLL

이런 그래프가 있다하면

그래프에서 (0,2)인 지점은 절대 최대값일 수가 없다 왜?

내 옆에 땅을 거쳐가면 반드시 현재 위치보다 더 긴시간이 걸릴테니까

이런 문제의 핵심은 적어도 파이썬으로 풀때는, 숨겨진 조건을 찾는것인거 같다.

다른사람의 풀이

import sys
from collections import deque

input = sys.stdin.readline

N, M = map(int, input().split())
bomool = []
land = []
for i in range(N):
    temp = list(map(str, input()))
    for j in range(len(temp)):
        if temp[j] == 'L':
            land.append((i, j))
    bomool.append(temp)

dr = [-1, 0, 1, 0]  # 행 상 우 하 좌
dc = [0, 1, 0, -1]  # 열 상 우 하 좌


def bfs(r, c):
    queue = deque([[r, c, 0]])
    visited[r][c] = True
    while queue:
        r, c, distance = queue.popleft()

        for i in range(4):

            nr = r + dr[i]
            nc = c + dc[i]

            if nr < 0 or nr >= N or nc < 0 or nc >= M or visited[nr][nc] or bomool[nr][nc] == 'W':
                continue

            visited[nr][nc] = True
            queue.append([nr, nc, distance + 1])

    return distance


max_ = 0
for i in range(len(land)):
    visited = [[False] * M for _ in range(N)]
    distance = bfs(land[i][0], land[i][1])
    if max_ < distance:
        max_ = distance

print(max_)

https://ji-gwang.tistory.com/m/406

https://school.programmers.co.kr/learn/courses/30/lessons/118667

내 풀이

from collections import deque

def solution(queue1, queue2):
    q1 = deque(queue1)
    q2 = deque(queue2)
    sumq1= sum(q1)
    target = (sum(q1) + sum(q2)) /2
    count=0
    
    while q1 and q2:
        if sumq1 == target:  
            return count
        elif sumq1 > target:  
            sumq1 -= q1.popleft()
        else:  
            q1.append(q2.popleft())
            sumq1 += q1[-1]
            
        count += 1

    return -1

deque를 이용한 평범한 풀이다. 

최초에는 sumq를 이용하지 않고 매번 sum을 구해줘서 했는데 그러니까 시간초과가 나더라.

그래서 따로 구해주고 +-만 해줬다.

다른 풀이를 보니까 q1 q2 둘다 append pop해줬던데 그럴필요없이 비교할 하나만 정해서

비교군이 타겟보다 크면 비교군에만 빼주고 다른 한쪽은 가만히 두는게 더 나은거 같다.

다른사람의 풀이

from collections import deque

def solution(queue1, queue2):
    qu_1 = deque(queue1)
    qu_2 = deque(queue2)
    sum_1 = sum(qu_1)
    sum_2 = sum(qu_2)

    for i in range(len(queue1) * 3):
        if sum_1 == sum_2:
            return i
        if sum_1 > sum_2:
            num = qu_1.popleft()
            qu_2.append(num)
            sum_1 -= num
            sum_2 += num
        else:
            num = qu_2.popleft()
            qu_1.append(num)
            sum_2 -= num
            sum_1 += num
    return -1

https://dev-dain.tistory.com/228

최초에 코테칠때 이 두문제 풀고나니 시간을 다써서 아무것도 못했었던 기억이난다..

발전을 하긴하는거같다 이 두문제 풀고나니까 동기부여를 조금 받은거 같다

이 두문제처럼 아주 어려운 문제들도 나중에 보면 그땐 그랬지 할 수 있었으면 한다.

https://school.programmers.co.kr/learn/courses/30/lessons/118666?language=python3 

내 풀이

#1번 라이언(R),튜브(T)
#2번 콘(C),프로도(F)
#3번 제이지(J),무지(M)
#4번 어피치(A),네오(N)

from collections import defaultdict

def solution(survey, choices):
    answer=''
    candi = defaultdict(int)
    
    for s,c in zip(survey,choices):
        if c<4:
            candi[s[0]] +=(4-c)
        elif c>4:
            candi[s[1]] +=c-4
    print(candi)
    
    answer +='R' if candi['R'] >= candi['T'] else 'T'
    answer +='C' if candi['C'] >= candi['F'] else 'F'
    answer +='J' if candi['J'] >= candi['M'] else 'M'
    answer +='A' if candi['A'] >= candi['N'] else 'N'
    
    
    return answer

defaultdict를 이용한 풀이다.

아니면 set에다 기본 값 주고 시작해도 될듯.

다른사람의 풀이

from collections import defaultdict

def solution(survey, choices):
    indicator = [('R', 'T'), ('C', 'F'), ('J', 'M'), ('A', 'N')]
    answer = ''
    personality = defaultdict(int)
    for s, c in zip(survey, choices):
        if c < 4:
            personality[s[0]] += (4 - c)
        elif c > 4:
            personality[s[1]] += (c - 4)
    for i in indicator:
        if personality[i[0]] >= personality[i[1]]:
            answer += i[0]
        else:
            answer += i[1]
    return answer

사실 이 문제 코테를 처음 준비하기 시작했을 때 무턱대고 지원했던 카카오 인턴 1차 문제에서 어렵게 풀었었던 기억이있다.

그때 이 문제푸는데 2시간 걸렸었는데 참 시간이 많이 지났음을 느낀다..