Node.js

• --node.js란--구글의 V8이라는 JS 엔진으로 만들어져 있고 싱글 스레드가 기반이다. / 논 블로킹
• Tomcat, JBoss 등과 같은 일반적 웹서버는 멀티 스레드가 기반이다.
• JS를 활용하여 고성능의 비동기 IO을 지원하는 네트워크 어플리케이션 개발 플랫폼
• --논 블로킹 IO--호출된 함수에서 I/O 작업 등을 요청 했을 경우 처리여부와 관계없이 바로 다음 작업이 가능하다.
• 직접 제어할 수 없는 작업이 완료되기 전에 제어권을 넘겨주는 경우
• --Node.js 구조--바인딩 (socket, http, etc)

  

  사진 출처 - https://sjh836.tistory.com/149
• V8 Engine / libuv (이벤트 루프, 논 블로킹 모델은 전부 여기서)
• 내장 라이브러리
• --Node.js--protocol://host(domain):port/path?query string 형식
• query string을 바꿔서 전달하면 페이지를 동적으로 가져올 수 있다.
• ${} 사용가능

접근 제어자

Public - 모든 패키지에서 접근이 가능하다.

Private - 자신을 포함한 패키지에서만 접근이 가능하다, 정의된 해당 클래스에서만 접근이 가능하도록 접근 범위를 제한한다.

protected - 클래스가 정의되어 있는 해당 패키지 내 그리고 해당 클래스를 상속받은 외부 패키지의 클래스에서 접근이 가능하다.

오버라이딩 vs 오버로딩

오버라이딩 : 상위 클래스의 메소드를 재정의 하는 것

오버로딩 : 같은 클래스 내에서 동일한 메소드 이름을 가지지만 매게변수 타입, 갯수가 다르게 구현할 수 있는 것

MVC1 vs MVC2

MVC1 : Jsp가 controller, view의 가능을 모두 담당한다.

MVC2 : 웹 브라우저 요청을 컨트롤러에서 처리하고 요청 로직을 모델로 보내서 결과를 view가 응답한다.

RDBMS vs NoSQL

RDBMS : 릴레이션을 통해 데이터를 저장하여 데이터 구조를 보장하고 중복을 피한다.

NoSQL : 자유로운 형태의 데이터를 저장한다. 수평적 확장, 분산처리지원

equals() vs ==

equals()는 대상의 내용 자체를 비교

== 은 주소값을 비교

String vs StringBuilder, StringBuffer

String : 불변

StringBuilder : 가변 타입 / Thread-safe X

StringBuffer : 가변 타입 / Thread-safe O / 멀티 스레드 환경

Thread-safe : 어떠한 동작이 여러 스레드로부터 동시에 이루어져도 프로그램 실행에 문제없음

Spring MVC 동작원리

1. 클라이언트의 요청을 DistpatcjerServler에 전달

2. 요청한 url에 맞는 controller 검색하여 HandlerMapping에 전달

3. HandlerMapping에서 해당 controller에 처리 요청

4. controller에서 처리 결과를 HandlerAdapter에서 ModelAndView 객체로 변환하여 DispatcherServlet에 전달

5. DispatcherServlet에서 전달받은 ModelAndView 객체를 이용하여 매핑되는 View를 검색

6. viewResolver에서 처리 결과를 view에 전달

7. 처리결과가 포함된 view를 DispatcherServlet에 전달

8. DispatcherServlet에서 최종 응답 결과를 클라이언트에게 출력

사진 출처 - https://gngsn.tistory.com/83

숫자 카드 게임

import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine().trim(), " ");

        int N = 0, M = 0;
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        
        String str = "";
        
        char[][] chararray = new char[N][M];
        
        for(int i = 0; i < N; i++){
            str = br.readLine();
            str = str.replace(" ", "");
            for(int j = 0; j < str.length(); j++){
                chararray[i][j] = str.charAt(j);
            }
        }
        
        
        char min = chararray[N-1][0];

        for(int i = 0; i < M; i++){
            if(min > chararray[N-1][i]){
                min = chararray[N-1][i];
            }
        }
        
        System.out.println(min);
    }
}

문제

8*8크기의 체스판에 왕이 하나 있다. 킹의 현재 위치가 주어진다. 체스판에서 말의 위치는 다음과 같이 주어진다. 알파벳 하나와 숫자 하나로 이루어져 있는데, 알파벳은 열을 상징하고, 숫자는 행을 상징한다. 열은 가장 왼쪽 열이 A이고, 가장 오른쪽 열이 H까지 이고, 행은 가장 아래가 1이고 가장 위가 8이다. 예를 들어, 왼쪽 아래 코너는 A1이고, 그 오른쪽 칸은 B1이다.

킹은 다음과 같이 움직일 수 있다.

• R : 한 칸 오른쪽으로
• L : 한 칸 왼쪽으로
• B : 한 칸 아래로
• T : 한 칸 위로
• RT : 오른쪽 위 대각선으로
• LT : 왼쪽 위 대각선으로
• RB : 오른쪽 아래 대각선으로
• LB : 왼쪽 아래 대각선으로

체스판에는 돌이 하나 있는데, 돌과 같은 곳으로 이동할 때는, 돌을 킹이 움직인 방향과 같은 방향으로 한 칸 이동시킨다. 아래 그림을 참고하자.

