From 81ba9eb66f8284d8760012973f84cdbe617ceb94 Mon Sep 17 00:00:00 2001 From: pants Date: Mon, 21 Sep 2026 14:16:34 -0700 Subject: init --- p2/P2_GeneratePermutations/Allocation.java | 128 +++++++++++++++++++++++++++++ p2/P2_GeneratePermutations/Client.java | 73 ++++++++++++++++ p2/P2_GeneratePermutations/Region.java | 84 +++++++++++++++++++ 3 files changed, 285 insertions(+) create mode 100644 p2/P2_GeneratePermutations/Allocation.java create mode 100644 p2/P2_GeneratePermutations/Client.java create mode 100644 p2/P2_GeneratePermutations/Region.java (limited to 'p2/P2_GeneratePermutations') diff --git a/p2/P2_GeneratePermutations/Allocation.java b/p2/P2_GeneratePermutations/Allocation.java new file mode 100644 index 0000000..a5ab72f --- /dev/null +++ b/p2/P2_GeneratePermutations/Allocation.java @@ -0,0 +1,128 @@ +import java.util.*; + +/** + * The Allocation class represents an unmodifiable relief solution. + * It provides methods to retrieve the total cost and total helped population + * of the solution. The ordering of the regions in the solution determines + * the population that can be helped. + */ +public class Allocation { + + private List regions; + + /** + * Creates a new Allocation object representing the given regions. + * @param regions the regions in the solution + */ + private Allocation(List regions) { + this.regions = new ArrayList<>(regions); + } + + /** + * Creates a new Allocation object with no regions in it. + */ + public Allocation() { + this(new ArrayList<>()); + } + + /** + * Returns a copy of this allocation's regions. + */ + public List getRegions() { + return new ArrayList<>(regions); + } + + /** + * Returns a new Allocation with the contents of this allocation + * and the passed in region added to it. + * @param r Region to be added to the end of the new Allocation. + * @return a new Allocation with r added to it. + */ + public Allocation withRegion(Region r) { + if (regions.contains(r)) { + throw new IllegalArgumentException("Allocation already contains region " + r); + } + List newRegions = new ArrayList<>(regions); + newRegions.add(r); + return new Allocation(newRegions); + } + + /** + * Returns a new Allocation with the contents of this allocation + * and the passed in region removed from it. + * @param r Region to be removed from the new Allocation. + * @return a new Allocation with r removed from it. + */ + public Allocation withoutRegion(Region r) { + if (!regions.contains(r)) { + throw new IllegalArgumentException("Allocation doesn't contain region " + r); + } + List newRegions = new ArrayList<>(regions); + newRegions.remove(r); + return new Allocation(newRegions); + } + + /** + * Returns the number of regions in this Allocation. + */ + public int size() { + return regions.size(); + } + + /** + * Calculates and returns the total population that can be helped + * by this Allocation. + * @return the total population that can be helped by this Allocation. + */ + public int totalPeople() { + int total = 0; + for (Region r : regions) { + total += r.getPopulation(); + } + return total; + } + + /** + * Calculates and returns the combined cost of this Allocation. + * @return the combined cost of this Allocation. + */ + public double totalCost() { + double total = 0; + for (int i = 0; i < regions.size(); i++) { + total += regions.get(i).getCost(i); + } + return total; + } + + /** + * Returns a String representation of an Allocation object in the format: + * "[Region, ..., Region]" where each Region is in its string representation. + * @return the String representation of an Allocation object + */ + public String toString() { + return regions.toString(); + } + + /** + * Compares the specified object with this allocation for equality. Returns true if the + * specified object is also an Allocation and the two Allocations have the same + * collection of regions. + * @param other object to be compared for equality with this allocation + * @return true if the specified object is equal to this allocation + */ + public boolean equals(Object other) { + if (other == this) { + return true; + } + if (!(other instanceof Allocation)) { + return false; + } + Allocation otherAlloc = (Allocation)other; + return this.regions.equals(otherAlloc.getRegions()); + } + + public int hashCode() { + return regions.hashCode(); + } +} + diff --git a/p2/P2_GeneratePermutations/Client.java b/p2/P2_GeneratePermutations/Client.java new file mode 100644 index 0000000..de00dc5 --- /dev/null +++ b/p2/P2_GeneratePermutations/Client.java @@ -0,0 +1,73 @@ +import java.util.*; + +public class Client { + private static Random rand = new Random(); + + public static void main(String[] args) throws Exception { + // List scenario = createRandomScenario(10, 10, 100, 1000, 100000); + List scenario = createSimpleScenario(); + System.out.println(scenario); + + double budget = 2000; + Set allocations = generateOptions(budget, scenario); + printAllocations(allocations); + } + + public static Set generateOptions(double budget, List sites) { + Set allocations = new HashSet<>(); + return generateOptions(budget, sites, allocations); + } + + private static Set generateOptions(double budget, List sites, + Set allocations) { + if (sites.isEmpty()) { + return allocations; + } + + Region temp = sites.remove(); + if (budget >= temp.baseCost) { + budget -= temp.baseCost; + } + } + + + /////////////////////////////////////////////////////////////////////////// + // PROVIDED HELPER METHODS - **DO NOT MODIFY ANYTHING BELOW THIS LINE!** // + /////////////////////////////////////////////////////////////////////////// + + public static void printAllocations(Set allocations) { + System.out.println("All Allocations:"); + for (Allocation a : allocations) { + System.out.println(" " + a); + } + } + + public static List createRandomScenario(int numLocs, int minPop, int maxPop, + double minCostPer, double maxCostPer) { + List result = new ArrayList<>(); + + for (int i = 0; i < numLocs; i++) { + int pop = rand.nextInt(minPop, maxPop + 1); + double cost = rand.nextDouble(minCostPer, maxCostPer) * pop; + result.add(new Region("Region #" + i, pop, round2(cost))); + } + + return result; + } + + public static List createSimpleScenario() { + List result = new ArrayList<>(); + + result.add(new Region("Region #1", 50, 500)); + result.add(new Region("Region #2", 100, 700)); + result.add(new Region("Region #3", 60, 1000)); + result.add(new Region("Region #4", 20, 1000)); + result.add(new Region("Region #5", 200, 900)); + + return result; + } + + private static double round2(double num) { + return Math.round(num * 100) / 100.0; + } +} diff --git a/p2/P2_GeneratePermutations/Region.java b/p2/P2_GeneratePermutations/Region.java new file mode 100644 index 0000000..d5273ba --- /dev/null +++ b/p2/P2_GeneratePermutations/Region.java @@ -0,0 +1,84 @@ +/** + * The Region class represents a geographical location with a name, population, and cost. + * It provides methods to retrieve the population and cost of the location, + * as well as a method to generate a string representation of the object. + */ +public class Region { + private String name; + private int population; + private double baseCost; + + /** + * Creates a new Region object with the given name, population, and cost. + * @param name the name of the location + * @param pop the population of the location + * @param baseCost the base cost of the location + */ + public Region(String name, int pop, double baseCost) { + this.name = name; + this.population = pop; + this.baseCost = baseCost; + } + + /** + * Returns the population of the location + * @return the population of the location + */ + public int getPopulation() { return this.population; } + + /** + * Returns the cost of the location + * @param index a number indicating when this region is provided relief. A larger value for + * index indicates that this region is helped later. + * @return the cost of providing relief to this region. Regions that are + * helped later (i.e. with a larger index value) have a higher cost. + */ + public double getCost(int index) { + return (1 + 0.1 * index) * this.baseCost; + } + + + /** + * Returns a String representation of a Region object in the format: + * ": pop. , cost: $" + * @return the String representation of a Region object + */ + public String toString() { + return name + ": pop. " + population + ", base cost: $" + baseCost; + } + + /** + * Compares the specified object with this location for equality. Returns true if the + * specified object is also a location and the two locations have the + * same name, population, and cost. + * @param other object to be compared for equality with this location + * @return true if the specified object is equal to this location + */ + @Override + public boolean equals(Object other) { + if (other == this) { + return true; + } + if (!(other instanceof Region)) { + return false; + } + Region otherLoc = (Region)other; + + return this.name.equals(otherLoc.name) && + this.population == otherLoc.population && + this.baseCost == otherLoc.baseCost; + } + + /** + * Returns the hash code value for this location + * @return the hash code value for this location + */ + @Override + public int hashCode() { + int result = name.hashCode(); + result = 31 * result + Integer.hashCode(population); + result = 31 * result + Double.hashCode(baseCost); + return result; + } +} + -- cgit v1.2.3