<문제>

문제 설명

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):
    answer = 0
    arr = [0]
    for num in numbers:
        tmp = []
        for a in arr:
            tmp.append(a + num)
            tmp.append(a - num)
        arr = tmp

    for i in arr:
        if i == target:
            answer += 1
    return answer

<다른 풀이>

방법 1.

def solution(numbers, target):
    if not numbers and target == 0 :
        return 1
    elif not numbers:
        return 0
    else:
        return solution(numbers[1:], target-numbers[0]) + solution(numbers[1:], target+numbers[0])

방법 2.

from itertools import product
def solution(numbers, target):
    l = [(x, -x) for x in numbers]
    s = list(map(sum, product(*l)))
    return s.count(target)

방법 3.

def solution(numbers, target):
    q = [0]
    for n in numbers:
        s = []
        for _ in range(len(q)):
            x = q.pop()
            s.append(x + n)
            s.append(x + n*(-1))
        q = s.copy()
    return q.count(target)

<느낀점>

코드 설명 필요

<문제>

문제 설명

수포자는 수학을 포기한 사람의 준말입니다. 수포자 삼인방은 모의고사에 수학 문제를 전부 찍으려 합니다. 수포자는 1번 문제부터 마지막 문제까지 다음과 같이 찍습니다.

1번 수포자가 찍는 방식: 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, ... 2번 수포자가 찍는 방식: 2, 1, 2, 3, 2, 4, 2, 5, 2, 1, 2, 3, 2, 4, 2, 5, ... 3번 수포자가 찍는 방식: 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, ...

1번 문제부터 마지막 문제까지의 정답이 순서대로 들은 배열 answers가 주어졌을 때, 가장 많은 문제를 맞힌 사람이 누구인지 배열에 담아 return 하도록 solution 함수를 작성해주세요.

제한 사항

시험은 최대 10,000 문제로 구성되어있습니다.
문제의 정답은 1, 2, 3, 4, 5중 하나입니다.
가장 높은 점수를 받은 사람이 여럿일 경우, return하는 값을 오름차순 정렬해주세요.

<풀이>

def solution(answers):
    answer1 = []
    answer2 = []
    answer3 = []
    a = [1,2,3,4,5] * 2000
    b = [2,1,2,3,2,4,2,5] * 1250
    c = [3,3,1,1,2,2,4,4,5,5] * 1000
    for i in range(len(answers)):
        if a[i]/answers[i] == 1.0:
            answer1.append(a[i])
    a_len = len(answer1)

    for i in range(len(answers)):
        if b[i]/answers[i] == 1.0:
            answer2.append(b[i])
    b_len = len(answer2)

    for i in range(len(answers)):
        if c[i]/answers[i] == 1.0:
            answer3.append(c[i])
    c_len = len(answer3)

    if a_len == 0 and  b_len == 0 and c_len == 0:
        return []

    elif c_len != 0 and b_len != 0 and a_len ==0:
        if (b_len > c_len):
            return [2]
        elif (c_len > b_len):
            return [3]
        elif (b_len == c_len):
            return [2,3]

    elif c_len == 0 and b_len != 0 and a_len !=0:
        if (a_len > b_len):
            return [1]
        elif (b_len > a_len):
            return [2]
        elif (a_len == b_len):
            return [1,2]

    elif c_len != 0 and b_len == 0 and a_len !=0:
        if (a_len > c_len):
            return [1]
        elif (c_len > a_len):
            return [3]
        elif (a_len == c_len):
            return [1,3]

    elif a_len != 0 and b_len == 0 and c_len == 0:
        return [1]
    elif a_len == 0 and b_len != 0 and c_len == 0:
        return [2]
    elif a_len == 0 and b_len == 0 and c_len != 0:
        return [3]

    elif c_len != 0 and b_len != 0 and a_len !=0:
        if (a_len > b_len > c_len) or (a_len > c_len > b_len) or (a_len > b_len == c_len):
            return [1]
        elif (b_len > a_len > c_len) or (b_len > c_len > a_len) or (b_len > a_len == c_len):
            return [2]
        elif (c_len > a_len > b_len) or (c_len > b_len > a_len) or (c_len > a_len == b_len):
            return [3]
        elif (a_len == b_len > c_len):
            return [1,2]
        elif (a_len == c_len > b_len):
             return [1,3]
        elif (b_len == c_len > a_len):
             return [2,3]
        elif (a_len == b_len == c_len):
            return [1,2,3]

