2023.7.31.월요일 : 코딧 강의와 프로그래머스 문제

코딧 강의와 프로그래머스 문제, 특히 프로그래머스 문제는 건들기는 하였으나 실제로 푼건 반정도 된다. 

나머지는 쳇이용도 하고 그래도 안되면 다시 보려고 패스/pass 표시를 했다. - 다시 도전 

현재 2010개 건들여서, 197개 풀었고, 나머지는 패스 혹은 답을 본 것이다.  오늘 21문제 중 8개 pass 했다. 

한지언

• 순위
  18,890위
• 점수
  1,370점
• 해결한 문제
  197개

 

7.31.월요일 

import pandas as pd

 

df = pd.read_csv('data/body_imperial1.csv', index_col=0)

 

# 여기에 코드를 작성하세요

 

# 테스트 코드

df.loc[[1,'Weight(Pound)']] ='200'

df.drop =(21, axis="index", inplace =True) 

df.loc[20]=[70,200]

df

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

File "<ipython-input-1-ebe9af57a6bd>" , line 9

df.drop =(21, axis="index", inplace =True)

^

SyntaxError : invalid syntax

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

해당 코드에서는 DataFrame에서 특정 행을 삭제하는 명령어를 실행하려고 하였으나, 문법 오류가 발생하여 실행되지 않았습니다. 

`SyntaxError`는 파이썬 코드 문법 오류를 나타내는 예외 클래스입니다. 

 

또한, 코드에서 사용된 용어들을 정의하면 다음과 같습니다.

 

- `DataFrame`: 판다스(Pandas) 라이브러리에서 제공하는 2차원 데이터 구조로, 행과 열로 이루어진 표 형태의 데이터를 다룹니다.

- `drop`: DataFrame에서 특정 행이나 열을 삭제하는 메서드입니다.

- `axis`: `drop` 메서드에서 삭제할 축을 지정하는 매개변수입니다. `axis="index"`는 행을 삭제하겠다는 의미입니다.

- `inplace`: `drop` 메서드에서 삭제한 결과를 원본 DataFrame에 적용할지 여부를 지정하는 매개변수입니다. `inplace=True`는 원본 DataFrame을 변경하겠다는 의미입니다.

 

 

프로그래머스

• 190//32전국 대회 선발 고사//못 풀었다//패스 

 

문제 설명

0번부터 n - 1번까지 n명의 학생 중 3명을 선발하는 전국 대회 선발 고사를 보았습니다. 등수가 높은 3명을 선발해야 하지만, 개인 사정으로 전국 대회에 참여하지 못하는 학생들이 있어 참여가 가능한 학생 중 등수가 높은 3명을 선발하기로 했습니다.

각 학생들의 선발 고사 등수를 담은 정수 배열 rank와 전국 대회 참여 가능 여부가 담긴 boolean 배열 attendance가 매개변수로 주어집니다. 전국 대회에 선발된 학생 번호들을 등수가 높은 순서대로 각각 a, b, c번이라고 할 때 10000 × a + 100 × b + c를 return 하는 solution 함수를 작성해 주세요.

 

제한사항

• 3 ≤ rank의 길이 = attendance의 길이 ≤ 100
• rank[i]는 i번 학생의 선발 고사 등수를 의미합니다.
• rank의 원소는 1부터 n까지의 정수로 모두 서로 다릅니다.
• attendance[i]는 i번 학생의 전국 대회 참석 가능 여부를 나타냅니다.
• attendance의 원소 중 적어도 3개는 true입니다.

입출력 예

rank	attendance	result
[3, 7, 2, 5, 4, 6, 1]	[false, true, true, true, true, false, false]	20403
[1, 2, 3]	[true, true, true]	102
[6, 1, 5, 2, 3, 4]	[true, false, true, false, false, true]	50200

 

입출력 예 설명

입출력 예 #1

• 예제 1번에서 1등은 6번 학생이지만 전국 대회에 참석 불가능하므로 넘어갑니다. 2등은 2번 학생이고 전국 대회에 참석 가능하므로 1순위로 선발됩니다. 3등은 0번 학생이고 전국 대회에 참석 불가능 하므로 넘어갑니다. 4등과 5등은 각각 4번, 3번 학생이고 두 학생 모두 전국 대회에 참석 가능하므로 각각 2순위, 3순위로 선발됩니다. 3명을 선발하였으므로 6등과 7등은 확인하지 않아도 됩니다. 따라서 10000 × 2 + 100 × 4 + 3 = 20403을 return 합니다.

입출력 예 #2

• 예제 2번에서 1, 2, 3등은 각각 0번, 1번, 2번 학생이고 세 학생 모두 전국 대회에 참석 가능하므로 각각 1순위, 2순위, 3순위로 선발됩니다. 따라서 10000 × 0 + 100 × 1 + 2 = 102를 return 합니다.

입출력 예 #3

• 예제 3번에서 1, 2, 3등은 각각 1번, 3번, 4번 학생이지만 세 학생 모두 전국 대회에 참석 불가능합니다. 다음으로 4, 5, 6등은 각각 5번, 2번, 0번 학생이고 세 학생 모두 전국 대회에 참석 가능하므로 각각 1순위, 2순위, 3순위로 선발됩니다. 따라서 10000 × 5 + 100 × 2 + 0 = 50200을 return 합니다.

def select_students(rank, attendance):

    n = len(rank)

    eligible_students = [(r, i) for i, r in enumerate(rank) if attendance[i]]

    eligible_students.sort(reverse=True)

 

    a, b, c = eligible_students[:3]

 

    return 10000 * a[1] + 100 * b[1] + c[1]

 

# Test cases

print(select_students([3, 7, 2, 5, 4, 6, 1], [False, True, True, True, True, False, False]))  # Output: 20403

print(select_students([1, 2, 3], [True, True, True]))  # Output: 102

print(select_students([6, 1, 5, 2, 3, 4], [True, False, True, False, False, True]))  # Output: 50200

 

 

• 191//31수열과 구간 쿼리 2
•  

문제 설명

정수 배열 arr와 2차원 정수 배열 queries이 주어집니다. queries의 원소는 각각 하나의 query를 나타내며, [s, e, k] 꼴입니다.

각 query마다 순서대로 s ≤ i ≤ e인 모든 i에 대해 k보다 크면서 가장 작은 arr[i]를 찾습니다.

각 쿼리의 순서에 맞게 답을 저장한 배열을 반환하는 solution 함수를 완성해 주세요.
단, 특정 쿼리의 답이 존재하지 않으면 -1을 저장합니다.

 

제한사항

• 1 ≤ arr의 길이 ≤ 1,000
• 1 ≤ queries의 길이 ≤ 1,000

입출력 예

arr	queries	result
[0, 1, 2, 4, 3]	[[0, 4, 2],[0, 3, 2],[0, 2, 2]]	[3, 4, -1]

입출력 예 설명

입출력 예 #1

• 첫 번째 쿼리의 범위에는 0, 1, 2, 4, 3이 있으며 이 중 2보다 크면서 가장 작은 값은 3입니다.
• 두 번째 쿼리의 범위에는 0, 1, 2, 4가 있으며 이 중 2보다 크면서 가장 작은 값은 4입니다.
• 세 번째 쿼리의 범위에는 0, 1, 2가 있으며 여기에는 2보다 큰 값이 없습니다.
• 따라서 [3, 4, -1]을 return 합니다.

 

