척척석사의 코딩기록

간단한 일차방정식의 꼴을 준 뒤, 초기값의 궤도가 그 이후와 일치하는가? 라는 것을 물어보는 문제가 되겠다.

즉, 어떤 함수 f(x) = ax + b가 주어져있을 때

초기값을 x_0 이라고 하고, i+1번째 항을 x_i로 둔다면

x_i = f(x_{i-1}) = f(f(x_{i-2})) = .... = f .... f(x_0) 꼴인가? 라는 것을 묻는 문제가 되겠습니다.

그리고 이에 해당하는 코드는 아래와 같습니다.

N = int(input())
num = list(map(int,input().split()))

def f(num):
    if len(num) == 1:
        return "A"
    else:
        ans = []
        for a in range (-200,201):
            b = num[1] - (a * num[0])
            jud = True
            for i in range (1, N):
                if a * num[i-1] + b != num[i]:
                    jud = False
                    break
            if jud == True:
                ans.append(a * num[-1] + b)
        ans = list(set(ans))
        if len(ans) == 1:
            return ans[0]
        elif len(ans) > 1:
            return "A"
        elif len(ans) == 0:
            return "B"
print(f(num))

먼저, 선릉역에 있는 크라우드웍스에서 2달간 계약직으로 근무 했습니다.

4/1~5/31까지 근무했네요.

근무 내용은 수학 문제 제작 및 Raw 데이터 관리, 데이터 라벨링이 되겠습니다만

수학 문제 제작은 못하고 데이터 라벨링과 관리쪽 업무를 진행하다가 온 것 같습니다.

첫번째 사회경험인만큼 먼저 회사 생활 어떻게 해야하는가? 에 대한 것을 집중적으로 생각해봤던 것 같습니다.

회사 업무에서 가장 힘든 것이 업무 강도라던지 업무 내용인 것도 있겠지만, 대인관계가 어떻게 형성되는가가 제일 중요한 것 같았습니다.

이에 많은 것들을 고민하면서 업무에 임했던 것 같습니다.

다음으로 회사 분위기에 대한 생각을 하게된 것 같습니다. 계약직 포지션인 것도 있으며 휴게실 옆에 딸린 소회의실을 근무공간으로 사용했던지라 회사의 전반적인 분위기를 느끼기에는 좋았던 것 같습니다.

일단, 소위 젊다고 느껴지는 20~30정도의 연령대의 분들이 많이 계셔서, 회사 자체가 액티브한 느낌은 굉장히 많이 들었습니다.

유동적으로 상황에 맞게 잘 흘러가는 부분이 많은 것 같습니다.

일하면서 느꼈던 것... 정말, 사람이 중요하구나 라는 것을 많이 느꼈던 것 같습니다.

정말 일을 쉬지 않고 했었는데, 그럼에도 불구하고 즐겁게 근무할 수 있었던 것은 좋은 분들과 많이 만날 수 있었던 것때문이라고 생각합니다.

물론 잘 안 맞는 분도 있었지만, 그래도 커뮤니케이션을 취하면서 열심히 프로젝트 목표를 달성하려고 노력했던 것 같습니다.

마지막으로 ... 회사 입지는 나쁘지 않았던 것 같습니다. 먼저 본가가 분당인지라 선릉까지 수인분당선 한번에 갈 수 있었던 장점이 있었던 것 같고, 내려서도 10분 이내로 갈 수 있었던 것 같아요.

주변에 먹을만한 식당도 많이 있지만 ... 밖에 나가서 먹는 것은 금새 질릴 것 같네요.

아무래도 식당가가 진짜 많은 동네랑은 역을 끼고 맞은편에 있다보니 ....

다시 한국 취준을 목표로 열심히 달려봐야겠습니다.

그러면서 코딩, 프로젝트 열심히 해봐야겠어요.

화이팅 !

2개의 누적합을 얼마나 잘 쓸 수 있겠니? 라는 문제인데

사실 누적합과 딕셔너리만 있어도 풀 수 있는 문제 같다

(키워드에는 이분 탐색이 있길래...)

물론, 이분 탐색을 통해서 빠르게 값을 찾아내는 것도 중요하겠다.

대신 이 경우에는 딕셔너리가 아닌 값을 사용해야겠지만 ...

답안 코드는 아래와 같다

from collections import defaultdict
T = int(input())
N = int(input())
A = list(map(int,input().split()))
M = int(input())
B = list(map(int,input().split()))


