say repository

https://programmers.co.kr/learn/courses/30/lessons/68935

출처 : 프로그래머스

def solution(n):
    answer = 0
    tmp = []
    
    while True:
        tmp.append(n % 3)
        n //= 3
        if n == 0:
            break       
            
    idx = 0  
    for t in tmp[::-1]:
        if t == 0:
            idx += 1
            continue
        answer += t*(3**idx)
        idx += 1
        
    return answer

풀이

3으로 나눈 나머지로 3진법을 구하는 방법으로 구했다.

하지만 다른 사람 풀이를 보고 놀랐다..ㅋ ㅋ ...

def solution(n):
    tmp = ''
    
    while True:
        tmp += str(n % 3)
        n //= 3
        if n == 0:
            break
            
    answer = int(tmp,3)
    return answer

풀이

int('문자열', 진법)

솔직히 int가 이런 옵션이 있는줄 몰랐다.

앞으로 진법문제 나올 때 유용하게 쓰자.

https://programmers.co.kr/learn/courses/30/lessons/77884

출처 : 프로그래머스

def solution(left, right):
    answer = 0
    for i in range(left,right+1):
        cnt = 0 # 약수 개수 카운트
        for j in range(1,i+1):
            if i % j == 0: # 약수면
                cnt += 1
        if cnt % 2 == 0: # 약수 개수가 짝수면 더하고
            answer += i
        else: # 약수 개수가 홀수면 빼기
            answer -= i
    return answer

풀이

left부터 right까지 하나씩 약수의 개수를 구한다.

약수의 개수가 짝수면 answer 에 더해주고

약수의 개수가 홀수면 answer 에서 빼준다.

import sys
n = int(sys.stdin.readline())
cnt = 0
for i in range(n):
    s = sys.stdin.readline().rstrip()
    new_word = [s[0]]
    err = 0
    for a in range(len(s)-1):
        if s[a] != s[a+1]:
            if s[a+1] in new_word:
                err += 1
            new_word.append(s[a+1])

    if err == 0:
        cnt += 1
print(cnt)

풀이

입력받은 문자열을 한 글자씩 비교하면서 다른 글자가 나오면 new_word에 넣는다.

이때, new_word에 있는 글자라면 그룹 단어가 되지 않으니 체크한다.

출처 : 백준

# 10972
import sys
n = int(sys.stdin.readline())
arr = list(map(int,sys.stdin.readline().split()))
x = 0
for i in range(n-1, 0, -1):
    if arr[i] > arr[i-1]:
        x = i-1
        break
for i in range(n-1, 0, -1):
    if arr[x] < arr[i]:
        arr[x], arr[i] = arr[i], arr[x]
        arr = arr[:x+1] + sorted(arr[x+1:])
        print(*arr)
        exit()
print(-1)

풀이

 next_permutation

1. 순열의 뒤 부터 비교하며 뒷 값이 앞 값 보다 큰 인덱스 구해서 x에 앞 값 인덱스 넣기
2. 이 x 값과 다시 순열의 뒤부터 비교해서 arr[x] 보다 큰 값 구하고 swap 진행하기
3. x 다음 값이 큰 값이었다.
4. 이 값 기준으로 앞은 그대로, 뒤는 sorted 해서 포인트로 접근 print()
5. exit() 종료

# 1476

import sys
e, s, m = map(int,sys.stdin.readline().split())
cnt = 1
starte, starts, startm = 1,1,1
while True:
    if starte == e and starts == s and startm == m:
        break
    starte += 1
    starts += 1
    startm += 1
    cnt += 1
    if starte > 15:
        starte = 1
    if starts > 28:
        starts = 1
    if startm > 19:
        startm = 1

print(cnt)

풀이

1 1 1 을 1년 지날 때마다 모두 +1 해주며 e, s, m 값과 같아질 때까지 cnt+=1 해준다.

+1 해줄 때, e,s,m 의 범위 넘으면 다시 1로 초기화해준다.

# 3085

import sys
n = int(sys.stdin.readline())
arr = [list(sys.stdin.readline().strip()) for _ in range(n)]
answer = 0