<다른 풀이>

방법 1.

def solution(answers):
    pattern1 = [1,2,3,4,5]
    pattern2 = [2,1,2,3,2,4,2,5]
    pattern3 = [3,3,1,1,2,2,4,4,5,5]
    score = [0, 0, 0]
    result = []

    for idx, answer in enumerate(answers):
        if answer == pattern1[idx%len(pattern1)]:
            score[0] += 1
        if answer == pattern2[idx%len(pattern2)]:
            score[1] += 1
        if answer == pattern3[idx%len(pattern3)]:
            score[2] += 1

    for idx, s in enumerate(score):
        if s == max(score):
            result.append(idx+1)

    return result

방법 2.

a = [1, 2, 3, 4, 5]
b = [2, 1, 2, 3, 2, 4, 2, 5]
c = [3, 3, 1, 1, 2, 2, 4, 4, 5, 5]

def solution(answers):
    answer = []
    aa = [1 for i, val in enumerate(answers) if a[i % 5] == val]
    bb = [1 for i, val in enumerate(answers) if b[i % 8] == val]
    cc = [1 for i, val in enumerate(answers) if c[i % 10] == val]

    x = max([len(aa),len(bb),len(cc)])

    if x == len(aa) :
        answer.append(1)
    if x == len(bb) :
        answer.append(2)
    if x == len(cc) :
        answer.append(3)

    sorted(answer)

    return answer

<느낀점>

코드 설명 필요

<문제>

주어진 숫자 중 3개의 수를 더했을 때 소수가 되는 경우의 개수를 구하려고 합니다. 숫자들이 들어있는 배열 nums가 매개변수로 주어질 때, nums에 있는 숫자들 중 서로 다른 3개를 골라 더했을 때 소수가 되는 경우의 개수를 return 하도록 solution 함수를 완성해주세요.

<제한 조건>

nums에 들어있는 숫자의 개수는 3개 이상 50개 이하입니다.
nums의 각 원소는 1 이상 1,000 이하의 자연수이며, 중복된 숫자가 들어있지 않습니다.

< 풀이 >

from itertools import combinations
def solution(nums):
    a = list(combinations(nums,3))
    arr = []
    for i in range(len(a)):
        arr.append(sum(a[i]))

    brr = []
    crr = []
    for j in arr:
        for k in range(1, int(j**0.5)+1):
            if j%k == 0:
                brr.append(k)
        if len(brr) == 1:
            crr.append(j)
        brr.clear()
    return len(crr)

<함수 개념>

1. combinations
2. permutations

<문제>

1부터 입력받은 숫자 n 사이에 있는 소수의 개수를 반환하는 함수, solution을 만들어 보세요. 소수는 1과 자기 자신으로만 나누어지는 수를 의미합니다. (1은 소수가 아닙니다.)

<제한 조건>

n은 2이상 1000000이하의 자연수입니다.

< 풀이 1단계>

def solution(n):
    answer = []
    for i in range(2,n+1):
        arr = []
        for j in range(1,i+1):
            if i%j == 0:
                arr.append(j)
        if len(arr) == 2:
            answer.append(i)
            del arr
    return len(answer)
# 테스트 케이스는 통과했으나 효율성 측면에서 실패

< 풀이 2단계>

def solution(n):
    li = [] 
    for n in range(2,n+1): 
        check = True 
        for i in range(2, int(n**0.5)+1): 
            if n%i == 0: 
                check = False 
        if check: 
            li.append(n)

    return len(li)
# 풀이 1단계보다 효율성은 높아졌지만, 통과 못함

< 풀이 3단계>

def solution(n):
    numbers = [True] * (n + 1)
    cnt = 0

    for i in range(2,int(n**0.5)+1):
        if numbers[i] == False:
            continue;

        for j in range(2*i,n+1,i):
            numbers[j] = False

    for j in range(2,n+1):
        if numbers[j] == True:
            cnt+=1

    return cnt
# 통과

<다른 풀이>

def solution(n):
    num=set(range(2,n+1))

    for i in range(2,n+1):
        if i in num:
            num-=set(range(2*i,n+1,i))
    return len(num)

