Security Lab

[백준] 1644번 소수의 연속합 (파이썬, 두 포인터)

$hineild — Wed, 3 Nov 2021 01:43:49 +0900

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

1644번: 소수의 연속합

첫째 줄에 자연수 N이 주어진다. (1 ≤ N ≤ 4,000,000)

www.acmicpc.net

오랜만에 아무것도 안찾아보고 푼 문제다.

하지만 풀고나서 사람들의 풀이를 보니 아직 나는 두 포인터를 활용하는 부분이 부족했던 것 같다.

코드를 보면서 더 설명하겠다.

import sys


def prime_list(n):
    sieve = [True] * n
    m = int(n ** 0.5)
    for i in range(2, m + 1):
        if sieve[i] == True:
            for j in range(i+i, n, i):
                sieve[j] = False
    return [i for i in range(2, n) if sieve[i] == True]


n = int(sys.stdin.readline())
answer = 0
arr = prime_list(n+1)
l = len(arr)
for i in range(len(arr)):
    if i < l-1 and arr[i] + arr[i+1] > n:
        break
    p = i+2
    while(p <= l):
        if sum(arr[i:p]) == n:
            answer += 1
            break
        elif sum(arr[i:p]) < n:
            p += 1
        else:
            break

if l != 0 and arr[-1] == n:
    answer += 1

print(answer)

보면 알겠지만 for문을 돌려서 왼쪽 포인터의 값을 증가시키고 그 안에 while 문을 돌려서 오른쪽 포인터를 증가 시켰다.

내가 놓친 부분은 else 문이다.

else 후에 p는 초기화할 필요가 사실 없다.

예를 들어 i가 2이고 p가 6 일때 n보다 합계가 커진다면?

i =2, p=4에서 시작하는 것이 아니라 p=6에서 시작하는 것이 속도적으로 효율적일 것이다.

그리고 실제 사람들은 합계가 작으면 i를 올리고 크면 p를 줄이는 식으로 한 것 같다.

내 코드도 통과는 했지만 pypy로 돌려야만 풀렸으며 p를 i+2 가 아니라 len(arr) 부터 시작해서 줄여가는 형태로 만들었을 때는 시간 초과가 나왔다.

테스트 케이스 차이인것 같다.

다음에 두포인터 문제를 또 만나면 그때는 정석적인 방법으로 문제를 해결해봐야겠다.

[백준] 17404번 RGB거리2 (파이썬, DP) feet. 인간적인 코딩

$hineild — Mon, 1 Nov 2021 21:32:28 +0900

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

17404번: RGB거리 2

첫째 줄에 집의 수 N(2 ≤ N ≤ 1,000)이 주어진다. 둘째 줄부터 N개의 줄에는 각 집을 빨강, 초록, 파랑으로 칠하는 비용이 1번 집부터 한 줄에 하나씩 주어진다. 집을 칠하는 비용은 1,000보다 작거나

www.acmicpc.net

개인적으로는 dp 문제가 제일 어렵다.

다른 사람의 코드를 봐도 점화식을 이해하는게 버겁기 때문이다.

참고로 rgb거리2의 점화식을 이해하기 위해서는 우선

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

1149번: RGB거리

www.acmicpc.net

rgb거리를 푸는 것이 좋다.

내가 오늘 글에 쓰고 싶은 것은 점화식이 포인트가 아니다.

다른 사람들의 정갈한 풀이를 이해하지 못해서 인간적인 모습의 코드를 풀어서 포스팅을 한다.

해당 문제의 점화식 코드는 다음과 같다.

for i in range(1, n-1):
    dp[i][0] = min(dp[i-1][1], dp[i-1][2]) + arr[i][0]
    dp[i][1] = min(dp[i-1][0], dp[i-1][2]) + arr[i][1]
    dp[i][2] = min(dp[i-1][1], dp[i-1][0]) + arr[i][2]

해당 점화식을 이해하고 있다는 가정하에 포스팅을 진행하겠다.

이번 문제는 맨 앞집과 끝 집의 색깔이 달라야한다는 조건이 추가되었다.

dp는 애초에 누적된 비용이 들어가 있음으로 첫번째 집이 어떤 색깔로 색칠했는지를 알지 못한다는 단점이 있다.

(아마 이 부분을 해결하라는 의미의 문제일 것이다.)

