728x90
반응형

문제:

풀이방법:

규칙 중 4를 구현하는 것이 핵심인 문제다.

 solution함수는 1,4,7 입력이 들어온다면 왼쪽 엄지손가락을 사용하고, 해당 번호로 left를 이동시키고, 3,6,9가 들어온다면 오른쪽 엄지손가락을 사용하고 right를 이동시킨다. 이제 2,5,8,0이 들어오는 경우 leftDistance와 rightDistance를 사용해서 거리를 계산한다. 더 작은 쪽의 엄지손가락으로 이동을 하고, 만약 같다면 hand의 우선순위에 따라 움직이도록 한다.

 leftDistance는 입력을 해야하는 숫자가 2,5,8,0일 때, 왼쪽 엄지손가락과 거리를 계산하는 함수다.

만약 이전 왼쪽 엄지 손가락이 2,5,8이고 입력해야 할 숫자가 0이라면 각 케이스마다 거리를 return 하게 만들고, 나머지는 두 수의 차를 3으로 나눈 몫을 반환하도록 한다. 왼쪽 엄지 손가락이 1,4,7에 있다면 이를 가운데 키패드로 옮겨주고 leftDistance로 재귀적으로 거리를 계산하도록 만든다. 이제 나머지 케이스인 0에 있거나, 초기 상태인 *에 있던 경우에 대해서만 거리를 계산해주면 된다.

 rightDistance로 leftDistance와 비슷하게 계산을 하도록 한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
def leftDistance(num,left):
    if left in [2,5,8]:
        if num == 0:
            if left ==2:
                return 3
            elif left == 5:
                return 2
            else:
                return 1
        return abs(left-num)//3
    elif left in [1,4,7]:
        return leftDistance(num,left+1)+1
    else:
        if left == -1:
            if num == 2:
                return 4
            elif num == 5:
                return 3
            elif num == 8:
                return 2
            else:
                return 1
        if num == 0:
            return 0
        elif num == 8:
            return 1
        elif num == 5:
            return 2
        else:
            return 3
        
def rightDistance(num,right):
    if right in [2,5,8]:
        if num == 0:
            if right ==2:
                return 3
            elif right == 5:
                return 2
            else:
                return 1
        return abs(right-num)//3
    elif right in [3,6,9]:
        return rightDistance(num,right-1)+1
    else:
        if right == -1:
            if num == 2:
                return 4
            elif num == 5:
                return 3
            elif num == 8:
                return 2
            else:
                return 1
        if num == 0:
            return 0
        elif num == 8:
            return 1
        elif num == 5:
            return 2
        else:
            return 3
def solution(numbers,hand):
    answer = ""
    left, right = -1-1
    for num in numbers:
        if num in [1,4,7]:
            left = num
            answer += "L"
        elif num in [3,6,9]:
            right = num
            answer += "R"
        else:
            center_l = leftDistance(num,left)
            center_r = rightDistance(num,right)
            distance = center_l-center_r
            if distance > 0:
                right = num
                answer += "R"
            elif distance < 0:
                left = num
                answer += "L"
            else:
                if hand =="right":
                    right = num
                    answer+= "R"
                else:
                    left = num
                    answer += "L"
    return answer
cs

문제링크:

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

 

코딩테스트 연습 - 키패드 누르기

[1, 3, 4, 5, 8, 2, 1, 4, 5, 9, 5] "right" "LRLLLRLLRRL" [7, 0, 8, 2, 8, 3, 1, 5, 7, 6, 2] "left" "LRLLRRLLLRR" [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] "right" "LLRLLRLLRL"

programmers.co.kr

 

728x90
반응형

'Algorithm > Python' 카테고리의 다른 글

[BOJ]2164. 카드2  (0) 2020.07.14
[Programmers]2020 카카오 인턴십. 수식 최대화  (0) 2020.07.09
[BOJ]1543. 문서 검색  (0) 2020.07.02
[BOJ]5525. IOIOI  (0) 2020.06.30
[BOJ]11652. 카드  (0) 2020.06.25
728x90
반응형

