[프로그래머스] 코딩테스트 입문 문제 풀이

 

def solution(n):
    answer = 0
    for _ in range(n):
        answer += 1
        while answer % 3 == 0 or '3' in str(answer):
            answer += 1
    return answer

[내 풀이]
- 최대 공약수 구하는 함수 math.gcd(a,b) 활용하지 못해서 추가 함수를 구현해야 했던 점이 아쉽다.

- 분자, 분모를 기약분수로 만들지 못해서 불필요한 처리가 생겼다. 

#약수 구하는 함수?
def soinsu(x):
    i = 2 
    res = []
    while i<=x:
        if x%i == 0:
            res.append(i)
            x/=i
        else:
            i+=1
    return res



def solution(a, b):
    bunmoSoinsu = soinsu(b)
    check = [x for x in bunmoSoinsu if x!=2 and x!=5]
    
    for x in check:
        if a%x != 0:
            return 2
        else:
            a//=x
    
    return 1

[참고 풀이]
- b //= gcd(a,b) 기약분수 만들기 (분모) 

- a //= gcd(a,b) 기약분수 만들기 (분자)

from math import gcd
def solution(a, b):
    b //= gcd(a,b)
    while b%2==0:
        b//=2
    while b%5==0:
        b//=5
    return 1 if b==1 else 2

[내 풀이]
- num 하나만으로 처리할 수 있었는데, res라는 추가 변수를 사용한 점 

def solution(n):
    i = 1
    num = 1 
    while i <= n:
        if '3' in str(num) or num%3==0:
            num += 1 
        else:
            res = num
            i += 1
            num += 1
    return res

- 최소한 이렇게 표현하는 게 나았다. 

def solution(n):
    i = 1
    num = 1
    while i < n:
        num += 1
        if '3' in str(num) or num%3==0:
            continue
        else:
            i += 1
    return num

[참고 풀이] ***
-  i =1 while i <= n 을 그냥 for n, while 조건 으로 표현할 수 있었다. 

- 특정 조건에서만 i가 증가할 것이라면, 그냥 for문 안에서 특정 회수만큼 돌고 그 조건이 만족하지 않을 때 그 for 문 안에서 while문이 계속 반복해서 돌도록 하는 것이 훨씬 깔끔해보이는구나.

def solution(n):
    answer = 0
    for _ in range(n):
        answer += 1
        while answer % 3 == 0 or '3' in str(answer):
            answer += 1
    return answer

 

 

[내 풀이]
- 꼭 정렬 기준을 x, -x 와 같이 할 필요가 없었는데 ... 

def solution(numlist, n):

    result = list(map(lambda x:x-n, numlist))
    result = sorted(result, key=lambda x:(abs(x), -x))
    result = list(map(lambda x:x+n, result))
    
    return result

[참고 풀이]
- 람다를 이용하면 현재 식의 값에 일률적으로 어떤 공식을 적용한 후에 그걸 기준으로 정렬할 수 있다. 

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

 

[내 풀이]
- 전에 deque.rotate() 함수 사용했던 풀이가 생각나서 적용해본 것

- rotate(1) rotate(2) 와 같이 몇 번 회전할 건지 정할 수도 있다. 

from collections import deque

def solution(A, B):
    A = deque(A)
    B = deque(B)
    cnt = 0
    for _ in range(len(A)):
        if A==B: 
            return cnt
        else:
            A.rotate()
            cnt += 1
    return -1

- cnt 는 어차피 1씩 증가하므로 for 문 앞에 빼 놓지 말고, 그냥 for의 변수로 사용하자. 

- 비슷한 종류의 선언은 그냥 한 줄에 선언하자. 

- A와 a는 다른 형식이므로 같은 A라는 변수 말고 a라는 새로운 변수에 할당하는 것이 더 깔끔하다. 

from collections import deque

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

[참고 풀이]
- 똑같은 걸 이어 붙여서 그 안에 공통값 있는 지 찾는 것. 이 idea도 예전에 본 적이 있었다. (원으로 생긴 것을 일자로 펴서 생각하려면 *2 해서 생각하면 된다)

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

 

