1. useEffect?

  - React Hook의 한 종류, side effect를 처리하기 위하여 사용한다.

  - useState처럼 state 변경이 감지되면 리렌더링을 하는 사이드 이펙트를 처리하기 위하여 사용한다.

  - 리랜더링과 무관한 작업, 데이터 비동기 호출 등의 기능을 구현할 때 사용한다.

  - ** useEffect는 콜백함수와 deps가 있던 없던, 랜더링 된 후 최초 1번만 실행된다.

 

2. 사용법과 동작방식

  - 콜백함수와 deps가 모두 있을 때

useEffect(()=>{.. }, deps)

  > deps(=의존성 배열)의 값이 변경될 때를 감지하여, 콜백함수를 실행한다.

 

  - deps가 없을 때 

useEffect(()=>{.. })

  > 모든 변경을 감지하여 실행한다.

 

  - deps가 빈 배열 [] 일때

useEffect(()=>{.. }, [])

  > 한번만 실행되고, 그 이후 전혀 실행되지 않음.

 

3. 예제

import "./App.css";
import Viewer from "./components/Viewer";
import Controller from "./components/Controller";
import { useEffect, useState } from "react";

function App() {
  const [count, setCount] = useState(0);
  const [input, setInput] = useState("");
  
  useEffect(() => {
    console.log(`count: ${count} / input: ${input}`);
  }, [count, input]); // 의존성 배열, deps(=dependency array)
  
  const onClickButton = (value) => {
    setCount(count + value);
    console.log(count); // 이전의 값이 출력되므로 여기다가 사용하면 안됨, useEffect를 통해서 변경된 스테이트 값을 이용해야함
  };

  return (
    <div className="App">
      <h1>Simple Counter</h1>
      <section>
        <input value={input} onChange={(e)=>{
          setInput(e.target.value);
        }} />
      </section>
      <section>
        <Viewer count={count} />
      </section>
      <section>
        <Controller onClickButton={onClickButton} />
      </section>
    </div>
  );
}

export default App;

1. Pod

  - Pod는 Kubernetes의 기본적인 배포 단위, 하나 이상의 container를 포함

  - Pod가 포함하는 container의 종류 (=설계 패턴)

    a. 실제 애플리케이션을 수행하는 runtime container

    b. 기동 시점에 처리(=환경셋팅)하고 종료되는 init container

    c. 보조 역할로써 배포되는 sidecar container

 

2. Pod의 장점

    - Pod 내부에는 자원(네트워크, 스토리지)을 공유하는 프로세스를, 여러 개의 container로 실행할 수 있음

    - Pod 내부의 프로세스(=컨테이너)들은 서로 접근가능

 

3. Pod Network

  3-1. Container to Container network

    a. 동일한 Pod에 있는 여러 컨테이너들은 network namespace 공유

    b. Pause container에 의해 공유되어 localhost 및 port 통신 가능

    c. 동일한 Pod의 각 컨테이너에는 포트 충돌을 방지하기 위해 고유한 통신 포트가 존재

 

  3-2.  Pod to Pod network

    a. 모든 Pod는 IP 주소(eth0)와 network namespace가 있고, Pod to Pod를 연결할 수 있는 가상 이더넷(calico 제공,       

        tunl0) 연결이 있어서 Pod(eth0) to Pod(eth0) 연결이 가능

 

  3-3. Node to Node network

 

    a. Cluster는 대부분 Node에 할당된 IP 주소가 포함된 정보를 Routing Table을 저장

    b. Routing Table은 bridge가 요청을 해결할 수 없을 때, 연결된 Node에 대해 IP 주소를 확인

    c. 일치하는 network 콘텐츠는 적절한 Node에 연결되고 연결은 Node 수준에서 지속됨

1. 핵심 내용

  - 별이 가장 첫 줄에는 1개 / 2번째 ~ (N - 1)번째는 2개 / 마지막 줄에는 2*N - 1개만큼 찍혀야한다.

  - N - i - 1 개만큼 공백히 찍힌 후에, 첫번째 별이 찍힌다.

  - 첫번째 별이 찍힌 이후, 그 다음 공백(=별 사이 공백)의 수는 2 * i - 1 개이다.

  - 두번째 별이 찍힌다.

  - 가장 마지막 라인은 2 * N - 1개만큼 별이 찍히고 프로그램이 종료된다.

 

import sys
input = sys.stdin.readline

N = int(input())
for i in range(N):
    for _ in range(N - i - 1):
        print(" ", end="")
    print("*", end="")
    if i == 0:
        print()
    elif i == N - 1:
        print("*" * (2*N - 2))
        print()
    else:
        for _ in range(2*i - 1):
            print(" ", end="")
        print("*")

