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

 

1543번: 문서 검색

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

www.acmicpc.net

# 내가 짠코드

word = str(input())
data = str(input())

# word = "aaaaaaa"
# data = "aa"
# word = "ababababa"
# data = "aba"

rew ,reda = word.replace(" ", ""), data.replace(" ", "")

rn = len(reda)
num, count = 0, 0

for i in range(len(rew)):

    if i == num:
        temp = rew[i:i+rn]
        # print(rew,temp, reda, i)
        if reda == temp:
            count +=1
            num += rn
        else:
            num += 1
print(count)
# 프로그래머스 코드
# word = str(input())
# data = str(input())

word = "aaaaaaa"
data = "aa"
# word = "ababababa"
# data = "aba"

# rew ,reda = word.replace(" ", ""), data.replace(" ", "")

# rn = len(reda)
index, count = 0, 0

while len(word) - index >= len(data):
    temp = word[index:index+len(data)]
    # print(rew,temp, reda, i)
    if temp == data:
        count +=1
        index += len(data)
    else:
        index += 1
print(count)
  • "n.replace(" ", "")매개변수 공백을 제거하고 싶을 때 사용

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

 

1568번: 새

N마리의 새가 나무에 앉아있고, 자연수를 배우기 원한다. 새들은 1부터 모든 자연수를 오름차순으로 노래한다. 어떤 숫자 K를 노래할 때, K마리의 새가 나무에서 하늘을 향해 날아간다. 만약, 현

www.acmicpc.net

 

# 나는 바보인듯
n = int(input())

count, result = 1, 0
while n > 0:
    if count > n:
        count = 1
    n -= count # 남아있는 수 
    count += 1 # 불러야 하는 수
    result +=1
    print(result)

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

 

1302번: 베스트셀러

첫째 줄에 오늘 하루 동안 팔린 책의 개수 N이 주어진다. 이 값은 1,000보다 작거나 같은 자연수이다. 둘째부터 N개의 줄에 책의 제목이 입력으로 들어온다. 책의 제목의 길이는 50보다 작거나 같고

www.acmicpc.net

# 정답

# import sys
# input = sys.stdin.readline
dic = {}

for i in range(int(input())):
    data = str(input())
    if data in dic.keys():
        dic[data] +=1
    else:
        dic[data] = 1


# dic = {'a': 2, 'c': 3, 'b': 3, 'd': 1}
rdic = sorted(dic.items(), key=lambda x:(x[0]))
for i, j in rdic:
    if max(dic.values()) == j:
        print(i)
        break
# print(max(dic.values()), rdic)
# 해설코드

# import sys
# input = sys.stdin.readline
# dic = {}

# for i in range(int(input())):
#     data = str(input())
#     if data in dic.keys():
#         dic[data] +=1
#     else:
#         dic[data] = 1


dic = {'a': 2, 'c': 3, 'b': 3, 'd': 1}
array = []
# rdic = sorted(dic.items(), key=lambda x:(x[0]))
for i, j in rdic:
    if max(dic.values()) == j:
        array.append(i)
        
print(sorted(array))
# print(max(dic.values()), rdic)
  • 내 코드는 str 기준으로 미리 정렬해서 반복문을 돌렸고
  • 해설 기준은 바로 집어 넣은뒤 마지막에 str 정렬해서 사용함.

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

 

1668번: 트로피 진열

민식이는 “오민식”이라는 팀이름으로 수없이 많은 로봇대회를 우승했다. 따라서 민식이의 집에는 트로피가 많다. 민식이는 트로피를 어떤 선반 위에 올려놨다. 이 선반은 민식이의 방문을 열

www.acmicpc.net

# 내 작성코드
temp = []
for i in range(int(input())):
    temp.append(int(input()))
  
array = [temp[0]]
for i in range(len(temp)):
    if i != 0:      
        if array[-1] < temp[i] :
            array.append(temp[i])
print(len(array))            

temp.reverse()
array = [temp[0]]
for i in range(len(temp)):
    if i != 0:      
        if array[-1] < temp[i] :
            array.append(temp[i])
print(len(array))
# 해설코드
def check(array):
    now = array[0]
    result = 1
    for i in range(1, len(array)):
        if now < array[i]:
            result +=1
            now = array[i]
    return result
    
n = int(input())
array = []

for i in range(n):
    array.append(int(input()))
    