<풀이 3단계 코드 설명>

< 풀이 >

def solution(s):
    answer = s.replace('one','1').replace('two','2').replace('three','3').replace('four','4').replace('five','5').replace('six','6').replace('seven', '7').replace('eight', '8').replace('nine','9').replace('zero','0')
    return int(answer)

<다른 풀이>

방법 1.

num_dic = {"zero":"0", "one":"1", "two":"2", "three":"3", "four":"4", "five":"5", "six":"6", "seven":"7", "eight":"8", "nine":"9"}

def solution(s):
    answer = s
    for key, value in num_dic.items():
        answer = answer.replace(key, value)
    return int(answer)

방법 2.

def solution(s):
    words = ['zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine']

    for i in range(len(words)):
        s = s.replace(words[i], str(i))

    return int(s)

<느낀점>

방법1의 경우 dict 개념을 완벽히 이해한 코드가 아닐까 싶다.

<문제>

두 정수 left와 right가 매개변수로 주어집니다. left부터 right까지의 모든 수들 중에서, 약수의 개수가 짝수인 수는 더하고, 약수의 개수가 홀수인 수는 뺀 수를 return 하도록 solution 함수를 완성해주세요.

< 풀이 >

def solution(left, right):
    arr = []
    cnt = []
    for i in range(left, right+1):
        for j in range(1,i+1):
            if i%j == 0:
                arr.append(j)
        if len(arr) %2 == 0:
            cnt.append(i)
            del arr[:]
        elif len(arr) %2 != 0:
            cnt.append(-i)
            del arr[:]
    return sum(cnt)

<다른 풀이>

방법 1.

def solution(left, right):
    answer = 0
    for i in range(left,right+1):
        if int(i**0.5)==i**0.5: # 개념 설명 밑에
            answer -= i
        else:
            answer += i
    return answer

방법 2.

import math
def solution(left, right):
    answer = 0
    for i in range(left, right + 1, 1):
        sqrt = math.sqrt(i)
        if int(sqrt) == sqrt:
            answer -= i
        else:
            answer += i

    return answer

방법 3.

def solution(left, right):
    def cnt_yak(number):
        cnt = 1
        for i in range(1, number//2+1):
            if number % i == 0:
                cnt += 1
        return cnt

    answer = 0
    for i in range(left, right+1):
        cnt = cnt_yak(i)
        if cnt % 2 == 0:
            answer += i
        else:
            answer -= i
    return answer

<방법 1. 코드 설명>

int(i0.5)==i0.5: 부분은 약수의 갯수를 구할 때 가장 핵심적인 코드이다.

예1) 25인 경우 -> 약수: [1, 5, 25]

25를 제곱근 씌운 경우 5 도출 -> 제곱근 값이 정수형으로 나타낸 값과 같은 경우 약수의 갯수는 홀수이므로 뺀 수 도출

예2) 15인 경우 -> 약수: [1, 3, 5, 15]

15를 제곱근 씌운 경우 3.XXX 도출 -> 제곱근 값이 정수형으로 나타낸 값과 같지 않으므로, 약수의 갯수는 짝수이므로 더한 수 도출

<방법 2. 코드 설명>

sqrt = math.sqrt(i) 여기서 sqrt는 제곱근을 의미하는 것으로 i****0.5와 동일한 코드이다. 제곱근 함수라고 기억하면 된다.

<문제>

문제 설명

정수를 저장한 배열, arr 에서 가장 작은 수를 제거한 배열을 리턴하는 함수, solution을 완성해주세요. 단, 리턴하려는 배열이 빈 배열인 경우엔 배열에 -1을 채워 리턴하세요. 예를들어 arr이 [4,3,2,1]인 경우는 [4,3,2]를 리턴 하고, [10]면 [-1]을 리턴 합니다.

제한 사항

arr은 길이 1 이상인 배열입니다.
인덱스 i, j에 대해 i ≠ j이면 arr[i] ≠ arr[j] 입니다.

<풀이>

def solution(arr):
    if len(arr) == 1:
        return [-1]
    else:
        a = sorted(arr)
        arr.remove(a[0])
        return arr

<다른 풀이>

방법 1.

def rm_small(mylist):
    return [i for i in mylist if i > min(mylist)]

방법 2.

def rm_small(mylist):
    mylist.pop(mylist.index(min(mylist)))
    return mylist

