Question

Below is a school problem of mine.

WHAT I KNOW AND HAVE DONE.

i have three variables for input

n for nunber of wnemies

k for fight capacity

an arraylist set to the size of n because it only needs to be as large as the number of enemies coming.

and x which is just the time stamps that will go into the arraylist.

i also have tHe array sorted from least to greatest because it doesnt matter what order they enter the times at but the time of the oppenets matters.

HELP NEEDED HERE.

I need help on how to handle the conditions of the program.

i know that it takes 1000secs to defeat an enemy. if an enemy appears and it is before 1000secs and less than an avengers capacity i need to add an avenger.

im having trouble on how to implent this into my program.

After many sacrifices and multiple time-heists, our beloved Avengers, finally managed to reverse

Thanos’ snap and bring everyone back to Earth. Now, only the final battle remains. Thanos’

army is huge and unpredictable, and the Avengers need to know when they will be attacking.

Luckily through Dr. Strange’s time travelling skills, he has seen the future and knows the arrival

time for each enemy. It is your job to find out how many avengers are needed to fight off

Thanos’ army.

Please make sure you are using an ArrayList<Integer> in this assignment. This is a requirement.

he timestamps are in chronological order. i.e. they will be entered by the user in increasing order.

To simplify this problem, we will make the following assumptions.

1) Every avenger can fight off equal number of enemies at once.

2) Each enemy takes 1000 seconds to defeat.

3) Multiple enemies may arrive at the same time.

Inputs

Your program will take the following inputs.

N: The total number of enemies to defeat.

K : the number of enemies each avenger can handle at once.

A list of N numbers, representing timestamps (in seconds).

Output

Your program should output the MINIMUM number of avengers needed to fight off Thanos’

army.

Sample Cases

Test Run 1

Input

Enter number of enemies (N) : 2

Enter fighting capacity of each avenger(K) : 1

Enter time of arrival for each enemy

300

1500

Output

1 avenger(s) are needed to fight off the army

Explanation: Avenger 1 starts fighting at t=300, defeats the first enemy at t=1300, can thus fight

the next enemy at t=1500. No additional avengers needed.

Test Run 2

Input

Enter number of enemies (N) : 3

Enter fighting capacity of each avenger(K) : 2

Enter time of arrival for each enemy

500

510

1499

Output

2 avenger(s) are needed to fight off the army

Explanation: Avenger 1 starts fighting at t=500, at t=510, 2nd enemy arrives, A1 can handle 2

enemies at once (see value of K), so still just 1 avenger needed. Next enemy arrives at t=499,

which is less than (500+1000), which means A1 is still fighting off 2 enemies at t=1499. Hence a

2nd avenger is needed, to deal with the last enemy. So minimum number = 2

Test Run 3

Input

Enter number of enemies (N) : 14

Enter fighting capacity of each avenger(K) : 3

Enter time of arrival for each enemy

100

200

345

980

1123

1242

1466

1777

1900

2000

2000

2001

2500

3000

Output

3 avenger(s) are needed to fight off the army

Explanation for Test Run 3 (A1 , A2 , A3 represents each avenger)

earliest

100

A1

earliest

100 200

A1 A1

earliest

100 200 345

A1 A1 A1

earliest

100 200 345 980

A1 A1 A1 A2

earliest

1123 200 345 980

A1 A1 A1 A2

earliest

1123 1242 345 980

A1 A1 A1 A2

earliest

1123 1242 1466 980

A1 A1 A1 A2

earliest

1123 1242 1466 1777

A1 A1 A1 A2

earliest

1123 1242 1466 1777 1900

A1 A1 A1 A2 A2

earliest

1123 1242 1466 1777 1900 2000

A1 A1 A1 A2 A2 A2

earliest

1123 1242 1466 1777 1900 2000 2000

A1 A1 A1 A2 A2 A2 A3

earliest

1123 1242 1466 1777 1900 2000 2000 2001

A1 A1 A1 A2 A2 A2 A3 A3

earliest

2500 1242 1466 1777 1900 2000 2000 2001

A1 A1 A1 A2 A2 A2 A3 A3

earliest

2500 3000 1466 1777 1900 2000 2000 2001

A1 A1 A1 A2 A2 A2 A3 A3

Approach

1) Each timestamp represents the time at which an enemy arrives.

2) You can represent the above data structure using an arraylist.

ArrayList<Integer> arr = new ArrayList<Integer>();

3) Every time you encounter a timestamp, you first check to see if 1000 secs has passed

since the earliest timestamp in your list. If yes, then the corresponding avenger has fought

off the earliest enemy in your list and has a ”slot open” to now fight the current enemy.

4) If 1000 secs have NOT passed since the earliest, then do one of the following

a. If the latest avenger is capable of simultaneously fighting more enemies than he is

currently fighting, then assign the current enemy to one of the “empty slots”

b. If all avengers are at full capacity, then introduce a new avenger, increment

minimum number of avengers needed by 1

Answer 1

here is the solution i have tried

and came up witha solution in java

If you find any issues or errors you can ask me here

import java.util.Scanner;
import java.util.ArrayList;


public class HelloWorld {
    

        public static void main(String[] args) {
                // TODO Auto-generated method stub

                Avengers_Info in = new Avengers_Info(); 
                System.out.println("Enter the number of enemies: ");
                
                Scanner input = new Scanner(System.in);
                int enemies = input.nextInt() ;
                
            System.out.println("Enter fighting capcity of each avenger : ");
                
            int fightCap = input.nextInt();
            fightCap = fightCap * 1000;
            
            System.out.println("Enter the time where the enemies are coming: " + " (Type a negative number to stop)");
         
            
          int enterTime = 0;
           do { 
                enterTime = input.nextInt();
           } while (enterTime > 0);
           
           
                
           //section 2
           in.setTimeOfArrival(enterTime);;
           in.setEnemies(enemies);
           in.setFightCap(fightCap);
           
              
           //Prints out statement
           
          System.out.println(in.AvengerNeeded(enterTime, fightCap) + " avenger(s) is needed to fight off the army" ); 
                        
                }
           
        }
         class Avengers_Info {

        ArrayList<Integer> timeOfArrival = new ArrayList <Integer>();
         
        int enemies ; 
        int fightCap;
    int avengers;
        
        public Avengers_Info() {
                
                int enemies = 0; 
                int fightCap = 0;
                int avengers = 0;
                
        }
        
        //---------Setters and Getters-------------
        public int getEnemies() {
                
                return enemies;
        }

        public void setEnemies(int enemies) {
                this.enemies = enemies;
        }

        public int getFightCap() {
                return fightCap;
        }

        public void setFightCap(int fightCap) {
                this.fightCap = fightCap;
        }
        
        public ArrayList<Integer> getTimeOfArrival() {
                return timeOfArrival;
        }

        public void setTimeOfArrival(int enterTime) {
                timeOfArrival.add(enterTime);
        }
        //-----------------------------------------------------


        
        
        //find the number of avengers needed to fight off enemies
        public int AvengerNeeded(int enterTime, int fightCap) {
                
                
                if (fightCap > enterTime ) { 
                 return  avengers++;
                }
                else if (enterTime > fightCap) {
                        return avengers + 2;
                }
                        
                return avengers;
        }
        


        
        
}

ask me for help