난이도 '하'라고 해서 걍 풀겠거니 했는데 오랜만에 푸니 감도 안오는구나 일단 정렬은 필수, 예외처리해야 되는지 확인

import sys

N = int(sys.stdin.readline())
K = int(sys.stdin.readline())

sensor_list = list(map(int, sys.stdin.readline().split()))

sensor_list.sort()
dist_list = []


if K >= N:
    print(0)
else:
    for i in range(len(sensor_list) - 1):
        dist_list.append(sensor_list[i + 1] - sensor_list[i])

    dist_list.sort()

    for _ in range(K - 1):
        dist_list.pop()

    print(sum(dist_list))

import sys
from collections import deque

N, M = map(int, sys.stdin.readline().split())

board = []

for i in range(N):
    board.append(list(sys.stdin.readline().strip()))

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

def bfs(x, y):

    dist = [[[0] * M for _ in range(N)] for _ in range(2)]
    dist[1][0][0] = 1

    que = deque([])
    que.append([0, 0, 1])


    while que:
        x, y, w = que.popleft()

        if x == N - 1 and y == M - 1:
            return dist[w][x][y]

        for i in range(4):
            nx = x + dx[i]
            ny = y + dy[i]

            if 0 <= nx < N and 0 <= ny < M:
                if board[nx][ny] == '0' and dist[w][nx][ny] == 0:
                    dist[w][nx][ny] = dist[w][x][y] + 1
                    que.append([nx, ny, w])
                elif board[nx][ny] == '1' and w == 1:
                    dist[0][nx][ny] = dist[w][x][y] + 1
                    que.append([nx, ny, 0])

    return -1

print(bfs(0, 0))

import sys

H, W = map(int, sys.stdin.readline().split())

block_list = list(map(int, sys.stdin.readline().split()))

h_index = 0
h_max = 0

for i in range(W):
    if h_max < block_list[i]:
        h_max = block_list[i]
        h_index = i

temp_max = 0
temp_cnt = 0

for i in range(h_index + 1):
    if temp_max < block_list[i]: # 이 부분이 핵심
        temp_max = block_list[i]
    temp_cnt += temp_max

temp_max = 0

for i in range(W - 1, h_index, -1):
    if temp_max < block_list[i]: # 이 부분이 핵심
        temp_max = block_list[i]
    temp_cnt += temp_max

print(temp_cnt - sum(block_list))

에라토스테네스...소수 나오면 바로 써먹어야겠다. 오랜만에 풀어서 그런지 BFS 응용문제 나오면 감을 못잡겠다. 문자열 슬라이싱도 간만에 해서 기억이 잘 안났다.

import sys
from collections import deque

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

primes = [False, False] + [True] * (9999)
result = []

for i in range(2, 10000):
    for j in range(2*i , 10000, i):
        primes[j] = False

for _ in range(T):
    start, end = map(int, sys.stdin.readline().split())

    que = deque([])
    que.append([start, 0])

    visited = [False] * 10000

    while que:
        cur, cnt = que.popleft()
        visited[cur] = True

        if cur == end:
            result.append(cnt)
            break

        temp = str(cur)

        for i in range(4):
            for j in range(10):
                next = int(temp[:i] + str(j) + temp[i + 1:])

                if not visited[next] and primes[next] and next >= 1000:
                    que.append([next, cnt + 1])

    else:
        result.append(-1)

for r in result:
    if r == -1:
        print("impossible")
    else:
        print(r)

방법이 어렴풋이 떠오르긴 했지만 결과적으로는 실패 nonlocal은 정말 새로웠다.. 함수 안에 함수에서 그 상위 지역변수를 어떻게 써야 되는 지 궁금했는데 nonlocal.. 하나 배웠다.

def solution(numbers, target):
    answer = 0
    num_cnt = len(numbers)

    def dfs(result, idx):
        nonlocal answer
        if idx == num_cnt:
            if result == target:
                answer += 1
            return
        else:
            dfs(result + numbers[idx], idx + 1)
            dfs(result - numbers[idx], idx + 1)

    dfs(0, 0)

    return answer

