Slowly, Step by Step

[백준] 11660 구간 합 구하기 5 python

jellylucy — Wed, 14 Feb 2024 23:01:33 +0900

문제

N×N개의 수가 N×N 크기의 표에 채워져 있다. (x1, y1)부터 (x2, y2)까지 합을 구하는 프로그램을 작성하시오. (x, y)는 x행 y열을 의미한다.

예를 들어, N = 4이고, 표가 아래와 같이 채워져 있는 경우를 살펴보자.

1	2	3	4
2	3	4	5
3	4	5	6
4	5	6	7

여기서 (2, 2)부터 (3, 4)까지 합을 구하면 3+4+5+4+5+6 = 27이고, (4, 4)부터 (4, 4)까지 합을 구하면 7이다.

표에 채워져 있는 수와 합을 구하는 연산이 주어졌을 때, 이를 처리하는 프로그램을 작성하시오.

입력

첫째 줄에 표의 크기 N과 합을 구해야 하는 횟수 M이 주어진다. (1 ≤ N ≤ 1024, 1 ≤ M ≤ 100,000) 둘째 줄부터 N개의 줄에는 표에 채워져 있는 수가 1행부터 차례대로 주어진다. 다음 M개의 줄에는 네 개의 정수 x1, y1, x2, y2 가 주어지며, (x1, y1)부터 (x2, y2)의 합을 구해 출력해야 한다. 표에 채워져 있는 수는 1,000보다 작거나 같은 자연수이다. (x1 ≤ x2, y1 ≤ y2)

출력

총 M줄에 걸쳐 (x1, y1)부터 (x2, y2)까지 합을 구해 출력한다.

예제 입력 1 복사

예제 출력 1 복사

27
6
64

포기했던 DP를 살려본 하루.. 포기했던 이유가 있어 ㅋㅎㅎㅋㅎ

돌아서면 또 까먹을 것 같어

initialize

n + 1 범위로 버퍼를 준다. 따라서 dp[i][j] 에 graph[i][j]가 아니라 graph[i-1][j-1].

양 x,y [0] [0] 막대기들이 0으로 되어있게끔.

=> [[0, 0, 0, 0, 0], [0, 1, 3, 6, 10], [0, 3, 8, 15, 24], [0, 6, 15, 27, 42], [0, 10, 24, 42, 64]] dp

dp = [[0 for _ in range(n + 1)] for _ in range(n + 1)]


for i in range(1, n+1):
    for j in range(1, n+1):
        dp[i][j] = dp[i-1][j] + dp[i][j-1] + graph[i - 1][j - 1] - dp[i-1][j-1]

DP내에서 시작점 끝점 변형한 부분합 (아래는 DP 이차원배열)

전체 부분합에서 대각선의 부분합을 뺀다 이 때 겹치는 대각선의 부분합이 2번 빼지니까 한번 더해준다.

import sys
input = sys.stdin.readline
n, m = map(int, input().split())
graph = []
for _ in range(n):
    graph.append(list(map(int, input().split())))

test = []
for _ in range(m):
    test.append(list(map(int, input().split())))

dp = [[0 for _ in range(n + 1)] for _ in range(n + 1)]


for i in range(1, n+1):
    for j in range(1, n+1):
        dp[i][j] = dp[i-1][j] + dp[i][j-1] + graph[i - 1][j - 1] - dp[i-1][j-1]

for x1, y1, x2, y2 in test:
    ans = 0

    ans = dp[x2][y2] - dp[x2][y1-1] - dp[x1-1][y2] + dp[x1-1][y1-1]

    print(ans)


# def findSum(x1, y1, x2, y2):
#     global graph
#     xLen = x2 - x1 + 1
#     yLen = y2 - y1 + 1
#     dp = [[0 for _ in range(yLen)] for _ in range(xLen)]
#     dp[0][0] = graph[x1][y1]
#     # print(dp)

#     # i
#     for i in range(1, xLen):
#         dp[i][0] = dp[i - 1][0] + graph[x1 + i][y1]

#     # j
#     for j in range(1, yLen):
#         dp[0][j] = dp[0][j - 1] + graph[x1][y1 + j]

#     # print(dp, "dd")
#     for i in range(xLen - 1):
#         for j in range(yLen - 1):
#             dp[i + 1][j + 1] = dp[i][j + 1] + dp[i + 1][j] + graph[x1 + i + 1][y1 + j + 1] - dp[i][j]
    
