Merge branch 'main' of https://github.com/kkak-java/Algorithm

Author: Yoepee

.idea/.name

@@ -0,0 +1,59 @@
+import java.util.ArrayList;
+
+class PG_17681 {
+    public int solution(String dartResult) {
+        int answer = 0;
+        ArrayList<Integer> scores = new ArrayList<>(); //최종 점수 3개를 저장하는 배열
+        int i = 0;
+        
+        //점수 저장 부분
+        while(i<dartResult.length()){
+            int num = 0;
+            
+            if (Character.isDigit(dartResult.charAt(i)) && Character.isDigit(dartResult.charAt(i+1))){ //연속으로 숫자가 2자리일때(10일 경우)
+                num = 10;
+                i+=2;
+            }
+            else if (Character.isDigit(dartResult.charAt(i))){
+                num = dartResult.charAt(i) - '0';
+                i++;
+            }
+            
+            //문자 저장 부분
+            if(dartResult.charAt(i) == 'S'){
+                scores.add(num);
+            }
+            else if(dartResult.charAt(i) == 'D'){
+                scores.add(num*num);
+            }
+            else{
+                scores.add(num*num*num);
+            }
+            
+            //마지막에 옵션 없으므로 종료
+            i++;
+            if(i==dartResult.length()){
+                break;
+            }
+            
+            //옵션 적용 부분
+            int index = scores.size()-1; //옵션을 적용할 점수가 몇번째인지
+            if(dartResult.charAt(i)=='*'){
+                scores.set(index, scores.get(index)*2);
+                if(index!=0){
+                    scores.set(index-1, scores.get(index-1)*2);
+                }
+                i++;
+            }
+            else if(dartResult.charAt(i)=='#'){
+                scores.set(index, scores.get(index)*(-1));
+                i++;
+            }
+        }
+        
+        for (int score : scores){
+            answer+=score;
+        }
+        return answer;
+    }
+}

src/week01/Chanjong/PG_17682.java

@@ -0,0 +1,82 @@
+package week01.Yoepee;
+
+// 괄호 변환
+public class PG_60058 {
+    static class Solution {
+        public String solution(String p) {
+            String answer = "";
+            // 빈 문자열인 경우, 빈 문자열 반환
+            if (p.length() == 0) return "";
+            // string의 길이가 2일 경우 올바른 괄호 문자열은 () 밖에 없으므로 () 반환
+            else if (p.length() == 2) return "()";
+
+            // u가 끝나는 index
+            int start = 0;
+            // 괄호가 제대로 닫혔는지 확인하는 변수
+            int count = 0;
+            // 균형잡힌 괄호 문자열 u가 올바른 괄호 문자열인지 확인하는 변수
+            boolean isRight = true;
+
+            // 균형잡힌 문자열 p를 u와 v로 나누는 로직
+            for (int i = 0; i<p.length(); i++){
+                count += p.charAt(i) == '(' ? 1 : -1;
+                // count가 음수로 한번이라도 변경되면 올바른 괄호 문자열이 아님.
+                if (count < 0) isRight = false;
+
+                // count가 0이 되면 괄호의 열림과 닫힘이 짝이 맞음
+                // 균형잡힌 괄호 문자열임.
+                if (count == 0){
+                    start = i+1;
+                    answer += p.substring(0, start);
+                    break;
+                }
+            }
+            // 반복문을 모두 돌았는데 균형잡힌 문자열이 아닌 경우 u의 값을 문자열 전체로 지정
+            if (count != 0) {
+                start = p.length();
+                answer += p.substring(0, start);
+            }
+
+            // p에서 u를 제외한 문자열 v를 재귀함수를 통해 반환
+            String v = solution(p.substring(start));
+            // 수행한 결과를 문자열 u에 이어 붙임
+            answer+=v;
+
+            // 문자열 u가 올바른 괄호 문자열이 아닌 경우 로직에 따라 processU 진행
+            if (!isRight) {
+                return processU(p.substring(0, start), v);
+            }
+
+            // 최종 결과 answer 반환
+            return answer;
+        }
+
+        // 문자열 u가 올바른 괄호 문자열이 아닌경우 동작하는 로직
+        private String processU(String p, String v){
+            String answer = "";
+            // 4-1. 빈 문자열에 첫 번째 문자로 '('를 붙입니다.
+            answer += "(";
+            // 4-2. 문자열 v에 대해 1단계부터 재귀적으로 수행한 결과 문자열을 이어 붙입니다.
+            answer += v;
+            // 4-3. ')'를 다시 붙입니다.
+            answer += ")";
+            // 4-4. u의 첫 번째와 마지막 문자를 제거하고, 나머지 문자열의 괄호 방향을 뒤집어서 뒤에 붙입니다.
+            for (int i = 1; i<p.length()-1; i++){
+                answer += p.charAt(i) =='(' ? ')' : '(';
+            }
+
+            // 4-5. 생성된 문자열을 반환합니다.
+            return answer;
+        }
+    }
+    public static void main(String[] args) {
+        Solution s = new Solution();
+
+        // 정상 결과 : "(()())()"
+        System.out.println(s.solution("(()())()"));
+        // 정상 결과 : "()"
+        System.out.println(s.solution(")("));
+        // 정상 결과 : "()(())()"
+        System.out.println(s.solution("()))((()"));
+    }
+}

