algorithms lesson #8 added

Author: biblelamp

BerlinTelran/Algorithms/src/lesson8/Item.java

@@ -0,0 +1,39 @@
+package lesson8;
+
+public class Item implements Comparable<Item>{
+    private final String name;
+    private final int weight;
+    private final float cost;
+
+    public Item(String name, int weight, float cost) {
+        this.name = name;
+        this.weight = weight;
+        this.cost = cost;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getWeight() {
+        return weight;
+    }
+
+    public float getCost() {
+        return cost;
+    }
+
+    @Override
+    public int compareTo(Item o) {
+        return Float.compare(o.cost/o.weight, cost/weight);
+    }
+
+    @Override
+    public String toString() {
+        return "Item{" +
+                "name='" + name + '\'' +
+                ", weight=" + weight +
+                ", cost=" + cost +
+                '}';
+    }
+}

BerlinTelran/Algorithms/src/lesson8/Lesson8.java

@@ -1,9 +1,6 @@
 package lesson8;
 
-import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collections;
-import java.util.LinkedList;
 import java.util.List;
 
 /**
@@ -18,43 +15,18 @@ public static void main(String[] args) {
         // 1 задача - выбор задач
         List<Integer> tasks = Arrays.asList(3, 2, 1, 4, 5, 3);
         int maxTime = 10;
-        List<Integer> resolved = taskSelection(tasks, maxTime);
+        List<Integer> resolved = Lesson8Methods.taskSelection(tasks, maxTime);
         System.out.println(resolved);
 
         // 2 задача - размен монет
         List<Integer> coins = Arrays.asList(1, 5, 10, 25);
         int amount = 63;
-        System.out.println(coinChange(coins, amount));
-    }
-
-    static List<Integer> taskSelection(List<Integer> tasks, int maxTime) {
-        List<Integer> result = new ArrayList<>();
-        int resultTime = 0;
-
-        LinkedList<Integer> sortedTasks = new LinkedList<>(tasks);
-        Collections.sort(sortedTasks);
-        while (resultTime < maxTime && maxTime - resultTime >= sortedTasks.peek()) {
-            int taskTime = sortedTasks.pop();
-            result.add(taskTime);
-            resultTime = resultTime + taskTime;
-        }
-        return result;
-    }
-
-    static List<Integer> coinChange(List<Integer> coins, int amount) {
-        List<Integer> result = new ArrayList<>();
-
-        Collections.sort(coins);
-        for (int i = coins.size() - 1; i >= 0; i--) {
-            while (amount >= coins.get(i)) {
-                amount = amount - coins.get(i);
-                result.add(coins.get(i));
-            }
-        }
+        System.out.println(Lesson8Methods.coinChange(coins, amount));
 
-        if (amount == 0) {
-            return result;
-        }
-        return Collections.EMPTY_LIST;
+        // 3 задача - упаковка рюкзака
+        List<Item> items = Arrays.asList(new Item("A", 7, 100), new Item("B", 5, 80), new Item("C", 3, 50));
+        int capacity = 10;
+        List<Item> result = Lesson8Methods.fractionalKnapsack(items, capacity);
+        System.out.println(result);
     }
 }

BerlinTelran/Algorithms/src/lesson8/Lesson8Methods.java

@@ -0,0 +1,61 @@
+package lesson8;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+
+public class Lesson8Methods {
+
+    // 1я задача: выбор задач
+    static List<Integer> taskSelection(List<Integer> tasks, int maxTime) {
+        List<Integer> result = new ArrayList<>();
+        int resultTime = 0;
+
+        LinkedList<Integer> sortedTasks = new LinkedList<>(tasks);
+        Collections.sort(sortedTasks);
+        while (resultTime < maxTime && maxTime - resultTime >= sortedTasks.peek()) {
+            int taskTime = sortedTasks.pop();
+            result.add(taskTime);
+            resultTime = resultTime + taskTime;
+        }
+        return result;
+    }
+
+    // 2я задача: размен монет
+    static List<Integer> coinChange(List<Integer> coins, int amount) {
+        List<Integer> result = new ArrayList<>();
+
+        Collections.sort(coins);
+        for (int i = coins.size() - 1; i >= 0; i--) {
+            while (amount >= coins.get(i)) {
+                amount = amount - coins.get(i);
+                result.add(coins.get(i));
+            }
+        }
+
+        if (amount == 0) {
+            return result;
+        }
+        return new ArrayList<>();
+    }
+
+    // 3я задача: упаковка рюкзака
+    static List<Item> fractionalKnapsack(List<Item> items, int capacity) {
+        List<Item> result = new ArrayList<>();
+        Collections.sort(items); // сортировка по убыванию вес/стоимость
+
+        int currentWeight = 0;
+
+        for (Item item : items) {
+            if (currentWeight + item.getWeight() <= capacity) {
+                currentWeight = currentWeight + item.getWeight();
+                result.add(item);
+            } else {
+                break;
+            }
+        }
+
+        return result;
+    }
+}