한주 한주 집중하고 주위에 좋은 동료들이 많아서 그런 것인지 시간 가는 줄도 모르고 재밌게 보냈다.

진정한 개발자가 되고 싶어서 퇴사를 결심하였고, 처음엔 막연하게 회사 4년 반 다녔으니 여행이나 다니면서 쉬었다가 해볼까? 라는 생각도 했었지만, 이 정글을 보게 되니 그럴 생각이 사라졌다.

난 정글로 여행을 간 것이다. 즐기면서 했다. 새로운 개념을 알아가는 것이 재미있었다. 좋은 사람들을 많이 만나서 또 좋았다. 어려운 과제들을 해낼 때마다 기분이 짜릿했다. 물론 너무 어려운 과제들은 일부 못하긴 했지만.. 참 아쉽다. 아직 나의 실력이 부족한 탓이다.

여행을 가면 견문이 넓어진다는 것이 이런 느낌일까? 확실히 나는 예전과 비교하여 개발을 보는 눈이 넓어졌다. 새로운 기술 스택을 접할 때 처음에는 처음 보는 기술 스택인데 할 수 있을까? 라는 의문이 들었다면 이제는 그거? 일단 해보자 해보면 할 수 있어 라는 태도로 변하였다.

이젠 진짜 정글로 들어가는 과정이다. 좋은 개발 환경에서 빨리 개발할 수 있었으면 좋겠다.

