메리

1. Connection Timeout

발생 시점: 서버와 연결을 시도하는 과정에서 시간 초과 발생.

1. 클라이언트가 서버에 연결 요청을 보냄 (CONNECT).
2. 서버가 응답하지 않거나 네트워크 문제로 연결이 지연.
3. Connection Timeout 설정 시간 초과 → ConnectTimeoutException 발생.

예시

• 서버 주소가 잘못 설정되어 DNS 조회 실패.
• 서버가 다운되어 요청을 처리하지 못함.
• 방화벽이 연결을 차단.

2. Socket Timeout (응답 대기)

발생 시점: 연결이 성공한 후, 서버가 응답 데이터를 보내기 시작하지 않을 때 시간 초과 발생.

전체 응답 시간이 아닌 개별 패킷 응답 시간

1. 클라이언트가 서버와 연결 성공.
2. 서버는 요청을 받았으나 응답 처리가 지연됨.
3. 클라이언트가 Socket Timeout 동안 대기했으나 데이터가 도착하지 않음 → SocketTimeoutException 발생.

예시

• 서버 과부하로 응답 지연.
• 요청 처리 중 서버의 작업이 중단됨.
• 네트워크 패킷이 손실됨.

3. Read Timeout

발생 시점: 응답 데이터의 일부를 읽은 후, 남은 데이터를 끝까지 받지 못할 때 시간 초과 발생.

1. 클라이언트가 서버와 연결 성공.
2. 서버가 일부 응답 데이터를 보내기 시작.
3. 응답 데이터의 나머지가 전송되지 않음.
4. 클라이언트가 Read Timeout 동안 대기했으나 데이터 전송이 완료되지 않음 → SocketTimeoutException 발생.

예시

• 대규모 데이터를 처리 중 네트워크 장애 발생.
• 서버 응답이 중간에 중단됨.
• 클라이언트가 데이터를 너무 빨리 읽으려 함.

SocketTimeout = ReadTimeout:

• 두 용어는 Java에서 동일한 타임아웃 설정을 가리킵니다.
• 둘 다 응답 데이터 읽기와 관련된 대기 시간을 제어합니다.

한화생명 코테

프로그래머스 난이도 1~1.5 쯤 예상됨

1. 오름차순 정렬

2. 배열 오른쪽부터 m개씩 끊으면 끊은 지점이 그 구간에서 제일 싼가격임..

import java.util.*;

class Solution {
    public int solution(int k, int m, int[] score) {
        Arrays.sort(score);
        int sum = 0;
        for (int i = score.length - m; i >= 0; i -= m) {
            sum += score[i] * m;
        }
        return sum;
    }
}

특정 수의 약수를 구할 때 그 수의 제곱근까지만 나눠보는 이유는 약수는 항상 짝을 이루기 때문

다른 풀이를 보고

for문 라벨링이란걸 처음 해보았다.

class Solution {
    public int solution(int n) {
        int answer = 0;
        
        outer:
        for(int i=2; i<=n; i++){
            for(int j=2; j<=Math.sqrt(i); j++){
                if(i%j == 0){
                    continue outer;
                } 
            }
            answer += 1;
        }
        return answer;
    }
}

1. 첫번째부터 롤러질

2. 어디까지 칠해졌는지 기록 <= checked

3. 칠할 section을 돌면서 checked보다 같거나 작은지 체크(칠해진거)

4. section이 칠해진 지점보다 크면 롤러횟수+1, 어디까지 칠해졌는지 기록.

5. 칠해진 지점이 전체 길이보다 같거나 크면 stop

class Solution {
    public int solution(int n, int m, int[] section) {
        int answer = 0;
        int checked = 0; //checked까지 칠해졌음
        
        
        for(int sec : section){
            if(checked >= sec){
                continue;
            }else{
                checked = sec + (m-1);
                answer += 1;
            }
            
            if(checked >= n) break;
        }
        
        return answer;
    }
}

투 포인터라는 알고리즘을 배웠음!

핵심 원리는 다음과 같음

1. start pointer / end pointer

2. end pointer을 오른쪽으로 옮기면 합이 증가

3. start pointer을 오른쪽으로 옮기면 합이 감소

4. pointer 이동한 뒤 목표합보다 작으면 -> end pointer를 오른쪽으로 옮긴다.

5. pointer 이동한 뒤 목표합보다 크면 -> start pointer를 오른쪽으로 옮긴다.

이제 여기서 문제마다

목표합과 같을때 무슨 액션을 할지 달라지는가 보다.

두번째 문제풀이

import java.util.*;

public class Problem1806 {
    //부분합
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int numsCount = sc.nextInt();
        int targetSum = sc.nextInt();
        sc.nextLine();
        int[] nums = new int[numsCount];
        for(int i=0; i<numsCount; i++){
            nums[i] = sc.nextInt();
        }

        int end = 0;
        int start = 0;
        int sum = 0;
        int minLen = numsCount+1;
        //end 포인터를 오른쪽으로 옮기면 합이 증가
        //start 포인터를 오른쪽으로 옮기면 합이 감소
    
        while(end < numsCount){ //end 포인터가 배열 마지막부분까지 가도록
            if(sum < targetSum){ //합이 목표합보다 작은 경우 : end 포인터를 오른쪽으로 옮긴다.
                sum += nums[end++];
            }
            while(sum >= targetSum){//합이 목표합보다 크거나 같은 경우 : start 포인터를 오른쪽으로 옮긴다.
                sum -= nums[start++];
                minLen = Math.min(minLen, end-start+1);
            }
        }
        
        if(minLen == numsCount + 1){
            System.out.println(0);
        }else{
            System.out.println(minLen);
        }
    }
    
}

첫번째 문제풀이

import java.util.*;

