메리

11399번

제일 앞에서는 사람이 걸리는 시간은 뒤의 사람 수만큼 곱해지므로 오름차순으로 세우면 됨

import java.util.*;

public class Problem11399 {
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        int cnt = sc.nextInt(); //사람수
        sc.nextLine();
        String[] temptimes = sc.nextLine().split(" ");
        int[] times = Arrays.stream(temptimes)
                    .mapToInt(Integer::parseInt)
                    .toArray();
        Arrays.sort(times); //오름차순 정렬
        
        int timeTotal = 0;
        for(int time : times){
            timeTotal += time * cnt;
            cnt -= 1;
        }
        System.out.println(timeTotal);
    }
}

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

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;
    }
}

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;
    }
}

숫자들 중에 중복없이 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;
        };
            
    }
}

써본것

정규식 정말 오랜만에 써봤음

[^ ] : 안에 있는 문자 제외하고. 대괄호 안에서는 이스케이프 처리 하지 않아도 됨

.{2,} : .이 두번 이상

^. : .으로 시작

.$ : .이 끝에 위치

isEmpty() : 문자열 빈 것 체크 

class Solution {
    public String solution(String new_id) {
        //1단계 new_id의 모든 대문자를 대응되는 소문자로 치환합니다.
        new_id = new_id.toLowerCase();
       
        //2단계 new_id에서 알파벳 소문자, 숫자, 빼기(-), 밑줄(_), 마침표(.)를 제외한 모든 문자를 제거합니다.
        new_id = new_id.replaceAll("[^a-z0-9\\-\\_\\.]","");
        
        //3단계 new_id에서 마침표(.)가 2번 이상 연속된 부분을 하나의 마침표(.)로 치환합니다.
        new_id = new_id.replaceAll("\\.{2,}",".");  
        
        //4단계 new_id에서 마침표(.)가 처음이나 끝에 위치한다면 제거합니다.
        new_id = new_id.replaceAll("^\\.|\\.$","");
        
        //5단계 new_id가 빈 문자열이라면, new_id에 "a"를 대입합니다.
        if("".equals(new_id)){
            new_id = "a";
        }
        //if(new_id.isEmpty())
        
        //6단계 new_id의 길이가 16자 이상이면, new_id의 첫 15개의 문자를 제외한 나머지 문자들을 모두 제거합니다.
        if(new_id.length() >= 16){
            new_id = new_id.substring(0,15);
        }
        
        //만약 제거 후 마침표(.)가 new_id의 끝에 위치한다면 끝에 위치한 마침표(.) 문자를 제거합니다.
        new_id = new_id.replaceAll("\\.$","");
        
        //7단계 new_id의 길이가 2자 이하라면, new_id의 마지막 문자를 new_id의 길이가 3이 될 때까지 반복해서 끝에 붙입니다.
        if(new_id.length() <= 2){
            String lastLetter = new_id.charAt(new_id.length()-1)+"";
            while(new_id.length() < 3){
                new_id += lastLetter;  
            }
        }
        return new_id;
    }
}

새로운것

result
    .stream()    //스트림의 각 요소를 주어진 함수를 통해 새로운 스트림으로 반환
    .mapToInt(Integer::intValue)	//객체 스트림을 int 스트림으로 변환
    .toArray(); 		//스트림을 배열로

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

//비교 시에 Date 라이브러리 쓰면 안 됨(한 달 28일로 가정하므로)
//계약일시 + 유효기간 합에서 단순히 12를 나눠서 계산하면 12월인경우 곤란해짐
class Solution {
    int todayDay; 
    int todayMonth;
    int todayYear;
    public int[] solution(String today, String[] terms, String[] privacies) {
        this.todayDay = Integer.parseInt(today.split("\\.")[2]);
        this.todayMonth = Integer.parseInt(today.split("\\.")[1]);
        this.todayYear = Integer.parseInt(today.split("\\.")[0]);
        
        Map<String,Integer> termsMap = new HashMap<>();
        for(String term : terms){
            termsMap.put(term.split(" ")[0],Integer.parseInt(term.split(" ")[1]));
        }
        
        List<Integer> result = new ArrayList<>();
        for(int i=0;i<privacies.length;i++){
            String start = privacies[i].split(" ")[0];
            int duration = termsMap.get(privacies[i].split(" ")[1]);
            if(!isOK(start,duration)){
                result.add(i+1);
            }
        }
        
        return result.stream().mapToInt(Integer::intValue).toArray();
    }
    
    //모든 달은 28일로 가정
    public boolean isOK(String start, int duration){
        int dueDay = Integer.parseInt(start.split("\\.")[2]);
        int dueMonth = Integer.parseInt(start.split("\\.")[1]) + duration;
        int dueYear = Integer.parseInt(start.split("\\.")[0]);        

        while(dueMonth > 12){
            dueMonth -= 12;
            dueYear += 1;
        }
        
        
        if(dueDay == 1){
            dueDay = 28;
            if(dueMonth == 1){
                dueMonth = 12;
                dueYear -= 1;
            }else{
                dueMonth -= 1;
            }
        }else{
            dueDay -= 1;
        }
        
        
        
        
        if(dueYear < todayYear){
            return false;
        }else if(dueYear > todayYear){
            return true;
        }else{
            if(dueMonth < todayMonth){
                return false;
            }else if(dueMonth > todayMonth){
                return true;
            }else{
                if(dueDay < todayDay){
                    return false;
                }else{
                    return true;
                }
            }
        }
    
        
    }
}