# 완전 탐색
def check(array):
    max_len = 1 # 함수의 리턴 값 -> 가장 긴 최대 길이
    for i in range(n):
        # 열 비교
        cnt = 1 # 같은 색인 최대 길이
        for j in range(1,n):
            if arr[i][j] == arr[i][j-1]:
                cnt += 1
            else: # 인접한 사탕 중 다른 색 나오면 cnt 초기화
                cnt = 1
            max_len = max(max_len, cnt) # max_len 갱신
        
        # 행 비교
        cnt = 1  # 같은 색인 최대 길이
        for j in range(1,n):
            if arr[j][i] == arr[j-1][i]:
                cnt += 1
            else:
                cnt = 1
            max_len = max(max_len, cnt)  # max_len 갱신
    return max_len

# 인접하고 색 다른 두 칸 고르고 완탐 호출
for i in range(n):
    for j in range(n):
        if j+1<n: # 인접한 열 끼리 비교 후 교체
            if arr[i][j] != arr[i][j+1]:
                arr[i][j],arr[i][j+1] = arr[i][j+1], arr[i][j]
                # 완전탐색 수행
                tmp = check(arr)
                # 정답과 완탐 CNT 비교
                answer = max(answer,tmp)
                # 교체 한 것 다시 원래대로 돌려놓기 ( 모든 경우의수 비교해야함)
                arr[i][j], arr[i][j + 1] = arr[i][j + 1], arr[i][j]

        if i+1<n: # 인접한 행 끼리 비교 후 교체
            if arr[i][j] != arr[i+1][j]:
                arr[i][j], arr[i + 1][j] = arr[i + 1][j],arr[i][j]
                # 완전탐색 수행
                tmp = check(arr)
                # 정답과 완탐 CNT 비교
                answer = max(answer, tmp)
                # 교체 한 것 다시 원래대로 돌려놓기 ( 모든 경우의수 비교해야함)
                arr[i][j], arr[i + 1][j] = arr[i + 1][j], arr[i][j]
print(answer)

풀이

보드의 크기 N이 주어진다. (3 ≤ N ≤ 50) -> 완전 탐색 가능하다.

1. 색이 다른 인접한 두 사탕 선택 후 교체

2. 교체한 배열에서 같은 사탕 색이 있는 (행 또는 열) 최대 길이 구하기

3. 교체한 사탕 다시 제자리로 위치시키고 다음 인접한 사탕 교체 후 완전탐색 반복

계속 교체할 사탕 2개 선택해서 자리 바꾸고 완탐으로 최대 길이 구하고 리턴 시켜서

answer 값을 max 값으로 갱신시킨다.

이 문제 괜찮은 것 같다.

나중에 다시 풀어보자.

# 11724
import sys
sys.setrecursionlimit(10000)
n,m = map(int,sys.stdin.readline().split())
graph = [[] for _ in range(n+1)]
visited = [0]*(n+1)
cnt = 0
for _ in range(m):
    u,v = map(int,sys.stdin.readline().split())
    graph[u].append(v)
    graph[v].append(u)
# print(graph)

def dfs(node):
    visited[node] = 1
    for i in graph[node]:
        if not visited[i]:
            dfs(i)

for i in range(1,n+1):
    if not visited[i]:
        dfs(i)
        cnt += 1
print(cnt)

풀이 2 (BFS)

# 11724
import sys
# sys.setrecursionlimit(10000)
from collections import deque
n,m = map(int,sys.stdin.readline().split())
graph = [[] for _ in range(n+1)]
visited = [0]*(n+1)
cnt = 0
for _ in range(m):
    u,v = map(int,sys.stdin.readline().split())
    graph[u].append(v)
    graph[v].append(u)
# print(graph)

def bfs(graph, node, visited):
    visited[node] = 1
    q = deque([node])
    while q:
        v = q.popleft()
        for i in graph[v]:
            if not visited[i]:
                q.append(i)
                visited[i] = 1

for i in range(1,n+1):
    if not visited[i]:
        bfs(graph, i, visited)
        cnt += 1
print(cnt)