#     # print(dp)
#     return dp[xLen - 1][yLen - 1]
    

    

# dp 같다.
# dp[n]은 0부터 n까지 의 합.

[백준] 20922 겹치는 건 싫어 python

jellylucy — Wed, 7 Feb 2024 12:30:17 +0900

겹치는 건 싫어 성공

시간 제한메모리 제한제출정답맞힌 사람정답 비율

1 초 (추가 시간 없음)

1024 MB

9838

3568

2732

35.425%

문제

홍대병에 걸린 도현이는 겹치는 것을 매우 싫어한다. 특히 수열에서 같은 원소가 여러 개 들어 있는 수열을 싫어한다. 도현이를 위해 같은 원소가 �개 이하로 들어 있는 최장 연속 부분 수열의 길이를 구하려고 한다.

100000 이하의 양의 정수로 이루어진 길이가 �인 수열이 주어진다. 이 수열에서 같은 정수를 �개 이하로 포함한 최장 연속 부분 수열의 길이를 구하는 프로그램을 작성해보자.

입력

첫째 줄에 정수 � (1≤�≤200000)과 � (1≤�≤100)가 주어진다.

둘째 줄에는 �1,�2,...��이 주어진다 (1≤��≤100000)

출력

조건을 만족하는 최장 연속 부분 수열의 길이를 출력한다.

예제 입력 1 복사

9 2
3 2 5 5 6 4 4 5 7

예제 출력 1 복사

문제 풀이

같은 원소의 개수를 확인하면서 탐색해야한다.

=> 수열의 같은 원소 개수를 담기 위한 counter[] 생성한다.

만약 counter[수열원소값] < k 인 경우

값을 더하고, 이동한다.

아닌 경우

수열의 처음 부분을 앞으로 당기고

그 수열의 처음부분의 원소 개수 값을 뺀다.

이 때 만들어진 부분수열의 길이를 answer와 비교해 max값을 넣는다.

n, k = map(int, input().split())
numbers = list(map(int, input().split()))
left, right = 0, 0

# 이걸 왜 하는걸까
counter = [0] * (max(numbers) + 1)
answer = 0
while right < n:
    if counter[numbers[right]] < k:
        counter[numbers[right]] += 1
        right += 1
    else:
        counter[numbers[left]] -= 1
        left += 1
    answer = max(answer, right - left)

print(answer)

Two Pointer 개념 정리

jellylucy — Wed, 7 Feb 2024 12:23:00 +0900

간단하게 두개의 인덱스를 이용해서 최적의 해를 구하는 것이다.

보통 start, end = 0, 0 으로 둔 뒤 end의 값을 늘려간다.

그리고 필요시 start += 1을 해주면서 두 인덱스 값을 조절한다.

특정한 합을 찾는 연속 수열

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

for start in range(n):
	while result < m and end < n:
    	result += graph[end]
        end += 1
    
    if result == m:
    	count += 1
    
    result -= graph[start]
   
print(count)

해당 문제에서는 모든 부분수열의 경우의 수를 다 확인하면서 찾는 공간을 사용해야한다..

그래서 end 만 이동시키는 것 뿐만 아니라,

start 또한 앞으로 한 번씩 움직인다.

[이코테] 음료수 얼려먹기 python

jellylucy — Fri, 2 Feb 2024 20:04:44 +0900

문제 풀이

이 문제는 BFS를 돌고 돌 수 있는 블럭의 개수를 구하는 것이다.

이중 For문으로 모든 이차원배열의 인덱스 bfs 돌리는데 이 때 방문하지 않는 값들만 count해준다.

from collections import deque

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

graph = []

result = 0

for i in range(n):

graph.append(list(map(int, input().split())))

def in_range(x,y):

if x >= 0 and x < n and y >= 0 and y < m:

return True

return False

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

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

def bfs(x, y):

global graph, dx, dy

q = deque()

# visited = [[0] * m for _ in range(n)]

q.append((x,y))

graph[x][y] = 1

while q:

x,y = q.popleft()

# 인접한 노드들 중에 갈 수 있는 거 확인하기, 갈 수만 있다면 다 넣는다 = 너비우선탐색

for a, b in zip(dx, dy):

