메리

백준 그리디 알고리즘 중 설탕배달

5kg짜리를 최대로 잡고  5kg 짜리를 줄이고 3kg짜리를 늘려가면서 맞춰보는 방식

import java.util.Scanner;

public class Problem2839{
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        int total = sc.nextInt();
        int count5 = total/5;

        while(count5 >= 0){
            int remain = total - count5 * 5;
            if(remain % 3 == 0){
                System.out.println(count5 + remain/3);
                return;
            }
            count5 -= 1;
        }

        System.out.println(-1);

    }
}

중첩 for문 안 쓰고 싶었는데 이게 제일 깔끔하고 쉬웠음 ㅠ

stage 총 이용자 수를 stage.length로 잡고 다음단계로 못 간 이용자를 제외시키면서 진행하는 걸 생각해내는데 어려움이 있었음..

연습해 본것

이중배열을 stream을 이용해 정렬하기

sorted( Comparator ) : 스트림의 요소를 정렬하는 데 사용됨

reversed() : 정렬 순서 뒤집기

Double[][] sortedArray = Arrays.stream(failRate)
                                .sorted(Comparator.comparingDouble((Double[] a) -> a[1]).reversed())
                                .toArray(Double[][]::new);

Comparator.naturalOrder() : 자연 정렬

Comparator.reverseOrder() : 역순 정렬

Comparator.nullsFirst(Comparator.naturalOrder()) : null을 맨 앞에 두고 정렬

Comparator.comparingInt(String::length) : 길이에 따라 정렬

import java.util.*;
import java.util.stream.*;

class Solution {
    public int[] solution(int N, int[] stages) {
        Double[][] failRate = new Double[N][2];
        int totalPlayers = stages.length; 
        
        for(int stage = 1; stage <= N ; stage++){
            int challengers = 0; //해당 스테이지의 이용자 수
            for(int s : stages){
                if(s == stage){
                    challengers += 1;
                }
            }
            
            failRate[stage-1][0] = (double) stage;
            //실패율 = challengers / totalPlayers;
            if(totalPlayers == 0){
                failRate[stage-1][1] = 0.0;
            }else{
                failRate[stage-1][1] = (double)challengers / (double)totalPlayers;
            }        
            
            //다음 단계로 못 간 이용자 제외
            totalPlayers -= challengers;
        }
        
        Double[][] sortedArray = Arrays.stream(failRate)
                                .sorted(Comparator.comparingDouble((Double[] a) -> a[1]).reversed())
                                .toArray(Double[][]::new);

        
        int[] answer = new int[N];
        for(int i=0; i<sortedArray.length; i++){
            answer[i] = sortedArray[i][0].intValue();
        }

        return answer;
    }
}

stream 연습 또했네~

import java.util.stream.*;
import java.util.*;

class Solution {
    public int solution(int[] nums) {
        int[] newNum = Arrays.stream(nums)
                        .distinct()
                        .toArray();
        int answer = newNum.length > nums.length/2 ? nums.length/2 : newNum.length;
        return answer;
    }
}

class Solution {
    public int solution(String[] friends, String[] gifts) {
        int[][] giftCount = new int[friends.length][friends.length];
        long[] giftIndex = new long[friends.length];

        //주고받은 관계 입력
        for(int i = 0 ;i< friends.length;  i++ ){
            for(int j = 0; j<friends.length; j++){
                String gift = friends[i] + " " + friends[j];
                for(String temp : gifts){
                    if(temp.equals(gift)){
                        giftCount[i][j] += 1;
                    }
                }

            }
        }

        //선물지수 입력
        for(int i=0;i< friends.length;i++){
            for(String temp : gifts) {
                String giver = temp.split(" ")[0];
                String receiver = temp.split(" ")[1];

                if (giver.equals(friends[i])) {
                    giftIndex[i] += 1;
                }

                if(receiver.equals(friends[i])){
                    giftIndex[i] -= 1;
                }
            }
        }

        int maxGift = 0;
        //선물 받을 개수 계산
        for(int i=0;i< friends.length;i++){
            int giftCnt = 0;
            for(int j =0;j< friends.length;j++){
                //자기거는 제외
                if(i==j){
                    continue;
                }
                
                //주고받은 내역 없는 경우
                if(giftCount[i][j] == giftCount[j][i]){
                    if(giftIndex[i] > giftIndex[j]){
                        giftCnt += 1;
                    }
                    
                }else{
                    //비교
                    if(giftCount[i][j] > giftCount[j][i]){
                        giftCnt += 1;
                    }
                }
                

            }
            
            if(giftCnt>maxGift) {
                maxGift = giftCnt;
            }
        }
        
        return maxGift;
    }
    
}

또 써본 mapToInt();

학생들 점수산출은 어렵지 않았는데 그 다음에

제일 큰 점수 구하기 -> 제일 큰 점수 가진 학생 구하기 -> 배열 만들기

이게 너무 싫음..

import java.util.*;
import java.util.stream.*;

