public class Lotto {
    public static void main(String[] args){ //예시 입력값
        int[] lotto = {44, 1, 0, 0, 31, 25};
        int[] win_nums ={31, 10, 45, 1, 6, 19};

        int[] result = solution(lotto, win_nums);
        for(int i =0; i<result.length; i++){
            System.out.println(result[i]);
        }
    }


    public static int[] solution(int[] lottos, int[] win_nums) {
        int count1 = 0;
        int zero_count = 0;
        for(int i=0; i<6; i++){
             if(lottos[i] == 0  && i != 5){ //0값을 찾으면 i를 1올리고 0의 갯수를 세준다(6이면 범위를 벗어나기 때문에 5까지만)
                    zero_count++;
                    continue;
                }
            else if(lottos[i] == 0  && i == 5){ //0값을 찾으면 i를 1올리고 0의 갯수를 세준다(5번째에서 0이 나오면 반복문을 종료시킨다)
                    zero_count++;
                    break;
                }
            for(int j =0; j<6; j++){
                if(lottos[i] == win_nums[j]){ //일치하는 값을 찾으면 j를 증가시키는 것을 멈추고 i를 1올린다
                    count1++;
                    break;
                }
            }
        }
        //if문을 써도 되지만 getRanking을 쓰는 이유는 if else if문을 쓰면 코드가 2배가 되어서 최대한 간결하게 할려고 했다
        int ranking1 = getRanking(count1 + zero_count);
        int ranking = getRanking(count1);
        
        int[] count = {ranking1, ranking};
        return count;
    }

    public static int getRanking(int count) { //count의 갯수를 세고 등수를 셈
        switch (count) {
            case 0:
            case 1:
                return 6;
            case 2:
                return 5;
            case 3:
                return 4;
            case 4:
                return 3;
            case 5:
                return 2;
            case 6:
                return 1;
            default:
                return 0; 
        }
    }
    
}

public class delivery {

    static final int INF = 1000000;

    public static void main(String[] args) {
        Solution s = new Solution();
        int N = 5;
        int[][] road = { { 1, 2, 1 }, { 2, 3, 3 }, { 5, 2, 2 }, { 1, 4, 2 }, { 5, 3, 1 }, { 5, 4, 2 } };
        int K = 3;
        System.out.println(s.solution(N, road, K));
    }
}

class Solution {
    public int solution(int N, int[][] road, int K) {
       int[][] map = new int[N][N];                                      
	    
	    for (int i = 0; i < map.length; i++) {
	        for (int j = 0; j < map.length; j++) {
	            if (i == j) {                                               
	                map[i][j] = 0;    //배열 기준으로 자신의 자리를 0으로 만들어준다. 1번째 노드이면 배열 기준으로 [0,0]
	                continue;
	            }
	            map[i][j] = 500001;   //나머지는 거리를 구해야하기 때문에 최대값으로 바꾸어준다 만약 거리가 존재한다면 나중에 바꿔주고 거리가 존재하지 않는다면 500001로 그대로 두어진다.                                  
	        }
	    }

	    for (int i = 0; i < road.length; i++) {   //양방향 통행이기 때문에 왔다갈다 할때의 거리가 같이 때문에 값이 변하는 것을 2개 넣어준다.(단방향 x)
	        if(map[road[i][0] - 1][road[i][1] - 1] < road[i][2]) 
	        	continue;   
	        map[road[i][0] - 1][road[i][1] - 1] = road[i][2];                 //1 ex) 1번에서 2번으로 갈떄의 거리
        
	        map[road[i][1] - 1][road[i][0] - 1] = road[i][2];                 //2 ex) 2번에서 1번으로 갈떄의 거리
	    }
	    
	    for (int k = 0; k < N; k++) {                          //첫번째 노드부터 최적의 경로를 찾는다(연결된 모든 경로를 다 찾는다)             
	        for (int i = 0; i < N; i++) {                      
	            for (int j = 0; j < N; j++) {
	                if (map[i][j] > map[i][k] + map[k][j]) {
	                    map[i][j] = map[i][k] + map[k][j];
	                }
	            }
	        }
	    }

	    int count = 0;                                                      

	    for (int i = 0; i < map.length; i++) {      //경로를 다 찾으면 [0][i]번째 혹은 [i][0]번째 경로들이 싹 다오는데 거기서 k보다 작은 것들을 출력하면 된다.
	        if (map[0][i] <= K) 
	            count++;
	    }
	    
	    return count;
    }
}

 