nx, ny = x + a, y + b

if in_range(nx, ny) and graph[nx][ny] == 0:

graph[nx][ny] = 1

q.append((nx,ny))

for i in range(n):

for j in range(m):

if graph[i][j] == 0:

result += 1

bfs(i,j)

print(result)

[백준] 13549 숨바꼭질3 python

jellylucy — Fri, 2 Feb 2024 20:02:42 +0900

숨바꼭질 3 성공

시간 제한메모리 제한제출정답맞힌 사람정답 비율

2 초

512 MB

95995

24571

16415

24.222%

문제

수빈이는 동생과 숨바꼭질을 하고 있다. 수빈이는 현재 점 N(0 ≤ N ≤ 100,000)에 있고, 동생은 점 K(0 ≤ K ≤ 100,000)에 있다. 수빈이는 걷거나 순간이동을 할 수 있다. 만약, 수빈이의 위치가 X일 때 걷는다면 1초 후에 X-1 또는 X+1로 이동하게 된다. 순간이동을 하는 경우에는 0초 후에 2*X의 위치로 이동하게 된다.

수빈이와 동생의 위치가 주어졌을 때, 수빈이가 동생을 찾을 수 있는 가장 빠른 시간이 몇 초 후인지 구하는 프로그램을 작성하시오.

입력

첫 번째 줄에 수빈이가 있는 위치 N과 동생이 있는 위치 K가 주어진다. N과 K는 정수이다.

출력

수빈이가 동생을 찾는 가장 빠른 시간을 출력한다.

예제 입력 1 복사

5 17

예제 출력 1 복사

문제 풀이

전형적인 BFS만 풀다보니까 BFS의 개념을 놓치고 있어서 못 풀었다.

BFS는 너비 우선 탐색이니까,

우선은 가능한 인접 노드 (즉, in_range인 경우 그리고 방문하지 않는 경우)는 다 queue에 저장하는 것이다.

여기서 추가적으로 순간이동하는 움직임에 대한 우선순위를 주기 위해

appendLeft()를 넣는다

from collections import deque

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

# 수빈이가 있는 위치, 동생이 있는 위치

result = 0

visited = [-1 for _ in range(100001)]

print(visited)

queue = deque()

queue.append(n)

visited[n] = 0

while queue:

x = queue.popleft()

if x == m:

print(visited[x])

break

# 방문을 어떤 걸 해야하는거지?

# 너비 탐색을 하려면 인접노드로 가야하는데

if 0 <= x-1 <= 100000 and visited[x-1] == -1:

visited[x-1] = visited[x] + 1

queue.append(x-1)

if 0 <= x*2 <= 100000 and visited[2*x] == -1:

queue.appendleft(x*2)

visited[2*x] = visited[x]

if 0 <= x+1 <= 100000 and visited[x+1] == -1:

visited[x+1] = visited[x] + 1

queue.append(x+1)

# while True:

# if (n == m):

# break

# else:

# if (n*2 <= m):

# n = n*2

# continue

# if (n < m):

# n += 1

# else:

# n -= 1

# result += 1

# print(result)

[백준] 17836 공주님을 구해라! python

jellylucy — Fri, 2 Feb 2024 19:49:53 +0900

공주님을 구해라! 성공

시간 제한메모리 제한제출정답맞힌 사람정답 비율

1 초

256 MB

15291

3980

2958

24.220%

문제

용사는 마왕이 숨겨놓은 공주님을 구하기 위해 (N, M) 크기의 성 입구 (1,1)으로 들어왔다. 마왕은 용사가 공주를 찾지 못하도록 성의 여러 군데 마법 벽을 세워놓았다. 용사는 현재의 가지고 있는 무기로는 마법 벽을 통과할 수 없으며, 마법 벽을 피해 (N, M) 위치에 있는 공주님을 구출해야만 한다.

마왕은 용사를 괴롭히기 위해 공주에게 저주를 걸었다. 저주에 걸린 공주는 T시간 이내로 용사를 만나지 못한다면 영원히 돌로 변하게 된다. 공주님을 구출하고 프러포즈 하고 싶은 용사는 반드시 T시간 내에 공주님이 있는 곳에 도달해야 한다. 용사는 한 칸을 이동하는 데 한 시간이 걸린다. 공주님이 있는 곳에 정확히 T시간만에 도달한 경우에도 구출할 수 있다. 용사는 상하좌우로 이동할 수 있다.