1. 핵심 내용

  - 여러 변수 동시 비교 가능 : A == B == C == 0 와 같이 동시 비교 가능

  - 삼각형에서 짧은 두 변의 합 : (A + B + C) - max(A, B, C)

 

import sys
input = sys.stdin.readline

while True:
    A, B, C = map(int, input().split())
    if A == B == C == 0:
        break
    if max(A, B, C) >= A + B + C - max(A, B, C):
        print("Invalid")
    elif A == B == C:
        print("Equilateral")
    elif A == B or B == C or A == C:
        print("Isosceles")
    else:
        print("Scalene")

 

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

2 초 128 MB 80489 51661 45500 64.337%

문제

한수는 지금 (x, y)에 있다. 직사각형은 각 변이 좌표축에 평행하고, 왼쪽 아래 꼭짓점은 (0, 0), 오른쪽 위 꼭짓점은 (w, h)에 있다. 직사각형의 경계선까지 가는 거리의 최솟값을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 x, y, w, h가 주어진다.

출력

첫째 줄에 문제의 정답을 출력한다.

제한

  • 1 ≤ w, h ≤ 1,000
  • 1 ≤ x ≤ w-1
  • 1 ≤ y ≤ h-1
  • x, y, w, h는 정수

예제 입력 1 복사

6 2 10 3

예제 출력 1 복사

1

예제 입력 2 복사

1 1 5 5

예제 출력 2 복사

1

예제 입력 3 복사

653 375 1000 1000

예제 출력 3 복사

347

예제 입력 4 복사

161 181 762 375

예제 출력 4 복사

161

출처

알고리즘 분류

메모

1. 현재 위치에서 직사각형의 각 변에 수선을 내렸을 때의 최소거리를 구하면 된다.

2. 즉 x, y, w-x, h-y 중 가장 작은 값을 선정하면 된다.

3. 2.에서 각 거리는 0보다 커야한다. 제한조건을 보면 x>0, y>0, w-x>0, h-y>0을 모두 만족한다.

( x<w는 x <= w-1 과 같고, y<h는 y<=h-1과 같다.)

 

풀이

x, y, w, h = map(int, input().split())
list = [x, y, h-y, w-x]
print(min(list))

 

특정 거리의 도시 찾기

 

어떤 나라에는 1번부터 N번까지의 도시와 M개의 단방향 도로가 존재한다. 모든 도로의 거리는 1이다.

이 때 특정한 도시 X로부터 출발하여 도달할 수 있는 모든 도시 중에서, 최단 거리가 정확히 K인 모든 도시들의 번호를 출력하는 프로그램을 작성하시오. 또한 출발 도시 X에서 출발 도시 X로 가는 최단 거리는 항상 0이라고 가정한다.

예를 들어 N=4, K=2, X=1일 때 다음과 같이 그래프가 구성되어 있다고 가정하자.

 

이 때 1번 도시에서 출발하여 도달할 수 있는 도시 중에서, 최단 거리가 2인 도시는 4번 도시 뿐이다.  2번과 3번 도시의 경우, 최단 거리가 1이기 때문에 출력하지 않는다.

입력

첫째 줄에 도시의 개수 N, 도로의 개수 M, 거리 정보 K, 출발 도시의 번호 X가 주어진다. (2 ≤ N ≤ 300,000, 1 ≤ M ≤ 1,000,000, 1 ≤ K ≤ 300,000, 1 ≤ X ≤ N) 둘째 줄부터 M개의 줄에 걸쳐서 두 개의 자연수 A, B가 공백을 기준으로 구분되어 주어진다. 이는 A번 도시에서 B번 도시로 이동하는 단방향 도로가 존재한다는 의미다. (1 ≤ A, B ≤ N) 단, A와 B는 서로 다른 자연수이다.

출력

X로부터 출발하여 도달할 수 있는 도시 중에서, 최단 거리가 K인 모든 도시의 번호를 한 줄에 하나씩 오름차순으로 출력한다.

이 때 도달할 수 있는 도시 중에서, 최단 거리가 K인 도시가 하나도 존재하지 않으면 -1을 출력한다.

예제 입력 1 복사

4 4 2 1
1 2
1 3
2 3
2 4

예제 출력 1 복사

4

예제 입력 2 복사

4 3 2 1
1 2
1 3
1 4

예제 출력 2 복사

-1

예제 입력 3 복사

4 4 1 1
1 2
1 3
2 3
2 4

예제 출력 3 복사

2
3

출처

 

1. 풀이

# 백준 18352
# https://www.acmicpc.net/problem/18352
from collections import deque
import sys
f = sys.stdin.readline

n, m, k, x = map(int, f().split())
graph = [[] for _ in range(n+1)]   # 인접 노드 표현 2차원 그래프
distance = [0] * (n+1)             # 노드 까지의 누적거리
visited = [False] * (n+1)          # 노드 방문여부