문제:

세준이는 영어로만 이루어진 어떤 문서를 검색하는 함수를 만들려고 한다. 이 함수는 어떤 단어가 총 몇 번 등장하는지 세려고 한다. 그러나, 세준이의 함수는 중복되어 세는 것은 빼고 세야 한다. 예를 들어, 문서가 abababa이고, 그리고 찾으려는 ababa라면, 세준이의 이 함수는 이 단어를 0번부터 찾을 수 있고, 2번부터도 찾을 수 있다. 그러나 동시에 설 수는 없다.

 

세준이는 문서와 검색하려는 단어가 주어졌을 때, 그 단어가 최대 몇 번 중복되지 않게 등장하는지 구하는 프로그램을 작성하시오.

입력:

첫째 줄에 문서가 주어진다. 문서의 길이는 최대 2500이다. 둘째 줄에 검색하고 싶은 단어가 주어진다. 이 길이는 최대 50이다. 문서와 단어는 알파벳 소문자와 공백으로 이루어져 있다.

출력:

첫째 줄에 중복되지 않게 최대 몇 번 등장하는지 출력한다.

풀이방법:

브루트 포스 방법으로 문서에서 함수를 찾는 방법을 사용했다. 이 때 함수를 찾았다면 함수의 길이만큼 인덱스를 이동시키고, 그렇지 않으면 1을 증가시켰다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
A=input()
B=input()
 
answer = 0
idx = 0
while idx <len(A):
    correct=True
    if A[idx]==B[0]:
        for j in range(1,len(B)):
            if idx+< len(A):
                if B[j]!=A[idx+j]:
                    correct=False
                    break
            else:
                correct = False
                break
    else:
        correct= False
    if correct:
        answer+=1
        idx+=len(B)
    else:
        idx+=1
            
print(answer)
cs

문제링크:

https://www.acmicpc.net/problem/1543

 

1543번: 문서 검색

세준이는 영어로만 이루어진 어떤 문서를 검색하는 함수를 만들려고 한다. 이 함수는 어떤 단어가 총 몇 번 등장하는지 세려고 한다. 그러나, 세준이의 함수는 중복되어 세는 것은 빼고 세야 한�

www.acmicpc.net

 

728x90
반응형

'Algorithm > Python' 카테고리의 다른 글

[Programmers]2020 카카오 인턴십. 수식 최대화  (0) 2020.07.09
[Programmers]2020 카카오 인턴십. 키패드 누르기  (0) 2020.07.07
[BOJ]5525. IOIOI  (0) 2020.06.30
[BOJ]11652. 카드  (0) 2020.06.25
[BOJ]5052. 전화번호 목록  (0) 2020.06.23
728x90
반응형

문제:

N+1개의 I와 N개의 O로 이루어져 있으면, I와 O이 교대로 나오는 문자열을 Pn 이라고 한다.

 

P1 IOI

P2 IOIOI

P3 IOIOIOI

Pn IOIOI...OI (O가 N개)

 

I과 O로만 이루어진 문자열 S와 정수 N이 주어졌을 때, S안에 Pn이 몇 군데 포함되어 있는지 구하는 프로그램을 작성하시오.

입력:

첫째 줄에 N이 주어진다. 둘째 줄에는 S의 길이 M이 주어지며, 셋째 줄에 S가 주어진다. (1<=N<=1,000,000 , 2N+1 <= M <= 1,000,000)

출력:

S에 Pn이 몇 군데 포함되어 있는지 출력한다.

풀이방법:

Pn은 I와 O가 교대로 나오는 문자열이다. 따라서 index로 비교해서 IOI 패턴을 만족하는지 확인하고 이렇게 연속된 횟수를 세고 N과 일치할 경우 answer를 1 증가시킨다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
= int(input())
= int(input())
= input()
 