입력으로 킹이 어떻게 움직여야 하는지 주어진다. 입력으로 주어진 대로 움직여서 킹이나 돌이 체스판 밖으로 나갈 경우에는 그 이동은 건너 뛰고 다음 이동을 한다.

킹과 돌의 마지막 위치를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 킹의 위치, 돌의 위치, 움직이는 횟수 N이 주어진다. 둘째 줄부터 N개의 줄에는 킹이 어떻게 움직여야 하는지 주어진다. N은 50보다 작거나 같은 자연수이고, 움직이는 정보는 위에 쓰여 있는 8가지 중 하나이다.

출력

첫째 줄에 킹의 마지막 위치, 둘째 줄에 돌의 마지막 위치를 출력한다.

예제 입력 1 복사

A1 A2 5
B
L
LB
RB
LT

예제 출력 1 복사

A1
A2

예제 입력 2 복사

A1 H8 1
T

예제 출력 2 복사

A2
H8

예제 입력 3 복사

A1 A2 1
T

예제 출력 3 복사

A2
A3

예제 입력 4 복사

A1 A2 2
T
R

예제 출력 4 복사

B2
A3

예제 입력 5 복사

A8 B7 18
RB
RB
RB
RB
RB
RB
RB
RB
RB
RB
RB
RB
RB
RB
RB
RB
RB
RB

예제 출력 5 복사

G2
H1

예제 입력 6 복사

C1 B1 3
L
T
LB

예제 출력 6 복사

B2
A1

정답

package project;

import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        StringBuffer sb = new StringBuffer();
        
        String move_input = "";
        int cnt = 0;
        
        char[] king_pos, stone_pos, next_king, next_stone;
        
        // 킹 포지션
        king_pos = st.nextToken().toCharArray();
        // 돌 포지션
        stone_pos = st.nextToken().toCharArray();
        // 몇 번 옮기는지 입력
        cnt = Integer.parseInt(st.nextToken());
        
        for(int i = 0; i < cnt; i++){
            move_input = br.readLine();
            next_king = move(move_input, king_pos);
            if(Range(next_king)){ // 킹이 범위 안에 있네
                if(next_king[0] == stone_pos[0] && next_king[1] == stone_pos[1]){ // 옮긴 킹의 위치하고 돌의 위치가 같네?
                    next_stone = move(move_input, stone_pos);
                    if(Range(next_stone)){ // 킹도 범위 안이고 좌표가 같으나 돌이 움직일 수 있으면 둘다 바꾼다.
                        king_pos = next_king;
                        stone_pos = next_stone;
                    }else{ // 돌이 움직일 수 없으면
                        continue;
                    }
                }else{ // 안곂치네? 고럼 움직여야지
                    king_pos = next_king;
                }
                
            }else{ // 킹이 범위에 없네? 그럼 무시
                continue;
            }
        }
        
        for(int i = 0; i < king_pos.length; i++){
            sb.append(king_pos[i]);
        }sb.append(" ");
        for(int i = 0; i < stone_pos.length; i++){
            sb.append(stone_pos[i]);
        }
        
        System.out.print(sb);
    }
    
    // 범위 넘어가는지 여부
    public static Boolean Range(char[] range){
        if(range[0]<'A' || range[0]>'H' || range[1]<'1' || range[1]>'8')
            return false;
        else
            return true;
    }
        
    public static char[] move(String mv, char[] pos){
        char[] result = pos.clone();
        // char로 된 'A', 'B' 는 아스키 코드로 인식되어 ++ --가 가능하다
        switch(mv){
            case "R":
                result[0]++;
                break;
            case "L":
                result[0]--;
                break;
            case "B":
                result[1]--;
                break;
            case "T":
                result[1]++;
                break;
            case "RT":
                result[0]++;    result[1]++;
                break;
            case "LT":
                result[0]--;    result[1]++;
                break;
            case "RB":
                result[0]++;    result[1]--;
                break;
            case "LB":
                result[0]--;    result[1]--;
        }
        return result;
    }
}

10 10

9 25

0 30

23 45

23 40

22 55

정답

package project;

import java.util.Scanner;

public class Main {

    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        
        int hour = sc.nextInt();
        int min  = sc.nextInt();
        
        if(min < 45){
            hour--;
            min = (60 + min) - 45;
            if(hour < 0){
                hour = 23;
            }
            System.out.print(hour+" "+min);
        }
        else{
            System.out.print(hour+" "+(min-45));
        }
    }
}

0 1 0 1
1 1 1 0
0 0 1 1

B
A
B

정답

package project;

import java.util.Scanner;

public class Main {

    public static void main(String[] args){
        //TODO Auto-generated method stub
		char[][] answer = new char[3][4];
        //BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        Scanner sc = new Scanner(System.in);
        int cnt = 0;
        
		for(int i = 0; i < answer.length; i++){            
            String str = sc.nextLine().trim();
            str = str.replace(" ","");
		    for(int j = 0; j < str.length(); j++){
		        answer[i][j] = str.charAt(j);
		    }
		}
        
        for(int i = 0; i < 3; i++){
            for(int j = 0; j < 4; j++){
                if(answer[i][j] == '1'){
                    cnt += 1;
                }
            }
            switch(cnt){
                case 0:
                    System.out.println("D");
                    break;
                case 1:
                    System.out.println("C");
                    break;
                case 2:
                    System.out.println("B");
                    break;
                case 3:
                    System.out.println("A");
                    break;
                case 4:
                    System.out.println("E");
                    break;
            }
            cnt = 0;
        }
    }
}