제출한 쿼리 :

SELECT ROUND(LONG_W, 4)
FROM STATION
WHERE LAT_N > 38.7780
ORDER BY LAT_N
LIMIT 1;

Weather Observation Station 18 (Aggregation)

맨헤튼 거리

• 두 점 사이의 거리를 측정하는 방법 중 하나
• 두 점 사이의 경로를 구부리지 않고 직선 경로로 계산(좌표 죽에 평행한 경로를 따름)

  두 점 P1 = (x1, y1)과 P2 = (x2, y2) 사이의 맨해튼 거리 = |x1 - x2| + |y1 - y2|

  예) 두 점 (1, 2)와 (4, 6) 사이의 맨헤튼 거리 |1 - 4| + |2 - 6| = 3 + 4 = 7

제출한 쿼리 :

SELECT ROUND((MAX(LAT_N) - MIN(LAT_N)) + (MAX(LONG_W) - MIN(LONG_W)), 4)
FROM STATION;

Weather Observation Station 19 (Aggregation)

유클리드 거리

• 두 점 사이의 직선 거리를 측정하는 방법(일반적으로 생각하는직선거리)

• 피타고라스의 정리 이용하여 계산
• 평면 또는 3차원 공간에서 두 점 사이의 최단 경로

  두 점 P1 = (x1, y1)과 P2 = (x2, y2) 사이의 유클리드 거리 = √(x2 - x1)^2 + (y2 - y1)^2

  예) 두 점 (1, 2)와 (4, 6) 사이의 유클리드 거리 √(4 - 1)^2 + (6 - 2)^2 = √3^2 + 4^2 = √9 + 16 = √25 = 5

제출한 쿼리 :

SELECT ROUND(POWER(POWER(MAX(LAT_N)-MIN(LAT_N),2) + POWER(MAX(LONG_W)-MIN(LONG_W), 2), 0.5), 4) 
FROM STATION;

Population Census (Basic Join)

제출한 쿼리 :

SELECT SUM(CITY.POPULATION) 
FROM CITY 
JOIN COUNTRY 
ON CITY.COUNTRYCODE = COUNTRY.CODE 
WHERE CONTINENT = 'ASIA';

African Cities (Basic Join)

제출한 쿼리 :

SELECT CI.NAME
FROM CITY CI
JOIN COUNTRY CO
ON CI.COUNTRYCODE = CO.CODE
WHERE CO.CONTINENT = 'AFRICA';

• 영재는 택배상자를 트럭에 싣는 일을 합니다. 영재가 실어야 하는 택배상자는 크기가 모두 같으며 1번 상자부터 n번 상자까지 번호가 증가하는 순서대로 컨테이너 벨트에 일렬로 놓여 영재에게 전달됩니다. 컨테이너 벨트는 한 방향으로만 진행이 가능해서 벨트에 놓인 순서대로(1번 상자부터) 상자를 내릴 수 있습니다. 하지만 컨테이너 벨트에 놓인 순서대로 택배상자를 내려 바로 트럭에 싣게 되면 택배 기사님이 배달하는 순서와 택배상자가 실려 있는 순서가 맞지 않아 배달에 차질이 생깁니다. 따라서 택배 기사님이 미리 알려준 순서에 맞게 영재가 택배상자를 실어야 합니다.
  만약 컨테이너 벨트의 맨 앞에 놓인 상자가 현재 트럭에 실어야 하는 순서가 아니라면 그 상자를 트럭에 실을 순서가 될 때까지 잠시 다른 곳에 보관해야 합니다. 하지만 고객의 물건을 함부로 땅에 둘 수 없어 보조 컨테이너 벨트를 추가로 설치하였습니다. 보조 컨테이너 벨트는 앞 뒤로 이동이 가능하지만 입구 외에 다른 면이 막혀 있어서 맨 앞의 상자만 뺄 수 있습니다(즉, 가장 마지막에 보조 컨테이너 벨트에 보관한 상자부터 꺼내게 됩니다). 보조 컨테이너 벨트를 이용해도 기사님이 원하는 순서대로 상자를 싣지 못 한다면, 더 이상 상자를 싣지 않습니다.
  예를 들어, 영재가 5개의 상자를 실어야 하며, 택배 기사님이 알려준 순서가 기존의 컨테이너 벨트에 네 번째, 세 번째, 첫 번째, 두 번째, 다섯 번째 놓인 택배상자 순서인 경우, 영재는 우선 첫 번째, 두 번째, 세 번째 상자를 보조 컨테이너 벨트에 보관합니다. 그 후 네 번째 상자를 트럭에 싣고 보조 컨테이너 벨트에서 세 번째 상자 빼서 트럭에싣습니다. 다음으로 첫 번째 상자를 실어야 하지만 보조 컨테이너 벨트에서는 두 번째 상자를, 기존의 컨테이너 벨트에는 다섯 번째 상자를 꺼낼 수 있기 때문에 더이상의 상자는 실을 수 없습니다. 따라서 트럭에는 2개의 상자만 실리게 됩니다.
  택배 기사님이 원하는 상자 순서를 나타내는 정수 배열 order가 주어졌을 때, 영재가 몇 개의 상자를 실을 수 있는지 return 하는 solution 함수를 완성하세요.
  

  • 제한사항
    • 1 ≤ order의 길이 ≤ 1,000,000
    • order는 1이상 order의 길이 이하의 모든 정수가 한번씩 등장합니다.
    • order[i]는 기존의 컨테이너 벨트에 order[i]번째 상자를 i+1번째로 트럭에 실어야 함을 의미합니다.

제출한 코드 :

def solution(order):
    stack = []
    order_idx = 0
    n = len(order)

    for box in range(1, n + 1):
        stack.append(box)
        while stack and stack[-1] == order[order_idx]:
            stack.pop()
            order_idx += 1

    return order_idx

큰 수 만들기 (탐욕법(Greedy))

• 어떤 숫자에서 k개의 수를 제거했을 때 얻을 수 있는 가장 큰 숫자를 구하려 합니다.
  예를 들어, 숫자 1924에서 수 두 개를 제거하면 [19, 12, 14, 92, 94, 24] 를 만들 수 있습니다. 이 중 가장 큰 숫자는 94 입니다.
  문자열 형식으로 숫자 number와 제거할 수의 개수 k가 solution 함수의 매개변수로 주어집니다. number에서 k 개의 수를 제거했을 때 만들 수 있는 수 중 가장 큰 숫자를 문자열 형태로 return 하도록 solution 함수를 완성하세요.
  

  • 제한사항
    • number는 2자리 이상, 1,000,000자리 이하인 숫자입니다.
    • k는 1 이상 number의 자릿수 미만인 자연수입니다.

제출한 코드 :

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

    # k가 남아있는 경우 처리 (남아있는 k만큼 뒤에서 자름)
    if k > 0:
        stack = stack[:-k]

    return ''.join(stack)

삼각 달팽이 ()

• 정수 n이 매개변수로 주어집니다. 다음 그림과 같이 밑변의 길이와 높이가 n인 삼각형에서 맨 위 꼭짓점부터 반시계 방향으로 달팽이 채우기를 진행한 후, 첫 행부터 마지막 행까지 모두 순서대로 합친 새로운 배열을 return 하도록 solution 함수를 완성해주세요.
  

  • 제한사항
    • n은 1 이상 1,000 이하입니다.

제출한 코드 :

def solution(n):
    # 2차원 배열 초기화
    triangle = [[] for _ in range(n)]

    # 각 행의 길이 설정
    for i in range(n):
        triangle[i] = [0] * (i + 1)

    # 방향: 아래(0), 오른쪽(1), 위(2)
    dx = [1, 0, -1]
    dy = [0, 1, -1]

    x, y, num = 0, 0, 1
    direction = 0

    while num <= n * (n + 1) // 2:
        triangle[x][y] = num
        num += 1

        nx, ny = x + dx[direction], y + dy[direction]

        if nx < 0 or ny < 0 or nx >= n or ny > nx or triangle[nx][ny] != 0:
            direction = (direction + 1) % 3
            nx, ny = x + dx[direction], y + dy[direction]

        x, y = nx, ny

    # 2차원 배열을 일차원 배열로 변환
    result = []
    for row in triangle:
        result.extend(row)

    return result

연속된 부분 수열의 합 (연습 문제)

• 비내림차순으로 정렬된 수열이 주어질 때, 다음 조건을 만족하는 부분 수열을 찾으려고 합니다.
  

  • 기존 수열에서 임의의 두 인덱스의 원소와 그 사이의 원소를 모두 포함하는 부분 수열이어야 합니다.
  • 부분 수열의 합은 k입니다.
  • 합이 k인 부분 수열이 여러 개인 경우 길이가 짧은 수열을 찾습니다.
  • 길이가 짧은 수열이 여러 개인 경우 앞쪽(시작 인덱스가 작은)에 나오는 수열을 찾습니다.

  수열을 나타내는 정수 배열 sequence와 부분 수열의 합을 나타내는 정수 k가 매개변수로 주어질 때, 위 조건을 만족하는 부분 수열의 시작 인덱스와 마지막 인덱스를 배열에 담아 return 하는 solution 함수를 완성해주세요. 이때 수열의 인덱스는 0부터 시작합니다.

  • 제한사항
    • 5 ≤ sequence의 길이 ≤ 1,000,000
      • 1 ≤ sequence의 원소 ≤ 1,000
      • sequence는 비내림차순으로 정렬되어 있습니다.
    • 5 ≤ k ≤ 1,000,000,000
      • k는 항상 sequence의 부분 수열로 만들 수 있는 값입니다.

제출한 코드 :

def solution(sequence, k):
    n = len(sequence)
    start, end = 0, 0
    current_sum = sequence[0]
    min_length = float('inf')
    best_range = [0, 0]

    while start < n and end < n:
        if current_sum == k:
            if (end - start) < min_length:
                min_length = end - start
                best_range = [start, end]

            # Move start to reduce the window size
            current_sum -= sequence[start]
            start += 1
        elif current_sum < k:
            # Expand the window
            end += 1
            if end < n:
                current_sum += sequence[end]
        else:
            # Shrink the window
            current_sum -= sequence[start]
            start += 1

    return best_range

두 큐 합 같게 만들기 (2022 KAKAO TECH INTERNSHIP)

• 길이가 같은 두 개의 큐가 주어집니다. 하나의 큐를 골라 원소를 추출(pop)하고, 추출된 원소를 다른 큐에 집어넣는(insert) 작업을 통해 각 큐의 원소 합이 같도록 만들려고 합니다. 이때 필요한 작업의 최소 횟수를 구하고자 합니다. 한 번의 pop과 한 번의 insert를 합쳐서 작업을 1회 수행한 것으로 간주합니다.
  큐는 먼저 집어넣은 원소가 먼저 나오는 구조입니다. 이 문제에서는 큐를 배열로 표현하며, 원소가 배열 앞쪽에 있을수록 먼저 집어넣은 원소임을 의미합니다. 즉, pop을 하면 배열의 첫 번째 원소가 추출되며, insert를 하면 배열의 끝에 원소가 추가됩니다. 예를 들어 큐 [1, 2, 3, 4]가 주어졌을 때, pop을 하면 맨 앞에 있는 원소 1이 추출되어 [2, 3, 4]가 되며, 이어서 5를 insert하면 [2, 3, 4, 5]가 됩니다.
  다음은 두 큐를 나타내는 예시입니다.

   queue1 = [3, 2, 7, 2]
   queue2 = [4, 6, 5, 1]

         두 큐에 담긴 모든 원소의 합은 30입니다. 따라서, 각 큐의 합을 15로        만들어야 합니다. 예를 들어, 다음과 같이 2가지 방법이 있습니다.
          1. queue2의 4, 6, 5를 순서대로 추출하여 queue1에 추가한 뒤,           queue1의 3, 2, 7, 2를 순서대로 추출하여 queue2에 추가합니다. 그           결과 queue1은 [4, 6, 5], queue2는 [1, 3, 2, 7, 2]가 되며, 각 큐의 원소           합은 15로 같습니다. 이 방법은 작업을 7번 수행합니다.         2. queue1에서 3을 추출하여 queue2에 추가합니다. 그리고 queue2에서           4를 추출하여 queue1에 추가합니다. 그 결과 queue1은 [2, 7, 2, 4],           queue2는 [6, 5, 1, 3]가 되며, 각 큐의 원소 합은 15로 같습니다. 이           방법은 작업을 2번만 수행하며, 이보다 적은 횟수로 목표를 달성할 수           없습니다.
  

       따라서 각 큐의 원소 합을 같게 만들기 위해 필요한 작업의 최소 횟수는        2입니다.

       길이가 같은 두 개의 큐를 나타내는 정수 배열 queue1, queue2가        매개변수로 주어집니다. 각 큐의 원소 합을 같게 만들기 위해 필요한        작업의 최소 횟수를 return 하도록 solution 함수를 완성해주세요. 단,        어떤 방법으로도 각 큐의 원소 합을 같게 만들 수 없는 경우, -1을 return        해주세요.

• 제한사항
  • 1 ≤ queue1의 길이 = queue2의 길이 ≤ 300,000
  • 1 ≤ ``queue1의 원소, queue2의 원소 ≤ 109
    • 주의: 언어에 따라 합 계산 과정 중 산술 오버플로우 발생 가능성이 있으므로 long type 고려가 필요합니다.

제출한 코드 :

def solution(queue1, queue2):
    total_sum = sum(queue1) + sum(queue2)
    target_sum = total_sum // 2

    # 전체 합이 홀수라면 불가능
    if total_sum % 2 != 0:
        return -1

    combined = queue1 + queue2
    n = len(queue1)
    max_index = len(combined)

    start, end = 0, n
    current_sum = sum(queue1)
    min_operations = float('inf')

    while start < max_index and end < max_index:
        if current_sum == target_sum:
            min_operations = min(min_operations, (start + (end - n)))
            current_sum -= combined[start]
            start += 1
        elif current_sum < target_sum:
            if end < max_index:
                current_sum += combined[end]
                end += 1
            else:
                break
        else:
            current_sum -= combined[start]
            start += 1

    return min_operations if min_operations != float('inf') else -1

제출한 쿼리 :

SELECT (SALARY * MONTHS)
       , COUNT(*)
FROM EMPLOYEE
GROUP BY SALARY * MONTHS
ORDER BY SALARY * MONTHS DESC
LIMIT 1;

Weather Observation Station 13 (Aggregation)

제출한 쿼리 :

SELECT ROUND(SUM(LAT_N), 4)
FROM STATION
WHERE LAT_N BETWEEN '38.7880' AND '137.2345';

Weather Observation Station 14 (Aggregation)

제출한 쿼리 :

SELECT ROUND(MAX(LAT_N), 4)
FROM STATION 
WHERE LAT_N < '137.2345';

Weather Observation Station 15 (Aggregation)

제출한 쿼리 :

SELECT ROUND(LONG_W, 4)
FROM STATION
WHERE LAT_N < 137.2345
ORDER BY LAT_N DESC
LIMIT 1;

