bright

import itertools

L, c = map(int,input().split()) # 암호 길이, 문자의 수 
data = list(map(str,input().split()))
data.sort()

# c 개 중에 L 개 뽑아 나열하기 
# 최소 모음 1개 최수 2개 자음 

vowel = [ 'a', 'e', 'i', 'o', 'u']

for i in itertools.combinations( data,L):

    cnt = 0 

    for k in i : 
        if k in vowel:
            cnt += 1 
    
    if cnt >= 1 and cnt <= L-2 : 
        print( ''.join( i ))

풀이 방법 : 조합 ( combination ) 사용  /  import itertools 

L 개 중, c 개의 문자를 뽑아 암호를 만든다. 문제에서 순서는 알파벳 순이라고 지정해 주었으므로 

순열 ( permutations ) 가 아닌 조합을 사용하면 된다. 

암호의 조건으로 모음이 최소 1개, 자음이 최소 2개이다. 

따라서, 우선 가능한 조합을 모두 나열한 다음,

모음을 세는 변수를 만들어 암호 안의 모음의 개수를 세고 이를 활용하여 자음의 개수 까지 센다. 

( 모음이 아닌 건 다 자음이므로 모음의 수가 ( 전체 암호 길이 ) - 2 이하라면 조건을 만족한다 ) 

import math

m, n = map(int,input().split()) # m ~ n 사이 소수 구하기 

prime = [ True for i in range(1000001)]
prime[1] = False # 1 은 소수가 아님 

for i in range(2, int(math.sqrt(n))+1):
  if prime[i] == True:
    j = 2
    while i*j <= n : 
      prime[i*j] = False
      j += 1 

for i in range(m,n+1):
  if prime[i] : 
    print( i)

약수는 대칭적인 구조로 이루어져 있으므로, n 의 제곱근 까지만 구하면 된다. 

ex ) 8 ( 제곱근 : 약 2.9 ) 

1*8 = 2*4 = 4*2 = 8*1 

에라토스테네스의 체 알고리즘을 이용하여 n 까지의 모든 소수를 구하고나서, 

m~ n 까지 출력하면 간단하게 구현 가능하다. 

- idea..

1. 내가 지금 있는 위치에서 1 로 표시된 곳을 찾아 이동해야 한다. 

2. BFS 

from collections import deque 

n,m = map(int,input().split())

graph=[]
for i in range(n):
  graph.append(list(map(int,input())))

dx = [-1,1,0,0]
dy = [0,0,-1,1]


def bfs(x,y):

  queue = deque()
  queue.append((x,y))

  while queue:
    x,y = queue.popleft()

    for i in range(4):
      nx = x+dx[i]
      ny = y+dy[i]

      if nx< 0 or nx>=n or ny<0 or ny>=m :
        continue 
      if graph[nx][ny] == 0 : 
        continue 
      if graph[nx][ny] == 1 :
        graph[nx][ny] = graph[x][y]+1 
        queue.append((nx,ny))

  return graph[n-1][m-1]


print(bfs(0,0))

- idea.. 

1. 나랑 붙어 있는 모든 0 찾기.

2. 찾기가 끝나면, 얼음 수 1개 늘리기? 

3. DFS 

n,m = map(int,input().split()) 

graph = []
for i in range(n):
  graph.append ( list(map(int,input())))

# 나랑 연결된 노드들을 모두 방문하는 dfs 함수 만들기 
def dfs(x, y):

  if x <0 or y < 0 or x >=n or y >=m :
    return False 
  
  if graph[x][y] == 0 :  # 아직 방문되지 않은 노드라면, 
    
    graph[x][y] = 1      # 방문처리 

    dfs(x-1,y)
    dfs(x+1,y)
    dfs(x,y-1)
    dfs(x,y+1)

    return True 
  return False 

cnt= 0 