for _ in range(m):
    a, b = map(int, f().split())
    graph[a].append(b)             # a에 인접한 노드 설정(=b)
print(distance)
print(visited)
print(graph)

def bfs(start):
    answer = []
    q = deque([start])             # 시작할 노드를 큐에 넣고
    visited[start] = True          # 시작노드 방문 처리
    distance[start] = 0            # 시작할 노드는 자기 자신이므로 0으로 거리 초기화
    while q:
        now = q.popleft()          # now번째부터 인접 노드 모두 확인
        for i in graph[now]:       # now번째 간선과 인접한 모든 노드 확인
            if not visited[i]:                    # 인접한 노드 중 방문하지 않은 노드일 경우
                visited[i] = True                 # 방문처리
                q.append(i)                       # q에 인접노드 넣기 > 다시 재시작하기위해
                distance[i] = distance[now] + 1   # 인접노드까지 누적된 거리
                if distance[i] == k:              # 누적거리가 k일 경우
                    answer.append(i)
    if len(answer) == 0:
        print(-1)
    else:
        answer.sort()              # 오름차순 정렬
        for i in answer:
            print(i, end='\n')     # 개행하지 않고 print

bfs(x)

 

2. 메인 아이디어 및 풀이 절차

    1) 인접 노드 그래프를 표현할 graph와, 노드까지의 누적거리 distance, 노드 방문 여부 visited 리스트를 만든다.

    2) deque를 활용하여 popleft()로 꺼낸 노드부터 시작하여 인접노드를 모두 방문처리

    3) 방문처리 후 해당 노드를 큐에 넣어서, 다시 출발할 시작점을 만듬

    4) 누적거리가 k에 해당하는 모든 노드를 answer 리스트에 넣음

    5) answer를 오름차순으로 정렬하여 정답을 낸다.

    

출처: https://www.acmicpc.net/problem/18352

# dfs는 재귀적으로 상하좌우 계속 방문한다 모두 방문 하면 +1

# 00110
# 00011
# 11111
# 00000

def dfs(x, y):
    # 주어진 범위를 벗어나는 경우 즉시 종료
    if x<=-1 or x>=n or y<=-1 or y>=m:
        return False
    # 아직 방문하지 않았다면
    if graph[x][y] == 0:
        # 방문 처리
        graph[x][y] = 1
        # 현재 위치로부터 좌상우하 위치들도 모두 재귀적으로 호출
        dfs(x-1,y)
        dfs(x,y-1)
        dfs(x+1,y)
        dfs(x,y+1)
        return True # 모두 방문했으면 True (아이스크림이 1 덩이 만들어 졌을시점)
    return False


n, m = map(int, input().split()) # 행, 열 받고
graph = []
for i in range(n):
    graph.append(list(map(int, input()))) # 행 만큼 리스트 넣음
cnt = 0
for i in range(n):
    for j in range(m):
        if dfs(i, j) == True:
            print(i, j)
            cnt += 1 # 아이스크림 1덩이 만들어질 때마다 ++1
print(cnt) # 결과

출처: https://www.youtube.com/watch?v=PqzyFDUnbrY&list=PLRx0vPvlEmdBFBFOoK649FlEMouHISo8N&index=3

 

# 최단 거리 문제는 BFS로 푼다
# 가장 가까운 노드부터 차례대로 방문
# 이전 거리에 +1하면서 최단거리 구함

# 1)
# 1 1 0
# 0 1 0
# 0 1 1

# 2)
# 1 (2) 0 +1
# 0  1  0
# 0  1  1

# 3)
# 1  2  0
# 0 (3) 0 +1
# 0  1  1

# 4)
# 1  2  0
# 0  3  0
# 0 (4) 1 +1

# 3)
# 1 2  0
# 0 3  0
# 0 4 (5) +1 ==> 최단거리는 5
from collections import deque

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 queue[nx][ny] == 0:
                continue
            if queue[nx][ny] == 1:
                queue[nx][ny] = queue[x][y] + 1
                queue.append((nx, ny))
    return graph[n-1][m-1] # 우측 맨 하단, 마지막 값

n, m = map(int, input().split())
graph = []
for i in range(n):
    graph.append(list(map(int, input())))
# 상하좌우
dx = [0,0,-1,1]
dy = [-1,1,0,0]

print(bfs(0,0))

출처 : https://www.youtube.com/watch?v=PqzyFDUnbrY&list=PLRx0vPvlEmdBFBFOoK649FlEMouHISo8N&index=3

Task description

 

A small frog wants to get to the other side of the road. The frog is currently located at position X and wants to get to a position greater than or equal to Y. The small frog always jumps a fixed distance, D.

Count the minimal number of jumps that the small frog must perform to reach its target.