print(check(array))
array.reverse()
print(check(array))
  • 비교 방식은 비슷하지만 나는 결과 값으로 리스트의 전체 길이를 반환함 또한 리스트에 배열 첫번쨰를 넣고 시작함
  • 해설 방식이 시간은 같지만 코드 가독성이 좋음
    • 내 코드였을때는 리스트에 먼저 집어넣고 이후 두번째부터 비교했다면 해설 코드는
      • 이전 첫번째 값"now = array[0]"으로 값을 잡고 두번째로 for 문을 한단계 앞에서 시작하여 비교함
      • 만약 "now"보다 뒤에값이 클경우 "now = array[i]"로 다시 재설정한뒤 "result +=1" 해줌 
  • 추가로 reversed(), a.reverse() 말고 쓰기 좋은 방법은 "a[::-1]"도 있다.   

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

 

1236번: 성 지키기

첫째 줄에 성의 세로 크기 N과 가로 크기 M이 주어진다. N과 M은 50보다 작거나 같은 자연수이다. 둘째 줄부터 N개의 줄에는 성의 상태가 주어진다. 성의 상태는 .은 빈칸, X는 경비원이 있는 칸이다

www.acmicpc.net

# 작성한 정답코드 핵심은 16 line
def minimum(x):
    answer = 0
    for i in x:
        if "X" not in i:
            answer += 1
    return answer

array = []

n, m = map(int, input().split())
for i in range(n):
    data = list(input())
    array.append(data)

newarray = list(map(list, zip(*array))) # 행과 렬 뒤집기
a = max(minimum(array),minimum(newarray))
print(a)
  • 나는 완전 탐색이라기 보단 배열 내 "x"가 있는지만 찾았음.
    • 행 전체를 기준으로 찾는것은 문제없었지만 위 문제의 핵심은 열로 다시 찾아서 서로 max 값을 도출하는 것임
    • 위 문제의 핵심은 행과 열을 서로 바꿔주기 위해선 zip 함수를 사용해야함.
    • ex) "new_array = list(map(list, zip(*array)))" <---- 위 zip 라이브러리가 행과 열을 변경해주는 것임
n, m = map(int, input().split())
array = []
for _ in range(n):
    array.append(input())


row = [0] * n
column = [0] * m

for i in range(n):
    for j in range(m):
        if array[i][j] == "X":
            row[i] = 1
            column[j] = 1
row_count = 0
for i in range(n):
    if row[i] == 0:
        row_count +=1
        
column_count = 0
for j in range(m):
    if column[j] == 0:
        column_count += 1
print(max(row_count,column_count))
  • 처음 2차원 리스트를 돌면서 X를 찾음. 이 때 라인 한쪽 끝으로 민다고 가정하여 row[i], column[j] 쪽으로 1로 처리함
  • row 돌아서 1이 안들어 간곳은 경비원이 필요한 곳이므로 +1씩함 column또한 마찬가지

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

 

2346번: 풍선 터뜨리기

1번부터 N번까지 N개의 풍선이 원형으로 놓여 있고. i번 풍선의 오른쪽에는 i+1번 풍선이 있고, 왼쪽에는 i-1번 풍선이 있다. 단, 1번 풍선의 왼쪽에 N번 풍선이 있고, N번 풍선의 오른쪽에 1번 풍선

www.acmicpc.net

  • 자료구조,덱
# 정답은 맞는데 틀림;

# import sys
from collections import deque
# input =sys.stdin.readline()

n = int(input())
data = list(map(int, input().split()))
# n = 5
# data = [3, 2, 1, -3, -1]
d = deque(data)

result = []

for i in range(n):
    # print(x)
    x = d.popleft()
    result.append(data.index(x)+1)
    
    if x > 0:
        for j in range(x-1):            
            d.rotate(1)           
    elif x < 0:
        for t in range(abs(x)):
            d.rotate(-1)

print(str(result)[1:-1])
# import sys
from collections import deque
# input =sys.stdin.readline()

# n = int(input())
# arr = list(map(int, input().split()))
n = 5
arr= [3, 2, 1, -3, -1]

d = deque()
for i in range(n):
    # (수, 번호) 형태로 원소를 삽입
    d.append((arr[i], i+1))

result = [] # 결과배열

current, index, = d.popleft() # 원소 추출
result.append(index)

for i in range(n-1): #원소를 모두 꺼내기
    if current > 0:
        # current -1번 왼쪽으로 회전
        for j in range(current -1):
            # d.rotate(1)
            x = d.popleft()
            d.append(x)
    else: # 음수라면
        # \current\번 오른쪽 회전
        for j in range(-current):
            # d.rotate(-1)
            x = d.pop()
            d.appendleft(x)
    # 원소 추출
    current, index = d.popleft()
    result.append(index)

