## DEV Community is a community of 756,027 amazing developers

We're a place where coders share, stay up-to-date and grow their careers.

# 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!

## Discussion (15) 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)
`````` 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)
}
}
`````` 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;
}
`````` 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
}
`````` 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
`````` 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 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;
}
`````` 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))
`````` 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
`````` 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. Swaraj Laha

function nbYear(p0, percent, aug, p) {