def solution(arr, queries):

    result = []

    for query in queries:

        s, e, k = query

        smallest_greater = float('inf')

        found = False

 

        for i in range(s, e + 1):

            if arr[i] > k and arr[i] < smallest_greater:

                smallest_greater = arr[i]

                found = True

 

        result.append(smallest_greater if found else -1)

 

    return result

 

 

def solution(arr, queries):

    answer = []

    for s, e, k in queries:

        tmp = []

        for x in arr[s:e+1]:

            if x > k:

                tmp.append(x)

        answer.append(-1 if not tmp else min(tmp))

    return answer

 

def solution(arr, queries):

    answer = []

    for s, e, k in queries:

        l = [i for i in arr[s:e+1] if i > k]

        answer.append(-1 if len(l) == 0 else min(l))

    return answer

 

def solution(arr, queries):

    return list(map(lambda x: -1 if x==10**6 else x, [min(list(filter(lambda x: x > k, arr[s:e+1])) + [10**6]) for s, e, k in queries]))

 

def solution(arr, queries):

    answer = []

    for (s, e, k) in queries:

        num = int(1e9)

        for i in range(s, e + 1):

            if arr[i] > k:

                num = min(num, arr[i])

        answer.append(num if num != int(1e9) else -1)

    return answer

 

def solution(arr, queries):

    answer = []

    for s, e, k in queries:

        temp = []

        for idx, n in enumerate(arr):

            if s<=idx<=e and n>k:

                temp.append(n)

        answer.append(min(temp) if temp else -1)

 

    return answer

 

• 192//31문자열 여러 번 뒤집기
• 
  문제 설명

문자열 my_string과 이차원 정수 배열 queries가 매개변수로 주어집니다. queries의 원소는 [s, e] 형태로, my_string의 인덱스 s부터 인덱스 e까지를 뒤집으라는 의미입니다. my_string에 queries의 명령을 순서대로 처리한 후의 문자열을 return 하는 solution 함수를 작성해 주세요.

 

제한사항

• my_string은 영소문자로만 이루어져 있습니다.
• 1 ≤ my_string의 길이 ≤ 1,000
• queries의 원소는 [s, e]의 형태로 0 ≤ s ≤ e < my_string의 길이를 만족합니다.
• 1 ≤ queries의 길이 ≤ 1,000

 

입출력 예

my_string	queries	result
"rermgorpsam"	[[2, 3], [0, 7], [5, 9], [6, 10]]	"programmers"

입출력 예 설명

• 예제 1번의 my_string은 "rermgorpsam"이고 주어진 queries를 순서대로 처리하면 다음과 같습니다.

• 따라서 "programmers"를 return 합니다.	• my_string
•	• "rermgorpsam"
• [2, 3]	• "remrgorpsam"
• [0, 7]	• "progrmersam"
• [5, 9]	• "prograsremm"
• [6, 10]	• "programmers"

 

def solution(my_string, queries):

    # 문자열을 리스트로 변환

    my_list = list(my_string)

    

    # 쿼리를 순서대로 처리

    for query in queries:

        start, end = query[0], query[1]

        my_list[start:end+1] = reversed(my_list[start:end+1])

    

    # 리스트를 문자열로 변환하여 반환

    return ''.join(my_list)

해당 함수는 문자열과 쿼리 리스트를 인자로 받아서, 쿼리를 순서대로 처리한 후 변환된 문자열을 반환합니다.

 

문자열을 리스트로 변환한 후, 쿼리를 순서대로 처리하면 됩니다. 각 쿼리는 시작 인덱스와 끝 인덱스가 주어지며, 해당 구간을 뒤집으면 됩니다. 이를 위해서 파이썬 내장 함수인 reversed를 사용합니다. 그리고 마지막으로, 리스트를 문자열로 변환하여 반환합니다.

 

def solution(my_string, queries):

    answer=list(my_string)

    for s,e in queries:

        answer[s:e+1]=answer[s:e+1][::-1]

    return ''.join(answer)

 

def solution(my_string, queries):

    for (s, e) in queries:

        my_string = my_string[:s] + my_string[s:e+1][::-1] + my_string[e+1:]

    return my_string

 

def solution(s,q):

    s=[*s]

    for t in q:a,b=t;s[a:b+1]=s[a:b+1][::-1]

    return ''.join(s)

 

 

• 193//30배열 만들기 6
•  

문제 설명

0과 1로만 이루어진 정수 배열 arr가 주어집니다. arr를 이용해 새로운 배열 stk을 만드려고 합니다.

i의 초기값을 0으로 설정하고 i가 arr의 길이보다 작으면 다음을 반복합니다.

• 만약 stk이 빈 배열이라면 arr[i]를 stk에 추가하고 i에 1을 더합니다.
• stk에 원소가 있고, stk의 마지막 원소가 arr[i]와 같으면 stk의 마지막 원소를 stk에서 제거하고 i에 1을 더합니다.
• stk에 원소가 있는데 stk의 마지막 원소가 arr[i]와 다르면 stk의 맨 마지막에 arr[i]를 추가하고 i에 1을 더합니다.

위 작업을 마친 후 만들어진 stk을 return 하는 solution 함수를 완성해 주세요.

단, 만약 빈 배열을 return 해야한다면 [-1]을 return 합니다.

제한사항

• 1 ≤ arr의 길이 ≤ 1,000,000

 

입출력 예

arr	result
[0, 1, 1, 1, 0]	[0, 1, 0]
[0, 1, 0, 1, 0]	[0, 1, 0, 1, 0]
[0, 1, 1, 0]	[-1]

입출력 예 설명

입출력 예 설명

입출력 예 #1

• 각 작업을 마친 후에 배열의 변화를 나타내면 다음 표와 같습니다.

idx	arr[idx]	stk
0	0	[]
1	1	[0]
2	1	[0, 1]
3	1	[0]
4	0	[0, 1]
5	-	[0, 1, 0]

• 따라서 [0, 1, 0]을 return 합니다.

 

입출력 예 #2

• 각 작업을 마친 후에 배열의 변화를 나타내면 다음 표와 같습니다.

idx	arr[idx]	stk
0	0	[]
1	1	[0]
2	0	[0, 1]
3	1	[0, 1, 0]
4	0	[0, 1, 0, 1]
5	-	[0, 1, 0, 1, 0]

• 따라서 [0, 1, 0, 1, 0]을 return 합니다.

 

입출력 예 #3

• 각 작업을 마친 후에 배열의 변화를 나타내면 다음 표와 같습니다.

idx	arr[idx]	stk
0	0	[]
1	1	[0]
2	1	[0, 1]
3	0	[0]
4	-	[]

• 마지막에 빈 배열이 되었으므로 [-1]을 return 합니다.

 

 

def solution(arr):

    stk = []

    i = 0

 

    while i < len(arr):

        if not stk:

            stk.append(arr[i])

            i += 1

        elif stk[-1] == arr[i]:

            stk.pop()

            i += 1

        else:

            stk.append(arr[i])

            i += 1

 

    if not stk:

        return [-1]

    return stk

 

 

def solution(arr):

    stk = []

    for i in range(len(arr)):

        if stk and stk[-1] == arr[i]:

            stk.pop()

        else:

            stk.append(arr[i])

 

    return stk or [-1]

 

 