백준 문제 해설에 대한 블로그 들의 치명적인 단점이 있는데 서로 참고해서 푸는 경우가 많다보니

글들이 최적화된 코드 1가지 모양으로 모인다는 것이다.

꼭 나쁘다고는 할 수 없지만 나는 이번 문제의 해답 코드가 이해가 잘 안갔다.

그래서 그걸 이해하고 따라하기 보다는 그냥 내가 생각하는데로 인간적인 면모의 코드를 작성했다.

포인트는 다른 사람들과 같다.

1. 경우의 수는 결국 3가지다. (첫번째 집이 빨강, 초록, 파랑인 경우)

2. 첫번째 집이 빨강일때는 마지막 집은 초록과 파랑 중 베스트를 찾아야하고 초록일때는 마지막 집이 빨강과 파랑 중 ...

3. 마지막 집의 경우의 수도 3가지이며 그 중 가장 최소 비용인 경우를 찾으면 된다.

이 3가지 중요한 점을 코드로 풀어서 적음면 끝이다.

1번 같은 경우는 첫번째 집이 빨강이라면 파랑일때와 초록일때의 비용을 1001로 지정하면 된다.(1001로 해도 크게 예외 없이 정답처리된다.)

첫번째 집이 빨강색일 때의 경우를 구해보면

dp[0][0] = arr[0][0]
dp[0][1] = 1001
dp[0][2] = 1001
for i in range(1, n-1):
    dp[i][0] = min(dp[i-1][1], dp[i-1][2]) + arr[i][0]
    dp[i][1] = min(dp[i-1][0], dp[i-1][2]) + arr[i][1]
    dp[i][2] = min(dp[i-1][1], dp[i-1][0]) + arr[i][2]

red = min(min(dp[n-2][0], dp[n-2][2]) + arr[n-1][1],
          min(dp[n-2][0], dp[n-2][1]) + arr[n-1][2])

이런 식으로 구할 수 있다.

이렇게 초록일 때와 파랑일 때도 구해주면 끝이다.

전체 코드를 보면 이 글에서 말하고자 하는 바가 무엇인지 파악할 수 있을 것이다.

import sys

n = int(sys.stdin.readline())

dp = [[0] * 3 for _ in range(n)]

arr = [list(map(int, sys.stdin.readline().split())) for _ in range(n)]

dp[0][0] = arr[0][0]
dp[0][1] = 1001
dp[0][2] = 1001
for i in range(1, n-1):
    dp[i][0] = min(dp[i-1][1], dp[i-1][2]) + arr[i][0]
    dp[i][1] = min(dp[i-1][0], dp[i-1][2]) + arr[i][1]
    dp[i][2] = min(dp[i-1][1], dp[i-1][0]) + arr[i][2]

red = min(min(dp[n-2][0], dp[n-2][2]) + arr[n-1][1],
          min(dp[n-2][0], dp[n-2][1]) + arr[n-1][2])

dp[0][0] = 1001
dp[0][1] = arr[0][1]
dp[0][2] = 1001
for i in range(1, n-1):
    dp[i][0] = min(dp[i-1][1], dp[i-1][2]) + arr[i][0]
    dp[i][1] = min(dp[i-1][0], dp[i-1][2]) + arr[i][1]
    dp[i][2] = min(dp[i-1][1], dp[i-1][0]) + arr[i][2]

green = min(min(dp[n-2][1], dp[n-2][2]) + arr[n-1][0],
            min(dp[n-2][0], dp[n-2][1]) + arr[n-1][2])

dp[0][0] = 1001
dp[0][1] = 1001
dp[0][2] = arr[0][2]
for i in range(1, n-1):
    dp[i][0] = min(dp[i-1][1], dp[i-1][2]) + arr[i][0]
    dp[i][1] = min(dp[i-1][0], dp[i-1][2]) + arr[i][1]
    dp[i][2] = min(dp[i-1][1], dp[i-1][0]) + arr[i][2]

blue = min(min(dp[n-2][1], dp[n-2][2]) + arr[n-1][0],
           min(dp[n-2][0], dp[n-2][2]) + arr[n-1][1])

print(min(red, green, blue))

남들은 for문을 3번 돌리면서 간결한 코드로 만들었던데 나는 그냥 이렇게 풀었다.

