I am working on a round robin algorithm in Java, and I have a loop that is not working correctly. I believe it is a simple logic error that I am missing. The exec[] array holds execution times for processes in a cpu. I need the quantam to be subtracted from that time or the amount of time left if less than the quantam. Then I need it to check the next process. Each process should have one pass through until the execution time is 0. The sum makes sure that the statements keep running while there is any one process that needs to run. The sum is simply from adding all the array element times.
while (sum != 0) {
int show = i + 1;
if (exec[i] != 0 && exec[i] > quant) {
exec[i] = exec[i] - quant;
sum = sum - quant;
JOptionPane.showMessageDialog(null, "Process" + " " + show + " is at" + " " + exec[i]);
JOptionPane.showMessageDialog(null, "sum" + " " + " is " + sum);
if (i == irq - 1) {
i = 0;
} else {
i++;
}
}
if (exec[i] != 0 && exec[i] < quant) {
exec[i] = exec[i] - exec[i];
sum = sum - exec[i];
JOptionPane.showMessageDialog(null, "Process" + " " + show + " is at" + " " + exec[i]);
JOptionPane.showMessageDialog(null, "sum" + " " + " is " + sum);
if (i == irq - 1) {
i = 0;
} else {
i++;
}
}
}
Please let me know if there is a fix or if any more information is needed. Thanks!
exec[i]=exec[i]-exec[i];
sum=sum-exec[i];
Is same as
exec[i]=0;
sum=sum-0;
Also, you don't treat the case of exec[i]==quant
I am not sure, what you want to do. It sounds like "I want Multithreading to make my application faster" but within in Single-Core loop, you won't succeed.
If you want a CPU round robin, let the JVM (or the operating system) decide. Both are made for this:
Some kind of java pseudo-Code:
int threadPoolSize = Runtime.getRuntime().availableProcessors();
ExecutorService pool = Executors.newFixedThreadPool(threadPoolSize);
pool.execute(new ImplementationOfCallableOrRunnable());
http://docs.oracle.com/javase/6/docs/api/java/util/concurrent/ExecutorService.html
Related
System.out.println("Composition Statistics for Families with Two Children: \n");
System.out.println("Total Number of Families: ");
FamilyNumber = Integer.parseInt(in.nextLine());
List<String> list = Arrays.asList(boy, girl);
while (RunCount < FamilyNumber) {
randNum = (int)(Math.random() * 1 + 0);
randNum2 = (int)(Math.random() * 1 + 0);
FirstGender = list.get(randNum);
SecondGender = list.get(randNum2);
GenderValues = FirstGender + SecondGender;
if (GenderValues == "BG" || GenderValues == "GB") {
BGCount++;
}
else if (GenderValues == "GG") {
GGCount ++;
}
else {
BBCount++;
}
RunCount++;
}
GGPercent = ((double)(GGCount/FamilyNumber)*(100));
BGPercent = ((double)(BGCount/FamilyNumber)*(100));
BBPercent = ((double)(BBCount/FamilyNumber)*(100));
System.out.println("Number of Families with: \n");
System.out.println("\tTwo Boys: " + BBCount + " Represents " + BBPercent + "%");
System.out.println("\tTwo Girls: " + GGCount + " Represents " + GGPercent + "%");
System.out.println("\tOne Boy and One Girl: " + BGCount + " Represents " + BGPercent + "%");
This is the segment of code the issue is in. I already initialized all the variables and imported everything necessary. The problem is, whenever I run the program, I get this output:
Composition Statistics for Families with Two Children:
Total Number of Families:
15
Number of Families with:
Two Boys: 15 Represents 100.0%
Two Girls: 0 Represents 0.0%
One Boy and One Girl: 0 Represents 0.0%
The output is always two boys make up all the families. I'm assuming that the issue is with randNum and randNum2 variables, but I'm really not sure. I have no idea what to do so any input on where I'm going wrong is greatly appreciated.
Math.random returns a number between 0 and 1.
So when cast to an int it will be always 0.
Select a scaling factor and multiply the result (lets say 5)
and then the result will an int in the range 0-4
I do not understand why the value of smallCountLoopCount changes from 0 to 1 in the code provided. I expect it to remain at 0. I use IntelliJ IDEA for testing. I have two statements to audit the values. Each are:
System.out.println("SMALL LOOP COUNT = " + smallCountLoopCount);
The first prints 0 and the second prints 1. What do I need to change to have the second one print 0?
I've tried working the () brackets to try and ensure that the math flows correctly, doing the multiplication first and then the addition second. It looks like the addition piece is incrementing the variable instead of doing math with it??
while (bigCountLoopCount <= bigCount) {
//System.out.println(bigCountLoopCount + " " + smallCountLoopCount);
if ((bigCountLoopCount * 5) == goal) {
//System.out.println("THIS TRUE ACTIVATED");
return true;
}
System.out.println("SMALL LOOP COUNT = " + smallCountLoopCount);
if (((bigCountLoopCount * 5) + smallCountLoopCount) == goal)
{
System.out.println("SMALL LOOP COUNT = " + smallCountLoopCount);
System.out.println("THIS TRUE ACTIVATED by:");
System.out.println(bigCountLoopCount + " " + smallCountLoopCount + " " + goal);
return true;
}
smallCountLoopCount++;
bigCountLoopCount++;
}
Expected result:
SMALL LOOP COUNT = 0
SMALL LOOP COUNT = 0
Actual result:
SMALL LOOP COUNT = 0
SMALL LOOP COUNT = 1
You have at the bottom of your while loop:
smallCountLoopCount++;
This is not surrounded by any condition so will always be executed. It is hard to see what exactly you're trying to do without the full piece of code, but if you want smallCountLoopCount to remain at zero, remove the above such as follows:
//System.out.println(bigCountLoopCount + " " + smallCountLoopCount);
if ((bigCountLoopCount * 5) == goal) {
//System.out.println("THIS TRUE ACTIVATED");
return true;
}
System.out.println("SMALL LOOP COUNT = " + smallCountLoopCount);
if (((bigCountLoopCount * 5) + smallCountLoopCount) == goal)
{
System.out.println("SMALL LOOP COUNT = " + smallCountLoopCount);
System.out.println("THIS TRUE ACTIVATED by:");
System.out.println(bigCountLoopCount + " " + smallCountLoopCount + " " + goal);
return true;
}
// smallCountLoopCount++ was here - Anything in this area will be executed regardless
bigCountLoopCount++;
}
This is because you have smallCountLoopCount++; at the end of the loop body. And apparently it doesn't hit neither of the returns.
If you change to goal=0 and bigCount=0 then you will get your desired output.
I know that it is a horrible question to ask at this forum since I do know the rules but at the moment I just do not know what the issue is here. So for anyone that has some spare time I would be very thankful if it could be answered. I tried to carry out the Euler Project exercise number 13: Work out the first ten digits of the sum of the following one-hundred 50-digit numbers.
I know the logic that I have used behind it is not the best and later I managed to solve the problem using another method, but it still bothers me until today why does the following code not work:
import java.util.ArrayList;
public class LargeSum {
public static ArrayList<String> addAll(ArrayList<ArrayList<Integer>> listOfResults) {
ArrayList<String> result = new ArrayList<String>();
int singlesum = 0;
int remainder = 0;
for (int i = 49; i >= 0; i--) {
System.out.println(remainder + "to rem");
singlesum += remainder;
for (ArrayList<Integer> list : listOfResults) {
System.out.println(list.get(i));
singlesum += list.get(i);
}
String lastChar = String.valueOf(singlesum);
singlesum = 0;
result.add(String.valueOf(lastChar.charAt(lastChar.length() - 1)));
remainder = 0;
if (lastChar.length() > 1) {
remainder = Integer.parseInt(lastChar.substring(0, lastChar.length() - 1));
}
}
if (remainder > 0)
result.add(String.valueOf(remainder));
return result;
}
public static ArrayList<ArrayList<Integer>> createLists() {
ArrayList<ArrayList<Integer>> results = new ArrayList<ArrayList<Integer>>();
String c =
"37107287533902102798797998220837590246510135740250"
+ "46376937677490009712648124896970078050417018260538"
+ "74324986199524741059474233309513058123726617309629"
+ "91942213363574161572522430563301811072406154908250"
+ "23067588207539346171171980310421047513778063246676"
+ "89261670696623633820136378418383684178734361726757"
+ "28112879812849979408065481931592621691275889832738"
+ "44274228917432520321923589422876796487670272189318"
+ "47451445736001306439091167216856844588711603153276"
+ "70386486105843025439939619828917593665686757934951"
+ "62176457141856560629502157223196586755079324193331"
+ "64906352462741904929101432445813822663347944758178"
+ "92575867718337217661963751590579239728245598838407"
+ "58203565325359399008402633568948830189458628227828"
+ "80181199384826282014278194139940567587151170094390"
+ "35398664372827112653829987240784473053190104293586"
+ "86515506006295864861532075273371959191420517255829"
+ "71693888707715466499115593487603532921714970056938"
+ "54370070576826684624621495650076471787294438377604"
+ "53282654108756828443191190634694037855217779295145"
+ "36123272525000296071075082563815656710885258350721"
+ "45876576172410976447339110607218265236877223636045"
+ "17423706905851860660448207621209813287860733969412"
+ "81142660418086830619328460811191061556940512689692"
+ "51934325451728388641918047049293215058642563049483"
+ "62467221648435076201727918039944693004732956340691"
+ "15732444386908125794514089057706229429197107928209"
+ "55037687525678773091862540744969844508330393682126"
+ "18336384825330154686196124348767681297534375946515"
+ "80386287592878490201521685554828717201219257766954"
+ "78182833757993103614740356856449095527097864797581"
+ "16726320100436897842553539920931837441497806860984"
+ "48403098129077791799088218795327364475675590848030"
+ "87086987551392711854517078544161852424320693150332"
+ "59959406895756536782107074926966537676326235447210"
+ "69793950679652694742597709739166693763042633987085"
+ "41052684708299085211399427365734116182760315001271"
+ "65378607361501080857009149939512557028198746004375"
+ "35829035317434717326932123578154982629742552737307"
+ "94953759765105305946966067683156574377167401875275"
+ "88902802571733229619176668713819931811048770190271"
+ "25267680276078003013678680992525463401061632866526"
+ "36270218540497705585629946580636237993140746255962"
+ "24074486908231174977792365466257246923322810917141"
+ "91430288197103288597806669760892938638285025333403"
+ "34413065578016127815921815005561868836468420090470"
+ "23053081172816430487623791969842487255036638784583"
+ "11487696932154902810424020138335124462181441773470"
+ "63783299490636259666498587618221225225512486764533"
+ "67720186971698544312419572409913959008952310058822"
+ "95548255300263520781532296796249481641953868218774"
+ "76085327132285723110424803456124867697064507995236"
+ "37774242535411291684276865538926205024910326572967"
+ "23701913275725675285653248258265463092207058596522"
+ "29798860272258331913126375147341994889534765745501"
+ "18495701454879288984856827726077713721403798879715"
+ "38298203783031473527721580348144513491373226651381"
+ "34829543829199918180278916522431027392251122869539"
+ "40957953066405232632538044100059654939159879593635"
+ "29746152185502371307642255121183693803580388584903"
+ "41698116222072977186158236678424689157993532961922"
+ "62467957194401269043877107275048102390895523597457"
+ "23189706772547915061505504953922979530901129967519"
+ "86188088225875314529584099251203829009407770775672"
+ "11306739708304724483816533873502340845647058077308"
+ "82959174767140363198008187129011875491310547126581"
+ "97623331044818386269515456334926366572897563400500"
+ "42846280183517070527831839425882145521227251250327"
+ "55121603546981200581762165212827652751691296897789"
+ "32238195734329339946437501907836945765883352399886"
+ "75506164965184775180738168837861091527357929701337"
+ "62177842752192623401942399639168044983993173312731"
+ "32924185707147349566916674687634660915035914677504"
+ "99518671430235219628894890102423325116913619626622"
+ "73267460800591547471830798392868535206946944540724"
+ "76841822524674417161514036427982273348055556214818"
+ "97142617910342598647204516893989422179826088076852"
+ "87783646182799346313767754307809363333018982642090"
+ "10848802521674670883215120185883543223812876952786"
+ "71329612474782464538636993009049310363619763878039"
+ "62184073572399794223406235393808339651327408011116"
+ "66627891981488087797941876876144230030984490851411"
+ "60661826293682836764744779239180335110989069790714"
+ "85786944089552990653640447425576083659976645795096"
+ "66024396409905389607120198219976047599490197230297"
+ "64913982680032973156037120041377903785566085089252"
+ "16730939319872750275468906903707539413042652315011"
+ "94809377245048795150954100921645863754710598436791"
+ "78639167021187492431995700641917969777599028300699"
+ "15368713711936614952811305876380278410754449733078"
+ "40789923115535562561142322423255033685442488917353"
+ "44889911501440648020369068063960672322193204149535"
+ "41503128880339536053299340368006977710650566631954"
+ "81234880673210146739058568557934581403627822703280"
+ "82616570773948327592232845941706525094512325230608"
+ "22918802058777319719839450180888072429661980811197"
+ "77158542502016545090413245809786882778948721859617"
+ "72107838435069186155435662884062257473692284509516"
+ "20849603980134001723930671666823555245252804609722";
for (int i = 0; i < 4950; i += 50) {
ArrayList<Integer> strings = new ArrayList<Integer>();
for (int j = i; j <= i + 49; j++) {
strings.add(Integer.parseInt(String.valueOf(c.charAt(j))));
}
results.add(strings);
}
return results;
}
public static void main(String[] args) {
ArrayList<ArrayList<Integer>> results = createLists();
System.out.println(addAll(results));
}
}
The array should give me the number from the back one by one each digit of the number yet I do not get the answer to the question. I investigated this many times for smaller numbers (where it worked) and for only two numbers (and it worked) yet I cannot get the answer to the question (I always get another number as result not the designated Result: 5537376230).
Thanks to everybody that looks at the code.
Best regards,
Rob
I believe the main source of the issue lies in the fact that you hardcoded a lot of numerical values and thus can not really verify correctness in the middle steps. Especially bad idea is using single String instead of the array of String[] for your source data.
Anyway, if you re-check the task you may find that the last numbers are:
...
72107838435069186155435662884062257473692284509516
20849603980134001723930671666823555245252804609722
53503534226472524250874054075591789781264330331690
while in your code you have:
+ "72107838435069186155435662884062257473692284509516"
+ "20849603980134001723930671666823555245252804609722";
So you just missed the last number and that spoils the result.
Sidenotes:
you don't really handle the top digits (your "top" digit is "55") properly which is a result of a lot of hardcoding but you probably already know that.
In java there is a BigInteger class that can solves this task easily. It is OK to write your own code for learning but for the real world task you should use a standard library unless you have a good reason not to use it.
In the case where you have a remainder left over, you add it to result as a string. But the digits in your results are reversed, so you also need to reverse the digits of the remainder.
It also looks like you've got an off-by-one error in the construction of your numbers. i < 4950 should be i < 5000 I think, since the 100th number starts at index 99 * 50 = 4950.
So, I am trying to make a text based RPG. A good starter project, as I am new to all of this. I want to make a critical hit, and math.random seems like the best way to go. Only one problem; when it loops, it doesn't refresh the random. I can assume that that's because it calls it once, and once it's called in, that's it. That's it's value. I want to know of an alternative so it refreshes every time the while loop starts over. I know there are some other bugs in my code; but that's not what I'm focusing on right now. Here's the entire method:
public void battleStart(Enemy enemy, Player player)
{
while (enemy.health != 0)
{
String battle = null;
int criticalHt = (int) (Math.random() * 10) + 0;
boolean T = true;
while (T = true)
{
battle = Game.console.next();
enemy.attackplayer(player);
if (battle.toLowerCase().contains("skip"))
{
System.out.println(criticalHt);
if (criticalHt == 1)
{
player.hitPoints -= enemy.dmg * 2;
System.out.println(Game.toTitleCase(enemy.firstName) + " " + Game.toTitleCase(enemy.lastName) + " has used " + Game.toTitleCase(enemy.attackName) + " for a critical level of " + enemy.dmg * 2 + "!.\n Your health is now " + player.hitPoints + ".");
}
else
{
player.hitPoints -= enemy.dmg;
System.out.println(Game.toTitleCase(enemy.firstName) + " " + Game.toTitleCase(enemy.lastName) + " has used " + Game.toTitleCase(enemy.attackName) + ".\n Your health is now " + player.hitPoints + ".");
System.out.println("Your turn to attack! Use an attack, or type \"skip\" to let your enemy strike.");
};
if (battle.contains("skp"))
{
};
}
}
}
Move the code
int criticalHt = (int)(Math.random() * 10) + 0;
INSIDE the while loop
while(T = true){
int criticalHt = (int)(Math.random() * 10) + 0;
battle = Game.console.next();
...
I'm having a problem with a variable not updating when its supposed to. I also am not sure where to update this variable as it does not fit into any of the if statement tests in my code. YOU MUST UNDERSTAND, that all I need fixed is where the variable peopleCompleted gets updated when the first person to enter is done. In my code you'll see where this first person is arriving, taking his place as the curServed and then being printed without being added to the queue holding everyone else who is in line. You'll notice that curServed gets changed in the serviceComplete() because it handles everyone else IN THE QUEUE. Below is my code and sameple output that is incorrect because of peopleCompleted not being updated for that first person. Basically, I really need help with knowing where to update his completion in the first place. This is a Simulation of a One Line One Queue. I am a beginner/student
CODE
public boolean arrival()
{
Customer myCust = new Customer(curTime);
if(curServed == null) // If no one being served
{
curServed = myCust; // myCust is served
peopleNoWait++;
return true;
}
else if(!q.isFull())
{
q.add(myCust);
peopleThatHadToWait++;
return true;
}
return false;
}
public Customer serviceComplete()
{
if(q.isEmpty())
{
curServed = null;
}
else
{
curServed = q.remove(); // Remove next from customer queue
peopleCompleted++;
sumOfWaitTime += getWaitTime();
}
return curServed;
}
THESE BELOW HANDLE THE SIMULATION ABOVE
private void doArrival()
{
boolean check = sim.arrival(); // Do an arrival
if(check == false)
System.out.println("Customer arrived but left immediately"
+ " because the line was full (too long) at time " +
sim.getTime() + ".");
else
System.out.println("A customer entered system at time " +
sim.getTime() + "." + " Number waiting in queue is "
+ sim.getNumWaiting() + ".");
}
private void doServiceComplete()
{
if(sim.notBeingServed() == true)
{
System.out.println("No customer is being served at the present time"
+ " of " + sim.getTime() + ".");
}
else
{
System.out.print("Customer " + sim.getCurCust().toString() +
" finished at time " + sim.getTime() + ". Number waiting" +
" is ");
System.out.println(sim.getNumWaiting() + ".");
}
sim.serviceComplete();
Methods that return the vals below
public int getNumWaiting()
{
int total = peopleThatHadToWait - peopleCompleted;
return total;
}
public int getTotalServed()
{
return peopleCompleted;
}
Sample output where error is:
Customer C1/T2 finished at time 7. Number waiting is 2. // Should be 1
Customer C2/T6 finished at time 7. Number waiting is 1. // Should be 0
Customer C3/T7 finished at time 13. Number waiting is 5. // 4
Customer C4/T7 finished at time 16. Number waiting is 4. // etc
Customer C5/T8 finished at time 16. Number waiting is 3.
Customer C6/T8 finished at time 17. Number waiting is 2.
Customer C7/T9 finished at time 17. Number waiting is 1.
The number of people served is 7. // Should be 8
The number of people served is 7. // Should be 8
COMMENTS:
These are the lines causing issue. The number waiting and the number of people
served are the ones that are incorrect. It is because of the the lack of the
peopleCompleted being updated with that first person after he is completed, which
according to your advice, is not done in serviceComplete()
I suspect it's because of this code block here.
private void doServiceComplete()
{
if(sim.notBeingServed() == true)
{
System.out.println("No customer is being served at the present time"
+ " of " + sim.getTime() + ".");
}
else
{
System.out.print("Customer " + sim.getCurCust().toString() +
" finished at time " + sim.getTime() + ". Number waiting" +
" is ");
System.out.println(sim.getNumWaiting() + ".");
}
sim.serviceComplete();
}
When you get to sim.getNumWaiting() your people waiting will be one less than you're expecting. sim.serviceComplete() has peopleCompleted++ which is performed AFTER you print your results. You should move this to the beginning of the method, or somewhere else logical, before sim.getNumWaiting() is called.
Example:
private void doServiceComplete()
{
sim.serviceComplete();
if(sim.notBeingServed() == true)
{
System.out.println("No customer is being served at the present time"
+ " of " + sim.getTime() + ".");
}
else
{
System.out.print("Customer " + sim.getCurCust().toString() +
" finished at time " + sim.getTime() + ". Number waiting" +
" is ");
System.out.println(sim.getNumWaiting() + ".");
}
}