def solution(arr):

    answer = []

 

    stk, i = [], 0

    while i < len(arr):

        if not stk:

            stk.append(arr[i])

        elif stk[-1] == arr[i]:

            stk.pop()

        else:

            stk.append(arr[i])

        i += 1

 

    if stk:

        answer = stk[:]

    else:

        answer = [-1]

 

    return answer

 

 

def solution(arr):

    answer = []

    for x in arr:

        if not answer:answer.append(x)

        elif answer[-1]==x: answer.pop()

        else: answer.append(x)

    if not answer:answer.append(-1)

    return answer

 

 

def solution(arr):

    stk = []

    i = 0

    while i < len(arr):

        if len(stk) == 0:

            stk.append(arr[i])

            i += 1

        elif stk[-1] == arr[i]:

            stk.pop()

            i += 1

        else:

            stk.append(arr[i])

            i += 1

    return stk if len(stk) > 0 else [-1]

 

 

 

 

194//29 a와 b 출력하기

• 
  문제 설명

정수 a와 b가 주어집니다. 각 수를 입력받아 입출력 예와 같은 형식으로 출력하는 코드를 작성해 보세요.

 

제한사항

• -100,000 ≤ a, b ≤ 100,000

 

입출력 예

입력 #1

4 5

출력 #1

a = 4

b = 5

def main():

    # Get input values for a and b

    a, b = map(int, input().split())

 

    # Print the output in the specified format

    print(f"a = {a}")

    print(f"b = {b}")

 

if __name__ == "__main__":

    main()

파이썬에서는 input() 함수를 사용하여 사용자 입력을 받은 다음 원하는 형식으로 출력을 인쇄함으로써

 이를 달성할 수 있습니다. 

코드는 다음과 같습니다.

main() 함수는 input() 및 split() 함수를 사용하여 a 및 b에 대한 입력 값을 읽어 입력 문자열을 두 개의 정수로 분할합니다. 그런 다음 f-문자열을 사용하여 원하는 형식으로 출력을 인쇄합니다.

이 코드를 실행하면 공백으로 구분된 두 개의 정수를 입력할 때까지 기다립니다. 값을 입력하고 Enter 키를 누르면 프로그램이 문제 설명에 지정된 형식으로 출력을 인쇄합니다. 예를 들어:

문제 설명에 명시된 대로 -100,000에서 100,000 사이의 입력 범위를 준수해야 합니다.

 

main() 함수를 정의합니다. 이 함수는 프로그램의 주요 로직이 담긴 함수입니다.

input() 함수를 사용하여 사용자로부터 입력 값을 받습니다. input() 함수는 사용자가 키보드로 값을 입력할 때까지 프로그램이 대기하고, 사용자가 엔터를 누르면 입력을 받아옵니다. input().split()은 입력된 값을 공백으로 분리하여 리스트로 변환하는 기능을 합니다.

map(int, ...) 함수를 사용하여 입력된 값들을 정수로 변환합니다. 

map() 함수는 리스트나 다른 반복 가능한 객체의 모든 요소에 특정 함수를 적용합니다. 

여기서는 입력된 값들을 int 함수를 사용하여 정수로 변환합니다.

 

a와 b에 정수로 변환된 값을 각각 할당합니다. 즉, 사용자가 입력한 두 개의 정수값이 각각 a와 b에 저장됩니다.

print(f"a = {a}")를 사용하여 a의 값을 출력합니다. 여기서 f-string을 사용합니다. f-string은 문자열 안에서 중괄호 {}로 변수나 표현식을 사용할 수 있게 해줍니다. 

중괄호 안에 변수 이름을 넣으면 해당 변수의 값으로 치환됩니다.

 

print(f"b = {b}")를 사용하여 b의 값을 출력합니다. 앞서 설명한 방식으로 b의 값을 출력합니다.

__name__ 변수는 현재 모듈의 이름을 나타내는 특별한 변수입니다. 모듈은 실행되는 파이썬 파일을 의미합니다. 

__name__ 변수가 "__main__"인 경우, 이는 현재 모듈이 직접 실행되었다는 것을 의미합니다.

if __name__ == "__main__":은 현재 모듈이 직접 실행될 때만 main() 함수를 호출하는 조건문입니다. 

즉, 다른 모듈에서 이 파일을 임포트하여 사용할 때는 main() 함수가 실행되지 않습니다. 

이 부분은 스크립트 파일이 다른 모듈에 임포트되는 경우에는 실행하지 않고, 직접 실행될 때만 main() 함수를 호출하여 코드를 실행하는데 사용됩니다.

 

이 코드를 실행하면 다음과 같은 동작이 이루어집니다.

• 프로그램이 시작되면 사용자에게 a와 b의 값을 입력하라는 메시지가 표시됩니다.
• 사용자는 정수 두 개를 공백으로 구분하여 입력합니다.
• 사용자가 엔터를 입력하면 input() 함수는 입력된 값을 문자열로 받아옵니다.
• map(int, ...) 함수가 문자열을 공백으로 분리하여 정수로 변환합니다.
• 변환된 정수 값들이 a와 b에 할당됩니다.
• f-string을 사용하여 a와 b의 값을 출력합니다.
• 프로그램이 종료됩니다.

이상의 코드는 사용자로부터 입력을 받고, 그 입력 값을 출력하는 간단한 기능을 가지고 있습니다.

 

a, b = map(int, input().strip().split(' '))

print(f"a = {a}\nb = {b}")

 

 

a, b = map(int, input().strip().split(' '))

print("a =",a) 

print("b =",b)

 

 

a, b = map(int, input().strip().split(' '))

print('a = {}\nb = {}'.format(a, b))

 

a, b = map(int, input().strip().split(' '))

print("a =", str(a))

print("b =", str(b))

 

a, b = map(int, input().strip().split(' '))

print('a =', a, '\nb =',b)

 

 

• 195//28외계어 사전

문제 설명

PROGRAMMERS-962 행성에 불시착한 우주비행사 머쓱이는 외계행성의 언어를 공부하려고 합니다. 알파벳이 담긴 배열 spell과 외계어 사전 dic이 매개변수로 주어집니다. spell에 담긴 알파벳을 한번씩만 모두 사용한 단어가 dic에 존재한다면 1, 존재하지 않는다면 2를 return하도록 solution 함수를 완성해주세요.

 

제한사항

• spell과 dic의 원소는 알파벳 소문자로만 이루어져있습니다.
• 2 ≤ spell의 크기 ≤ 10
• spell의 원소의 길이는 1입니다.
• 1 ≤ dic의 크기 ≤ 10
• 1 ≤ dic의 원소의 길이 ≤ 10
• spell의 원소를 모두 사용해 단어를 만들어야 합니다.
• spell의 원소를 모두 사용해 만들 수 있는 단어는 dic에 두 개 이상 존재하지 않습니다.
• dic과 spell 모두 중복된 원소를 갖지 않습니다.

 

입출력 예

spell	dic	result
["p", "o", "s"]	["sod", "eocd", "qixm", "adio", "soo"]	2
["z", "d", "x"]	["def", "dww", "dzx", "loveaw"]	1
["s", "o", "m", "d"]	["moos", "dzx", "smm", "sunmmo", "som"]	2

입출력 예 설명

입출력 예 #1

• "p", "o", "s" 를 조합해 만들 수 있는 단어가 dic에 존재하지 않습니다. 따라서 2를 return합니다.

입출력 예 #2

• "z", "d", "x" 를 조합해 만들 수 있는 단어 "dzx"가 dic에 존재합니다. 따라서 1을 return합니다.