이 편이 내 자신이 이해하기 쉬웠기 때문이다.

[백준] 4386번 별자리 만들기(파이썬, MST)

$hineild — Sun, 31 Oct 2021 19:06:23 +0900

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

4386번: 별자리 만들기

도현이는 우주의 신이다. 이제 도현이는 아무렇게나 널브러져 있는 n개의 별들을 이어서 별자리를 하나 만들 것이다. 별자리의 조건은 다음과 같다. 별자리를 이루는 선은 서로 다른 두 별을 일

www.acmicpc.net

이번 문제는 최소 스패닝 트리 문제였다.

kuruskal mst 알고리즘을 사용했다.

핵심은 간선간의 비용은 좌표 간의 거리이며 2차 평면에서 두 좌표의 거리는 직각삼각형을 그려서 빗변의 길이를 구하면 두 좌표간의 거리가 된다.

x1, y1 과 x2, y2 두 좌표가 있다면

|x1 - x2|^2 + |y1 - y2|^2

의 루트 값이 바로 두 좌표간의 거리가 된다.

import sys
import heapq
n = int(sys.stdin.readline())
parent = {}
graph = []

def find(x):
    if parent[x] == False:
        return x
    p = find(parent[x])
    parent[x] = p
    return p

def union(x, y):
    if parent[x] < parent[y]:
        parent[x] += parent[y]
        parent[y] = x
    else:
        parent[y] += parent[x]
        parent[x] = y


for _ in range(n):
    x, y = map(float, sys.stdin.readline().split())
    parent[(x, y)] = False
    graph.append((x, y))

arr = []

for i in range(n-1):
    a = graph[i][0]
    b = graph[i][1]
    for j in range(i+1, n):
        x = graph[j][0]
        y = graph[j][1]
        dx = abs(a-x)
        dy = abs(b-y)
        l = round((dx**2 + dy**2)**0.5, 2)
        heapq.heappush(arr, [l, (a, b), (x, y)])

cnt = n-1
answer = 0

while(cnt):
    l, a, b = heapq.heappop(arr)
    ar = find(a)
    br = find(b)
    if ar != br:
        union(ar, br)
        answer += l
        cnt -= 1
print(answer)

요로코롬 풀었다.

[백준] 2473번 세 용액 (파이썬, 두 포인터)

$hineild — Fri, 29 Oct 2021 11:43:17 +0900

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

2473번: 세 용액

첫째 줄에는 전체 용액의 수 N이 입력된다. N은 3 이상 5,000 이하의 정수이다. 둘째 줄에는 용액의 특성값을 나타내는 N개의 정수가 빈칸을 사이에 두고 주어진다. 이 수들은 모두 -1,000,000,000 이상

www.acmicpc.net

이 문제는 이전 용액 문제를 풀고 푸는 것을 추천한다.

2021.08.08 - [Coding Test/Algorithm] - [백준] 2467번 용액 (파이썬)

[백준] 2467번 용액 (파이썬)

https://www.acmicpc.net/problem/2467 2467번: 용액 첫째 줄에는 전체 용액의 수 N이 입력된다. N은 2 이상 100,000 이하의 정수이다. 둘째 줄에는 용액의 특성값을 나타내는 N개의 정수가 빈칸을 사이에 두고..

shineild-security.tistory.com

오늘도 신나는 알고리즘

해당 문제는 또 다시 포인터를 움직여 가며 푸는 문제로 이번엔 세개의 용액을 선택해야한다는 차이가 있었다.

여러 생각을 하며 짰다가 지웠다가를 반복하고 for문에 while문을 곁들인 코드로 마무리 했다.

import sys

n = int(sys.stdin.readline())
arr = list(map(int, sys.stdin.readline().split()))
arr.sort()

result = 10000000000

index = []
for i in range(n-2):
    l = i+1
    h = n-1
    while(l < h):
        tmp = arr[i] + arr[l] + arr[h]
        if abs(result) > abs(tmp):
            result = tmp
            index = [arr[i], arr[l], arr[h]]
        if tmp > 0:
            h -= 1
        elif tmp < 0:
            l += 1
        else:
            break
print(index[0], index[1], index[2])

코드 자체는 심플하다.

전체 값이 만약 0보다 작다면 이미 arr[h]는 최대 값이기에 l에 1을 더해서 arr[l]의 값을 더 큭게하고