출처 : [프로그래머스]배달 /Java (velog.io)

문제 설명
점심시간에 도둑이 들어, 일부 학생이 체육복을 도난당했습니다. 다행히 여벌 체육복이 있는 학생이 이들에게 체육복을 빌려주려 합니다. 학생들의 번호는 체격 순으로 매겨져 있어, 바로 앞번호의 학생이나 바로 뒷번호의 학생에게만 체육복을 빌려줄 수 있습니다. 예를 들어, 4번 학생은 3번 학생이나 5번 학생에게만 체육복을 빌려줄 수 있습니다. 체육복이 없으면 수업을 들을 수 없기 때문에 체육복을 적절히 빌려 최대한 많은 학생이 체육수업을 들어야 합니다.

전체 학생의 수 n, 체육복을 도난당한 학생들의 번호가 담긴 배열 lost, 여벌의 체육복을 가져온 학생들의 번호가 담긴 배열 reserve가 매개변수로 주어질 때, 체육수업을 들을 수 있는 학생의 최댓값을 return 하도록 solution 함수를 작성해주세요.

제한사항
전체 학생의 수는 2명 이상 30명 이하입니다.
체육복을 도난당한 학생의 수는 1명 이상 n명 이하이고 중복되는 번호는 없습니다.
여벌의 체육복을 가져온 학생의 수는 1명 이상 n명 이하이고 중복되는 번호는 없습니다.
여벌 체육복이 있는 학생만 다른 학생에게 체육복을 빌려줄 수 있습니다.
여벌 체육복을 가져온 학생이 체육복을 도난당했을 수 있습니다. 이때 이 학생은 체육복을 하나만 도난당했다고 가정하며, 남은 체육복이 하나이기에 다른 학생에게는 체육복을 빌려줄 수 없습니다.
입출력 예
n	lost	reserve	return
5	[2, 4]	[1, 3, 5]	5
5	[2, 4]	[3]	4
3	[3]	[1]	2
import java.util.Arrays;
class Solution {
    public int solution(int n, int[] lost, int[] reserve) {
       int []student = new int[n+1];
        for (int r:reserve) student[r] += 1 ; //여분이 있는 학생수는 1로 지정해준다
        for (int l:lost) student[l] -= 1; //도난당한 학생은 -1로 지정해준다
        //아무것도 포함 안되는 학생은 0으로 자동 지정해준다
        
        int idx = 1;
        
        while(idx<n){
            
            if(Math.abs(student[idx]) ==1){ //여분,도난당한 학생을 검색한다
                if(student[idx] + student[idx+1] == 0){ //여분 도난 당한 학생이 일치하면 이 조건문이 실행되면서 0으로 값이 바뀐다
                    student[idx] = 0;
                    student[idx+1] = 0;
                    idx ++;
                }
            }

            idx ++;
        }
        
        int count = 0;
        for (int s:student) if(s == -1) count ++;
        return n - count;
       


       
    }
}​
문제 설명
두 정수 left와 right가 매개변수로 주어집니다. left부터 right까지의 모든 수들 중에서, 약수의 개수가 짝수인 수는 더하고, 약수의 개수가 홀수인 수는 뺀 수를 return 하도록 solution 함수를 완성해주세요.

