Week 16
Source Code
import java.util.*;
public class Week16 {
public static void main(String[] args) {
String myName = ""; // add your name
System.out.println("Week 16" + " - " + myName);
// Menu
System.out.println("Menu");
System.out.println("E1 - Example 1");
System.out.println("Q - Quit");
// setup Scanner
Scanner in = new Scanner(System.in);
System.out.print("Choice: ");
String choice = in.nextLine();
// switch choices
switch (choice) {
case "E1":
System.out.println("Example 1");
example1();
break;
case "E2":
System.out.println("Example 2");
example2();
break;
case "E3":
System.out.println("Example 3");
example3();
break;
case "E4":
System.out.println("Example 4");
example4();
break;
case "E5":
System.out.println("Example 5");
example5();
break;
case "Q":
System.out.println("Quitting..!");
break;
}
}
// example1 method
public static void example1() {
// create an array of friends
// for loop
// enhanced for loop
}
// example2 method
public static void example2() {
// create an array of horses
// enhanced for loop
}
// example3 method
public static void example3() {
// create array
int[] values = { 6, 2, 1, 7, 12, 5 };
// assign first value
int first = values[0];
// loop
// if it's not the last element, copy the next one over
// last element gets first
// print
}
// example4 method
public static void example4() {
Scanner in = new Scanner(System.in);
System.out.print("Enter the number of elements: ");
int n = in.nextInt();
int[] values = new int[n];
System.out.print("Enter the elements:");
for (int i = 0; i < n; i++) {
values[i] = in.nextInt();
}
// Checking for adjacent duplicates
}
// example5 method
public static void example5() {
Scanner in = new Scanner(System.in);
System.out.print("Enter the number of elements: ");
int n = in.nextInt();
int[] values = new int[n];
System.out.print("Enter the elements:");
for (int i = 0; i < n; i++) {
values[i] = in.nextInt();
}
// Checking for any duplicates in the array
}
// Method to check for adjacent duplicates
public static boolean hasAdjacentDuplicates(int[] values) {
for (int i = 0; i < values.length - 1; i++) {
if (values[i] == values[i + 1]) {
return true;
}
}
return false;
}
// Method to check for duplicates anywhere in the array
public static boolean hasAnyDuplicates(int[] values) {
for (int i = 0; i < values.length; i++) {
for (int j = i + 1; j < values.length; j++) {
if (values[i] == values[j]) {
return true;
}
}
}
return false;
}
// printArray method
public static void printArray(int[] arr) {
System.out.println("Print Array");
System.out.println("Index\tValue");
for (int i = 0; i < arr.length; i++) {
System.out.println(i + "\t" + arr[i]);
}
}
}
CommandLineArgs.java
public class CommandLineArgs {
public static void main(String[] args) {
System.out.println("Number of arguments: " + args.length);
for (int i = 0; i < args.length; i++) {
System.out.println("Argument " + i + ": " + args[i]);
}
}
}CommandLineSum.java
public class CommandLineSum {
public static void main(String[] args) {
if (args.length < 2) {
System.out.println("Please provide two numbers.");
return;
}
int num1 = Integer.parseInt(args[0]);
int num2 = Integer.parseInt(args[1]);
int sum = num1 + num2;
System.out.println("Sum: " + sum);
}
}W16Problem1.java
import java.util.*;
public class W16Problem1
{
public static void main(String[] args)
{
System.out.println("Problem 1");
// Array to store 1000 random numbers
// Array to track occurrences of numbers 1-100
// Fill the first array with random numbers from 1 to 10
// Count the occurrences using an enhanced for loop
// Adjust index since 1 should go to index 0
// Print frequency of each number
}
}W16Problem2.java
import java.util.*;
public class W16Problem2
{
public static void main(String[] args)
{
System.out.println("Problem 2");
// Array to hold 10000 random numbers
// Array to store frequency counts (index 0 for 0, index 99 for 99)
// Fill the first array with random numbers from 0 to 99
// Sort the array in ascending order
// Count occurrences of each number using an enhanced for loop
// by incrementing the corresponding index in frequency array
// Find most and least frequent numbers
// Create variables to track the most and least frequent numbers
// Print the frequency of each number in the range 0-99
// Print the most and least frequent numbers
}
}W16Problem3.java
public class W16Problem3 {
public static boolean hasConsecutiveIncreasing(int[] values) {
// TODO: Implement logic to check for consecutive increasing numbers
return false;
}
public static void main(String[] args) {
// Test 1
int[] values1 = {1, 2, 3, 5, 7};
// Expected output: true
System.out.println(hasConsecutiveIncreasing(values1));
// Test 2
int[] values2 = {1, 1, 1, 1, 1};
// Expected output: false
System.out.println(hasConsecutiveIncreasing(values2));
}
}
W16Problem4.java
public class W16Problem4 {
public static boolean hasPairWithSum(int[] values, int targetSum) {
// TODO: Implement logic to check if any two elements sum to targetSum
return false;
}
public static void main(String[] args) {
// Test 1
int[] values1 = {4, 7, 1, 2, 8};
int targetSum1 = 9;
// Expected output: true
System.out.println(hasPairWithSum(values1, targetSum1));
// Test 2
int[] values2 = {1, 7, 1, 3, 10};
int targetSum2 = 9;
// Expected output: false
System.out.println(hasPairWithSum(values2, targetSum2));
}
}
W16Problem5.java
public class W16Problem5 {
public static int countUniqueElements(int[] values) {
// TODO: Implement logic to count unique elements
return 0;
}
public static void main(String[] args) {
// Test 1
int[] values1 = {1, 2, 3, 2, 4, 1, 5};
// Expected output: 5
System.out.println(countUniqueElements(values1));
// Test 2
int[] values2 = {1, 2, 1, 2, 1, 2, 1};
// Expected output: 2
System.out.println(countUniqueElements(values2));
}
}W16Problem6.java
public class W16Problem6 {
public static void main(String[] args) {
// Create an array of size 10000
// Fill array with random numbers from 0 to 99
// Sort the array to group identical numbers together
// Variables to track current count and mode
// Variables to track minimum frequency
// Count consecutive occurrences
// Same number continues
// Check if previous run is the mode
// Check if previous run is the minimum (excluding the current run)
// Reset count for new number
// Print results
}
}Horse.java
public class Horse {
private String name;
private int weight;
public Horse(String name, int weight) {
this.name = name;
this.weight = weight;
}
public String getName() {
return name;
}
public int getWeight() {
return weight;
}
}HorseBarn.java
/**
* HorseBarn - A class to manage horses in a barn with numbered spaces.
* Each space can hold at most one horse, and each horse has a unique name.
*/
public class HorseBarn {
// Instance Variables
private Horse[] spaces; // Array to store horses, null represents empty space
/**
* Constructor for HorseBarn
*
* @param numberOfSpaces the number of spaces in the barn
*/
public HorseBarn(int numberOfSpaces) {
spaces = new Horse[numberOfSpaces];
}
/**
* Returns the index of the space that contains the horse with the specified
* name.
*
* @param name the name of the horse to find
* @return the index of the space containing the horse with the specified name;
* -1 if no horse with the specified name is in the barn.
*/
public int findHorseSpace(String name) {
// Input validation
if (name == null) {
return -1;
}
// Search through all spaces
for (int i = 0; i < spaces.length; i++) {
// Check if space has a horse and if the names match
if (spaces[i] != null && spaces[i].getName().equals(name)) {
return i;
}
}
// Horse not found
return -1;
}
/**
* Consolidates the barn by moving horses so that the horses are in adjacent
* spaces,
* starting at index 0, with no empty space between any two horses.
* The order of the horses remains the same as before the consolidation.
*/
public void consolidate() {
// Create temporary array
Horse[] temp = new Horse[spaces.length];
int nextPosition = 0;
// Copy non-null horses in order
for (int i = 0; i < spaces.length; i++) {
if (spaces[i] != null) {
temp[nextPosition] = spaces[i];
nextPosition++;
}
}
// Replace original array with consolidated version
spaces = temp;
}
/**
* Adds a horse to the first available (empty) space in the barn.
*
* @param horse the horse to add
* @return true if the horse was added successfully, false if the barn is full
* or if a horse with the same name already exists
*/
public boolean addHorse(Horse horse) {
// Input validation
if (horse == null) {
return false;
}
// Check if horse with same name already exists
if (findHorseSpace(horse.getName()) != -1) {
return false;
}
// Find first empty space
for (int i = 0; i < spaces.length; i++) {
if (spaces[i] == null) {
spaces[i] = horse;
return true;
}
}
// No empty space found
return false;
}
/**
* Removes a horse from the barn by name.
*
* @param name the name of the horse to remove
* @return true if the horse was removed successfully, false if the horse wasn't
* found
*/
public boolean removeHorse(String name) {
int index = findHorseSpace(name);
if (index != -1) {
spaces[index] = null;
return true;
}
return false;
}
/**
* Returns the horse at the specified index.
*
* @param index the index of the space to check
* @return the horse at the specified space, or null if the space is empty
* or the index is invalid
*/
public Horse getHorse(int index) {
if (index >= 0 && index < spaces.length) {
return spaces[index];
}
return null;
}
/**
* Returns the number of spaces in the barn.
*
* @return the total number of spaces
*/
public int getSpaces() {
return spaces.length;
}
/**
* Returns the number of horses currently in the barn.
*
* @return the number of occupied spaces
*/
public int getNumberOfHorses() {
int count = 0;
for (Horse horse : spaces) {
if (horse != null) {
count++;
}
}
return count;
}
/**
* Returns true if the barn is empty (contains no horses).
*
* @return true if the barn is empty, false otherwise
*/
public boolean isEmpty() {
return getNumberOfHorses() == 0;
}
/**
* Returns true if the barn is full (all spaces occupied).
*
* @return true if the barn is full, false otherwise
*/
public boolean isFull() {
return getNumberOfHorses() == spaces.length;
}
/**
* Returns a string representation of the barn.
*
* @return a string showing the contents of each space in the barn
*/
@Override
public String toString() {
StringBuilder result = new StringBuilder();
result.append("HorseBarn with ").append(spaces.length).append(" spaces:\n");
for (int i = 0; i < spaces.length; i++) {
result.append("Space ").append(i).append(": ");
if (spaces[i] == null) {
result.append("empty");
} else {
result.append(spaces[i].getName()).append(" (").append(spaces[i].getWeight()).append(" lbs)");
}
result.append("\n");
}
return result.toString();
}
public static void main(String[] args) {
// Create test barn
// Test 1: Empty barn
// Add horses
// print the barn layout
// Test 2: Find existing horses
// Test 3: Find non-existent horse
// Test 4: Consolidate
}
}
Vehicle.java
public class Vehicle {
private String licensePlate;
private String make;
private String model;
public Vehicle(String licensePlate, String make, String model) {
this.licensePlate = licensePlate;
this.make = make;
this.model = model;
}
public String getLicensePlate() { return licensePlate; }
public String getMake() { return make; }
public String getModel() { return model; }
@Override
public String toString() {
return make + " " + model + " (" + licensePlate + ")";
}
}ParkingGarage.java
public class ParkingGarage {
private Vehicle[] spots;
private static final double HOURLY_RATE = 5.00; // $5 per hour
public ParkingGarage(int numSpots) {
spots = new Vehicle[numSpots];
}
/**
* Parks a vehicle in the first available appropriate spot
* @param vehicle the vehicle to park
* @return the spot number if successful, -1 if no spots available
*/
public int parkVehicle(Vehicle vehicle) {
// TODO: Implement this method
return -1;
}
/**
* Removes a vehicle from the garage and calculates parking fee
* @param licensePlate the license plate of the vehicle to remove
* @return the parking fee in dollars, -1 if vehicle not found
*/
public double removeVehicle(String licensePlate) {
// TODO: Implement this method
return -1.0;
}
/**
* Finds a vehicle by license plate
* @param licensePlate the license plate to search for
* @return the spot number if found, -1 if not found
*/
public int findVehicle(String licensePlate) {
// TODO: Implement this method
return -1;
}
/**
* Returns a formatted string representing the parking garage layout.
* Shows which spots are occupied and by which vehicle.
*
* @return A string representation of the parking garage.
*/
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("Parking Garage Status:\n");
for (int i = 0; i < spots.length; i++) {
sb.append("Spot ").append(i).append(": ");
if (spots[i] != null) {
sb.append(spots[i]); // Calls Vehicle's toString()
} else {
sb.append("Empty");
}
sb.append("\n");
}
return sb.toString();
}
/**
* The main method for testing the Parking Garage Management System.
*/
public static void main(String[] args) {
System.out.println("Welcome to the Parking Garage!");
// Create a parking garage with 10 spots
// Create some vehicles
Vehicle car1 = new Vehicle("ABC123", "Dodge", "Charger");
Vehicle car2 = new Vehicle("XYZ789", "Honda", "Civic");
Vehicle car3 = new Vehicle("LMN456", "Ford", "Escape");
Vehicle car4 = new Vehicle("NULL", "Toyota", "Corolla");
Vehicle car5 = new Vehicle("VROOM", "Dodge", "Challenger");
// Park vehicles
// Find vehicle (ask the user for a Vehicle to find)
// Remove a vehicle and calculate fee
}
}Last updated
Was this helpful?