만약 0보다 크다면 반대로 arr[h]를 줄여서 가장 큰 값을 줄이는 방식을 사용했다.

이런식으로 i를 0부터 n-3까지 진행해주면 가장 0에 근접한 값이 무엇인지 알수 있었다.

파이썬3는 시간초과가 뜨지만 pypy로 하면 문제 없게 통과된다.

[백준] 2239번 스도쿠 (파이썬, DFS)

$hineild — Wed, 27 Oct 2021 12:16:34 +0900

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

2239번: 스도쿠

스도쿠는 매우 간단한 숫자 퍼즐이다. 9×9 크기의 보드가 있을 때, 각 행과 각 열, 그리고 9개의 3×3 크기의 보드에 1부터 9까지의 숫자가 중복 없이 나타나도록 보드를 채우면 된다. 예를 들어 다

www.acmicpc.net

스도쿠 조아~

익숙한 기법을 좋아하다보니 이번에도 DFS로 구현했다.

사실 BFS로 하기에는 뭔가 이상한 것 같아서 그런 것도 있다.

~~원래 스도쿠 푸는 걸 좋아했는데 무지성으로 다 때려 박아서 풀지만 나보다 빨리 푸는 코드를 보면서 씁슬한 마음이 들었다.~~

문제 접근은 간단하다.

규칙에 맞는 숫자가 없다면 백트래킹 하도록 구현하면 그만이다.

def dfs(i):
    if i == len(arr):
        ppp()
        sys.exit(0)
    x = arr[i][0]
    y = arr[i][1]
    b = box(x, y)
    for k in range(1, 10):
        if not k in board[x]:
            c = 0
            for n in range(9):
                if k == board[n][y]:
                    c = 1
                    break
            if c == 1:
                continue
            if not k in nop[b]:
                board[x][y] = k

                nop[b].append(k)
                dfs(i+1)
                board[x][y] = 0
                nop[b].remove(k)

dfs 자체는 이런 식으로 구현했다.

여기서 핵심은 arr과 box이다.

3*3 크기의 박스에서 숫자가 중복되는지 확인하는 과정은 매번 진행하면 번거롭다.

그렇기 때문에 사전에 9개의 박스에 각각 들어있는 숫자를 미리 배열로 넣어서 nop에 저장했다.

이렇게 하면 k라는 상수가 박스 안에 있는지 검증하는 것은 현재 x,y 좌표에 해당하는 상자의 번호를 알아오고 그 번호에 해당하는 상자에 중복되는 숫자가 있는지만 찾으면 된다.

if not k in nop[b]

이런 식으로 깔끔하게 정리가 가능하다.

def box(x, y):
    if x//3 == 0:
        if y//3 == 0:
            return 0
        elif y//3 == 1:
            return 1
        elif y//3 == 2:
            return 2
    if x//3 == 1:
        if y//3 == 0:
            return 3
        elif y//3 == 1:
            return 4
        elif y//3 == 2:
            return 5
    if x//3 == 2:
        if y//3 == 0:
            return 6
        elif y//3 == 1:
            return 7
        elif y//3 == 2:
            return 8

몇 번째 상자인지 구하는 방법은 3으로 나눴을때의 몫에 있다.

1~9로 생각하면 안된다.

인덱스 배열 그자체로 생각하는 편이 더 쉽다.

0~2는 3으로 나눌때 0이고 3~5는 1, 6~8은 2인 점을 고려해서 좌표값을 압축해서 표시할 수 있다.

board = [list(map(int, list(str(sys.stdin.readline().rstrip()))))
         for _ in range(9)]
arr = []
nop = [[], [], [], [], [], [], [], [], []]
for i in range(9):
    for j in range(9):
        if board[i][j] != 0:
            if i//3 == 0:
                if j//3 == 0:
                    nop[0].append(board[i][j])
                elif j//3 == 1:
                    nop[1].append(board[i][j])
                elif j//3 == 2:
                    nop[2].append(board[i][j])
            elif i//3 == 1:
                if j//3 == 0:
                    nop[3].append(board[i][j])
                elif j//3 == 1:
                    nop[4].append(board[i][j])
                elif j//3 == 2:
                    nop[5].append(board[i][j])
            elif i//3 == 2:
                if j//3 == 0:
                    nop[6].append(board[i][j])
                elif j//3 == 1:
                    nop[7].append(board[i][j])
                elif j//3 == 2:
                    nop[8].append(board[i][j])
        else:
            arr.append([i, j])