public class Problem1806 {
    //부분합
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int numsCount = sc.nextInt();
        int targetSum = sc.nextInt();
        sc.nextLine();
        int[] nums = new int[numsCount];
        for(int i=0; i<numsCount; i++){
            nums[i] = sc.nextInt();
        }

        int start = 0;
        int sum = 0;
        int minLen = numsCount+1;
        for(int end=0; end<numsCount; end++){
            sum += nums[end]; //end에 있는 수 더하기

            while(sum >= targetSum){//목표합보다 같거나 큰 경우 길이를 기록, start을 오른쪽으로 땡김
                minLen = Math.min(end-start+1,minLen);
                sum -= nums[start++];      
            } 

        }
        minLen = minLen == numsCount+1 ? 0 : minLen;
        System.out.println(minLen);
    }
    
}

아래코드는 다음과 같이 바꿀 수 있음

start += 1; 
sum -= nums[start-1];

=> sum -= nums[start++];

boxed를 해주는 이유

1. Comparator는 객체를 비교하는 인터페이스이다.
2. Instream은 기본 데이터 타입인 int 를 다루는 스트림이므로 Comparator를 사용할 수 없다.
3. 따라서 boxed()를 사용하여 IntStream을 Stream<Integer>로 변환한다.

import java.util.*;

public class Problem10817 {
    // 세 수
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] nums = sc.nextLine().split(" ");
        Optional<Integer> num = Arrays.stream(nums)
                                .mapToInt(Integer::parseInt)
                                .boxed()
                                .sorted((a,b) -> b-a)
                                .skip(1)
                                .findFirst();

        System.out.println(num.get());
    }
}

오랜만에 stream sorted사용

사전순 정렬시

Comparator.naturalOrder() 혹은

String::compareTo 사용하면 된다고 함

import java.util.*;

public class Problem1181 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int cnt = Integer.parseInt(sc.nextLine());
        String[] words = new String[cnt];
        for(int i=0; i<cnt; i++){
            words[i] = sc.nextLine();
        }

        String[] newWords = Arrays.stream(words)
                        .distinct()
                        .sorted(Comparator.comparingInt(String::length)
                        .thenComparing(Comparator.naturalOrder()))
                        .toArray(String[]::new);

        for(String w : newWords){
            System.out.println(w);
        }
    }
    
}

문제 제대로 안 읽고 오름차순인거 캐치 못하고 계속 삽질..

나는 왜그럴까.. 

import java.io.File;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Deque;
import java.util.List;
import java.util.Scanner;

public class Main {
    static boolean[][] isChecked; //체크여부
    static int[][] map;           //지도
    static int mapSize;           //지도의 크기
    static Deque<int[]> queue = new ArrayDeque<>();   //방문할 좌표
    static int[] xmove = new int[]{-1, 1, 0, 0};           //상하좌우
    static int[] ymove = new int[]{0, 0, -1, 1};           //상하좌우
    static int townCnt = 0;
    public static void main(String[] args) throws Exception{
        Scanner sc = new Scanner(System.in);
        mapSize = Integer.parseInt(sc.nextLine());
        map = new int[mapSize][mapSize];
        isChecked = new boolean[mapSize][mapSize];

        //map 저장
        for(int i=0; i<mapSize; i++){
            String row = sc.nextLine();
            for(int j=0; j<row.length(); j++){
                map[i][j] = row.charAt(j) - '0';
            }
        }

        for(int i=0; i<mapSize; i++){
            for(int j=0; j<mapSize; j++){
                if(!isChecked[i][j] && map[i][j] == 1){ //방문체크 안되어있는 1값인 경우 시작
                    townCnt += 1; //단지 카운트
                    bfs(i, j);
                }
            }
        }
        System.out.println(townCnt);
        Collections.sort(townSizes);
        for(Integer cnt : townSizes){
            System.out.println(cnt);
        }
    }
    static List<Integer> townSizes = new ArrayList<>();
    public static void bfs(int x, int y){
        int townSize = 1;
        queue.add(new int[]{x, y});
        isChecked[x][y] = true;
        while(!queue.isEmpty()){
            int[] position = queue.poll();
            for(int i=0; i<4; i++){
                int newx = position[0] + xmove[i];
                int newy = position[1] + ymove[i];
                if(newx >= 0 && newy >= 0 && newx < mapSize && newy < mapSize
                    && map[newx][newy] == 1
                    && !isChecked[newx][newy]
                ){
                    queue.add(new int[]{newx, newy});
                    isChecked[newx][newy] = true;
                    townSize += 1;
                }
            }
        }

        townSizes.add(townSize);    
        
    }
}

DFS 사용

import java.io.File;
import java.util.Scanner;

public class Problem2606 {
    static int[][] map; //연결망
    static boolean[] isChecked; //체크여부
    static int computerCnt; //컴퓨터 개수
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        computerCnt = Integer.parseInt(sc.nextLine());
        int lineCnt = Integer.parseInt(sc.nextLine());
        isChecked = new boolean[computerCnt+1];
        map = new int[computerCnt+1][computerCnt+1];

        //map에 연결여부 넣기
        for(int i=1; i<=lineCnt; i++){
            String[] line = sc.nextLine().split(" ");
            int a = Integer.parseInt(line[0]);
            int b = Integer.parseInt(line[1]);
            map[a][b] = map[b][a] = 1;
        }

        dfs(1);
        System.out.println(virusCnt);
    }

    static int virusCnt = 0;
    public static void dfs(int start){
        isChecked[start] = true;
        for(int i=1; i<=computerCnt; i++){
            if(map[start][i] == 1 && !isChecked[i]){ //방문한 적 없고 연결1이면
                virusCnt+=1;
                dfs(i);
            }
        }
    }
}