Weather Observation Station 16 (Aggregation)

제출한 쿼리 :

SELECT ROUND(MIN(LAT_N), 4)
FROM STATION
WHERE LAT_N > 38.7780

• 양의 정수 x에 대한 함수 f(x)를 다음과 같이 정의합니다.

  • x보다 크고 x와 비트가 1~2개 다른 수들 중에서 제일 작은 수 예를 들어,
  • f(2) = 3 입니다. 다음 표와 같이 2보다 큰 수들 중에서 비트가 다른 지점이 2개 이하이면서 제일 작은 수가 3이기 때문입니다.
    
    수 비트 다른   비트의 개수 2   000...0010
    3   000...0011  1
    f(7) = 11 입니다. 다음 표와 같이 7보다 큰 수들 중에서 비트가 다른 지점이 2개 이하이면서 제일 작은 수가 11이기 때문입니다.
    수  비트          다른 비트의 개수 7    000...0111
    8    000...1000   4 9    000...1001   3 10   000...1010   3 11   000...1011   2
    정수들이 담긴 배열 numbers가 매개변수로 주어집니다. numbers의 모든 수들에 대하여 각 수의 f 값을 배열에 차례대로 담아 return 하도록 solution 함수를 완성해주세요.
  • 제한사항
    • 1 ≤ numbers의 길이 ≤ 100,000
    • 0 ≤ numbers의 모든 수 ≤ 10^15

제출한 코드 :

def solution(numbers):
    result = []
    for x in numbers:
        if x % 2 == 0:
            result.append(x + 1)
        else:
            # x의 가장 낮은 0 비트를 1로 바꾸고, 그 다음 비트를 0으로 바꾼다.
            bit = 1
            while x & bit:
                bit <<= 1
            result.append(x + bit - (bit >> 1))
    return result

다리를 지나는 트럭 (스택/큐)

• 트럭 여러 대가 강을 가로지르는 일차선 다리를 정해진 순으로 건너려 합니다. 모든 트럭이 다리를 건너려면 최소 몇 초가 걸리는지 알아내야 합니다. 다리에는 트럭이 최대 bridge_length대 올라갈 수 있으며, 다리는 weight 이하까지의 무게를 견딜 수 있습니다. 단, 다리에 완전히 오르지 않은 트럭의 무게는 무시합니다.
  예를 들어, 트럭 2대가 올라갈 수 있고 무게를 10kg까지 견디는 다리가 있습니다. 무게가 [7, 4, 5, 6]kg인 트럭이 순서대로 최단 시간 안에 다리를 건너려면 다음과 같이 건너야 합니다.
  경과 시간 다리를 지난 트럭 다리를 건너는 트럭 대기 트럭 0             []                     []                         [7,4,5,6] 12         []                     [7]                        [4,5,6] 3             [7]                   [4]                        [5,6] 4             [7]                   [4,5]                      [6] 5             [7,4]                 [5]                        [6] 67          [7,4,5]              [6]                        [] 8             [7,4,5,6]             []                         []
  따라서, 모든 트럭이 다리를 지나려면 최소 8초가 걸립니다.
  solution 함수의 매개변수로 다리에 올라갈 수 있는 트럭 수 bridge_length, 다리가 견딜 수 있는 무게 weight, 트럭 별 무게 truck_weights가 주어집니다. 이때 모든 트럭이 다리를 건너려면 최소 몇 초가 걸리는지 return 하도록 solution 함수를 완성하세요.
  

  • 제한사항
    • bridge_length는 1 이상 10,000 이하입니다.
    • weight는 1 이상 10,000 이하입니다.
    • truck_weights의 길이는 1 이상 10,000 이하입니다.
    • 모든 트럭의 무게는 1 이상 weight 이하입니다.

제출한 코드 :

from collections import deque

def solution(bridge_length, weight, truck_weights):
    time = 0
    bridge_queue = deque([0] * bridge_length)  # 다리 길이만큼의 큐 생성
    bridge_weight = 0  # 현재 다리 위 트럭들의 총 무게

    for truck in truck_weights:
        while True:
            time += 1
            bridge_weight -= bridge_queue.popleft()  # 다리에서 트럭이 나가는 경우 무게 감소
            if bridge_weight + truck <= weight:  # 새로운 트럭이 올라올 수 있는지 확인
                bridge_queue.append(truck)
                bridge_weight += truck
                break
            else:
                bridge_queue.append(0)  # 트럭이 올라올 수 없으면 0을 추가하여 다리 상태 유지

    # 마지막 트럭이 다리 위에 올라간 후 다리 길이만큼 시간이 더 필요
    time += bridge_length
    return time

가장 큰 수 (정렬)

• 0 또는 양의 정수가 주어졌을 때, 정수를 이어 붙여 만들 수 있는 가장 큰 수를 알아내 주세요.
  예를 들어, 주어진 정수가 [6, 10, 2]라면 [6102, 6210, 1062, 1026, 2610, 2106]를 만들 수 있고, 이중 가장 큰 수는 6210입니다.
  0 또는 양의 정수가 담긴 배열 numbers가 매개변수로 주어질 때, 순서를 재배치하여 만들 수 있는 가장 큰 수를 문자열로 바꾸어 return 하도록 solution 함수를 작성해주세요.
  - 제한사항 - numbers의 길이는 1 이상 100,000 이하입니다. - numbers의 원소는 0 이상 1,000 이하입니다. - 정답이 너무 클 수 있으니 문자열로 바꾸어 return 합니다.

제출한 코드 :

from functools import cmp_to_key

def compare(x, y):
    if x + y > y + x:
        return -1
    elif x + y < y + x:
        return 1
    else:
        return 0

def solution(numbers):
    # numbers를 문자열로 변환
    numbers = list(map(str, numbers))
    # 커스텀 정렬 기준으로 정렬
    numbers.sort(key=cmp_to_key(compare))
    # 정렬된 숫자들을 이어붙임
    answer = ''.join(numbers)
    # 앞자리 0 처리 (e.g., [0, 0]인 경우 '00' -> '0')
    return answer if answer[0] != '0' else '0'

소수 찾기 (완전탐색)

• 한자리 숫자가 적힌 종이 조각이 흩어져있습니다. 흩어진 종이 조각을 붙여 소수를 몇 개 만들 수 있는지 알아내려 합니다.
  각 종이 조각에 적힌 숫자가 적힌 문자열 numbers가 주어졌을 때, 종이 조각으로 만들 수 있는 소수가 몇 개인지 return 하도록 solution 함수를 완성해주세요.

  
  
  • 제한사항
    • numbers는 길이 1 이상 7 이하인 문자열입니다.
    • numbers는 0~9까지 숫자만으로 이루어져 있습니다.
      • "013"은 0, 1, 3 숫자가 적힌 종이 조각이 흩어져있다는 의미입니다.

제출한 코드 :

from itertools import permutations

# 소수 판별 함수
def is_prime(n):
    if n <= 1:
        return False
    if n == 2:
        return True
    if n % 2 == 0:
        return False
    for i in range(3, int(n**0.5) + 1, 2):
        if n % i == 0:
            return False
    return True

def solution(numbers):
    # 모든 숫자 조합을 생성
    num_set = set()
    for i in range(1, len(numbers) + 1):
        perms = permutations(numbers, i)
        for perm in perms:
            num = int(''.join(perm))
            num_set.add(num)

    # 소수 판별 후 카운트
    prime_count = 0
    for num in num_set:
        if is_prime(num):
            prime_count += 1

    return prime_count

쿼드압축 후 개수 세기 (월간 코드 챌린지 시즌1)

• 0과 1로 이루어진 2n x 2n 크기의 2차원 정수 배열 arr이 있습니다. 당신은 이 arr을 쿼드 트리와 같은 방식으로 압축하고자 합니다. 구체적인 방식은 다음과 같습니다.
  

  1. 당신이 압축하고자 하는 특정 영역을 S라고 정의합니다.
  2. 만약 S 내부에 있는 모든 수가 같은 값이라면, S를 해당 수 하나로 압축시킵니다.
  3. 그렇지 않다면, S를 정확히 4개의 균일한 정사각형 영역(입출력 예를 참고해주시기 바랍니다.)으로 쪼갠 뒤, 각 정사각형 영역에 대해 같은 방식의 압축을 시도합니다.

  arr이 매개변수로 주어집니다. 위와 같은 방식으로 arr을 압축했을 때, 배열에 최종적으로 남는 0의 개수와 1의 개수를 배열에 담아서 return 하도록 solution 함수를 완성해주세요.

  
  
  • 제한사항
    • arr의 행의 개수는 1 이상 1024 이하이며, 2의 거듭 제곱수 형태를 하고 있습니다. 즉, arr의 행의 개수는 1, 2, 4, 8, ..., 1024 중 하나입니다.
      • arr의 각 행의 길이는 arr의 행의 개수와 같습니다. 즉, arr은 정사각형 배열입니다.
      • arr의 각 행에 있는 모든 값은 0 또는 1 입니다.

제출한 코드 :

def solution(arr):
    def compress(x, y, size):
        initial = arr[x][y]
        all_same = True

        for i in range(x, x + size):
            for j in range(y, y + size):
                if arr[i][j] != initial:
                    all_same = False
                    break
            if not all_same:
                break

        if all_same:
            if initial == 0:
                result[0] += 1
            else:
                result[1] += 1
        else:
            new_size = size // 2
            compress(x, y, new_size)
            compress(x, y + new_size, new_size)
            compress(x + new_size, y, new_size)
            compress(x + new_size, y + new_size, new_size)

    n = len(arr)
    result = [0, 0]
    compress(0, 0, n)
    return result

반복해서 사용할수록 SQL/파이썬은 적응 되지만 폭언은...

들어도 들어도 적응이 안 돼ㅋ 그냥 빨리 이 집구석에서 탈출하고 싶음. 내 마음의 자유를 위해서는 무조건 취업해서 독립하는게 장땡인데, 무작정 아무데나 취업하기는 무섭다. 진짜 어떤 회사든 간에 처음으로 붙은 회사 가버려? 이게 맞아? 내 미래/커리어를 위한 회사여야 하는데 어째 나는 회사 선택/취업을 도피의 수단으로 쓰고 있는건지.

통계

새로운 것 투성이, 그러나 재밌는

분명 학교에서 통계 배웠을 때는 안 재밌었던 것 같은데 다시 시작하니까 생각보다 재밌다. 어렵기는 한데, 뭔가 하나하나 적용시켜보고 따져보는게 재밌달까? 통계의 세계는 생각보다 넓더라.

다짐

무너지지 말아야 한다 내 자신아

버텨!!!!!! 제발... 이러는거 하루이틀도 아닌데 여기서 무너지면 안된다.

• 주차장의 요금표와 차량이 들어오고(입차) 나간(출차) 기록이 주어졌을 때, 차량별로 주차 요금을 계산하려고 합니다. 아래는 하나의 예시를 나타냅니다.
  
  • 요금표 기본 시간(분) 기본 요금(원) 단위 시간(분) 단위 요금(원) 180             5000            10               600
    
  • 입/출차 기록 시각(시:분) 차량 번호 내역 05:34        5961       입차 06:00        0000       입차 06:34        0000       출차 07:59        5961       출차 07:59        0148       입차 18:59        0000       입차 19:09        0148       출차 22:59        5961       입차 23:00        5961       출차
    
  • 자동차별 주차 요금 차량 번호 누적 주차 시간(분) 주차 요금(원) 0000        34 + 300 = 334    5000 + ⌈(334 - 180) / 10⌉ x 600 =                                        14600 0148        670                    5000 +⌈(670 - 180) / 10⌉x 600 =                                        34400 5961        145 + 1 = 146      5000
    
  • 어떤 차량이 입차된 후에 출차된 내역이 없다면, 23:59에 출차된 것으로 간주합니다.
    • 0000번 차량은 18:59에 입차된 이후, 출차된 내역이 없습니다. 따라서, 23:59에 출차된 것으로 간주합니다.
  • 00:00부터 23:59까지의 입/출차 내역을 바탕으로 차량별 누적 주차 시간을 계산하여 요금을 일괄로 정산합니다.
  • 누적 주차 시간이 기본 시간이하라면, 기본 요금을 청구합니다.
  • 누적 주차 시간이 기본 시간을 초과하면, 기본 요금에 더해서 초과한 시간에 대해서 단위 시간 마다 단위 요금을 청구합니다.
    • 초과한 시간이 단위 시간으로 나누어 떨어지지 않으면, ``올림합니다.
    • ⌈a⌉ : a보다 작지 않은 최소의 정수를 의미합니다. 즉, 올림을 의미합니다.

      주차 요금을 나타내는 정수 배열 fees, 자동차의 입/출차 내역을       나타내는 문자열 배열 records가 매개변수로 주어집니다. 차량 번호가       작은 자동차부터 청구할 주차 요금을 차례대로 정수 배열에 담아서       return 하도록 solution 함수를 완성해주세요.
           - 제한사항               - fees의 길이 = 4                 - fees[0] = 기본 시간(분)                 - 1 ≤ fees[0] ≤ 1,439                 - fees[1] = 기본 요금(원)                 - 0 ≤ fees[1] ≤ 100,000                 - fees[2] = 단위 시간(분)                 - 1 ≤ fees[2] ≤ 1,439                 - fees[3] = 단위 요금(원)                 - 1 ≤ fees[3] ≤ 10,000               - 1 ≤ records의 길이 ≤ 1,000                 - records의 각 원소는 "시각 차량번호 내역" 형식의                   문자열입니다.
                - 시각, 차량번호, 내역은 하나의 공백으로 구분되어 있습니다.
                - 시각은 차량이 입차되거나 출차된 시각을 나타내며, HH:MM                   형식의 길이 5인 문자열입니다.                     - HH:MM은 00:00부터 23:59까지 주어집니다.
                    - 잘못된 시각("25:22", "09:65" 등)은 입력으로 주어지지                      않습니다.
                 - 차량번호는 자동차를 구분하기 위한, '0'~'9'로 구성된 길이 4인                   문자열입니다.                 - 내역은 길이 2 또는 3인 문자열로, IN 또는 OUT입니다.                   IN은 입차를, OUT은 출차를 의미합니다.                  - records의 원소들은 시각을 기준으로 오름차순으로 정렬되어                   주어집니다.
                 - records는 하루 동안의 입/출차된 기록만 담고 있으며,                   입차된 차량이 다음날 출차되는 경우는 입력으로 주어지지                   않습니다.
                 - 같은 시각에, 같은 차량번호의 내역이 2번 이상 나타내지                   않습니다.                  - 마지막 시각(23:59)에 입차되는 경우는 입력으로 주어지지                   않습니다.                  - 아래의 예를 포함하여, 잘못된 입력은 주어지지 않습니다                     - 주차장에 없는 차량이 출차되는 경우
                    - 주차장에 이미 있는 차량(차량번호가 같은 차량)이 다시                      입차되는 경우

