우당탕탕 히온이네

🔎 문제

📣 풀이

import java.util.*;

class Solution {
    public int[] solution(int[] answers) {
    
        int n = answers.length;
		int[] arr1 = {1, 2, 3, 4, 5};
		int[] arr2 = {2, 1, 2, 3, 2, 4, 2, 5};
		int[] arr3 = {3, 3, 1, 1, 2, 2, 4, 4, 5, 5};
		int[] cnt = {0, 0, 0};
		
		for (int i = 0; i < n; i++) {
			if(arr1[i % arr1.length] == answers[i]) cnt[0]++;
			if(arr2[i % arr2.length] == answers[i]) cnt[1]++;
			if(arr3[i % arr3.length] == answers[i]) cnt[2]++;
		}
		
		int max = Math.max(Math.max(cnt[0], cnt[1]), cnt[2]);
		
        ArrayList<Integer> list = new ArrayList<Integer>();
		for (int i = 0; i < cnt.length; i++) {
			if (max == cnt[i]) list.add(i+1);
		}
        
        int[] answer = new int[list.size()];
		for (int i = 0; i < answer.length; i++) {
			answer[i] = list.get(i);
		}
        
		return answer;
    }
}

배열을 리스트로 변환시키는 부분과

ArrayList<> list = new ArrayList<>();

array[i] = list.get[i]

로 원소를 가져와주는 부분 숙지할 필요가 있다!

📣 문제

🔎 풀이

import java.util.ArrayList;
import java.util.List;

class Solution {
    public int solution(int[] nums) {
        int answer = 0;
		List<Integer> list = new ArrayList<Integer>();
		for (int i = 0; i < nums.length; i++) {
			if(!list.contains(nums[i]))
				list.add(nums[i]);
		}
		
		int N = nums.length/2;
		answer = N >= list.size()? list.size():N;
        return answer;
    }
}

📣 문제

🔎 풀이

class Solution {
    public int solution(int left, int right) {
        int answer = 0;
        
        for (int i = left; i <= right; i++) {
            int cnt = 0;
            for (int j = 1; j <= i; j++) {
                if (i % j == 0)
                    cnt++;
            }
            answer += (cnt % 2 == 0) ? i : -i;
        }
        return answer;
    }
}

🔎문제

🔎 풀이

import java.util.Arrays;
class Solution {
    public int[] solution(int[] array, int[][] commands) {
        int[] answer = new int[commands.length];
        
        for (int i = 0; i < commands.length; i++) {
            int[] temp = Arrays.copyOfRange(array, commands[i][0]-1, commands[i][1]);
            Arrays.sort(temp);
            answer[i] = temp[commands[i][2]-1];
        } 
        return answer;
    }
}

✔ 문제

🔎 풀이

수학에서 에라토스테네스의 체는 소수를 찾는 방법이다.

📍 알고리즘

1. 2부터 소수를 구하고자 하는 구간의 모든 수를 나열한다. 그림에서 회색 사각형으로 두른 수들이 여기에 해당한다.
2. 2는 소수이므로 오른쪽에 2를 쓴다. (빨간색)
3. 자기 자신을 제외한 2의 배수를 모두 지운다.
4. 남아있는 수 가운데 3은 소수이므로 오른쪽에 3을 쓴다. (초록색)
5. 자기 자신을 제외한 3의 배수를 모두 지운다.
6. 남아있는 수 가운데 5는 소수이므로 오른쪽에 5를 쓴다. (파란색)
7. 자기 자신을 제외한 5의 배수를 모두 지운다.
8. 남아있는 수 가운데 7은 소수이므로 오른쪽에 7을 쓴다. (노란색)
9. 자기 자신을 제외한 7의 배수를 모두 지운다.
10. 위의 과정을 반복하면 구하는 구간의 모든 소수가 남는다.

✔ 나의코드

문제 설명

1937년 Collatz란 사람에 의해 제기된 이 추측은, 주어진 수가 1이 될때까지 다음 작업을 반복하면, 모든 수를 1로 만들 수 있다는 추측입니다. 작업은 다음과 같습니다.

1-1. 입력된 수가 짝수라면 2로 나눕니다. 
1-2. 입력된 수가 홀수라면 3을 곱하고 1을 더합니다.
2. 결과로 나온 수에 같은 작업을 1이 될 때까지 반복합니다.

