[조시] 8주차 과제 제출

1주차/10814/josh_java_10814.java

@@ -0,0 +1,49 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+class Pair implements Comparable<Pair> {
+    int age;
+    int order;
+    String name;
+
+    public Pair(int age, int order, String name) {
+        this.age = age;
+        this.order = order;
+        this.name = name;
+    }
+
+    @Override
+    public int compareTo(Pair other) {
+        if (age == other.age) {
+            return order - other.order;
+        }
+        return age - other.age;
+    }
+
+    @Override
+    public String toString() {
+        return age + " " + name;
+    }
+}
+
+public class josh_java_10814 {
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int num = Integer.parseInt(br.readLine());
+        List<Pair> pairs = new ArrayList<>();
+        for (int order = 0; order<num; ++order) {
+            String[] inputs = br.readLine().split(" ");
+            int age = Integer.parseInt(inputs[0]);
+            String name = inputs[1];
+            pairs.add(new Pair(age, order, name));
+        }
+        Collections.sort(pairs);
+        for (Pair pair : pairs) {
+            System.out.println(pair);
+        }
+    }
+}

1주차/14659/josh_java_14659.java

@@ -0,0 +1,32 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class josh_java_14659 {
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int num = Integer.parseInt(br.readLine());
+        String[] inputs = br.readLine().split(" ");
+        List<Integer> inputBucket = Arrays.stream(inputs).map(Integer::parseInt).collect(Collectors.toList());
+        List<Integer> answer = new ArrayList<>();
+        int highest = inputBucket.get(0);
+        int answerCandidate = 0;
+        for (int i = 1; i<num; ++i) {
+            if (highest < inputBucket.get(i)) {
+                answer.add(answerCandidate);
+                answerCandidate = 0;
+                highest = inputBucket.get(i);
+                continue;
+            }
+            ++answerCandidate;
+        }
+        answer.add(answerCandidate);
+        System.out.println(Collections.max(answer));
+    }
+}

1주차/17362/josh_java_17362.java

@@ -0,0 +1,18 @@
+import java.util.Arrays;
+import java.util.List;
+import java.util.Scanner;
+
+public class josh_java_17362 {
+    public static int solve(int count) {
+        List<Integer> bucket = Arrays.asList(2, 1, 2, 3, 4, 5, 4, 3);
+        int index = count % 8;
+        return bucket.get(index);
+    }
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int count = sc.nextInt();
+        int answer = solve(count);
+        System.out.println(answer);
+    }
+}

1주차/4796/josh_java_4796.java

@@ -0,0 +1,26 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public class josh_java_4796 {
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int caseIndex = 1;
+        while (true) {
+            String[] inputs = br.readLine().split(" ");
+            int unit = Integer.parseInt(inputs[0]);
+            int period = Integer.parseInt(inputs[1]);
+            int vacation = Integer.parseInt(inputs[2]);
+            if (unit == 0) {
+                break;
+            }
+            int rest = (vacation % period);
+            if (rest > unit) {
+                rest = unit;
+            }
+            int answer = rest + unit * (vacation / period);
+            System.out.println("Case " + caseIndex++ + ": " + answer);
+        }
+    }
+}

2주차/11866/josh_java_11866.java

@@ -0,0 +1,62 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.StringTokenizer;
+import java.util.stream.Collectors;
+
+public class josh_java_11866 {
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(bf.readLine());
+        StringBuilder sb = new StringBuilder();
+
+        int maxNum = Integer.parseInt(st.nextToken());
+        int moveNum = Integer.parseInt(st.nextToken());
+
+        List<Integer> bucket = makeBucket(maxNum);
+        List<Integer> answer = josephusResult(bucket, moveNum);
+
+        String output = answer.stream()
+                .map(String::valueOf)
+                .collect(Collectors.joining(", "));
+
+        sb.append("<");
+        sb.append(output);
+        sb.append(">");
+
+        System.out.println(sb);
+        bf.close();
+    }
+
+    private static List<Integer> josephusResult(List<Integer> bucket, int moveNum) {
+        List<Integer> result = new ArrayList<>();
+
+        int index = 0;
+        while (!bucket.isEmpty()) {
+            index = getIndex(index, moveNum, bucket.size());
+            result.add(bucket.get(index));
+            bucket.remove(index);
+        }
+        return result;
+    }
+
+    private static int getIndex(int index, int moveNum, int upperLimit) {
+        int result = index + moveNum - 1;
+        if (result >= upperLimit) {
+            result %= upperLimit;
+        }
+        return result;
+    }
+
+    private static List<Integer> makeBucket(int maxNum) {
+        List<Integer> result = new ArrayList<>();
+        for (int i = 0; i < maxNum; ++i) {
+            result.add(i + 1);
+        }
+        return result;
+    }
+}
+

2주차/12789/josh_java_12789.java