제출한 코드 :

from math import ceil

def time_to_minutes(time):
    """시간을 분으로 변환"""
    h, m = map(int, time.split(':'))
    return h * 60 + m

def calculate_fee(total_time, fees):
    """주차 요금을 계산"""
    base_time, base_fee, unit_time, unit_fee = fees
    if total_time <= base_time:
        return base_fee
    else:
        extra_time = total_time - base_time
        extra_fee = ceil(extra_time / unit_time) * unit_fee
        return base_fee + extra_fee

def solution(fees, records):
    parking_times = {}
    in_parking = {}

    for record in records:
        time, car_number, status = record.split()
        time = time_to_minutes(time)

        if status == 'IN':
            in_parking[car_number] = time
        elif status == 'OUT':
            if car_number in in_parking:
                in_time = in_parking.pop(car_number)
                parked_time = time - in_time
                if car_number in parking_times:
                    parking_times[car_number] += parked_time
                else:
                    parking_times[car_number] = parked_time

    # 23:59 출차 처리를 위해
    end_time = time_to_minutes("23:59")
    for car_number, in_time in in_parking.items():
        parked_time = end_time - in_time
        if car_number in parking_times:
            parking_times[car_number] += parked_time
        else:
            parking_times[car_number] = parked_time

    result = []
    for car_number in sorted(parking_times.keys()):
        total_time = parking_times[car_number]
        fee = calculate_fee(total_time, fees)
        result.append(fee)

    return result

모음사전 (완전탐색)

• 사전에 알파벳 모음 'A', 'E', 'I', 'O', 'U'만을 사용하여 만들 수 있는, 길이 5 이하의 모든 단어가 수록되어 있습니다. 사전에서 첫 번째 단어는 "A"이고, 그다음은 "AA"이며, 마지막 단어는 "UUUUU"입니다.
  단어 하나 word가 매개변수로 주어질 때, 이 단어가 사전에서 몇 번째 단어인지 return 하도록 solution 함수를 완성해주세요.

    <bR>

  • 제한사항
    • word의 길이는 1 이상 5 이하입니다.
    • word는 알파벳 대문자 'A', 'E', 'I', 'O', 'U'로만 이루어져 있습니다.

제출한 코드 :

def solution(word):
    # 각 자리별 가중치를 설정
    weights = [781, 156, 31, 6, 1]
    vowels = ['A', 'E', 'I', 'O', 'U']

    result = 0

    for i, char in enumerate(word):
        # 현재 자리의 단어가 몇 번째 모음인지 확인
        index = vowels.index(char)
        # 각 자리의 위치를 계산해서 더하기
        result += weights[i] * index + 1

    return result

뒤에 있는 큰 수 찾기 (연습문제)

• 정수로 이루어진 배열 numbers가 있습니다. 배열 의 각 원소들에 대해 자신보다 뒤에 있는 숫자 중에서 자신보다 크면서 가장 가까이 있는 수를 뒷 큰수라고 합니다.
  정수 배열 numbers가 매개변수로 주어질 때, 모든 원소에 대한 뒷 큰수들을 차례로 담은 배열을 return 하도록 solution 함수를 완성해주세요. 단, 뒷 큰수가 존재하지 않는 원소는 -1을 담습니다.

      <bR>

  • 제한사항
    • 4 ≤ numbers의 길이 ≤ 1,000,000
      • 1 ≤ numbers[i] ≤ 1,000,000

제출한 코드 :

def solution(numbers):
    n = len(numbers)
    answer = [-1] * n
    stack = []

    for i in range(n - 1, -1, -1):
        # 스택이 비어 있지 않고, 현재 숫자가 스택의 top보다 크거나 같으면 pop
        while stack and stack[-1] <= numbers[i]:
            stack.pop()

        # 스택이 비어 있지 않다면, top이 뒷 큰수가 됨
        if stack:
            answer[i] = stack[-1]

        # 현재 숫자를 스택에 추가
        stack.append(numbers[i])

    return answer

롤케이크 자르기 (연습문제)

• 철수는 롤케이크를 두 조각으로 잘라서 동생과 한 조각씩 나눠 먹으려고 합니다. 이 롤케이크에는 여러가지 토핑들이 일렬로 올려져 있습니다. 철수와 동생은 롤케이크를 공평하게 나눠먹으려 하는데, 그들은 롤케이크의 크기보다 롤케이크 위에 올려진 토핑들의 종류에 더 관심이 많습니다. 그래서 잘린 조각들의 크기와 올려진 토핑의 개수에 상관없이 각 조각에 동일한 가짓수의 토핑이 올라가면 공평하게 롤케이크가 나누어진 것으로 생각합니다.
  예를 들어, 롤케이크에 4가지 종류의 토핑이 올려져 있다고 합시다. 토핑들을 1, 2, 3, 4와 같이 번호로 표시했을 때, 케이크 위에 토핑들이 [1, 2, 1, 3, 1, 4, 1, 2] 순서로 올려져 있습니다. 만약 세 번째 토핑(1)과 네 번째 토핑(3) 사이를 자르면 롤케이크의 토핑은 [1, 2, 1], [3, 1, 4, 1, 2]로 나뉘게 됩니다. 철수가 [1, 2, 1]이 놓인 조각을, 동생이 [3, 1, 4, 1, 2]가 놓인 조각을 먹게 되면 철수는 두 가지 토핑(1, 2)을 맛볼 수 있지만, 동생은 네 가지 토핑(1, 2, 3, 4)을 맛볼 수 있으므로, 이는 공평하게 나누어진 것이 아닙니다. 만약 롤케이크의 네 번째 토핑(3)과 다섯 번째 토핑(1) 사이를 자르면 [1, 2, 1, 3], [1, 4, 1, 2]로 나뉘게 됩니다. 이 경우 철수는 세 가지 토핑(1, 2, 3)을, 동생도 세 가지 토핑(1, 2, 4)을 맛볼 수 있으므로, 이는 공평하게 나누어진 것입니다. 공평하게 롤케이크를 자르는 방법은 여러가지 일 수 있습니다. 위의 롤케이크를 [1, 2, 1, 3, 1], [4, 1, 2]으로 잘라도 공평하게 나뉩니다. 어떤 경우에는 롤케이크를 공평하게 나누지 못할 수도 있습니다.
  롤케이크에 올려진 토핑들의 번호를 저장한 정수 배열 topping이 매개변수로 주어질 때, 롤케이크를 공평하게 자르는 방법의 수를 return 하도록 solution 함수를 완성해주세요.

        <BR>

  • 제한사항
    • 1 ≤ topping의 길이 ≤ 1,000,000
      • 1 ≤ topping의 원소 ≤ 10,000

제출한 코드 :

def solution(topping):
    from collections import defaultdict

    left_set = set()
    right_count = defaultdict(int)

    # 오른쪽 집합에 모든 토핑의 개수 세기
    for t in topping:
        right_count[t] += 1

    # 공평하게 나눌 수 있는 위치의 수
    fair_cuts = 0

    # 각 위치에서 자를 때 왼쪽과 오른쪽의 토핑 종류 수를 비교
    for t in topping:
        # 현재 토핑을 왼쪽으로 이동
        left_set.add(t)
        right_count[t] -= 1

        # 오른쪽에 더 이상 존재하지 않으면 집합에서 제거
        if right_count[t] == 0:
            del right_count[t]

        # 공평하게 나눌 수 있는지 확인
        if len(left_set) == len(right_count):
            fair_cuts += 1

    return fair_cuts

숫자 변환하기 (연습문제)

• 자연수 x를 y로 변환하려고 합니다. 사용할 수 있는 연산은 다음과 같습니다.

          <BR>

  • x에 n을 더합니다
  • x에 2를 곱합니다.
  • x에 3을 곱합니다.

       자연수 x, y, n이 매개변수로 주어질 때, x를 y로 변환하기 위해        필요한 최소 연산 횟수를 return하도록 solution 함수를 완성해주세요.        이때 x를 y로 만들 수 없다면 -1을 return 해주세요.

       - 제한사항          - 1 ≤ x ≤ y ≤ 1,000,000          - 1 ≤ n < y

제출한 코드 :

from collections import deque

def solution(x, y, n):
    if x == y:
        return 0

    # BFS를 위한 큐 초기화: (현재 값, 연산 횟수)
    queue = deque([(x, 0)])
    visited = set()  # 방문한 값을 기록

    while queue:
        current, operations = queue.popleft()

        # 다음 가능한 연산들을 수행
        for next_value in (current + n, current * 2, current * 3):
            if next_value == y:
                return operations + 1
            if next_value < y and next_value not in visited:
                visited.add(next_value)
                queue.append((next_value, operations + 1))

    # 큐를 다 돌 때까지 목표 값을 찾지 못한 경우
    return -1

• 프로그래머스 팀에서는 기능 개선 작업을 수행 중입니다. 각 기능은 진도가 100%일 때 서비스에 반영할 수 있습니다.
  또, 각 기능의 개발속도는 모두 다르기 때문에 뒤에 있는 기능이 앞에 있는 기능보다 먼저 개발될 수 있고, 이때 뒤에 있는 기능은 앞에 있는 기능이 배포될 때 함께 배포됩니다.
  먼저 배포되어야 하는 순서대로 작업의 진도가 적힌 정수 배열 progresses와 각 작업의 개발 속도가 적힌 정수 배열 speeds가 주어질 때 각 배포마다 몇 개의 기능이 배포되는지를 return 하도록 solution 함수를 완성하세요.
  - 제한사항 - 작업의 개수(progresses, speeds배열의 길이)는 100개 이하입니다. - 작업 진도는 100 미만의 자연수입니다. - 작업 속도는 100 이하의 자연수입니다. - 배포는 하루에 한 번만 할 수 있으며, 하루의 끝에 이루어진다고 가정합니다. 예를 들어 진도율이 95%인 작업의 개발 속도가 하루에 4%라면 배포는 2일 뒤에 이루어집니다.

제출한 코드 :

import math

def solution(progresses, speeds):
    # 각 작업이 완료되는데 필요한 일수 계산
    days = [math.ceil((100 - p) / s) for p, s in zip(progresses, speeds)]

    # 배포 결과를 저장할 리스트
    result = []

    # 첫 번째 작업의 완료 일수
    current_max_day = days[0]
    count = 0

    for day in days:
        if day > current_max_day:
            result.append(count)
            current_max_day = day
            count = 1
        else:
            count += 1

    # 마지막 배포 그룹 추가
    result.append(count)

    return result

프로세스 (스택/큐)

• 운영체제의 역할 중 하나는 컴퓨터 시스템의 자원을 효율적으로 관리하는 것입니다. 이 문제에서는 운영체제가 다음 규칙에 따라 프로세스를 관리할 경우 특정 프로세스가 몇 번째로 실행되는지 알아내면 됩니다.
  1. 실행 대기 큐(Queue)에서 대기중인 프로세스 하나를 꺼냅니다.
     2. 큐에 대기중인 프로세스 중 우선순위가 더 높은 프로세스가 있다면 방금 꺼낸 프로세스를 다시 큐에 넣습니다.
     3. 만약 그런 프로세스가 없다면 방금 꺼낸 프로세스를 실행합니다.
     4. 1 한 번 실행한 프로세스는 다시 큐에 넣지 않고 그대로 종료됩니다.
        

      예를 들어 프로세스 4개 [A, B, C, D]가 순서대로 실행 대기 큐에       들어있고, 우선순위가 [2, 1, 3, 2]라면 [C, D, A, B] 순으로 실행하게       됩니다.

       현재 실행 대기 큐(Queue)에 있는 프로세스의 중요도가 순서대로 담긴       배열 priorities와, 몇 번째로 실행되는지 알고싶은 프로세스의 위치를       알려주는 location이 매개변수로 주어질 때, 해당 프로세스가 몇 번째로       실행되는지 return 하도록 solution 함수를 작성해주세요.

• 제한사항
  • priorities의 길이는 1 이상 100 이하입니다.
    • priorities의 원소는 1 이상 9 이하의 정수입니다.
      • priorities의 원소는 우선순위를 나타내며 숫자가 클 수록    우선순위가 높습니다.
  • location은 0 이상 (대기 큐에 있는 프로세스 수 - 1) 이하의 값을 가집니다.
    • priorities의 가장 앞에 있으면 0, 두 번째에 있으면 1 … 과 같이    표현합니다.

제출한 코드 :

from collections import deque

def solution(priorities, location):
    # 프로세스와 초기 위치를 큐에 저장
    queue = deque([(p, i) for i, p in enumerate(priorities)])
    # 실행 순서 카운터
    order = 0

    while queue:
        # 큐의 맨 앞에 있는 프로세스
        current = queue.popleft()

        # 큐에 남아있는 프로세스 중 우선순위가 더 높은 것이 있는지 확인
        if any(current[0] < q[0] for q in queue):
            # 현재 프로세스를 다시 큐의 끝에 넣음
            queue.append(current)
        else:
            # 현재 프로세스를 실행
            order += 1
            # 현재 프로세스가 목표 프로세스인지 확인
            if current[1] == location:
                return order

피로도 (완전탐색)

• XX게임에는 피로도 시스템(0 이상의 정수로 표현합니다)이 있으며, 일정 피로도를 사용해서 던전을 탐험할 수 있습니다. 이때, 각 던전마다 탐험을 시작하기 위해 필요한 "최소 필요 피로도"와 던전 탐험을 마쳤을 때 소모되는 "소모 피로도"가 있습니다. "최소 필요 피로도"는 해당 던전을 탐험하기 위해 가지고 있어야 하는 최소한의 피로도를 나타내며, "소모 피로도"는 던전을 탐험한 후 소모되는 피로도를 나타냅니다. 예를 들어 "최소 필요 피로도"가 80, "소모 피로도"가 20인 던전을 탐험하기 위해서는 유저의 현재 남은 피로도는 80 이상 이어야 하며, 던전을 탐험한 후에는 피로도 20이 소모됩니다.
  이 게임에는 하루에 한 번씩 탐험할 수 있는 던전이 여러개 있는데, 한 유저가 오늘 이 던전들을 최대한 많이 탐험하려 합니다. 유저의 현재 피로도 k와 각 던전별 "최소 필요 피로도", "소모 피로도"가 담긴 2차원 배열 dungeons 가 매개변수로 주어질 때, 유저가 탐험할수 있는 최대 던전 수를 return 하도록 solution 함수를 완성해주세요.
  - 제한사항 - k는 1 이상 5,000 이하인 자연수입니다. - dungeons의 세로(행) 길이(즉, 던전의 개수)는 1 이상 8 이하 입니다.  - dungeons의 가로(열) 길이는 2 입니다.  - dungeons의 각 행은 각 던전의 ["최소 필요 피로도", "소모   피로도"] 입니다. - "최소 필요 피로도"는 항상 "소모 피로도"보다 크거나    같습니다. - "최소 필요 피로도"와 "소모 피로도"는 1 이상 1,000 이하인    자연수입니다.  - 서로 다른 던전의 ["최소 필요 피로도", "소모 피로도"]가   서로 같을 수 있습니다.

