최소직사각형
def solution(sizes):
w = []
h = []
for i in range(len(sizes)):
if sizes[i][0] >= sizes[i][1]:
w.append(sizes[i][0])
h.append(sizes[i][1])
else:
h.append(sizes[i][0])
w.append(sizes[i][1])
return max(w) * max(h)def solution(sizes):
return max(max(x) for x in sizes) * max(min(x) for x in sizes)모의고사
def solution(answers):
answer = []
grade = [0]*3
first = [1,2,3,4,5]
second = [2, 1, 2, 3, 2, 4, 2, 5]
third = [3, 3, 1, 1, 2, 2, 4, 4, 5, 5]
for idx in range(0, len(answers)):
if answers[idx] == first[idx%5]:
grade[0] += 1
if answers[idx] == second[idx%8]:
grade[1] += 1
if answers[idx] == third[idx%10]:
grade[2] += 1
# "% ": 나누기 연산 후 몫이 아닌 나머지를 구함
max_grade = max(grade)
for idx in range(0, 3):
if grade[idx] == max_grade:
answer.append(idx+1)
return answer소수 찾기
from itertools import permutations
def sosu(n):
if n < 2:
return False
for i in range(2, n//2+1):
if n%i == 0:
return False
return True
def solution(numbers):
answer = 0
p = []
result = []
for i in range(1, len(numbers)+1):
p.extend(permutations(numbers, i))
result = [int(''.join(i)) for i in p]
for i in set(result):
if sosu(i):
answer+=1
return answerfrom itertools import permutations
def solution(numbers):
answer = []
nums = [n for n in numbers] # numbers를 하나씩 자른 것
per = []
for i in range(1, len(numbers)+1): # numbers의 각 숫자들을 순열로 모든 경우 만들기
per += list(permutations(nums, i)) # i개씩 순열조합
new_nums = [int(("").join(p)) for p in per] # 각 순열조합을 하나의 int형 숫자로 변환
for n in new_nums: # 모든 int형 숫자에 대해 소수인지 판별
if n < 2: # 2보다 작은 1,0의 경우 소수 아님
continue
check = True
for i in range(2,int(n**0.5) + 1): # n의 제곱근 보다 작은 숫자까지만 나눗셈
if n % i == 0: # 하나라도 나눠떨어진다면 소수 아님!
check = False
break
if check:
answer.append(n) # 소수일경우 answer 배열에 추가
return len(set(answer)) # set을 통해 중복 제거 후 반환import math
from itertools import permutations
def solution1(numbers):
answer = 0
nums = set()
for i in range(1,len(numbers)+1):
for j in list(permutations(numbers,i)):
nums.add(int(''.join(j)))
numsmax = max(nums)
arr = [True]*(numsmax+1)
arr[0] = False
arr[1] = False
# 소수 9,999,999 까지 찾기
for i in range(2, int(math.sqrt(numsmax)+1 )):
if arr[i]:
j = 2
while i*j <= numsmax:
arr[i*j] = False
j+=1
for i in nums:
if arr[i]:
answer += 1
return answer카펫
참고하기)
링크텍스트
def solution(brown, yellow):
answer = []
total = brown + yellow # a * b = total
for b in range(1,total+1):
if (total / b) % 1 == 0: # total / b = a
a = total / b
if a >= b: # a >= b
if 2*a + 2*b == brown + 4: # 2*a + 2*b = brown + 4
return [a,b]
return answer피로도
from itertools import permutations
def solution(k, dungeons):
dun_num = len(dungeons)
answer = 0
for permut in permutations(dungeons, dun_num):
hp = k
count = 0
for pm in permut:
if hp >= pm[0]:
hp -= pm[1]
count += 1
if count > answer:
answer = count
return answeranswer = 0
N = 0
visited = []
def dfs(k, cnt, dungeons):
global answer
if cnt > answer:
answer = cnt
for j in range(N):
if k >= dungeons[j][0] and not visited[j]:
visited[j] = 1
dfs(k - dungeons[j][1], cnt + 1, dungeons)
visited[j] = 0
def solution(k, dungeons):
global N, visited
N = len(dungeons)
visited = [0] * N
dfs(k, 0, dungeons)
return answeranswer = 0
def dfs(k, cnt, dungeons, visited):
global answer
if cnt > answer:
answer = cnt
for i in range(len(dungeons)):
if not visited[i] and k >= dungeons[i][0]:
visited[i] = True
dfs(k - dungeons[i][1], cnt + 1, dungeons, visited)
visited[i] = False
def solution(k, dungeons):
global answer
visited = [False] * len(dungeons)
dfs(k, 0, dungeons, visited)
return answer전력망을 둘로 나누기
from collections import deque
def bfs(start,visitied,graph):
queue = deque([start])
result = 1
visitied[start] = True
while queue:
now = queue.popleft()
for i in graph[now]:
if visitied[i] == False:
result += 1
queue.append(i)
visitied[i] = True
return result
def solution(n, wires):
answer = n
graph = [[] for _ in range(n+1)]
for v1,v2 in wires:
graph[v1].append(v2)
graph[v2].append(v1)
for start,not_visit in wires:
visitied = [False]*(n+1)
visitied[not_visit] = True
result = bfs(start,visitied,graph)
if abs(result - (n-result)) < answer:
answer = abs(result - (n-result))
return answerfrom collections import deque
def bfs(node, tree, visited, wire, cnt):
queue = deque()
queue.append([node, tree, visited, wire])
visited[node] = True
while queue:
node, tree, visited, wire = queue.popleft()
cnt += 1
for i in tree[node]:
if not ((node == wire[0] and i == wire[1]) or (node == wire[1] and i == wire[0])):
if not visited[i]:
visited[i] = True
queue.append([i, tree, visited, wire])
return cnt
def solution(n, wires):
answer = 1e9
tree = [[] for _ in range(n + 1)]
for wire in wires:
a, b = wire
tree[a].append(b)
tree[b].append(a)
for wire in wires:
visited = [False] * (n + 1)
temp = []
for i in range(1, n + 1):
if not visited[i]:
cnt = bfs(i, tree, visited, wire, 0)
temp.append(cnt)
answer = min(answer, abs(temp[0] - temp[1]))
return answer모음사전
from itertools import product
def solution(word):
words = []
for i in range(1, 6):
for c in product(['A', 'E', 'I', 'O', 'U'], repeat=i):
words.append(''.join(list(c)))
words.sort()
return words.index(word) + 1from itertools import product
def solution(word):
answer = []
li = ['A', 'E', 'I', 'O', 'U']
for i in range(1,6):
for per in product(li,repeat = i):
answer.append(''.join(per))
answer.sort()
return answer.index(word)+1product 라이브러리
데카르트 곱이라고도 하는 cartesian product를 표현할 때 사용하는 메소드이다(DB의 join, 관계 대수의 product를 생각하면 된다). 이 메소드의 특징은 두 개 이상의 리스트의 모든 조합을 구할 때 사용된다.
from itertools import product
_list = ["012", "abc", "!@#"]
pd = list(product(*_list))
# [('0', 'a', '!'), ('0', 'a', '@'), ('0', 'b', '!'), ('0', 'b', '@'), ('1', 'a', '!'), ('1', 'a', '@'), ('1', 'b', '!'), ('1', 'b', '@')]
This is a velog that freely records the process I learn.