제한사항
1 ≤ left ≤ right ≤ 1,000
입출력 예
left	right	result
13	17	43
24	27	52
class Solution {
    public int solution(int left, int right) {
        
        int cnt = 0; //약수 갯수
        int result = 0; // 최종 return값 
        int repetition = left; //처음 시작값
        while(repetition <= right){
        for(int i = 1; i*i  <= repetition ; i++){
            if(repetition % i == 0){
                if(repetition / i == i){
                    cnt++;
                }
                else{
                    cnt +=2;
                }
               
            }
         
        }
        if(cnt % 2 == 0){ //약수의 개수가 짝수이라면~
            result += repetition;
            cnt =0;

        }
        else{ //약수의 개수가 홀수라면~
            result -= repetition;
            cnt = 0;
        }
        repetition++;

    }
        return result;
    
    }
}
1 x 1 크기의 칸들로 이루어진 직사각형 격자 형태의 미로에서 탈출하려고 합니다. 각 칸은 통로 또는 벽으로 구성되어 있으며, 벽으로 된 칸은 지나갈 수 없고 통로로 된 칸으로만 이동할 수 있습니다. 통로들 중 한 칸에는 미로를 빠져나가는 문이 있는데, 이 문은 레버를 당겨서만 열 수 있습니다. 레버 또한 통로들 중 한 칸에 있습니다. 따라서, 출발 지점에서 먼저 레버가 있는 칸으로 이동하여 레버를 당긴 후 미로를 빠져나가는 문이 있는 칸으로 이동하면 됩니다. 이때 아직 레버를 당기지 않았더라도 출구가 있는 칸을 지나갈 수 있습니다. 미로에서 한 칸을 이동하는데 1초가 걸린다고 할 때, 최대한 빠르게 미로를 빠져나가는데 걸리는 시간을 구하려 합니다.
미로를 나타낸 문자열 배열 maps가 매개변수로 주어질 때, 미로를 탈출하는데 필요한 최소 시간을 return 하는 solution 함수를 완성해주세요. 만약, 탈출할 수 없다면 -1을 return 해주세요.

제한사항
5 ≤ maps의 길이 ≤ 100
5 ≤ maps[i]의 길이 ≤ 100
maps[i]는 다음 5개의 문자들로만 이루어져 있습니다.
S : 시작 지점
E : 출구
L : 레버
O : 통로
X : 벽
시작 지점과 출구, 레버는 항상 다른 곳에 존재하며 한 개씩만 존재합니다.
출구는 레버가 당겨지지 않아도 지나갈 수 있으며, 모든 통로, 출구, 레버, 시작점은 여러 번 지나갈 수 있습니다.
입출력 예
maps	result
["SOOOL","XXXXO","OOOOO","OXXXX","OOOOE"]	16
["LOOXS","OOOOX","OOOOO","OOOOO","EOOOO"]	-1
import java.util.ArrayDeque;
import java.util.Queue;
class Solution {
    public int solution(String[] maps) {
        int n = maps.length;   //maps의 배열 길이만큼 판을 세로칸을 만든다
        int m = maps[0].length(); //maps[0]의 문자열 길이만큼 가로칸을 만든다.

        // 시작 지점, 출구, 레버의 위치를 찾습니다./시작지점과 출구 레버 위치는 매번 다르기 때문이다
        int[] start = null;
        int[] exit = null;
        int[] lever = null;

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (maps[i].charAt(j) == 'S') {
                    start = new int[]{i, j};
                } else if (maps[i].charAt(j) == 'E') {
                    exit = new int[]{i, j};
                } else if (maps[i].charAt(j) == 'L') {
                    lever = new int[]{i, j};
                }
            }
        }

        // BFS를 위한 방향을 정의합니다.
        int[][] directions = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

   

        // 시작 지점부터 레버까지의 최단 경로와 레버부터 출구까지의 최단 경로를 찾습니다.
        int startToLever = bfs(start, lever, maps, n, m, directions);
        int leverToExit = bfs(lever, exit, maps, n, m, directions);

        // 탈출이 불가능한 경우 -1을 반환합니다.
        if (startToLever == -1 || leverToExit == -1) {
            
            return -1;
        }
        else{
            return startToLever + leverToExit;  // 최단 경로의 합을 반환합니다.

        }
    }
     static int bfs(int[] start, int[] target, String[] maps, int n, int m, int[][] directions) {
        boolean[][] visited = new boolean[n][m];
        Queue<int[]> queue = new ArrayDeque<>();
        queue.add(new int[]{start[0], start[1], 0});
        visited[start[0]][start[1]] = true;

        while (!queue.isEmpty()) {
            int[] current = queue.poll();
            int x = current[0];
            int y = current[1];
            int steps = current[2]; //움직인 숫자

            if (x == target[0] && y == target[1]) {
                return steps;
            }

            for (int[] direction : directions) {
                int newX = x + direction[0];
                int newY = y + direction[1];

                if (newX >= 0 && newX < n && newY >= 0 && newY < m && !visited[newX][newY] && maps[newX].charAt(newY) != 'X') {
                    queue.add(new int[]{newX, newY, steps + 1});
                    visited[newX][newY] = true;
                }
            }
        }

        return -1;
    }
}
머쓱이는 태어난 지 11개월 된 조카를 돌보고 있습니다. 
조카는 아직 "aya", "ye", "woo", "ma" 네 가지 발음과 네 가지 발음을 조합해서 만들 수 있는 발음밖에 하지 못하고 연속해서 같은 발음을 하는 것을 어려워합니다. 
문자열 배열 babbling이 매개변수로 주어질 때, 머쓱이의 조카가 발음할 수 있는 단어의 개수를 return하도록 solution 함수를 완성해주세요.