제출한 코드 :

from itertools import permutations

def solution(k, dungeons):
    max_dungeons = 0
    n = len(dungeons)

    for perm in permutations(dungeons):
        current_fatigue = k
        explored_dungeons = 0

        for required, consume in perm:
            if current_fatigue >= required:
                current_fatigue -= consume
                explored_dungeons += 1
            else:
                break

        max_dungeons = max(max_dungeons, explored_dungeons)

    return max_dungeons

타겟 넘버 (깊이/너비 우선 탐색(DFS/BFS))

• n개의 음이 아닌 정수들이 있습니다. 이 정수들을 순서를 바꾸지 않고 적절히 더하거나 빼서 타겟 넘버를 만들려고 합니다. 예를 들어 [1, 1, 1, 1, 1]로 숫자 3을 만들려면 다음 다섯 방법을 쓸 수 있습니다.
  
• 1+1+1+1+1 = 3
• 1-1+1+1+1 = 3
• 1+1-1+1+1 = 3
• 1+1+1-1+1 = 3
• 1+1+1+1-1 = 3
  사용할 수 있는 숫자가 담긴 배열 numbers, 타겟 넘버 target이 매개변수로 주어질 때 숫자를 적절히 더하고 빼서 타겟 넘버를 만드는 방법의 수를 return 하도록 solution 함수를 작성해주세요.
  - 제한사항 - 주어지는 숫자의 개수는 2개 이상 20개 이하입니다. - 각 숫자는 1 이상 50 이하인 자연수입니다. - 타겟 넘버는 1 이상 1000 이하인 자연수입니

제출한 코드 :

def solution(numbers, target):
    def dfs(index, current_sum):
        # 기저 사례: 인덱스가 numbers의 길이와 같으면 현재 합이 타겟과 같은지 확인
        if index == len(numbers):
            return 1 if current_sum == target else 0

        # 현재 숫자를 더하는 경우와 빼는 경우를 재귀 호출
        add_case = dfs(index + 1, current_sum + numbers[index])
        subtract_case = dfs(index + 1, current_sum - numbers[index])

        # 두 경우의 수를 합산하여 반환
        return add_case + subtract_case

    # 재귀 호출 시작
    return dfs(0, 0)

k진수에서 소수 개수 구하기 (2022 KAKAO BLIND RECRUITMENT)

• 양의 정수 n이 주어집니다. 이 숫자를 k진수로 바꿨을 때, 변환된 수 안에 아래 조건에 맞는 소수(Prime number)가 몇 개인지 알아보려 합니다.
  - `0P0`처럼 소수 양쪽에 0이 있는 경우 - `P0`처럼 소수 오른쪽에만 0이 있고 왼쪽에는 아무것도 없는 경우 - `0P`처럼 소수 왼쪽에만 0이 있고 오른쪽에는 아무것도 없는 경우 - `P`처럼 소수 양쪽에 아무것도 없는 경우 - 단, `P`는 각 자릿수에 0을 포함하지 않는 소수입니다. - 예를 들어, 101은 `P`가 될 수 없습니다.
  

       예를 들어, 437674을 3진수로 바꾸면 211020101011입니다. 여기서        찾을 수 있는 조건에 맞는 소수는 왼쪽부터 순서대로 211, 2, 11이        있으며, 총 3개입니다. (211, 2, 11을 k진법으로 보았을 때가 아닌,        10진법으로 보았을 때 소수여야 한다는 점에 주의합니다.) 211은 P0        형태에서 찾을 수 있으며, 2는 0P0에서, 11은 0P에서 찾을 수        있습니다.

       정수 n과 k가 매개변수로 주어집니다. n을 k진수로 바꿨을 때,        변환된 수 안에서 찾을 수 있는 위 조건에 맞는 소수의 개수를 return        하도록 solution 함수를 완성해 주세요.
       - 제한사항           - 1 ≤ n ≤ 1,000,000           - 3 ≤ k ≤ 10

제출한 코드 :

def is_prime(num):
    if num <= 1:
        return False
    if num == 2:
        return True
    if num % 2 == 0:
        return False
    sqrt_n = int(num ** 0.5) + 1
    for divisor in range(3, sqrt_n, 2):
        if num % divisor == 0:
            return False
    return True

def convert_to_base_k(n, k):
    result = ''
    while n > 0:
        result = str(n % k) + result
        n //= k
    return result

def solution(n, k):
    base_k_number = convert_to_base_k(n, k)
    candidates = base_k_number.split('0')

    count_primes = 0
    for candidate in candidates:
        if candidate and is_prime(int(candidate)):
            count_primes += 1

    return count_primes

제출한 쿼리 :

SELECT AVG(POPULATION)
FROM CITY
WHERE DISTRICT = 'California';

Revising Aggregations - Averages (Aggregation)

제출한 쿼리 :

SELECT AVG(POPULATION)
FROM CITY
WHERE DISTRICT = 'California';

Average Population (Aggregation)

제출한 쿼리 :

SELECT FLOOR(AVG(POPULATION))
FROM CITY;

FLOOR : 주어진 숫자보다 작거나 같은 가장 큰 정수 반환 (내림) ROUND : 주어진 숫자를 소수점 이하 특정 자릿수로 반올림 TRUNC : 주어진 숫자를 소수점 이하 특정 자릿수로 잘라냄 (버림) CEIL : 주어진 숫자보다 크거나 같은 가장 작은 정수 (올림)

# FLOOR
SELECT FLOOR(4.7);  # 결과 : 4
SELECT FLOOR(-4.7); # 결과 : -5

# ROUND
# 두 번째 인수로 반올림할 자릿수 지정 가능, 기본값 0
SELECT ROUND(4.567, 2);  # 결과 : 4.57
SELECT ROUND(4.567);     # 결과 : 5
SELECT ROUND(-4.567);    # 결과 : -5

# TRUNC
# 두 번째 인수로 잘라낼 자릿수 지정 가능, 기본값 0
SELECT TRUNC(4.567, 2);  # 결과 : 4.56
SELECT TRUNC(4.567);     # 결과 : 4
SELECT TRUNC(-4.567);    # 결과 : -4

# CEIL
SELECT CEIL(4.3);  # 결과 : 5
SELECT CEIL(-4.3); # 결과 : -4

Japan Population (Aggregation)

제출한 쿼리 :

SELECT SUM(POPULATION)
FROM CITY
WHERE COUNTRYCODE = 'JPN';

Population Density Difference (Aggregation)

제출한 쿼리 :

SELECT MAX(POPULATION) - MIN(POPULATION)
FROM CITY;

The Blunder (Aggregation)

제출한 쿼리 :

SELECT CEIL((AVG(SALARY)) - (AVG(REPLACE(SALARY, '0', '')))) AS AVG_SALARY
FROM EMPLOYEES;

제출한 쿼리 :

SELECT NAME
FROM EMPLOYEE
WHERE SALARY > 2000
    AND MONTHS < 10
ORDER BY EMPLOYEE_ID ASC;

Type of Triangle (Advanced Select)

제출한 쿼리 :

SELECT CASE WHEN (A = B AND B = C) THEN 'Equilateral'
            WHEN ((A + B <= C) OR (B + C <= A) OR (A + C <= B)) THEN 'Not A Triangle'
            WHEN ((A = B) OR (B = C) OR (A = C)) THEN 'Isosceles'
       ELSE 'Scalene'
       END AS triangle_type
FROM TRIANGLES;

The PADS (Advanced Select)

제출한 쿼리 :

SELECT CONCAT(Name, '(', LEFT(Occupation, 1), ')') AS Name_Occupation
FROM OCCUPATIONS
ORDER BY Name_Occupation;

SELECT  CONCAT('There are a total of ', COUNT(Occupation), ' ', LOWER(Occupation), 's.') AS Occupation_Count
FROM OCCUPATIONS
GROUP BY Occupation
ORDER BY COUNT(Occupation), Occupation;

Revising Aggregations - The Count Function (Aggregation)

제출한 쿼리 :

SELECT COUNT(NAME)
FROM CITY
WHERE POPULATION > 100000

Revising Aggregations - The Sum Function (Aggregation)

제출한 쿼리 :

SELECT SUM(POPULATION)
FROM CITY
WHERE DISTRICT = 'California'

• H-Index는 과학자의 생산성과 영향력을 나타내는 지표입니다. 어느 과학자의 H-Index를 나타내는 값인 h를 구하려고 합니다. 위키백과에 따르면, H-Index는 다음과 같이 구합니다.
  어떤 과학자가 발표한 논문 n편 중, h번 이상 인용된 논문이 h편 이상이고 나머지 논문이 h번 이하 인용되었다면 h의 최댓값이 이 과학자의 H-Index입니다.
  어떤 과학자가 발표한 논문의 인용 횟수를 담은 배열 citations가 매개변수로 주어질 때, 이 과학자의 H-Index를 return 하도록 solution 함수를 작성해주세요.

  • 제한사항
    • 과학자가 발표한 논문의 수는 1편 이상 1,000편 이하입니다.
    • 논문별 인용 횟수는 0회 이상 10,000회 이하입니다.

제출한 코드 :

def solution(citations):
    citations.sort(reverse=True)  

    h_index = 0
    for i, citation in enumerate(citations):
        if citation >= i + 1:  # 현재 논문의 인용 횟수가 현재 순위보다 크거나 같으면 h-index 갱신
            h_index = i + 1
        else:
            break

    return h_index  

n^2 배열 자르기 (월간 코드 챌린지 시즌3)

• 정수 n, left, right가 주어집니다. 다음 과정을 거쳐서 1차원 배열을 만들고자 합니다.
  

  • n행 n열 크기의 비어있는 2차원 배열을 만듭니다.

  • i = 1, 2, 3, ..., n에 대해서, 다음 과정을 반복합니다.

  • 1행 1열부터 i행 i열까지의 영역 내의 모든 빈 칸을 숫자 i로 채웁니다.

  • 1행, 2행, ..., n행을 잘라내어 모두 이어붙인 새로운 1차원 배열을 만듭니다.

  • 새로운 1차원 배열을 arr이라 할 때, arr[left], arr[left+1], ..., arr[right]만 남기고 나머지는 지웁니다.

  • 정수 n, left, right가 매개변수로 주어집니다. 주어진 과정대로 만들어진 1차원 배열을 return 하도록 solution 함수를 완성해주세요.

  • 제한사항

    • 1 ≤ n ≤ 10^7
    • 0 ≤ left ≤ right < n^2
    • right - left < 10^5

제출한 코드 :

def solution(n, left, right):
    result = []
    for i in range(left, right + 1):
        row = i // n
        col = i % n
        result.append(max(row, col) + 1)

    return result

행렬의 곱셈 (연습문제)

• 2차원 행렬 arr1과 arr2를 입력받아, arr1에 arr2를 곱한 결과를 반환하는 함수, solution을 완성해주세요.

  • 제한사항
    • 행렬 arr1, arr2의 행과 열의 길이는 2 이상 100 이하입니다.
    • 행렬 arr1, arr2의 원소는 -10 이상 20 이하인 자연수입니다.
    • 곱할 수 있는 배열만 주어집니다.

제출한 코드 :

import numpy as np

def solution(arr1, arr2):
    arr1_np = np.array(arr1)
    arr2_np = np.array(arr2)
    result = np.dot(arr1_np, arr2_np)

    return result.tolist()  

할인행사 (연습문제)

• XYZ 마트는 일정한 금액을 지불하면 10일 동안 회원 자격을 부여합니다. XYZ 마트에서는 회원을 대상으로 매일 한 가지 제품을 할인하는 행사를 합니다. 할인하는 제품은 하루에 하나씩만 구매할 수 있습니다. 알뜰한 정현이는 자신이 원하는 제품과 수량이 할인하는 날짜와 10일 연속으로 일치할 경우에 맞춰서 회원가입을 하려 합니다.
  예를 들어, 정현이가 원하는 제품이 바나나 3개, 사과 2개, 쌀 2개, 돼지고기 2개, 냄비 1개이며, XYZ 마트에서 14일간 회원을 대상으로 할인하는 제품이 날짜 순서대로 치킨, 사과, 사과, 바나나, 쌀, 사과, 돼지고기, 바나나, 돼지고기, 쌀, 냄비, 바나나, 사과, 바나나인 경우에 대해 알아봅시다. 첫째 날부터 열흘 간에는 냄비가 할인하지 않기 때문에 첫째 날에는 회원가입을 하지 않습니다. 둘째 날부터 열흘 간에는 바나나를 원하는 만큼 할인구매할 수 없기 때문에 둘째 날에도 회원가입을 하지 않습니다. 셋째 날, 넷째 날, 다섯째 날부터 각각 열흘은 원하는 제품과 수량이 일치하기 때문에 셋 중 하루에 회원가입을 하려 합니다.
  정현이가 원하는 제품을 나타내는 문자열 배열 want와 정현이가 원하는 제품의 수량을 나타내는 정수 배열 number, XYZ 마트에서 할인하는 제품을 나타내는 문자열 배열 discount가 주어졌을 때, 회원등록시 정현이가 원하는 제품을 모두 할인 받을 수 있는 회원등록 날짜의 총 일수를 return 하는 solution 함수를 완성하시오. 가능한 날이 없으면 0을 return 합니다.

  • 제한사항
    • 1 ≤ want의 길이 = number의 길이 ≤ 10
      • 1 ≤ number의 원소 ≤ 10
      • number[i]는 want[i]의 수량을 의미하며, number의 원소의 합은 10입니다.
      • 10 ≤ discount의 길이 ≤ 100,000
      • want와 discount의 원소들은 알파벳 소문자로 이루어진 문자열입니다
        • 1 ≤ want의 원소의 길이, discount의 원소의 길이 ≤ 12

제출한 코드 :

def solution(want, number, discount):
    answer = 0
    dict_wishlist = {}

    for i in range(len(want)):
        dict_wishlist[want[i]] = number[i]

    for i in range(len(discount) - 9):
        dict_tmp = dict_wishlist.copy()
        for j in range(i, i + 10):
            if discount[j] in dict_tmp and dict_tmp[discount[j]] != 0:
                dict_tmp[discount[j]] -= 1
            else:
                break
        if sum(dict_tmp.values()) == 0:
            answer += 1

    return answer  

의상 (해시)

• 코니는 매일 다른 옷을 조합하여 입는것을 좋아합니다.
  예를 들어 코니가 가진 옷이 아래와 같고, 오늘 코니가 동그란 안경, 긴 코트, 파란색 티셔츠를 입었다면 다음날은 청바지를 추가로 입거나 동그란 안경 대신 검정 선글라스를 착용하거나 해야합니다.
  종류 이름 얼굴 동그란 안경, 검정 선글라스 상의 파란색 티셔츠 하의 청바지 겉옷 긴 코트
  