for x in range(n):
  for y in range(m):
    if dfs(x,y) == True:  # 한 번 True를 뱉고, 함수 내부에서 연결된 모든 노드에 대한 처리가 끝난다. 
      cnt += 1 

print(cnt )

n = int(input())

data = [0]*1001

data[1] = 1
data[2] = 3 

for i in range(3,n+1):
  data[i] = (data[i-1]+ data[i-2]*2) % 796796

print(data[n])

# 어렵다..
# 익숙해지기 

# 인접한 곳은 공격 x 
# 최대로 약탈하기.. 

n = int(input()) # 식량창고의 개수 
k = list(map(int,input().split())) 

data = [0]*100  # 앞서 계산한 결과 저장 

d[0]=k[0]
d[1]= max(k[0],k[1])

for i in range(2,n):
  # 지금 내가 있는 곳을 털지, 
  # 전에 있는 것을 터는 것 중에 더 큰 것 선택.. 
  d[i] = max(d[i-1],d[i-2]+array[i])

print(d[n-1])

n = int(input())
data= [0]*3001

# 5, 3, 2 로 나누거나 1 빼기.. 
# 연산한 것이 무엇이 가장 작은지 판별
# +1 은 계산 횟수를 더해주기 위한 것. 
# bottom up 방식이므로.. i//k < i 를 만족해서 다음처럼 표현 가능.. 

for i in range(2,n+1):
  d[i] = d[i-1]+1

  if i %2 == 0:
    d[i] = min(d[i], d[i//2]+1)
  if i %3 == 0:
    d[i] = min(d[i], d[i//3]+1)
  if i %5 == 0:
    d[i] = min(d[i], d[i//5]+1)

print(d[n])

1. 재귀 함수   // 시간 복잡도 : O(2^n)

def fivo(x):
  if x == 1 or x == 2 :
    return 1
    
  return fivo(x-1)+ fivo(x-2)

2. Top-down 방식 , Memoization 기법 사용 ( Cashing )   // 시간 복잡도 : O(N) 

# 계산된 피보나치 결과를 저장하는 리스트 선언 
result = [0] * 100 

def fivo(x):
  if x == 1 or x == 2 :
    return 1 
  
  if result[x] != 0 :
    return result[x]

  d[x]= fivo(x-1)+fivo(x-2)
  return d[x]

3. Bottom-up 방식 

# 계산된 피보나치 결과를 저장하는 리스트 선언 
result = [0] * 100 

result[1]=result[2]=1
n = 99 

for i in range(3,n+1):
  d[i] = d[i-1]+d[i-2]

1. 순차 탐색 -> 시간오류 날 것.. 

n,m = map(int, input().split())
data = list(map(int, input().split()))

data = sorted(data,reverse=True)

l = data[0]
sum = 0 
while sum < m :
  sum = 0 
  for i in data:
    if l-i <= 0 : 
      pass
    else :
      sum += l-i 

print(sum)

2. 파라메트릭 서치 -> 이진탐색 

n,m = map(int, input().split())
data = list(map(int, input().split()))

start = 0 
end = max(data)

result = 0 
while start<= end:
  sum = 0 
  mid = (start + end) //2 

  for i in data:
    if i > mid :
      sum += (i-mid)
    
  if sum < m : 
    end = mid -1 
  else : 
    result = mid
    start = mid +1 

print (result)

n = int(input())  # 내가 가진 것 
ndata = list(map(int,input().split()))
m = int(input())  # 상대의 요청 
mdata = list(map(int,input().split()))

ndata.sort()

def bin_sort(arr,start,end,target):
  if start> end:
    return None 
  
  mid = (start + end) // 2 
  
  if target > arr[mid]:
    return bin_sort(arr,mid+1,end,target)
  elif target == arr[mid]:
    return True
  else : 
    return bin_sort(arr,start,mid-1,target)

for i in mdata:
  result = bin_sort(ndata,0,n-1,i)

  if result : 
    print('yes', end=' ')
  else : 
    print('no', end=' ')