코딩테스트 연습 6일차

Lv.1

최대공약수와 최소공배수

유클리드 호제법

def GCD(n,m):
    while(m): #m이 아직 숫자일 때
        n,m = m, n%m
    return n

def LCM(n,m):
    result = (n*m)//GCD(n,m)
    return result
        

def solution(n, m):
    answer = []
    answer.append(GCD(n,m))
    answer.append(LCM(n,m))
    return answer

재귀함수 사용

def gcd(a, b):
    return b if a % b == 0 else gcd(b, a % b)

def lcm(a, b):
    return int(a * b / gcd(a, b))


def gcdlcm(a, b):
    answer = [gcd(a,b), lcm(a,b)]

    return answer

lambda 사용

lambda 매개변수 : 표현식
참이면 여기 실행 if (조건) else 거짓이면 여기 실행

def solution(n, m):
    gcd = lambda a,b : b if not a%b else gcd(b, a%b)
    lcm = lambda a,b : a*b//gcd(a,b)
    return [gcd(n, m), lcm(n, m)]

같은 숫자는 싫어

내 코드

def solution(arr):
    answer = []
    answer.append(arr[0]) #빈건 안되니 무조건 넣고
    arr = arr[1:]
    idx = 0
    for item in arr:
        if answer[idx] == item:
            continue
        answer.append(item)
        idx += 1
        
    return answer

satck을 활용했다는데...
생각해보니 맞네, result[-1]가 stack의 제일 후미가 된다. (가장 최근에 넣은 값)
그래서 stack(list)이 비었거나 제일 최근 값이 s에서 나오는 값과 다르면 착착 쌓는다!

def no_continuous(s):
    result = []
    for c in s:
        if (len(result) == 0) or (result[-1] != c):
            result.append(c)
    return result

밑에꺼 이해하니 정말 좋군....

def no_continuous(s):
    a = []
    for i in s:
        if a[-1:] == [i]: continue
        a.append(i)
    return a

3진법 뒤집기

아 3진법은 또 뭐야 ㅡㅡ
저는 2,8,10,16만 배웠다구요.
어쨌든 원리는 같을테니까. + 거꾸로 뒤집어야 하니까!
나머지를 이용해서 풀어보자.

def solution(n):
    answer = ''
    
    while n > 0:
        n, re = divmod(n,3)	# n을 3으로 나눈 몫과 나머지
        answer += str(re) # 나머지를 거꾸로 착착 쌓는다.
        
    return int(answer, 3) 
    # 3진법을 10진법으로...이걸 맨날 까먹어서 고생했다.

divmod 안 쓰기
코테에서 제공함수를 쓰는게 좋은지 안 쓰고 구현하는게 좋은지 잘 모르겠다.

def solution(n):
    answer = ''
    while n:
        answer += str(n % 3)
        n = n // 3

    answer = int(answer, 3)
    return answer

이상한 문자 만들기

틀린 코드
무슨 테스트 케이스에 걸렸는지 모르겠다....

def solution(s):
    data = s.split(" ") #공백 기준 쪼개기
    answer = ''
    
    for item in data:
        for i in range(0,len(item),2):
            answer += item[i].upper()
            if i+1 < len(item):
                answer += item[i+1].lower()          
        answer += " "

    return answer.strip()

양쪽에 공백이 있는 케이스도 있을 수 있다고...
아...이럴수가....
이건 일단은 통과한다. 공백을 나중에 join하네.

def solution(s):
    answer = []
    word=s.split(" ")
    for i in word:
        part=[]
        for j in range(0,len(i)):
            if j%2==0:
                part.append(i[j].upper())
            else:
                part.append(i[j].lower())
        part="".join(part)
        answer.append(part)

    answer=" ".join(answer)

    return answer

미쳤네 람다 써서 이걸 한줄에?
그리고 enumerate 써도 되는구나...

def toWeirdCase(s):
    return " ".join(map(lambda x: "".join([a.lower() if i % 2 else a.upper() for i, a in enumerate(x)]), s.split(" ")))

예산

틀린 코드

def solution(d, budget):
    cnt = 0
    tmp = 0
    if sum(d) > budget:
        for i in d:
            tmp += i
            if tmp >= budget:
                answer = cnt
                break
            cnt += 1
    else:
        answer = len(d)
    
    return answer

덧셈말고 뺄셈으로 가자.
그리고 총 예산을 최대한 다수에게 쓰려면 신청금액이 작은 것부터 빼는 것이 유리하다. 1,2,3이 쓰든 1,2,5가 쓰든 예산안에만 들어오면 ok
남아도 된다.

def solution(d, budget):
    d.sort() # 오름차순(작은 순)
    
    cnt = 0
    for pay in d:
        budget -= pay
        if budget < 0:
            break 
        cnt += 1
        
    return cnt