고마워 정글 :) 잘있어 정글 ;(

처음에 봤을 때는 그냥 단순 비교하면 될 줄 알고 코드를 때려 박았더니 역시나 안됐다.

이분탐색으로 풀어야 시간 초과가 안남.

비교 전에 sort 해주는 것 잊지 않기.

import sys

N = int(sys.stdin.readline().strip())
card_list = list(map(int, sys.stdin.readline().strip().split()))
M = int(sys.stdin.readline().strip())
compare_list = list(map(int, sys.stdin.readline().strip().split()))

card_list.sort()

for i in range(M):
    low, high = 0, N - 1
    while low <= high:
        mid = (high + low) // 2
        if card_list[mid] == compare_list[i]:
            print(1, end=" ")
            break
        elif card_list[mid] < compare_list[i]:
            low = mid + 1
        else:
            high = mid - 1

        if low > high:
            print(0, end=" ")
            break

이건.. 진짜 내 자신에게 실망한 문제다 각 자리수를 어떻게 잘라서 구해야 될 지 map을 사용해서 구하는걸 생각 못했다.

생성자가 없는 경우 0을 출력하는 것에 유의하자

import sys

N = int(sys.stdin.readline().strip())
result = 0

for i in range(1, N + 1):
    M_list = list(map(int, str(i)))

    result = i + sum(M_list)

    if result == N:
        print(i)
        break

    if i == N:
        print(0)

문자열에서 폭탄 문자열을 찾아서 제거하는 문제 쉽게 생각했는데 못풀었다. 문자열을 for문으로 하나씩 꺼내 temp list에 append하다가 폭탄 문자열 끝 문자가 일치하고 temp list와 폭탄 문자열 리스트가 일치하는 시점에서 폭탄 문자열의 크기만큼 pop을 해준다. 그 이후에 temp list에 남은 문자를 문자열로 만들어준 뒤 체크하여 문자열이 없다면 FRULA를 보낸다.

오랜만에 보니 슬라이싱 규칙이 잘 기억이 안났따... 기억하자!!

import sys

N = sys.stdin.readline().strip()
B = list(sys.stdin.readline().strip())

B_len = len(B)
B_last = B[-1]

temp_N = []
result = "FRULA"


for ch in N:
    temp_N.append(ch)
    if ch == B_last and B == temp_N[-B_len:]:  # -B_len 번째 부터 끝까지 리스트 슬라이싱
        for _ in range(B_len):
            temp_N.pop()
temp_result = ''.join(temp_N)

if temp_result:
    result = temp_result

print(result)

WebSocket?

HTTP의 단점을 보완하기 위해 등장하였고, 클라이언트와 서버 사이의 동적인 양방향 연결 채널을 구성하는 통신 프로토콜

WebSocket API를 통해 서버로 메시지를 보내고, 요청없이 응답을 받아오는 것도 가능.

WebSocket은 HTML5 기술이기 때문에 오래된 버전의 웹브라우저는 지원하지 않는데 이를 해결하기 위해 나온 것 중 하나가 Socket.IO이다. Socket.IO는 지원하지 않는 브라우저에 대해 일반 HTTP를 이용하여 실시간 통신을 흉내냄.

WebSocket 등장 배경

HTTP 이용했을 때는 요청을 해야 응답이 오는데 이를 개선하여 자유롭게 데이터를 주고 받을 수 있게하면 불필요한 자원 소모를 줄일 수 있음.

HTTP는 지나치게 많은 Header(KB)를 가지고 있지만, WebSocket은 Byte 단위까지 압축 가능하여 네트워크 과부하 (오버헤드)를 줄일 수 있음.

작동원리

서버 클라이언트 연결을 HTTP를 사용하고 TCP/IP 기반 연결. 일정 시간 후 HTTP 연결은 끊긴다.

WebRTC?

Web Real-Time Communications의 약자이며, 웹브라우저 상에서 플러그인 도움 없이 서로 실시간 통신할 수 있도록 설계된 기술. (음성채팅, 화상채팅, 데이터 교환 가능)

WebRTC 기술은 P2P 통신 최적화 아래와 같이 크게 3가지 클래스가 있다.

• MediaStream : 카메라와 마이크 등의 데이터 스트림 접근
• RTCPeerConnection : 암호화 및 대역폭 관리 및 오디오, 비디오의 연결
• RTCDataChannel : Peer간 데이터를 주고 받을 수 있는 Tunnel API

WebRTC 등장 배경

개방형 프로토콜인 HTML5의 취약한 보안점을 해소, 다른 방식에 비해 프로그램 설치도 필요없고 운영체제에 부담을 주지 않음.

WebRTC 작동원리

단순 P2P와 다르게 크게 4가지 Step을 거쳐 동작한다. (() 내용은 프로토콜)

• Signaling (SDP = Session Description Protocol )
• Connecting (ICE = Interactive Connectivity Establishment)
• Securing (DTLS = Datagram Transport Layer Security, SRTP = Secure Real-time Transport Protocol)
• Communicationing (RTP = Real-time Transport Protocol, SCTP = Stream Control Transmission Protocol, RTCP = Real-time Transport Control Protocol)

Signaling

caller가 callee를 Call할 때 Signaling server가 양쪽의 signal OK를 확인 후 연결 및 서로의 IP주소 교환한다.(통신 방식 같은 기본 정보도 같이 전송)

Signaling을 하기 위해 도움을 주는 서버가 있다.

1. STUN(Session Traversal Utilities for NAT)

• peer 연결을 가능하게 해줄 public IP를 제공.
  2. TURN(Network Address Translation)
  • STUN의 확장으로 STUN을 통해 IP를 얻지 못한 경우 사용.
  • TURN 서버는 인터넷망에 위치하고 각 Peer들이 private IP안에서 통신한다.
  • 각 Peer들이 직접 통신하는 것이 아니라 릴레이 역할을 하는 TURN 서버를 통해 경유한다.
  • TURN은 이러한 릴레이로부터 IP 주소와 포트를 클라이언트가 취득할 수 있는 릴레이 주소를 할당한다.
  • STUN에 비해 리소스 낭비가 심하다.

마무리

프로젝트를 하면서 WebSocket과 WebRTC 방식 중 어떤 것을 택해야 하는 상황이 왔다.

WebSocket과 WebRTC를 크게 2가지로 생각해보았다.

1. TCP vs UDP
2. 서버에 부담 vs 클라이언트에 부담

프로젝트 특성상 실시간이라는 키워드와 클라이언트에 큰 부담을 주지 않을 수준이라 WebRTC를 선택하였다. 그리고 뭔가 새로운 기술이라 더 끌렸던 것 같다.

참고 사이트 https://gh402.tistory.com/45

https://post.naver.com/viewer/postView.nhn?volumeNo=30734315&memberNo=33264526&vType=VERTICAL

https://velog.io/@devdynam0507/%EC%9B%B9%EC%82%AC%EC%9D%B4%ED%8A%B8%EC%97%90%EC%84%9C-%EC%8B%A4%EC%8B%9C%EA%B0%84-%ED%86%B5%EC%8B%A0%EC%9D%84-WebRTC

https://medium.com/@hyun.sang/webrtc-webrtc%EB%9E%80-43df68cbe511

https://www.html5rocks.com/ko/tutorials/webrtc/infrastructure/#how-can-i-build-a-signaling-service

https://doublem.org/webrtc-story-02/

https://lovejaco.github.io/posts/webrtc-connectivity-and-nat-traversal/

CRDT?

Conflict-Free Replicated Data Type 직역하면 충돌 없는 복제 자료 유형 (ADT) 동시편집 기술 중 하나

동시편집 기술을 쓰는 도구 예시를 들자면 Google Docs(OT 방식), Figma(CRDT 방식) 등이 있음.

CRDT 작동 원리

어떤 변경 사항을 받으면, 순서와 상관없이 변경사항만 같으면 같은 상태

예시)

