🤖 옌지니어의 IT 기록 🤖

"상상 이상의 파괴력" 2024년 네트워크 트렌드를 주도할 3가지 아이디어 (링크)

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

문제

문제 설명

두 정수 X, Y의 임의의 자리에서 공통으로 나타나는 정수 k(0 ≤ k ≤ 9)들을 이용하여 만들 수 있는 가장 큰 정수를 두 수의 짝꿍이라 합니다(단, 공통으로 나타나는 정수 중 서로 짝지을 수 있는 숫자만 사용합니다). X, Y의 짝꿍이 존재하지 않으면, 짝꿍은 -1입니다. X, Y의 짝꿍이 0으로만 구성되어 있다면, 짝꿍은 0입니다.

예를 들어, X = 3403이고 Y = 13203이라면, X와 Y의 짝꿍은 X와 Y에서 공통으로 나타나는 3, 0, 3으로 만들 수 있는 가장 큰 정수인 330입니다. 다른 예시로 X = 5525이고 Y = 1255이면 X와 Y의 짝꿍은 X와 Y에서 공통으로 나타나는 2, 5, 5로 만들 수 있는 가장 큰 정수인 552입니다(X에는 5가 3개, Y에는 5가 2개 나타나므로 남는 5 한 개는 짝 지을 수 없습니다.)
두 정수 X, Y가 주어졌을 때, X, Y의 짝꿍을 return하는 solution 함수를 완성해주세요.

제한 사항

• 3 ≤ X, Y의 길이(자릿수) ≤ 3,000,000입니다.
• X, Y는 0으로 시작하지 않습니다.
• X, Y의 짝꿍은 상당히 큰 정수일 수 있으므로, 문자열로 반환합니다.

입출력 예

소스 코드

# 1 (시간 초과)
def solution(X, Y):
    answer = ""

    inter = []

    for x in X:
        if x in Y:
            inter.append(int(x))
            Y = Y.replace(x,"",1)  

    inter.sort(reverse=True) 
    if len(inter) == 0:
        answer = "-1"
    elif inter[0] == 0:
        answer = "0"
    else:
        for i in inter:
            answer += str(i)
        
    return answer

풀이 # 1

• 교집합 원소를 담을 inter 리스트 생성
• X를 돌면서 X의 원소가 Y에 있으면 inter 리스트에 해당 원소 추가하고 Y에서 해당 원소 삭제
  • replace("바꾸기 전 문자", "바꾼 후의 문자", 바꾸고 싶은 문자 갯수)
• inter 를 내림차순으로 정렬
• inter가 없을 경우 "-1", 0이 여러개인 경우에는 "0"을 출력
• inter가 있고 0이 아니라면 리스트를 돌면서 문자를 answer에 추가

# 2
def solution(X, Y):
    answer = ""

    numberX = [0]*10
    numberY = [0]*10
    
    # 각 숫자가 몇 개씩 있는지 카운트
    for x in X:
        numberX[int(x)] += 1
    
    for y in Y:
        numberY[int(y)] += 1


    # 반복문을 돌면서 추가
    for idx in range(9,-1,-1):
        if numberX[idx] > 0 and numberY[idx] > 0:
            cnt = min(numberX[idx], numberY[idx])
            answer += (str(idx) * cnt)

    if answer == "":
        answer = "-1"
    elif answer[0] == "0":
        answer = "0"

        
    return answer

풀이 #2

• X와 Y의 각 숫자 갯수를 numberX와 numberY에 카운트 (각 숫자 = 인덱스)
• sort를 하지 않기 위해 가장 큰 수부터 반복문
  • numberX와 numberY에 둘 다 존재하면 둘 중에 작은 수만큼 answer에 추가
• 교집합이 없거나 0이 여러 개인 경우 처리

문제 자체는 단순한데 제한 사항을 보면 정수가 상당히 클 수도 있다는 조건이 있다. sort를 이용하면 시간이 오래 걸리므로 sort를 사용하지 않고 for문도 10개 숫자 내에서 돌도록 코드를 수정하였다. 통과는 했지만 시간이 적게 걸리는 것 같지는 않다. 시간 복잡도도 고려해서 코드를 짜는 게 중요한데....어렵구만...

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