• 코니는 각 종류별로 최대 1가지 의상만 착용할 수 있습니다. 예를 들어 위 예시의 경우 동그란 안경과 검정 선글라스를 동시에 착용할 수는 없습니다.
• 착용한 의상의 일부가 겹치더라도, 다른 의상이 겹치지 않거나, 혹은 의상을 추가로 더 착용한 경우에는 서로 다른 방법으로 옷을 착용한 것으로 계산합니다.
• 코니는 하루에 최소 한 개의 의상은 입습니다.

      코니가 가진 의상들이 담긴 2차원 배열 clothes가 주어질 때 서로 다른       옷의 조합의 수를 return 하도록 solution 함수를 작성해주세요.
       - 제한사항           - clothes의 각 행은 [의상의 이름, 의상의 종류]로 이루어져 있습니다.            - 코니가 가진 의상의 수는 1개 이상 30개 이하입니다.            - 같은 이름을 가진 의상은 존재하지 않습니다.            - clothes의 모든 원소는 문자열로 이루어져 있습니다.            - 모든 문자열의 길이는 1 이상 20 이하인 자연수이고 알파벳 소문자             또는 '_' 로만 이루어져 있습니다.

제출한 코드 :

from collections import defaultdict

def solution(clothes):
    clothes_dict = defaultdict(int)

    for _, category in clothes:
        clothes_dict[category] += 1

    answer = 1

    for count in clothes_dict.values():
        answer *= (count + 1)

    return answer - 1 # 모든 종류에서 아무 의상도 입지 않은 경우를 제외하고 반환  

제출한 쿼리 :

SELECT DISTINCT CITY
FROM STATION
WHERE RIGHT(CITY, 1) NOT IN ('a', 'e', 'i', 'o', 'u');

Weather Observation Station 11 (Basic Select)

제출한 쿼리 :

SELECT DISTINCT CITY
FROM STATION 
WHERE LEFT(CITY, 1) NOT IN ('a', 'e', 'i', 'o', 'u')
   OR RIGHT(CITY, 1) NOT IN ('a', 'e', 'i', 'o', 'u');

Weather Observation Station 12 (Basic Select)

제출한 쿼리 :

SELECT DISTINCT CITY
FROM STATION 
WHERE LEFT(CITY, 1) NOT IN ('a', 'e', 'i', 'o', 'u')
    AND RIGHT(CITY, 1)  NOT IN ('a', 'e', 'i', 'o', 'u');

Higher Than 75 Marks (Basic Select)

제출한 쿼리 :

SELECT NAME
FROM STUDENTS
WHERE MARKS  > 75
ORDER BY RIGHT(NAME, 3) ASC, ID ASC;

Employee Names (Basic Select)

제출한 쿼리 :

SELECT NAME
FROM EMPLOYEE
ORDER BY NAME ASC;

제출한 쿼리 :

(
    SELECT CITY, LENGTH(CITY) AS LEN
    FROM STATION
    ORDER BY LENGTH(CITY) ASC, CITY ASC
    LIMIT 1
)

UNION ALL

(
    SELECT CITY, LENGTH(CITY) AS LEN
    FROM STATION
    ORDER BY LENGTH(CITY) DESC, CITY ASC
    LIMIT 1
);

Weather Observation Station 6 (Basic Select)

제출한 쿼리 :

SELECT DISTINCT CITY
FROM STATION
WHERE LEFT(CITY, 1) IN ('a', 'e', 'i', 'o', 'u');

LEFT 함수

• 문자열의 왼쪽에서부터 지정한 수의 문자를 반환하는 함수

  LEFT(문자열, 길이)

• 길이 : 반환할 문자 수(정수). 문자열의 왼쪽부터 얼마나 많은 문자를 반환할지를 나타낸다.
  예)

  SELECT LEFT('Hello, World!', 3);

  반환값 : Hel

물론

SELECT DISTINCT CITY
FROM STATION
WHERE CITY LIKE 'a%' 
   OR CITY LIKE 'e%' 
   OR CITY LIKE 'i%' 
   OR CITY LIKE 'o%' 
   OR CITY LIKE 'u%';

이렇게 하나하나 작성하는 방법도 있다.

Weather Observation Station 7 (Basic Select)

제출한 쿼리 :

SELECT DISTINCT CITY
FROM STATION
WHERE RIGHT(CITY, 1) IN ('a', 'e', 'i', 'o', 'u');

LEFT 함수와 반대이다. 사용법은 동일

Weather Observation Station 8 (Basic Select)

제출한 쿼리 :

SELECT DISTINCT CITY
FROM STATION
WHERE LEFT(CITY, 1) IN ('a', 'e', 'i', 'o', 'u')
  AND RIGHT(CITY, 1) IN ('a', 'e', 'i', 'o', 'u');

Weather Observation Station 9 (Basic Select)

제출한 쿼리 :

SELECT DISTINCT CITY
FROM STATION
WHERE LEFT(CITY, 1) NOT IN ('a', 'e', 'i', 'o', 'u');

• 두 수의 최소공배수(Least Common Multiple)란 입력된 두 수의 배수 중 공통이 되는 가장 작은 숫자를 의미합니다. 예를 들어 2와 7의 최소공배수는 14가 됩니다. 정의를 확장해서, n개의 수의 최소공배수는 n 개의 수들의 배수 중 공통이 되는 가장 작은 숫자가 됩니다. n개의 숫자를 담은 배열 arr이 입력되었을 때 이 수들의 최소공배수를 반환하는 함수, solution을 완성해 주세요.

  • 제한사항
    • arr은 길이 1이상, 15이하인 배열입니다.
    • arr의 원소는 100 이하인 자연수입니다.

제출한 코드 :

import math

def lcm(x, y):
    # 두 수의 최소공배수를 계산하는 함수
    return x * y // math.gcd(x, y)

def solution(arr):
    answer = arr[0]
    for num in arr[1:]:
        # answer와 현재 수의 최소공배수를 계산하여 answer에 저장
        answer = lcm(answer, num)
    return answer

멀리뛰기 (연습문제)

• 효진이는 멀리 뛰기를 연습하고 있습니다. 효진이는 한번에 1칸, 또는 2칸을 뛸 수 있습니다. 칸이 총 4개 있을 때, 효진이는 (1칸, 1칸, 1칸, 1칸) (1칸, 2칸, 1칸) (1칸, 1칸, 2칸) (2칸, 1칸, 1칸) (2칸, 2칸) 의 5가지 방법으로 맨 끝 칸에 도달할 수 있습니다. 멀리뛰기에 사용될 칸의 수 n이 주어질 때, 효진이가 끝에 도달하는 방법이 몇 가지인지 알아내, 여기에 1234567를 나눈 나머지를 리턴하는 함수, solution을 완성하세요. 예를 들어 4가 입력된다면, 5를 return하면 됩니다.

  • 제한사항
    • n은 1 이상, 2000 이하인 정수입니다.

제출한 코드 :

def solution(n):
    answer = 0
    a, b = 0,1

    for i in range(n) :
        a,b = b, a+b

    answer = b % 1234567
    return answer

귤 고르기 (연습문제)

• 경화는 과수원에서 귤을 수확했습니다. 경화는 수확한 귤 중 'k'개를 골라 상자 하나에 담아 판매하려고 합니다. 그런데 수확한 귤의 크기가 일정하지 않아 보기에 좋지 않다고 생각한 경화는 귤을 크기별로 분류했을 때 서로 다른 종류의 수를 최소화하고 싶습니다.
  예를 들어, 경화가 수확한 귤 8개의 크기가 [1, 3, 2, 5, 4, 5, 2, 3] 이라고 합시다. 경화가 귤 6개를 판매하고 싶다면, 크기가 1, 4인 귤을 제외한 여섯 개의 귤을 상자에 담으면, 귤의 크기의 종류가 2, 3, 5로 총 3가지가 되며 이때가 서로 다른 종류가 최소일 때입니다.
  경화가 한 상자에 담으려는 귤의 개수 k와 귤의 크기를 담은 배열 tangerine이 매개변수로 주어집니다. 경화가 귤 k개를 고를 때 크기가 서로 다른 종류의 수의 최솟값을 return 하도록 solution 함수를 작성해주세요.

  • 제한사항
    • 1 ≤ k ≤ tangerine의 길이 ≤ 100,000
      • 1 ≤ tangerine의 원소 ≤ 10,000,000

제출한 코드 :

def solution(k, tangerine):
    answer = 0
    a = {}

    for i in tangerine:
        if i in a:
            a[i] += 1
        else:
            a[i] = 1

    a = dict(sorted(a.items(), key=lambda x: x[1], reverse=True))

    for i in a:
        if k <= 0:
            return answer
        k -= a[i]
        answer += 1
    return answer

괄호 회전하기 (월간 코드 챌린지 시즌2)

• 다음 규칙을 지키는 문자열을 올바른 괄호 문자열이라고 정의합니다.
  

  • (), [], {} 는 모두 올바른 괄호 문자열입니다.

  • 만약 A가 올바른 괄호 문자열이라면, (A), [A], {A} 도 올바른 괄호 문자열입니다. 예를 들어, [] 가 올바른 괄호 문자열이므로, ([]) 도 올바른 괄호 문자열입니다.

  • 만약 A, B가 올바른 괄호 문자열이라면, AB 도 올바른 괄호 문자열입니다. 예를 들어, {} 와 ([]) 가 올바른 괄호 문자열이므로, {}([]) 도 올바른 괄호 문자열입니다.
    대괄호, 중괄호, 그리고 소괄호로 이루어진 문자열 s가 매개변수로 주어집니다. 이 s를 왼쪽으로 x (0 ≤ x < (s의 길이)) 칸만큼 회전시켰을 때 s가 올바른 괄호 문자열이 되게 하는 x의 개수를 return 하도록 solution 함수를 완성해주세요.

  • 제한사항

    • s의 길이는 1 이상 1,000 이하입니다.

제출한 코드 :

def is_valid(s):
    stack = []
    for char in s:
        if char in ['(', '[', '{']:
            stack.append(char)
        else:
            if not stack:
                return False
            if char == ')' and stack[-1] == '(':
                stack.pop()
            elif char == ']' and stack[-1] == '[':
                stack.pop()
            elif char == '}' and stack[-1] == '{':
                stack.pop()
            else:
                return False
    return len(stack) == 0

def solution(s):
    count = 0
    for i in range(len(s)):
        rotated = s[i:] + s[:i]
        if is_valid(rotated):
            count += 1
    return count

연속 부분 수열 합의 개수 (연습문제)

• 철호는 수열을 가지고 놀기 좋아합니다. 어느 날 철호는 어떤 자연수로 이루어진 원형 수열의 연속하는 부분 수열의 합으로 만들 수 있는 수가 모두 몇 가지인지 알아보고 싶어졌습니다. 원형 수열이란 일반적인 수열에서 처음과 끝이 연결된 형태의 수열을 말합니다. 예를 들어 수열 [7, 9, 1, 1, 4] 로 원형 수열을 만들면 다음과 같습니다. 원형 수열은 처음과 끝이 연결되어 끊기는 부분이 없기 때문에 연속하는 부분 수열도 일반적인 수열보다 많아집니다. 원형 수열의 모든 원소 elements가 순서대로 주어질 때, 원형 수열의 연속 부분 수열 합으로 만들 수 있는 수의 개수를 return 하도록 solution 함수를 완성해주세요.

  • 제한사항
    • 3 ≤elements의 길이 ≤ 1,000
    • 1 ≤ elements의 원소 ≤ 1,000

제출한 코드 :

def solution(elements):
    n = len(elements)
    total = set()

    for i in range(n):
        s = 0
        for j in range(n):
            s += elements[(i + j) % n]
            total.add(s)

    return len(total)

• JadenCase란 모든 단어의 첫 문자가 대문자이고, 그 외의 알파벳은 소문자인 문자열입니다. 단, 첫 문자가 알파벳이 아닐 때에는 이어지는 알파벳은 소문자로 쓰면 됩니다. (첫 번째 입출력 예 참고) 문자열 s가 주어졌을 때, s를 JadenCase로 바꾼 문자열을 리턴하는 함수, solution을 완성해주세요.

  • 제한사항
    • s는 길이 1 이상 200 이하인 문자열입니다.
      • s는 알파벳과 숫자, 공백문자(" ")로 이루어져 있습니다.
      • 숫자는 단어의 첫 문자로만 나옵니다.
      • 숫자로만 이루어진 단어는 없습니다.
      • 공백문자가 연속해서 나올 수 있습니다.

제출한 코드 :

def solution(s):
    words = s.split(' ')
    jaden_case_words = []

    for word in words:
        if word:
            # 첫 문자가 알파벳이면 대문자로 변환, 나머지는 소문자로 변환
            jaden_case_words.append(word[0].upper() + word[1:].lower())
        else:
            # 공백인 경우 그대로 추가
            jaden_case_words.append('')

    return ' '.join(jaden_case_words)

이진 변환 반복하기 (월간 코드 챌린지 시즌1)

• 0과 1로 이루어진 어떤 문자열 x에 대한 이진 변환을 다음과 같이 정의합니다.
  

  1. x의 모든 0을 제거합니다.
  2. x의 길이를 c라고 하면, x를 "c를 2진법으로 표현한 문자열"로 바꿉니다.
     예를 들어, x = "0111010"이라면, x에 이진 변환을 가하면 x = "0111010" -> "1111" -> "100" 이 됩니다.
     0과 1로 이루어진 문자열 s가 매개변수로 주어집니다. s가 "1"이 될 때까지 계속해서 s에 이진 변환을 가했을 때, 이진 변환의 횟수와 변환 과정에서 제거된 모든 0의 개수를 각각 배열에 담아 return 하도록 solution 함수를 완성해주세요.
  • 제한사항
    • s의 길이는 1 이상 150,000 이하입니다.
    • s에는 '1'이 최소 하나 이상 포함되어 있습니다.

제출한 코드 :

def solution(s):
    answer = [0, 0]  # [이진 변환 횟수, 제거된 0의 개수]

    # s가 "1"이 될 때까지 반복
    while s != "1":
        answer[0] += 1  # 이진 변환 횟수 증가
        answer[1] += s.count('0')  # 0의 개수를 세어 제거된 0의 개수에 추가
        s = bin(s.count('1'))[2:]  # s에 이진 변환을 적용하여 다음 문자열로 업데이트

    return answer

피보나치 수 (연습문제)

• 피보나치 수는 F(0) = 0, F(1) = 1일 때, 1 이상의 n에 대하여 F(n) = F(n-1) + F(n-2) 가 적용되는 수 입니다.
  예를들어
  

  • F(2) = F(0) + F(1) = 0 + 1 = 1
  • F(3) = F(1) + F(2) = 1 + 1 = 2
  • F(4) = F(2) + F(3) = 1 + 2 = 3
  • F(5) = F(3) + F(4) = 2 + 3 = 5
    와 같이 이어집니다.
    2 이상의 n이 입력되었을 때, n번째 피보나치 수를 1234567으로 나눈 나머지를 리턴하는 함수, solution을 완성해 주세요.
  • 제한사항
    • n은 2 이상 100,000 이하인 자연수입니다.

