프로그래머스 LV0

다음에 올 숫자

def solution(common):
    answer = 0
    
    a, b, c = common[:3]
    # 등차 수열
    if b - a == c - b:
        answer = common[-1] + (b - a)
    else:
        answer = common[-1] * (b // a)
    return answer

연속된 수의 합

def solution(num, total):
    answer = []
    
    first = (total - sum(range(num))) // num
        
    answer = [first + i for i in range(num)]
        
    return answer

문자열 밀기

def solution(A, B):
    answer = 0
    if A == B:
        return answer
    
    for i in range(len(A) - 1):
        answer += 1
        A = A[-1] + A[:-1]
        if A == B:
            return answer 
    
    return -1

from collections import deque

def solution(A, B):
    answer = 0
    
    a, b = deque(A), deque(B)
    for answer in range(0, len(A)):
        if a == b:
            return answer
        a.rotate(1)
    
    return -1

문자열 정렬하기 (2)

sorted(정렬할 데이터, key 파라미터, reverse 파라미터)

첫 번째 매개변수로 들어온 이터러블한 데이터를 새로운 정렬된 리스트로 만들어서 반환해 준다.

def solution(my_string):

    return "".join(sorted(my_string.lower()))

A로 B만들기

def solution(before, after):
    return 1 if sorted(before) == sorted(after) else 0

세균 증식

def solution(n, t):
    answer = n * 2 ** t
    return answer

비트 연산자

def solution(n, t):
    return n << t

문자열안에 문자열

str.count()

def solution(str1, str2):
    return 1 if str1.count(str2) else 2

7의 개수

def solution(array):
    
    return "".join(map(str, array)).count("7")

한 번만 등장한 문자

str.count()

def solution(s):
    return "".join(sorted([letter for letter in s if s.count(letter) == 1]))

k의 개수

def solution(i, j, k):
    input = ''.join([str(i) for i in range(i, j+1)])
    return input.count(str(k))

람다 표현식

def solution(i, j, k):
    return sum(map(lambda x: str(x).count(str(k)), range(i, j+1)))    

특이한 정렬

람다 표현식

def solution(numlist, n):
    return sorted(numlist, key = lambda x : (abs(x-n), -x))

자릿수 더하기

def solution(n):
    return sum(list(map(int, str(n))))

n의 배수 고르기

def solution(n, numlist):
    
    answer = [num for num in numlist if num % n == 0]
    return answer

람다 표현식

def solution(n, numlist):
    
    answer = list(filter(lambda x: x % n == 0, numlist))
    return answer

숫자 찾기

str.find()

def solution(num, k):
    index = str(num).find(str(k))
    return -1 if index == -1 else index + 1

배열의 유사도

집합

def solution(s1, s2):
    answer = 0
    for e in s1:
        answer += 1 if e in s2 else 0
    
    return answer

def solution(s1, s2):
    return len(set(s1) & set(s2))

가장 큰 수 찾기

list.index()

def solution(array):
    mx = max(array)
    return [mx, array.index(mx)]

❗️등수 매기기

def solution(score):
    answer = []
    
    avgList = [sum(i)/len(i) for i in score]
    sort_score = sorted(avgList, reverse = True)
    # print(sort_score)
    # print(avgList)
    
    for avg in avgList:
        answer.append(sort_score.index(avg)+1)
    
    return answer

프로그래머스 코드

def solution(score):
    sortList = sorted([sum(i) for i in score], reverse = True)
    return [sortList.index(sum(i)) + 1 for i in score]

문자열 계산하기

eval()

문자열 수식이 들어오면 해당 수식 결과 반환

def solution(my_string):
    return eval(my_string)

인덱스 바꾸기

def solution(my_string, num1, num2):

    s = list(my_string)
    s[num1], s[num2] = s[num2], s[num1]
    return "".join(s)
    

영어가 싫어요

str.replace()

def solution(numbers):
    return  int(numbers.replace('zero', '0').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'))

enumerate()

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(my_string):
    return my_string.swapcase()

로그인 성공?

프로그래머스 풀이

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"