2023.7.30. 일요일 // 프로그래머스 문제 그리고 코딧 강의

7.30.

• 165//56 이진수 더하기???
• 
   

문제 설명

이진수를 의미하는 두 개의 문자열 bin1과 bin2가 매개변수로 주어질 때, 두 이진수의 합을 return하도록 solution 함수를 완성해주세요.

 

제한사항

• return 값은 이진수를 의미하는 문자열입니다.
• 1 ≤ bin1, bin2의 길이 ≤ 10
• bin1과 bin2는 0과 1로만 이루어져 있습니다.
• bin1과 bin2는 "0"을 제외하고 0으로 시작하지 않습니다.

 

입출력 예

bin1	bin2	result
"10"	"11"	"101"
"1001"	"1111"	"11000"

 

입출력 예 설명

입출력 예 #1

• 10 + 11 = 101 이므로 "101" 을 return합니다.

입출력 예 #2

• 1001 + 1111 = 11000 이므로 "11000"을 return합니다.

def solution(bin1, bin2):

    answer = bin(int(bin1,2) + int(bin2,2))[2:]

    return answer

 

def solution(bin1, bin2):

    answer = 0

    bin1_size = len(bin1)

    bin2_size = len(bin2)

 

    sum = 0

 

    for i in bin1:

        sum += int(i) * (2 ** (bin1_size - 1))

        bin1_size -= 1

 

    for i in bin2:

        sum += int(i) * (2 ** (bin2_size - 1))

        bin2_size -= 1

 

    answer = str(bin(sum))[2:]

 

    return answer

 

 

def solution(bin1, bin2):

    ans = int(bin1,2) +int(bin2,2)

    answer = bin(ans)[2:]

    return answer

 

def solution(bin1, bin2):

    return bin(int('0b' + bin1, 2) + int('0b' + bin2, 2))[2:]

 

 

• 166//55컨트롤 제트
•  

문제 설명

숫자와 "Z"가 공백으로 구분되어 담긴 문자열이 주어집니다. 문자열에 있는 숫자를 차례대로 더하려고 합니다. 이 때 "Z"가 나오면 바로 전에 더했던 숫자를 뺀다는 뜻입니다. 숫자와 "Z"로 이루어진 문자열 s가 주어질 때, 머쓱이가 구한 값을 return 하도록 solution 함수를 완성해보세요.

 

제한사항

• 1 ≤ s의 길이 ≤ 200
• -1,000 < s의 원소 중 숫자 < 1,000
• s는 숫자, "Z", 공백으로 이루어져 있습니다.
• s에 있는 숫자와 "Z"는 서로 공백으로 구분됩니다.
• 연속된 공백은 주어지지 않습니다.
• 0을 제외하고는 0으로 시작하는 숫자는 없습니다.
• s는 "Z"로 시작하지 않습니다.
• s의 시작과 끝에는 공백이 없습니다.
• "Z"가 연속해서 나오는 경우는 없습니다.

입출력 예

s	result
"1 2 Z 3"	4
"10 20 30 40"	100
"10 Z 20 Z 1"	1
"10 Z 20 Z"	0
"-1 -2 -3 Z"	-3

입출력 예 설명

입출력 예 #1

• 본문과 동일합니다.

입출력 예 #2

• 10 + 20 + 30 + 40 = 100을 return 합니다.

입출력 예 #3

• "10 Z 20 Z 1"에서 10 다음 Z, 20 다음 Z로 10, 20이 지워지고 1만 더하여 1을 return 합니다.

입출력 예 #4, #5

 

 

def solution(s):

    s_list = s.split()  # 문자열을 공백을 기준으로 분리하여 리스트로 만듦

    result = 0  # 머쓱이가 구한 값

    prev_num = 0  # 이전에 더한 숫자

    for elem in s_list:

        if elem == "Z":

            result -= prev_num  # 이전에 더한 숫자를 빼줌

        else:

            num = int(elem)

            result += num  # 숫자를 더해줌

            prev_num = num  # 이전에 더한 숫자를 갱신

    return result  # 머쓱이가 구한 값을 반환

아래는 Python으로 작성한 코드입니다. 주어진 문자열을 공백을 기준으로 분리하여 리스트로 만들고, 리스트를 순회하면서 "Z"가 나오면 이전에 더한 값을 빼주고, 숫자가 나오면 더해줍니다. 마지막으로 구한 값을 반환합니다.

 

```python

def solution(s):

    s_list = s.split()  # 문자열을 공백을 기준으로 분리하여 리스트로 만듦

    result = 0  # 머쓱이가 구한 값

    prev_num = 0  # 이전에 더한 숫자

    for elem in s_list:

        if elem == "Z":

            result -= prev_num  # 이전에 더한 숫자를 빼줌

        else:

            num = int(elem)

            result += num  # 숫자를 더해줌

            prev_num = num  # 이전에 더한 숫자를 갱신

    return result  # 머쓱이가 구한 값을 반환

```

 

예를 들어, `solution("1 2 Z 3")`을 호출하면 `4`를 반환합니다. 이유는 다음과 같습니다.

* `s_list = ["1", "2", "Z", "3"]`

* 처음에 `result`와 `prev_num`은 모두 `0`이므로, `num = 1`일 때 `result`는 `1`이 됩니다.

* 다음으로 `num = 2`일 때 `result`는 `3`이 됩니다.

* 다음으로 "Z"가 나왔으므로, 이전에 더한 숫자인 `prev_num`인 `2`를 빼줍니다. 따라서 `result`는 `1`이 됩니다.

* 마지막으로 `num = 3`일 때 `result`는 `4`가 됩니다.

 

남들 답

def solution(s):

    answer = 0

    for i in range(len(s := s.split(" "))):

        answer += int(s[i]) if s[i] != "Z" else -int(s[i-1])

    return answer

 

def solution(s):

    stack = []

    for a in s.split():

        if a != 'Z':

            stack.append(int(a))

        else:

            if stack:

                stack.pop()

 

    return sum(stack)

 

def solution(s):

    arr = s.split(' ')

    result =[]

    for i in arr :

        if i=='Z':

            result.pop()

        else:

            result.append(int(i))

    return sum(result)

 

 

• 167//54리스트 자르기 ~~할수 있는데 시간사pass
•  

문제 설명

정수 n과 정수 3개가 담긴 리스트 slicer 그리고 정수 여러 개가 담긴 리스트 num_list가 주어집니다. slicer에 담긴 정수를 차례대로 a, b, c라고 할 때, n에 따라 다음과 같이 num_list를 슬라이싱 하려고 합니다.