예를 들어, 입력된 수가 6이라면 6→3→10→5→16→8→4→2→1 이 되어 총 8번 만에 1이 됩니다. 위 작업을 몇 번이나 반복해야하는지 반환하는 함수, solution을 완성해 주세요. 단, 작업을 500번을 반복해도 1이 되지 않는다면 –1을 반환해 주세요.

제한 사항

• 입력된 수, num은 1 이상 8000000 미만인 정수입니다.

입출력 예

6	8
16	4
626331	-1

입출력 예 설명

입출력 예 #1
문제의 설명과 같습니다.

입출력 예 #2
16 -> 8 -> 4 -> 2 -> 1 이되어 총 4번만에 1이 됩니다.

입출력 예 #3
626331은 500번을 시도해도 1이 되지 못하므로 -1을 리턴해야합니다.

---

풀이코드

🔑 비교적 간단한 문제였지만 testcase3번이 자꾸 틀림... 

형변환을 안해주면 3번이 자꾸 488번으로 나옴...

입력받은 num을 int 그대로 사용하면 오버플로우가 나서 정확히 측정이 안되므로 long n = num; 으로 형변환이 필요함

문제 설명

풀이

class Solution {
    public int[] solution(int[] lottos, int[] win_nums) {
        int[] answer = new int[2];
        int[] rank = {6, 6, 5, 4, 3, 2, 1};
        
        int cnt = 0;
    int bonus = 0;
        
        for (int i = 0; i < 6; i++) {
            for (int z = 0; z < 6; z++) {
        if (lottos[i]==win_nums[z]) {
        cnt++;
        }
        }
        if(lottos[i]==0) {
        bonus++;
            }
        }
        answer[1] = rank[cnt];
        answer[0] = rank[cnt+bonus];       
        return answer;
    }
}

문제 설명

풀이

너무 쓸데없이 긴 느낌...

문제

• 예산

문제 설명

S사에서는 각 부서에 필요한 물품을 지원해 주기 위해 부서별로 물품을 구매하는데 필요한 금액을 조사했습니다. 그러나, 전체 예산이 정해져 있기 때문에 모든 부서의 물품을 구매해 줄 수는 없습니다. 그래서 최대한 많은 부서의 물품을 구매해 줄 수 있도록 하려고 합니다.

물품을 구매해 줄 때는 각 부서가 신청한 금액만큼을 모두 지원해 줘야 합니다. 예를 들어 1,000원을 신청한 부서에는 정확히 1,000원을 지원해야 하며, 1,000원보다 적은 금액을 지원해 줄 수는 없습니다.

부서별로 신청한 금액이 들어있는 배열 d와 예산 budget이 매개변수로 주어질 때, 최대 몇 개의 부서에 물품을 지원할 수 있는지 return 하도록 solution 함수를 완성해주세요.

제한사항

• d는 부서별로 신청한 금액이 들어있는 배열이며, 길이(전체 부서의 개수)는 1 이상 100 이하입니다.
• d의 각 원소는 부서별로 신청한 금액을 나타내며, 부서별 신청 금액은 1 이상 100,000 이하의 자연수입니다.
• budget은 예산을 나타내며, 1 이상 10,000,000 이하의 자연수입니다.

---

 

입출력 예

 

입출력 예 설명

입출력 예 #1
각 부서에서 [1원, 3원, 2원, 5원, 4원]만큼의 금액을 신청했습니다. 만약에, 1원, 2원, 4원을 신청한 부서의 물품을 구매해주면 예산 9원에서 7원이 소비되어 2원이 남습니다. 항상 정확히 신청한 금액만큼 지원해 줘야 하므로 남은 2원으로 나머지 부서를 지원해 주지 않습니다. 위 방법 외에 3개 부서를 지원해 줄 방법들은 다음과 같습니다.

• 1원, 2원, 3원을 신청한 부서의 물품을 구매해주려면 6원이 필요합니다.
• 1원, 2원, 5원을 신청한 부서의 물품을 구매해주려면 8원이 필요합니다.
• 1원, 3원, 4원을 신청한 부서의 물품을 구매해주려면 8원이 필요합니다.
• 1원, 3원, 5원을 신청한 부서의 물품을 구매해주려면 9원이 필요합니다.