<느낀점>

방법2처럼 pop을 하는 경우 메모리 낭비의 위험이 있다.

<문제>

어떤 문장의 각 알파벳을 일정한 거리만큼 밀어서 다른 알파벳으로 바꾸는 암호화 방식을 시저 암호라고 합니다. 예를 들어 "AB"는 1만큼 밀면 "BC"가 되고, 3만큼 밀면 "DE"가 됩니다. "z"는 1만큼 밀면 "a"가 됩니다. 문자열 s와 거리 n을 입력받아 s를 n만큼 민 암호문을 만드는 함수, solution을 완성해 보세요.

<제한 조건>

공백은 아무리 밀어도 공백입니다.
s는 알파벳 소문자, 대문자, 공백으로만 이루어져 있습니다.
s의 길이는 8000이하입니다.
n은 1 이상, 25이하인 자연수입니다.

< 풀이 1단계>

    cap_list = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']*25
    small_list = ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']*25
    a = []
    for i in range(len(s)):
        a.append(s[i])
    for j in range(len(a)):
        if a[j] in cap_list:
            b = cap_list.index(a[j])
            a[j] = cap_list[b+n]
        elif a[j] in small_list:
            c = small_list.index(a[j])
            a[j] = small_list[c+n]
    return ''.join(a)

<다른 풀이>

방법 1.

def caesar(s, n):
    s = list(s)
    for i in range(len(s)):
        if s[i].isupper():
            s[i]=chr((ord(s[i])-ord('A')+ n)%26+ord('A'))
        elif s[i].islower():
            s[i]=chr((ord(s[i])-ord('a')+ n)%26+ord('a'))

    return "".join(s)

방법 2.

def caesar(s, n):
    lower_list = "abcdefghijklmnopqrstuvwxyz"
    upper_list = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

    result = []

    for i in s:
        if i is " ":
            result.append(" ")
        elif i.islower() is True:
            new_ = lower_list.find(i) + n
            result.append(lower_list[new_ % 26])
        else:
            new_ = upper_list.find(i) + n
            result.append(upper_list[new_ % 26])
    return "".join(result)

방법 3.

def caesar(s, n):
    eng = "abcdefghijklmnopqrstuvwxyz"
    new = ""
    for i in s :
        if i == " " :
            new += " "
        for j in range(len(eng)) :
            if eng[j] == i.lower() :
                if i.isupper() == True :
                    new += eng[(j+n) % len(eng)].upper()
                else :
                    new += eng[(j+n) % len(eng)]
    return new

<느낀점>

ord문자 활용하는 방법만 알아도 문제를 편리하게 풀 수 있는 것 같다. 그렇지만 나에겐 아직 정립이 안된 느낌~

<문제>

문제 설명

자연수 n이 매개변수로 주어집니다. n을 x로 나눈 나머지가 1이 되도록 하는 가장 작은 자연수 x를 return 하도록 solution 함수를 완성해주세요. 답이 항상 존재함은 증명될 수 있습니다.

제한 사항

3 ≤ n ≤ 1,000,000

<풀이>

def solution(n):
    answer = []
    for x in range(2,n+1):
        if n%x == 1:
            answer.append(x)
            return answer[0]

<다른 풀이>

방법 1.