• n = 1 : num_list의 0번 인덱스부터 b번 인덱스까지
• n = 2 : num_list의 a번 인덱스부터 마지막 인덱스까지
• n = 3 : num_list의 a번 인덱스부터 b번 인덱스까지
• n = 4 : num_list의 a번 인덱스부터 b번 인덱스까지 c 간격으로

올바르게 슬라이싱한 리스트를 return하도록 solution 함수를 완성해주세요.

 

제한사항

• n 은 1, 2, 3, 4 중 하나입니다.
• slicer의 길이 = 3
• slicer에 담긴 정수를 차례대로 a, b, c라고 할 때
• 5 ≤ num_list의 길이 ≤ 30
• 0 ≤ num_list의 원소 ≤ 100

 

입출력 예

n	slicer	num_list	result
3	[1, 5, 2]	[1, 2, 3, 4, 5, 6, 7, 8, 9]	[2, 3, 4, 5, 6]
4	[1, 5, 2]	[1, 2, 3, 4, 5, 6, 7, 8, 9]	[2, 4, 6]

입출력 예 설명

입출력 예 #1

• [1, 2, 3, 4, 5, 6, 7, 8, 9]에서 1번 인덱스부터 5번 인덱스까지 자른 리스트는 [2, 3, 4, 5, 6]입니다.

입출력 예 #2

• [1, 2, 3, 4, 5, 6, 7, 8, 9]에서 1번 인덱스부터 5번 인덱스까지 2개 간격으로 자른 리스트는 [2, 4, 6]입니다.

 

쳇거

 

아래는 Python으로 작성된 해당 문제의 코드입니다.

 

 

def solution(n, slicer, num_list):

    a, b, c = slicer

    if n == 1:

        return num_list[:b+1]

    elif n == 2:

        return num_list[a:]

    elif n == 3:

        return num_list[a:b+1]

    elif n == 4:

        return num_list[a:b+1:c]