3개 부서보다 더 많은 부서의 물품을 구매해 줄 수는 없으므로 최대 3개 부서의 물품을 구매해 줄 수 있습니다.

입출력 예 #2
모든 부서의 물품을 구매해주면 10원이 됩니다. 따라서 최대 4개 부서의 물품을 구매해 줄 수 있습니다.

 

---

 나의 예시 코드

여기서 핵심은 예산을 나눠주면서 마이너스 값이 나오기 전까지 계산해주며 남은 금액은 도출할 필요가 없다는 것입니다.

예를들어, testcase 1번 처럼 

• 1원, 2원, 3원을 신청한 부서의 물품을 구매해주려면 6원이 필요합니다.
• 1원, 2원, 5원을 신청한 부서의 물품을 구매해주려면 8원이 필요합니다.
• 1원, 3원, 4원을 신청한 부서의 물품을 구매해주려면 8원이 필요합니다.
• 1원, 3원, 5원을 신청한 부서의 물품을 구매해주려면 9원이 필요합니다.

남은 금액은 각각 3원, 1원, 0원이지만 나눠줄 수 있는 최대 부서는 3개로 동일합니다. 따라서 남은 금액은 고려할 필요가 없습니다.

여러분은 백엔드라고 하면 flask나 django, jsp 등등을 생각하는 경향이 있다.

뭐 틀린말은 아니지만 이는 backend중에서는 앞단이다.

내부적으로 데이터를 처리하고 가공하는 backend중에서도 뒷단이 존재한다.

즉 backend에서도 front, back이 나뉘게 된다.

back의 front와 back의 back, 보통 앞은 RESTful, SOAP, GraphQL등의 API서버라고 불리게 되고 뒷단은 Analysis서버라고 불리게된다.

이 둘을 한 서버에서 돌리는건 위험하다(실무에서는 한 컴퓨터에서 한 서버를 돌리니까 정확히 말하면 한 컴퓨터에서 돌리는게 위험하다고 볼 수 있다.)

왜냐하면 사용자가 접속해서 트래픽을 발생시키는 API와 데이터를 계속해서 처리하고 있는 분석서버가 같이 돌아가면

사용자가 갑자기 트래픽이 폭주하는 상황에서 뜬금없이 분석서버가 사망,

반대로 갑자기 분석할 데이터양이 늘어나서 폭주해서 API서버가 뜬금없이 죽어서 분명 분석서버가 죽었는데 로그인까지 못하는 어처구니 없는 상황이 일어난다.

그래서 서버는 계속해서 분할하는게 가용성측면에서 이득을 본다. 그리고 이렇게 해야 확장성도 용이하게 된다.

이러한 구조를 MSA(마이크로 서비스 아키텍쳐)라고 부르게된다. 어찌됬던 서버들이 분할된다는 것이다.

문제는 이렇게 분할된 서버들을 어떻게 데이터를 주고받을 것이냐는 것이다.

사실 그냥 다이렉트로 주고받으면 안되냐?라고 생각할 수 있다.

하지만 그렇게 하지 않는 정말 실무적인 이유가 있다.

가령 API서버와 분석서버간의 통신을 예시로 들어보자. 분석서버가 데이터 분석을 끝내고 이를 API서버로 요청해서 데이터를 적재한다고 가정하자.

근데 분석서버의 데이터가 갑자기 폭주했다고 가정하자. 이 때 API서버가 폭주하는 데이터를 버텨내지 못하고... 죽어버렸다면?

서비스는 멈추게 된다. 

그래서 큐에 적재하고 큐에서 완충역활을 하는 녀석이 있어주면 좋다.

데이터가 폭주하는 최악에 상황에서 어짜피 죽는건 큐다. 그럼 API서버는 무사하므로 일반 웹은 계속 돌아간다.

그럼 분석은 추가적으로 안되겠지만 DB도 무사하고 인증서버도 무사하므로 그냥 평소처럼 웹을 사용할 수 있다.

그런데 심지어 그런 외부의 큐가 AMQP형식을 지키고 있네?? 오 땡큐!

그런데 메이저 언어들 지원해서 심지어 서버의 형식역시 달라도 되네 오 굿!

그래서 RabbitMQ가 실무에서 자주 쓰이는 것이다.

요약하자면