nop 또한 입력 받은 후 바로 생성해 줌으로 탐색을 계속 돌릴 필요를 없애준다.

그리고 가장 중요한 핵심은 dfs에서 arr과 i이다.(이 부분은 사실 for문을 써도 되지 않았을까 싶다)

board의 좌표를 계속 올려가면서 91개의 칸을 탐색하는 것이 아닌 0인 칸. 즉, nop를 정의할 때 함께 arr도 정의하여 비어있는 칸의 좌표를 arr에 넣어 줌으로써 빈 칸만 루프를 돌려가며 탐색하도록 했다.

이 부분이 가장 중요했던 것 같다.

하지만 python3 로는 시간초과임으로 pypy를 활용했다..

[2021 KAKAO BLIND RECRUITMENT] 메뉴 리뉴얼 (파이썬)

$hineild — Sat, 11 Sep 2021 04:55:00 +0900

오늘 있는 코딩 테스트를 대비해서 열심히 문제를 풀고 있다..

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

코딩테스트 연습 - 메뉴 리뉴얼

레스토랑을 운영하던 스카피는 코로나19로 인한 불경기를 극복하고자 메뉴를 새로 구성하려고 고민하고 있습니다. 기존에는 단품으로만 제공하던 메뉴를 조합해서 코스요리 형태로 재구성해서

programmers.co.kr

해당 문제를 부분집합이라는 개념에 접근하여 풀어보았다.

https://www.welcomekakao.com/learn/courses/30/lessons/42890

코딩테스트 연습 - 후보키

[["100","ryan","music","2"],["200","apeach","math","2"],["300","tube","computer","3"],["400","con","computer","4"],["500","muzi","music","3"],["600","apeach","music","2"]] 2

www.welcomekakao.com

동빈나 선생님의 후보키 풀이법을 보면 부분집합을 이용하여 푸는 방식이 나오는데 그걸 활용해서 메뉴 리뉴얼도 풀었다.

~~(배운걸 잘 실천하는 모범 학생)~~

정답률 25%문제를 풀게된 것이라 뿌듯하며 언제쯤 1자리 수 합격률의 문제를 안 보고 풀 수 있을련지...

해당 문제를 푸는데 중요하게 생각 한 것은 두가지 였다.

1. 코스요리 후보를 생성하는 것

2. 가장 많이 주문한 후보를 추리는 것

첫번째 코스요리 후보를 생성하는 것은 부분집합을 이용하면 쉽게 할 수 있다.

def get_all_subset(iterable):
    s = list(iterable)
    return chain.from_iterable(combinations(s, r) for r in range(len(s) + 1))

라는 함수를 이용하면 쉽게 부분집합을 생성할 수가 있다.

이제 딕셔너리를 하나 생성하고 거기에 후보를 담기 시작한다.

dic = {}
    
    orders = sorted(orders)
    for i in range(len(orders)):
        orders[i] = sorted(list(orders[i]))
    for i in range(len(orders)): 
        subset_list = get_all_subset(list(range(0, len(orders[i]))))
        for j in subset_list:
            if len(j) in course:
                string = ''
                for k in j:
                    string += orders[i][k]
                if string in dic:
                    dic[string] += 1
                else:
                    dic[string] = 1

for문을 통해 차례대로 부분집합을 생성해주고 course에 해당하는 길이의 부분집합을 불러오고 dic에 있다면 value를 올려서 counting 해주고 없다면 새로 생성한다.

이렇게 해주면 첫번째 할일은 끝난다.

두번째로 중요한 가장 많이 시킨 후보군을 고르는 것은 흔히 수동으로(?) 만들던 max 기능을 구현해서 사용하면 된다.

tmp = [0] * 10
    tmp_answer = [['']] * 10
    for key, val in dic.items():
        if val >= 2:
            l = len(key)-1
            if tmp[l] < val:
                tmp[l] = val
                tmp_answer[l] = [key]
            elif tmp[l] == val:
                tmp_answer[l].append(key)

이후 tmp_answer의 값을 예쁘게 answer에 담아서 제출하였다.

[백준] 2467번 용액 (파이썬)