def solution(n):
    answer = 0

    for divisior in range(2, (n-1//2) +1) : #2부터~반값까지 
        if (n-1) % divisior == 0: #약수가 있다면
            answer = divisior 
            break #탈출
        else: 
            answer = n-1 #약수가 없다면 본인
    return answer

방법 2.

import math
def solution(n):
    x = n - 1
    if x % 2 == 0:
        return 2
    for i in range(2, int(math.sqrt(x)) + 1):
        if x % i == 0:
            return i
    return x

<코드 리뷰>

sqrt의 경우 제곱근을 의미하는 것으로, math 함수를 import 하지 않고 대신, (x**0.5)로 써도 된다.

<문제>

문제 설명

정수 배열 numbers가 주어집니다. numbers에서 서로 다른 인덱스에 있는 두 개의 수를 뽑아 더해서 만들 수 있는 모든 수를 배열에 오름차순으로 담아 return 하도록 solution 함수를 완성해주세요.

제한 사항

numbers의 길이는 2 이상 100 이하입니다.
numbers의 모든 수는 0 이상 100 이하입니다.

<풀이>

def solution(numbers):
    answer = []
    numbers.sort()
    for i in range(len(numbers)):
        for j in range(len(numbers)):
            if i < j:
                answer.append(numbers[i]+numbers[j])
    return sorted(list(set(answer)))

<다른 풀이 >

방법 1.

def solution(numbers):
    answer = []
    for i in range(len(numbers)):
        for j in range(i+1, len(numbers)):
            answer.append(numbers[i] + numbers[j])
    return sorted(list(set(answer)))

방법 2.

from itertools import combinations
def solution(numbers):
    return sorted(set(sum(i) for i in list(combinations(numbers, 2))))

<느낀점>

방법2의 경우에는 수열조합을 통해 구현하였다. 굉장히 간편한 방법으로 다양한 함수를 익혀두는 것이 좋을 듯 싶다.

<문제>

문제 설명

문자열 s에 나타나는 문자를 큰것부터 작은 순으로 정렬해 새로운 문자열을 리턴하는 함수, solution을 완성해주세요. s는 영문 대소문자로만 구성되어 있으며, 대문자는 소문자보다 작은 것으로 간주합니다.

제한 사항

str은 길이 1 이상인 문자열입니다.

<풀이>

def solution(s):
    return "".join(list(reversed(sorted(s))))

<다른 풀이>

def solution(s):
    return ''.join(sorted(s, reverse=True))
    # reverse의 다른 표현방식

<느낀점>

reverse vs reversed 개념 확실히 정리하기!

<문제>

문제 설명

새로 생긴 놀이기구는 인기가 매우 많아 줄이 끊이질 않습니다. 이 놀이기구의 원래 이용료는 price원 인데, 놀이기구를 N 번 째 이용한다면 원래 이용료의 N배를 받기로 하였습니다. 즉, 처음 이용료가 100이었다면 2번째에는 200, 3번째에는 300으로 요금이 인상됩니다. 놀이기구를 count번 타게 되면 현재 자신이 가지고 있는 금액에서 얼마가 모자라는지를 return 하도록 solution 함수를 완성하세요. 단, 금액이 부족하지 않으면 0을 return 하세요.

제한 사항

놀이기구의 이용료 price : 1 ≤ price ≤ 2,500, price는 자연수
처음 가지고 있던 금액 money : 1 ≤ money ≤ 1,000,000,000, money는 자연수
놀이기구의 이용 횟수 count : 1 ≤ count ≤ 2,500, count는 자연수

<풀이>

def solution(price, money, count):
    sum = 0
    for i in range(1, count+1):
        a = price * i
        sum += a
    if sum > money:
        return sum - money
    else:
        return 0

<다른 풀이>

방법 1.

def solution(price, money, count):
    return max(0,price*(count+1)*count//2-money)

방법 2.

def solution(price, money, count):
    return abs(min(money - sum([price*i for i in range(1,count+1)]),0))

<느낀점>

개발자가 수학자가 되어가는 기분이 솔솔......

<문제>

어떤 정수들이 있습니다. 이 정수들의 절댓값을 차례대로 담은 정수 배열 absolutes와 이 정수들의 부호를 차례대로 담은 불리언 배열 signs가 매개변수로 주어집니다. 실제 정수들의 합을 구하여 return 하도록 solution 함수를 완성해주세요.

[제한사항]

absolutes의 길이는 1 이상 1,000 이하입니다.
absolutes의 모든 수는 각각 1 이상 1,000 이하입니다.
signs의 길이는 absolutes의 길이와 같습니다.
signs[i] 가 참이면 absolutes[i] 의 실제 정수가 양수임을, 그렇지 않으면 음수임을 의미합니다.

<풀이>

def solution(absolutes, signs):
    arr = []
    for i in range(len(absolutes)):
        if signs[i] == True:
            arr.append(absolutes[i])
        elif signs[i] == False:
            arr.append(-absolutes[i])
    return sum(arr)

<다른 풀이>

def solution(absolutes, signs):
    return sum(absolutes if sign else -absolutes for absolutes, sign in zip(absolutes, signs))

<느낀점>

zip 함수를 통해 absolutes와 signs를 묶고, list comprehension을 이용하여 한줄로 표현한 것이 너무 인상깊었다. 아직까지는 zip함수가 익숙하지가 않아서 표현에 어려움이 있지만 편리한 함수인만큼 다양하게 사용하는 것이 좋을 듯 하다.

<문제>

문제 설명

배열 array의 i번째 숫자부터 j번째 숫자까지 자르고 정렬했을 때, k번째에 있는 수를 구하려 합니다.

예를 들어 array가 [1, 5, 2, 6, 3, 7, 4], i = 2, j = 5, k = 3이라면

array의 2번째부터 5번째까지 자르면 [5, 2, 6, 3]입니다. 1에서 나온 배열을 정렬하면 [2, 3, 5, 6]입니다. 2에서 나온 배열의 3번째 숫자는 5입니다. 배열 array, [i, j, k]를 원소로 가진 2차원 배열 commands가 매개변수로 주어질 때, commands의 모든 원소에 대해 앞서 설명한 연산을 적용했을 때 나온 결과를 배열에 담아 return 하도록 solution 함수를 작성해주세요.

<풀이>

# 처음 생각(예로 만들어보기)
array = [1, 5, 2, 6, 3, 7, 4]
i = 2
j = 5
k = 3

array2 = array[i-1:j]
array2.sort()
array2[k-1]

----------------------------------------------
#생각 확장 및 답
def solution(array, commands):
    answer = []
    for i in range(len(commands)):
        arr = array[commands[i][0]-1 : commands[i][1]]
        arr.sort()
        answer.append(arr[commands[i][2]-1])
    return answer

<다른 풀이>

방법 1.

def solution(array, commands):
    return list(map(lambda x:sorted(array[x[0]-1:x[1]])[x[2]-1], commands))

방법 2.

def solution(array, commands):
    answer = []
    for command in commands:
        i,j,k = command
        answer.append(list(sorted(array[i-1:j]))[k-1])
    return answer

방법 3.

def solution(array, commands):
    return [sorted(array[a[0]-1:a[1]])[a[2]-1] for a in commands]

<느낀점>

파이썬은 공부할 수록 내가 멍청해지는 기분이다. 다른 사람 코드 볼 때마다 감탄과 현타를 느끼게 되는................ =^=

자료구조 분류

출처) https://blog.naver.com/sun_zero2/221747373979

스택(Stack)

stack의 구조를 가장 잘 표현해주는 이미지이다. 사실 stack을 설명할때 쌓여있는 책으로 표현을 많이 하는데, 난 편의상 쌓여있는 마카롱으로 이해했다.(가장 접근하기 쉬운 방법으로 이해하는 것이 좋다 ㅎㅎㅎㅎㅎ)

새로운 마카롱을 만들었다고 가정하자. 새로운 마카롱을 어디다 위치하는 것이 좋을까? 당연히, 노란색 마카롱 위에 위치하는 것이 좋다. 즉, 차례대로 밑에서부터 쌓아가는 과정이자 가장 최신에 만든 자료가 맨 위에 위치하는 방법이 stack이다.

스택 구조에서 사용할 수 있는 명령어

1. push : stack 맨 위(맨 끝)에 항목을 삽입하기

<사용법>
s = [1,2,3,4,5]
s.push(6)
print(s) -> [1,2,3,4,5,6]

2.** pop** : stack 맨 끝의 항목을 빼내기

<사용법>
s = [1,2,3,4,5,6]
s.pop() # 6제거됨
print(s) -> [1,2,3,4,5]

3.** top/peek** : stack 맨 끝의 항목을 조회하기

<사용법>
s = [1,2,3,4,5]
print(s.peek()) -> 5
print(s) -> [1,2,3,4,5]

4.** empty** : 빈 stack인지 확인하기

<사용법>
s = [1,2,3,4,5]
print(s.isempty()) -> False

5. ** size** : stack 크기 확인

   <사용법>
   s = [1,2,3,4,5]
   print(s.size()) -> 5
   

스택 구현방법

1. 함수 설정

2. 확인

3. 출력

머신러닝 강의 수강 및 수료증 발급받기
(과제 제출 및 퀴즈 포함)

계획2

혼자 공부하는 머신러닝+딥러닝 책 **완독** 하기
2022.04.18.(월) 책 주문 완료
2022.04.19.(화) 책 수령 예정

계획3

알고리즘 강의 듣고 문제 풀이
문제 풀이 방법 블로그 업로드 및 개념 정리
1) 스택/큐
    문제1. 주택가격
    문제2. 기능개발
    문제3. 다리를 지나는 트럭

2) 완전탐색/이분탐색
    문제1. 모의고사
    문제2. 소수 찾기
    문제3. 숫자카드2