각 개체를 유니크한 값으로 처리. 그 후 동시 편집을 하더라도 합치는 과정에서 유니크한 값으로 비교(그림 예시는 L과 !를 동시에 입력한다 가정하였고, 소수 대소 비교)를 하여 정렬하기 때문에 충돌이 일어나지 않음.

하지만 여러 단어를 마구 입력하게 되면 입력한 단어들이 섞여서 나오는 문제점이 있음.

그 문제를 해결하기 위해 아래와 같이 여러 알고리즘이 존재.

Project 4. FILE SYSTEM

이번 project 4는 핵심 키워드만 정리해보려고 한다.

프로젝트 3이 주기억장치(ex : RAM)에 관련한 내용이었다면 프로젝트 4는 보조기억장치(ex : HDD)에 관한 내용이다.

sector size = 512 byte block = sector를 모아둔 것 disk는 block 단위의 읽기 / 쓰기를 함 disk = free block들의 모음

1. 파일 할당 방식 1) 연속 할당 (Contiguous Allocation) 각 파일에 대해 디스크 상의 연속된 block에 할당 (List 처럼 할당)

   장점 : 디스크 헤더의 이동 최소화 = 빠른 I/O 성능 단점 : 외부 단편화로 인한 디스크 공간의 낭비 발생, 삭제 시 hole 발생

   
   2) 연결 할당 (Linked Allocation) 파일을 linked list로 처리하여 각 block에 할당 각 block은 포인터 저장을 위한 4byte 이상을 소모한다. FAT(File Allocation Table)이 여기서 등장 table에 별도 block을 저장하여 FAT 손실 시 복구 가능 시스템 구축.

   장점 : 외부 단편화 발생하지 않음 단점 : 느린 속도, 포인터 저장을 위한 저장공간 손실

   
   

   3) 색인 할당 (Indexed Allocation) data block 외에 index block이 존재하고, index block은 data block들의 포인터를 모은 block이다.

   장점 : 외부 단편화 발생하지 않음 단점 : index block 할당에 따른 저장공간 손실

진행 상황 공유

이번 프로젝트는 솔직히 거의 내용을 보지도 못했고.. 관련 내용 구글링하여 공부는 했지만 구현은 역시 또 못했다. 그래도 이번 PintOS 덕에 OS가 어떻게 흘러가는 지 어느정도 알게 되었다. 열심히한 같은 팀 인원들 고맙고, 정말 고생 많았다!!!