```

 

위 코드는 입력으로 주어진 `n` 값에 따라 `slicer` 리스트에 담긴 인덱스 범위를 이용하여 `num_list`를 슬라이싱한 결과를 반환하는 함수입니다. 각 경우에 따라 슬라이싱 방법이 다르므로, `if-elif`문을 이용하여 처리하였습니다.

 

def solution(n, slicer, num_list):

    a, b, c = slicer

    return [num_list[:b + 1], num_list[a:], num_list[a:b + 1], num_list[a:b + 1:c]][n - 1]

 

def solution(n, slicer, num_list):

    num_dict = {num+1 : v for num, v in enumerate([

        num_list[:slicer[1]+1],

        num_list[slicer[0]:],

        num_list[slicer[0]:slicer[1]+1],

        [num_list[i] for i in list(range(slicer[0], slicer[1]+1, slicer[2]))]]

    )}

 

    return num_dict[n]

 

def solution(n, slicer, num_list):

    a, b, c = slicer

    b += 1

    if n == 1:

        return num_list[0:b]

    if n == 2:

        return num_list[a:]

    if n == 3:

        return num_list[a:b]

    if n == 4:

        return num_list[a:b:c]

 

def solution(n, slicer, num_list):

    a, b, c = slicer

    if n == 1:

        return num_list[:b+1]

    elif n == 2:

        return num_list[a:]

    elif n == 3:

        return num_list[a:b+1]

    elif n == 4:

        return num_list[a:b+1:c]

 

def solution(n, slicer, num_list):

    a,b,c=slicer

    if n==1: return num_list[:b+1]

    if n==2: return num_list[a:]

    if n==3: return num_list[a:b+1]

    return num_list[a:b+1:c]

 

• 168//53수열과 구간 쿼리 4 // 이건 솔직히 풀수 있어서 패스 // 지금은 머리가 너무 아파서
• 
   

문제 설명

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

각 query마다 순서대로 s ≤ i ≤ e인 모든 i에 대해 i가 k의 배수이면 arr[i]에 1을 더합니다.

위 규칙에 따라 queries를 처리한 이후의 arr를 return 하는 solution 함수를 완성해 주세요.

 

제한사항

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

 

내답 

def solution(arr, queries):

    answer=[]

    for query in queries:

        s,e,k =query

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

            if i%k ==0:

                arr[i] +=1

    answer = arr

    return answer

 

 

 

남의 답—??? 무슨 뜻인지 언뜻 이해가 아니되어서

 

def solution(arr, queries):

    for q in queries:

        for i in range((q[0] + q[2] - 1) // q[2] * q[2], q[1] + 1, q[2]):

            arr[i] += 1

 

    return arr

 

 

• 169//52소인수분해
•  

문제 설명

소인수분해란 어떤 수를 소수들의 곱으로 표현하는 것입니다. 예를 들어 12를 소인수 분해하면 2 * 2 * 3 으로 나타낼 수 있습니다. 

따라서 12의 소인수는 2와 3입니다. 

자연수 n이 매개변수로 주어질 때 n의 소인수를 오름차순으로 담은 배열을 return하도록 solution 함수를 완성해주세요.

 

제한사항

• 2 ≤ n ≤ 10,000

 

입출력 예

n	result
12	[2, 3]
17	[17]
420	[2, 3, 5, 7]

입출력 예 설명

 

입출력 예 #1

• 12를 소인수분해하면 2 * 2 * 3 입니다. 따라서 [2, 3]을 return합니다.

입출력 예 #2

• 17은 소수입니다. 따라서 [17]을 return 해야 합니다.

입출력 예 #3

• 420을 소인수분해하면 2 * 2 * 3 * 5 * 7 입니다. 따라서 [2, 3, 5, 7]을 return합니다.

 

 

 

 

나의 오답

def solution(n):

    answer = []

    ls1 =[]# 이유는 모든 수를 뽑아 넣어놓으려고 1-10000까지 그 안에 소수의 곱으로 나타내려면 그리고 나서 그 인수들을 가지고 set()으로 처리하면 된다

    in1 =[]

    for i in range(2,10001):#애초부터 1은 배제하려고 2부터 썼다

        ls1.append(i)           #이제 1만 까지의 숫자의 리스트를 만들었다.왜 소인수가 그 피젯수보다 클수는 없으니까

 

        if n%i ==0:

            in1.append(i)

    

    in2 = set(in1)

    answer = list(in2)

 

 

    return answer

 

 

쳇답 - 이것도 오류란다

def solution(n):

    prime_factors = []

    

    divisor = 2

 

    while n > 1:

        if n % divisor == 0:

            prime_factors.append(divisor)

            n = n // divisor

        else:

            divisor += 1

    prime_factors = set(prime_factors)

    prime_factors = list(prime_factors)

    return prime_factors

 

이건 수정 정답 쳇거

def find_prime_factors(n):

    prime_factors = set()

    divisor = 2

 

    while n > 1:

        if n % divisor == 0:

            prime_factors.add(divisor)

            n = n // divisor

        else:

            divisor += 1

 

    return sorted(list(prime_factors))

 

# Test cases

print(find_prime_factors(12))  # Output: [2, 3]

print(find_prime_factors(17))  # Output: [17]

print(find_prime_factors(420)) # Output: [2, 3, 5, 7]

 

다른 사람 풀이

def solution(n):

    answer = []

    d = 2

    while d <= n:

        if n % d == 0:

            n /= d

            if d not in answer:

                answer.append(d)

        else:

            d += 1

    return answer

 

def solution(n):

    k = 2

    answer = []

    while n>1:

        if n%k==0:

            answer.append(k)

            while n%k==0:

                n//=k

        k+=1

 

    return answer

 

 

def solution(n):

    output = []

    i = 2

    while i <= n:

        if n % i == 0:

            output.append(i)

            while n % i == 0:

                n //= i

        i += 1

    return output

 

 

• 170//51//.   7의 개수
•  

문제 설명

머쓱이는 행운의 숫자 7을 가장 좋아합니다. 정수 배열 array가 매개변수로 주어질 때, 7이 총 몇 개 있는지 return 하도록 solution 함수를 완성해보세요.

 

제한사항

• 1 ≤ array의 길이 ≤ 100
• 0 ≤ array의 원소 ≤ 100,000

 

입출력 예

array	result
[7, 77, 17]	4
[10, 29]	0

입출력 예 설명

입출력 예 #1

• [7, 77, 17]에는 7이 4개 있으므로 4를 return 합니다.

 

내답

 

def solution(array):

    answer = 0

    count =0

    for a in array:

        count += str(a).count("7")

    return count

 

남의 답// 한단계 위

def solution(array):

    return str(array).count('7')

 

def solution(array):

    return ''.join(map(str, array)).count('7')       ????

 

def solution(array):

    answer = sum([str(i).count("7") for i in array])

    return answer

 

• 171//50 문자열 묶기 -5시s,
• 
  문제 설명

문자열 배열 strArr이 주어집니다. strArr의 원소들을 길이가 같은 문자열들끼리 그룹으로 묶었을 때 가장 개수가 많은 그룹의 크기를 return 하는 solution 함수를 완성해 주세요.

 

제한사항

• 1 ≤ strArr의 길이 ≤ 100,000

 

입출력 예

strArr	result
["a","bc","d","efg","hi"]	2

입출력 예 설명

입출력 예 #1

• 각 문자열들을 길이에 맞게 그룹으로 묶으면 다음과 같습니다.

문자열 길이	문자열 목록	개수
1	["a","d"]	2
2	["bc","hi"]	2
3	["efg"]	1

• 개수의 최댓값은 2이므로 2를 return 합니다.

내답 ——> 이거 푸느라고 Counter 와 most_common()[]공부했다

from collections import Counter

 

def solution(strArr):

    

    an1 =[]

    for i in strArr:

        an1.append(len(i)) #an1 이 숫자로 리스트가 된다 이것을 Counter 클래스를 서서한다

    an2 = Counter(an1)

    p,q = an2.most_common(1)[0]

        

        

    return q

 

def solution(strArr):

    a=[0]*31

    for x in strArr: a[len(x)]+=1

    return max(a)

 

 

def solution(strArr):

    d = {}

 

    for i in strArr:

        d[len(i)] = d.get(len(i), 0) + 1

 

    return max(d.values())

 

def solution(strArr):

    w_len = [0 for _ in range(31)]

    for w in strArr:

        w_len[len(w)] += 1

    return max(w_len)

 

 

from collections import Counter

def solution(strArr):

    return Counter(map(lambda x: len(x), strArr)).most_common(1)[0][1]

 

• 172//49조건에 맞게 수열 변환하기 2 PPP
•  

문제 설명

정수 배열 arr가 주어집니다. arr의 각 원소에 대해 값이 50보다 크거나 같은 짝수라면 2로 나누고, 50보다 작은 홀수라면 2를 곱하고 다시 1을 더합니다.

이러한 작업을 x번 반복한 결과인 배열을 arr(x)라고 표현했을 때, arr(x) = arr(x + 1)인 x가 항상 존재합니다. 이러한 x 중 가장 작은 값을 return 하는 solution 함수를 완성해 주세요.

단, 두 배열에 대한 "="는 두 배열의 크기가 서로 같으며, 같은 인덱스의 원소가 각각 서로 같음을 의미합니다.

 

제한사항

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

 

입출력 예

arr	result
[1, 2, 3, 100, 99, 98]	5

입출력 예 설명

입출력 예 #1

• 위 작업을 반복하면 다음과 같이 arr가 변합니다.

반복 횟수	arr
0	[1, 2, 3, 100, 99, 98]
1	[3, 2, 7, 50, 99, 49]
2	[7, 2, 15, 25, 99, 99]
3	[15, 2, 31, 51, 99, 99]
4	[31, 2, 63, 51, 99, 99]
5	[63, 2, 63, 51, 99, 99]
6	[63, 2, 63, 51, 99, 99]

 

def solution(arr):

    def apply_operations(num):

        if num % 2 == 0 and num >= 50:

            return num // 2

        elif num % 2 != 0 and num < 50:

            return num * 2 + 1

        else:

            return num

 

    visited_states = set()

    current_state = tuple(arr)

    visited_states.add(current_state)

    x = 0

 

    while True:

        next_state = tuple(apply_operations(num) for num in current_state)

        if next_state in visited_states:

            break

        visited_states.add(next_state)

        current_state = next_state

        x += 1

 

    return x

 

 

def solution(arr):

    answer = 0

    old = arr

    while(True):

        new = []

        for i in old:

            if i>=50 and i%2 == 0:

                i = i/2

            elif i<50 and i%2 == 1:

                i = i*2 + 1

            new.append(int(i))

        if old == new:

            break

        else:

            old = new

            answer += 1

    return answer

 

 

def solution(arr):

    ret = 0

    while True:

        tmp = list(map(lambda x: x // 2 if x >= 50 and ~x & 1 else x * 2 + 1 if x < 50 and x & 1 else x, arr[:]))

        if arr == tmp:

            break

        arr = tmp[:]

        ret += 1

 

    return ret

 

 

• 173//48.     2의 영역//틀린문제// PPP
•  

문제 설명

정수 배열 arr가 주어집니다. 배열 안의 2가 모두 포함된 가장 작은 연속된 부분 배열을 return 하는 solution 함수를 완성해 주세요.

단, arr에 2가 없는 경우 [-1]을 return 합니다.

 

제한사항

• 1 ≤ arr의 길이 ≤ 100,000

 

입출력 예

arr	result
[1, 2, 1, 4, 5, 2, 9]	[2, 1, 4, 5, 2]
[1, 2, 1]	[2]
[1, 1, 1]	[-1]
[1, 2, 1, 2, 1, 10, 2, 1]	[2, 1, 2, 1, 10, 2]

입출력 예 설명

입출력 예 #1

• 2가 있는 인덱스는 1번, 5번 인덱스뿐이므로 1번부터 5번 인덱스까지의 부분 배열인 [2, 1, 4, 5, 2]를 return 합니다.

입출력 예 #2

• 2가 한 개뿐이므로 [2]를 return 합니다.

입출력 예 #3

• 2가 배열에 없으므로 [-1]을 return 합니다.

입출력 예 #4

• 2가 있는 인덱스는 1번, 3번, 6번 인덱스이므로 1번부터 6번 인덱스까지의 부분 배열인 [2, 1, 2, 1, 10, 2]를 return 합니다.

#include <stdio.h>

#include <stdbool.h>

#include <stdlib.h>

 

int* solution(int arr[], size_t arr_len) {

    int start = 0, end = arr_len - 1;

    for(; start < arr_len; start++) {

        if(arr[start] == 2) break;

    }

    for(; end >= 0; end--) {

        if(arr[end] == 2) break;

    }

    if(end < start) {

        int* answer = (int*)malloc(sizeof(int));

        answer[0] = -1;

        return answer;

    }

    int* answer = (int*)malloc((end - start + 1) * sizeof(int));

    int cnt = 0;

    for(int i = start; i <= end; i++) answer[cnt++] = arr[i];

    return answer;

}

 

 

 

 

• 174//47커피 심부름 PPP 
• 
   

문제 설명

팀의 막내인 철수는 아메리카노와 카페 라테만 판매하는 카페에서 팀원들의 커피를 사려고 합니다. 아메리카노와 카페 라테의 가격은 차가운 것과 뜨거운 것 상관없이 각각 4500, 5000원입니다. 각 팀원에게 마실 메뉴를 적어달라고 하였고, 그 중에서 메뉴만 적은 팀원의 것은 차가운 것으로 통일하고 "아무거나"를 적은 팀원의 것은 차가운 아메리카노로 통일하기로 하였습니다.

각 직원이 적은 메뉴가 문자열 배열 order로 주어질 때, 카페에서 결제하게 될 금액을 return 하는 solution 함수를 작성해주세요. order의 원소는 아래의 것들만 들어오고, 각각의 의미는 다음과 같습니다.

order의 원소	의미
"iceamericano", "americanoice"	차가운 아메리카노
"hotamericano", "americanohot"	따뜻한 아메리카노
"icecafelatte", "cafelatteice"	차가운 카페 라테
"hotcafelatte", "cafelattehot"	따뜻한 카페 라테
"americano"	아메리카노
"cafelatte"	카페 라테
"anything"	아무거나

제한사항

• 1 ≤ order의 길이 ≤ 1,000

 

입출력 예

order	result
["cafelatte", "americanoice", "hotcafelatte", "anything"]	19000
["americanoice", "americano", "iceamericano"]	13500

입출력 예 설명

입출력 예 #1

• 예제 1번의 입력을 표로 나타내면 다음과 같습니다.

• 철수는 차가운 아메리카노 2잔, 차가운 카페 라테 1잔, 따뜻한 카페 라테 1잔을 주문하게 되므로 결제 금액은 4500 × 2 + 5000 × 2 = 19000원입니다. 따라서 19000을 return 합니다.	• 팀원의 적은 음료	• 실제 주문 음료
• "cafelatte"	• 카페 라테	• 차가운 카페 라테

입출력 예 #2

• 예제 2번의 입력에서는 모든 음료를 차가운 아메리카노로 시키게 됩니다. 따라서 결제 금액은 4500 × 3 = 13500원이고 13500을 return 합니다.

#include <stdio.h>

#include <stdbool.h>

#include <stdlib.h>

 

// order_len은 배열 order의 길이입니다.

// 파라미터로 주어지는 문자열은 const로 주어집니다. 변경하려면 문자열을 복사해서 사용하세요.

int solution(const char* order[], size_t order_len) {

    int answer = 0;

    int count =0;

 

    for(int i=0;i<order_len;i++)

    {

        if(strstr(order[i], "cafelatte") != NULL)

            count ++;

    }

    answer = count*5000 + (order_len-count)*4500;

    return answer;

}

 

 

#include <stdio.h>

#include <stdbool.h>

#include <stdlib.h>

#include <string.h>

 

// order_len은 배열 order의 길이입니다.

// 파라미터로 주어지는 문자열은 const로 주어집니다. 변경하려면 문자열을 복사해서 사용하세요.

int solution(const char* order[], size_t orderLen) {

    int answer = 0;

    for(int i = 0; i < orderLen; i++){

        if(order[i][0] == 'a' || order[i][strlen(order[i])-1] == 'o')

            answer += 4500;

        else if(order[i][0] == 'c' || order[i][strlen(order[i])-1] == 'e')

            answer += 5000;

    }

    return answer;

}

 

 

#include <stdio.h>

#include <stdbool.h>

#include <stdlib.h>

 

// order_len은 배열 order의 길이입니다.

// 파라미터로 주어지는 문자열은 const로 주어집니다. 변경하려면 문자열을 복사해서 사용하세요.

int solution(const char* order[], size_t order_len) {

    int answer = 0;

    for(int i=0;i<order_len;i++)

    {

        if(strstr(order[i],"americano")!=NULL || strstr(order[i],"anything")) answer+=4500;

        else answer+=5000;

    }

    return answer;

}

 

 

• 175//46 . 공 던지기 PPP???? 못풀었어
•  

문제 설명

머쓱이는 친구들과 동그랗게 서서 공 던지기 게임을 하고 있습니다. 공은 1번부터 던지며 오른쪽으로 한 명을 건너뛰고 그다음 사람에게만 던질 수 있습니다. 친구들의 번호가 들어있는 정수 배열 numbers와 정수 K가 주어질 때, k번째로 공을 던지는 사람의 번호는 무엇인지 return 하도록 solution 함수를 완성해보세요.

 

제한사항

• 2 < numbers의 길이 < 100
• 0 < k < 1,000
• numbers의 첫 번째와 마지막 번호는 실제로 바로 옆에 있습니다.
• numbers는 1부터 시작하며 번호는 순서대로 올라갑니다.

 

입출력 예

numbers	k	result
[1, 2, 3, 4]	2	3
[1, 2, 3, 4, 5, 6]	5	3
[1, 2, 3]	3	2

입출력 예 설명

입출력 예 #1

• 1번은 첫 번째로 3번에게 공을 던집니다.
• 3번은 두 번째로 1번에게 공을 던집니다.

입출력 예 #2

• 1번은 첫 번째로 3번에게 공을 던집니다.
• 3번은 두 번째로 5번에게 공을 던집니다.
• 5번은 세 번째로 1번에게 공을 던집니다.
• 1번은 네 번째로 3번에게 공을 던집니다.
• 3번은 다섯 번째로 5번에게 공을 던집니다.

입출력 예 #3

• 1번은 첫 번째로 3번에게 공을 던집니다.
• 3번은 두 번째로 2번에게 공을 던집니다.
• 2번은 세 번째로 1번에게 공을 던집니다.

 

 

#include <stdio.h>

#include <stdbool.h>

#include <stdlib.h>

 

// numbers_len은 배열 numbers의 길이입니다.

int solution(int n[], size_t l, int k) {

    int c,i;

    for(c=i=0;c<k-1;c++)i=(i+2)%l;    

    return n[i]; }

 

include <stdio.h>

#include <stdbool.h>

#include <stdlib.h>

 

// numbers_len은 배열 numbers의 길이입니다.

int solution(int numbers[], size_t numbers_len, int k) {

    int a = (2*k-1)%numbers_len;

    int answer = 0;

    answer = numbers[a-1];

    return answer;

}

 

• 176//45특수문자 출력하기 PPP??
• 
  문제 설명

다음과 같이 출력하도록 코드를 작성해 주세요.

 

출력 예시

!@#$%^&*(\'"<>?:;

 

print("!@#$%^&*(\\'\"<>?:;")

 

2	print(r'!@#$%^&*(\'"<>?:;')

 

2	print('\u0021\u0040\u0023\u0024\u0025\u005e\u0026\u002a\u0028\u005c\u0027\u0022\u003c\u003e\u003f\u003a\u003b')

2	print("!@#$%^&*(\\'\"<>?:;")

 

• 177//44잘라서 배열로 저장하기 as
• 
  문제 설명

문자열 my_str과 n이 매개변수로 주어질 때, my_str을 길이 n씩 잘라서 저장한 배열을 return하도록 solution 함수를 완성해주세요.

 

제한사항

• 1 ≤ my_str의 길이 ≤ 100
• 1 ≤ n ≤ my_str의 길이
• my_str은 알파벳 소문자, 대문자, 숫자로 이루어져 있습니다.

 

입출력 예

my_str	n	result
"abc1Addfggg4556b"	6	["abc1Ad", "dfggg4", "556b"]
"abcdef123"	3	["abc", "def", "123"]

입출력 예 설명

 

입출력 예 #1

• "abc1Addfggg4556b" 를 길이 6씩 잘라 배열에 저장한 ["abc1Ad", "dfggg4", "556b"]를 return해야 합니다.

입출력 예 #2

• "abcdef123" 를 길이 3씩 잘라 배열에 저장한 ["abc", "def", "123"]를 return해야 합니다.

 

유의사항

• 입출력 예 #1의 경우 "abc1Addfggg4556b"를 길이 6씩 자르면 "abc1Ad", "dfggg4" 두개와 마지막 "556b"가 남습니다. 이런 경우 남은 문자열을 그대로 배열에 저장합니다.

 

def split_string_by_length(my_str, n):

    substrings = []

    for i in range(0, len(my_str), n):

        substrings.append(my_str[i:i+n])

    return substrings

 

 

def solution(my_str, n):

    return [my_str[i: i + n] for i in range(0, len(my_str), n)]

 

 

def solution(my_str, n):

    answer = []

 

    while my_str:

        if len(my_str)>=n:

            answer.append(my_str[:n])

            my_str=my_str[n:]

        elif len(my_str)<n:

            answer.append(my_str)

            my_str=[]

    return answer

 

 

def solution(my_str, n):

    answer = []

 

    while len(my_str) > n:

        answer.append(my_str[:n])

        my_str = my_str[n:]

 

    if my_str != "":

        answer.append(my_str)

 

 

    return answer

 

 

 

 

 

• 178//43 영어가 싫어요//틀렸어 //ss
• 
   

문제 설명

영어가 싫은 머쓱이는 영어로 표기되어있는 숫자를 수로 바꾸려고 합니다. 문자열 numbers가 매개변수로 주어질 때, numbers를 정수로 바꿔 return 하도록 solution 함수를 완성해 주세요.

 

제한사항

• numbers는 소문자로만 구성되어 있습니다.
• numbers는 "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" 들이 공백 없이 조합되어 있습니다.
• 1 ≤ numbers의 길이 ≤ 50
• "zero"는 numbers의 맨 앞에 올 수 없습니다.

 

입출력 예

numbers	result
"onetwothreefourfivesixseveneightnine"	123456789
"onefourzerosixseven"	14067

입출력 예 설명

입출력 예 #1

• "onetwothreefourfivesixseveneightnine"를 숫자로 바꾼 123456789를 return합니다.

입출력 예 #1

• "onefourzerosixseven"를 숫자로 바꾼 14067를 return합니다.

 

아래는 Python으로 작성한 코드입니다.

 

```python