성에는 이전 용사가 사용하던 전설의 명검 "그람"이 숨겨져 있다. 용사가 그람을 구하면 마법의 벽이 있는 칸일지라도, 단숨에 벽을 부수고 그 공간으로 갈 수 있다. "그람"은 성의 어딘가에 반드시 한 개 존재하고, 용사는 그람이 있는 곳에 도착하면 바로 사용할 수 있다. 그람이 부술 수 있는 벽의 개수는 제한이 없다.

우리 모두 용사가 공주님을 안전하게 구출 할 수 있는지, 있다면 얼마나 빨리 구할 수 있는지 알아보자.

입력

첫 번째 줄에는 성의 크기인 N, M 그리고 공주에게 걸린 저주의 제한 시간인 정수 T가 주어진다. 첫 줄의 세 개의 수는 띄어쓰기로 구분된다. (3 ≤ N, M ≤ 100, 1 ≤ T ≤ 10000)

두 번째 줄부터 N+1번째 줄까지 성의 구조를 나타내는 M개의 수가 띄어쓰기로 구분되어 주어진다. 0은 빈 공간, 1은 마법의 벽, 2는 그람이 놓여있는 공간을 의미한다. (1,1)과 (N,M)은 0이다.

출력

용사가 제한 시간 T시간 이내에 공주에게 도달할 수 있다면, 공주에게 도달할 수 있는 최단 시간을 출력한다.

만약 용사가 공주를 T시간 이내에 구출할 수 없다면, "Fail"을 출력한다.

예제 입력 1 복사

6 6 16
0 0 0 0 1 1
0 0 0 0 0 2
1 1 1 0 1 0
0 0 0 0 0 0
0 1 1 1 1 1
0 0 0 0 0 0

예제 출력 1 복사

문제 풀이

첫번째 풀이

1. 검의 위치를 먼저 구해서 검까지의 bfs를 구한다.

2. n,m까지의 bfs를 구한다

3. 두 가지 값을 비교해 print한다

반례가 존재했다.

검까지의 최단거리가 검까지의 좌표 밖에서 실행될 수도 있다

두번째 풀이

1. n,m까지의 bfs 알고리즘 안에다 검을 찾는 로직을 넣는다.

이 때 검의 최단거리의 값이 존재하는 경우로 비교구문을 넣어서 출력한다.

from collections import deque

def in_range(x, y, nn, mm):
    if (x >= 0 and x < nn and y >= 0 and y < mm):
        return True
    return False

n, m, t = map(int, input().split())
graph = []
gun = -1
checkX, checkY = 0, 0
for i in range(n):
    graph.append(list(map(int, input().split())))
    for j in range(m):
        if graph[i][j] == 2:
            checkX = i + 1
            checkY = j + 1


def bfs(x, y, aa, bb):
    global graph, gun
    visited = [[-1] * bb for _ in range(aa)]
    # print(visited,"uv")
    queue = deque()
    queue.append((x, y))
    visited[x][y] = 0

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

    while queue:
        x, y = queue.popleft()
        if (x == aa - 1 and y == bb - 1): # 공주에게 도착한 경우
            if gun != -1:
                return min(visited[x][y], gun)
            else:
                return visited[x][y]

        for a, b in zip(dx, dy):
            nx, ny = a + x, b + y
            if in_range(nx, ny, aa, bb) and graph[nx][ny] != 1 and visited[nx][ny] == -1:
                if graph[nx][ny] == 2:
                    # 검을 찾은 경우
                    gun = n - 1 - nx + m - 1 - ny + visited[x][y] + 1
                visited[nx][ny] = visited[x][y] + 1
                # print(nx, ny, "nx, ny")
                queue.append((nx, ny))
    # print(visited,"visites")
    
    return -1
    

# 검 찾는 최단거리를 구한다.
# gun = bfs(0, 0, checkX, checkY)
basic = bfs(0, 0, n, m)
# print(basic, "na")
if (basic == - 1 and -1 < gun <= t):
    print(gun)
elif (-1 < basic <= t):
    print(basic)
else:
    print("Fail")
    
