def distance(x1, y1, x2, y2, r_squared):
    dist_sq = (x2 - x1) ** 2 + (y2 - y1) ** 2
    return dist_sq <= r_squared

def solve():

    N, R, D, X, Y = map(int, input().split())

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

    v = [False] * (N + 1)
    
    q = deque([(X, Y, 0)])
    
    result = 0.0
    
    r_sq = R * R

    while q:
        cur_x, cur_y, count = q.popleft()

        for i in range(1, N + 1):
            target_x, target_y = graph[i]

            if not v[i] and distance(cur_x, cur_y, target_x, target_y, r_sq):
                v[i] = True

                result += (D / (2 ** count))
                
                q.append((target_x, target_y, count + 1))

    print(result)
solve()

N, M = map(int, input().split())
grid = [list(input().strip()) for _ in range(M)]
visited = set()

dxy = [(-1, 0), (1, 0), (0, -1), (0, 1)]

def bfs(x, y, team):
    q = deque([(x, y)])
    visited.add((x, y))
    count = 1
    
    while q:
        x, y = q.popleft()
        
        for dx, dy in dxy:
            nx, ny = x + dx, y + dy
            
            if not(0 <= nx < M and 0 <= ny < N):
                continue
            if (nx, ny) in visited:
                continue
            if grid[nx][ny] != team:
                continue
            visited.add((nx, ny))
            q.append((nx, ny))
            count += 1
    return count

white_power = 0
blue_power = 0

for i in range(M):
    for j in range(N):
        if (i, j) in visited:
            continue
        team = grid[i][j]
        count = bfs(i, j, team)
        if team == 'W':
            white_power += count ** 2
        else:
            blue_power += count ** 2

print(white_power, blue_power)

def bfs(n):
    q = deque([1])
    while q:
        cur = q.popleft()
        for n_num in (cur * 10 + 0, cur * 10 + 1):
            if len(str(n_num)) > 100:
                continue
            
            if n_num % n == 0:
                return n_num
            q.append(n_num)

while True:
    n = int(input())
    if n == 0:
        break

    print(bfs(n))

O(2^100) (worst case, but pruned by modulo check)

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

ans = n - 2

# 모든 가능한 두 카드 조합 (i, j)에 대해 확인
for i in range(n):
    for j in range(i + 1, n):
        if (cards[j] - cards[i]) % (j - i) != 0:
            continue
        d = (cards[j] - cards[i]) // (j - i)
        cnt = 0
        
        for k in range(n):
            expected = cards[i] + (k - i) * d
            if cards[k] != expected:
                cnt += 1
        
        ans = min(ans, cnt)

print(ans)

input = sys.stdin.readline

N, M, R = map(int, input().split())

graph = [[] for _ in range(N + 1)]
for _ in range(M):
    a, b = map(int, input().split())
    graph[a].append(b)
    graph[b].append(a)

def bfs(start):
    q = deque([(start, 0)])
    visited = [-1] * (N + 1)
    visited[start] = 0
    
    while q:
        cur_node, d = q.popleft()
        for n_node in graph[cur_node]:
            if visited[n_node] != -1:
                continue
            visited[n_node] = d + 1
            q.append((n_node, d + 1))

    return visited[1:]

print(*bfs(R), sep='\n')

D, N = map(int, input().split())
oven = list(map(int, input().split()))
doughs = list(map(int, input().split()))

min_oven = oven[0]
for i in range(1, D):
    min_oven = min(min_oven, oven[i])
    oven[i] = min(oven[i], min_oven)

oven_i = D - 1
dough_i = 0

while dough_i < N:
    if oven[oven_i] < doughs[dough_i]:
        # 못들어감
        oven_i -= 1
        if oven_i < 0:
            # 다 들어갈 수 없음
            print(0)
            break
    else:
        dough_i += 1
        oven_i -= 1

else:
    print(oven_i + 2)

from collections import defaultdict, deque

N, M = map(int, input().split())

taller = defaultdict(list)
shorter = defaultdict(list)

for _ in range(M):
    a, b = map(int, input().split())
    taller[a].append(b)
    shorter[b].append(a)

def bfs(graph, start):
    visited = set()
    q = deque([start])
    while q:
        node = q.popleft()
        for n in graph[node]:
            if n not in visited:
                visited.add(n)
                q.append(n)
    return visited

result = 0
for i in range(1, N+1):
    visited_taller = bfs(taller, i)
    visited_shorter = bfs(shorter, i)
    # 앞 뒤의 키를 모두 탐색 가능할 경우
    if len(visited_taller) + len(visited_shorter) == N - 1:
        result += 1

print(result)

n, w, L = map(int, input().split())
trucks = list(map(int, input().split()))

bridge = deque([0] * w)
t = 0
cur_w = 0
i = 0

while i < n:
    t += 1
    cur_w -= bridge.popleft()
    if cur_w + trucks[i] <= L:
        bridge.append(trucks[i])
        cur_w += trucks[i]
        i += 1
    else:
        bridge.append(0)

t += w
print(t)

field = list(map(list, [input() for _ in range(12)]))

dyx = [(1, 0), (0, 1), (-1, 0), (0, -1)]

