수학과의 개발자 도전기

- 문제 : https://school.programmers.co.kr/learn/courses/30/lessons/92335

Lv2. 문제이고, 스스로 푼 문제다!

마지막에 '0'이 0개인지 아닌지에 따라서 조건문을 나눴는데 그렇게 할 필요가 없었다 

문제 이해 

조건을 만족하는 수는 모두 0을 기준으로 나뉘어지므로 n을 k진수로 변경한다음 0을 제외한 수들이 10진수에서 소수인지 확인하는 로직으로 진행하면 된다 

1. 주어진 수 n을 k진수로 변경 후 changed에 저장한다(여기서 changed는 문자열)

2. changed에서 0을 기준으로 숫자들을 구분한 뒤 changed에 저장한다(여기서 changed는 리스트)

3. 구분된 숫자들 중에서 소수가 있으면 answer += 1을 해준다

- 정답 풀이 :

import math
def isPrime(num):
    if num <= 1:
        return False
    for i in range(2, int(math.sqrt(num)) + 1):
        if num % i == 0:
            return False
    return True
                       
def solution(n, k):
    answer = 0
    temp = n
    changed = ''
    mul = 0
    while True:
        if temp // k == 0:
            break
        temp //= k
        mul += 1
    
    temp = n
    for i in range(mul, -1, -1):        
        if temp // (k ** i) != 0:
            changed += str(temp // (k ** i)) 
            temp = temp - (k ** i) * (temp // (k ** i))
        else:
            changed += '0'
         
   
    changed = changed.split('0')
    for each in changed:
        if len(each) != 0:   
            if isPrime(int(each)):
                answer += 1
    return answer

- 시도해본 풀이 : 

테스트 16개 중 2개에서 계속 틀렸다 

어차피 0을 기준으로 숫자들을 구분하기 때문에 0의 갯수가 0개인 경우를 따로 확인할 필요는 없다 

여기를 뺀 뒤 돌렸더니 코드가 정상 작동했다 

    if changed.count('0') == 0 :
        if isPrime(n):
            return 1
        else:
            return 0

import math
def isPrime(num):
    flag = True
    for i in range(2, int(math.sqrt(num)) + 1):
        if num % i == 0:
            flag = False
            break
    if flag:
        return True
    else:
        return False
                       
def solution(n, k):
    answer = 0
    temp = n
    changed = ''
    mul = 0
    while True:
        if temp // k == 0:
            break
        temp //= k
        mul += 1
    
    temp = n
    for i in range(mul, -1, -1):        
        if temp // (k ** i) != 0:
            changed += str(temp // (k ** i)) 
            temp = temp - (k ** i) * (temp // (k ** i))
        else:
            changed += '0'
         
    if changed.count('0') == 0 :
        if isPrime(n):
            return 1
        else:
            return 0
    else: 
        changed = changed.split('0')
        for each in changed:
            if len(each) != 0 and int(each) > 1:   
                if isPrime(int(each)):
                    answer += 1
        return answer

- 문제 : https://school.programmers.co.kr/learn/courses/30/lessons/87390

나름 풀어본다고 고군분투했는데도 틀려서 답지 봤는데 풀이가 너무 짧아서 당황스럽네 

- 정답 풀이 

def solution(n, left, right):
    answer = []
    for i in range(left, right + 1):
        answer.append(max(i // n, i % n) + 1)
        print(answer)
    return answer

- 시도해본 풀이 

대부분 시간초과가 발생했다

def solution(n, left, right):
    matrix = [[0] * n for _ in range(n)]
    
    answer = []
    for k in range(n):
        for i in range(k + 1):
            for j in range(k + 1):
                if matrix[i][j] == 0:
                    matrix[i][j] = k + 1
    
    answer = []
    for i in range(n):
        for j in range(n):
            answer.append(matrix[i][j])
            
    return answer[left : right + 1]

45%까지는 맞았는데, 나머지는 시간초과 발생 

def solution(n, left, right):
    temp = [i for i in range(1, n + 1)]
    answer = []
    for i in range(1, n + 1):
        for j in range(i):
            answer.append(i)
        for j in range(i, n):
            answer.append(temp[j])      
            
    return answer[left : right + 1]

answer를 다 구하고 거기서 left ~ right를 구하기보다 

left가 속한 리스트, 그 사이의 리스트, right가 속한 리스트를 직접 구해서 진행했는데 60퍼센트까지 가서 멈췄다 

def solution(n, left, right):
    temp = [i for i in range(1, n + 1)]
    start_num = left // n
    end_num = right // n
    start = []
    end = []
               
    for _ in range(start_num + 1):
        start.append(start_num + 1)
    for i in range(start_num + 1, n):
        start.append(temp[i])
    
    mid = []
    for i in range(start_num + 1, end_num):
        for _ in range(i + 1):
            mid.append(i + 1)
        for j in range(i + 1, n):
            mid.append(temp[j])
    
    for _ in range(end_num + 1):
        end.append(end_num + 1)
    for i in range(end_num + 1, n):
        end.append(temp[i])

    answer = start[left % n : ] + mid + end[ : right % n + 1]
            
    return answer

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

참고한 블로그

Lv2문제이고, 생각보다 문제가 까다롭다고 생각해서 시간이 오래 걸렸지만 결국 답을 본 문제다!

문제 이해 

1. 하루 내에 In에 상응하는 Out이 있는 경우 시간을 계산 한다음 그 시간들을 자동차 번호에 각각 저장한다.(여기서 해시 이용)

dict에 자동차 번호가 있다는 건 입차해 있다는 거고, 이제 출차한다는 의미이므로 자동차 번호의 누적 시간을 계산한다

total[number] += (time(출차 시간) - dic[number](입차 시간))

dict에 자동차 번호가 없으면 입차한다는 의미이므로 dict[number] = time을 해준다

2. 아직 출차를 안 했다는 것은 dict에 number가 있다는 의미이므로 23:59에서 입차 시간을 뺀 시간을 total에 누적한다

3. total에 있는 시간들을 토대로 주차 요금을 계산한다. 초과시간은 올림을 해야하므로 math.ceil()을 이용한다 

주차요금이 완료 되었으면 (자동차 번호, 부과된 요금)을 answer에 추가한다

4. 자동차 번호를 오름차순으로 정렬한다

5. answer에서 각 주차요금을 반환한다 

- 정답 풀이 :

import math
from collections import defaultdict

def solution(fees, records):
    answer = []

    dict = {}
    total = defaultdict(int)
    # 주차한 시간
    for record in records :
        # 시간, 차량 번호, 상태(In or Out)
        time, number, state = record.split() 
        hour, minutes = time.split(":")
        time = int(hour) * 60 + int(minutes)
        # 이미 입차되어 있다면
        if number in dict : 
            total[number] += time - dict[number]
            del dict[number]
        else : # 입차할 경우
            dict[number] = time

    # 출차를 안 한 경우
    max_time = (23 * 60) + 59
    for num, t in dict.items():
        total[num] += max_time - t

    # 요금 계산
    basic_minutes, basic_fee, split_minutes, split_fee = fees
    for num, t in total.items() :
        cost = basic_fee
        if t > basic_minutes : # 추가 요금 발생
            cost += math.ceil((t - basic_minutes) / split_minutes) * split_fee # 올림 처리
        answer.append((num, cost))

    # 차량 번호 오름차순
    answer.sort()
    return [value[1] for value in answer]

- 시도해본 풀이: 

from datetime import datetime

def solution(fees, records):
    #차 번호, 입차한 시간 
    dic = {}
    #차 번호, 누적 시간
    money = {}
    
    for record in records:
        a,b,c = record.split(' ')
        if c ==  "IN":
            dic[b] = a
        if c == "OUT":
            #주차한 시간 구하기, 요금계산하기, money에 누적하기 
            intime = datetime.strptime(dic[b], "%H:%M")
            outtime = datetime.strptime(a, "%H:%M")
            diff = outtime - intime
            time = (diff.seconds) // 60 
            if b in money:
                money[b] += time
            else:
                money[b] = time
                
            dic[b] = 0
            
    for i in dic:
        if dic[i] != 0:
            outtime = datetime.strptime("23:59", "%H:%M")
            intime = datetime.strptime(dic[i], "%H:%M")
            diff = outtime - intime
            time = (diff.seconds) // 60
            if b in money:
                money[i] += time
            else:
                money[i] = time   
    
    for each in money.keys():
        if money[each] <= fees[0]:
            money[each] = fees[1]
        else:
            time = money[each]
            time -= fees[0]
            if time % fees[2] != 0:
                time = time // fees[2] + 1
            else:
                time = time // fees[2] 
            money[each] = fees[1] + time * fees[3]
        
    answer = []
    hello = sorted(money.items(), key = lambda x : x[0])
    for a,b in hello:
        answer.append(b)
        
    return answer

- 문제 : https://school.programmers.co.kr/learn/courses/30/lessons/17677

Lv2 문제다! 대부분의 로직은 작성했지만, 교집합 구하는 로직이 의도와 잘 맞지 않아 고생을 약간 했던 문제다

문제 이해 

1. 모든 문자는 소문자로 처리해야하므로 str1, str2에 모두 lower()를 적용시킨다

2. str1을 알파벳으로 두개씩 처리한 문자열들을 담을 리스트를 one, str2는 two로 설정했다

3. i -1번째와 i 번째 문자가 모두 소문자 알파벳인 경우에 리스트에 추가한다

4-1. one, two 리스트 모두 원소가 없다면 문제 조건에 따라 65536을 반환해준다

4-2. 원소가 각각 있다면 이제 one과 two의 공통 원소를 intersection 리스트에 추가한다

처음에는 두 리스트에 모두 있는 원소를 찾아서 넣었는데 같은 값이 중복될 수 있으므로 공통 값을 intersection에 넣어준 뒤 one, two 중에 더 긴 리스트에서 공통 원소들을 하나씩 pop해준다. 

반례 ['ab', 'ab', ' cd'], ['ab','ef'] -> 실제 공통인 원소는 'ab'하나 인데 두 리스트에 있는 원소만 식별하면 'ab' 두개가 intersection에 들어간다 

5. 합집합 = len(one) + len(two) - len(intersection)을 계산한 후  (union // intersection) * 65536를 반환한다 

- 정답 풀이 

def solution(str1, str2):
    #글자를 두개씩 쪼개기 
    str1 = str1.lower()
    str2 = str2.lower()
    
    one, two = [], []    
    for i in range(1, len(str1)):
        if 97 <= ord(str1[i - 1]) <= 122:
            if 97 <= ord(str1[i]) <= 122:
                one.append(str1[i - 1:  i + 1])
                
    for i in range(1, len(str2)):
        if 97 <= ord(str2[i - 1]) <= 122:
            if 97 <= ord(str2[i]) <= 122:
                two.append(str2[i - 1:  i + 1])

    if len(one) == 0 and len(two) == 0:       
        return 65536
    else:
        #교집합 원소 구하는데 약간 애 먹음
        intersection = []    
        union = len(one) + len(two)
        if len(one) < len(two):
            for i in range(len(one)):
                if one[i] in two:
                    intersection.append(one[i])
                    two.pop(two.index(one[i]))
        else:
            for i in range(len(two)):
                if two[i] in one:
                    intersection.append(two[i])
                    one.pop(one.index(two[i]))
                    
        union -= len(intersection)
        answer = int((len(intersection) / union) * 65536)
        
        return answer

- 시도해본 풀이 

61퍼센트에서 틀렸다

def solution(str1, str2):
    #글자를 두개씩 쪼개기 
    str1 = str1.lower()
    str2 = str2.lower()
    
    one, two = [], []    
    for i in range(1, len(str1)):
        if 97 <= ord(str1[i - 1]) <= 122:
            if 97 <= ord(str1[i]) <= 122:
                one.append(str1[i - 1:  i + 1])
                
    for i in range(1, len(str2)):
        if 97 <= ord(str2[i - 1]) <= 122:
            if 97 <= ord(str2[i]) <= 122:
                two.append(str2[i - 1:  i + 1])

    if len(one) == 0 and len(two) == 0:       
        return 65536
    else:
        intersection = []    
        change_one = []
        for each in one:
            if each in two:
                intersection.append(each)
            else:
                change_one.append(each)
            
        union = change_one + two
        
        answer = int((len(intersection) / len(union)) * 65536)
        
        return answer