for tt in result:
    print(tt, end=" ")
  • 값과, 인덱스를 튜플로 묶어서 비교 시작.
  • 핵심은 양수일 때 "x-1" 값만큼 우측회전 음수일 때 절댓값"\x\" 값만큼 좌측 회전
  • 처음 반복문 전에 처음값을 뽑고 시작하여 안에서 반복문이 끝나면 다시 원소(값과 인덱스)를 추출해서 비교반복을 함
  • 또한 튜플형태로 인덱스와 값을 함께 사용하기 때문에 리스트 추가 시 장점이 많음
  • "print(tt, end=" ")" 기억하자

 

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

 

17298번: 오큰수

첫째 줄에 수열 A의 크기 N (1 ≤ N ≤ 1,000,000)이 주어진다. 둘째 줄에 수열 A의 원소 A1, A2, ..., AN (1 ≤ Ai ≤ 1,000,000)이 주어진다.

www.acmicpc.net

  • 자료구조, 스택
import sys
input = sys.stdin.readline

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

result = []

for i in range(n): # 9548
    lstack, rstack = [], []

    for j in range(i+1, n): #548
        if data[i] < data[j]:
            lstack.append(data[j])
        elif data[i] > data[j]:
            rstack.append(data[i])
    if len(lstack) != 0:
        result.append(lstack[0])
    if len(rstack) != 0:
        if max(rstack) == max(data):
            result.append(-1)
        
result.append(-1)        
print(result)

 

  • 정답은 야매로 했지만,  시간초과로 실패 함. 
n = int(input())
arr = list(map(int, input().split()))
stack = [] # 스택 초기화
NGE = [-1] * n

for i in range(n):
    x = arr[i]
    if len(stack) == 0 or stack[-1][0] >= x:
        stack.append((x, i)) # (수, 인덱스) 형태로 삽입
    else:
        while len(stack) > 0: # 역방향으로 하나씩 추출
            previous, index = stack.pop()
            if previous >= x: # 크기나 같은 이전 원소를 만났다면 다시 삽입
                stack.append((previous, index))
                break
            else:
                NGE[index] = x # 오큰수 기록
        stack.append((x, i)) # (수, 인덱스) 형태로 삽입
for x in NGE:
    print(x, end =' ')
  • 이 문제는 다시 풀어봐야할듯
n = 11
data = [3,2,1,10,9,5,4,8,15,11,13]
LB = [-1] * n

stack = []
for i in range(n):
    x = data[i]
    if len(stack)==0 or stack[-1][0] >= x: # 최상단 원소가 새로운 값보다 같거나 클 때 스택 삽입 
        stack.append((x,i))
    else:
        while len(stack) > 0:
            value, idx = stack.pop()
            if value >= x:
                stack.append((value, idx))
                break
            else:
                LB[idx] = x
        stack.append((x, i))
        
for i in LB:
    print(i, end=' ')

 

  • for i in LB:
        print(i, end=' ')
    • " print(i, end=' ')"를 통해 한줄에 한번에 출력
  • 스택으로 문제를 접근함.
  • "data = [3,2,1,10,9,5,4,8,15,11,13]" 아래 값이 입력으로 들어 왔다고 가정했을 때 새로운 큰 수가 나오기 전까지는 전부다 "stack"에 어팬드 해줌, 이후 큰 수를 만났을 때 추가되었던 스택 을 뒤에서 부터 하나씩 꺼내며 확인을 함
    • "value, idx = stack.pop()" 확인을 시작하는데
      • 현재 꺼낸 값이 최상단으로 들어온 "x" 보다 크다면 다시 꺼낸 값을 그대로 돌려놓고 반복문 종료 
        •  if value >= x: stack.append((value, idx))
                      break
      • 그렇지 않으면 다시 오큰수로 최상단 값을 기존 추가하였던 스택의 개별 인덱스로 저장함 LB[idx] = x
    • 이후 새로 들어온 x 값을 스택에 새로 추가함

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

 

1021번: 회전하는 큐

첫째 줄에 큐의 크기 N과 뽑아내려고 하는 수의 개수 M이 주어진다. N은 50보다 작거나 같은 자연수이고, M은 N보다 작거나 같은 자연수이다. 둘째 줄에는 지민이가 뽑아내려고 하는 수의 위치가