def solution(numbers):

    num_dict = {

        "zero": "0",

        "one": "1",

        "two": "2",

        "three": "3",

        "four": "4",

        "five": "5",

        "six": "6",

        "seven": "7",

        "eight": "8",

        "nine": "9"

    }

    for key, value in num_dict.items():

        numbers = numbers.replace(key, value)

    return int(numbers)

```

 

위 코드는 입력으로 주어진 `numbers` 문자열에서 각 영어 단어를 숫자로 변환하여 정수로 반환하는 함수입니다. 이 함수는 다음과 같은 방식으로 동작합니다.

 

1. `num_dict`라는 딕셔너리를 만듭니다. 이 딕셔너리는 각 영어 단어를 대응하는 숫자로 매핑하는 역할을 합니다.

2. `num_dict`에 저장된 각 영어 단어를 숫자로 변환합니다. 이를 위해 `numbers` 문자열의 `replace` 메서드를 사용합니다.

3. 변환된 문자열 `numbers`를 정수형으로 변환하여 반환합니다.

 

예를 들어, 입력으로 `"onetwothreefourfivesixseveneightnine"`가 주어진 경우, 이 함수는 `123456789`를 반환합니다.

 

def solution(numbers):

    for num, eng in enumerate(["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"]):

        numbers = numbers.replace(eng, str(num))

    return int(numbers)

 

 

def solution(numbers):

    dic = ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"]

    i=0

    for word in dic:

        numbers = numbers.replace(word, str(i))

        i+=1

    return int(numbers)

 

 

 

 

• 179//42문자열 계산하기as

문제 설명

my_string은 "3 + 5"처럼 문자열로 된 수식입니다. 문자열 my_string이 매개변수로 주어질 때, 수식을 계산한 값을 return 하는 solution 함수를 완성해주세요.

 

제한사항

• 연산자는 +, -만 존재합니다.
• 문자열의 시작과 끝에는 공백이 없습니다.
• 0으로 시작하는 숫자는 주어지지 않습니다.
• 잘못된 수식은 주어지지 않습니다.
• 5 ≤ my_string의 길이 ≤ 100
• my_string을 계산한 결과값은 1 이상 100,000 이하입니다.
• return type 은 정수형입니다.
• my_string의 숫자와 연산자는 공백 하나로 구분되어 있습니다.

입출력 예

my_string	result
"3 + 4"	7

입출력 예 설명

입출력 예 #1

• 3 + 4 = 7을 return 합니다.

 

def solution(my_string):

    result = eval(my_string)

    return result

 

 

def solution(my_string):

    return sum(int(i) for i in my_string.replace(' - ', ' + -').split(' + '))

 

 

 

solution=eval

 

def solution(my_string):

    s = my_string.split()

    answer = int(s[0])

    for i in range(1,len(s),2):

        if s[i]=='+':

            answer+=int(s[i+1])

        else:

            answer-=int(s[i+1])

    return answer

 

 

 

• 180//41문자 개수 세기 pppaa ??
• 
  

문제 설명

알파벳 대소문자로만 이루어진 문자열 my_string이 주어질 때, my_string에서 'A'의 개수, my_string에서 'B'의 개수,..., my_string에서 'Z'의 개수, my_string에서 'a'의 개수, my_string에서 'b'의 개수,..., my_string에서 'z'의 개수를 순서대로 담은 길이 52의 정수 배열을 return 하는 solution 함수를 작성해 주세요.

 

제한사항

• 1 ≤ my_string의 길이 ≤ 1,000

 

입출력 예

my_string	result
"Programmers"	[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 2, 0, 1, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0]

입출력 예 설명

입출력 예 #1

• 예제 1번의 my_string에서 'P'가 1개, 'a'가 1개, 'e'가 1개, 'g'가 1개, 'm'이 2개, 'o'가 1개, 'r'가 3개, 's'가 1개 있으므로 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 2, 0, 1, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0]를 return 합니다.

 

def solution(my_string):

    count_array = [0] * 52

 

    for char in my_string:

        if 'A' <= char <= 'Z':

            count_array[ord(char) - ord('A')] += 1

        elif 'a' <= char <= 'z':

            count_array[ord(char) - ord('a') + 26] += 1

 

    return count_array

 

 

def solution(my_string):

    answer=[0]*52

    for x in my_string:

        if x.isupper():

            answer[ord(x)-65]+=1

        else:

            answer[ord(x)-71]+=1

    return answer

 

 

def solution(my_string):

    return [my_string.count(alphabet) for alphabet in 'abcdefghijklmnopqrstuvwxyz'.upper()+'abcdefghijklmnopqrstuvwxyz']

 

 

import string

def solution(my_string):

    count = dict.fromkeys(string.ascii_uppercase + string.ascii_lowercase, 0)

    for s in my_string:

        count[s] += 1

    return list(count.values())

 

 

• 181//40.   qr code. pppss??
• 
  

문제 설명

두 정수 q, r과 문자열 code가 주어질 때, code의 각 인덱스를 q로 나누었을 때 나머지가 r인 위치의 문자를 앞에서부터 순서대로 이어 붙인 문자열을 return 하는 solution 함수를 작성해 주세요.

 

제한사항

• 0 ≤ r < q ≤ 20
• r < code의 길이 ≤ 1,000
• code는 영소문자로만 이루어져 있습니다.

 

입출력 예

q	r	code	result
3	1	"qjnwezgrpirldywt"	"jerry"
1	0	"programmers"	"programmers"

 

입출력 예 설명

입출력 예 #1

• 예제 1번의 q와 r은 각각 3, 1이고 인덱스와 그 값을 q로 나눈 나머지가 잘 보이도록 표로 만들면 다음과 같습니다.

• q로 나눈 나머지가 1인 인덱스의 문자들을 앞에서부터 순서대로 이어 붙이면 "jerry"가 되므로 이를 return 합니다.

• q

• j

• n

• w

• e

• z

• g

• r

• p

• i

• r

• l

• d

• y

• w

• t

• index

• 0

• 1

• 2

• 3

• 4

• 5

• 6

• 7

• 8

• 9

• 10

• 11

• 12

• 13

• 14

• 15

• q로 나눈 나머지

• 0

• 1

• 2

• 0

• 1

• 2

• 0

• 1

• 2

• 0

• 1

• 2

• 0

• 1

• 2

• 0

 

 

 

def solution(q, r, code):

    result = ""

 

    for i, char in enumerate(code):

        if i % q == r:

            result += char

 

    return result

 

 

def solution(q, r, code):

    return code[r::q]

 

 

def solution(q, r, code):

    return ''.join(code[i] for i in range(r, len(code), q))

 

 

def solution(q, r, code):

    answer=''

    for i in range(r,len(code),q):

        answer+=code[i]

    return answer

 

 

def solution(q, r, code):

    answer = ''

    for i in range(len(code)):

        if i % q == r:

            answer += code[i]

    return answer

 

• 182//39. 배열 만들기 4. Ppppassss
• 
   

문제 설명

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

변수 i를 만들어 초기값을 0으로 설정한 후 i가 arr의 길이보다 작으면 다음 작업을 반복합니다.

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

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

 

제한사항

• 1 ≤ arr의 길이 ≤ 100,000

 

입출력 예

arr	result
[1, 4, 2, 5, 3]	[1, 2, 3]

입출력 예 설명

입출력 예 #1

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

i	arr[i]	stk
0	1	[]
1	4	[1]
2	2	[1, 4]
2	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.append(arr[i])             i += 1         else:             stk.pop()     return stk	[1]
3	5	[1, 2]
4	3	[1, 2, 5]

 

따라서 [1, 2, 3]을 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.append(arr[i])

            i += 1

        else:

            stk.pop()

 

    return stk

 

def solution(arr):

    stk = []

    for i in range(len(arr)):

        while stk and stk[-1] >= arr[i]:

            stk.pop()

        stk.append(arr[i])

    return stk

 

 

def solution(arr):

    stack = []

    for i in range(len(arr)):

        n=arr[i]

        while stack and stack[-1]>=n:

            stack.pop()

        stack.append(n)

    return stac

 

 

 

• //183//38//구슬을 나누는 경우의 수

 

문제 설명

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

 

제한사항

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

 

입출력 예

balls	share	result
3	2	3
5	3	10

입출력 예 설명

입출력 예 #1

• 서로 다른 구슬 3개 중 2개를 고르는 경우의 수는 3입니다. 

 

입출력 예 #2

• 서로 다른 구슬 5개 중 3개를 고르는 경우의 수는 10입니다.

 

Hint

• 서로 다른 n개 중 m개를 뽑는 경우의 수 공식은 다음과 같습니다. 

 

 

 

import math

 

def solution(balls, share):

    combinations = math.comb(balls, share)

    return combinations

 

 

import math

 

def solution(balls, share):

    return math.comb(balls, share)

 

 

def solution(balls, share):

    answer = factorial(balls) / (factorial(balls - share) * factorial(share))

    return answer

 

def factorial(n):

    result = 1

    for i in range(1, n + 1):

        result = result * i

    return result

 

• 184//37. 두 수의 합
•  

문제 설명

0 이상의 두 정수가 문자열 a, b로 주어질 때, a + b의 값을 문자열로 return 하는 solution 함수를 작성해 주세요.

 

제한사항

• 1 ≤ a의 길이 ≤ 100,000
• 1 ≤ b의 길이 ≤ 100,000
• a와 b는 숫자로만 이루어져 있습니다.
• a와 b는 정수 0이 아니라면 0으로 시작하지 않습니다.

 

입출력 예

a	b	result
"582"	"734"	"1316"
"18446744073709551615"	"287346502836570928366"	"305793246910280479981"
"0"	"0"	"0"

 

입출력 예 설명

입출력 예 #1

• 예제 1번의 a, b는 각각 582, 734이고 582 + 734 = 1316입니다. 따라서 "1316"을 return 합니다.

입출력 예 #2

• 예제 2번의 a, b는 각각 18446744073709551615, 287346502836570928366이고 18446744073709551615 + 287346502836570928366 = 305793246910280479981입니다. 따라서 "305793246910280479981"을 return 합니다.

입출력 예 #3

• 예제 3번의 a, b는 각각 0, 0이고 0 + 0 = 0입니다. 따라서 "0"을 return 합니다.

 

 

def solution(a, b):

    a_int = int(a)

    b_int = int(b)

    result_int = a_int + b_int

    result_str = str(result_int)

    return result_str

 

 

def solution(a, b):

    return str(int(a) + int(b))

 

 

def solution(a, b):

    answer = ''

    return str(int(a)+int(b))

 

 

def solution(a, b):

    return str(sum([int(a),int(b)]))

 

def solution(a, b):

    answer = int(a)+int(b)

    answer = str(answer)

    return answer

 

 

def solution(a: str, b: str):

    return str(int(a) + int(b))

 

 

 

• 185//36 삼각형의 완성조건 (2)Pass
•  

문제 설명

선분 세 개로 삼각형을 만들기 위해서는 다음과 같은 조건을 만족해야 합니다.

• 가장 긴 변의 길이는 다른 두 변의 길이의 합보다 작아야 합니다.

삼각형의 두 변의 길이가 담긴 배열 sides이 매개변수로 주어집니다. 나머지 한 변이 될 수 있는 정수의 개수를 return하도록 solution 함수를 완성해주세요.

 

제한사항

• sides의 원소는 자연수입니다.
• sides의 길이는 2입니다.
• 1 ≤ sides의 원소 ≤ 1,000

 

입출력 예

sides	result
[1, 2]	1
[3, 6]	5
[11, 7]	13

출력 예 설명

입출력 예 #1

• 두 변이 1, 2 인 경우 삼각형을 완성시키려면 나머지 한 변이 2여야 합니다. 따라서 1을 return합니다.

입출력 예 #2

• 가장 긴 변이 6인 경우
• 나머지 한 변이 가장 긴 변인 경우
• 따라서 3 + 2 = 5를 return합니다.

입출력 예 #3

• 가장 긴 변이 11인 경우
• 나머지 한 변이 가장 긴 변인 경우
• 따라서 7 + 6 = 13을 return합니다.

 

Pass

 

187//35왼쪽 오른쪽

문제 설명

문자열 리스트 str_list에는 "u", "d", "l", "r" 네 개의 문자열이 여러 개 저장되어 있습니다. str_list에서 "l"과 "r" 중 먼저 나오는 문자열이 "l"이라면 해당 문자열을 기준으로 왼쪽에 있는 문자열들을 순서대로 담은 리스트를, 먼저 나오는 문자열이 "r"이라면 해당 문자열을 기준으로 오른쪽에 있는 문자열들을 순서대로 담은 리스트를 return하도록 solution 함수를 완성해주세요. "l"이나 "r"이 없다면 빈 리스트를 return합니다.

 

제한사항

• 1 ≤ str_list의 길이 ≤ 20
• str_list는 "u", "d", "l", "r" 네 개의 문자열로 이루어져 있습니다.

 

입출력 예

str_list	result
["u", "u", "l", "r"]	["u", "u"]
["l"]	[]

입출력 예 설명

입출력 예 #1

• "r"보다 "l"이 먼저 나왔기 때문에 "l"의 왼쪽에 있는 문자열들을 담은 리스트인 ["u", "u"]를 return합니다.

입출력 예 #2

• "l"의 왼쪽에 문자열이 없기 때문에 빈 리스트를 return합니다.

 

def solution(str_list):

    if "l" not in str_list and "r" not in str_list:

        return []

    elif "l" not in str_list:

        return str_list[str_list.index("r")+1:]

    elif "r" not in str_list:

        return str_list[:str_list.index("l")]

    else:

        if str_list.index("l") < str_list.index("r"):

            return str_list[:str_list.index("l")]

        else:

            return str_list[str_list.index("r")+1:]

 

위 코드는 문자열 리스트 `str_list`를 입력으로 받아, "l"과 "r" 중 먼저 나오는 문자열을 기준으로 왼쪽 또는 오른쪽에 있는 문자열들을 순서대로 담은 리스트를 반환하는 함수입니다. 이 함수는 다음과 같은 방식으로 동작합니다.

 

1. `str_list`에 "l"과 "r"이 모두 없는 경우, 빈 리스트를 반환합니다.

2. `str_list`에 "l"은 있지만 "r"은 없는 경우, "r"의 오른쪽에 있는 문자열들을 순서대로 담은 리스트를 반환합니다.

3. `str_list`에 "r"은 있지만 "l"은 없는 경우, "l"의 왼쪽에 있는 문자열들을 순서대로 담은 리스트를 반환합니다.

4. `str_list`에 "l"과 "r"이 모두 있는 경우, "l"과 "r" 중 먼저 나오는 문자열을 비교합니다. "l"이 먼저 나온 경우, "l"의 왼쪽에 있는 문자열들을 순서대로 담은 리스트를 반환합니다. 그렇지 않은 경우, "r"의 오른쪽에 있는 문자열들을 순서대로 담은 리스트를 반환합니다.

 

예를 들어, 입력으로 `["u", "u", "l", "r"]`가 주어진 경우, 이 함수는 `["u", "u"]`를 반환합니다.

 

def solution(str_list):

    for i in range(len(str_list)):

        if str_list[i]=='l': return str_list[:i]

        elif str_list[i]=='r': return str_list[i+1:]

    return []

 

 

def solution(str_list):

    for i, s in enumerate(str_list):

        if s == 'l':

            return str_list[:i]

        elif s == 'r':

            return str_list[i+1:]

    return []

 

 

def solution(str_list):

    answer = []

 

    for i in range(len(str_list)):

        if str_list[i] == 'l':

            answer = str_list[:i]

            break

        if str_list[i] == 'r':

            answer = str_list[i + 1:]

            break

    return answer

 

def solution(str_list):

    answer = []

    a="".join(str_list)

    for i in range(len(str_list)):

        if str_list[i]=="l":

            for x in range(0,i):

                answer.append(str_list[x])

            break

        if str_list[i]=="r":

            for x in range(i+1,len(str_list)):

                answer.append(str_list[x])

            break

    return answer

 

 

• 188//34 조건 문자열
•  

문제 설명

문자열에 따라 다음과 같이 두 수의 크기를 비교하려고 합니다.

• 두 수가 n과 m이라면

두 문자열 ineq와 eq가 주어집니다. ineq는 "<"와 ">"중 하나고, eq는 "="와 "!"중 하나입니다. 그리고 두 정수 n과 m이 주어질 때, n과 m이 ineq와 eq의 조건에 맞으면 1을 아니면 0을 return하도록 solution 함수를 완성해주세요.

 

제한 사항

• 1 ≤ n, m ≤ 100

 

입출력 예

ineq	eq	n	m	result
"<"	"="	20	50	1
">"	"!"	41	78	0

입출력 예 설명

입출력 예 #1

• 20 <= 50은 참이기 때문에 1을 return합니다.

입출력 예 #2

• 41 > 78은 거짓이기 때문에 0을 return합니다.

 

def solution(ineq, eq, n, m):

    if ineq == "<":

        if eq == "=":

            return int(n <= m)

        else:

            return int(n < m)

    else:

        if eq == "=":

            return int(n >= m)

        else:

            return int(n > m)

 

 

def solution(ineq, eq, n, m):

    return int(eval(str(n)+ineq+eq.replace('!', '')+str(m)))

 

 

def solution(ineq, eq, n, m):

    answer = 0

    if n > m and ineq ==">":

        answer = 1

    elif n < m and ineq == "<":

        answer = 1

    elif n == m and eq == "=":

        answer = 1

 

   return answer

 

 

def solution(ineq, eq, n, m):

    if eq == '!':

        eq = ''

    return int(eval(f'{n} {ineq}{eq} {m}'))

 

 

• 189//33정사각형으로 만들기
•  

문제 설명

이차원 정수 배열 arr이 매개변수로 주어집니다. arr의 행의 수가 더 많다면 열의 수가 행의 수와 같아지도록 각 행의 끝에 0을 추가하고, 열의 수가 더 많다면 행의 수가 열의 수와 같아지도록 각 열의 끝에 0을 추가한 이차원 배열을 return 하는 solution 함수를 작성해 주세요.

 

제한사항

• 1 ≤ arr의 길이 ≤ 100
• 1 ≤ arr의 원소의 길이 ≤ 100
• 1 ≤ arr의 원소의 원소 ≤ 1,000

 

입출력 예

arr	result
[[572, 22, 37], [287, 726, 384], [85, 137, 292], [487, 13, 876]]	[[572, 22, 37, 0], [287, 726, 384, 0], [85, 137, 292, 0], [487, 13, 876, 0]]
[[57, 192, 534, 2], [9, 345, 192, 999]]	[[57, 192, 534, 2], [9, 345, 192, 999], [0, 0, 0, 0], [0, 0, 0, 0]]
[[1, 2], [3, 4]]	[[1, 2], [3, 4]]

입출력 예 설명

입출력 예 #1

• 예제 1번의 arr은 행의 수가 4, 열의 수가 3입니다. 행의 수가 더 많으므로 열의 수를 4로 만들기 위해 arr의 각 행의 끝에 0을 추가한 이차원 배열 [[572, 22, 37, 0], [287, 726, 384, 0], [85, 137, 292, 0], [487, 13, 876, 0]]를 return 합니다.

입출력 예 #2

• 예제 2번의 arr은 행의 수가 2, 열의 수가 4입니다. 열의 수가 더 많으므로 행의 수를 4로 만들기 위해 arr의 각 열의 끝에 0을 추가한 이차원 배열 [[57, 192, 534, 2], [9, 345, 192, 999], [0, 0, 0, 0], [0, 0, 0, 0]]을 return 합니다.

입출력 예 #3

• 예제 3번의 arr은 행의 수와 열의 수가 2로 같습니다. 따라서 0을 추가하지 않고 [[1, 2], [3, 4]]을 return 합니다.

 

 

def solution(arr):

    num_rows = len(arr)

    num_cols = len(arr[0])

 

    if num_rows > num_cols:

        for row in arr:

            row.extend([0] * (num_rows - num_cols))

    elif num_cols > num_rows:

        num_zeros = num_cols - num_rows

        for _ in range(num_zeros):

            arr.append([0] * num_cols)

 

    return arr

 

 

 

def solution(arr):

    n=len(arr)

    m=len(arr[0])

    if n>m:

        for i in range(n):

            for j in range(n-m):

                arr[i].append(0)

    else:

        for i in range(m-n):

            arr.append([0]*m)

 

    return arr

 

def solution(arr):

    num_rows = len(arr)

    num_cols = len(arr[0])

 

    if num_rows > num_cols:

        for i in range(num_rows):

            arr[i] += [0] * (num_rows - num_cols)

    elif num_cols > num_rows:

        for i in range(num_cols - num_rows):

            arr.append([0] * num_cols)

 

    return arr

 

 

def solution(arr):

    answer = []

 

    countMax = max(len(arr), max(len(row) for row in arr))

    i = 0

    while i < countMax:

        if i < len(arr):

            answer.append(arr[i] + [0] * (countMax - len(arr[i])))

        else:

            answer.append([0] * countMax)

        i += 1

 

    return answer

 

def solution(arr):

    while True:

        if len(arr) > len(arr[0]):

            for i in range(len(arr)):

                arr[i].append(0)

        elif len(arr) < len(arr[0]):

            for i in range(len(arr[0])-len(arr)):

                arr.append(len(arr[0])*[0])

        else:

            break

    return arr