계획4

공모전 본격적으로 준비
2020년도 출품작 분석하기

2022. 04. 30.(토)까지 완료하기

머신러닝에 무너질 수 없다

<문제>

문자열 s를 숫자로 변환한 결과를 반환하는 함수, solution을 완성하세요.

예를들어 str이 "1234"이면 1234를 반환하고, "-1234"이면 -1234를 반환하면 됩니다. str은 부호(+,-)와 숫자로만 구성되어 있고, 잘못된 값이 입력되는 경우는 없습니다.

<풀이>

def solution(s):
    s = int(s)
    return s

<다른 풀이>

def solution(str):
    result = 0

    for idx, number in enumerate(str[::-1]):
        if number == '-':
            result *= -1
        else:
            result += int(number) * (10 ** idx)

    return result

<코드 해설>

다른 풀이법에서, enumerate를 쓴 것이 인상깊는다. enumerate는 반복문을 사용 할 때 몇 번째 반복문인지 인덱스 번호를 매겨주는 요소라고 생각하면 된다. 코드 설명은 다음과 같다.

예) '1234'입력

 str[::-1]에 의해 4321로 바뀜.
 이때, enumerate에 의해 idx = 0, number = 4
 else구문에서 reseult값은 int(4)*(10**0) = 4
 for문에 의해 다시 돌아가면 idx = 1, number = 3
 else구문에서 reseult값은 int(3)*(10**1) = 30
 result += 에 의해 4 + 30 = 34 도출
 이러한 형태로 1까지 가게 되면 1234 정수 값이 도출된다.

