Revert "Revert "feat: 문제풀이 추가""

This reverts commit f1c9087.

Author: seunggulee1007

.gitignore

@@ -5,7 +5,7 @@ build/
 !**/src/test/**/build/
 
 ### IntelliJ IDEA ###
-.idea/*
+.idea/
 *.iws
 *.iml
 *.ipr
@@ -36,4 +36,6 @@ bin/
 .vscode/
 
 ### Mac OS ###
-.DS_Store
+.DS_Store
+.idea/workspace.xml
+.idea/workspace.xml

.idea/aws.xml

@@ -1,8 +1,31 @@
 package sgyj;
 
+import java.util.ArrayList;
+import java.util.List;
+
 public class Main {
 
+
     public static void main ( String[] args ) {
-        System.out.println( "Hello world!" );
+
+        int[] array = new int[] {8, 5, 6, 2, 4};
+        for(int i=1; i<array.length; i++) {
+            int temp = array[i];
+            for(int j=i-1; j >= 0; j--) {
+                int compare = array[j];
+                if(compare <= temp)break;
+                array[j+1] = compare;
+                array[j] = temp;
+            }
+        }
+
+        List<String> objects = new ArrayList<>();
+
+        for(int i=0; i< array.length; i++) {
+            System.out.println(array[i]);
+        }
+
     }
+
+
 }

.idea/gradle.xml

@@ -0,0 +1,34 @@
+package sgyj.backjun.seunggu;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+
+public class Main1182 {
+
+    private static int answer;
+    public static void main(String[] args) {
+        try( BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
+            String[] lines = reader.readLine().split(" ");
+            int sum = Integer.parseInt(lines[1]);
+            answer = 0;
+            int[] array = Arrays.stream(reader.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();
+            dfs(0, 0, sum, array);
+            System.out.println(sum == 0? answer-1 : answer);
+        }  catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    static void dfs(int number, int total, int sum, int[] array) {
+        if(number == array.length-1) {
+            if(total == sum) answer++;
+            return;
+        }
+        dfs(number+1, total + array[number], sum, array);
+        dfs(number+1, total, sum, array);
+
+    }
+
+}

.idea/jpa-buddy.xml

@@ -0,0 +1,87 @@
+package sgyj.backjun.seunggu;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class Main12865 {
+
+    private static int max;
+    private static int count;
+    public static void main ( String[] args ) {
+        try( BufferedReader reader = new BufferedReader(new InputStreamReader( System.in))) {
+            int[] numbers = Arrays.stream( reader.readLine().split( " ")).mapToInt( Integer::parseInt).toArray();
+            max = numbers[1];
+            count = numbers[0];
+            Item[] items = getItems( reader, count );
+            System.out.println( solution( items ));
+            System.out.println(solution2( items ));
+        }catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    static int solution2( Item[] items ) {
+        int[] dp = new int[max+1];
+        Arrays.fill( dp, Integer.MIN_VALUE );
+        dp[0] = 0;
+        for(int i=1; i<items.length; i++) {
+            Item item = items[i];
+            for(int j=max; j >= item.weight; j--) {
+                dp[j] = Math.max( dp[j], dp[j-item.weight] + item.value );
+            }
+        }
+        System.out.println( Arrays.toString( dp ) );
+        return dp[max];
+    }
+
+    private static int solution ( Item[] items ) {
+        int[][] bags = new int[count+1][max+1];
+
+        for( int i=1; i<items.length; i++) {
+            Item item = items[i];
+            for(int j=1; j<=max; j++) {
+                if(j >= item.weight) {
+                    bags[i][j] = Math.max(bags[i-1][j - item.weight] + item.value, bags[i-1][j]) ;
+                } else {
+                    bags[i][j] = bags[i -1][j];
+                }
+            }
+        }
+        System.out.println( Arrays.deepToString( bags ) );
+        return bags[count][max];
+    }
+
+    private static Item[] getItems ( BufferedReader reader, int count ) throws IOException {
+        Item[] items = new Item[count+1];
+        for(int i=1; i <= count; i++) {
+            int[] item = Arrays.stream( reader.readLine().split( " " ) ).mapToInt( Integer::parseInt ).toArray();
+            items[i] = Item.of(item[0], item[1]);
+        }
+        return items;
+    }
+
+    static class Item implements Comparable<Item>{
+
+        private final int weight;
+        private final int value;
+
+        private Item ( int weight, int value ) {
+            this.weight = weight;
+            this.value = value;
+        }
+
+        public static Item of ( int weight, int value ) {
+            return new Item( weight, value );
+        }
+
+        @Override
+        public int compareTo( Item b) {
+            return this.weight - b.weight;
+        }
+    }
+
+
+
+}

.idea/misc.xml

@@ -0,0 +1,77 @@
+package sgyj.backjun.seunggu;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import java.util.Deque;
+
+public class Main14791 {
+
+
+    public static void main(String[] args) {
+        try(BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
+            int result = 0;
+            int[] array = Arrays.stream(reader.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();
+            int[] rains = Arrays.stream(reader.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();
+            Deque<Integer> deque = new ArrayDeque<>();
+            int startIndex = 0;
+            int height = rains[startIndex];
+            for(int i=0; i<rains.length; i++) {
+                if(height <= rains[i]) {
+                    height = rains[i];
+                    startIndex = i;
+                } else {
+                    break;
+                }
+            }
+            int end = startIndex;
+            for(int i=startIndex; i<rains.length; i++) {
+                if(height <= rains[i]) {
+                    result += calculateRain(deque, height);
+                    height = rains[i];
+                    end = i;
+                    deque = new ArrayDeque<>();
+                } else {
+                    deque.add(rains[i]);
+                }
+            }
+            deque = new ArrayDeque<>();
+            startIndex = rains.length-1;
+            height = rains[startIndex];
+            for(int i=rains.length-1; i >= 0; i--) {
+                if(height <= rains[i]) {
+                    height = rains[i];
+                    startIndex = i;
+                } else {
+                    break;
+                }
+            }
+
+            for(int i=startIndex; i >= end; i--) {
+                if(height <= rains[i]) {
+                    result += calculateRain(deque, height);
+                    height = rains[i];
+                    deque = new ArrayDeque<>();
+                } else {
+                    deque.add(rains[i]);
+                }
+            }
+
+
+            System.out.println(result);
+        }catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static int calculateRain(Deque<Integer> deque, int height) {
+        int answer = 0;
+        while(!deque.isEmpty()) {
+            answer += (height - deque.pop());
+        }
+        return answer;
+    }
+
+}

.idea/sonarlint/issuestore/index.pb

@@ -0,0 +1,42 @@
+package sgyj.backjun.seunggu;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public class Main15649 {
+
+    public static void main(String[] args) {
+        try( BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
+            String[] lines = reader.readLine().split(" ");
+            int n = Integer.parseInt(lines[0]);
+            int m = Integer.parseInt(lines[1]);
+            int[] combination = new int[m+1];
+            boolean[] visited = new boolean[n+ 1];
+            StringBuilder stringBuilder = new StringBuilder();
+            dfs(0,n, m, combination, visited, stringBuilder);
+            System.out.println(stringBuilder);
+        }  catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static void dfs(int number, int depth, int limit, int[] combination, boolean [] visited, StringBuilder stringBuilder) {
+        if(number == limit) {
+            for (int i =0; i < number; i++) {
+                stringBuilder.append(combination[i]).append(" ");
+            }
+            stringBuilder.append("\n");
+            return;
+        }
+        for(int i=1; i<= depth; i++) {
+            if(!visited[i]) {
+                visited[i] = true;
+                combination[number] = i;
+                dfs(number+1, depth, limit, combination, visited, stringBuilder);
+                visited[i] = false;
+            }
+        }
+    }
+
+}

.idea/vcs.xml

@@ -0,0 +1,37 @@
+package sgyj.backjun.seunggu;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public class Main15650 {
+
+    public static void main(String[] args) {
+        try( BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
+            String[] lines = reader.readLine().split(" ");
+            int n = Integer.parseInt(lines[0]);
+            int m = Integer.parseInt(lines[1]);
+            int[] combination = new int[m];
+            StringBuilder stringBuilder = new StringBuilder();
+            dfs(1, 0,n, m, combination, stringBuilder);
+            System.out.println(stringBuilder);
+        }  catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static void dfs(int start, int number, int depth, int limit, int[] combination, StringBuilder stringBuilder) {
+        if(number == limit) {
+            for (int i : combination) {
+                stringBuilder.append(i).append(" ");
+            }
+            stringBuilder.append("\n");
+            return;
+        }
+        for(int i=start; i<= depth; i++) {
+            combination[number] = i;
+            dfs(i+1, number+1, depth, limit, combination, stringBuilder);
+        }
+    }
+
+}