www.acmicpc.net

  • 자료구조, 덱
# import sys
# input = sys.stdin.readline

from collections import deque

n, m = map(int, input().split()) # 원소 개수, 뽑아내는 횟수
data = list(map(int, input().split())) # 뽑아낼 원소 목록

d = deque([i for i in range(1, n+1)]) #덱

cnt = 0
for i in data:
    index = d.index(i)
    if index <= len(d) // 2:
        for i in range(index):
            d.rotate(-1)
            cnt +=1
    else:
        for i in range(len(d) - index):
            d.rotate(1)
            cnt +=1
    d.popleft()
                
print(cnt)
  1. 문제의 핵심은 입력 받는 값 ex) 2, 9, 5 등 값들이 n까지의 원소들중 중간 앞에 위치하면 왼쪽 회전, 중간 뒤에 위치하면 우측 회전이다.
  2. 원소 개수 "n"까지 데크를 만들어 둠. 이후 각각의 개별 데이터들"i"을 입력으로 받아옴
  3. 현재 개별 데이터들이 생성해둔 데크 안에 어디에 위치하는지 알기 위해 인덱스로 위치를 개별 매칭함 "index = d.index(i)"
  4. 앞서 1번에서 말한 것 처럼 중간 앞에 위치하면 "if index <= len(d)//2:" 
    1. 현재 "index" 값만큼 좌측회전 "d.rotate(-1)" 후 카운트
  5. 위와 같이 만약 왼쪽에 위치한다면 "if index > len(d)//2" or "else"
    1. 현재 전체 데크의 길이 "lend(d) - index" 에서 인덱스를 뺀 횟수만큼 우측회전 " d.rotate(1) "
  6. 끝으로 회전이 끝난 뒤 각 개별데이터들은 리스트 맨앞에 위치하므로 뽑기"d.popleft()"

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

 

11866번: 요세푸스 문제 0

첫째 줄에 N과 K가 빈 칸을 사이에 두고 순서대로 주어진다. (1 ≤ K ≤ N ≤ 1,000)

www.acmicpc.net

from collections import deque
# n, m = 7,3
n, m = map(int, input().split())
d = deque([i for i in range(1, n+1)])
result = []

while len(d) > 0:
    d.rotate(-(m-1))
    result.append(d[0])
    d.popleft()

temp = str(result)[1:-1]
print(f"<{temp}>")
  • 처음부터 좌측[0]을 기준으로 입력 받은 k-2 씩 좌측으로 회전해주면 끝인문제

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

 

10828번: 스택

첫째 줄에 주어지는 명령의 수 N (1 ≤ N ≤ 10,000)이 주어진다. 둘째 줄부터 N개의 줄에는 명령이 하나씩 주어진다. 주어지는 정수는 1보다 크거나 같고, 100,000보다 작거나 같다. 문제에 나와있지

www.acmicpc.net

  • 자료구조, 스택, 시뮬레이션
import sys

input = sys.stdin.readline
n = int(input())
stack = []
for i in range(n):
    data = list(input().split())
    if data[0] == "empty":
        if len(stack) == 0: print(1)      
        else: print(0)
    elif data[0] == "push":
        stack.append(data[-1])
    elif data[0] == "pop":
        if len(stack) == 0: print(-1)
        else:print(stack.pop())  
    elif data[0] == "size":
        print(len(stack))
    elif data[0] == "top":
        if len(stack) == 0:print(-1)
        else:print(stack[-1])
  • 일반적으로 입력을 넣으시면 "시간초과" 발생함.
  • 또한 데이터가 비었을 때는 이전까지는 그냥 "if stack"이라고 표현하였지만, 그냥 "if len(stack) == 0"으로 표현해야함.

 

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

 

10773번: 제로

첫 번째 줄에 정수 K가 주어진다. (1 ≤ K ≤ 100,000) 이후 K개의 줄에 정수가 1개씩 주어진다. 정수는 0에서 1,000,000 사이의 값을 가지며, 정수가 "0" 일 경우에는 가장 최근에 쓴 수를 지우고, 아닐 경

www.acmicpc.net

  • 자료구조, 스택, 시뮬레이션
import sys

result = []
for _ in range(int(input())):
    # print(f"result: {result}")
    k = int(input())
    if k == 0:
        if len(result) != 0: result.pop()
    elif k != 0:
        result.append(k)
print(sum(result))