answer = 0
pattern = 0
= 1
while i < M-1:    
    if S[i-1]=='I' and S[i]=='O' and S[i+1]=='I':
        pattern +=1
        if pattern == N:
            pattern -=1
            answer +=1
        i+=1
    else:
        pattern = 0
    i+=1
print(answer)
cs

문제링크:

https://www.acmicpc.net/problem/5525

 

5525번: IOIOI

문제 N+1개의 I와 N개의 O로 이루어져 있으면, I와 O이 교대로 나오는 문자열을 PN이라고 한다. P1 IOI P2 IOIOI P3 IOIOIOI PN IOIOI...OI (O가 N개) I와 O로만 이루어진 문자열 S와 정수 N이 주어졌을 때, S안에 PN

www.acmicpc.net

 

728x90
반응형

'Algorithm > Python' 카테고리의 다른 글

[Programmers]2020 카카오 인턴십. 키패드 누르기  (0) 2020.07.07
[BOJ]1543. 문서 검색  (0) 2020.07.02
[BOJ]11652. 카드  (0) 2020.06.25
[BOJ]5052. 전화번호 목록  (0) 2020.06.23
[BOJ]12865. 평범한 배낭  (0) 2020.06.18
728x90
반응형

문제:

준규는 숫자 카드 N장을 가지고 있다. 숫자 카드에는 정수가 하나 적혀있는데, 적혀있는 수는 -2^62보다 크거나 같고, 2^62보다 작거나 같다.

 

준규가 가지고 있는 카드가 주어졌을 때, 가장 많이 가지고 있는 정수를 구하는 프로그램을 작성하시오. 만약, 가장 많이 가지고 있는 정수가 여러 가지라면, 작은 것을 출력한다.

입력:

첫째 줄에 준규가 가지고 있는 숫자 카드의 개수 N (1<=N<=100,000)이 주어진다. 둘째 줄부터 N개 줄에는 숫자 카드에 적혀있는 정수가 주어진다.

출력:

첫째 줄에 준규가 가장 많이 가지고 있는 정수를 출력한다.

풀이방법:

 숫자를 입력받으면서 HashTabel을 만들고, 이를 item 리스트로 만들면서 조건에 맞게 정렬을 하면 된다.

1
2
3
4
5
6
7
8
9
10
= int(input())
hashTable={}
for _ in range(N):
    h = int(input())
    if h in hashTable:
        hashTable[h] += 1
    else:
        hashTable[h] = 1
hashList = sorted(list(hashTable.items()),key=lambda x : (-x[1],x[0]))
print(hashList[0][0])
cs

문제링크:

https://www.acmicpc.net/problem/11652

 

11652번: 카드

준규는 숫자 카드 N장을 가지고 있다. 숫자 카드에는 정수가 하나 적혀있는데, 적혀있는 수는 -262보다 크거나 같고, 262보다 작거나 같다. 준규가 가지고 있는 카드가 주어졌을 때, 가장 많이 가지

www.acmicpc.net

 

728x90
반응형

'Algorithm > Python' 카테고리의 다른 글

[BOJ]1543. 문서 검색  (0) 2020.07.02
[BOJ]5525. IOIOI  (0) 2020.06.30
[BOJ]5052. 전화번호 목록  (0) 2020.06.23
[BOJ]12865. 평범한 배낭  (0) 2020.06.18
[BOJ]10830. 행렬 제곱  (0) 2020.06.16
728x90
반응형

문제:

전화번호 목록이 주어진다. 이때, 이 목록이 일관성이 있는지 없는지를 구하는 프로그램을 작성하시오.

전화번호 목록이 일관성을 유지하려면, 한 번호가 다른 번호의 접두어인 경우가 없어야 한다.

예를 들어, 전화번호 목록이 아래와 같은 경우를 생각해보자.

- 긴급전화 : 911

- 상근 : 97 625 999

- 선영 : 91 12 54 26

이 경우에 선영이에게 전화를 걸 수 있는 방법이 없다. 전화기를 들고 선영이 번호의 처음 세 자리를 누르는 순간 바로 긴급전화가 걸리기 때문이다. 따라서, 이 목록은 일관성이 없는 목록이다.

