World Population Growth

[em jan]

I always struggle with the logic . Here is a problem I am working on:

Write a program that calculates world population growth each year for the next 75 years, using the simplifying  assumption that the current growth will stay constant. Print the results in a table. The first column should display the year from  year 1 to year 75. The second column should display the anticipated world  population at the end of that year. The third column should display the numerical increase in the world population that would occur that year. Using the results, determine the year in which the population would be double what it is today, if this growth rate were to persist.

Is this correct?

Note: The table just now is rudimentary and prints everything that the problem doesn't ask for.

public class Ex39WorldPopulationGrowth {
	
	public static void main (String [] args) {
		
		double growthRate = 2.0;
		double worldPopulationToday = 4.0;
		double worldPopulationIncreaseThisYear = 0;
		double worldPopulationThisYear = 0;
		int years = 1;
		int currentYear = 2019;
		
		System.out.println("Number" + "\t" + "Year" + "\t" + "World Population Today" +  "\t" + "worldPopulationThisYear" + "\t" + "worldPopulationIncreaseThisYear");
		
		System.out.println(years + "\t" + currentYear + "\t" + worldPopulationToday +  "\t\t\t" + worldPopulationIncreaseThisYear + "\t\t\t" + worldPopulationThisYear);
		
		while (years < 75) {//while
			
			worldPopulationToday *= growthRate;
			worldPopulationThisYear += worldPopulationToday;
			worldPopulationIncreaseThisYear = worldPopulationThisYear - worldPopulationToday;
			currentYear++;
			
			years++;
			
			
			System.out.printf("%d\t"
					+ "%d\t"
					+ "%,.2f\t\t\t"
					+ "%,.2f\t\t\t"
					+ "%,.2f\n", years, currentYear, worldPopulationToday, worldPopulationThisYear,worldPopulationIncreaseThisYear);
			
		}
		
		
	}//main

}//class

[salvin francis]

A couple of points:
MainIsPain <-- That's a link.
QuoteYourSources <-- That's a link.

Your solution is still incomplete, the problem statement also asks you to determine the year in which it doubles. What's your planned solution for that ?

[salvin francis]

I am also confused over the growth rate. Instead of being a simple multiplier, I would expect it to be a percent.

This is what you are doing:
population = population * growthRate

(Because your growthRate is 2.0, your population is doubled at the second iteration itself, that should be the expected answer to your problem statement)

This is what I think it should be (eg 10% growth rate):
population = population + (10% * population)


Problem statement does not ask about currentYear, yet you are tracking and iterating it with every loop. Even if you need it for printing, since it's a derived value and is dependent on loop iteration, there is no need to calculate it separately.
i.e. if you have a variable called startYear=2019, currentYear = years + (startYear - 1)  since years starts with 1.

[Campbell Ritchie]

. . . and welcome to the Ranch

[em jan]

thanks well I at least like what the current year looks like in the output. I still don't think I am doing the right thing for the population computation though. And you are right:  I somehow thought that I could write an if and magically the year of double population would show up .

I have moved the bulk of the code from main.  The main method will eventually have a while loop that will allow the user to compute population growth for different inputs.

I will share the source from where the problem is from. when I find a soft copy of it online. This is from a very old dietal How to Program text book.

public class Ex39WorldPopulationGrowth {
	
	public static void main (String [] args) {
		
		System.out.println("welcome to the World Population Growth Calculator\n");
		Scanner sc = new Scanner(System.in);
		
		System.out.print("Number of years to Project" );
		int projection = sc.nextInt();
		
		System.out.print("Current Year: ");
		int startYear = sc.nextInt();
		
		System.out.print("Current Population: ");
		double currentPopulation = sc.nextDouble();
		
		System.out.print("Growth Rate (%): ");
		double growthRate = sc.nextDouble();
		growthRate /= 100;
		
		System.out.println(growthRate);
		determinePopulationIncrease(projection, startYear, currentPopulation, growthRate);
		
		
		
	}//main
	
	public static void determinePopulationIncrease(int projection,int startYear,
			double worldPopulationToday,double rate) {
		

		System.out.println("Year" + "\t" + "Population This Year" + "\t" + "World Population Increase This Year");
		
		double worldPopulationIncreaseThisYear = 0;
		double worldPopulationThisYear = 0;
		int years = 1;
		int currentYear = 0;
	
		
		while (years < projection) {//while
			worldPopulationThisYear = worldPopulationToday;
			worldPopulationToday  = worldPopulationToday + (rate * worldPopulationToday);
			worldPopulationIncreaseThisYear = worldPopulationToday - worldPopulationThisYear;
			currentYear = years + (startYear - 1);
			years++;
				
			System.out.printf("%d\t\t"
					+ "%,.2f\t\t\t"
					+ "%,.2f\n",  currentYear, worldPopulationThisYear,worldPopulationIncreaseThisYear);
			
			}
			
		if(worldPopulationThisYear <= worldPopulationToday*2) {
			System.out.printf("Population in year %d will be twice the population today", currentYear);
		}
		
	}

}//class

[Tim Moores]

salvin francis wrote:This is what you are doing:
population = population * growthRate

This is what I think it should be (eg 10% growth rate):
population = population + (10% * population)

Both approaches are fundamentally the same, though, if the growth rate is 1.1. It's more a matter of how explicit the growth rate should be stated in the code.

[Campbell Ritchie]

Avoid the keyword static as much as possible. That means (see the links in Salvin's first post) you need to get as much code out of the main method as possible:-

class PopulationPredicterDemo
{
   // ...
   public static void main(String... args)
   {
      new PopulationPredicterDemo().run();
   }
   // ...
   void run()
   {
      Scanner input = ...
      long currentPopulation = ...
      PopulationPredicter predicter =
            new PopulationPredicter(currentPopulation);
      int yearsToPredict = ...
      // ...
      predicter.predictGrowth(growthRate, yearsToPredict);
      // ...
      /*
       * consider wrapping the prediction call in a do loop
       * so you can try different growth rates in one run
       */
   }
}

If you do it that way you will need two classes, which makes that a full‑blown application. Much more object oriented (=OO), too.
I would prefer to use double arithmetic because there is no such thing as part of a person. You can do all that with integer arithmetic:-

i = i * (100 + x) / 100;

...but make sure that i is always less than Long.MAX_VALUE ÷ (100 + x) to avoid overflow errors. Also you are stuck with whole number percentages. You can mimic 2.5% growth by entering 25 and writing 1000 rather than 100, but that is awkward isn't it.
Your prediction method is too long. It isn't doing one thing; a method should do one thing rather than trying to do multiple things. You want methods to do the calculations, to find when you get to double current population, etc. The OO way to do that might be to record future populations (maybe an array of Population objects) and the other methods can query this record.

class Population
{
   private final int year;
   private final long population;

   Population(int year, long population)
   {
      // ...
   }
   // lots of methods, but no setXXX methods
}