제출한 코드 :

def solution(n):
    fibo = [0, 1]  # 초기 피보나치 수열
    MOD = 1234567  # 나머지

    # n까지 피보나치 수열 계산
    for i in range(2, n + 1):
        fibo.append((fibo[-1] + fibo[-2]) % MOD)

    return fibo[n]

카펫 (제출 내역)

• Leo는 카펫을 사러 갔다가 아래 그림과 같이 중앙에는 노란색으로 칠해져 있고 테두리 1줄은 갈색으로 칠해져 있는 격자 모양 카펫을 봤습니다. Leo는 집으로 돌아와서 아까 본 카펫의 노란색과 갈색으로 색칠된 격자의 개수는 기억했지만, 전체 카펫의 크기는 기억하지 못했습니다.
  Leo가 본 카펫에서 갈색 격자의 수 brown, 노란색 격자의 수 yellow가 매개변수로 주어질 때 카펫의 가로, 세로 크기를 순서대로 배열에 담아 return 하도록 solution 함수를 작성해주세요.

  • 제한사항
    • 갈색 격자의 수 brown은 8 이상 5,000 이하인 자연수입니다.
    • 노란색 격자의 수 yellow는 1 이상 2,000,000 이하인 자연수입니다.
    • 카펫의 가로 길이는 세로 길이와 같거나, 세로 길이보다 깁니다.

제출한 코드 :