문제

문제 설명

나만의 카카오 성격 유형 검사지를 만들려고 합니다.
성격 유형 검사는 다음과 같은 4개 지표로 성격 유형을 구분합니다. 성격은 각 지표에서 두 유형 중 하나로 결정됩니다.

4개의 지표가 있으므로 성격 유형은 총 16(=2 x 2 x 2 x 2)가지가 나올 수 있습니다. 예를 들어, "RFMN"이나 "TCMA"와 같은 성격 유형이 있습니다.

검사지에는 총 n개의 질문이 있고, 각 질문에는 아래와 같은 7개의 선택지가 있습니다.

• 매우 비동의
• 비동의
• 약간 비동의
• 모르겠음
• 약간 동의
• 동의
• 매우 동의

각 질문은 1가지 지표로 성격 유형 점수를 판단합니다.

예를 들어, 어떤 한 질문에서 4번 지표로 아래 표처럼 점수를 매길 수 있습니다.

이때 검사자가 질문에서 약간 동의 선택지를 선택할 경우 어피치형(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

입출력 예

소스 코드

# 1
def solution(survey, choices):
    answer = ''

    types = [["R","T"],["C","F"],["J","M"],["A","N"]]
    scores = [[0,0],[0,0],[0,0],[0,0]]

    # survey 기반 점수 계산
    n = len(survey)
    for idx in range(n):
        front = survey[idx][0]
        back = survey[idx][1]
        if "R" in survey[idx]:
            if choices[idx] < 4:
                scores[0][types[0].index(front)] += (4-choices[idx])
            else:
                scores[0][types[0].index(back)] += (choices[idx]-4)
        elif "C" in survey[idx]:
            if choices[idx] < 4:
                scores[1][types[1].index(front)] += (4-choices[idx])
            else:
                scores[1][types[1].index(back)] += (choices[idx]-4)
        elif "J" in survey[idx]:
            if choices[idx] < 4:
                scores[2][types[2].index(front)] += (4-choices[idx])
            else:
                scores[2][types[2].index(back)] += (choices[idx]-4)
        elif "A" in survey[idx]:
            if choices[idx] < 4:
                scores[3][types[3].index(front)] += (4-choices[idx])
            else:
                scores[3][types[3].index(back)] += (choices[idx]-4)          



    # scores를 보고 점수가 높은 유형 출력 
    for idx in range(4):
        if scores[idx][0] >= scores[idx][1]:
            answer += types[idx][0]
        else:
            answer += types[idx][1]

    return answer

풀이 # 1

• 각 타입과 점수를 2차원 배열로 생성
• survey 길이만큼 인덱스를 돌면서 점수를 계산
  • survey에서 앞글자와 뒷글자를 구분
  • 어떤 글자를 포함하고 있는지 확인하고 socres에 점수 더하기
  • 점수가 4보다 작으면 앞글자의 인덱스에 4보다 크면 뒷글자의 인덱스에 점수 더하기
• 앞에서 계산한 scores를 돌면서 점수가 높은 값의 type을 answer로 출력

# 2
def solution(survey, choices):
    answer = ''

    scores = {"A":0, "N":0, "C":0, "F":0, "M":0, "J":0, "R":0, "T":0}
    for idx, choice in enumerate(choices):
        if choice - 4 > 0:
            scores[survey[idx][1]] += choice - 4
        elif choice - 4 < 0:
            scores[survey[idx][0]] += 4 - choice

    if scores["R"] >= scores["T"]:
        answer += "R"
    else:
        answer += "T"

    if scores["C"] >= scores["F"]:
        answer += "C"
    else:
        answer += "F"

    if scores["J"] >= scores["M"]:
        answer += "J"
    else:
        answer += "M"

    if scores["A"] >= scores["N"]:
        answer += "A"
    else:
        answer += "N"
    

    return answer

풀이 #2

• 딕셔너리의 키에 유형 값에 점수를 표기
• 점수가 4보다 작으면 앞글자의 인덱스에 4보다 크면 뒷글자의 인덱스에 점수 더하기
• RT, CF, JM, AN의 점수를 각각 비교해서 answer로 출력

# 3
def solution(survey, choices):
    types = {"RT":0,"CF":0,"JM":0,"AN":0}
    
    for A,B in zip(survey,choices):
        if A not in types.keys():
            A = A[::-1]
            types[A] -= B-4
        else:
            types[A] += B-4

    answer = ''    
    for name in types.keys():
        if types[name] > 0:
            answer += name[1]
        elif types[name] < 0:
            answer += name[0]
        else:
            answer += sorted(name)[0]

    return answer

풀이 #3

• 짝이 되는 유형끼리 딕셔너리의 키로 구성
• survey에 있는 문자가 딕셔너리의 키가 아닌 경우에 키를 역순으로 바꾸고 점수 빼기 (순서 변경 O)
  
  • 점수가 높으면 (점수-4)가 0보다 크므로 양수 = 뒤에 있는 문자에 점수 빼기
  • 점수가 낮으면 (점수-4)가 0보다 작으므로 음수 = 뒤에 있는 문자에 점수 더하기
• survey에 있는 문자가 딕셔너리의 키인 경우에는 그냥 점수 더하기 (순서 변경 X)
  • 점수가 높으면 (점수-4)가 0보다 크므로 양수 = 뒤에 있는 문자에 점수 더하기
  • 점수가 낮으면 (점수-4)가 0보다 작으므로 음수 = 뒤에 있는 문자에 점수 빼기
• 위의 방식대로 점수를 더하고 빼면 점수는 결국 키의 뒷 문자 기반
  • 점수가 0보다 크면 뒷 문자를 출력하고 0보다 작은면 앞 문자를 출력

문제에 대해 설명이 자세해서 이해는 잘 되었는데 코드를 구현하려니까 좀 복잡해졌다. 첫 번째 풀이는 점수가 4보다 작으면 앞에 있는 문자에 +3, 4보다 크면 뒤에 있는 문자에 +3이 되는 것을 이용해서 풀었다. 첫 번째 풀이 기반으로 딕셔너리를 이용해서 두 번째 풀이까지 만들었는데 다른 사람 풀이를 보다 보니 세 번째 풀이가 진짜 씽크빅이어서 추가했다....문자열을 바꾸면서 점수 더하기? 도대체 이런 생각은 어떻게 하시는거에요? 해석하기도 어려웠는데...천재 아니신가요...? 

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

문제

문제 설명

머쓱이는 구슬을 친구들에게 나누어주려고 합니다. 구슬은 모두 다르게 생겼습니다. 머쓱이가 갖고 있는 구슬의 개수 balls와 친구들에게 나누어 줄 구슬 개수 share이 매개변수로 주어질 때, balls개의 구슬 중 share개의 구슬을 고르는 가능한 모든 경우의 수를 return 하는 solution 함수를 완성해주세요.

제한 사항

• 1 ≤ balls ≤ 30
• 1 ≤ share ≤ 30
• 구슬을 고르는 순서는 고려하지 않습니다.
• share ≤ balls

입출력 예

소스 코드

# 1 (런타임 에러)
def solution(balls, share):
    answer = 1
    
    ball_list = list(range(balls,1,-1))
    share_list = list(range(1,share+1))
    
    for idx in range(1,share+1):
        answer *= ball_list[idx-1]
        answer = int(answer/share_list[idx-1])
    
    
    return answer

풀이 # 1

• 공의 갯수에서 1씩 빼서 ball_list에 담고, 공유할 공의 갯수를 1부터 1씩 더해 share_list에 담기
• share 숫자 범위에서 ball_list의 원소는 곱하고 share_list의 원소는 나누기

# 2
def solution(balls, share):
    answer = 1
    cnt = 0

    while cnt < share:
        answer *= (balls-cnt)
        answer = int(answer/(cnt+1))
        cnt += 1    
    
    return answer

풀이 #2

• cnt가 share의 숫자보다 작을동안 곱하기와 나누기를 실행
  • balls-cnt를 곱하기
  • 위의 숫자에서 cnt+1을 나누기 

# 3
import math

def solution(balls, share):
    return math.comb(balls, share)

풀이 #3

• math 라이브러리에서 combination 함수 사용

처음에 숫자를 곱하고 나누는 방향으로 하다가 잘 안되길래 리스트로 풀어봤는데 역시나 런타임 에러가 났다. 그래서 숫자를 조작해서 while문에 넣었더니 결과는 나왔지만 뭔가 더 빠르게 나왔으면 좋겠다는 생각이 들었다. 다른 사람들의 풀이를 보다보니 math 라이브러리에 combination 함수가 있었다...라이브러리 함수 쓰는거 최고...!!

구글, AI 언어모델 '제미나이' 공개…"GPT-4·사람 능력 넘어" (링크)

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

문제

문제 설명

선분 3개가 평행하게 놓여 있습니다. 세 선분의 시작과 끝 좌표가 [[start, end], [start, end], [start, end]] 형태로 들어있는 2차원 배열 lines가 매개변수로 주어질 때, 두 개 이상의 선분이 겹치는 부분의 길이를 return 하도록 solution 함수를 완성해보세요.

lines가 [[0, 2], [-3, -1], [-2, 1]]일 때 그림으로 나타내면 다음과 같습니다.

선분이 두 개 이상 겹친 곳은 [-2, -1], [0, 1]로 길이 2만큼 겹쳐있습니다.

제한 사항

• lines의 길이 = 3
• lines의 원소의 길이 = 2
• 모든 선분은 길이가 1 이상입니다.
• lines의 원소는 [a, b] 형태이며, a, b는 각각 선분의 양 끝점 입니다.
• -100 ≤ a < b ≤ 100

입출력 예

소스 코드

# 1
def solution(lines):
    answer = 0
    count = [0]*200
    
    starts = []
    ends = []

    for line in lines:
        start, end = line

        starts.append(start)
        ends.append(end)

        for num in range(start, end):
            count[num+100] += 1

    for cnt in count[100+min(starts):100+max(ends)+1]:
        if cnt > 1:
            answer += 1

    return answer

풀이 # 1

• 원소가 0인 길이 200의 리스트 count 생성
  • 선분이 점 (-100,100) 범위에 있으므로 길이가 200
• 각 선분의 시작 및 끝 좌표를 담을 starts / ends 리스트 생성
• linelist 돌기
  • 각 선분의 시작 및 끝 좌표 추가
  • 시작과 끝 좌표 사이 숫자에 +1 (count 리스트 범위가 -100~100이므로 인덱스에 +100)
• 시작 좌표 중 가장 작은 수와 끝 좌표 중 가장 큰 수 범위에서 count가 2보다 크면 선분이 겹치는 것이므로 +1

# 2
def solution(lines):
    s1 = set(i for i in range(lines[0][0], lines[0][1]))
    s2 = set(i for i in range(lines[1][0], lines[1][1]))
    s3 = set(i for i in range(lines[2][0], lines[2][1]))
    
    return len((s1 & s2) | (s2 & s3) | (s1 & s3))

풀이 #2

• 각 라인의 시작 좌표부터 끝 좌표까지의 숫자를 세트로 생성 (s1 / s2 / s3)
• 선분끼리의 교집합(&)들의 합집합(|) 길이를 출력

(-100,100) 범위를 만들어 놓는 걸 생각하지 못했었는데 범위를 만들고 나니 간단하게 풀 수 있는 문제였다. 굳이 시작과 끝 좌표의 min/max는 구하지 않아도 괜찮을 거 같다. 두 번째 풀이처럼 세트에서 합집합과 교집합을 이용하면 더 간단하게 풀 수 있는 문제인데...방법을 생각해 내는 게 항상 어렵다...

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

문제

문제 설명

정수 n을 기준으로 n과 가까운 수부터 정렬하려고 합니다. 이때 n으로부터의 거리가 같다면 더 큰 수를 앞에 오도록 배치합니다. 정수가 담긴 배열 numlist와 정수 n이 주어질 때 numlist의 원소를 n으로부터 가까운 순서대로 정렬한 배열을 return하도록 solution 함수를 완성해주세요.

제한 사항

• 1 ≤ n ≤ 10,000
• 1 ≤ numlist의 원소 ≤ 10,000
• 1 ≤ numlist의 길이 ≤ 100
• numlist는 중복된 원소를 갖지 않습니다.

입출력 예

소스 코드

# 1
def solution(numlist, n):
    # Key = 숫자 / Value = 차이
    num_diff = {}
    for num in numlist:
        num_diff[num] = abs(num-n)   

    rank = dict(sorted(num_diff.items(), key=lambda x:(x[1],-x[0])))
    
    return list(rank.keys())

풀이 # 1

• num_diff 라는 딕셔너리 생성
  • Key값에 numlist의 숫자 / Value값에 numlist 숫자와 n의 차이 입력
• rank라는 딕셔너리 생성
  • num_diff의 Value(= numlist 숫자와 n의 차이) 기준 오름차순 정렬 → x[1]
  • Value가 같다면 Key가 큰 값 먼저 오도록 내림차순 정렬 → -x[0]
• 정렬된 rank 딕셔너리의 Key값(=numlist의 숫자) 출력

# 2
def solution(numlist, n):
    numlist.sort(key=lambda x:(abs(n-x), -x))
    return numlist

풀이 #2

• numlist 숫자와 n의 차이 오름차순 / numlist 숫자 내림차순으로 정렬
• 정렬된 numlist 출력

첫 번째 풀이는 '차이값 만들기 → 차이값과 숫자를 딕셔너리에 넣기 → 차이값 기준으로 정렬하기 → 정렬된 딕셔너리에서 키 값 출력하기' 의 과정을 거치고 두 번째 풀이는 '차이값 기준으로 정렬하기'가 끝이다. 원리?는 같지만 얼마나 간결하게 표현하는지에 따라서 코드가 좀 더 깔끔해지는 것 같다. 문제를 많이 풀어봐야겠다고 3928490번째 다짐하는 중이다. 

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

문제

문제 설명

양의 정수 n이 매개변수로 주어집니다. n × n 배열에 1부터 n^2까지 정수를 인덱스 [0][0]부터 시계방향 나선형으로 배치한 이차원 배열을 return 하는 solution 함수를 작성해 주세요.

제한 사항

• 1 ≤ n ≤ 30

입출력 예

소스 코드

def solution(n):
    if n == 1:
        return [[1]]

    answer = [[0 for j in range(n)] for i in range(n)]

    i = 0       # 행
    j = 0       # 열
    dir = 'r'   # 방향
    
    for num in range(n*n):
        answer[i][j] = num+1
        if dir == 'r':
            j += 1
            if j == n-1 or answer[i][j+1] != 0:
                dir = 'd'
        elif dir == 'd':
            i += 1
            if i == n-1 or answer[i+1][j] != 0:
                dir = 'l'
        elif dir == 'l':
            j -= 1
            if j == 0 or answer[i][j-1] != 0:
                dir = 'u'
        else:
            i -= 1
            if i == 0 or answer[i-1][j] != 0:
                dir = 'r'            
    
    
    return answer

풀이

• 1 x 1 배열인 경우에 [[1]]을 출력
• 행 번호 = i / 열 번호 = j / 방향 = dir (r:오른쪽 → d:아래쪽  → l:왼쪽 → u:위쪽)
• n x n 범위를 돌면서 숫자를 하나씩 채워주는 for문
  • 방향이 오른쪽인 경우 : 열 한 칸 이동 / 마지막 열이거나 칸이 채워져 있으면 방향 변경
  • 방향이 아래쪽인 경우 : 행 한 칸 이동 / 마지막 행이거나 칸이 채워져 있으면 방향 변경
  • 방향이 왼쪽인 경우 : 열 한 칸 앞으로 이동 / 첫 번째 열이거나 칸이 채워져 있으면 방향 변경
  • 방향이 위쪽인 경우 : 행 한 칸 위로 이동 / 첫 번째 행이거나 칸이 채워져 있으면 방향 변경

이거 레벨0 맞아요..? 그렇다면 내 실력이 마이너스인가보다....이런 저런 방식으로 해보다가 결국 검색해서 알게 되었는데 앞으로 더 많은 문제를 풀어봐야겠다는 생각이 든다...플러스 실력이 될 때까지 화이팅..!!