예) '-1234'입력

 str[::-1]에 의해 4321-로 바뀜.
 위에 설명한대로 idx = 3, number 1까지 했을 경우 1234가 도출된다.
 그 후, - 가 있으니 1234 * '-' 값인 -1234 도출

<느낀점>

알고리즘을 알고리즘처럼 푸는 것이 쉽지 않다.

<문제>

2016년 1월 1일은 금요일입니다. 2016년 a월 b일은 무슨 요일일까요? 두 수 a ,b를 입력받아 2016년 a월 b일이 무슨 요일인지 리턴하는 함수, solution을 완성하세요. 요일의 이름은 일요일부터 토요일까지 각각 SUN,MON,TUE,WED,THU,FRI,SAT 입니다. 예를 들어 a=5, b=24라면 5월 24일은 화요일이므로 문자열 "TUE"를 반환하세요.

<풀이>

def solution(a, b):
    m = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
    d = ['THU','FRI','SAT','SUN','MON','TUE','WED']
    dday = sum(m[:a-1]) + b
    return d[dday%7]

<다른 풀이>

방법 1.

def getDayName(a,b):
    answer = ""
    if a>=2:
        b+=31
        if a>=3:
            b+=29#2월
            if a>=4:
                b+=31#3월
                if a>=5:
                    b+=30#4월
                    if a>=6:
                        b+=31#5월
                        if a>=7:
                            b+=30#6월
                            if a>=8:
                                b+=31#7월
                                if a>=9:
                                    b+=31#8월
                                    if a>=10:
                                        b+=30#9월
                                        if a>=11:
                                            b+=31#10월
                                            if a==12:
                                                b+=30#11월
    b=b%7

    if b==1:answer="FRI"
    elif b==2:answer="SAT" 
    elif b==3:answer="SUN"
    elif b==4:answer="MON"
    elif b==5:answer="TUE"
    elif b==6:answer="WED"
    else:answer="THU"
    return answer

방법 2.

import datetime

def getDayName(a,b):
    t = 'MON TUE WED THU FRI SAT SUN'.split()
    return t[datetime.datetime(2016, a, b).weekday()]

방법 3.

def getDayName(a,b):
    day_name = ['THU', 'FRI', 'SAT', 'SUN', 'MON', 'TUE', 'WED']
    month_dict = {
        "1":31, 
        "2":29, 
        "3":31, 
        "4":30, 
        "5":31, 
        "6":30, 
        "7":31, 
        "8":31, 
        "9":30, 
        "10":31, 
        "11":30, 
        "12":31
    }
    days = 0
    for i in range(1, a):
        days += month_dict[str(i)]
    days += b
    index = days % 7

    return day_name[index]