class Solution {
    public int[] solution(int[] answers) {
        int[] student1 = {1, 2, 3, 4, 5}; //len 5
        int[] student2 = {2, 1, 2, 3, 2, 4, 2, 5}; //len8
        int[] student3 = {3, 3, 1, 1, 2, 2, 4, 4, 5, 5}; //len10
        
        int[] scores = new int[3];
        for(int i=0;i<answers.length;i++){
            int answer = answers[i];
            
            //학생1정답
            if(student1[i%student1.length] == answer) scores[0] += 1;
            //학생2정답
            if(student2[i%student2.length] == answer) scores[1] += 1;
            //학생3정답
            if(student3[i%student3.length] == answer) scores[2] += 1;
        }
        
        int max = Arrays.stream(scores).max().orElse(0);
        
        List<Integer> students = new ArrayList<>();
        for(int i=0;i<scores.length;i++){
            if(scores[i] == max){
                students.add(i+1);
            }
        }
        
        return students.stream()
            .mapToInt(Integer::intValue)
            .toArray();
    }
}

사실 중간에 순서 뒤집기 때문에..

그냥 단순히 나눈 순서대로 Math.pow() 해도 될텐데

진법 변환을 다 해보았다..

n진법 변환시 나머지를 어떻게 쌓는지 순서를 파악하면 간단할듯.

import java.util.*;

class Solution {
    public int solution(int n) {
        return getNumFormatTen(getNumFormatThree(n));
    }
    
    public String getNumFormatThree(int n){
        Deque<String> deque  = new ArrayDeque<>();
        while(true){
            deque.offer(Integer.toString(n % 3));
            int share = n / 3;
            if(share == 0){
                break;
            }else{
                n = share;
            } 
        }        
        StringBuilder formatThree = new StringBuilder();
         while (!deque.isEmpty()) {
            formatThree.append(deque.poll()); //넣은 순 꺼내기.
        }
        return formatThree.toString();
    }
    
    public int getNumFormatTen(String n){
        int num=0;
        for(int i=0;i<n.length();i++){
            num += Math.pow(3,i) * (n.charAt(n.length()-1-i)-'0');
        }
        return num;
    }
}

최대공약수는 영어로 The Greatest Common Factor...  혹은 Divisor...

최소공배수는 영어로 The Least Common Multiple..

최대공약수 구할 때 재귀함수 호출을 해보았다.

class Solution {
    public int[] solution(int n, int m) {
        int[] answer = new int[2];
        answer[0] = getGreatestCommonFactor(n,m);
        answer[1] = getLeastCommonMultiple(n,m,answer[0]);
        return answer;
    }
    
    //둘중의 한 쪽의 수를 나머지로 계속 나눈다..
    public int getGreatestCommonFactor(int n, int m){
        if(m == 0) return n;
        return getGreatestCommonFactor(m,n%m);
    }
    
    public int getLeastCommonMultiple(int n, int m, int gcf){
        return n*m/gcf;
    }
}

숫자들 중에 중복없이 3개의 수를 뽑는 탐색 조건 정하는게 참 헷갈렸음..

첫번째 num은 인덱스 0부터 뒤에서 -2까지

두번째 num은 그다음 인덱스부터 뒤에서 -1까지

세번째 num은 그다음 인덱스부터 맨뒤까지~

class Solution {
    public int solution(int[] nums) {
        int answer = 0;
        for(int i=0;i<nums.length-2;i++){
            for(int j=i+1;j<nums.length-1;j++){
                for(int k=j+1;k<nums.length;k++){
                    if(isPrimeNumber(nums[i]+nums[j]+nums[k])){
                        answer += 1;
                    }
                        
                }
            }
        }

        return answer;
    }
    
    public boolean isPrimeNumber(int num){
        for(int i = 2; i<= Math.sqrt(num); i++){
            if(num % i == 0) return false;    
        }
        return true;
    }
}

향상된 for문을 사용해 보았다.

class Solution {
    public int[] solution(int[] lottos, int[] win_nums) {
        //0이 몇개나 있는지 확인해야함
        //숫자 당첨 갯수 -> 최저순위
        //숫자 당첨 개수 + 0개 개수 -> 최고 순위
        
        int zeroCnt = 0;
        int winCnt = 0;
        for(int lottoNum : lottos){
            if(lottoNum==0){
                zeroCnt += 1;
                continue;
            }
            for(int winNum : win_nums){
                if(lottoNum == winNum){
                    winCnt += 1;
                    break;
                }
            }
        }
        

        int[] answer = new int[2];
        answer[0] = getRank(winCnt+zeroCnt);//최고순위
        answer[1] = getRank(winCnt);//최저순위
        return answer;
    }
    
    public int getRank(int win){
       return switch(win){
            case 6 -> 1;
            case 5 -> 2;
            case 4 -> 3;
            case 3 -> 4;
            case 2 -> 5;
            default -> 6;
        };
            
    }
}

굳이 Stack을 쓸 필요가 없고 ArrayDeque가 비교적 빠르다 하니 ArrayDeque사용

집게로 뽑으러 갔는데 인형이 없는 경우 stack 접근 안하도록 continue 처리해야함;;

import java.util.*;

class Solution {
    public int solution(int[][] board, int[] moves) {
        int answer = 0;
        Deque<Integer> stack = new ArrayDeque<>();
        for(int move : moves){
            int index = move -1;
            int dollNo = 0;
            //인형 꺼내고 0 넣기
            for(int i=0;i<board.length;i++){
                if(board[i][index] != 0){
                    dollNo = board[i][index];
                    board[i][index] = 0;
                    break;
                }
            }
            if(dollNo == 0 ) continue;
            
            if(stack.isEmpty()){
                stack.push(dollNo);
            }else{
                //마지막에 넣은 것과 같은경우
                if(stack.peek() == dollNo){
                    stack.pop();
                    answer+=2;
                }else{
                    stack.push(dollNo);
                }
            }
            
        }
        
        return answer;
    }
}