src/week01/Yoepee/PG_60058.java

@@ -0,0 +1,77 @@
+package week02.Juchan;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+public class PG_42586 {
+    static class Solution {
+        public int[] solution(int[] progresses, int[] speeds) {
+            // 각 작업이 완료되기까지 남은 '일 수'를 저장할 큐
+            Queue<Integer> queue = new LinkedList<>();
+
+            //(100-진도율)/개발 속도를 통해 남은 일 수 계산
+            for (int i = 0; i < progresses.length; i++) {
+                int day = (int) Math.ceil((100.0 - progresses[i]) / speeds[i]); //ex 3.8888 일이면 4일 필요하기에 ceil 함수를 사용해서 올림 처리 후 형 변환
+                queue.offer(day);
+            }
+            List<Integer> result = new ArrayList<>();
+
+            // 첫번 째 배포 일 수를 뽑아냅니다.
+            while (!queue.isEmpty()) {
+                int current = queue.poll();
+                int count = 1;
+
+                // 배포일과 비교하여 큐의 첫 번째 일 수가 작거나 같으면 같이 묶어서 리스트에 저장합니다.
+                while (!queue.isEmpty() && queue.peek() <= current) {
+                    queue.poll();
+                    count++;
+                }
+                result.add(count);
+            }
+            int[] answer = new int[result.size()];
+            for (int i = 0; i < result.size(); i++) {
+                answer[i] = result.get(i);
+            }
+            return answer;
+        }
+    }
+
+    public static void main(String[] args) { //테스트
+        Solution solution = new Solution();
+
+
+        int[] progresses = {93, 30, 55};
+        int[] speeds = {1, 30, 5};
+
+        int[] result = solution.solution(progresses, speeds);
+
+
+        System.out.print("[");
+        for (int i = 0; i < result.length; i++) {
+            System.out.print(result[i]);
+            if (i != result.length - 1) { //마지막 요소는 , 를 빼줍니다.
+                System.out.print(", ");
+            }
+        }
+        System.out.println("]");
+        // 예상 출력: [2, 1]
+    }
+}
+
+
+/**
+ * 문제
+ * 각각 기능은 진도(progress) 가 있고, 매일 각 기능마다 개발 속도(speed) 만큼 진도가 올라간다.
+ * 기능은 진도가 100% 이상이 되어야 배포 할 수 있다.
+ * 배포는 하루에 한 번, 하루가 끝난 후 진행한다.
+ * 진도가 뒤에 있는 기능이 앞 기능보다 빨리 끝날 수 있는데 뒤에 있는 기능은 앞 기능이 배포되는 시점에 같이 배포된다.
+ * <p>
+ * 풀이 방법
+ * 1. 각 기능마다 100%가 될 때까지 걸리는 날을 계산한다.(100-진도율)/개발 속도
+ * 2. 큐에서 가장 앞에 있는 기능을 꺼내 배포일을 지정한다.
+ * 3. 배포일보다 작업이 먼저 끝난 뒤에 있는 기능도 같이 묶어준다.
+ * 4. 묶인 기능의 수를 리스트에 넣어준다.
+ * 5. 리스트를 출력한다.
+ */

src/week02/Juchan/PG_42586.java

@@ -0,0 +1,42 @@
+package week02.haemin;
+
+import java.util.HashMap;
+import java.util.*;
+
+// 1
+class Solution {
+    
+    private static HashMap<String, String> map = new HashMap<>();
+    
+    public int solution1(String s) {
+        // map 구성
+        map.put("zero", "0");
+        map.put("one", "1");
+        map.put("two", "2");
+        map.put("three", "3");
+        map.put("four", "4");
+        map.put("five", "5");
+        map.put("six", "6");
+        map.put("seven", "7");
+        map.put("eight", "8");
+        map.put("nine", "9");
+        
+        for(String key : map.keySet()){
+            s = s.replaceAll(key, map.get(key));
+        }
+
+        int answer = Integer.parseInt(s);
+        return answer;
+    }
+}
+
+// 2
+//class Solution2 {
+//    public int solution(String s) {
+//        String[] strArr = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
+//        for(int i = 0; i < strArr.length; i++) {
+//            s = s.replaceAll(strArr[i], Integer.toString(i));
+//        }
+//        return Integer.parseInt(s);
+//    }
+//}