Node.js가 설치 되어 있다고 가정하고 VS code 터미널에 아래와 같이 입력

npm init

npm init을 치고 enter 키를 누르면 package.json이 생성

npm install -g express

package.json에 아래와 같이 express가 생기면 완료.

설치 완료 후 테스트

server.js를 생성한 뒤, 아래 코드를 입력

var express = require('express'); var app = express();

app.get('/', (req, res) => { res.send("Express Test"); });

app.listen(5000, (req, res) => { console.log("Server Running.."); });

server.js를 만든 디렉토리까지 이동 후 node server.js 입력

아래와 같이 나오면 완료

만약에 오류가 난다면 환경 변수 편집

2. TypeScript 설치

VS code 터미널에 아래와 같이 입력

npm install -g typescript

설치 확인

tsconfig.json 생성

npx tsc --init

생성 후 아래 내용으로 바꿈 (각 속성 내용은 https://geonlee.tistory.com/214 여기를 참고)

{ "compilerOptions": { "strict": true, "module": "commonjs", "moduleResolution": "node", "lib": ["es2015","es2016","es2017","es2018","es2019","es2020"], "target": "ES5", "outDir": "./dist", "esModuleInterop": true }, "exclude": ["node_modules"], "include": ["src/*/"] }

ts-node 설치

typescript를 바로 실행하는데 사용

npm install -g ts-node

설치 완료

설치 완료 후 테스트

test.ts 생성한 뒤, 아래 코드를 입력

let hello: string = "hello typescript!"; console.log(hello);

해당 경로에서 tsc test.ts를 입력하면 빌드되면서 test.js 생성

ts-node로 test.ts 직접 실행

마무리

여기까지 기본적인 환경 설정 방법이었습니다. 감사합니다.

자바스크립트 런타임

https://nodejs.org/ko/

아무런 체크 필요 없이 그냥 Next 눌러서 설치 진행 PowerShell을 관리자 권한으로 실행 후 다음 명령어를 입력 후 설치 확인

2. OpenJDK 설치

안드로이드 앱을 빌드하기 위해 필요

https://www.azul.com/downloads/?os=windows&architecture=x86-64-bit&package=jdk

주의 : gradle에서 특정 Java 버전 지원 안하는 경우도 있어서 무조건 최신 버전을 깔면 안될 수도 있음 (작성자는 Java15를 설치)

아무런 체크 필요 없이 그냥 Next 눌러서 설치 진행 PowerShell에 다음 명령어를 입력 후 설치 확인

3. Python 설치

리액트 네이티브 빌드 시스템은 파이썬에 의존함

https://www.python.org/downloads/

PowerShell에 다음 명령어를 입력 후 설치 확인 (작성자는 이미 깔려 있어서 버전 다름)

4. Android Studio 설치

안드로이드 앱 빌드를 위한 IDE

https://developer.android.com/studio/index.html

설치 완료 후 Finish를 누르고 안드로이드 스튜디오가 실행 실행하면 import 관련하여 창이 뜨는데 Do not import settings가 클릭 후 OK를 누름

Next

Custom으로 한 뒤 Next

Android Virtual Device가 설치가 되어 있지 않다면 체크 하여 설치 (작성자는 이미 설치함)

완료

는 아직이고 환경 변수 편집을 해주어야 한다.

윈도우 검색 - "시스템 환경 변수 편집" 검색 후 실행

환경 변수 클릭

새로 만들기를 눌러 위의 변수와 값을 추가

Path 편집을 누르고 위에 추가한 값 경로를 추가

PowerShell에 다음 명령어를 입력 후 설치 확인

5. React Native CLI 설치

리액트 네이티브 Command Line Interface Expo CLI는 무겁고 자유도가 없어서 일단 React Native CLI로

cmd 실행 후 다음과 같이 설치 및 설치 확인

마무리

우선 여기까지 진행하고 다음 포스트 때 Express와 TypeScript 적용 및 프로젝트 실행을 해보겠습니다.

감사합니다.

def solution(dirs):
    answer = 0
    dx = [-1, 1, 0, 0]
    dy = [0, 0, -1, 1]
    dir_dict = {"U" : 0, "D" : 1, "L" : 2, "R" : 3}
    visited = set()

    cx = 0
    cy = 0

    for i in range(len(dirs)):
        nx = cx + dx[dir_dict[dirs[i]]]
        ny = cy + dy[dir_dict[dirs[i]]]

        if -5 <= nx <= 5 and -5 <= ny <= 5:
            # 양방향 처리
            if (cx, cy, nx, ny) not in visited:
                visited.add((cx, cy, nx, ny))
                visited.add((nx, ny, cx, cy))
                answer += 1
            cx = nx
            cy = ny

    return answer

Project 3. VIRTUAL MEMORY

3-1 Memory Management

page는 VM_UNINIT, VM_ANON, VM_FILE 3개 중 하나의 속성을 갖는다.

page 가상 메모리 주소에 접근 시 해당 주소가 page table에 mapping되어 있지 않다면(matching된 kva가 없다면), page fault가 발생하게 되고, page fault handler는 미리 해당 주소에 대한 정보가 담긴 supplemental page table(spt)에 해당 주소에 대한 정보를 찾아 page table에 mapping 시켜준다.

va(page)는 kva(frame)과 matching되어 있고, kva는 실제 물리 메모리와 matching되어 있다. => 실제 물리 메모리를 pintos가 건들지 못하게 하기 위함.

3-2 Anonymous Page

단어 그대로 익명, 이름이 없는 page다. 왜 없냐면 disk의 file을 실행시키면서 만들어 진 게 아니라서(특정 file과 matching 안되서) 이름이 없다.

Anonymous Page는 private 또는 shared로 할당받을 수 있다. 프로세스의 힙과 스택이 private로 할당된 anonymous page이다. shared는 프로세스간 통신을 위해 사용되는 anonymous page이다.

왜 사용하는 지 궁금해져서 찾아보니 아래와 같은 장단점이 있다.

• 장점 단편화가 없다. 할당 후 크기 조절이 가능. heap을 거칠 필요가 없다.

• 단점 새로운 공간을 할당 받는 overhead가 heap에서 가져오는 것 보다 크다. kernel의 page 사이즈 크기 배수로 할당 받다보니 공간 낭비가 있을 수 있다.

3-3 Stack Growth

page fault 후 page 공간만큼 stack 영역이 늘어나야 한다. 메모리 할당 후 stack_bottom을 더 늘려줘야 한다. Test Case 중 여러 개의 page를 늘리는 경우는 없다.

3-4 Memory Mapped Files

file backed mapping 부분이다. mmap을 호출하면 syscall이 발생하고 예외처리 체크 후 do_mmap 호출하게 되고 disk에 있는 file을 메모리 mapping을 하게 된다. munmap은 반대로 메모리 mapping을 해제함.

3-5 Swap In/Out

Swap In / Out 은 물리 메모리에 page를 올렸다(Swap In), 뺐다(Swap Out)라고 생각하면 된다. Swap In은 Load를 위해 당연히 진행해야 되고 실제 page 속성은 Swap In 과정에서 정해진다. Swap Out은 메모리 공간이 부족해졌을 때 판단하에 가장 빠져도 되는 page를 Swap Out(swap area로 방출)하게 된다.

아래와 같이 Swap Out을 위한 여러 policy가 있다.

• FIFO First In First Out 먼저 들어 간 것이 먼저 나온다. 선입 선출 교체 시기도 마찬가지로 먼저 들어간 page가 먼저 나온다.

• Second-change FIFO의 변형된 형태의 알고리즘. 참조비트를 추가하여 참조비트가 1이면 queue의 맨 뒤로 이동시키고, 그렇지 않다면 교체한다.

• LRU 가장 오랫동안 사용되지 않은 page를 교체

• LFU 참조된 횟수가 가장 적은 page를 교체

• Clock Second-change보다 더 효율적인 FIFO 버전, LRU를 근사화 시킨 알고리즘. 참조 비트가 1이면 옮기지 않고 참조비트를 Clear 한 뒤, 다음 page를 찾는다. 참조 비트가 0인 page를 찾았으면 그 page를 교체한다.

진행 상황 공유

열심히 하는 같은 팀 조원들에 비해 너무 부족하였다고 생각한다. 이번 프로젝트도 역시나 구현은 못했고, 다른 사람들의 내용을 참고하면서 이해하였다. 다들 고생 많았고 다음 주도 화이팅!!

from collections import defaultdict, deque
graph_dict = defaultdict(list)
result_dict = defaultdict(list)
node_list = deque([])
max_cnt = 0

def bfs(v, curr, cnt):
    global max_cnt
    node_list.append([curr, cnt])

    while node_list:
        t_cur, t_cnt = node_list.popleft()

        for e in graph_dict[t_cur]:
            if not v[e]:
                v[e] = True
                result_dict[t_cnt + 1].append(e)
                node_list.append([e, t_cnt + 1])
                max_cnt = max(max_cnt, t_cnt + 1)
    return

def solution(n, edge):
    answer = 0
    visited = [False] * (n + 1)

    for e in edge:
        graph_dict[e[0]].append(e[1])
        graph_dict[e[1]].append(e[0])

    visited[1] = True
    bfs(visited, 1, 0)

    answer = len(result_dict[max_cnt])
    return answer

다른 사람 풀이

from collections import deque, defaultdict

def solution(n, edge):
    routes = defaultdict(list)
    for e1, e2 in edge:
        routes[e1].append(e2)
        routes[e2].append(e1)

    q = deque([[1, 0]]) 

    check = [-1]*(n+1)

    while q:
        index, depth = q.popleft()
        check[index] = depth
        for i in routes[index]:
            if check[i]== -1:
                check[i] = 0
                q.append([i, depth+1])
    return check.count(max(check))

그리고 문제를 좀 끝까지 제대로 읽자...

import sys
from collections import deque

n = int(sys.stdin.readline())
board = [-1] + list(map(int, sys.stdin.readline().strip().split()))
c = int(sys.stdin.readline())
case = deque([])

for _ in range(c):
    input_case = list(map(int , sys.stdin.readline().strip().split()))
    case.append(input_case)

while case:
    sex, num = case.popleft()

    if sex == 1:
        for i in range(1, n + 1):
            if i % num == 0:
                if board[i] == 1:
                    board[i] = 0
                else:
                    board[i] = 1
    else:
        if board[num] == 1:
            board[num] = 0
        else:
            board[num] = 1

        for i in range(1, n):
            # 앞으로는 예외처리하는 식을 break 처리 하는 걸로..
            if num + i > n or num - i < 1 : 
                break
            if board[num + i] == board[num - i]:
                if board[num + i] == 1:
                    board[num + i] = board[num - i] = 0
                else:
                    board[num + i] = board[num - i] = 1
            else:
                break

for i in range(1, n + 1):
    print(board[i], end=" ")
    if i % 20 == 0:
        print()

서비스 이름

라이브 메모

주제

Connected Memo를 통해 여러 사용자가 실시간으로 내용을 수정 및 공유함.

주제 선정 배경

이 주제를 선정한 이유는 단순하게 메모를 기록하는 것 외에 같이 메모를 공유하는 사람들끼리 실시간으로 내용이나 일정을 공유한다면 일상에서 좀 더 효율적으로 활용할 수 있지 않을까? 라는 생각이 있었고, 그렇기 때문에 이런 주제를 가지고 프로젝트를 진행하게 되었습니다.

상황 예시 ) 지은이는 친구들과의 여행을 준비하기 위해 단체 대화방을 만들었다. 친구들이 서로 가고 싶은 곳, 하고 싶은 일정을 마구 올리고 이런 저런 얘기를 하기 시작했다. 여행 직전 정리를 해야 되는 상황에서 그 전에 공유 했던 내용들이 여러 잡담으로 묻히고 흩어져 있어 나중에 정리할 때 일일이 다시 찾아야 하는 수고가 있었다. 주제에 맞는 내용만 딱 정리해서 다 같이 볼 수 있었으면 참 좋았을 것 같다.