def bfs(sy, sx):
    visited = set()
    q = [(sy, sx)]
    visited.add((sy, sx))
    while q:
        y, x = q.pop(0)
        for dy, dx in dyx:
            ny, nx = y + dy, x + dx
            if not(0 <= ny < 12 and 0 <= nx < 6):
                continue
            if (ny, nx) in visited:
                continue
            
            if field[ny][nx] == field[sy][sx]:
                visited.add((ny, nx))
                q.append((ny, nx))
    
    if len(visited) >= 4:
        for y, x in visited:
            field[y][x] = '.'
        return True
    return False

cnt = 0
while True:
    is_remove = False
    for i in range(12):
        for j in range(6):
            if field[i][j] == '.':
                continue

            if bfs(i, j):
                is_remove = True

    if not is_remove:
        break

    # 블록 내리기
    for j in range(6):
        stack = []
        for i in range(11, -1, -1):
            if field[i][j] == '.':
                continue
            
            stack.append(field[i][j])
            field[i][j] = '.'
        
        i = 11
        while stack:
            field[i][j] = stack.pop(0)
            i -= 1

    cnt += 1

print(cnt)

N, M = map(int, input().split())

grid = [list(map(int, input().split())) for _ in range(N)]

dxy = ((0, 1), (0, -1), (1, 0), (-1, 0))


def bfs(x, y):
    q = deque([(x, y)])

    while q:
        x, y = q.popleft()

        for dx, dy in dxy:
            nx, ny = x + dx, y + dy

            nx %= N
            ny %= M

            if grid[nx][ny] == 1:
                continue

            grid[nx][ny] = 1
            q.append((nx, ny))

    return 1


result = 0

for x in range(N):
    for y in range(M):
        if grid[x][y] == 1:
            continue

        result += bfs(x, y)

print(result)

R, C = map(int, input().split())
grid = [list(map(int, input().split())) for _ in range(R)]

N = int(input())
dxy = [list(map(int, input().split())) for _ in range(N)]

visited = [[False] * C for _ in range(R)]

q = deque()
for i, floor in enumerate(grid[0]):
    if floor == 1:
        q.append([0, i, 0])
        visited[0][i] = True

result = -1
while q:
    x, y, t = q.popleft()
    
    if x == R - 1:
        result = t
        break
    
    for dx, dy in dxy:
        nx, ny = x + dx, y + dy
        if not(0 <= nx < R and 0 <= ny < C):
            continue
        if grid[nx][ny] == 0 or visited[nx][ny]:
            continue
        
        q.append([nx, ny, t + 1])
        visited[nx][ny] = True

print(result)

P = list(map(int, input().split()))
S = list(map(int, input().split()))

def shuffle_card(cards, S):
    new_cards = [0] * (N)
    for i, n_i in enumerate(S):
        new_cards[n_i] = cards[i]
    return new_cards