import sys
input = sys.stdin.readline
result = []
for _ in range(int(input())):
    # print(f"result: {result}")
    k = int(input())
    if k == 0:
        if len(result) != 0: result.pop()
    elif k != 0:
        result.append(k)
print(sum(result))

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

 

1874번: 스택 수열

1부터 n까지에 수에 대해 차례로 [push, push, push, push, pop, pop, push, push, pop, push, push, pop, pop, pop, pop, pop] 연산을 수행하면 수열 [4, 3, 6, 8, 7, 5, 2, 1]을 얻을 수 있다.

www.acmicpc.net

  • 자료구조, 스택, 시뮬레이션.
stack, result = [], []
count = 0

for _ in range(int(input())):
    n = int(input())
    while count < n:
        count += 1
        stack.append(count)
        result.append("+")
    if stack[-1] == n:
        stack.pop()
        result.append("-")
    else:
        print("NO")
        exit(0)

print("\n".join(result))
  • 다시 풀면서 헷갈렸던걸 정리하자면, "while"안에서 계속 조건문을 사용하려고 했던 문제점 1
  • "print("No")"라고 적어두고 "print("NO")" 차이점 때문에 시간 소비한점.
  •  "print("\n".join(result))" 반복문 궂이 사용할 필요가 없다는점.
n = int(input())
arr = list(map(int, input().split()))
stack = [] # 스택 초기화
NGE = [-1] * n

for i in range(n):
    x = arr[i]
    if len(stack) == 0 or stack[-1][0] >= x:
        stack.append((x, i)) # (수, 인덱스) 형태로 삽입
    else:
        while len(stack) > 0: # 역방향으로 하나씩 추출
            previous, index = stack.pop()
            if previous >= x: # 크기나 같은 이전 원소를 만났다면 다시 삽입
                stack.append((previous, index))
                break
            else:
                NGE[index] = x # 오큰수 기록
        stack.append((x, i)) # (수, 인덱스) 형태로 삽입
for x in NGE:
    print(x, end =' ')

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

 

10930번: SHA-256

첫째 줄에 문자열 S가 주어진다. S는 알파벳 대문자와 소문자, 그리고 숫자로만 이루어져 있으며, 길이는 최대 50이다.

www.acmicpc.net

 

import hashlib

# 암호화할 데이터
data = input()

# SHA-256 해시 객체 생성
hash_object = hashlib.sha256()

# 데이터 업데이트
hash_object.update(data.encode())

# 해시 값 추출
hash_value = hash_object.hexdigest()

# 결과 출력
print(hash_value)
import hashlib

# 암호화할 데이터
data = input()

encode_dtat = data.encode()
result = hashlib.sha256(encode_dtat).hexdigest()
print(result)

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

 

1920번: 수 찾기

첫째 줄에 자연수 N(1 ≤ N ≤ 100,000)이 주어진다. 다음 줄에는 N개의 정수 A[1], A[2], …, A[N]이 주어진다. 다음 줄에는 M(1 ≤ M ≤ 100,000)이 주어진다. 다음 줄에는 M개의 수들이 주어지는데, 이 수들

www.acmicpc.net

n = int(input())
narr = list(map(int, input().split()))
m = int(input())
marr = list(map(int, input().split()))
narr = set(narr)
for i in marr:
    if i in narr:
        print("1")
    else:
        print("0")
  • 처음 배열에서 받은 것 중에 두번째 개별 원소가 있는지만 확인하면 되기 때문에 첫번째 배열은 "set을" 사용.

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

 

4195번: 친구 네트워크

첫째 줄에 테스트 케이스의 개수가 주어진다. 각 테스트 케이스의 첫째 줄에는 친구 관계의 수 F가 주어지며, 이 값은 100,000을 넘지 않는다. 다음 F개의 줄에는 친구 관계가 생긴 순서대로 주어진

www.acmicpc.net

  • 해시, 집합, 그래프 문제
더보기
  • 더 작은 원소를 부모로 삼도록 설정하고 1이 4를 가리켰을 때
  • 4가 1번 노드를 가리켜 있으므로 1, 2, 3, 1 값이 다른건 3개
  • 2가 4를 가리켰을 때 실제 4 값은 1을 가지고 있으므로 2도 1임(더 작은 원솔르 부모로 삼기 떄문에)
  •  따라서 총 두 개의 집합을 가짐
def find(x):
    if x == parent[x]:
        return x
    else:
        p = find(parent[x])
        parent[x] = p
        return parent[x]