주요 기능

1. 실시간으로 수정 할 수 있는 Memo

   • 실시간으로 공유 가능.
   • 쓰기 권한이 있는 구성원 누구나 실시간으로 수정 가능.
   
   2. **Group Call** * 현재 열람 중인 사용자들과의 그룹 통화 기능을 제공.

3. App Push

   • 공유하고 있는 멤버들에게 푸시 알림을 보냄.
   
   

4. 내보내기

   • 공유 대상이 해당 어플을 설치하지 않았더라도 내보내기 기능을 통해 다양한 플랫폼(카카오톡, 슬랙, pdf 등)으로 내용 전달.
     

와이어 프레임

기술 스택

backend : Node js, Express , WebRTC frontend : React 인프라 : AWS EC2, Firebase 언어 : Java script 기타 필요시 추가 가능

기술 스택 선정 이유

앱과 웹을 모두 가지면서 빠르게 개발할 수 있는 방법을 찾다 보니 '하이브리드 앱' 과 '크로스 플랫폼 앱' 둘 중 하나로 진행하면 좋다고 판단하였고, 그중에서 퍼포먼스를 최대한 끌어올릴 수 있고, 동적인 요소 구현을 상대적으로 쉽게 할 수 있는 것을 고려하다 보니 크로스 플랫폼 앱으로 진행하기로 하였습니다. PWA로 진행하는 걸로 변경하였습니다.

