[전지희] 5주차 과제 제출

5주차/12914/12914_전지희.java

@@ -0,0 +1,17 @@
+class Solution {
+      public long solution(int n) {
+          long answer = 0;
+
+              if(n >= 1 && n <= 2000) {
+                  long[] dp = new long[n + 1];
+                  dp[0] = 1;
+                  dp[1] = 2;
+                  for(int i = 2; i < n; i++) {
+                      dp[i] = (dp[i - 2] + dp[i - 1]) % 1234567;
+                  }
+                  answer = dp[n - 1];
+              }
+
+          return answer;
+      }
+}

5주차/131127/131127_전지희.java

@@ -0,0 +1,35 @@
+import java.util.*;
+
+class Solution {
+    public int solution(String[] want, int[] number, String[] discount) {
+        int answer = 0;
+        int count = 10;
+
+        Map<String, Integer> map = new HashMap<>();
+
+        for(int i = 0; i < want.length; i++){
+            map.put(want[i], number[i]);
+        } 
+
+        for(int i = 0; i < discount.length - count + 1; i++){
+            Map<String, Integer> hashMap = new HashMap<>();
+
+            for(int j = 0; j < count; j++){
+                hashMap.put(discount[i + j], hashMap.getOrDefault(discount[i + j], 0) + 1);
+            }
+
+            Boolean isIdentical = true;
+
+            for(String key : map.keySet()){
+                if(map.get(key) != hashMap.get(key)){
+                    isIdentical = false;
+                    break;
+                }
+            }
+
+            answer += isIdentical ? 1 : 0;
+        }
+
+        return answer;
+    }
+}

5주차/17680/17680_전지희.java

@@ -0,0 +1,31 @@
+import java.util.LinkedList;
+
+class Solution {
+    public int solution(int cacheSize, String[] cities) {
+        int answer = 0;
+
+        if (cacheSize == 0) {
+            return cities.length * 5;
+        }
+
+        LinkedList<String> cache = new LinkedList<>();
+
+        for (String city : cities) {
+            city = city.toLowerCase();
+
+            if (cache.contains(city)) {
+                cache.remove(city);
+                cache.add(city);
+                answer += 1;
+            } else {
+                cache.add(city);
+                if (cache.size() > cacheSize) {
+                    cache.removeFirst();
+                }
+                answer += 5;
+            }
+        }
+
+        return answer;
+    }
+}

5주차/250121/250121_전지희.java

@@ -0,0 +1,91 @@
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+class Solution {
+    public int[][] solution(int[][] data, String ext, int val_ext, String sort_by) {
+        List<DataRecord> filteredData = filterData(data, ext, val_ext);
+        Collections.sort(filteredData, (a, b) -> compareData(a, b, sort_by));
+
+        int[][] answer = new int[filteredData.size()][];
+        for (int i = 0; i < filteredData.size(); i++) {
+            answer[i] = filteredData.get(i).getData();
+        }
+
+        return answer;
+    }
+
+    private List<DataRecord> filterData(int[][] data, String ext, int val_ext) {
+        List<DataRecord> filteredData = new ArrayList<>();
+        for (int[] record : data) {
+            if (matchesCondition(record, ext, val_ext)) {
+                filteredData.add(new DataRecord(record));
+            }
+        }
+        return filteredData;
+    }
+
+    private boolean matchesCondition(int[] record, String ext, int val_ext) {
+        switch (ext) {
+            case "code":
+                return record[0] < val_ext;
+            case "date":
+                return record[1] < val_ext;
+            case "maximum":
+                return record[2] < val_ext;
+            case "remain":
+                return record[3] < val_ext;
+            default:
+                return false;
+        }
+    }
+
+    private int compareData(DataRecord a, DataRecord b, String sort_by) {
+        switch (sort_by) {
+            case "code":
+                return Integer.compare(a.getCode(), b.getCode());
+            case "date":
+                return Integer.compare(a.getDate(), b.getDate());
+            case "maximum":
+                return Integer.compare(a.getMaximum(), b.getMaximum());
+            case "remain":
+                return Integer.compare(a.getRemain(), b.getRemain());
+            default:
+                return 0;
+        }
+    }
+
+    private static class DataRecord {
+        private final int code;
+        private final int date;
+        private final int maximum;
+        private final int remain;
+
+        public DataRecord(int[] data) {
+            this.code = data[0];
+            this.date = data[1];
+            this.maximum = data[2];
+            this.remain = data[3];
+        }
+
+        public int getCode() {
+            return code;
+        }
+
+        public int getDate() {
+            return date;
+        }
+
+        public int getMaximum() {
+            return maximum;
+        }
+
+        public int getRemain() {
+            return remain;
+        }
+
+        public int[] getData() {
+            return new int[]{code, date, maximum, remain};
+        }
+    }
+}