def union(x, y):
    x = find(x)
    y = find(y)

    if x != y:
        parent[y] = x
        number[x] += number[y]
        
for _ in range(int(input())):
    parent = {}
    number = {}
    f = int(input())
    for _ in range(f):      
        x, y = list(map(str, input().split()))
        if x not in parent:
            parent[x] = x
            number[x] = 1
        if y not in parent:
            parent[y] = y
            number[y] = 1
        union(x, y)
        print(number[find(x)])
  • 해시, 그래프, 집합들의 문제인데 재귀함수도 있고, 나중에 다시한번 풀어봐야될 문제

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

 

1874번: 스택 수열

1부터 n까지에 수에 대해 차례로 [push, push, push, push, pop, pop, push, push, pop, push, push, pop, pop, pop, pop, pop] 연산을 수행하면 수열 [4, 3, 6, 8, 7, 5, 2, 1]을 얻을 수 있다.

www.acmicpc.net

  • 스택, 그리디
더보기

 

 

  1. 입력 4일 때 ++++ >>1234
  2. 4 읽기 -  >> 123
  3. 입력 3일 때 3 읽기 - >>12
  4. 입력 6일 때  34 는 없으므로 ++ >>1256
  5. 6읽기 - >> 125
  6. 입력 8일 때 ++ >>12578
  7. 8읽기 - >>1257
  8. 7읽기 - >> 125
  9. 5읽기 - >> 12
  10. 2읽기 - >>1
  11. 1읽기 - >> empty

출력 결과 = ++++--++-++-----

  • 한번에 두개씩 못 뺌
n = int(input())
count = 1
stack = []; result = []

for i in range(1, n+1): # 데이터 개수만큼 반복

    data = int(input())
    while count <= data: # 입력 받은 데이터에 도달할 때까지 삽입
        stack.append(count)
        count += 1
        result.append("+")
    if stack[-1] == data: # 스택의 최상위 원소가 데이터와 같을 때 출력
        stack.pop()
        result.append('-')
    else: # 불가능한 경우
        print("NO")
        exit(0)
print('\n'.join(result))

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

 

1966번: 프린터 큐

여러분도 알다시피 여러분의 프린터 기기는 여러분이 인쇄하고자 하는 문서를 인쇄 명령을 받은 ‘순서대로’, 즉 먼저 요청된 것을 먼저 인쇄한다. 여러 개의 문서가 쌓인다면 Queue 자료구조에

www.acmicpc.net

for _ in range(int((input()))):
    n, m = list(map(int, input().split()))
    arr = list(map(int, input().split()))
    queue = [(i, idx) for idx, i in enumerate(arr)]


# n, m  = 4, 2 
# arr = [1,2,3,4]

# n, m  = 6, 0 
# arr = [1,1,9,1,1,1]

# queue = [(i, idx) for idx, i in enumerate(arr)] # [(1, 0), (2, 1), (3, 2), (4, 3)] 인덱스 맵핑
# temp = max(queue, key=lambda x:x[0])[0] # (4, 3) -> 4
# print(queue, temp)
    count = 0
    while True:
        if queue[0][0] == max(queue, key=lambda x:x[0])[0]: # 제일 높은 중요도 값
            count += 1 
            if queue[0][1] == m:
                print(count)
                break
            else:
                queue.pop(0)
        else:
            queue.append(queue.pop(0))
  • 큐, 구현, 그리디
  • 문제의 핵심은 중요도가 높은 순서데로(ex)4, 3, 2, 1) 몇 바퀴를 돌렸을 때 그 값을 카운팅 함
    • 입력 받은 배열을 그대로 큐로 인덱스와 함꼐 튜플 형태로 맵핑시킴 "queue = [(i, idx) for idx, i in enumerate(arr)]" 
    • 맵핑된 결과 "[queue[0][0]]" 는 중요도, "queue[0][1]" 은 인덱스 맵핑 당시 책 위치임
    • 현재 배열" queue"에서 가장 높은 중요도를 찾음  "max(queue, key=lambda x:x[0])[0]" 
      • 조건문을 통해 위 값과 배열의 매 첫번 째 값과 비교하여 값이 일치할 때까지 회전을 시키며 "count +=1"
      • 일치 한다면 "if queue[0][1] == m" (처음 입력받은 m 값의 자리를 비교)
        • 현재까지 카운트된 값을 출력하고 반복문 종료
        • 일치 하지만 위치가 맞지 않다면, 그 값은 제거
      • 그렇지 않다면 회전을 시킴
        • 회전 방법"queue.append(queue.pop(0))"

 

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

 