#     # 검의 최단거리 값이 있을 경우
#     gun += (n - checkX) + (m - checkY)
#     realResult = min(gun, basic)
#     # 기본으로 최단거리 구하기
#     if (-1 < realResult <= t):
#         print(realResult)
#     else:
#         print("Fail")
# else:
#     if (-1 < basic <= t):
#         # print(basic)
#         print(basic)
#     else:
#         print("Fail")

[백준] 완전탐색 22864, 18511, 15721, 1969 python

jellylucy — Thu, 1 Feb 2024 11:32:58 +0900

22864

완전탐색은 어느 범위로 for문을 돌아야할지 결정하는게 제일 중요하다.

하루에 최대 얼마나 일을 할 수 있는지 - => 하루 24시간으로 정했다.

import sys
input = sys.stdin.readline

a, b, c, m = map(int, input().split())
tired = 0
work = 0
# 각 시간마다 피로도를 체크하고 안 넘었으면 계속 일하는게 최대인 것 같음 
for i in range(24):
    # print(work, tired,"work, tired")
    if (a > m):
        break
    # 일 더 해도 되는지 체크
    if (tired + a > m):
        # 더 할 경우 m 넘어간다
        if (tired - c < 0):
            tired = 0
        else:
            tired -= c
    else:
        tired += a
        work += b

print(work)

18511

중복 순열 !!

from itertools import product

data = ['사과', '배', '귤']

result = list(product(data, repeat=2))

print(result)


//결과
// [('사과', '사과'), ('사과', '배'), ('사과', '귤'), ('배', '사과'), ('배', '배'), ('배', '귤'), ('귤', '사과'), ('귤', '배'), ('귤', '귤')]

from itertools import product
graph = list(map(int, input().split()))

num = list(product(graph, length = maxLen))

product는 클래스이므로 객체 초기화 이후에는 리스트 자료형으로 변환하여 사용한다.

str 각 문자가 들어있는 배열을 int값으로 합치고 싶을 때

-> strList를 map해서 list로 다시 묶은 이유는 product의 list 자료형은 순서쌍으로 존재해서.

num = int(''.join(list(map(str, strList))))

# n보다 작거나 같은 자연수 중에서, 집합 k의 원소로만 구성된 가장 큰 수
# K의 모든 원소는 1부터 9까지의 자연수로만 구성된다
# n = 657, 집한 k의 원소 1, 5, 7dlaus
from itertools import product
# 중복순열..

n, countK = map(int, input().split())
graph = list(map(int, input().split()))
result = 0
graph.sort()
# 하나 또는 n의 자릿수만큼 graph의 원소를 구한다.
maxLen = len(str(n))

num = list(product(graph, repeat = maxLen))

# print(num)
# print(''.join(list(map(str, num[0]))))
# # 뭘까..?
while 1:
    # 최대길이로 먼저 중복순열을 돌린다
    num = list(product(graph, repeat = maxLen))
    for a in num:
        print(a, "a")
        print(list(map(str, a)), "list")
        tempA = int(''.join(list(map(str, a))))
        if (tempA <= n):
            result = max(result, tempA)
    if result == 0:
        maxLen -= 1
    else:
        print(result)
        break

15721

for문을 어떻게 잡아야할지 몰라서 헤맸다.

이럴 때는 ====> while(True)

배열의 index로 원소값을 찾고 싶을 때

tempList.index(1)

tempList.index((x, y))

a = int(input())
t = int(input())
say = int(input())

# T번째 번 또는 데기를 외치는 사람은 위 원에서 몇 번 사람인지를 구하라

bundegi = []
bun = degi = 1
n = 0

while True:
    prev_n = bun # 번이든 , 데기이든 한 번에 카운팅되는 수가 같음
    n += 1
    for _ in range(2):
        bundegi.append((bun, 0)) #왜 이렇게 넣는걸까 - 첫번째의. 0이다?
        bun += 1 # 몇번쨰의 번인지 카운팅
        bundegi.append((degi, 1))
        degi += 1
    for _ in range(n+1):
        bundegi.append((bun, 0)) #왜 이렇게 넣는걸까 - 첫번째의. 0이다?
        bun += 1 # 몇번쨰의 번인지 카운팅
    for _ in range(n+1):
        bundegi.append((degi, 1))
        degi += 1
    if prev_n < t <= bun:
        print(bundegi.index((t, say)) % a)
        break