크로스 플랫폼 앱의 프레임워크도 크게 Flutter와 React Native로 나뉘는데, 상대적으로 더 오래되고 요즘 떠오르는 JavaScript를 쓰는 이유로 React Native 선택하였습니다. React로 변경하였습니다.

서버 쪽 역시 JavaScript로 개발할 수 있는 Node js를 택했으며, 서버 프레임워크로는 크게 Nest와 Express 둘 중 고민하다가 상대적으로 자유도가 높고 참고 자료가 많은 Express를 선택하였습니다.

또한, 어플 컨셉 상 실시간 양방향 통신을 원활히 해줄 수 있는 Socket.IO와 실시간 음성 통신을 편리하게 해줄 수 있는 라이브러리인 PeerJS를 사용할 예정입니다. WebRTC 기술을 선택하였습니다.

DB 같은 경우에는 Firebase에서 제공해주고 작업 속도를 빠르게 해줄 수 있을 것으로 기대되는 RealTimeDB를 선택하였습니다. Atlas MongoDB를 선택하였습니다.

마치며

같이 팀을 하게 된다면 재밌고, 유쾌한 분위기에서 프로젝트를 진행했으면 합니다. 다들 여기까지 오느라 정말 고생 많았고, 마무리까지 다들 화이팅합시다! 긴 글 읽어주셔서 감사합니다!

# -*- coding: euc-kr -*-
import sys
from collections import deque

F, S, G, U, D = map(int, sys.stdin.readline().strip().split())

visited = [False] * (F + 1)

curr_list = deque([[S, 0]])
visited[S] = True

while curr_list:
    curr, cnt = curr_list.popleft()
    if curr == G:
        print(cnt)
        break

    go_up = curr + U
    go_down = curr - D

    if go_up <= F and not visited[go_up]:
        curr_list.append([go_up, cnt + 1])
        visited[go_up] = True

    if go_down > 0  and not visited[go_down]:
        curr_list.append([go_down, cnt + 1])
        visited[go_down] = True

else:
    print("use the stairs")