## DEV Community is a community of 663,940 amazing developers

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

# Daily Challenge #120 - Growth of a Population dev.to staff
The hardworking team behind dev.to ❤️

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 (14) 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)
}
}
`````` 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 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
`````` 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;
}
`````` 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
`````` 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))
`````` 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.