def solution(brown, yellow):
    for i in range(1, yellow + 1):
        if yellow % i == 0:
            # yellow를 가로와 세로의 길이로 나눔
            if 2 * (i + yellow // i) + 4 == brown:
                # 갈색 격자 수와 일치하는 경우 가로와 세로의 길이 반환
                return [max(i, yellow // i) + 2, min(i, yellow // i) + 2]

예상 대진표 (2017 팁스타운)

• △△ 게임대회가 개최되었습니다. 이 대회는 N명이 참가하고, 토너먼트 형식으로 진행됩니다. N명의 참가자는 각각 1부터 N번을 차례대로 배정받습니다. 그리고, 1번↔2번, 3번↔4번, ... , N-1번↔N번의 참가자끼리 게임을 진행합니다. 각 게임에서 이긴 사람은 다음 라운드에 진출할 수 있습니다. 이때, 다음 라운드에 진출할 참가자의 번호는 다시 1번부터 N/2번을 차례대로 배정받습니다. 만약 1번↔2번 끼리 겨루는 게임에서 2번이 승리했다면 다음 라운드에서 1번을 부여받고, 3번↔4번에서 겨루는 게임에서 3번이 승리했다면 다음 라운드에서 2번을 부여받게 됩니다. 게임은 최종 한 명이 남을 때까지 진행됩니다.
  이때, 처음 라운드에서 A번을 가진 참가자는 경쟁자로 생각하는 B번 참가자와 몇 번째 라운드에서 만나는지 궁금해졌습니다. 게임 참가자 수 N, 참가자 번호 A, 경쟁자 번호 B가 함수 solution의 매개변수로 주어질 때, 처음 라운드에서 A번을 가진 참가자는 경쟁자로 생각하는 B번 참가자와 몇 번째 라운드에서 만나는지 return 하는 solution 함수를 완성해 주세요. 단, A번 참가자와 B번 참가자는 서로 붙게 되기 전까지 항상 이긴다고 가정합니다.

  • 제한사항
    • N : 21 이상 220 이하인 자연수 (2의 지수 승으로 주어지므로 부전승은 발생하지 않습니다.)
    • A, B : N 이하인 자연수 (단, A ≠ B 입니다.)

제출한 코드 :

def solution(n, a, b):
    answer = 0

    # 대진이 이루어지는 참가자 번호의 범위를 정하고, 두 참가자가 만날 때까지 반복
    while a != b:
        answer += 1
        a = (a + 1) // 2  # 다음 라운드에서의 참가자 번호 계산
        b = (b + 1) // 2

    return answer

• 문제

제출한 쿼리 :

SELECT *
FROM CITY
WHERE COUNTRYCODE = 'JPN';

Weather Observation Station 1 (Basic Select)

• 문제

제출한 쿼리 :

SELECT CITY
       , STATE
FROM STATION

Weather Observation Station 2 (Aggregation)

• 문제

제출한 쿼리 :

SELECT ROUND(SUM(LAT_N), 2) AS LAT
       , ROUND(SUM(LONG_W), 2) AS LON
FROM STATION;

Weather Observation Station 3 (Basic Select)

• 문제

제출한 쿼리 :

SELECT DISTINCT CITY
FROM STATION
WHERE ID % 2 = 0;

Weather Observation Station 4 (Basic Select)

제출한 쿼리 :

SELECT COUNT(*) - COUNT(DISTINCT CITY)
FROM STATION;

• 고객의 약관 동의를 얻어서 수집된 1~n번으로 분류되는 개인정보 n개가 있습니다. 약관 종류는 여러 가지 있으며 각 약관마다 개인정보 보관 유효기간이 정해져 있습니다. 당신은 각 개인정보가 어떤 약관으로 수집됐는지 알고 있습니다. 수집된 개인정보는 유효기간 전까지만 보관 가능하며, 유효기간이 지났다면 반드시 파기해야 합니다.
  예를 들어, A라는 약관의 유효기간이 12 달이고, 2021년 1월 5일에 수집된 개인정보가 A약관으로 수집되었다면 해당 개인정보는 2022년 1월 4일까지 보관 가능하며 2022년 1월 5일부터 파기해야 할 개인정보입니다. 당신은 오늘 날짜로 파기해야 할 개인정보 번호들을 구하려 합니다.
  모든 달은 28일까지 있다고 가정합니다.
  다음은 오늘 날짜가 2022.05.19일 때의 예시입니다.
  약관 종류 유효기간 A            6 달 B            12 달 C            3 달
  번호 개인정보 수집 일자 약관 종류 1     2021.05.02             A 2     2021.07.01             B 3     2022.02.19             C 4     2022.02.20             C
  

  • 첫 번째 개인정보는 A약관에 의해 2021년 11월 1일까지 보관 가능하며, 유효기간이 지났으므로 파기해야 할 개인정보입니다.
  • 두 번째 개인정보는 B약관에 의해 2022년 6월 28일까지 보관 가능하며, 유효기간이 지나지 않았으므로 아직 보관 가능합니다.
  • 세 번째 개인정보는 C약관에 의해 2022년 5월 18일까지 보관 가능하며, 유효기간이 지났으므로 파기해야 할 개인정보입니다.
  • 네 번째 개인정보는 C약관에 의해 2022년 5월 19일까지 보관 가능하며, 유효기간이 지나지 않았으므로 아직 보관 가능합니다.
    

      따라서 파기해야 할 개인정보 번호는 [1, 3]입니다.
       오늘 날짜를 의미하는 문자열 today, 약관의 유효기간을 담은        1차원 문자열 배열 terms와 수집된 개인정보의 정보를 담은        1차원 문자열 배열 privacies가 매개변수로 주어집니다.        이때 파기해야 할 개인정보의 번호를 오름차순으로 1차원 정수        배열에 담아 return 하도록 solution 함수를 완성해 주세요.

• 제한사항
  • today는 "YYYY.MM.DD" 형태로 오늘 날짜를 나타냅니다.
  • 1 ≤ terms의 길이 ≤ 20
    • terms의 원소는 "약관 종류 유효기간" 형태의 약관 종류와 유효기간을 공백 하나로 구분한 문자열입니다.
    • 약관 종류는 A~Z중 알파벳 대문자 하나이며, terms 배열에서 약관 종류는 중복되지 않습니다.
    • 유효기간은 개인정보를 보관할 수 있는 달 수를 나타내는 정수이며, 1 이상 100 이하입니다.
  • 1 ≤ privacies의 길이 ≤ 100
    • privacies[i]는 i+1번 개인정보의 수집 일자와 약관 종류를 나타냅니다.
    • privacies의 원소는 "날짜 약관 종류" 형태의 날짜와 약관 종류를 공백 하나로 구분한 문자열입니다
    • 날짜는 "YYYY.MM.DD" 형태의 개인정보가 수집된 날짜를 나타내며, today 이전의 날짜만 주어집니다.
    • privacies의 약관 종류는 항상 terms에 나타난 약관 종류만 주어집니다.
  • today와 privacies에 등장하는 날짜의 YYYY는 연도, MM은 월, DD는 일을 나타내며 점(.) 하나로 구분되어 있습니다.
    • 2000 ≤ YYYY ≤ 2022
    • 1 ≤ MM ≤ 12
    • MM이 한 자릿수인 경우 앞에 0이 붙습니다.
    • 1 ≤ DD ≤ 28
    • DD가 한 자릿수인 경우 앞에 0이 붙습니다.
  • 파기해야 할 개인정보가 하나 이상 존재하는 입력만 주어집니다.

제출한 코드 :

from datetime import datetime, timedelta
from dateutil.relativedelta import relativedelta

def get_date(date):
    return datetime.strptime(date, "%Y.%m.%d")

def solution(today, terms, privacies):
    today = get_date(today)
    answer = []
    tm = {}

    for t in terms:
        term, mon = t.split(" ")
        tm[term] = int(mon)

    for i, p in enumerate(privacies):
        date, term = p.split(" ")
        time = tm[term]
        start_date = get_date(date)
        end_date = start_date + relativedelta(months=time)

        if end_date <= today:
            answer.append(i+1)

    return answer

달리기 경주 (연습문제)

• 얀에서는 매년 달리기 경주가 열립니다. 해설진들은 선수들이 자기 바로 앞의 선수를 추월할 때 추월한 선수의 이름을 부릅니다. 예를 들어 1등부터 3등까지 "mumu", "soe", "poe" 선수들이 순서대로 달리고 있을 때, 해설진이 "soe"선수를 불렀다면 2등인 "soe" 선수가 1등인 "mumu" 선수를 추월했다는 것입니다. 즉 "soe" 선수가 1등, "mumu" 선수가 2등으로 바뀝니다.
  선수들의 이름이 1등부터 현재 등수 순서대로 담긴 문자열 배열 players와 해설진이 부른 이름을 담은 문자열 배열 callings가 매개변수로 주어질 때, 경주가 끝났을 때 선수들의 이름을 1등부터 등수 순서대로 배열에 담아 return 하는 solution 함수를 완성해주세요.
  

  • 제한사항
    • 5 ≤ players의 길이 ≤ 50,000
      • players[i]는 i번째 선수의 이름을 의미합니다.
        • players의 원소들은 알파벳 소문자로만 이루어져 있습니다.
        • players에는 중복된 값이 들어가 있지 않습니다.
        • 3 ≤ players[i]의 길이 ≤ 10
    • 2 ≤ callings의 길이 ≤ 1,000,000
      • callings는 players의 원소들로만 이루어져 있습니다.
      • 경주 진행중 1등인 선수의 이름은 불리지 않습니다.

제출한 코드 :

def solution(players, callings):
    # 선수들의 현재 위치를 기록하는 딕셔너리
    position = {player: idx for idx, player in enumerate(players)}

    for call in callings:
        # 추월한 선수의 현재 위치
        current_idx = position[call]

        if current_idx > 0:  # 현재 1등은 추월하지 않기 때문에
            # 앞선 선수의 이름
            prev_player = players[current_idx - 1]

            # 선수들의 위치를 서로 교환
            players[current_idx - 1], players[current_idx] = players[current_idx], players[current_idx - 1]

            # 위치 정보 업데이트
            position[call], position[prev_player] = position[prev_player], position[call]

    return players

공원 산책 (연습문제)

• 지나다니는 길을 'O', 장애물을 'X'로 나타낸 직사각형 격자 모양의 공원에서 로봇 강아지가 산책을 하려합니다. 산책은 로봇 강아지에 미리 입력된 명령에 따라 진행하며, 명령은 다음과 같은 형식으로 주어집니다.
  

  • ["방향 거리", "방향 거리" … ]
    

      예를 들어 "E 5"는 로봇 강아지가 현재 위치에서 동쪽으로 5칸       이동했다는 의미입니다. 로봇 강아지는 명령을 수행하기 전에       다음 두 가지를 먼저 확인합니다.

• 주어진 방향으로 이동할 때 공원을 벗어나는지 확인합니다.

• 주어진 방향으로 이동 중 장애물을 만나는지 확인합니다.

  위 두 가지중 어느 하나라도 해당된다면, 로봇 강아지는 해당 명령을 무시하고 다음 명령을 수행합니다. 공원의 가로 길이가 W, 세로 길이가 H라고 할 때, 공원의 좌측 상단의 좌표는 (0, 0), 우측 하단의 좌표는 (H - 1, W - 1) 입니다. 공원을 나타내는 문자열 배열 park, 로봇 강아지가 수행할 명령이 담긴 문자열 배열 routes가 매개변수로 주어질 때, 로봇 강아지가 모든 명령을 수행 후 놓인 위치를 [세로 방향 좌표, 가로 방향 좌표] 순으로 배열에 담아 return 하도록 solution 함수를 완성해주세요.

• 제한사항

  • 3 ≤ park의 길이 ≤ 50
    • 3 ≤ park[i]의 길이 ≤ 50
      • park[i]는 다음 문자들로 이루어져 있으며 시작지점은 하나만 주어집니다.
        • S : 시작 지점
        • O : 이동 가능한 통로
        • X : 장애물
      • park는 직사각형 모양입니다.
    • 1 ≤ routes의 길이 ≤ 50
    • routes의 각 원소는 로봇 강아지가 수행할 명령어를 나타냅니다.
    • 로봇 강아지는 routes의 첫 번째 원소부터 순서대로 명령을 수행합니다.
    • routes의 원소는 "op n"과 같은 구조로 이루어져 있으며, op는 이동할 방향, n은 이동할 칸의 수를 의미합니다.
      • op는 다음 네 가지중 하나로 이루어져 있습니다.
        • N : 북쪽으로 주어진 칸만큼 이동합니다.
        • S : 남쪽으로 주어진 칸만큼 이동합니다.
        • W : 서쪽으로 주어진 칸만큼 이동합니다.
        • E : 동쪽으로 주어진 칸만큼 이동합니다.
      • 1 ≤ n ≤ 9

제출한 코드 :

def solution(park, routes):
    # 공원의 크기
    h = len(park)
    w = len(park[0])

    # 초기 위치 찾기
    for i in range(h):
        for j in range(w):
            if park[i][j] == 'S':
                start_pos = (i, j)
                break

    # 방향 설정
    directions = {
        'N': (-1, 0),
        'S': (1, 0),
        'W': (0, -1),
        'E': (0, 1)
    }

    current_pos = start_pos

    # 명령 처리
    for route in routes:
        direction, distance = route.split()
        distance = int(distance)
        new_pos = current_pos

        # 이동 가능 여부 확인
        for step in range(1, distance + 1):
            next_pos = (new_pos[0] + directions[direction][0], new_pos[1] + directions[direction][1])

            # 공원을 벗어나는지 확인
            if not (0 <= next_pos[0] < h and 0 <= next_pos[1] < w):
                break

            # 장애물인지 확인
            if park[next_pos[0]][next_pos[1]] == 'X':
                break

            new_pos = next_pos
        else:
            # 모두 성공한 경우 현재 위치 업데이트
            current_pos = new_pos

    return [current_pos[0], current_pos[1]]

신고 결과 받기 (2022 KAKAO BLIND RECRUITMENT)

• 신입사원 무지는 게시판 불량 이용자를 신고하고 처리 결과를 메일로 발송하는 시스템을 개발하려 합니다. 무지가 개발하려는 시스템은 다음과 같습니다.
  • 각 유저는 한 번에 한 명의 유저를 신고할 수 있습니다.
    • 신고 횟수에 제한은 없습니다. 서로 다른 유저를 계속해서 신고할 수 있습니다.
    • 한 유저를 여러 번 신고할 수도 있지만, 동일한 유저에 대한 신고 횟수는 1회로 처리됩니다.
  • k번 이상 신고된 유저는 게시판 이용이 정지되며, 해당 유저를 신고한 모든 유저에게 정지 사실을 메일로 발송합니다.
    • 유저가 신고한 모든 내용을 취합하여 마지막에 한꺼번에 게시판 이용 정지를 시키면서 정지 메일을 발송합니다.
      

       다음은 전체 유저 목록이 ["muzi", "frodo", "apeach", "neo"]이고,        k = 2(즉, 2번 이상 신고당하면 이용 정지)인 경우의 예시입니다.

       유저 ID   유저가 신고한 ID   설명         "muzi"     "frodo"                "muzi"가 "frodo"를 신고했습니다.         "apeach"  "frodo"                "apeach"가 "frodo"를                                              신고했습니다.         "frodo"     "neo"                  "frodo"가 "neo"를 신고했습니다.         "muzi"      "neo"                 "muzi"가 "neo"를 신고했습니다.         "apeach"   "muzi"                "apeach"가 "muzi"를                                              신고했습니다.
        각 유저별로 신고당한 횟수는 다음과 같습니다.

       유저 ID   신고당한 횟수         "muzi"     1         "frodo"    2         "apeach"  0         "neo"      2

       위 예시에서는 2번 이상 신고당한 "frodo"와 "neo"의 게시판        이용이 정지됩니다. 이때, 각 유저별로 신고한 아이디와 정지된        아이디를 정리하면 다음과 같습니다.
        유저 ID   유저가 신고한 ID 정지된 ID         "muzi"    ["frodo", "neo"]    ["frodo", "neo"]         "frodo"   ["neo"]               ["neo"]         "apeach" ["muzi", "frodo"]   ["frodo"]         "neo"     없음                  없음
        따라서 "muzi"는 처리 결과 메일을 2회, "frodo"와 "apeach"는        각각 처리 결과 메일을 1회 받게 됩니다.
        이용자의 ID가 담긴 문자열 배열 id_list, 각 이용자가 신고한        이용자의 ID 정보가 담긴 문자열 배열 report, 정지 기준이        되는 신고 횟수 k가 매개변수로 주어질 때, 각 유저별로 처리        결과 메일을 받은 횟수를 배열에 담아 return 하도록 solution        함수를 완성해주세요.

• 제한사항
  • 2 ≤ id_list의 길이 ≤ 1,000
    • 1 ≤ id_list의 원소 길이 ≤ 10
    • id_list의 원소는 이용자의 id를 나타내는 문자열이며 알파벳 소문자로만 이루어져 있습니다.
    • id_list에는 같은 아이디가 중복해서 들어있지 않습니다.
  • 1 ≤ report의 길이 ≤ 200,000
    • 3 ≤ report의 원소 길이 ≤ 21
    • report의 원소는 "이용자id 신고한id"형태의 문자열입니다.
    • 예를 들어 "muzi frodo"의 경우 "muzi"가 "frodo"를 신고했다는 의미입니다.
    • id는 알파벳 소문자로만 이루어져 있습니다.
    • 이용자id와 신고한id는 공백(스페이스)하나로 구분되어 있습니다.
    • 자기 자신을 신고하는 경우는 없습니다.
    • 1 ≤ k ≤ 200, k는 자연수입니다.
    • return 하는 배열은 id_list에 담긴 id 순서대로 각 유저가 받은 결과 메일 수를 담으면 됩니다.

제출한 코드 :

def solution(id_list, report, k):
    # 중복 제거된 신고 내역을 저장할 세트
    report_set = set(report)

    # 각 유저가 신고당한 횟수를 저장할 딕셔너리
    report_count = {user: 0 for user in id_list}

    # 각 유저가 신고한 유저 목록을 저장할 딕셔너리
    user_reports = {user: [] for user in id_list}

    # 신고 내역 처리
    for rep in report_set:
        reporter, reported = rep.split()
        report_count[reported] += 1
        user_reports[reporter].append(reported)

    # 정지된 유저 리스트
    suspended_users = {user for user, count in report_count.items() if count >= k}

    # 결과 메일 횟수 저장 리스트
    result = [0] * len(id_list)

    # 각 유저가 받은 메일 수 계산
    for i, user in enumerate(id_list):
        result[i] = len([reported for reported in user_reports[user] if reported in suspended_users])

    return result

최댓값과 최솟값 (연습문제)

• 문자열 s에는 공백으로 구분된 숫자들이 저장되어 있습니다. str에 나타나는 숫자 중 최소값과 최대값을 찾아 이를 "(최소값) (최대값)"형태의 문자열을 반환하는 함수, solution을 완성하세요. 예를들어 s가 "1 2 3 4"라면 "1 4"를 리턴하고, "-1 -2 -3 -4"라면 "-4 -1"을 리턴하면 됩니다.

  • 제한사항
    • s에는 둘 이상의 정수가 공백으로 구분되어 있습니다.

제출한 코드 :

def solution(s):
    # 문자열을 공백으로 분리하여 리스트로 만듦
    numbers = s.split()

    # 리스트의 원소들을 정수로 변환
    numbers = list(map(int, numbers))

    # 최소값과 최대값을 찾음
    min_num = min(numbers)
    max_num = max(numbers)

    # 형식에 맞게 문자열로 반환
    return f"{min_num} {max_num}"

현타

진짜 1일 10현타... 진짜 기본 생활(?)에 문제 있는데 공부해서 뭐하나 싶다ㅋㅋㅋ 그렇다고 안 할수는 없으니 하기는 하는데 이도저도 아닌 기분이랄까. 해결책? 실행 가능했으면 당장 했지...^^ 진짜 경제적인 문제, 가족/집안 문제에서 계속 삐그덕 대는거 이제는 놀랍지도 않지만 요즘 유독 현타가 많이 온다. 하지만 버텨야지 모. 내가 여기서 공부 손 놓는다고 문제가 해결되는것도 아니니까...... 하지만 답답한걸ㅋㅋ 오늘도 다짐한다. 빨리 취업해서 "독립" 해야지...

오히려 좋아

누가보면 억긍정이라고 할 수도 있겠지만 약간 스스로를 긍정 가스라이팅 오히려 좋아/원영적사고 실천 중. 어렵지만 안 하는 것보다는 낫더라. 공부? 오히려 좋아~ 머리 조금이라도 빨리빨리 돌아갈 때 많이 배워놓는게 최고! 갈등? 오히려 좋아~ 면접때 얘기 할 소재 생겼네? 이번에 경험했으니 다음에는 대비할 수 있겠다! 라고 자기최면중ㅋㅋ

하면 된다

일단 해

누가 한 말인지는 모르겠는데 왜, '하기 싫어도 해라. 감정은 사라지고 결과만 남는다.'라는 말이 요즘 너무 공감돼서 일단 뭐든 하는 중. 진짜 어떻게든 하니까 뭘 해도 결과는 나오고, 이왕 시작한거 더 열심히 하게 된다. 물론 그 과정이 평탄한건 아니지만. 그래서 내일 SQLD 시험 떨어질 것 같지만 일단 벼락치기라도 한다...! 재수 하더라도 남는게 있겠지 모

노력과 재능

하지만 누군가의 재능을 뛰어넘는 다는건 어쩌면 불가능한 일이라고 생각한다. 재능 하나만 믿고 아무것도 안하고 뻗대는 사람이야 넘을 수도 있겠지만, 재능 + 노력까지 하는 사람 넘으려고 하는건 너무 욕심인 것 같다. 그냥 주어진거 내 선에서 열심히 하는게 최고인듯. 긍정적으로 생각하자,,, 애매한 재능이 있을 바에는 아무런 재능이 없는게 낫다...ㅋㅋㅋ

• 문제

제출한 쿼리 :

SELECT *
FROM CITY

Select By ID (Basic Select)

• 문제

제출한 쿼리 :

SELECT * 
FROM CITY
WHERE ID = 1661;

Revising the Select Query(I) (Basic Select)

• 문제

제출한 쿼리 :

SELECT *
FROM CITY
WHERE population > 100000
    AND CountryCode = 'USA';

Revising the Select Query(II) (Basic Select)

• 문제

제출한 쿼리 :

SELECT NAME
FROM CITY
WHERE POPULATION > 120000 
    AND COUNTRYCODE = "USA";

Japanese Cities' Names (Basic Select)

• 문제

제출한 쿼리 :

SELECT name
FROM CITY
WHERE COUNTRYCODE = 'JPN';

• 휴대폰의 자판은 컴퓨터 키보드 자판과는 다르게 하나의 키에 여러 개의 문자가 할당될 수 있습니다. 키 하나에 여러 문자가 할당된 경우, 동일한 키를 연속해서 빠르게 누르면 할당된 순서대로 문자가 바뀝니다.
  예를 들어, 1번 키에 "A", "B", "C" 순서대로 문자가 할당되어 있다면 1번 키를 한 번 누르면 "A", 두 번 누르면 "B", 세 번 누르면 "C"가 되는 식입니다.
  같은 규칙을 적용해 아무렇게나 만든 휴대폰 자판이 있습니다. 이 휴대폰 자판은 키의 개수가 1개부터 최대 100개까지 있을 수 있으며, 특정 키를 눌렀을 때 입력되는 문자들도 무작위로 배열되어 있습니다. 또, 같은 문자가 자판 전체에 여러 번 할당된 경우도 있고, 키 하나에 같은 문자가 여러 번 할당된 경우도 있습니다. 심지어 아예 할당되지 않은 경우도 있습니다. 따라서 몇몇 문자열은 작성할 수 없을 수도 있습니다.
  이 휴대폰 자판을 이용해 특정 문자열을 작성할 때, 키를 최소 몇 번 눌러야 그 문자열을 작성할 수 있는지 알아보고자 합니다.
  1번 키부터 차례대로 할당된 문자들이 순서대로 담긴 문자열배열 keymap과 입력하려는 문자열들이 담긴 문자열 배열 targets가 주어질 때, 각 문자열을 작성하기 위해 키를 최소 몇 번씩 눌러야 하는지 순서대로 배열에 담아 return 하는 solution 함수를 완성해 주세요.
  단, 목표 문자열을 작성할 수 없을 때는 -1을 저장합니다.
  - 제한사항 - 1 ≤ `keymap`의 길이 ≤ 100 - 1 ≤ `keymap`의 원소의 길이 ≤ 100 - `keymap[i]`는 i + 1번 키를 눌렀을 때 순서대로 바뀌는 문자를 의미합니다. - 예를 들어 `keymap[0]` = "ABACD" 인 경우 1번 키를 한 번 누르면 A, 두 번 누르면 B, 세 번 누르면 A 가 됩니다. - `keymap`의 원소의 길이는 서로 다를 수 있습니다. - `keymap`의 원소는 알파벳 대문자로만 이루어져 있습니다. - 1 ≤ `targets`의 길이 ≤ 100 - 1 ≤ `targets`의 원소의 길이 ≤ 100 - `targets`의 원소는 알파벳 대문자로만 이루어져 있습니다.

제출한 코드 :

def solution(keymap, targets):
    answer = []

    for target in targets:
        minkey = 0 

        for i in target: 
            c = 101 
            flag = False 

            for k in keymap:
                key = k.find(i)

                if key == -1: 
                    continue
                c = min(key+1, c) 
                flag = True 

            if flag: 
                minkey += c
            else: 
                answer.append(-1)
                break
        else: 
            answer.append(minkey) 

    return answer

둘만의 암호 (연습문제)

• 두 문자열 s와 skip, 그리고 자연수 index가 주어질 때, 다음 규칙에 따라 문자열을 만들려 합니다. 암호의 규칙은 다음과 같습니다.

문자열 s의 각 알파벳을 index만큼 뒤의 알파벳으로 바꿔줍니다. index만큼의 뒤의 알파벳이 z를 넘어갈 경우 다시 a로 돌아갑니다. skip에 있는 알파벳은 제외하고 건너뜁니다. 예를 들어 s = "aukks", skip = "wbqd", index = 5일 때, a에서 5만큼 뒤에 있는 알파벳은 f지만 [b, c, d, e, f]에서 'b'와 'd'는 skip에 포함되므로 세지 않습니다. 따라서 'b', 'd'를 제외하고 'a'에서 5만큼 뒤에 있는 알파벳은 [c, e, f, g, h] 순서에 의해 'h'가 됩니다. 나머지 "ukks" 또한 위 규칙대로 바꾸면 "appy"가 되며 결과는 "happy"가 됩니다.

두 문자열 s와 skip, 그리고 자연수 index가 매개변수로 주어질 때 위 규칙대로 s를 변환한 결과를 return하도록 solution 함수를 완성해주세요.

• 제한사항
  • 5 ≤ s의 길이 ≤ 50
  • 1 ≤ skip의 길이 ≤ 10
    • s와 skip은 알파벳 소문자로만 이루어져 있습니다.
      • skip에 포함되는 알파벳은 s에 포함되지 않습니다.
  • 1 ≤ index ≤ 20

제출한 코드 :

def rotate(aci):
    return (aci - 96) % 26 + 97

def solution(s, skip, index):
    answer = ''

    for c in s:        
        aci = ord(c)
        for i in range(index):
            aci = rotate(aci)
            while chr(aci) in skip:
                aci = rotate(aci)
        ret = chr(aci)
        answer += chr(aci)

    return answer

햄버거 만들기 (연습문제)

• 햄버거 가게에서 일을 하는 상수는 햄버거를 포장하는 일을 합니다. 함께 일을 하는 다른 직원들이 햄버거에 들어갈 재료를 조리해 주면 조리된 순서대로 상수의 앞에 아래서부터 위로 쌓이게 되고, 상수는 순서에 맞게 쌓여서 완성된 햄버거를 따로 옮겨 포장을 하게 됩니다. 상수가 일하는 가게는 정해진 순서(아래서부터, 빵 – 야채 – 고기 - 빵)로 쌓인 햄버거만 포장을 합니다. 상수는 손이 굉장히 빠르기 때문에 상수가 포장하는 동안 속 재료가 추가적으로 들어오는 일은 없으며, 재료의 높이는 무시하여 재료가 높이 쌓여서 일이 힘들어지는 경우는 없습니다.
  예를 들어, 상수의 앞에 쌓이는 재료의 순서가 [야채, 빵, 빵, 야채, 고기, 빵, 야채, 고기, 빵]일 때, 상수는 여섯 번째 재료가 쌓였을 때, 세 번째 재료부터 여섯 번째 재료를 이용하여 햄버거를 포장하고, 아홉 번째 재료가 쌓였을 때, 두 번째 재료와 일곱 번째 재료부터 아홉 번째 재료를 이용하여 햄버거를 포장합니다. 즉, 2개의 햄버거를 포장하게 됩니다.
  상수에게 전해지는 재료의 정보를 나타내는 정수 배열 ingredient가 주어졌을 때, 상수가 포장하는 햄버거의 개수를 return 하도록 solution 함수를 완성하시오.
  - 제한사항 - 1 ≤ `ingredient`의 길이 ≤ 1,000,000 - `ingredient`의 원소는 1, 2, 3 중 하나의 값이며, 순서대로 빵, 야채, 고기를 의미합니다.

제출한 코드 :

def solution(ingredient):
    s = []
    cnt = 0
    for i in ingredient:
        s.append(i)
        if s[-4:] == [1, 2, 3, 1]:
            cnt += 1
            for _ in range(4):
                s.pop()
    return cnt

성격 유형 검사하기 (2022 KAKAO TECH INTERNSHIP)

• 나만의 카카오 성격 유형 검사지를 만들려고 합니다. 성격 유형 검사는 다음과 같은 4개 지표로 성격 유형을 구분합니다. 성격은 각 지표에서 두 유형 중 하나로 결정됩니다.
  지표 번호 성격 유형  1번 지표  라이언형(R), 튜브형(T)  2번 지표  콘형(C), 프로도형(F)  3번 지표  제이지형(J), 무지형(M)  4번 지표  어피치형(A), 네오형(N)
  4개의 지표가 있으므로 성격 유형은 총 16(=2 x 2 x 2 x 2)가지가 나올 수 있습니다. 예를 들어, "RFMN"이나 "TCMA"와 같은 성격 유형이 있습니다.
  검사지에는 총 n개의 질문이 있고, 각 질문에는 아래와 같은 7개의 선택지가 있습니다.
  
  • 매우 비동의
  • 비동의
  • 약간 비동의
  • 모르겠음
  • 약간 동의
  • 동의
  • 매우 동의
    

      각 질문은 1가지 지표로 성격 유형 점수를 판단합니다.
       예를 들어, 어떤 한 질문에서 4번 지표로 아래 표처럼 점수를 매길 수       있습니다.
       선택지         성격 유형 점수        매우 비동의  네오형 3점        비동의         네오형 2점        약간 비동의  네오형 1점        모르겠음      어떤 성격 유형도 점수를 얻지 않습니다        약간 동의     어피치형 1점        동의            어피치형 2점        매우 동의     어피치형 3점
      이때 검사자가 질문에서 약간 동의 선택지를 선택할 경우 어피치형(A)       성격 유형 1점을 받게 됩니다. 만약 검사자가 매우 비동의 선택지를       선택할 경우 네오형(N) 성격 유형 3점을 받게 됩니다.

      위 예시처럼 네오형이 비동의, 어피치형이 동의인 경우만 주어지지 않고,       질문에 따라 네오형이 동의, 어피치형이 비동의인 경우도 주어질 수       있습니다.        하지만 각 선택지는 고정적인 크기의 점수를 가지고 있습니다.
       - 매우 동의나 매우 비동의 선택지를 선택하면 3점을 얻습니다.        - 동의나 비동의 선택지를 선택하면 2점을 얻습니다.        - 약간 동의나 약간 비동의 선택지를 선택하면 1점을 얻습니다.        - 모르겠음 선택지를 선택하면 점수를 얻지 않습니다.
       검사 결과는 모든 질문의 성격 유형 점수를 더하여 각 지표에서 더 높은       점수를 받은 성격 유형이 검사자의 성격 유형이라고 판단합니다. 단,       하나의 지표에서 각 성격 유형 점수가 같으면, 두 성격 유형 중 사전       순으로 빠른 성격 유형을 검사자의 성격 유형이라고 판단합니다.
       질문마다 판단하는 지표를 담은 1차원 문자열 배열 survey와 검사자가       각 질문마다 선택한 선택지를 담은 1차원 정수 배열 choices가       매개변수로 주어집니다. 이때, 검사자의 성격 유형 검사 결과를 지표       번호 순서대로 return 하도록 solution 함수를 완성해주세요.
       - 제한사항         - 1 ≤ survey의 길이 ( = n) ≤ 1,000            - survey의 원소는 "RT", "TR", "FC", "CF", "MJ", "JM",             "AN","NA" 중 하나입니다.            - survey[i]의 첫 번째 캐릭터는 i+1번 질문의 비동의 관련             선택지를 선택하면 받는 성격 유형을 의미합니다.            - survey[i]의 두 번째 캐릭터는 i+1번 질문의 동의 관련 선택지를             선택하면 받는 성격 유형을 의미합니다.
          - choices의 길이 = survey의 길이              - choices[i]는 검사자가 선택한 i+1번째 질문의 선택지를               의미합니다.              - 1 ≤ choices의 원소 ≤ 7                choices 뜻                1         매우 비동의                2         비동의                3         약간 비동의                4         모르겠음                5         약간 동의                6         동의                7         매우 동의

제출한 코드 :

def solution(survey, choices):
    # 유형별 목록(같은 지표에서는 알파벳 순), score = 카테고리별 획득 점수
    category = ["R","T","C","F","J","M","A","N"]
    score = [0 for str in category]
    answer = ""

    # choices에 따른 점수 부여
    for i in range(len(choices)):
        if 4 < choices[i] <= 7:
            score[category.index(survey[i][-1])] += choices[i]-4

        if choices[i] == 4:
            pass
        if 1 <= choices[i]<4:
            score[category.index(survey[i][0])] += 4 - choices[i]

    # 지표별 최종 유형 결정
    for i in range(len(score) // 2):
        if score[2 * i] >= score[2 * i + 1]:
            answer += category[2 * i]
        else:
            answer += category[2 * i + 1]

    return answer

바탕화면 정리 (연습문제)

• 코딩테스트를 준비하는 머쓱이는 프로그래머스에서 문제를 풀고 나중에 다시 코드를 보면서 공부하려고 작성한 코드를 컴퓨터 바탕화면에 아무 위치에나 저장해 둡니다. 저장한 코드가 많아지면서 머쓱이는 본인의 컴퓨터 바탕화면이 너무 지저분하다고 생각했습니다. 프로그래머스에서 작성했던 코드는 그 문제에 가서 다시 볼 수 있기 때문에 저장해 둔 파일들을 전부 삭제하기로 했습니다.
  컴퓨터 바탕화면은 각 칸이 정사각형인 격자판입니다. 이때 컴퓨터 바탕화면의 상태를 나타낸 문자열 배열 wallpaper가 주어집니다. 파일들은 바탕화면의 격자칸에 위치하고 바탕화면의 격자점들은 바탕화면의 가장 왼쪽 위를 (0, 0)으로 시작해 (세로 좌표, 가로 좌표)로 표현합니다. 빈칸은 ".", 파일이 있는 칸은 "#"의 값을 가집니다. 드래그를 하면 파일들을 선택할 수 있고, 선택된 파일들을 삭제할 수 있습니다. 머쓱이는 최소한의 이동거리를 갖는 한 번의 드래그로 모든 파일을 선택해서 한 번에 지우려고 하며 드래그로 파일들을 선택하는 방법은 다음과 같습니다.
  

  • 드래그는 바탕화면의 격자점 S(lux, luy)를 마우스 왼쪽 버튼으로 클릭한 상태로 격자점 E(rdx, rdy)로 이동한 뒤 마우스 왼쪽 버튼을 떼는 행동입니다. 이때, "점 S에서 점 E로 드래그한다"고 표현하고 점 S와 점 E를 각각 드래그의 시작점, 끝점이라고 표현합니다.
  • 점 S(lux, luy)에서 점 E(rdx, rdy)로 드래그를 할 때, "드래그 한 거리"는 |rdx - lux| + |rdy - luy|로 정의합니다.
  • 점 S에서 점 E로 드래그를 하면 바탕화면에서 두 격자점을 각각 왼쪽 위, 오른쪽 아래로 하는 직사각형 내부에 있는 모든 파일이 선택됩니다.

  예를 들어 wallpaper = [".#...", "..#..", "...#."]인 바탕화면을 그림으로 나타내면 다음과 같습니다. 이러한 바탕화면에서 다음 그림과 같이 S(0, 1)에서 E(3, 4)로 드래그하면 세 개의 파일이 모두 선택되므로 드래그 한 거리 (3 - 0) + (4 - 1) = 6을 최솟값으로 모든 파일을 선택 가능합니다. (0, 0)에서 (3, 5)로 드래그해도 모든 파일을 선택할 수 있지만 이때 드래그 한 거리는 (3 - 0) + (5 - 0) = 8이고 이전의 방법보다 거리가 늘어납니다.
  머쓱이의 컴퓨터 바탕화면의 상태를 나타내는 문자열 배열 wallpaper가 매개변수로 주어질 때 바탕화면의 파일들을 한 번에 삭제하기 위해 최소한의 이동거리를 갖는 드래그의 시작점과 끝점을 담은 정수 배열을 return하는 solution 함수를 작성해 주세요. 드래그의 시작점이 (lux, luy), 끝점이 (rdx, rdy)라면 정수 배열 [lux, luy, rdx, rdy]를 return하면 됩니다.

  • 제한사항
    • 1 ≤ wallpaper의 길이 ≤ 50
    • 1 ≤ wallpaper[i]의 길이 ≤ 50
      • wallpaper의 모든 원소의 길이는 동일합니다.
    • wallpaper[i][j]는 바탕화면에서 i + 1행 j + 1열에 해당하는 칸의 상태를 나타냅니다.
      • wallpaper[i][j]는 "#" 또는 "."의 값만 가집니다.
      • 바탕화면에는 적어도 하나의 파일이 있습니다.
      • 드래그 시작점 (lux, luy)와 끝점 (rdx, rdy)는 lux < rdx, luy < rdy를 만족해야 합니다.

제출한 코드 :

def solution(wallpaper):
    answer = []
    maxx, minx, maxy, miny = 0, 100, 0, 100

    r = len(wallpaper)
    c = len(wallpaper[0])

    for x in range(r):
        for y in range(c):
            if wallpaper[x][y] == "#":
                minx = min(minx, x)
                miny = min(miny, y)
                maxx = max(maxx, x)
                maxy = max(maxy, y)


    return [minx, miny, maxx+1, maxy+1]

• Table: Person
• -------------+---------+ | Column Name | Type |
• -------------+---------+ | id | int | | email | varchar |
• -------------+---------+ id is the primary key (column with unique values) for this table. Each row of this table contains an email. The emails will not contain uppercase letters.
  Write a solution to delete all duplicate emails, keeping only one unique email with the smallest id.
  For SQL users, please note that you are supposed to write a DELETE statement and not a SELECT one.
  For Pandas users, please note that you are supposed to modify Person in place.
  After running your script, the answer shown is the Person table. The driver will first compile and run your piece of code and then show the Person table. The final order of the Person table does not matter.
  

제출한 쿼리 :

DELETE p1
FROM Person p1
JOIN Person p2
ON p1.email = p2.email AND p1.id > p2.id;

176. Second Highest Salary (Medium)

• Table: Employee
• -------------+------+ | Column Name | Type |
• -------------+------+ | id | int | | salary | int |
• -------------+------+ id is the primary key (column with unique values) for this table. Each row of this table contains information about the salary of an employee.
  Write a solution to find the second highest salary from the Employee table. If there is no second highest salary, return null (return None in Pandas).
  

제출한 쿼리 :

SELECT (SELECT DISTINCT salary
        FROM Employee
        ORDER BY salary DESC
        LIMIT 1 OFFSET 1
       ) AS SecondHighestSalary;

1484. Group Sold Products By The Date (Easy)

• Table Activities:
• -------------+---------+ | Column Name | Type |
• -------------+---------+ | sell_date | date | | product | varchar |
• -------------+---------+ There is no primary key (column with unique values) for this table. It may contain duplicates. Each row of this table contains the product name and the date it was sold in a market.
  Write a solution to find for each date the number of different products sold and their names.
  The sold products names for each date should be sorted lexicographically.
  Return the result table ordered by sell_date.
  

제출한 쿼리 :

SELECT sell_date
       , COUNT(DISTINCT product) AS num_sold
       , GROUP_CONCAT(DISTINCT product ORDER BY product SEPARATOR ',') AS products
FROM Activities
GROUP BY sell_date
ORDER BY sell_date;

1327. List the Products Ordered in a Period (Easy)

• Table: Products
• ------------------+---------+ | Column Name | Type |
• ------------------+---------+ | product_id | int | | product_name | varchar | | product_category | varchar |
• ------------------+---------+ product_id is the primary key (column with unique values) for this table. This table contains data about the company's products.
  Table: Orders
• ---------------+---------+ | Column Name | Type |
• ---------------+---------+ | product_id | int | | order_date | date | | unit | int |
• ---------------+---------+ This table may have duplicate rows. product_id is a foreign key (reference column) to the Products table. unit is the number of products ordered in order_date.
  Write a solution to get the names of products that have at least 100 units ordered in February 2020 and their amount.
  Return the result table in any order.
  

제출한 쿼리 :

SELECT p.product_name
       , SUM(o.unit) AS unit
FROM Orders o
JOIN Products p ON o.product_id = p.product_id
WHERE o.order_date >= '2020-02-01' 
    AND o.order_date < '2020-03-01'
GROUP BY p.product_name
HAVING SUM(o.unit) >= 100;

1517. Find Users With Valid E-Mails (Easy)

• Table: Users
• ---------------+---------+ | Column Name | Type |
• ---------------+---------+ | user_id | int | | name | varchar | | mail | varchar |
• ---------------+---------+ user_id is the primary key (column with unique values) for this table. This table contains information of the users signed up in a website. Some e-mails are invalid.
  Write a solution to find the users who have valid emails.
  A valid e-mail has a prefix name and a domain where:
  • The prefix name is a string that may contain letters (upper or lower case), digits, underscore '_', period '.', and/or dash '-'. The prefix name must start with a letter.
  • The domain is '@leetcode.com'

      Return the result table in any order.

제출한 쿼리 :

SELECT *
FROM Users
WHERE mail REGEXP '^[A-Za-z][A-Za-z0-9_\.\-]*@leetcode(\\?com)?\\.com$';