제한사항
1 ≤ babbling의 길이 ≤ 100
1 ≤ babbling[i]의 길이 ≤ 30
문자열은 알파벳 소문자로만 이루어져 있습니다.
입출력 예
babbling	result
["aya", "yee", "u", "maa"]	1
["ayaye", "uuu", "yeye", "yemawoo", "ayaayaa"]	2
class Solution {
    public int solution(String[] babbling) {
             int count = babbling.length; //특정 조건이 성립 안하면 뺄 것이기 때문에 길이를 구한다.
        for(int i=0; i<babbling.length; i++){
           //영어로 바꾸는게 아니라 숫자인 문자열로 바꾼 이유는 영어가 입력이 될수도 있기 때문이다.
            if(babbling[i].contains("aya")){
                babbling[i] = babbling[i].replaceAll("aya", "1");
                 
            }
            if(babbling[i].contains("ye")){
                babbling[i] =babbling[i].replaceAll("ye", "2");
               

            }
            if(babbling[i].contains("woo")){
                babbling[i] =babbling[i].replaceAll("woo", "3");
                

            }
            if(babbling[i].contains("ma") ){
                babbling[i] =babbling[i].replaceAll("ma", "4");
                
            }
        
        }


        for(int i =0; i<babbling.length; i++){
            for(int j=0; j<babbling[i].length(); j++){
            	//중복되는 단어가 있으면 if문을 통과시킨다.
                if(babbling[i].contains("11") || babbling[i].contains("22")  || babbling[i].contains("33")  || babbling[i].contains("44")  ){
                    count--;
                    break;
                  
                }
                //1,2,3,4가 아닌 char이 있으면 else if문을 통과시킨다.
                else if(babbling[i].charAt(j) != '1' && babbling[i].charAt(j) != '2'  &&  babbling[i].charAt(j) != '3'  &&  babbling[i].charAt(j) != '4'  ){
                    count--;
                    break;
                }
            }
           
        }
       
        return count;

    }
}
카카오톡 게임별의 하반기 신규 서비스로 다트 게임을 출시하기로 했다. 다트 게임은 다트판에 다트를 세 차례 던져 그 점수의 합계로 실력을 겨루는 게임으로, 모두가 간단히 즐길 수 있다.
갓 입사한 무지는 코딩 실력을 인정받아 게임의 핵심 부분인 점수 계산 로직을 맡게 되었다. 다트 게임의 점수 계산 로직은 아래와 같다.