입출력 예 #3

• "s", "o", "m", "d" 를 조합해 만들 수 있는 단어가 dic에 존재하지 않습니다. 따라서 2을 return합니다.

 

유의사항

• 입출력 예 #3 에서 "moos", "smm", "som"도 "s", "o", "m", "d" 를 조합해 만들 수 있지만 spell의 원소를 모두 사용해야 하기 때문에 정답이 아닙니다.

 

def solution(spell, dic):

    from itertools import permutations

    

    for p in permutations(spell):

        word = ''.join(p)

        if word in dic:

            return 1

    

    return 2

 

 

 

def solution(spell, dic):

    spell = set(spell)

    for s in dic:

        if not spell-set(s):

            return 1

    return 2

 

 

def solution(spell, dic):

    for d in dic:

        if sorted(d) == sorted(spell):

            return 1

    return 2

 

def solution(spell, dic):

    spell = set(spell)

    return int(any(d for d in dic if not spell - set(d))) or 2

 

 

 

196//27 무작위로 K개의 수 뽑기

문제 설명

랜덤으로 서로 다른 k개의 수를 저장한 배열을 만드려고 합니다. 적절한 방법이 떠오르지 않기 때문에 일정한 범위 내에서 무작위로 수를 뽑은 후, 지금까지 나온적이 없는 수이면 배열 맨 뒤에 추가하는 방식으로 만들기로 합니다.

이미 어떤 수가 무작위로 주어질지 알고 있다고 가정하고, 실제 만들어질 길이 k의 배열을 예상해봅시다.

정수 배열 arr가 주어집니다. 문제에서의 무작위의 수는 arr에 저장된 순서대로 주어질 예정이라고 했을 때, 완성될 배열을 return 하는 solution 함수를 완성해 주세요.

단, 완성될 배열의 길이가 k보다 작으면 나머지 값을 전부 -1로 채워서 return 합니다.

 

제한사항

• 1 ≤ arr의 길이 ≤ 100,000
• 1 ≤ k ≤ 1,000

입출력 예

arr	k	result
[0, 1, 1, 2, 2, 3]	3	[0, 1, 2]
[0, 1, 1, 1, 1]	4	[0, 1, -1, -1]

입출력 예 설명

입출력 예 #1

• 앞에서부터 서로 다른 k개의 수를 골라내면 [0, 1, 2]가 됩니다. 따라서 [0, 1, 2]를 return 합니다.

입출력 예 #2

• 서로 다른 수의 개수가 2개 뿐이므로 서로 다른 수들을 앞에서부터 차례대로 저장한 [0, 1]에서 이후 2개의 인덱스를 -1로 채워넣은 [0, 1, -1, -1]을 return 합니다.

 

def solution(arr, k):

    answer = []

    for num in arr:

        if num not in answer:

            answer.append(num)

            if len(answer) == k:

                break

    while len(answer) < k:

        answer.append(-1)

    return answer

 

def solution(arr, k):

    ret = []

    for i in arr:

        if i not in ret:

            ret.append(i)

        if len(ret) == k:

            break

 

    return ret + [-1] * (k - len(ret))

 

 

def solution(arr, k):

    res = list(dict.fromkeys(arr))

    res.extend([-1] * max(0, k - len(res)))

    return res[:k]

 

def solution(arr, k):

    answer=[]

    cnt=0

    d=set()

    for x in arr:

        if x not in d:

            d.add(x)

            cnt+=1

            answer.append(x)

            if cnt==k: break

    while len(answer)<k: answer.append(-1)

 

    return answer

 

 

def solution(arr, k):

    answer = []

 

    num_set = set()

    for a in arr:

        if a in num_set:

            continue

        num_set.add(a)

        answer.append(a)

 

    return (answer + [-1] * max(0, k - len(num_set)))[:k]

 

 

def solution(arr, k):

    answer = []

    for i in arr:

        if i not in answer:

            answer.append(i)

    while len(answer) < k:

        answer.append(-1)

    return answer[:k]

 

 

197//26 문자열 겹쳐쓰기

• 
  문제 설명

문자열 my_string, overwrite_string과 정수 s가 주어집니다. 문자열 my_string의 인덱스 s부터 overwrite_string의 길이만큼을 문자열 overwrite_string으로 바꾼 문자열을 return 하는 solution 함수를 작성해 주세요.

 

제한사항

• my_string와 overwrite_string은 숫자와 알파벳으로 이루어져 있습니다.
• 1 ≤ overwrite_string의 길이 ≤ my_string의 길이 ≤ 1,000
• 0 ≤ s ≤ my_string의 길이 - overwrite_string의 길이

 

입출력 예

my_string	overwrite_string	s	result
"He11oWor1d"	"lloWorl"	2	"HelloWorld"
"Program29b8UYP"	"merS123"	7	"ProgrammerS123"

입출력 예 설명

입출력 예 #1

• 예제 1번의 my_string에서 인덱스 2부터 overwrite_string의 길이만큼에 해당하는 부분은 "11oWor1"이고 이를 "lloWorl"로 바꾼 "HelloWorld"를 return 합니다.

입출력 예 #2

• 예제 2번의 my_string에서 인덱스 7부터 overwrite_string의 길이만큼에 해당하는 부분은 "29b8UYP"이고 이를 "merS123"로 바꾼 "ProgrammerS123"를 return 합니다.

 

 

def solution(my_string, overwrite_string, s):

    return my_string[:s] + overwrite_string + my_string[s+len(overwrite_string):]

 

 

def solution(my_string, overwrite_string, s):

    return my_string[:s] + overwrite_string + my_string[s + len(overwrite_string):]

 

 

 

def solution(m, o, s):

    return m[:s]+o+m[len(o)+s:]

 

 

def solution(my_string, overwrite_string, s):

    answer = my_string[:s]+overwrite_string+my_string[s+len(overwrite_string):]

    return answer

 

 

def solution(my_string, overwrite_string, s):

    answer = my_string[:s] + overwrite_string + my_string[s+len(overwrite_string):]

    return a

 

 

 

198//25 그림 확대 pass

문제 설명

직사각형 형태의 그림 파일이 있고, 이 그림 파일은 1 × 1 크기의 정사각형 크기의 픽셀로 이루어져 있습니다. 이 그림 파일을 나타낸 문자열 배열 picture과 정수 k가 매개변수로 주어질 때, 이 그림 파일을 가로 세로로 k배 늘린 그림 파일을 나타내도록 문자열 배열을 return 하는 solution 함수를 작성해 주세요.

 

제한사항

• 1 ≤ picture의 길이 ≤ 20
• 1 ≤ picture의 원소의 길이 ≤ 20
• 모든 picture의 원소의 길이는 같습니다.
• picture의 원소는 '.'과 'x'로 이루어져 있습니다.
• 1 ≤ k ≤ 10

 

입출력 예

picture	k	result
[".xx...xx.", "x..x.x..x", "x...x...x", ".x.....x.", "..x...x..", "...x.x...", "....x...."]	2	["..xxxx......xxxx..", "..xxxx......xxxx..", "xx....xx..xx....xx", "xx....xx..xx....xx", "xx......xx......xx", "xx......xx......xx", "..xx..........xx..", "..xx..........xx..", "....xx......xx....", "....xx......xx....", "......xx..xx......", "......xx..xx......", "........xx........", "........xx........"]
["x.x", ".x.", "x.x"]	3	["xxx...xxx", "xxx...xxx", "xxx...xxx", "...xxx...", "...xxx...", "...xxx...", "xxx...xxx", "xxx...xxx", "xxx...xxx"]