1969

처음에 해맸던게 이중배열로 값을 담으려고 했다.

=> 심플하게 생각할 것!

입력이 이중배열이니까 넣는 것도 이중배열이면,, 머리가 안 돌아간다 ><

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

# 모든 DNA와 비교를 해야한다....
# 만들 수 있는 거는 .. 4 *  4 * 4 000 이거 아니야?
# checkList = [[0] * 4 for _ in  range(m)]
checkList = []
# print(checkList)
for i in range(m):
    countT = 0
    countA = 0
    countG = 0
    countC = 0
    for j in range(n):
        if graph[j][i] == 'T':
            countT += 1
        if graph[j][i] == 'A':
            countA += 1
        if graph[j][i] == 'G':
            countG += 1
        if graph[j][i] == 'C':
            countC += 1
    # print(countT, countA, countG, countC)
    checkList.append([countA,countC,countG, countT])
# print(checkList)

alpha = ['A', 'C', 'G', 'T']
result = []
resultSum = 0
for check in checkList:
    tempNum = 0
    tempChar = ''
    tempCount = 0
    for i in range(4):
        if tempNum < check[i]:
            tempNum = check[i]
            tempChar = alpha[i]
            tempCount = n - check[i]
    resultSum += tempCount
    result.append(tempChar)

result = ''.join(result)
print(result)
print(resultSum)

다른 풀이

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

list = []
s=''
dna = ['A', 'C', 'G', 'T']
hamming_distance = 0

for i in range(n):
    data = input()
    list.append(data)
    
for i in range(m):
    a_count, c_count , g_count, t_count = 0,0,0,0
    for j in range(n):
        if list[j][i]==dna[0]:
            a_count += 1
        elif list[j][i]==dna[1]:
            c_count += 1
        elif list[j][i]==dna[2]:
            g_count += 1
        elif list[j][i]==dna[3]:
            t_count += 1
    count_list = [a_count, c_count, g_count, t_count]
    selected_dna = dna[count_list.index(max(count_list))]
    s+=selected_dna
    for k in range(n):
        if list[k][i]!= selected_dna:
            hamming_distance += 1 
        
print(s)
print(hamming_distance)

같은 것이 있을 때 사전순서로 출력하는 부분에서, max를 쓰면 안된다고 생각했다.

근데 이게 되네 => 첫번째로 나타나는 인덱스를 반환한다.

만약 tempList가 [4, 4, 3, 1]인 경우에는 tempList.index(max(tempList))의 결과는 0입니다.

max(tempList)는 리스트 내에서 가장 큰 값을 반환하며, 그 값은 4입니다. 
그 다음으로 tempList.index() 함수는 해당 값(4)이 처음으로 나타나는 인덱스를 반환합니다. 
따라서 4가 리스트에서 첫 번째로 나타나는 위치는 0번 인덱스입니다.

[백준] 완전탐색 2231, 2798, 18312, 19532 python

jellylucy — Wed, 31 Jan 2024 12:36:16 +0900

2798

주어진 카드 중에서 3개를 고르는 경우의 수를 구해야한다. => 조합

from itertools import combinations

for cards in combinations(graph, 3)

# 카드의 합이 21을 넘지 않는 한도내에서 카드의 합을 최대한 크게 만드는 게임이다
# 첫째 줄에 카드의 개수
import sys
from itertools import combinations
# input = sys.stdin.readline()

n, m = map(int, input().split())
graph = list(map(int, input().split()))
graph.sort()
result = 0
# 합이 넘지 않는 카드 3장을 찾을 수 있는 경우만 입력으로 주어진다
# N 개 중에 서로다른 3장을 구하는 경우의 수 = 조합 nC3
# 모든 경우의 합을 다 구한다.
resultList = []
for cards in combinations(graph, 3):
    tempSum = sum(cards)
    differ = m - tempSum
    if (differ >= 0):
        resultList.append([tempSum, differ])
    # if (differ < (m - result)):
    #     result = tempSum
    #     print(cards)
resultList.sort(key=lambda x:x[1])

print(resultList[0][0])
# 그 경우의 합을 구할 때 마다 차이값을 넣는다

2231

3자리 예제를 보고 3자리만 생각했다.

n의 값을 낼 수 있는 부분합의 모든 경우의 수 = 1부터 n 사이의 정수

