What component has the job of managing data as it flows into and out of the places it needs to go?
2 answers:
You might be interested in
Answer:
// class definition of MethodPractice
public class MethodPractice {
// main method that begin program execution
public static void main(String args[]) {
// call to the planParty2 method is done using some parameter
// and the return value is displayed
System.out.println("The number of p-packs needed is: " + planParty2(9, 14, 6));
System.out.println("The number of p-packs needed is: " + planParty2(4, 6, 3));
System.out.println("The number of p-packs needed is: " + planParty2(4, 6, 4));
}
// planParty2 method with 3 parameters and it return an integer
// the calculation needed to get the required pack is done here
public static int planParty2(int f, int c, int p){
// the party owner is added to list of friend
// and the value is assigned to totalPeople
int totalPeople = f + 1;
// the totalPeople times the can drink
// is assigned to totalDrinkNeeded
int totalDrinkNeeded = totalPeople * c;
// number of packs required is declared
int numberOfPacks;
// if the totalDrinkNeeded contains exact multiple of a pack
// we return the numberOfPack by dividing totalDrinkNeeded with p
if (totalDrinkNeeded % p == 0){
return numberOfPacks = totalDrinkNeeded / p;
}
// else we compute if the totalDrinkNeeded is not a multiple of a pack
// first we get the remainder when the totalDrinkNeeded is divided with p
// then the needed can is computed by subtracting remainder from p
// the neededCan is added to totalDrinkNeeded, then divided with p
// and assigned to numberOfPacks
// numberOfPacks is returned.
else {
int remainder = totalDrinkNeeded % p;
int neededCan = p - remainder;
numberOfPacks = (totalDrinkNeeded + neededCan) / p;
return numberOfPacks;
}
}
}
Explanation:
Image showing the detailed question is attached.
The program is written in Java and is well commented. A sample image of program output when it is executed is attached.
Answer:
The algorithm is as follows:
1. Start
2. Get the number of items (n)
3. Get the current price of the n items (a1, a2..... an)
4. Get the possible hiked price of the n items (b1, b2..... bn)
5. Calculate the difference between the current and hiked prices for each item i.e.
6. Sort the differences in descending order (i.e. from the greatest to the least)
7. Buy items in this order of difference
8. Stop
Explanation:
The algorithm is self-explanatory; however, what it does is that:
It takes a list of the current price of items (say list a)
E.g:
Then take a list of the hiked price of the items (say list b)
E.g:
Next, it calculates the difference (d) between corresponding prices
Sort the difference from greatest to lowest (as the difference is sorted, lists a and b are also sorted)
If there is no hike up to item k, the couple would have saved (i = 1 to d[k-1])
Assume k = 3
The couple would have saved for 2 item
The saved amount will then be added to the kth item in list a i.e. a[k](in this case k = 3) in order to buy b[k]
Using the assumed value of k
Add the saved amount (40) to a[3]
This new amount can then be used to buy b[3] i.e. 165, then they save the change for subsequent items