입력:

첫째 줄에 테스트 케이스의 개수 t가 주어진다. (1<=t<=50) 각 테스트 케이스의 첫째 줄에는 전화번호의 수 n이 주어진다. (1<=n<=10000) 다음 n개의 줄에는 목록에 포함되어 있는 전화번호가 하나씩 주어진다. 전화 번호의 길이는 길어야 10자리이며, 목록에 있는 두 전화번호가 같은 경우는 없다.

출력:

각 테스트 케이스에 대해서, 일관성 있는 목록인 경우에는 YES, 아닌 경우에는 NO를 출력한다.

풀이방법:

 이전에 프로그래머스에서 이 문제를 풀었었지만, 그 때에는 단순히 반복문을 사용해서 풀었다면 이번에는 문자열에서 비교하는 자료구조인 Trie를 사용하도록 한다.

 정보를 담을 Node 클래스와 이 Node들로 이루어진 Trie 클래스를 사용한다. Node의 key에는 알파벳, char 하나의 값이 들어가고, terminate는 이 Node가 마지막인지, 즉 string의 마지막인지를 나타내는 boolean 값이다. children은 더 이동할 수 있는 곳을 나타낸다.

 함수로는 insert와 search 두 개가 있다. insert로 전화번호를 넣어주고 search로 일관성을 파악하도록 한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
class Node(object):
    def __init__(self,key,flag=False):
        self.key = key
        self.terminate = flag
        self.children = {}
        
class Trie(object):
    def __init__(self):
       self.root = Node(None)
    
    def insert(self,string):
        currNode = self.root
        
        for char in string:
            if char not in currNode.children:
                currNode.children[char] = Node(char)
            
            currNode.terminate = False
            currNode = currNode.children[char]
        
        currNode.terminate = True
        
    def search(self,string):
        currNode = self.root
        
        for char in string:
            if char in currNode.children:
                currNode = currNode.children[char]
            else:
                return False
        if currNode.terminate:
            return True
        else:
            return False
    
    
t=int(input())
for _ in range(t):
    numberList = []
    n=int(input())
    for _ in range(n):
        numberList.append(input())
    numberList.sort()
    Tree = Trie()
    for number in numberList:
        Tree.insert(number)
    
    endFlag=True
    for number in numberList:
        if not Tree.search(number):
            print("NO")
            endFlag=False
            break
    if endFlag:
        print("YES")        
cs

문제링크:

https://www.acmicpc.net/problem/5052

 

5052번: 전화번호 목록

문제 전화번호 목록이 주어진다. 이때, 이 목록이 일관성이 있는지 없는지를 구하는 프로그램을 작성하시오. 전화번호 목록이 일관성을 유지하려면, 한 번호가 다른 번호의 접두어인 경우가 없�

www.acmicpc.net

 

728x90
반응형

'Algorithm > Python' 카테고리의 다른 글

[BOJ]5525. IOIOI  (0) 2020.06.30
[BOJ]11652. 카드  (0) 2020.06.25
[BOJ]12865. 평범한 배낭  (0) 2020.06.18
[BOJ]10830. 행렬 제곱  (0) 2020.06.16
[BOJ]1837. 암호제작  (0) 2020.06.11
728x90
반응형

문제:

이 문제는 아주 평범한 배낭에 관한 문제이다.

한 달 후면 국가의 부름을 받게 되는 준서는 여행을 가려고 한다. 세상과의 단절을 슬퍼하며 최대한 즐기기 위한 여행이기 때문에, 가지고 다닐 배낭 또한 최대한 가치 있게 싸려고 한다.

준서가 여행에 필요하다고 생각하는 N개의 물건이 있다. 각 물건은 무게 W와 가치 V를 가지는데, 해당 물건을 배낭에 넣어서 가면 준서가 V만큼 즐길 수 있다. 아직 행군을 해본 적이 없는 준서는 최대 K무게까지의 배낭만 들고 다닐 수 있다. 준서가 최대한 즐거운 여행을 하기 위해 배낭에 넣을 수 있는 물건들의 가치의 최댓값을 알려주자.