5397번: 키로거

첫째 줄에 테스트 케이스의 개수가 주어진다. 각 테스트 케이스는 한줄로 이루어져 있고, 강산이가 입력한 순서대로 길이가 L인 문자열이 주어진다. (1 ≤ L ≤ 1,000,000) 강산이가 백스페이스를 입

www.acmicpc.net

 

더보기

단순히 구현만해서는 못품

 

  • 스택, 구현, 그리디
  • 2개의 스택을 통해 구현하는 문제
  • "<"  커서 왼쪽이동, ">" 커서 오른쪽 이동 "-" 앞에 문자열 있을경우 제거
  • 기억하기 좋은 라이브러리는 두 개 
    • "extend(reversed(right_stack))" 리스트간 합칠 때 사용. reversed도 사용 가능.
    • "        print(' '.join(left_stack))               " 리스트 내 쉼표 제거 시 사용.
test = int(input())

for _ in range(test):
    left_stack, right_stack = [], []
    data = input()
    for i in data:
        if i == "-":
            if left_stack:
                left_stack.pop()
        elif i == "<":
            if left_stack:
                right_stack.append(left_stack.pop())
        elif i == ">":
            if right_stack:
                left_stack.append(right_stack.pop())
        else:
            left_stack.append(i)
    left_stack.extend(reversed(right_stack)) # append()가 아닌 extend()를 통해 확장해서 뒤집어 넣어줌
    print("".join(left_stack)) #개별 리스트 쉼표 제거 후 출력

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

 

2920번: 음계

다장조는 c d e f g a b C, 총 8개 음으로 이루어져있다. 이 문제에서 8개 음은 다음과 같이 숫자로 바꾸어 표현한다. c는 1로, d는 2로, ..., C를 8로 바꾼다. 1부터 8까지 차례대로 연주한다면 ascending, 8

www.acmicpc.net

 

  • 배열, 구현 문제
arr = list(map(int, input().split()))
uparr = sorted(arr)
downarr = sorted(arr, reverse = True)

if arr == uparr:
    print("ascending")
elif arr == downarr:
    print("descending")
else:
    print("mixed")

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

 

2798번: 블랙잭

첫째 줄에 카드의 개수 N(3 ≤ N ≤ 100)과 M(10 ≤ M ≤ 300,000)이 주어진다. 둘째 줄에는 카드에 쓰여 있는 수가 주어지며, 이 값은 100,000을 넘지 않는 양의 정수이다. 합이 M을 넘지 않는 카드 3장

www.acmicpc.net

 

  • 배열, 완전탐색 -> 3중 포문 문제
  • 여기서 3중 반복문을 사용할 때  2번째 반복문의 인덱스를 +1씩 해줌 3번 째라면 +2
  • 즉 "for i in range(0, n)" -> "for j in range(i+1, n)" -> for t in range(j+1, n) 
n, m = map(int, input().split())
arr = list(map(int, input().split()))
# n, m = 10, 500
# arr = [93, 181, 245, 214, 315, 36, 185, 138, 216, 295]
arr.sort(reverse = True)
max_dif = 0
lenth = len(arr)

for i in range(0, lenth):
    for j in range(i+1, lenth):
        for t in range(j+1, lenth):
            sum = arr[i] + arr[j] + arr[t]
            if sum <= m:
                max_dif = max(max_dif, sum)
print(max_dif)

 

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

 

2170번: 선 긋기

첫째 줄에 선을 그은 횟수 N (1 ≤ N ≤ 1,000,000)이 주어진다. 다음 N개의 줄에는 선을 그을 때 선택한 두 점의 위치 x, y (-1,000,000,000 ≤ x < y ≤ 1,000,000,000)가 주어진다.

www.acmicpc.net

,

#pypy3

n = int(input())

arr = []

for _ in range(n):
    x, y = map(int, input().split())
    arr.append((x, y)) # SP, EP

# arr = [(1, 3), (2, 5), (3, 5), (6, 7)]
arr.sort()
result = 0
start, current = arr[0] # 1,3 -- 2, 5
 
for line in arr:
    x, y = line
    if current >= x:
        current = max(current, y)
    else:
        result += current - start
        start = x
        current = y
result += current - start

print(result)

 

# n = int(input())

# arr = []

# for _ in range(n):
#     x, y = map(int, input().split())
#     arr.append((x, y)) # SP, EP
# print(arr)