@@ -0,0 +1,59 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Stack;
+import java.util.stream.Collectors;
+
+public class josh_java_12789 {
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int num = Integer.parseInt(br.readLine());
+        String[] inputs = br.readLine().split(" ");
+        List<Integer> bucket = Arrays.stream(inputs)
+                .map(Integer::parseInt)
+                .collect(Collectors.toList());
+
+        int currentOrder = 1;
+        int index = 0;
+        Stack<Integer> stack = new Stack<>();
+        stack.add(1001);
+
+        String answer = "Nice";
+        while (!isEnd(bucket, index) || !isStackEmpty(stack)) {
+            int element = getElement(bucket, index);
+            if (element == currentOrder) {
+                currentOrder += 1;
+                index += 1;
+            } else if (stack.peek() == currentOrder) {
+                stack.pop();
+                currentOrder += 1;
+            } else if (element < stack.peek()) {
+                stack.push(element);
+                index += 1;
+            } else {
+                answer = "Sad";
+                break;
+            }
+        }
+
+        System.out.println(answer);
+    }
+
+    private static int getElement(List<Integer> bucket, int index) {
+        if (isEnd(bucket, index)) {
+            return 2000;
+        }
+        return bucket.get(index);
+    }
+
+    private static boolean isStackEmpty(Stack<Integer> stack) {
+        return stack.peek() == 1001;
+    }
+
+    private static boolean isEnd(List<Integer> bucket, int index) {
+        return bucket.size() == index;
+    }
+}

2주차/2121/josh_java_2121.java

@@ -0,0 +1,78 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class josh_java_2121 {
+
+    static Map<Integer, List<Integer>> points = new HashMap<>();
+    static List<Integer> xs = new ArrayList<>();
+    static List<Integer> ys = new ArrayList<>();
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int inputNum = Integer.parseInt(br.readLine());
+        String[] inputs = br.readLine().split(" ");
+        int width = Integer.parseInt(inputs[0]);
+        int height = Integer.parseInt(inputs[1]);
+        for (int i = 0; i<inputNum; ++i) {
+            inputs = br.readLine().split(" ");
+            int x = Integer.parseInt(inputs[0]);
+            int y = Integer.parseInt(inputs[1]);
+            xs.add(x);
+            ys.add(y);
+            List<Integer> bucket = points.getOrDefault(x, new ArrayList<>());
+            bucket.add(y);
+            points.put(x, bucket);
+        }
+        for (List<Integer> bucket : points.values()) {
+            bucket.sort(Comparator.naturalOrder());
+        }
+
+        int answer = 0;
+        for (int i = 0; i<xs.size(); ++i) {
+            int x = xs.get(i);
+            int y = ys.get(i);
+
+            boolean isPresent = true;
+            isPresent &= find(x, y+height);
+            isPresent &= find(x+width, y);
+            isPresent &= find(x+width, y+height);
+
+            if (isPresent) {
+                answer += 1;
+            }
+        }
+        System.out.println(answer);
+    }
+
+    private static boolean find(int x, int y) {
+        if (!points.containsKey(x)) {
+            return false;
+        }
+        List<Integer> bucket = points.get(x);
+        return binarySearch(bucket, y);
+    }
+
+    private static boolean binarySearch(List<Integer> bucket, int y) {
+        int first = 0;
+        int end = bucket.size() - 1;
+
+        while (first <= end) {
+            int middle = (first + end) / 2;
+            int middleValue = bucket.get(middle);
+            if (middleValue == y) {
+                return true;
+            } else if (middleValue < y) {
+                first = middle + 1;
+            } else {
+                end = middle - 1;
+            }
+        }
+        return false;
+    }
+}

2주차/22941/josh_java_22941.java

@@ -0,0 +1,37 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public class josh_java_22941 {
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        String[] inputs = br.readLine().split(" ");
+        long playerHp = Long.parseLong(inputs[0]);
+        long playerAtk = Long.parseLong(inputs[1]);
+        long monsterHp = Long.parseLong(inputs[2]);
+        long monsterAtk = Long.parseLong(inputs[3]);
+        inputs = br.readLine().split(" ");
+        long skillActivateCondition = Long.parseLong(inputs[0]);
+        long additionalHp = Long.parseLong(inputs[1]);
+
+        long cycle = playerHp / monsterAtk;
+        if (playerHp % monsterAtk != 0L) {
+            cycle += 1L;
+        }
+
+        long monsterBeforeDieHp = monsterHp % playerAtk;
+        if (monsterBeforeDieHp == 0L && playerAtk <= skillActivateCondition) {
+            monsterHp += additionalHp;
+        } else if (monsterBeforeDieHp != 0L && monsterBeforeDieHp <= skillActivateCondition) {
+            monsterHp += additionalHp;
+        }
+
+        long maxDamage = cycle * playerAtk;
+        if (maxDamage >= monsterHp) {
+            System.out.println("Victory!");
+        } else {
+            System.out.println("gg");
+        }
+    }
+}