psum_A = [0 for _ in range (0,N+1)]
psum_B = [0 for _ in range (0,M+1)]
for i in range (1,N+1):
    psum_A[i] = psum_A[i-1] + A[i-1]
for i in range (1,M+1):
    psum_B[i] = psum_B[i-1] + B[i-1]

partial_sum_A = defaultdict(int)
partial_sum_B = defaultdict(int)

for i in range (1, N+1):
    for j in range (0,i):
        partial_sum_A[psum_A[i] - psum_A[j]] += 1

for i in range (1, M+1):
    for j in range (0,i):
        partial_sum_B[psum_B[i] - psum_B[j]] += 1

pnum_A = list(partial_sum_A.keys())
pnum_A.sort()
cnt = 0

for i in range (0,len(pnum_A)):
    target = T - pnum_A[i]
    if target in partial_sum_B:
        cnt += partial_sum_A[pnum_A[i]] * partial_sum_B[target]
print(cnt)

수의 이진표현에 대한 문제가 되겠다.

import math
a,b = map(int,input().split())

def f(a,b):
    if a == 0 and b == 0:
        return -1
    elif a == 0 and b != 0:
        return "-"
    elif a == 1 and b == 1:
        return "*"
    #이제 비트마스킹을 활용해야함
    else:
        for i in range (1,64):
            t = a * ((2 ** i) - 1) // b
            if b * t == a * ((2 ** i) - 1):
                x = format(t, 'b') #주어진 숫자를 2진수로 변환해야할 필요가 있음
                if i >= len(x):
                    new_x = "0" * (i - len(x)) + x
                    ans = ""
                    for j in range (0,i):
                        if new_x[j] == "0":
                            ans += "-"
                        else:
                            ans += "*"
                    if len(ans) >= 61:
                        return -1
                    return ans
        return -1
print(f(a,b))

재밌는 문제였던 것 같다.

N = int(input())
R = N // 2 #반지름이 되겠다
def f(n):
    x,y = 0,n-1
    cnt = 0
    dx,dy = [1,0,1], [0,-1,-1]
    while x != y:
        for i in range (0,3):
            xx,yy = x + dx[i], y + dy[i]
            if xx ** 2 + yy ** 2 < n ** 2 and (xx + 1) ** 2 + (yy + 1) ** 2 > n ** 2:
                cnt += 1
                x,y = xx, yy
                break
    return 8 * cnt + 4
print(f(R))

반지름을 어떻게 활용할지에 대한 중요한 문제가 될 것 같다.

그래프이론을 좀 더 공부해보다가 이런 문제를 발견해서 바로 덥석 풀어봤는데 생각보다 걸리긴했네요.

from collections import deque
import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.readline

N, L, R = map(int, input().split())
graph = []
for _ in range (0,N):
    a = list(map(int,input().split()))
    graph.append(a)

#L이상 R이하인 경우에는 모두 열림
dx,dy = [0,0,1,-1],[1,-1,0,0]
def bfs(mapp,cnt):
    visited = [[False for _ in range(0, N)] for _ in range(0, N)]
    pt = []
    for i in range (0,N):
        for j in range (0,N):
            for k in range (0,4):
                ii = i+dx[k]
                jj = j+dy[k]
                if 0 <= ii < N and 0 <= jj < N and L <= abs(mapp[ii][jj] - mapp[i][j]) <= R:
                    pt.append([i,j])
    if len(pt) == 0:
        return cnt
    ptt = []
    for x in pt:
        if visited[x[0]][x[1]] == False:
            deq = deque()
            deq.append(x)
            cnting = 0
            summary = 0
            pts = []
            while deq:
                z = deq.popleft()
                xx,yy = z[0], z[1]
                if visited[xx][yy] == False:
                    pts.append([xx,yy])
                    summary += mapp[xx][yy]
                    cnting += 1
                    visited[xx][yy] = True
                    for i in range (0,4):
                        a,b = xx + dx[i], yy + dy[i]
                        if 0 <= a < N and 0 <= b < N and L <= abs(mapp[a][b] - mapp[xx][yy]) <= R and visited[a][b] == False:
                            deq.append([a,b])
            ptt.append([pts, summary, cnting])
    for y in ptt:
        pts = y[0]
        t = int(y[-2] / y[-1])
        for pt in pts:
            aa,bb = pt[0],pt[1]
            mapp[aa][bb] = t
    return bfs(mapp, cnt + 1)

t = bfs(graph, 0)
print(t)

5월로 계약직으로 일하는곳도 종료되는만큼, 프로그래밍에도 좀 더 신경을 써보고자 한다.

생각보다는 쉽게 풀었던 문제인데, 