arr = [(1, 3), (2, 5), (3, 5), (6, 7)]
arr.sort()
result = 0
start, current = arr[0] # 첫번 째 선을 따라 현재 펜을 이동 # # 튜플을 이렇게 나눌 수 있음!!

for line in arr: # 하나씩 선들 확인
    x, y = line # 튜플을 이렇게 나눌 수 있음!!
    # print(x, y, current)
    if current >= x: # 현재 펜이 시작점보다 더 크다면
        current = max(current, y) # 최대한 펜을 쭉 긋기
    else: # 현재 펜이 시작점보다 작다면 (새로 그어야 한다면)
        result += current - start
        start = x # 펜을 이용해 새로 선을 긋기 시작한 점
        current = y # 현재 펜의 위치(끝점)
result += current - start

print(result)

 

  • 정렬과, 그리드 문제
  • 문제는 펜을 땟을 때의 길이를 찾는 것
    • 위 "for"문에서 각각의 x, y를 가져온 뒤 현재 선을 최대로 그은 "current"와 "x"값을 비교해서 "current" 값이 더 커질수록 한번에 그어진 최대선의 길이 값이 됨. <---"if" 문
    • 새로 그어진 값을 찾으면 "result"에다 현재까지의 길이("current" - "start")를 추가해주고 새로 "start", "current" 값들을 "x", "y"로 대입시켜줌. 
    • 마지막으로 새로 그어진 길이 값 또한 "result"에 추가해서 결과 도출함.

 

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

 

3273번: 두 수의 합

n개의 서로 다른 양의 정수 a1, a2, ..., an으로 이루어진 수열이 있다. ai의 값은 1보다 크거나 같고, 1000000보다 작거나 같은 자연수이다. 자연수 x가 주어졌을 때, ai + aj = x (1 ≤ i < j ≤ n)을 만족하는

www.acmicpc.net

 

 

import sys
# input = sys.stdin.readline
n = int(input())
arr = list(map(int, input().split()))
x = int(input())

arr.sort()
result, start, end = 0, 0, n-1 # count, start_point, end_point

while start < end: # start가 end를 넘기면 종료
    current = arr[start] + arr[end] # start + end
    if current == x: #  x 값을 만족하는 쌍을 찾은경우
        result += 1 # result +
        start += 1 # start 위치 한 칸 이동 +
    elif current < x: # x 값 보다 작은경우
        start += 1 # start 위치 한 칸 이동 +
    elif current > x: # 현재 값이 x 값 보다 작으면
        end -=1 # end 값 한 칸 이동 -
        
print(result)
  • 주어진 값의 조건에 맞게 수열의 쌍을 찾는 문제( 정렬, 투포인트 )
  •  문제.
    • 1.처음 입력 받은 배열을 정렬
    • 하나의 배열을 기준으로 서로 양 끝(시작점, 끝점)에서 부터 값을 서로 합하여 주어진 값 "x"와 조건이 맞는지 찾는게 목적 -- "while start < end"  --- start가 end를 넘기면 종료
    • 현재 값"current"는 "arr[start]" + "arr[end]" 값임 -> 위 조건에 해당하는 x를 찾는게 목적 따라서,
    • "if current == x" 조건이 맞는 경우 "result += 1"를 해주고 "start 값 증가"
    • "elif current < x" 현재 값이 x 값 보다 작은경우 "start +=1" 값 증가 
    • "elif current > x "현재 값이 x 값 보다 큰경우 "end -= 1" 값 가감
  • 즉 "current"가 "x" 값을 만족하거나 "x"보다 작으면 "start"를 증가시키고 더 작은경우 "end"를 감소시킴

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

 

11497번: 통나무 건너뛰기

남규는 통나무를 세워 놓고 건너뛰기를 좋아한다. 그래서 N개의 통나무를 원형으로 세워 놓고 뛰어놀려고 한다. 남규는 원형으로 인접한 옆 통나무로 건너뛰는데, 이때 각 인접한 통나무의 높이

www.acmicpc.net

 

  • 위 문제의 핵심방법은 가장큰 수를 중간에 두는 것임
  • , ex) 2, 5, 9, 7, 4 ->, 4, 7, 9, 5, 2 
for i in range(int(input())):
    n = int(input())
    arr = list(map(int, input().split()))
    arr.sort(reverse=True)
    max_dif = 0
    for i in range(n-2):
        dif = abs(arr[i] - arr[i+2])
        max_dif = max(max_dif, dif)
    print(max_dif)

+ Recent posts