$hineild — Sun, 8 Aug 2021 00:32:36 +0900

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

2467번: 용액

첫째 줄에는 전체 용액의 수 N이 입력된다. N은 2 이상 100,000 이하의 정수이다. 둘째 줄에는 용액의 특성값을 나타내는 N개의 정수가 빈칸을 사이에 두고 오름차순으로 입력되며, 이 수들은 모두 -

www.acmicpc.net

이번에는 이진탐색 문제를 풀었다.

2019.06.17 - [Knowledge/Algorithm] - 알고리즘 - 이진탐색 알고리즘 개념

알고리즘 - 이진탐색 알고리즘 개념

안녕하세요. 오늘은 이진탐색 알고리즘 개념에 대해서 정리하려 합니다. 이진탐색이란 이진법, 이분법에서 파생된 말로 아메바를 예로 들 수가 있겠네요. 아메바는 번식을 할 때 자신의 몸을 반

shineild-security.tistory.com

이진탐색이 무엇인지 처음 접하는 사람은 위 글을 읽고 오면 좋을 것이다.

(참고로 다른사람 풀이를 안보고 풀고 올리는 것이라 효율은 보장하지 않는다. / ("효율 < 직접 풀이" 라고 생각하는 편)

이번 문제의 핵심은 bisect 모듈의 응용력이다.

파이썬의 bisect 모듈의 단점은 선택한 데이터가 들어가야할 위치를 반환하는 모듈이라는 것이다.

우리는 찾고자하는 값과 가장 가까운 값을 알기 원하지만

arr = [-1, 30, 100]

라는 배열에서 bisect.bisect(arr, 31)을 하면 2를 반환한다.

그래서 arr[1]의 값이 31보다 작은게 확실하지만 arr[2]의 값이 arr[1]보다 31에 더 가깝다는 보장을 주지 못한다.

그래서 이러한 부분을 고려하고 if문으로 직접 검증해서 인덱스 값을 조정해주었다.

import sys
import bisect
n = int(sys.stdin.readline())
arr = list(map(int, sys.stdin.readline().rstrip().split()))
mini = 2000000000
answer = []
while(True):
    t = bisect.bisect_left(arr, -arr[0])
    if t == len(arr):
        t -= 1
    elif t == 0:
        t = 1
    if t > 1:
        if abs(arr[t] + arr[0]) > abs(arr[t-1] + arr[0]):
            t -= 1
    tmp = arr[0] + arr[t]
    if tmp == 0:
        print(arr[0], arr[t])
        break
    if abs(mini) > abs(tmp):
        mini = tmp
        answer = [arr[0], arr[t]]
    del arr[0]
    if len(arr) == 1:
        print(answer[0], answer[1])
        break

이 부분이 핵심이라 생각한다.

if t == len(arr):
        t -= 1
    elif t == 0:
        t = 1
    if t > 1:
        if abs(arr[t] + arr[0]) > abs(arr[t-1] + arr[0]):
            t -= 1

범위의 오류를 처리하고 반환값의 왼쪽의 값과 검증을 통해 인덱스값을 조정해주면

쉽게 원하고자 하는 값과 가장 근사한 값을 알 수 있게 된다.

[백준] 2166번 다각형의 면적(파이썬)

$hineild — Fri, 6 Aug 2021 21:29:47 +0900

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

2166번: 다각형의 면적

첫째 줄에 N이 주어진다. 다음 N개의 줄에는 다각형을 이루는 순서대로 N개의 점의 x, y좌표가 주어진다. 좌표값은 절댓값이 100,000을 넘지 않는 정수이다.

www.acmicpc.net

처음에 다각형 면적을 도대체 어떻게 구해야하는지 어리둥절했었는데 공식을 알고나서 매우 쉽다는 것을 알았다.

https://ko.wikihow.com/%EB%8B%A4%EA%B0%81%ED%98%95-%EB%84%93%EC%9D%B4-%EA%B5%AC%ED%95%98%EA%B8%B0

다각형 넓이 구하기

다각형의 넓이를 계산하는 일은 정삼각형 넓이를 구하는 것처럼 간단하기도 하지만 각 변의 길이가 다른 11각형의 넓이를 구하는 것처럼 복잡하기도 합니다. 다양한 다각형의 넓이를 구하는 방

ko.wikihow.com

이 글이 한줄기 빛과 같았다.

공식을 코드로 작성해서 쉽게 풀었다.

import sys
n = int(sys.stdin.readline())
arr = [list(map(int, sys.stdin.readline().split())) for _ in range(n)]
arr.append(arr[0])
x = 0
y = 0
for i in range(n):
    x += arr[i][0] * arr[i+1][1]
    y += arr[i][1] * arr[i+1][0]
result = round((x - y)/2, 1)
if result < 0:
    result *= -1
print(result)

~~(주석이 없는 나의 상당히 불친절한 코드)~~

사실 설명할만한 부분이 없다........

다만 결과값이 음수로 나오는 경우가 있어서(예시에 나온 테스트 케이스) 그런 부분을 처리해주기 위해서

음수의 결과는 양수로 바꾸어서 출력했다.

솔직히 골드난이도의 문제라고 보기 어려웠다.

[백준] 나이순 정렬 (10814번 파이썬)

$hineild — Fri, 16 Jul 2021 16:58:34 +0900

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

10814번: 나이순 정렬

온라인 저지에 가입한 사람들의 나이와 이름이 가입한 순서대로 주어진다. 이때, 회원들을 나이가 증가하는 순으로, 나이가 같으면 먼저 가입한 사람이 앞에 오는 순서로 정렬하는 프로그램을

www.acmicpc.net

이번 문제도 나는

2021.07.15 - [Coding Test/Algorithm] - [백준] 단어정렬 (1181번 파이썬)

[백준] 단어정렬 (1181번 파이썬)

https://www.acmicpc.net/problem/1181 1181번: 단어 정렬 첫째 줄에 단어의 개수 N이 주어진다. (1 ≤ N ≤ 20,000) 둘째 줄부터 N개의 줄에 걸쳐 알파벳 소문자로 이루어진 단어가 한 줄에 하나씩 주어진다. 주..

shineild-security.tistory.com

이 문제를 풀었을 때와 비슷하게 풀었다.

같은 나이는 먼저 입력받은 순서로 출력해야하는 조건때문에 이런식으로 풀었다.

import sys
arr = [[] for _ in range(201)]
n = int(sys.stdin.readline())
for i in range(n):
    age, name = sys.stdin.readline().rstrip().split()
    age = int(age)
    arr[age].append(name)
for i in range(len(arr)):
    if len(arr[i]) > 0:
        for k in arr[i]:
            print(i, k)

그래서 이러한 코드를 작성하게 되었다.

[백준] 단어정렬 (1181번 파이썬)

$hineild — Thu, 15 Jul 2021 06:02:02 +0900

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

1181번: 단어 정렬

첫째 줄에 단어의 개수 N이 주어진다. (1 ≤ N ≤ 20,000) 둘째 줄부터 N개의 줄에 걸쳐 알파벳 소문자로 이루어진 단어가 한 줄에 하나씩 주어진다. 주어지는 문자열의 길이는 50을 넘지 않는다.

www.acmicpc.net

이번 문제는 생각을 좀 하게 만든 문제였다.

~~하지만 여전히 가볍게 풀었다 음하하하~~

입력 조건을 보면 문자열의 길이가 최대 50개라고 한다.

나는 어렵게 정렬하기보다는 다른 문제를 풀때 방문한 좌표를 저장하는 스킬을 응용해서 풀었다.

길이가 50인 배열을 만들고 입력받은 문자열의 길이에 해당하는 인덱스에 해당 문자열을 넣었다.

word = sys.stdin.readline().rstrip()
    l = len(word)
    if word not in arr[l]:
        arr[l].append(word)

여기섯 if를 써서 not in을 쓴 이유는 같은 문자열을 입력받았을때는 무시하라고 조건에 적혀있기 때문이였다.

이렇게 해서 입력을 받으면 같은 길이의 문자열들은 arr[i]을 했을때 길이값이 2이상이 나온다.

그 점을 이용해서 중복된 길이의 문자열들을 따로 정렬해주는 코드를 짰다.

for c in arr:
    l = len(c)
    if l > 1:
        c = sorted(c)
        for k in c:
            print(k)
    elif l == 1:
        print(c[0])

2개 이상은 정렬해서 출력

1개는 바로 출력해주면 완성!

~~님들은 arr.sort(key=len) 쓰세요...~~