=> for i in range(1, n)

각 자리 수를 string으로 변환해서 합을 구해야한다.

=> sum ( map(int, str(i)) )

https://dojang.io/mod/page/view.php?id=2286

map 개념 복습할 것.

n = int(input())
result = 0
# 생성자가 생길 수 있는 경우의 수 = n의 작은 자연수들.
# 생성자를 정하고 각 자리 수를 하나씩 더하고 비교한다.

for i in range(1, n+1):
    # 각자리수를 더해야한다...
    # map(int, str(i)) = 문자열을 숫자로 변환한다. 그거를 리스트로..
    nums = sum(map(int, str(i)))
    tempNum = i + nums
    if (tempNum == n):
        # print(tempNum, nums,  "tempNu")
        result = i
        break

print(result)

19532

변수를 할당하는 것으로 시간 초과가 날 수 있다ㅠ

from itertools import combinations
import sys
input = sys.stdin.readline
a, b, c, d, e, f = map(int, input().split())
realx, realy = 0, 0
for x in range(-999, 1000):
    for y in range(-999, 1000):
        # tempC = a * x + b * y
        # tempF = d * x + e * y
        # if (tempC == c and tempF == f):
            # print(x, y)
        if (a * x + b * y == c and d * x + e * y == f):
            print(x,y)

# graph = list(i for i in range(-999, 1000))
# for x,y in combinations(graph, 2)

18312

단순 완탐이였는데 수학적으로 접근해서 꼬였다

n, kk = map(int, input().split())
# 모든 시각 중에서 K가 하나라도 포함되는 모든 시각?
# result = 0
# temp_result = 0
# if (k <= n):
#     # k시인 경우일 때 모든 분초
#     result += 60 * 60
#     # k시아닌 경우에서 분에서 3이 나온 경우
#     temp_result = ((6*k + 8) * 60) * (n) 
#     + (6*k + 8) * n - ((6*k + 8) * (6*k +8) * n)
#     result += temp_result
# print(result)
count = 0
strK = str(kk)
# 모든 시각
for i in range(n+1):
    for j in range(60):
        for k in range(60):
            if (i < 10):
                tempI = '0' + str(i)
            else:
                tempI = str(i)
            if (j < 10):
                tempJ = '0' + str(j)
            else:
                tempJ = str(j)
            if (k < 10):
                tempK = '0' + str(k)
            else:
                tempK = str(k)
            if (strK in tempI or strK in tempJ or strK in tempK):
                count+=1

print(count)

[백준] string 11365, 11720, 3029 python

jellylucy — Wed, 31 Jan 2024 12:20:57 +0900

11365

for문을 역순으로 돌리는 것 연습

for(처음, 끝, step)

codeList = []

while(True):
    code = str(input())
    if (code == 'END'):
        break
    codeList.append(code)

codeLen = len(codeList)
for c in codeList:
    for i in range(len(c)-1, -1, -1):
        print(c[i], end='')
    print()

11720

string을 int로 변환하는 것.

int으로 묶으면

# n개의 숫자가 공백 없이 쓰여있다
result = 0
n = int(input())
ans = str(input())

for i in range(len(ans)):
    result += int(ans[i])
print(result)

3029

입력

첫째 줄에 현재 시간이 hh:mm:ss 형식으로 주어진다. (시, 분, 초) hh는 0보다 크거나 같고, 23보다 작거나 같으며, 분과 초는 0보다 크거나 같고, 59보다 작거나 같다.

둘째 줄에는 나트륨을 던질 시간이 위와 같은 형식으로 주어진다.

출력

첫째 줄에 정인이가 기다려야 하는 시간을 입력과 같은 형식으로 출력한다.

예제 입력 1 복사

20:00:00
04:00:00

예제 출력 1 복사

08:00:00

문제풀이

1. 24시간이 지나면 추가로 더해줘야 한다.

2. 시간형태로 출력하기

-> "출력형식"%(데이터)

02%d => 시계열의 출력형식

import sys
input = sys.stdin.readline

h1, m1, s1 = map(int, input().split(':'))
h2, m2, s2 = map(int, input().split(':'))
total = h1*60*60 + m1*60 + s1
total2 = h2*60*60 + m2*60 + s2
t = total2 - total
if (total2 - total <= 0):
    t = t + 24*60*60