cards = P[:]
answer = [0, 1, 2] * (N // 3)
cnt = 0

while answer != cards:
    cards = shuffle_card(cards, S)
    cnt += 1

    if cards == P:
        print(-1)
        break

else:
    print(cnt)

SELECT CONCAT('/home/grep/src/', b.board_id, '/', f.file_id, f.file_name, f.file_ext) as file_path
FROM used_goods_board AS b
    JOIN
    used_goods_file AS f
    ON b.board_id = f.board_id
WHERE b.views = (SELECT MAX(views) FROM used_goods_board)
ORDER BY f.file_id DESC;

문제에서 요구한 결과를 만들기 위해 쿼리에서 실제로 쓴 것들이다.

• 테이블 1회 JOIN 으로 두 테이블을 연결
• WHERE 로 조건에 맞는 행만 남김
• ORDER BY 로 정렬 (내림차순 포함)
• 서브쿼리를 사용
• 사용한 함수: CONCAT(), MAX()

SELECT route,
    CONCAT(ROUND(SUM(d_between_dist), 1), 'km') AS total_distance,
    CONCAT(ROUND(AVG(d_between_dist), 2), 'km') AS average_distance
FROM subway_distance
GROUP BY route
ORDER BY ROUND(SUM(d_between_dist), 1) DESC;

-- SELECT route,
--     CONCAT(ROUND(SUM(d_between_dist), 1), 'km') AS total_distance,
--     CONCAT(ROUND(AVG(d_between_dist), 2), 'km') AS average_distance
-- FROM subway_distance
-- GROUP BY route
-- ORDER BY total_distance DESC;

문제에서 요구한 결과를 만들기 위해 쿼리에서 실제로 쓴 것들이다.

WITH cars_with_fee AS (
    SELECT
        c.car_id,
        c.car_type,
        FLOOR(c.daily_fee * 30 * (100 - p.discount_rate) / 100) AS fee
    FROM
        car_rental_company_car AS c
    JOIN
        car_rental_company_discount_plan AS p ON c.car_type = p.car_type
    WHERE
        c.car_type IN ('세단', 'SUV')
        AND p.duration_type = '30일 이상'
)
SELECT
    car_id,
    car_type,
    fee
FROM
    cars_with_fee
WHERE
    car_id NOT IN (
        SELECT
            car_id
        FROM
            car_rental_company_rental_history
        WHERE
            end_date >= '2022-11-01' AND start_date <= '2022-11-30'
    )
    AND fee >= 500000 AND fee < 2000000
ORDER BY
    fee DESC,
    car_type ASC,
    car_id DESC;

SELECT pd.product_code, SUM(os.sales_amount) * pd.price as sales
FROM product as pd
    JOIN
    offline_sale as os
    ON pd.product_id = os.product_id
GROUP BY pd.product_id
ORDER BY sales DESC, pd.product_code ASC

문제에서 요구한 결과를 만들기 위해 쿼리에서 실제로 쓴 것들이다.

• 테이블 1회 JOIN 으로 두 테이블을 연결
• GROUP BY 로 묶어서 집계
• ORDER BY 로 정렬 (내림차순 포함)
• 사용한 함수: SUM()

-- 사번, 성명, 평가 등급, 성과금
-- 부서 정보
-- 사원 정보
-- 사원 평가 정보
WITH avg_emp AS (
    SELECT he.emp_no, he.emp_name, he.sal,
        CASE
            WHEN AVG(hg.score) >= 96 THEN 'S'
            WHEN AVG(hg.score) >= 90 THEN 'A'
            WHEN AVG(hg.score) >= 80 THEN 'B'
            ELSE 'C'
    END AS grade
    FROM hr_employees AS he
        LEFT JOIN
        hr_grade AS hg
        ON he.emp_no = hg.emp_no
    GROUP BY he.emp_no
)

SELECT emp_no, emp_name, grade,
    CASE
        WHEN grade = 'S' THEN sal * 0.2
        WHEN grade = 'A' THEN sal * 0.15
        WHEN grade = 'B' THEN sal * 0.1
        WHEN grade = 'C' THEN 0
        ELSE NULL
    END AS bonus
FROM avg_emp
ORDER BY emp_no

WITH quarter AS (
    SELECT 
        CASE
            WHEN(QUARTER(differentiation_date)) = 1 THEN '1Q'
            WHEN(QUARTER(differentiation_date)) = 2 THEN '2Q'
            WHEN(QUARTER(differentiation_date)) = 3 THEN '3Q'
            WHEN(QUARTER(differentiation_date)) = 4 THEN '4Q'
            ELSE NULL
    END AS quarter
    FROM ecoli_data
)

SELECT quarter, COUNT(*) AS ecoli_count
FROM quarter
GROUP BY quarter
ORDER BY quarter

문제에서 요구한 결과를 만들기 위해 쿼리에서 실제로 쓴 것들이다.

-- 코드를 입력하세요
WITH rm AS (SELECT ri.rest_id,
            ri.rest_name,
            ri.food_type,
            ri.favorites,
            ri.address,
            ROUND(AVG(review_score), 2) AS score
    FROM rest_info AS ri
        JOIN
        rest_review AS rr
        ON ri.rest_id = rr.rest_id
    WHERE ri.address LIKE "서울%"
    GROUP BY ri.rest_id, RI.REST_NAME, RI.FOOD_TYPE, RI.FAVORITES, RI.ADDRESS)

SELECT *
FROM rm
ORDER BY score DESC, favorites DESC;

문제에서 요구한 결과를 만들기 위해 쿼리에서 실제로 쓴 것들이다.

WITH rare_item AS (
    SELECT it.item_id
    FROM item_info AS ii
        JOIN
        item_tree AS it
        ON ii.item_id = it.parent_item_id
    WHERE rarity = "RARE"
)

# SELECT *
# FROM rare_item

SELECT ii.item_id, ii.item_name, ii.rarity
FROM rare_item AS ri
    JOIN
    item_info AS ii
    ON ri.item_id = ii.item_id
ORDER BY ii.item_id DESC

문제에서 요구한 결과를 만들기 위해 쿼리에서 실제로 쓴 것들이다.

• 테이블 2회 JOIN 으로 두 테이블을 연결
• WHERE 로 조건에 맞는 행만 남김
• ORDER BY 로 정렬 (내림차순 포함)
• 서브쿼리를 사용

WITH max_fish AS (
    SELECT fish_type, MAX(length) AS max_length
    FROM fish_info
    GROUP BY fish_type
)

SELECT fi.id, fni.fish_name, fi.length
FROM fish_info fi
JOIN 
    max_fish mf
    ON fi.fish_type = mf.fish_type AND fi.length = mf.max_length
JOIN 
    fish_name_info fni
    ON fi.fish_type = fni.fish_type
ORDER BY 
    fi.id;

문제에서 요구한 결과를 만들기 위해 쿼리에서 실제로 쓴 것들이다.

• 테이블 2회 JOIN 으로 두 테이블을 연결
• GROUP BY 로 묶어서 집계
• ORDER BY 로 정렬
• 서브쿼리를 사용
• 사용한 함수: MAX()

SELECT e1.id
FROM ecoli_data AS e1
    JOIN ecoli_data AS e2 ON e1.parent_id = e2.id
    JOIN ecoli_data AS e3 ON e2.parent_id = e3.id
WHERE e3.parent_id IS NULL
ORDER BY e1.id ASC

문제에서 요구한 결과를 만들기 위해 쿼리에서 실제로 쓴 것들이다.

• 테이블 2회 JOIN 으로 두 테이블을 연결
• WHERE 로 조건에 맞는 행만 남김
• ORDER BY 로 정렬

WITH per AS (
    SELECT id, PERCENT_RANK() OVER (ORDER BY size_of_colony DESC) as per_rank
    FROM ECOLI_DATA
)
SELECT id,
CASE
    WHEN per_rank < 0.25 THEN 'CRITICAL'
    WHEN per_rank < 0.5 THEN 'HIGH'
    WHEN per_rank < 0.75 THEN 'MEDIUM'
    ELSE 'LOW'
END AS colony_name
FROM per
ORDER BY id;

문제에서 요구한 결과를 만들기 위해 쿼리에서 실제로 쓴 것들이다.

• ORDER BY 로 정렬 (내림차순 포함)
• 서브쿼리를 사용
• CASE WHEN 으로 조건에 따라 값을 분기

WITH null_item as (SELECT t1.item_id
    FROM item_tree as t1
        LEFT JOIN
        item_tree as t2
        ON t1.item_id = t2.parent_item_id
    WHERE t2.item_id IS NULL
)

SELECT ii.item_id, ii.item_name, ii.rarity
FROM null_item as ni
    JOIN
    item_info as ii
    ON ni.item_id = ii.item_id
ORDER BY ii.item_id DESC

문제에서 요구한 결과를 만들기 위해 쿼리에서 실제로 쓴 것들이다.

• 테이블 2회 LEFT JOIN 으로 두 테이블을 연결
• WHERE 로 조건에 맞는 행만 남김
• ORDER BY 로 정렬 (내림차순 포함)
• 서브쿼리를 사용

• 위 현상이 나타날 수 있는 이유
  • 토크나이저 설정 오류:
    • 문제: 사용하는 토크나이저가 예상과 다르게 token_type_ids를 생성하고 있을 수 있습니다. 예를 들어, 토크나이저가 질의-응답 모델처럼 두 개 이상의 세그먼트를 처리하도록 설정되어 있거나, 잘못된 매개변수가 사용되었을 수 있습니다.
    • 해결 방법:
      • 토크나이저의 설정과 사용법을 다시 확인합니다. 특히 encode_plus 또는 __call__ 메서드의 매개변수를 주의 깊게 살펴보아야 합니다.
      • 단일 문장 분류와 같은 작업에서는 token_type_ids가 실제로 필요하지 않으므로, 토크나이저에서 이를 생성하지 않도록 설정하거나, 생성된 값을 무시해야 합니다.
      • encodings['token_type_ids'] = torch.zeros_like(encodings['input_ids']) 이 코드를 통해 모든 토큰 id를 0으로 설정하면, 위 문제를 회피할 수 있습니다.
  • 입력 데이터 형태 오류:
    • 문제: 입력 데이터가 토크나이저가 예상하는 형태와 다를 수 있습니다. 예를 들어, 질의-응답 쌍과 같은 형태의 데이터가 단일 문장으로 처리되고 있을 수 있습니다.
    • 해결 방법:
      • 입력 데이터의 형태를 확인하고, 토크나이저가 데이터를 올바르게 처리할 수 있도록 데이터를 조정합니다.
      • 문제가 되는 특정 데이터의 형태를 확인하는 것이 중요합니다.
  • 모델 또는 라이브러리 문제:
    • 문제: 드물게 모델 자체 또는 사용하는 라이브러리에 오류가 있을 수 있습니다.
    • 해결 방법:
      • 사용하는 모델과 라이브러리의 버전을 확인하고, 최신 버전으로 업데이트하거나 다른 버전으로 시도해 봅니다.
      • 허깅페이스와 같은 유명한 모델은, 버전 업데이트가 빠른 편입니다. 가능한 최신버전을 이용하는게 좋습니다.
  • 패딩의 문제점:
    • 문제: 패딩 과정에서 일부 토큰 타입 ID가 원하지 않는 값으로 설정될 수 있습니다.
    • 해결 방법:
      • 패딩 설정과 방식을 확인하고, 필요에 따라 패딩 마스크를 사용하여 패딩된 토큰을 모델이 무시하도록 합니다.

    ...
    		stages {
            stage('Checkout Code') {
                steps {
                    // 내장 checkout 단계를 사용합니다. Jenkins가 모든 것을 처리하도록 합니다.
                    checkout([$class: 'GitSCM',
                              branches: [[name: '*/release']], // 또는 '*/main' 등
                              extensions: [],
                              userRemoteConfigs: [[credentialsId: 'gitlab-token',
                                                   url: 'gitlab-url']]])
                }
            }
    ...
    ```

...
dev-backend   |     connection.connect()
dev-backend   |     ~~~~~~~~~~~~~~~~~~^^
dev-backend   |   File "/usr/local/lib/python3.13/site-packages/redis/connection.py", line 363, in connect
dev-backend   |     raise ConnectionError(self._error_message(e))
dev-backend   | redis.exceptions.ConnectionError: Error 111 connecting to 127.0.0.1:6379. Connection refused.

• redis가 docker에 제대로 연결되지 않아 발생하는 문제
  • 127.0.0.1은 local에서 사용하는 것이므로 docker에 맞게 바꿔줄 필요가 있음

    ...
    CMD ["cp", "-r", "/app/dist", "/app/frontend_build"]
    ```

- volume mount를 할 때 local의 상태가 덮어 쓰기 된다는 것을 명심하자
---

# 📚 Reference

    ...
    build_backend:
      tags:
        - backend-runner
      script:
        - cd Backend
        - docker build -t $IMAGE_BACKEND:$TAG -f Dockerfile.dev .
        - docker push $IMAGE_BACKEND:$TAG
      only:
        - develop
        - master
    
    build_frontend:
      tags:
        - frontend-runner
      script:
        - cd Frontend
        - docker build -t $IMAGE_FRONTEND:$TAG -f Dockerfile.dev .
        - docker push $IMAGE_FRONTEND:$TAG
      only:
        - develop
        - master
    ...
    ```

• 분명 conda activate 이후 가상환경 안에서 pip install을 통해 모듈을 설치했음에도 불구하고 not found module이 발생하는 경우가 있다.

• pip의 경로를 확인해보면 conda 환경의 경로가 아님을 확인할 수 있다. 이 때문에 global 환경에 설치가 되어 가상환경 내에서 사용할 수 없었던 것

    $ which pip
    /home/user/.local/bin/pip
    ```

- pip를 현재 가상환경의 것으로 사용하도록 명시한다.

```bash
    python -m pip install <module_name>
    ```

# 📚 Reference

    server {
        listen 80;
        server_name momoso106.duckdns.org;
    
        location /.well-known/acme-challenge/ {
            root /var/www/certbot;
        }
    
        location / {
            return 301 https://$host$request_uri;
        }
    }
    
    server {
        listen 443 ssl; // 이게 문제임
        server_name momoso106.duckdns.org;
    
        location / {
            root /app/frontend/build;
            index index.html;
            try_files $uri /index.html;
        }
    
        location /api/ {
            proxy_pass http://backend:8000/;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto https;
        }
    
        location /openvidu/ {
            proxy_pass https://openvidu:4443/;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto https;
            proxy_ssl_verify off;
        }
    }
    
    ```

• webpack@4.47.0과 webpack-cli@5.1.4 간의 의존성 충돌 문제이다. webpack-cli@5.x.x는 webpack@5.x.x를 필요로 하지만, 현재 프로젝트에서는 webpack@4.47.0이 사용되고 있기 때문.

• 일단 webpack의 버전을 5로 올려줬다.

    npm install webpack@5 --save-dev
    ```

- 추후에 front 담당자와 확실히 정하면 될 거 같다.
---

# 📚 Reference

    ...
      frontend:
        build: ./Frontend
        environment:
          - CHOKIDAR_USEPOLLING=true  # 파일 변경 감지를 위한 설정
        ports:
          - "3000:3000"
        volumes:
          - ./Frontend:/app  # 로컬 파일 시스템을 컨테이너에 마운트
          - /app/node_modules  # 로컬의 node_modules가 container 내에 적용되지 않도록
        networks:
          - app_network
    ...
    ```

- 해결하기 까지 정말 오래 걸렸다. node_modules를 지우고 하더라고 한 번만 잘 되고 계속 안됐었는데 mount된 volume에 local 파일이 영향을 줘서 생기는 문제라고는 생각을 못했다.
- 어찌 보면 기본적인 compose 작성법일 수 있는데 기초 공부가 조금 부족하지 않았나 반성하게 되는 계기가 되었다.
---

    @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
    @         WARNING: UNPROTECTED PRIVATE KEY FILE!          @
    @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
    Permissions 0644 for 'amazonec2.pem' are too open.
    It is recommended that your private key files are NOT accessible by others.
    This private key will be ignored.
    bad permissions: ignore key: amazonec2.pem
    Permission denied (publickey).
    ```

- pem 파일에 너무 많은 권한이 부여되어 보안 상 AWS에서 거부한 것
---

/ # gitlab-runner exec shell build
Runtime platform                                    arch=amd64 os=linux pid=139 revision=66a723c3 version=17.5.0
FATAL: Command exec not found.

• gitlab-runner의 버전이 v17 이상인 경우 exec가 안되는 경우가 있다고 한다.

🛠 해결책

• gitlab-runner의 버전을 v16.10.0으로 내렸다.

    services:
      gitlab-runner:
        image: gitlab/gitlab-runner:v16.10.0
        container_name: gitlab_runner
        restart: always
        volumes:
          - ./gitlab-runner/config:/etc/gitlab-runner
          - /var/run/docker.sock:/var/run/docker.sock
          - ./entrypoint.sh:/entrypoint.sh
        environment:
          - RUNNER_NAME=my-runner
          - TZ=Asia/Seoul
          - CI_SERVER_URL=${CI_SERVER_URL}
          - REGISTRATION_TOKEN=${REGISTRATION_TOKEN}
          - RUNNER_EXECUTOR=${RUNNER_EXECUTOR}
        ports:
          - "9252:9252"
        entrypoint: ["tail", "-f", "dev/null"]
    ```

🛠 해결책

• 명령어 변경

    gitlab-runner register \
      --url "$CI_SERVER_URL"\
      --token "$REGISTRATION_TOKEN"\
      --listen-address ":9252" \
      --executor "docker"\
      --docker-image "alpine:latest"
    ```

- `config.toml`파일을 제거하고 다시 등록하니 403 발생 안됨

## 1. **`--registration-token`**

- *Runner를 등록(Register)**할 때 사용되는 **일회성 토큰**입니다.
- GitLab에서 새 Runner를 프로젝트, 그룹, 또는 인스턴스에 연결하기 위해 사용합니다.
- 이 토큰은 Runner를 등록한 뒤에는 더 이상 사용되지 않습니다.

- **프로젝트**나 **그룹**의 **Settings > CI/CD > Runners** 섹션에서 확인 가능합니다.
- 예: `Settings > CI/CD > Specific Runners`에서 `registration-token`으로 표시됩니다.

# 베이스 이미지 선택
FROM kwon0528/postgres_backend:0.5

# 필요한 패키지 설치 (bash 설치)
RUN apt-get update && apt-get install -y bash

# 작업 디렉토리 설정
WORKDIR /home

# back.sh 파일 복사
COPY back.sh /home/back.sh

# 실행 권한 부여
RUN chmod +x /home/back.sh

# 실행
CMD ["bash", "/home/back.sh"]

Dockerfile.vue

# 베이스 이미지 선택
FROM kwon0528/vue_frontend:0.3.2

# 작업 디렉토리 설정
WORKDIR /app

# # front.sh 파일 복사
# COPY front.sh /app/chuibot/front.sh

# # 실행 권한 부여
# RUN chmod +x /app/chuibot/front.sh

# # 실행
# CMD ["sh", "/app/front.sh"]
# CMD cd ~/chuibot && git pull

C:\Users\Kwon>docker run --name mysql000ex11 -dit --net=wp -e MYSQL_ROOT_PASSWORD=1234 -e MYSQL_DATABASE=wordpress---db -e MYSQL_USER=wordpress000user -e MYSQL_PASSWORD=1234 mysql --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci --default-authentication-plugin=mysql_native_password
853dd040ade1fef5532d8429504d7a1b2ab3f0b3cb6f8ed635918d4df773b1b6

C:\Users\Kwon>docker run --name wordpress000ex12 -dit --net=wp -p 8085:80 -e WORDPRESSS_DB_HOST=mysql000ex11 -e WORDPRES
S_DB_NAME=wordpress000db -e WORDPRESS_DB_USER=wordpress000user -e WORDPRESS_DB_PASSWORD=1234 wordpress
aef41f135fbdba00fe389a0f882e52aaa05f24f638fbf7ce3277dfc964ea5e79

C:\Users\Kwon>docker ps
CONTAINER ID   IMAGE       COMMAND                  CREATED          STATUS          PORTS                  NAMES
aef41f135fbd   wordpress   "docker-entrypoint.s…"   24 seconds ago   Up 21 seconds   0.0.0.0:8085->80/tcp   wordpress000ex12

2-1. OS는 뭘 하는가?

소프트웨어나 프로그램의 명령을 하드웨어에 전달하는 역할을 한다.

하드웨어는 자신의 판단으로 여러 의미 중 적절한 것을 고르거나 적당히 일을 할 수 없고, 지시받은 대로만 수행할 수 있으므로 동작 하나하나를 지정해 주지 않으면 안 된다.

OS는 이런 일들을 하드웨어가 알아들을 수 있게 번역하여 전달하게 된다.

2-2. 도커의 리눅스 OS 비슷한 것

본래 OS는 ‘커널’이라는 부분과 ‘그 이외의 주변 부분’으로 구성된다. 주변 부분이 프로그램의 연락 내용을 커널에 전달하고 커널이 하드웨어를 다룬다.

여기서 도커의 컨테이너는 운영체제의 주변 부분을 가지고 있다. 이를 통해 프로그램의 명령을 전달받고, 이를 밑바탕이 되는 커널에 전달하는 구조로 되어 있다.

이 덕분에 OS 전체를 컨테이너에 넣지 않을 수 있어, 도커는 가장 큰 특징인 ‘가벼움’을 얻을 수 있다.

2-3. 도커는 기본적으로 Linux 용이다.

2-1. 컨테이너

컴퓨터(서버) 상의 환경을 작게 분할한 공간

이렇게 나누어진 컨테이너에 데이터나 프로그램을 두어 격리한다. 이를 격리하는 기능을 제공하는 소프트웨어가 도커다. 도커는 도커 소프트웨어 본체인 도커 엔진을 설치해 사용한다. 이 도커 엔진을 사용하여 컨테이너를 생성하고 구동할 수 있다.

컨테이너를 만드는 데에는 도커 엔진 외에도 이미지가 필요하다

이미지는 컨테이너의 빵틀과도 같은 역할을 하는 것

이미지에는 많은 종류가 있다. 아파치 컨테이너를 만들려면 아파치 이미지를 사용하고, MySQL 컨테이너를 만들려면 MySQL 이미지를 사용한다.

용량이 허락하는 한, 하나의 도커에서 여러 개의 컨테이너를 만들 수 있다.

2-2. 도커의 작동

도커는 리눅스 상에서 동작한다.

Windows나 MacOS에서도 동작하지만 결국 내부적으로 리눅스가 개입한다. 또한, 컨테이너에서 동작시킨 프로그램도 리눅스용 프로그램이다.

test_case = int(input())

def chk_test():
    chk_a_list = [0] * k
    chk_b_list = [1] * k

    for w_i in range(w):
        is_success = False

        for d_i in range(d - k + 1):
            cur_chk = [film[tmp_i][w_i] for tmp_i in range(d_i, d_i + k)]
            if cur_chk == chk_a_list or cur_chk == chk_b_list:
                is_success = True
                break
        if not is_success:
            return False
    return True


def test_film(film, depth=0, cnt_inject=0, chk_list=[]):
    global min_inject
    
    if cnt_inject >= min_inject:
        return

    if chk_test():
        min_inject = min(min_inject, cnt_inject)
        return

    if depth >= d:
        return
    
    origin_membrane = film[depth][:]

    # 현재 층을 그대로
    test_film(film, depth + 1, cnt_inject)

    # 현재 층을 a로
    film[depth] = inject_a
    test_film(film, depth + 1, cnt_inject + 1)
    film[depth] = origin_membrane

    # 현재 층을 b로
    film[depth] = inject_b
    test_film(film, depth + 1, cnt_inject + 1)
    film[depth] = origin_membrane

for t in range(test_case):
    d, w, k = map(int, input().split())

    film = [list(map(int, input().split())) for _ in range(d)]
    
    inject_a = [0] * w
    inject_b = [1] * w

    min_inject = float('inf')

    test_film(film)
    print(f"#{t + 1} {min_inject}")

def max_subset_sum(arr):
    dp = [[0, 0] for _ in range(c + 1)]

    for num in arr:
        for j in range(c, num - 1, -1):
            if dp[j - num][0] + num > c:
                continue
            next_sq_value = dp[j - num][1] + num ** 2
            if next_sq_value > dp[j][1]:
                dp[j][0] = dp[j - num][0] + num
                dp[j][1] = next_sq_value
    _, max_sum = max(dp, key=lambda x: x[1])
    return max_sum

test_case = int(input())

for t in range(test_case):
    n, m, c = map(int, input().split())
    honey_map = [list(map(int, input().split())) for _ in range(n)]
    total_max = 0

    for fst_i in range(n):
        for fst_j in range(n - m + 1):

            fst_max = max_subset_sum(honey_map[fst_i][fst_j:fst_j + m])

            for snd_i in range(n):
                start = 0
                if snd_i == fst_i:
                    start = fst_j + m
                for snd_j in range(start, n - m + 1):
                    snd_max = max_subset_sum(honey_map[snd_i][snd_j:snd_j + m])

                    total_max = max(total_max, fst_max + snd_max)

    print(f"#{t + 1} {total_max}")

# 계산

def calculate(num1, num2, operator):

    if operator == '+':
        num1 += num2
    elif operator == '-':
        num1 -= num2
    elif operator == '*':
        num1 *= num2
    elif operator == '/':
        num1 = int(num1 / num2)
    return num1

# 수식 완성
def search_expression(i, result):
    if i == n:
        global max_num, min_num
        max_num = max(max_num, result)
        min_num = min(min_num, result)
        return

    for operator in operators:
        if operator_dict[operator] > 0:
            operator_dict[operator] -= 1
            search_expression(i + 1, calculate(result, nums[i+1], operator))
            operator_dict[operator] += 1



test_case = int(input())

for t in range(test_case):
    n = int(input()) - 1
    operators = ['+', '-', '*', '/']
    operator_dict = {operator: cnt for operator, cnt in zip(operators, map(int, input().split()))}

    nums = list(map(int, input().split()))

    max_num = float('-inf')
    min_num = float('inf')
    result_dict = {}
    visited = []

    search_expression(0, nums[0])

    print(f"#{t + 1} {max_num - min_num}")

test_case = int(input())

def search_recipe(index_list, n):
    if n == 1 :
        return [[i] for i in index_list]
    result = []
    for i in range(len(index_list) - 1):
        for j in search_recipe(index_list[i+1:], n - 1):
            result.append([index_list[i]] + j)
    
    return result


for t in range(test_case):
    n = int(input())
    min_diff = float('inf')

    recipe = [list(map(int, input().split())) for _ in range(n)]
    
    index_set = set(range(n))

    comb_list = [[0] + c for c in search_recipe(list(range(1, n)), n // 2 - 1)]

    for comb in comb_list:
        comb2 = list(index_set - set(comb))
        food1, food2 = 0, 0

        for i_idx, (i1, i2) in enumerate(zip(comb, comb2)):
            for j1, j2 in zip(comb[i_idx + 1:], comb2[i_idx + 1:]):
                food1 += recipe[i1][j1] + recipe[j1][i1]
                food2 += recipe[i2][j2] + recipe[j2][i2]
        min_diff = min(min_diff, abs(food1 - food2))

    print(f"#{t + 1} {min_diff}")

test_case = int(input())


# 제한 칼로리 내에서 최대의 맛
def search_best(hamburgers, sum_cal=0, sum_score=0):
    global max_score
    max_score = max(max_score, sum_score)

    for i, (score, cal) in enumerate(hamburgers):
        if sum_cal + cal > l:
            continue
        search_best(hamburgers[i + 1:], sum_cal + cal, sum_score + score)


for t in range(test_case):
    n, l = map(int, input().split())

    hamburgers = [list(map(int, input().split())) for _ in range(n)]

    max_score = 0

    search_best(hamburgers)

    print(f"#{t + 1} {max_score}")

$a, b \in \mathbb{Z}$이고 $a$를 $b$로 나눈 나머지를 $r$이라 하자. ($b \leq a, 0 \leq r \leq b$)

$a, b$의 최대 공약수를 $(a, b)$라고 하면, 다음이 성립한다.

$(a, b)=(b, r)$

출처: wikipidia

$r$이 0이 될 때 알고리즘을 멈추며, 이 때의 $b$가 최대공약수가 된다.

예를 들어 1460과 1037에 대해 알고리즘을 진행해보면 다음과 같다.

$r$이 0일때 $b$가 4이므로 1460과 1037의 최대공약수는 4이다.

def evaluate(pairs, source_vocab, target_vocab, encoder, decoder, target_max_length):
    for pair in pairs:
        print(">", pair[0])
        print("=", pair[1])
        source_tensor = tensorize(source_vocab, pair[0])
        source_length = source_tensor.size()[0]
        encoder_hidden = torch.zeros([1, 1, encoder.hidden_size]).to(device)

        for ei in range(source_length):
            _, encoder_hidden = encoder(source_tensor[ei], encoder_hidden)

        decoder_input = torch.Tensor([[SOS_token]]).long().to(device) # 수정해야 작동
        decoder_hidden = encoder_hidden
        decoded_words = []

        for di in range(target_max_length):
            decoder_output, decoder_hidden = decoder(decoder_input, decoder_hidden)
            _, top_index = decoder_output.data.topk(1) # 1개의 가장 큰 요소를 반환
            if top_index.item() == EOS_token:
                decoded_words.append("<EOS>")
                break
            else:
                decoded_words.append(target_vocab.index2vocab[top_index.item()])

            decoder_input = top_index.squeeze().detach()

        predict_words = decoded_words
        predict_sentence = " ".join(predict_words)
        print("<", predict_sentence)
        print("")

# load data
xy = np.loadtxt("data-02-stock_daily.csv", delimiter=",")
xy = xy[::-1]  # reverse order

# split train-test set
train_size = int(len(xy) * 0.7)
train_set = xy[0:train_size]
test_set = xy[train_size - seq_length:]

앞서 언급한대로 scaling을 하고 학습하기 좋은 형태로 data를 가공해야 한다.

def minmax_scaler(data):
    numerator = data - np.min(data, 0)
    denominator = np.max(data, 0) - np.min(data, 0)
    return numerator / (denominator + 1e-7)

train_set = minmax_scaler(train_set)
test_set = minmax_scaler(test_set)

# data setting
x_data = []
y_data = []

# window를 오른쪽으로 움직이면서 자름
for i in range(0, len(sentence) - sequence_length):
    x_str = sentence[i:i + sequence_length]
    y_str = sentence[i + 1: i + sequence_length + 1]
    print(i, x_str, '->', y_str)

    x_data.append([char_dic[c] for c in x_str])  # x str to index (dict 사용)
    y_data.append([char_dic[c] for c in y_str])  # y str to index

x_one_hot = [np.eye(dic_size)[x] for x in x_data]

X = torch.FloatTensor(x_one_hot)
Y = torch.LongTensor(y_data)

'''output
0 if you wan -> f you want
1 f you want ->  you want 
2  you want  -> you want t
3 you want t -> ou want to
4 ou want to -> u want to 
...
166 ty of the  -> y of the s
167 y of the s ->  of the se
168  of the se -> of the sea
169 of the sea -> f the sea.
'''

char_set = ['h', 'i', 'e', 'l', 'o']

# hyper parameters
input_size = len(char_set)
hidden_size = len(char_set)
learning_rate = 0.1

# data setting
x_data = [[0, 1, 0, 2, 3, 3]]
x_one_hot = [[[1, 0, 0, 0, 0],
              [0, 1, 0, 0, 0],
              [1, 0, 0, 0, 0],
              [0, 0, 1, 0, 0],
              [0, 0, 0, 1, 0],
              [0, 0, 0, 1, 0]]]
y_data = [[1, 0, 2, 3, 3, 4]]

X = torch.FloatTensor(x_one_hot)
Y = torch.LongTensor(y_data)

마찬가지로 one-hot encoding하여 Tensor로 바꾼다. 다만 각 알파벳 변수에 배열을 저장하는 방식이 아니라 char_set에 저장된 알파벳을 x_data의 값을 인덱스로 불러오는 방식이다. one-hot encoding은 x_data에 적용하여 학습한다.