Write a function:

class Solution { public int solution(int X, int Y, int D); }

that, given three integers X, Y and D, returns the minimal number of jumps from position X to a position equal to or greater than Y.

For example, given:

X = 10 Y = 85 D = 30

the function should return 3, because the frog will be positioned as follows:

  • after the first jump, at position 10 + 30 = 40
  • after the second jump, at position 10 + 30 + 30 = 70
  • after the third jump, at position 10 + 30 + 30 + 30 = 100

Write an efficient algorithm for the following assumptions:

  • X, Y and D are integers within the range [1..1,000,000,000];
  • X ≤ Y.
Copyright 2009–2023 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
 
class Solution {
    public int solution(int X, int Y, int D) {
        // 점프 횟수 jmpCnt = Math.ceil(가야할 거리 / D)
        // 예를들어 3.5번을 뛰어야한다면, Y와 같아지지도 않을 뿐더러
        // 한번더 뛰어서 4번을 뛰어야만 Y이상이 되기 때문
        int dist = Y - X;
        if(dist<=0) return 0;
        return (int) Math.ceil((double) dist / D);
    }
}

 

1. 풀이 전략

  1) 반복문으로 코딩하면, 점프횟수가 매우 클 경우(1~10억의 범위) runtime error가 발생함

  2) O(1)의 시간 복잡도로 해결

  3) 결국 점프횟수는 가야할거리 / D를 무조건 올린 수 이다.

      (예를들어 3.5번 점프해야한다면, 1번을 더 점프해서 4번을 점프해야, Y 이상이 되기 때문)

  4) Math.ceil() 함수는 위 코드에서 double타입으로 리턴하기 때문에, (int)로 casting해서 결과값을 리턴한다.

'코딩 테스트 > Codility' 카테고리의 다른 글

Codility - OddOccurrencesInArray  (0) 2023.03.26
Codility - CyclicRotation  (0) 2023.03.26
Codility - BinaryGap  (0) 2023.03.25

Task description

 

A non-empty array A consisting of N integers is given. The array contains an odd number of elements, and each element of the array can be paired with another element that has the same value, except for one element that is left unpaired.

For example, in array A such that:

A[0] = 9 A[1] = 3 A[2] = 9 A[3] = 3 A[4] = 9 A[5] = 7 A[6] = 9
  • the elements at indexes 0 and 2 have value 9,
  • the elements at indexes 1 and 3 have value 3,
  • the elements at indexes 4 and 6 have value 9,
  • the element at index 5 has value 7 and is unpaired.

Write a function:

class Solution { public int solution(int[] A); }

that, given an array A consisting of N integers fulfilling the above conditions, returns the value of the unpaired element.

For example, given array A such that:

A[0] = 9 A[1] = 3 A[2] = 9 A[3] = 3 A[4] = 9 A[5] = 7 A[6] = 9

the function should return 7, as explained in the example above.

Write an efficient algorithm for the following assumptions:

  • N is an odd integer within the range [1..1,000,000];
  • each element of array A is an integer within the range [1..1,000,000,000];
  • all but one of the values in A occur an even number of times.
Copyright 2009–2023 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
 
import java.util.Set;
import java.util.HashSet;

class Solution {
    public int solution(int[] A) {
        Set<Integer> set = new HashSet<>();
        for(int num : A) {
            if(set.contains(num)) {
                set.remove(num);
            }else {
                set.add(num);
            }
        }
        return set.iterator().next();
    }
}

 

1. 풀이 전략

  1) 짝을 이루지 않는 수(1개만 있는)를 리턴해야 한다.

  2) A의 원소 값을 가지는 새로운 배열을 만들고, A의 값이 새로운 배열의 인덱스가 될 수 있는지 판단한다.

  3) 문제에서 A의 값이 될 수 있는 원소는 10억까지로 매우 크기 때문에, 2)의 방법은 옳지않다.

  4) Java에서 중복값을 허용하지 않는 Set Collection을 사용하여 문제를 해결한다.

  5) set을 instance화 하여, A 배열에 담겨있는 값을 하나씩 저장한다. 그러나, 이미 포함되어 있으면 제거한다.

  6) 결국 set에는 짝을 이루지 않는 단 하나의 요소만 저장이 된다.

      (set.contains(value)에 걸렸던 값은 set에서 아예 제거되므로)

  7) set.iterator().next()를 통해 단 하나의 짝을 이루지 않는 값을 리턴한다.

 

출처 : Codility (https://app.codility.com/programmers)

'코딩 테스트 > Codility' 카테고리의 다른 글

Codility - FlogJmp  (0) 2023.03.26
Codility - CyclicRotation  (0) 2023.03.26
Codility - BinaryGap  (0) 2023.03.25

+ Recent posts