[내 풀이]
- 다항식 표현할 때 실수 많이하는 것: 1x+3 과 같이 표현하지 않는다는 것. x+3 과 같이 표현해주어야 한다. 

- 불필요하게 리스트 컴프리헨션을 써서 더 복잡해진 것 같다. 한 번 for문 돌 때 a와 b 모두 다 처리할 수 있었는데.

def solution(polynomial):
    if len(polynomial) == 1:
        return polynomial
    
    lst = polynomial.split(' + ') 
    lst = ['1x' if x=='x' else x for x in lst]
    b = sum([int(x) for x in lst if x.isdigit() ])
    a = sum([int(x[:-1]) for x in lst if not x.isdigit()])
    
    #예외 처리 1x+3 -> x+3
    if a!=0 and b!=0:
        if a==1:
            return 'x + ' + str(b)
        return str(a)+'x + '+str(b)
    elif a!=0 and b==0:
        if a==1:
            return 'x'
        return str(a)+'x'
    elif a==0 and b!=0:
        return str(b)
    elif a==0 and b==0:
        return '0'

[참고 풀이]
- 리스트 컴프리헨션 없이 그냥 평범한 for문으로 a, b 계산 

def solution(polynomial):
    xnum = 0
    const = 0
    for c in polynomial.split(' + '):
        if c.isdigit():
            const+=int(c)
        else:
            xnum = xnum+1 if c=='x' else xnum+int(c[:-1])
    if xnum == 0:
        return str(const)
    elif xnum==1:
        return 'x + '+str(const) if const!=0 else 'x'
    else:
        return f'{xnum}x + {const}' if const!=0 else f'{xnum}x'

 

[수정한 내 풀이1]  

- 불필요한 리스트 컴프리헨션을 줄이고 한 번의 for문으로 a와 b 계산하기 

def solution(polynomial):
    a, b = 0, 0   
    for x in polynomial.split(' + '):
        if x.isdigit():
            b+=int(x)
        elif x=='x':
            a+=1
        else:
            a+=int(x[:-1])
            
    if a==0:
        return str(b)
    elif a==1:
        return 'x + '+str(b) if b!=0 else 'x'
    else:
        return str(a)+'x + '+str(b) if b!=0 else str(a)+'x'

 

[수정한 내 풀이2]

- 숫자일 때 숫자가 아닐 때 두가지로 구분하는 게 더 가독성 좋을 듯 하다 

- 형식에 맞춰 출력할 때 f'{변수이름}와 {변수이름}가 문제를 풀고 있다.' 과 같이 표현

def solution(polynomial):
    a, b = 0, 0   
    for x in polynomial.split(' + '):
        if x.isdigit():
            b+=int(x)
        else:
            a = a+1 if x=='x' else a+int(x[:-1]) #숫자일 때 숫자가 아닐 때 두가지로 구분하는 게 더 가독성 좋을 듯 하다 
            
    if a==0:
        return str(b)
    elif a==1:
        return 'x + '+str(b) if b!=0 else 'x'
    else:
        return f'{a}x + {b}' if b!=0 else f'{a}x' #형식에 맞춰 출력할 때 f'{변수이름}와 {변수이름}가 문제를 풀고 있다.' 과 같이 표현

 

[내 풀이]

- 빈도 수 기준으로 값을 묶어 표현하려고 했다. 그래서 딕셔너리를 {빈도:항목} 으로 구성한 후,

- max(빈도)의 항목 값을 반환하되 항목 값이 여러 개일 경우 -1을 반환 

# 한 번에 생각 안 남 

def solution(array):
    dic = dict() 
    
    for x in array:
        dic[array.count(x)] = list(set(dic.get(array.count(x), []) + [x]))
    
    return dic[max(dic.keys())][0] if len(dic[max(dic.keys())])==1 else -1

 

[참고 풀이]

- set을 이용해서 하나씩만 제거 후 마지막 남는 것이 뭔지 확인하고, 그것을 결과값으로 반환

def solution(array):
    while len(array) != 0:
        for i, a in enumerate(set(array)):
            array.remove(a)
        if i == 0: return a
    return -1