h = t//60//60
m = t//60 % 60
s = t % 60
print("%02d:%02d:%02d" % (h, m, s))

[프로그래머스] 아이템 줍기 python

jellylucy — Wed, 24 Jan 2024 18:29:12 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/87694

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

문제 풀이

어려워. . . . 다시 풀어야 한다

1. 입력받은 직사각형의 좌표값으로 테두리만을 갖고 있는 2차원 배열 만들기

(1) 모든 좌표값은 2배로 만든다.

ㄷ 모양을 ㅁ으로 착각할 수 있기 때문이다.

(2) 각 직사각형의 x,y 폭만큼 이중 For문을 돌다가,

해당 값이 직사각형의 테두리쪽 안에 있으면 0 값을 넣고

테두리 쪽인 경우에만 1을넣는다.

(2) 그다음 BFS..

    field = [[-1] * 102 for i in range(102)]
    
    for r in rectangle:
    	# 모든 좌표값 2배
        x1, y1, x2, y2 = map(lambda x: x*2, r)
        for i in range(x1, x2+1):
            for j in range(y1, y2+1):
                if x1 < i < x2 and y1 < j < y2:
                    field[i][j] = 0
                # 다른 직사각형의 내부가 아니면서 현재 직사각형의 테두리일 때 1로 채움
                elif field[i][j] != 0:
                    field[i][j] = 1

from collections import deque
def makeGraph(rectangle):
    x, y = 0, 0
    graph = []
    leftX, leftY, rightX, rightY = 60, 60, 0, 0
    for a, b, c, d in rectangle:
        leftX = min(a, leftX)
        leftY = min(b, leftY)
        rightX = max(c, rightX)
        rightY = max(d, rightY)
    # print(leftX, leftY, rightX, rightY, "leftX, leftY, rightX, rightY")
    x = rightX - leftX
    y = rightY - leftY
    
    graph = [[0] * (x+1) for _ in range(y+1)]
    
#   직사각형 하나씩 만들어서 1 값 넣어주기
    for a, b, c, d in rectangle:
        for i in range(d-b+1):
            for j in range(c-a+1):
                graph[i+leftY-b][j+leftX-a] = 1
    
    return graph

def solution(rectangle, characterX, characterY, itemX, itemY):
    answer = 0
#     모든 경우의 수를 지닌 2차원 배열 초기화
    field = [[-1] * 102 for i in range(102)]
    
#     (1) 직사각형 만든다 테두리부분만 1로 
    for r in rectangle:
        # 모든 좌표값 2배 -> ㄷ 자 일때 ㅁ으로 보여질 수 있어서
        x1, y1, x2, y2 = map(lambda x: x*2, r)
        for i in range(x1, x2+1):
            for j in range(y1, y2+1):
                if x1 < i < x2 and y1 < j < y2:
                    field[i][j] = 0
                # 다른 직사각형의 내부가 아니면서 현재 직사각형의 테두리일 때.
                # for문이 현재의 직사각형 내부에서 도니까
                elif field[i][j] != 0:
                    field[i][j] = 1

    dx = [-1, 1, 0, 0]
    dy = [0, 0, -1, 1]
    
    q = deque()
    q.append([characterX * 2, characterY * 2])
    visited = [[1] * 102 for i in range(102)] # 아직 방문하지 않은 곳은 1로 표시
    visited[characterX * 2][characterY * 2] = 0 # 시작 지점은 0으로 초기화
    
    while q:
        x, y = q.popleft()
        # 도착한 곳이 아이템이 있는 장소라면 현재의 최단거리(나누기 2)를 answer로 하고 while문을 빠져나옴
        if x == itemX * 2 and y == itemY * 2:
            answer = visited[x][y] // 2
            break
        # 아니라면 상하좌우를 탐색
        for k in range(4):
            nx = x + dx[k]
            ny = y + dy[k]
            
            # 현재 좌표가 테두리이고 아직 방문하지 않은 곳이라면 q에 추가 후 visited를 최단거리로 갱신
            if field[nx][ny] == 1 and visited[nx][ny] == 1:
                q.append([nx, ny])
                visited[nx][ny] = visited[x][y] + 1
            
    #   먼저 2차원으로 큰 직사각형 만들기
    # graph = makeGraph(rectangle)

    
    
    return answer