입력:

첫 줄에 물품의 수 N(1<=N<=100)과 준서가 버틸 수 있는 무게 K(1<=K<=100,000)가 주어진다. 두 번째 줄부터 N개의 줄에 거쳐 각 물건의 무게 W(1<=W<=100,000)와 해당 물건의 가치 V(0<=V<=1,000)가 주어진다.

 

입력으로 주어진느 모든 수는 정수이다.

출력:

한 줄에 배낭에 넣을 수 있는 물건들의 가치합의 최댓값을 출력한다.

풀이방법:

knapsack의 가장 기본적인 문제다. dp를 사용해서 간단하게 풀었다.

1
2
3
4
5
6
7
8
9
10
11
12
N,K = map(int,input().split())
dp =[[0]*(K+1for _ in range(N+1)]
items =[(0,0)]
for _ in range(N):
    items.append(tuple(map(int,input().split())))
 
for i in range(N+1):
    for j in range(K+1):
        dp[i][j] = dp[i-1][j]
        if (j-items[i][0]>=0):
            dp[i][j] = max(dp[i][j],dp[i-1][j-items[i][0]]+items[i][1])
print(dp[N][K])
cs

문제링크:

https://www.acmicpc.net/problem/12865

 

12865번: 평범한 배낭

첫 줄에 물품의 수 N(1 ≤ N ≤ 100)과 준서가 버틸 수 있는 무게 K(1 ≤ K ≤ 100,000)가 주어진다. 두 번째 줄부터 N개의 줄에 거쳐 각 물건의 무게 W(1 ≤ W ≤ 100,000)와 해당 물건의 가치 V(0 ≤ V ≤ 1,000)

www.acmicpc.net

 

728x90
반응형

'Algorithm > Python' 카테고리의 다른 글

[BOJ]11652. 카드  (0) 2020.06.25
[BOJ]5052. 전화번호 목록  (0) 2020.06.23
[BOJ]10830. 행렬 제곱  (0) 2020.06.16
[BOJ]1837. 암호제작  (0) 2020.06.11
[BOJ]9506. 약수들의 합  (0) 2020.06.09
728x90
반응형

문제:

크기가 N*N인 행렬 A가 주어진다. 이때, A의 B제곱을 구하는 프로그램을 작성하시오. 수가 매우 커질 수 있으니, A^B의 각 원소를 1,000으로 나눈 나머지를 출력한다.

입력:

첫째 줄에 행렬의 크기 N과 B가 주어진다. (2<=N<=5, 1<=B<=100,000,000,000)

둘째 줄부터 N개의 줄에 행렬의 각 원소가 주어진다. 행렬의 각 원소는 1,000보다 작거나 같은 자연수 또는 0이다.

출력:

첫째 줄부터 N개의 줄에 걸쳐 행렬 A를 B제곱한 결과를 출력한다.

풀이방법:

B의 최대 크기가 100,000,000,000인 만큼 효율적인 계산 방법이 필요한 문제다. 따라서 다음과 같은 규칙에 의해서 계산을 한다.

 

A^N일 때,

if N이 짝수라면, (A^2)^(N/2)로 수정한다.

if N이 홀수라면, (A^(N-1))*A로 수정하고, A는 answer에 곱한다.

N이 1이 될 때까지 위를 반복하고, 1이면 그 때의 A를 answer에 곱한다.

 

위와 같이 계산을 한다면 지수가 log2단위로 줄어들기 때문에 최대 100,000,000,000번 연산이 최대 36번으로 줄어들게 될 것이다. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
n,b = map(int,input().split())
 
def matmul(A,B):
    result = [[0]*len(A) for _ in range(len(B))]
    for i in range(len(A)):
        for j in range(len(B)):
            for k in range(len(A[0])):
                result[i][j] += A[i][k]*B[k][j]
                result[i][j] %= 1000
    return result
            
matrix = []
for _ in range(n):
    matrix.append(list(map(int,input().split())))
    
answer = [[1 if i==else 0 for i in range(n)] for j in range(n)]
 
while b !=1:
    temp = matrix[:]
    if b%2:
        answer = matmul(answer,temp)
        b-=1
    else:
        matrix = matmul(temp,temp)
        b//=2
 
answer = matmul(answer,matrix)
for ans in answer:
    print(*ans)
cs

문제링크:

https://www.acmicpc.net/problem/10830

728x90
반응형

'Algorithm > Python' 카테고리의 다른 글

[BOJ]5052. 전화번호 목록  (0) 2020.06.23
[BOJ]12865. 평범한 배낭  (0) 2020.06.18
[BOJ]1837. 암호제작  (0) 2020.06.11
[BOJ]9506. 약수들의 합  (0) 2020.06.09
[Programmers]2018 Kakao[1차]추석 트래픽  (0) 2020.05.26
728x90
반응형

문제:

원룡이는 한 컴퓨터 보안 회사에서 일을 하고 있다. 그러던 도중, 원룡이는 YESWOA.COM 으로부터 홈페이지 유저들의 비밀키를 만들라는 지시를 받았다. 원룡이는 비밀 키를 다음과 같은 방법으로 만들었다.

 

개인마다 어떤 특정한 소수 p와 q를 주어 두 소수의 곱 pq를 비밀 키로 두었다. 이렇게 해 두면 두 소수 p,q를 알지 못하는 이상, 비밀 키를 알 수 없다는 장점을 가지고 있다.

 

하지만 원룡이는 한 가지 사실을 잊고 말았다. 최근 컴퓨터 기술이 발달함에 따라, 소수가 작은 경우에는 컴퓨터로 모든 경우의 수를 돌려보아 비밀 키를 쉽게 알 수 있다는 것이다.

 

원룡이는 주성조교님께 비밀 키를 제출하려던 바로 직전에 이 사실을 알아냈다. 그래서 두 소수 p,q 중 하나라도 K보다 작은 암호는 좋지 않은 암호로 간주하여 제출하지 않기로 하였다. 이것을 손으로 직접 구해보는 일은 매우 힘들 것이다. 당신은 원룡이를 도와 두 소수의 곱으로 이루어진 암호와 K가 주어져 있을 때, 그 암호가 좋은 암호인지 좋지 않은 암호인지 구하는 프로그램을 작성하어야 한다.

입력:

암호 P(4<=P<=10^100)와 K (2<=K<=10^6)이 주어진다.

출력:

만약에 그 암호가 좋은 암호이면 첫째 줄에 GOOD을 출력하고, 만약에 좋지 않은 암호이면 BAD와 소수 r을 공백으로 구분하여 출력하는데 r은 암호를 이루는 두 소수 중 작은 소수를 의미한다.

풀이방법:

 n보다 작은 소수를 찾아서 이를 P에다가 나눠본다. 이 때 나눠진다면 좋지 못한 암호이기 때문에 BAD와 그 수를 출력하면 된다. 이 때, K가 최대 10^6까지 가능하기 때문에 소수를 구하는 최적의 알고리즘이 필요할 것이라고 생각했고, 가장 효율적인 소수 알고리즘 중 하나인 에라토스테네스의 체를 사용했다.

 길이가 K이고 값들이 1인 배열을 만들었고, 에라토스테네스의 체를 사용해서 소수를 구했다. 에라토스테네스의 체를 간단히 설명하면 한 소수 n의 배수들은 이 소수 n로 다 나눠질 것이기 때문에 소수가 아니라는 것이다.

 따라서 해당하는 인덱스의 배열 값이 1이고, 소수라면 그 배수들의 배열값들을 다 0으로 만들어준다. 그리고 추후 탐색을 편하게 하기 위해서 인덱스를 answer 리스트에 담아둔다.

 이렇게 하면 answer에는 소수만 남게 되고, 이를 P에다가 나눠보면서 좋은 암호인지 판단한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import math
 
P,K = map(int,input().split())
 
def check(number):
    if number==1:
        return False
    for i in range(2,int(math.sqrt(number))+1):
        if number%i:
            pass
        else:
            return False
    return True
 
 
sosu = [1]*K
answer = []
for i in range(1,K):
    if sosu[i-1and check(i):
        for j in range(i+i,K+1,i):
            sosu[j-1]=0
        answer.append(i)
    else:
        sosu[i-1= 0
        
correct = True
for a in answer:
    if P%a==0:
        correct = False
        break
if correct:
    print("GOOD")
else:
    print("BAD {}".format(a))
cs

문제링크:

https://www.acmicpc.net/problem/1837

 

1837번: 암호제작

문제 원룡이는 한 컴퓨터 보안 회사에서 일을 하고 있다. 그러던 도중, 원룡이는 YESWOA.COM 으로부터 홈페이지 유저들의 비밀키를 만들라는 지시를 받았다. 원룡이는 비밀 키를 다음과 같은 방법��

www.acmicpc.net

 

728x90
반응형

'Algorithm > Python' 카테고리의 다른 글

[BOJ]12865. 평범한 배낭  (0) 2020.06.18
[BOJ]10830. 행렬 제곱  (0) 2020.06.16
[BOJ]9506. 약수들의 합  (0) 2020.06.09
[Programmers]2018 Kakao[1차]추석 트래픽  (0) 2020.05.26
[Programmers]2019 Kakao 불량 사용자  (0) 2020.05.21
728x90
반응형

문제:

어떤 숫자 n이 자신을 제외한 모든 약수들의 합과 같으면, 그 수를 완전수라고 한다.

예를 들어 6은 6 = 1 + 2 + 3 으로 완전수이다.

n이 완전수인지 아닌지 판단해주는 프로그램을 작성하라.

입력:

입력은 테스트 케이스마다 한 줄 간격으로 n이 주어진다. (2 < n < 100,000)

입력의 마지막엔 -1이 주어진다.

출력:

테스트케이스마다 한줄에 하나씩 출력해야 한다.

n이 완전수라면, n을 n이 아닌 약수들의 합으로 나타내어 출력한다. (예제 출력 참고).

이때, 약수들은 오름차순으로 나열해야 한다.

n이 완전수가 아니라면 n is NOT perfect. 를 출력한다.

풀이방법:

약수들을 찾는 것은 어렵지 않으나 출력 요건을 주의 깊게 맞춰야 하는 문제인 것 같다.

약수들을 찾는 것은 브루트포스 방법으로 2부터 다 나눠보면서 나머지가 없는 값을 찾으면 된다. 이 때, 조금이라도 시간을 줄이기 위해서 n까지 다 나눠보는 것이 아닌 n//2-1까지 나눠보도록 했다. 이렇게 약수들을 모두 찾은 다음에 중복을 제거한 다음에 정렬을 했다. (중복은 제곱수를 위해 제거, 9와 같은 경우 1,3,3과 같이 들어가 있을 것)

약수들의 합이 n과 같으면 완전수이므로 출력 조건에 맞춰서 출력을 하고, 다르면 n is NOT perfect.로 출력한다.

100,000미만의 완전수는 6, 28, 496, 8128만 있으니 확인 후 제출하면 된다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
while True:
    n=int(input())
    if n==-1:
        break
    factor=[1]
    for i in range(2,int(n//2)):
        if n%i==0 and i not in factor:
            factor.append(i)
            factor.append(n//i)
    factor=sorted(list(set(factor)))
    answer=""
    if sum(factor)==n:
        answer += "{} =".format(n)
        for i in range(len(factor)):
            answer += " {}".format(factor[i])
            if (i+1)!=len(factor):
                answer+=" +"
    else:
        answer = "{} is NOT perfect.".format(n)
    print(answer)
cs

문제링크:

https://www.acmicpc.net/problem/9506

 

9506번: 약수들의 합

문제 어떤 숫자 n이 자신을 제외한 모든 약수들의 합과 같으면, 그 수를 완전수라고 한다.  예를 들어 6은 6 = 1 + 2 + 3 으로 완전수이다. n이 완전수인지 아닌지 판단해주는 프로그램을 작성하라.

www.acmicpc.net

 

728x90
반응형

'Algorithm > Python' 카테고리의 다른 글

[BOJ]10830. 행렬 제곱  (0) 2020.06.16
[BOJ]1837. 암호제작  (0) 2020.06.11
[Programmers]2018 Kakao[1차]추석 트래픽  (0) 2020.05.26
[Programmers]2019 Kakao 불량 사용자  (0) 2020.05.21
[BOJ]2468. 안전 영역  (0) 2020.05.19
728x90
반응형

문제:

풀이방법:

문자열을 잘 parsing할 수 있는지와, 어느 시점에 최대가 되는지 알아야 하는 문제다.

 우선 문자열을 파싱하기 위해서 splitTime이라는 함수를 만들었고, 날짜, 시간, 처리시간은 공백으로 구분되어 있기 때문에 split해주고, 날짜는 항상 2016년 9월 15일로 고정되어 있기 때문에 사용하지 않는다. 시간은 다시한번 :로 구분되어 있기 때문에 split해주고 1초간 처리하는 요청의 최대 개수를 알아야 하기 때문에 시간을 1초 단위로 만들어준다. 처리시간은 초 단위로 나오고 항상 s로 끝나기 때문에 이를 제거한 다음에 float으로 만들어 준다. 그리고 처리시간은 시작시간과 끝시간을 포함하기 때문에 배열로 반환을 할 때 시작시간에 0.001만큼 더하도록 한다.

 보통 최대 개수인 부분은 시작시간이나 끝시간에서 발생하게 된다. 이 시간들을 기준으로 처리해야하는 데이터가 생성되거나 사라지기 때문이다. (배열의 모든 시간을 탐색해도 좋지만 시간이 오래 걸릴 것이다.) 각 트래픽별의 시작시간과 끝나는 시간을 기준으로 트래픽의 갯수를 세서 최대 갯수를 파악한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
def splitTime(line):
    strings = line.split()
    end = strings[1]
    duration = float(strings[2][:-1])
    times = end.split(":")
    time = int(times[0])*3600
    time += int(times[1])*60
    time += float(times[2])
    return [time-duration+0.001,time]
 
def check(times,traffic):
    count = 0
    for time in times:
        temp = 0
        start = time
        end = time +1
        for t in traffic:
            if t[1]>= start and t[0]<end:
                temp+=1
        count=max(count,temp)
    return count
    
 
def solution(lines):
    traffic=[]
    answer=[]
    for line in lines:
        traffic.append(splitTime(line))
    for t in traffic:
        answer.append(check(t,traffic))
    return max(answer)
cs

 

문제링크:

https://programmers.co.kr/learn/courses/30/lessons/17676?language=python3

 

코딩테스트 연습 - [1차] 추석 트래픽

입력: [ 2016-09-15 20:59:57.421 0.351s, 2016-09-15 20:59:58.233 1.181s, 2016-09-15 20:59:58.299 0.8s, 2016-09-15 20:59:58.688 1.041s, 2016-09-15 20:59:59.591 1.412s, 2016-09-15 21:00:00.464 1.466s, 2016-09-15 21:00:00.741 1.581s, 2016-09-15 21:00:00.748

programmers.co.kr

 

728x90
반응형

'Algorithm > Python' 카테고리의 다른 글

[BOJ]1837. 암호제작  (0) 2020.06.11
[BOJ]9506. 약수들의 합  (0) 2020.06.09
[Programmers]2019 Kakao 불량 사용자  (0) 2020.05.21
[BOJ]2468. 안전 영역  (0) 2020.05.19
[BOJ]2167. 2차원 배열의 합  (0) 2020.05.14

+ Recent posts