입출력 예 설명

입출력 예 #1

• 예제 1번의 picture는 다음과 같습니다.
  .xx...xx.
• x..x.x..x
• x...x...x
• .x.....x.
• ..x...x..
• ...x.x...
• ....x....
• 
  
  이를 가로 세로로 k배, 즉 2배 확대하면 그림 파일은 다음과 같습니다.
  ..xxxx......xxxx..
• ..xxxx......xxxx..
• xx....xx..xx....xx
• xx....xx..xx....xx
• xx......xx......xx
• xx......xx......xx
• ..xx..........xx..
• ..xx..........xx..
• ....xx......xx....
• ....xx......xx....
• ......xx..xx......
• ......xx..xx......
• ........xx........
• ........xx........
• 
  
  따라서 ["..xxxx......xxxx..", "..xxxx......xxxx..", "xx....xx..xx....xx", "xx....xx..xx....xx", "xx......xx......xx", "xx......xx......xx", "..xx..........xx..", "..xx..........xx..", "....xx......xx....", "....xx......xx....", "......xx..xx......", "......xx..xx......", "........xx........", "........xx........"]를 return 합니다.

입출력 예 #2

• 예제 2번의 picture는 다음과 같습니다.
  x.x
• .x.
• x.x
• 
  
  이를 가로 세로로 k배, 즉 3배 확대하면 그림 파일은 다음과 같습니다.
  xxx...xxx
• xxx...xxx
• xxx...xxx
• ...xxx...
• ...xxx...
• ...xxx...
• xxx...xxx
• xxx...xxx
• xxx...xxx
• 
  
  따라서 ["xxx...xxx", "xxx...xxx", "xxx...xxx", "...xxx...", "...xxx...", "...xxx...", "xxx...xxx", "xxx...xxx", "xxx...xxx"]를 return 합니다.

 

199//25 직사각형 넓이 구하기pass

 

문제 설명

2차원 좌표 평면에 변이 축과 평행한 직사각형이 있습니다. 직사각형 네 꼭짓점의 좌표 [[x1, y1], [x2, y2], [x3, y3], [x4, y4]]가 담겨있는 배열 dots가 매개변수로 주어질 때, 직사각형의 넓이를 return 하도록 solution 함수를 완성해보세요.

 

제한사항

• dots의 길이 = 4
• dots의 원소의 길이 = 2
• -256 < dots[i]의 원소 < 256
• 잘못된 입력은 주어지지 않습니다.

입출력 예

dots	result
[[1, 1], [2, 1], [2, 2], [1, 2]]	1
[[-1, -1], [1, 1], [1, -1], [-1, 1]]	4

입출력 예 설명

입출력 예 #1

• 좌표 [[1, 1], [2, 1], [2, 2], [1, 2]] 를 꼭짓점으로 갖는 직사각형의 가로, 세로 길이는 각각 1, 1이므로 직사각형의 넓이는 1 x 1 = 1입니다.

입출력 예 #2

• 좌표 [[-1, -1], [1, 1], [1, -1], [-1, 1]]를 꼭짓점으로 갖는 직사각형의 가로, 세로 길이는 각각 2, 2이므로 직사각형의 넓이는 2 x 2 = 4입니다.

 

 

 

200//25 캐릭터의 좌표

 

문제 설명

머쓱이는 RPG게임을 하고 있습니다. 게임에는 up, down, left, right 방향키가 있으며 각 키를 누르면 위, 아래, 왼쪽, 오른쪽으로 한 칸씩 이동합니다. 예를 들어 [0,0]에서 up을 누른다면 캐릭터의 좌표는 [0, 1], down을 누른다면 [0, -1], left를 누른다면 [-1, 0], right를 누른다면 [1, 0]입니다. 머쓱이가 입력한 방향키의 배열 keyinput와 맵의 크기 board이 매개변수로 주어집니다. 캐릭터는 항상 [0,0]에서 시작할 때 키 입력이 모두 끝난 뒤에 캐릭터의 좌표 [x, y]를 return하도록 solution 함수를 완성해주세요.

• [0, 0]은 board의 정 중앙에 위치합니다. 예를 들어 board의 가로 크기가 9라면 캐릭터는 왼쪽으로 최대 [-4, 0]까지 오른쪽으로 최대 [4, 0]까지 이동할 수 있습니다.

 

제한사항

• board은 [가로 크기, 세로 크기] 형태로 주어집니다.
• board의 가로 크기와 세로 크기는 홀수입니다.
• board의 크기를 벗어난 방향키 입력은 무시합니다.
• 0 ≤ keyinput의 길이 ≤ 50
• 1 ≤ board[0] ≤ 99
• 1 ≤ board[1] ≤ 99
• keyinput은 항상 up, down, left, right만 주어집니다.

 

입출력 예

keyinput	board	result
["left", "right", "up", "right", "right"]	[11, 11]	[2, 1]
["down", "down", "down", "down", "down"]	[7, 9]	[0, -4]

입출력 예 설명

입출력 예 설명 #1

• [0, 0]에서 왼쪽으로 한 칸 오른쪽으로 한 칸 위로 한 칸 오른쪽으로 두 칸 이동한 좌표는 [2, 1]입니다.

입출력 예 설명 #2

• [0, 0]에서 아래로 다섯 칸 이동한 좌표는 [0, -5]이지만 맵의 세로 크기가 9이므로 아래로는 네 칸을 넘어서 이동할 수 없습니다. 따라서 [0, -4]를 return합니다.

 

