DEV Community

dev.to staff
dev.to staff

Posted on

Daily Challenge #120 - Growth of a Population

In a small town, the population is p0 = 1000 at the beginning of a year. The population regularly increases by 2 percent per year and moreover 50 new inhabitants per year come to live in the town.

How many years does the town need to see its population greater or equal to p = 1200 inhabitants?

At the end of the first year there will be:
1000 + 1000 * 0.02 + 50 => 1070 inhabitants

At the end of the 2nd year there will be:
1070 + 1070 * 0.02 + 50 => 1141 inhabitants (number of inhabitants is an integer)

At the end of the 3rd year there will be:
1141 + 1141 * 0.02 + 50 => 1213

It will need 3 entire years.

More generally given parameters:

p0, percent, aug (inhabitants coming or leaving each year), p (population to surpass)

the function nb_year should return n number of entire years needed to get a population greater or equal to p.

aug is an integer, percent a positive or null number, p0 and p are positive integers (> 0)

Examples:
nb_year(1500, 5, 100, 5000) -> 15
nb_year(1500000, 2.5, 10000, 2000000) -> 10

Note: Don't forget to convert the percent parameter as a percentage in the body of your function: if the parameter percent is 2 you have to convert it to 0.02.


This challenge comes from Becojo on CodeWars. Thank you to CodeWars, who has licensed redistribution of this challenge under the 2-Clause BSD License!

Want to propose a challenge idea for a future post? Email yo+challenge@dev.to with your suggestions!

Top comments (15)

Collapse
 
savagepixie profile image
SavagePixie

JavaScript recursion

const nbYear = (p0, percent, aug, p, year=0) => p0 >= p ? year : nbYear(p0 + Math.round(p0 * percent / 100) + aug, percent, aug, p, year + 1)
Enter fullscreen mode Exit fullscreen mode
Collapse
 
dak425 profile image
Donald Feury

Lets have a Go, shall we?

population.go

package population

// Threshold returns the number of years needed for the given population
// to reach a given population threshold
func Threshold(p0, aug, p int, percent float64) (year int) {
    for p0 < p {
        year++
        p0 += int(float64(p0)*(percent/100)) + aug
    }
    return
}

population_test.go

package population

import "testing"

type testCase struct {
    description string
    p0          int
    aug         int
    p           int
    percent     float64
    expected    int
}

func TestThreshold(t *testing.T) {
    testCases := []testCase{
        testCase{"first example", 1500, 100, 5000, 5, 15},
        testCase{"second example", 1500000, 10000, 2000000, 2.5, 10},
    }

    for _, test := range testCases {
        if result := Threshold(test.p0, test.aug, test.p, test.percent); result != test.expected {
            t.Fatalf("FAIL: %s - Threshold(%d, %d, %d, %f): %d - expected: %d", test.description, test.p0, test.aug, test.p, test.percent, result, test.expected)
        }
        t.Logf("PASS: %s", test.description)
    }
}
Collapse
 
qkleinfelter_98 profile image
Quinn Kleinfelter

Simple python solution:

def nb_year(p0, percent, aug, p):
    numyears = 0
    newpop = p0
    while(newpop < p):
        newpop = newpop + (newpop * (percent / 100)) + aug
        numyears = numyears + 1
    return numyears
Collapse
 
hectorpascual profile image
Héctor Pascual

I implemented the same but using recursion, check if you want :)

Collapse
 
peter279k profile image
peter279k

Here is the PHP code snippets:

function nbYear($p0, $percent, $aug, $p) {
  $percent = $percent / 100;
  $entry = 0;
  while ($p0 < $p) {
    $p0 = $p0 + $p0 * $percent + $aug;
    $entry += 1;
  }

  return $entry;
}
Collapse
 
kesprit profile image
kesprit

Swift solution :

func nbYears(populationOrigin: Int, percent: Float, aug: Int, populationTarget: Int) -> Int {
    var numberOfYears = 0
    guard populationOrigin > 0, populationTarget > 0 else { return numberOfYears }
    var increasePopulation = Double(populationOrigin)
    while increasePopulation < Double(populationTarget) {
        increasePopulation += (increasePopulation * Double(percent / 100)) + Double(aug)
        numberOfYears += 1
    }
    return numberOfYears
}
Collapse
 
bjorngrunde profile image
Björn Grunde

Elixir variant :)

@doc """
     iex> nb_year(1150, 2, 30, 5000)
     iex> 46
  """
  def nb_year(p0, percent, aug, p, year \\ 0) do
    if p0 >= p,
      do: year,
      else: nb_year(p0 + p0 * (percent / 100) + aug, percent, aug, p, year + 1)
  end
Collapse
 
aminnairi profile image
Amin • Edited

Elm

overcrowding : Int -> Float -> Int -> Int -> Int
overcrowding population evolution augmentation expectedPopulation =
    let
        newPopulation : Int
        newPopulation =
            (toFloat population) * (1.0 + evolution / 100) ^ 1 + (toFloat augmentation)
                |> ceiling
    in
    if newPopulation > expectedPopulation then
        1

    else
        1 + overcrowding newPopulation evolution augmentation expectedPopulation

Playground

Ellie App.

Collapse
 
vaibhavyadav1998 profile image
Vaibhav Yadav

In C

int np_year(int p0, float percent, int aug, int p) {
    int cp = p0;
    int i = 0;

    while (cp < p) {
        cp = cp + cp * percent / 100 + aug;
        i++;
    }

    return i;
}
Collapse
 
hectorpascual profile image
Héctor Pascual

A python one using recursion :

def nb_year(p0, inc, new_comers, p, calls=1):
  pn = p0*(1+inc/100)  + new_comers
  if pn >= p:
    return calls
  else:
    return nb_year(pn, inc, new_comers, p, calls+1)


print(nb_year(1500,5,100,5000))
print(nb_year(1500000, 2.5, 10000, 2000000))
Collapse
 
udiudi profile image
Udi

Ruby

def nb_year(p0, percent, aug, p)
  actual_percent = percent.to_f / 100
  year = 0

  while p >= p0
    year += 1
    p0 += p0 * actual_percent + aug
  end

  year
end
Collapse
 
erezwanderman profile image
erezwanderman

JS

nb_year = (p0, p100, aug, target) => {
    const rate = p100/100 + 1;
    let n, pop;
    for (n = 0, pop = p0; pop < target; n++) {
        pop = ~~(pop * rate + aug);
    }
    return n;
}
Collapse
 
savagepixie profile image
SavagePixie

By the way, I've just noticed that the author of this challenge is g964, not Becojo. It might be good to fix that in the post.

Collapse
 
swarajlaha profile image
Swaraj Laha

function nbYear(p0, percent, aug, p) {
// your code
let n = 0;
while(p0 < p) {
p0 = p0 + Math.round(p0 * (percent/100)) + aug;
n ++;
}

return n;
}