다트 게임은 총 3번의 기회로 구성된다.
각 기회마다 얻을 수 있는 점수는 0점에서 10점까지이다.
점수와 함께 Single(S), Double(D), Triple(T) 영역이 존재하고 각 영역 당첨 시 점수에서 1제곱, 2제곱, 3제곱 (점수1 , 점수2 , 점수3 )으로 계산된다.
옵션으로 스타상(*) , 아차상(#)이 존재하며 스타상(*) 당첨 시 해당 점수와 바로 전에 얻은 점수를 각 2배로 만든다. 아차상(#) 당첨 시 해당 점수는 마이너스된다.
스타상(*)은 첫 번째 기회에서도 나올 수 있다. 이 경우 첫 번째 스타상(*)의 점수만 2배가 된다. (예제 4번 참고)
스타상(*)의 효과는 다른 스타상(*)의 효과와 중첩될 수 있다. 이 경우 중첩된 스타상(*) 점수는 4배가 된다. (예제 4번 참고)
스타상(*)의 효과는 아차상(#)의 효과와 중첩될 수 있다. 이 경우 중첩된 아차상(#)의 점수는 -2배가 된다. (예제 5번 참고)
Single(S), Double(D), Triple(T)은 점수마다 하나씩 존재한다.
스타상(*), 아차상(#)은 점수마다 둘 중 하나만 존재할 수 있으며, 존재하지 않을 수도 있다.
0~10의 정수와 문자 S, D, T, *, #로 구성된 문자열이 입력될 시 총점수를 반환하는 함수를 작성하라.

입력 형식
"점수|보너스|[옵션]"으로 이루어진 문자열 3세트.
예) 1S2D*3T

점수는 0에서 10 사이의 정수이다.
보너스는 S, D, T 중 하나이다.
옵선은 *이나 # 중 하나이며, 없을 수도 있다.
출력 형식
3번의 기회에서 얻은 점수 합계에 해당하는 정수값을 출력한다.
예) 37

입출력 예제
예제	dartResult	answer	설명
1	1S2D*3T	37	11 * 2 + 22 * 2 + 33
2	1D2S#10S	9	12 + 21 * (-1) + 101
3	1D2S0T	3	12 + 21 + 03
4	1S*2T*3S	23	11 * 2 * 2 + 23 * 2 + 31
5	1D#2S*3S	5	12 * (-1) * 2 + 21 * 2 + 31
6	1T2D3D#	-4	13 + 22 + 32 * (-1)
7	1D2S3T*	59	12 + 21 * 2 + 33 * 2

 

class Solution {
    public int solution(String dartResult) {
        int Lastvalue = 0;
        int nowvalue = 0;
        int beforevalue = 0;
        double result = 0;
         for(int i =0; i<dartResult.length(); i++){
            switch (dartResult.charAt(i)) {
                case 'S':
                    nowvalue = nowvalue;
                    
                    break;
                case 'D':
                	//Math.pow는 실수형을 받기 때문에 result로 받고 int로 형 변환 해주었다.
                    result = Math.pow(nowvalue,2);
                    nowvalue = (int)result;
                    
                    break;
                case 'T':
                    result = Math.pow(nowvalue,3);
                    nowvalue = (int)result;
                    
                    break;
                case '*':
                    //*일시 현재값과 전값에 *2를 해준다
                    beforevalue = beforevalue * 2;
                    nowvalue = nowvalue *2;

                    break;
                case '#':
                    nowvalue = nowvalue * -1;
                    
                    break;
            
                default:
                    //만약 숫자가 10일시 이 조건을 통과하도록 한다
                    if(dartResult.charAt(i) == '1' && dartResult.charAt(i+1) == '0'){
                        Lastvalue = beforevalue;
                        beforevalue = nowvalue;
                        nowvalue = 10;
                        i++;
                        break;

                    }
                    else{
                        //문자열 3세트이기때문에 3개의 변수를 만들어준다 && 값이 숫자라면 이 조건을 통과시킨다
                        Lastvalue = beforevalue; //마지막값
                        beforevalue  = nowvalue; //중간값
                        nowvalue = Character.getNumericValue(dartResult.charAt(i)); //첫번째 값
                        break;
                    }
                  
            }
        }
        //3개의 값을 더한다
        int sum = Lastvalue+beforevalue+nowvalue;
        return sum;
    }
}

+ Recent posts