from collections import deque
N = int(input())
gp = [[] for _  in range (0,N+1)]
for _ in range (0,N-1):
    a,b = map(int,input().split())
    gp[a].append(b)
    gp[b].append(a)
depth = [[] for _ in range (0,N+1)]
depth[1] = (1,1)
deq = deque()
check = [False for _ in range (0,N+1)]
new_graph = [[] for _ in range (0,N+1)]
deq.append((1,1))
while deq:
    x = deq.popleft()
    x,y = x[0], x[1]
    check[x] = True
    for z in gp[x]:
        if check[z] == False:
            deq.append((z,y + 1))
            new_graph[x].append((z,y+1))
            
ans = [0 for _ in range (0,N+1)]

for i in range (0,N+1):
    if new_graph[i] != []:
        for x in new_graph[i]:
            ans[x[0]] = i

for i in range (2,N+1):
    print(ans[i])

말이 어렵게 쓰여있지만, 결국 해답은 뭐냐면 

다각형의 세 점을 이어서 만들 수 있는 삼각형 중 가장 넓이가 큰 것을 찾으시오 라는 문제가 되겠습니다.

여기서, 아이디어로서 사용되는 것은 신발끈 정리입니다.

https://ko.wikipedia.org/wiki/%EC%8B%A0%EB%B0%9C%EB%81%88_%EA%B3%B5%EC%8B%9D

좌표 평면에 점의 좌표가 주어져 있을 때 다각형의 넓이를 구할 수 있게 도와주는 공식이예요.

이를 활용해 아래와 같이 코드를 짤 수 있겠습니다.

def area의 부분이 넓이를 구하는 함수가 되겠습니다.

from itertools import combinations
import math
def area(a,b,c):
    x1,y1 = a[0],a[1]
    x2,y2 = b[0],b[1]
    x3,y3 = c[0],c[1]
    return int(math.fabs(x1*y2 + x2*y3 + x3*y1 - x2*y1 - x3*y2 - x1*y3)) * 1/2
ans = -1
N = int(input())
pts = []
for _ in range (0,N):
    pt = list(map(int,input().split()))
    pts.append(pt)

for t in combinations(pts,3):
    t = list(t)
    a,b,c = t[0],t[1],t[2]
    ans = max(ans, area(a,b,c))
print(ans)

from collections import defaultdict
import sys
input = sys.stdin.readline
N,M = map(int,input().split())
cnt = defaultdict(int)
length = defaultdict(int)
for _ in range (0,N):
    a = input().rstrip()
    if len(a) >= M:
        cnt[a] += 1
        length[a] = len(a)
words = []
dd =  list(cnt.keys())
for word in dd:
    words.append([word, cnt[word], length[word]])

words.sort(key = lambda x:(-x[1],-x[2],x[0]))
for word in words:
    print(word[0])

문자열 정렬을 어떤 우선순위에 따라서 둘 것인지 확인해야할 필요가 있습니다.

key = lambda의 사용법을 익히기에 좋을 것 같습니다.

import sys
sys.setrecursionlimit(10000)

N,M = map(int,input().split())
x,y,di = map(int,input().split())
mapp = []
for _ in range (0,N):
    a = list(map(int,input().split()))
    mapp.append(a)

direction =[[-1,0],[0,1],[1,0],[0,-1]]
check = [[False for _ in range (0,M)] for _ in range (0,N)]
#di는 방향을 나타내고 있는 것
    
def algo(x,y,di):
    cnt = 0
    while True:
        if mapp[x][y] == 0 and check[x][y] == False:
            cnt += 1
            check[x][y] = True
    #첫번째 스텝에서 진행하는 자리가 더러우면 청소하는 경우
    #자신의 4방향 탐지하기
        jud = True
        for i in range (1,5):
        #반시계방향부터 탐색한다는 것에 유의
            t = (di - i) % 4
            xx = x + direction[t][0]
            yy = y + direction[t][1]
            if 0 <= xx < N and 0 <= yy < M:
                if mapp[xx][yy] == 0 and check[xx][yy] == False:
                    jud = False
                    x,y,di = xx,yy,t
                    break
        if jud == True:
            a = x - direction[di][0]
            b = y - direction[di][1]
            if mapp[a][b] == 1 or (0 > a or a == N or 0 > b or M == b):
                print(cnt)
                return
            x,y = a,b        
algo(x,y,di)

시간이 좀 오래 걸렸던 문제 ... 다 짜놓고서 이상한 곳에서 뻘짓을 많이했던 기억이 ....