def solution(keyinput, board):

    width, height = board

    x, y = 0, 0

 

    for direction in keyinput:

        if direction == "up":

            if y + 1 <= height // 2:

                y += 1

        elif direction == "down":

            if y - 1 >= -(height // 2):

                y -= 1

        elif direction == "left":

            if x - 1 >= -(width // 2):

                x -= 1

        elif direction == "right":

            if x + 1 <= width // 2:

                x += 1

 

    return [x, y]

 

 

def solution(keyinput, board):

    x_lim,y_lim = board[0]//2,board[1]//2

    move = {'left':(-1,0),'right':(1,0),'up':(0,1),'down':(0,-1)}

    x,y = 0,0

    for k in keyinput:

        dx,dy = move[k]

        if abs(x+dx)>x_lim or abs(y+dy)>y_lim:

            continue

        else:

            x,y = x+dx,y+dy

 

    return [x,y]

 

 

def solution(keyinput, board):

    curr = [0, 0]

    for k in keyinput:

        if k == 'left':

            curr[0] = max(curr[0] - 1, -(board[0] // 2))

        elif k == 'right':

            curr[0] = min(curr[0] + 1, board[0] // 2)

        elif k == 'down':

            curr[1] = max(curr[1] - 1, -(board[1] // 2))

        else:

            curr[1] = min(curr[1] + 1, board[1] // 2)

 

    return curr

 

 

def solution(keyinput, board):

    dic = {

        "left" : (-1,0),

        "up" : (0,1),

        "down" : (0,-1),

        "right" : (1,0),

    }

    x,y = 0,0

    lr, ud = board

    lr//=2

    ud//=2

    for key in keyinput:

        dx,dy = dic[key]

        x += dx

        y += dy

        x=max(-lr,x)

        y = max(-ud,y)

        x = min(lr,x)

        y = min(ud,y)

    answer = [x,y]

    return answer

 

 

from functools import reduce

 

def solution(keyinput, board):

    move = {"left": [-1, 0], "right": [1, 0], "up": [0, 1], "down": [0, -1]}

    return reduce(lambda pos, key: [p+m if -(b//2) <= p+m <= b//2 else p for p, m, b in zip(pos, move[key], board)], keyinput, [0,0])

 

 

• 201//24 로그인 성공?

 

문제 설명

머쓱이는 프로그래머스에 로그인하려고 합니다. 머쓱이가 입력한 아이디와 패스워드가 담긴 배열 id_pw와 회원들의 정보가 담긴 2차원 배열 db가 주어질 때, 다음과 같이 로그인 성공, 실패에 따른 메시지를 return하도록 solution 함수를 완성해주세요.

• 아이디와 비밀번호가 모두 일치하는 회원정보가 있으면 "login"을 return합니다.
• 로그인이 실패했을 때 아이디가 일치하는 회원이 없다면 “fail”를, 아이디는 일치하지만 비밀번호가 일치하는 회원이 없다면 “wrong pw”를 return 합니다.

 

제한사항

• 회원들의 아이디는 문자열입니다.
• 회원들의 아이디는 알파벳 소문자와 숫자로만 이루어져 있습니다.
• 회원들의 패스워드는 숫자로 구성된 문자열입니다.
• 회원들의 비밀번호는 같을 수 있지만 아이디는 같을 수 없습니다.
• id_pw의 길이는 2입니다
• id_pw와 db의 원소는 [아이디, 패스워드] 형태입니다.
• 1 ≤ 아이디의 길이 ≤ 15
• 1 ≤ 비밀번호의 길이 ≤ 6
• 1 ≤ db의 길이 ≤ 10
• db의 원소의 길이는 2입니다.

 

입출력 예

id_pw	db	result
["meosseugi", "1234"]	[["rardss", "123"], ["yyoom", "1234"], ["meosseugi", "1234"]]	"login"
["programmer01", "15789"]	[["programmer02", "111111"], ["programmer00", "134"], ["programmer01", "1145"]]	"wrong pw"
["rabbit04", "98761"]	[["jaja11", "98761"], ["krong0313", "29440"], ["rabbit00", "111333"]]	"fail"

입출력 예 설명

입출력 예 #1

• db에 같은 정보의 계정이 있으므로 "login"을 return합니다.

입출력 예 #2

• db에 아이디는 같지만 패스워드가 다른 계정이 있으므로 "wrong pw"를 return합니다.

입출력 예 #3

• db에 아이디가 맞는 계정이 없으므로 "fail"을 return합니다.

 

 

 

def solution(id_pw, db):

    input_id, input_pw = id_pw

 

    for member in db:

        db_id, db_pw = member

        if db_id == input_id:

            if db_pw == input_pw:

                return "login"

            else:

                return "wrong pw"

 

    return "fail"

 

 

def solution(id_pw, db):

    if db_pw := dict(db).get(id_pw[0]):

        return "login" if db_pw == id_pw[1] else "wrong pw"

    return "fail"

 

 

def solution(id_pw, db):

    dic = dict(db)

    if dic.get(id_pw[0],-1) == id_pw[1]:

        return "login"

    elif dic.get(id_pw[0],-1) == -1:

        return "fail"

    else:

        return "wrong pw"

 

def solution(id_pw, db):

    answer = ''

    a, b = id_pw[0], id_pw[1]

    for pk, pw in db:

        if pk == a and pw == b:

            return "login"

    for pk, pw in db:

        if pk == a:

            return "wrong pw"

 

    return "fail"

 

 

 

• 202//23 치킨 쿠폰 pass
•  

문제 설명

프로그래머스 치킨은 치킨을 시켜먹으면 한 마리당 쿠폰을 한 장 발급합니다. 쿠폰을 열 장 모으면 치킨을 한 마리 서비스로 받을 수 있고, 서비스 치킨에도 쿠폰이 발급됩니다. 시켜먹은 치킨의 수 chicken이 매개변수로 주어질 때 받을 수 있는 최대 서비스 치킨의 수를 return하도록 solution 함수를 완성해주세요.

 

제한사항

• chicken은 정수입니다.
• 0 ≤ chicken ≤ 1,000,000

 

입출력 예

chicken	result
100	11
1,081	120

입출력 예 설명

입출력 예 #1

• 100마리를 주문하면 쿠폰이 100장 발급되므로 서비스 치킨 10마리를 주문할 수 있습니다.
• 10마리를 주문하면 쿠폰이 10장 발급되므로 서비스 치킨 1마리를 주문할 수 있습니다.
• 따라서 10 + 1 = 11 을 return합니다.

입출력 예 #2

• 1081마리를 주문하면 쿠폰이 1081장 발급되므로 서비스 치킨 108마리를 주문할 수 있습니다. 그리고 쿠폰이 1장 남습니다.
• 108마리를 주문하면 쿠폰이 108장 발급되므로 서비스 치킨 10마리를 주문할 수 있습니다. 그리고 쿠폰이 8장 남습니다.
• 10마리를 주문하면 쿠폰이 10장 발급되므로 서비스 치킨 1마리를 주문할 수 있습니다.
• 1마리를 주문하면 쿠폰이 1장 발급됩니다.
• 가지고 있는 쿠폰이 총 10장이므로 서비스 치킨 1마리를 추가로 주문할 수 있습니다.
• 따라서 108 + 10 + 1 + 1 = 120 을 return합니다.

 

203//23 등수 매기기

 

문제 설명

영어 점수와 수학 점수의 평균 점수를 기준으로 학생들의 등수를 매기려고 합니다. 영어 점수와 수학 점수를 담은 2차원 정수 배열 score가 주어질 때, 영어 점수와 수학 점수의 평균을 기준으로 매긴 등수를 담은 배열을 return하도록 solution 함수를 완성해주세요.

 

제한사항

• 0 ≤ score[0], score[1] ≤ 100
• 1 ≤ score의 길이 ≤ 10
• score의 원소 길이는 2입니다.
• score는 중복된 원소를 갖지 않습니다.

 

입출력 예

score	result
[[80, 70], [90, 50], [40, 70], [50, 80]]	[1, 2, 4, 3]
[[80, 70], [70, 80], [30, 50], [90, 100], [100, 90], [100, 100], [10, 30]]	[4, 4, 6, 2, 2, 1, 7]

입출력 예 설명

입출력 예 #1

• 평균은 각각 75, 70, 55, 65 이므로 등수를 매겨 [1, 2, 4, 3]을 return합니다.

입출력 예 #2

• 평균은 각각 75, 75, 40, 95, 95, 100, 20 이므로 [4, 4, 6, 2, 2, 1, 7] 을 return합니다.
• 공동 2등이 두 명, 공동 4등이 2명 이므로 3등과 5등은 없습니다.

 

 

def solution(score):

    # Calculate the average score for each student

    averages = [(sum(s) / len(s), i + 1) for i, s in enumerate(score)]

 

    # Sort the students based on their average scores in descending order

    sorted_students = sorted(averages, key=lambda x: x[0], reverse=True)

 

    # Assign ranks to the students

    ranks = [0] * len(score)

    rank = 1

    prev_score = sorted_students[0][0]

    for i, (avg, student_id) in enumerate(sorted_students):

        if avg < prev_score:

            rank = i + 1

            prev_score = avg

        ranks[student_id - 1] = rank

 

    return ranks

 

 

def solution(score):

    a = sorted([sum(i) for i in score], reverse = True)

    return [a.index(sum(i))+1 for i in score]

 

 

def solution(score):

    rank = sorted([sum(s) / 2 for s in score], reverse=True)

    rankDict = {}

    for i, r in enumerate(rank):

        if r not in rankDict.keys():

            rankDict[r] = i + 1

    return [rankDict[sum(s) / 2] for s in score]

 

 

 

 

from functools import reduce

def solution(score):

    sorted_score = sorted(reduce(lambda x,y:x.append(sum(y)) or x,score,[]),reverse=True)

 

    return [sorted_score.index(sum(s))+1 for s in score]

 

 

def solution(score):

    return [{v : k for k, v in dict(sorted(enumerate(sorted([i + j for i, j in score], reverse = True)), key = lambda x : (x[1], x[0]), reverse = True)).items()}[i] + 1 for i in ([j + k for j, k in score])]

 

 

• 204//22대소문자 바꿔서 출력하기 pass
• 
  문제 설명

영어 알파벳으로 이루어진 문자열 str이 주어집니다. 각 알파벳을 대문자는 소문자로 소문자는 대문자로 변환해서 출력하는 코드를 작성해 보세요.

 

제한사항

• 1 ≤ str의 길이 ≤ 20

 

입출력 예

입력 #1

aBcDeFg

출력 #1

AbCdEfG

 

 

• 205//22 저주의 숫자 3. Pass

 

문제 설명

3x 마을 사람들은 3을 저주의 숫자라고 생각하기 때문에 3의 배수와 숫자 3을 사용하지 않습니다. 3x 마을 사람들의 숫자는 다음과 같습니다.

10진법	3x 마을에서 쓰는 숫자	10진법	3x 마을에서 쓰는 숫자
1	1	6	8
2	2	7	10
3	4	8	11
4	5	9	14
5	7	10	16

정수 n이 매개변수로 주어질 때, n을 3x 마을에서 사용하는 숫자로 바꿔 return하도록 solution 함수를 완성해주세요.

 

제한사항

• 1 ≤ n ≤ 100

입출력 예

n	result
15	25
40	76

입출력 예 설명

입출력 예 #1

• 15를 3x 마을의 숫자로 변환하면 25입니다.

입출력 예 #2

• 40을 3x 마을의 숫자로 변환하면 76입니다.
• 206//22특이한 정렬 pass

 

문제 설명

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

 

제한사항

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

 

입출력 예

numlist	n	result
[1, 2, 3, 4, 5, 6]	4	[4, 5, 3, 6, 2, 1]
[10000,20,36,47,40,6,10,7000]	30	[36, 40, 20, 47, 10, 6, 7000, 10000]

입출력 예 설명

입출력 예 #1

• 4에서 가까운 순으로 [4, 5, 3, 6, 2, 1]을 return합니다.
• 3과 5는 거리가 같으므로 더 큰 5가 앞에 와야 합니다.
• 2와 6은 거리가 같으므로 더 큰 6이 앞에 와야 합니다.

입출력 예 #2

• 30에서 가까운 순으로 [36, 40, 20, 47, 10, 6, 7000, 10000]을 return합니다.
• 20과 40은 거리가 같으므로 더 큰 40이 앞에 와야 합니다.

 

def custom_sort(elem):

    return (abs(elem - n), -elem)

 

def solution(numlist, n):

    global n

    n = n

 

    # Sort the elements of numlist based on the custom_sort function

    sorted_list = sorted(numlist, key=custom_sort)

 

    return sorted_list

 

# Test cases

print(solution([1, 2, 3, 4, 5, 6], 4))  # Output: [4, 5, 3, 6, 2, 1]

print(solution([10000, 20, 36, 47, 40, 6, 10, 7000], 30))  # Output: [36, 40, 20, 47, 10, 6, 7000, 10000]

 

n과의 거리를 기준으로 numlist의 요소를 정렬하고 동률인 경우 더 큰 숫자를 먼저 배치하려면 거리와 숫자 자체를 정렬 기준으로 계산하는 사용자 정의 정렬 기능을 사용할 수 있습니다.

솔루션에 대한 Python 코드는 다음과 같습니다.

 

 

 

solution 함수에서 사용자 정의 정렬 함수 custom_sort를 정의합니다. 이 함수는 요소와 n 간의 절대 차이(abs(elem - n))와 요소 자체의 부정(-elem)의 두 가지 값을 계산합니다. 첫 번째 값은 'n'으로부터의 거리를 기준으로 요소가 정렬되도록 하고 두 번째 값은 동률인 경우 더 큰 숫자가 먼저 오도록 합니다.

그런 다음 sorted 함수를 사용하여 사용자 지정 정렬 함수 custom_sort를 기반으로 numlist를 정렬하고 정렬된 목록을 반환합니다.

주어진 테스트 케이스로 이 코드를 실행하면 I/O 예제에 표시된 대로 정렬된 목록을 얻을 수 있습니다.

 

 

 

• 207//22문자열 밀기
• 문제 설명

문자열 "hello"에서 각 문자를 오른쪽으로 한 칸씩 밀고 마지막 문자는 맨 앞으로 이동시키면 "ohell"이 됩니다. 이것을 문자열을 민다고 정의한다면 문자열 A와 B가 매개변수로 주어질 때, A를 밀어서 B가 될 수 있다면 밀어야 하는 최소 횟수를 return하고 밀어서 B가 될 수 없으면 -1을 return 하도록 solution 함수를 완성해보세요.

 

제한사항

• 0 < A의 길이 = B의 길이 < 100
• A, B는 알파벳 소문자로 이루어져 있습니다.

입출력 예

A	B	result
"hello"	"ohell"	1
"apple"	"elppa"	-1
"atat"	"tata"	1
"abc"	"abc"	0

입출력 예 설명

입출력 예 #1

• "hello"를 오른쪽으로 한 칸 밀면 "ohell"가 됩니다.

입출력 예 #2

• "apple"은 몇 번을 밀어도 "elppa"가 될 수 없습니다.

입출력 예 #3

• "atat"는 오른쪽으로 한 칸, 세 칸을 밀면 "tata"가 되므로 최소 횟수인 1을 반환합니다.

 

입출력 예 #4

• "abc"는 밀지 않아도 "abc"이므로 0을 반환합니다.

 

 

def solution(A, B):

    if len(A) != len(B):

        return -1

 

    if A == B:

        return 0

 

    for i in range(len(A)):

        A = A[-1] + A[:-1] 

        if A == B:

            return i + 1  

    return -1  

 

 

solution=lambda a,b:(b*2).find(a)

 

def solution(A, B):

    #if A == "":

    #    return 0

 

    AA = A+A

    answer = AA.find(B)

 

    if answer >0:

        answer = len(A) - answer

 

    return answer

 

 

from collections import deque

 

def solution(A, B):

    a, b = deque(A), deque(B)

    for cnt in range(0, len(A)):

        if a == b:

            return cnt

        a.rotate(1)

    return -1

 

 

• 208//21.       배열 만들기 2

 

문제 설명

정수 l과 r이 주어졌을 때, l 이상 r이하의 정수 중에서 숫자 "0"과 "5"로만 이루어진 모든 정수를 오름차순으로 저장한 배열을 return 하는 solution 함수를 완성해 주세요.

만약 그러한 정수가 없다면, -1이 담긴 배열을 return 합니다.

 

제한사항

• 1 ≤ l ≤ r ≤ 1,000,000

입출력 예

l	r	result
5	555	[5, 50, 55, 500, 505, 550, 555]
10	20	[-1]

입출력 예 설명

입출력 예 #1

• 5 이상 555 이하의 0과 5로만 이루어진 정수는 작은 수부터 5, 50, 55, 500, 505, 550, 555가 있습니다. 따라서 [5, 50, 55, 500, 505, 550, 555]를 return 합니다.

입출력 예 #2

• 10 이상 20 이하이면서 0과 5로만 이루어진 정수는 없습니다. 따라서 [-1]을 return 합니다.

 

 

 

def solution(l, r):

    result = []

    for num in range(l, r + 1):

        if set(str(num)) <= {'0', '5'}:

            result.append(num)

    return result if result else [-1]

 

 

def solution(l, r):

    answer = []

    for num in range(l, r + 1):

        if not set(str(num)) - set(['0', '5']):

            answer.append(num)

    return answer if answer else [-1]

 

 

def solution(l, r):

    answer = []

    n = [5,50,55,500,505,550,555,5000,5005,5050,5055,5500,5505,5550,5555,50000,50005,50050,50055,50500,50505,50550,50555,55000,55005,55050,55055,55500,55505,55550,55555,500000,500005,500050,500055,500500,500505,500550,500555,505000,505005,505050,505055,505500,505505,505550,505555,550000,550005,550050,550055,550500,550505,550550,550555,555000,555005,555050,555055,555500,555505,555550,555555]

    for i in n:

        if i >= l and i <= r:

            answer.append(i)

    if answer == []:

        answer.append(-1)

    return answer

 

 

def solution(l, r):

    ret = []

    def f(lim, val):

        if lim == 0:

            ret.append(val)

            return

 

        f(lim - 1, val * 10 + 5)

        f(lim - 1, val * 10)

 

    f(6, 0)

 

    return list(i for i in ret if l <= i <= r)[::-1] or [-1]

 

def solution(l, r):

    answer = []

    i = 1

    n = 5

 

    while True:

        if n > r: break

        n = 5 * int(bin(i)[2:])

        if l <= n <= r:

            answer.append(n)

        i += 1

 

    return [-1] if len(answer) == 0 else answer

 

• 209//20    다항식 더하기 pass

 

문제 설명

한 개 이상의 항의 합으로 이루어진 식을 다항식이라고 합니다. 다항식을 계산할 때는 동류항끼리 계산해 정리합니다. 덧셈으로 이루어진 다항식 polynomial이 매개변수로 주어질 때, 동류항끼리 더한 결괏값을 문자열로 return 하도록 solution 함수를 완성해보세요. 같은 식이라면 가장 짧은 수식을 return 합니다.

 

제한사항

• 0 < polynomial에 있는 수 < 100
• polynomial에 변수는 'x'만 존재합니다.
• polynomial은 양의 정수, 공백, ‘x’, ‘+'로 이루어져 있습니다.
• 항과 연산기호 사이에는 항상 공백이 존재합니다.
• 공백은 연속되지 않으며 시작이나 끝에는 공백이 없습니다.
• 하나의 항에서 변수가 숫자 앞에 오는 경우는 없습니다.
• " + 3xx + + x7 + "와 같은 잘못된 입력은 주어지지 않습니다.
• 0으로 시작하는 수는 없습니다.
• 문자와 숫자 사이의 곱하기는 생략합니다.
• polynomial에는 일차 항과 상수항만 존재합니다.
• 계수 1은 생략합니다.
• 결괏값에 상수항은 마지막에 둡니다.
• 0 < polynomial의 길이 < 50

 

입출력 예

polynomial	result
"3x + 7 + x"	"4x + 7"
"x + x + x"	"3x"

입출력 예 설명

입출력 예 #1

• "3x + 7 + x"에서 동류항끼리 더하면 "4x + 7"입니다.

입출력 예 #2

• "x + x + x"에서 동류항끼리 더하면 "3x"입니다.

오답

def solution(polynomial):

    terms = polynomial.split(' + ')

    term_dict = {}

    

    for term in terms:

        coefficient, variable = term.split('x')

        coefficient = int(coefficient.strip())

        term_dict[variable] = term_dict.get(variable, 0) + coefficient

 

    result = ' + '.join([f"{coefficient}{variable}" for variable, coefficient in term_dict.items() if coefficient != 0])

 

    return result if result else '0'

• 210//20.   OX퀴즈 pass
• 
  문제 설명

덧셈, 뺄셈 수식들이 'X [연산자] Y = Z' 형태로 들어있는 문자열 배열 quiz가 매개변수로 주어집니다. 수식이 옳다면 "O"를 틀리다면 "X"를 순서대로 담은 배열을 return하도록 solution 함수를 완성해주세요.

 

제한사항

• 연산 기호와 숫자 사이는 항상 하나의 공백이 존재합니다. 단 음수를 표시하는 마이너스 기호와 숫자 사이에는 공백이 존재하지 않습니다.
• 1 ≤ quiz의 길이 ≤ 10
• X, Y, Z는 각각 0부터 9까지 숫자로 이루어진 정수를 의미하며, 각 숫자의 맨 앞에 마이너스 기호가 하나 있을 수 있고 이는 음수를 의미합니다.
• X, Y, Z는 0을 제외하고는 0으로 시작하지 않습니다.
• -10,000 ≤ X, Y ≤ 10,000
• -20,000 ≤ Z ≤ 20,000
• [연산자]는 + 와 - 중 하나입니다.

 

입출력 예

quiz	result
["3 - 4 = -3", "5 + 6 = 11"]	["X", "O"]
["19 - 6 = 13", "5 + 66 = 71", "5 - 15 = 63", "3 - 1 = 2"]	["O", "O", "X", "O"]

입출력 예 설명

입출력 예 #1

• 3 - 4 = -3 은 틀린 수식이므로 "X", 5 + 6 = 11 은 옳은 수식이므로 "O" 입니다. 따라서 ["X", "O"]를 return합니다.

입출력 예 #2

• 19 - 6 = 13 은 옳은 수식이므로 "O", 5 + 66 = 71 은 옳은 수식이므로 "O", 5 - 15 = 63 은 틀린 수식이므로 "X", 3 - 1 = 2는 옳은 수식이므로 "O" 따라서 ["O", "O", "X", "O"]를 return합니다.

 

 

쳇거 오답

def evaluate_formula(formula):

    x, operator, y, result = formula.split()

    x = int(x)

    y = int(y)

    result = int(result)

 

    if operator == '+':

        return x + y == result

    elif operator == '-':

        return x - y == result

    else:

        return False

 

def check_quiz(quiz):

    result = []

 

    for formula in quiz:

        if evaluate_formula(formula):

            result.append('O')

        else:

            result.append('X')

 

    return result

 

# Test cases

print(check_quiz(["3 - 4 = -3", "5 + 6 = 11"]))  # Output: ["X", "O"]

print(check_quiz(["19 - 6 = 13", "5 + 66 = 71", "5 - 15 = 63", "3 - 1 = 2"]))  # Output: ["O", "O", "X", "O"]