방법 4.

def solution(a, b):
    days = ["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"]
    dayLen = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

    now = 5
    for i in range(0, a - 1) :
        now += dayLen[i]

    answer = (now + b - 1) % 7

    return days[answer]

<느낀점>

사실 방법1 경우를 가장 먼저 생각했다. 도저히 어떻게 코드를 구현해야할 지 감이 안와서 노가다로 하다가 결국 list형식으로 구현했다. 끝까지 코드를 완성시키는 것 또한 너무나 본받을 점이다.

<문제>

두 수를 입력받아 두 수의 최대공약수와 최소공배수를 반환하는 함수, solution을 완성해 보세요. 배열의 맨 앞에 최대공약수, 그다음 최소공배수를 넣어 반환하면 됩니다. 예를 들어 두 수 3, 12의 최대공약수는 3, 최소공배수는 12이므로 solution(3, 12)는 [3, 12]를 반환해야 합니다.

<생각 흐름 상 풀이>

def solution(n, m):
    for i in range(2, 1000000):
        for j in range(2, 1000000):
            if m%j == 0 and n%i == 0:
                if i == j:
                    if i == n or j == m:
                        return [i, int(i*(m/i)*(n/i))]
                    else:
                        return [i,int((m/i)*(n/i))]
                    break  
            if n%m == 0:
                return [m, n]
            break
        if m%n == 0:
            return [n, m]
        break
    if (m%j != 0 and n%i !=0) and (n%m != 0) and (m%n != 0):
        return [1, n*m]
    elif (m%j == 0 and n%i !=0) and (n%m != 0) and (m%n != 0):
        return [1, n*m]
    elif (m%j!= 0 and n%i ==0) and (n%m != 0) and (m%n != 0):
        return [1, n*m]
        # 안풀림. 때에 따라 다르게 결과 도출

<최종 풀이>

def solution(n, m): 
    min_i = 0
    max_i = 0
    for i in range(min(n,m),0,-1): # 최대공약수 구하기
        if n%i == 0 and m%i == 0:
            min_i = i
            break

    for i in range(max(n,m), (n*m)+1): # 최소공배수 구하기
        if i%n == 0 and i%m == 0:
            max_i = i
            break

    return [min_i, max_i]

<다른 풀이>

방법 1.

def gcdlcm(a, b):
    c, d = max(a, b), min(a, b)
    t = 1
    while t > 0:
        t = c % d
        c, d = d, t
    answer = [c, int(a*b/c)]

    return answer

방법 2.

def solution(n, m):
    nlist = []
    mlist = []
    for i in range(1, n+1):
        if n%i == 0:
            nlist.append(i)
    for i in range(1, m+1):
        if m%i == 0:
            mlist.append(i)
    maxi=[]
    for i in nlist:
        if i in mlist:
            maxi.append(i)
    maximum = max(maxi)

    minimum = int(maximum * (n/maximum) * (m/maximum))

    answer = [maximum, minimum]
    return answer

<개념>

방법 1: Euclidean algorithm 도입

출처 : https://j1w2k3.tistory.com/1173

<문제>

행렬의 덧셈은 행과 열의 크기가 같은 두 행렬의 같은 행, 같은 열의 값을 서로 더한 결과가 됩니다. 2개의 행렬 arr1과 arr2를 입력받아, 행렬 덧셈의 결과를 반환하는 함수, solution을 완성해주세요.

< 풀이 >

import numpy as np # 넘파이 활용 간단 
def solution(A,B):
    A=np.array(A)
    B=np.array(B) 
    answer=A+B 
    return answer.tolist()

<다른 풀이>

방법 1.

def sumMatrix(A,B):
    answer = []

    for a, b in zip(A, B):
        l = []
        for x, y in zip(a, b):
            l.append(x + y)
        answer.append(l)

    return answer

방법 2.

def sumMatrix(A,B):
    answer = [[c + d for c, d in zip(a, b)] for a, b in zip(A,B)]
    return answer

<느낀점>

행렬 연산은 넘파이가 가장 간편하다.