dev.to staff

Posted on Nov 19, 2019

Daily Challenge #120 - Growth of a Population

#challenge

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 (14)

SavagePixie • Nov 19 '19

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 • Nov 19 '19

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)
    }
}

Quinn Kleinfelter • Nov 19 '19

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

Héctor Pascual • Nov 22 '19

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

peter279k • Jul 14 '20

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 • Nov 19 '19

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 • Nov 19 '19

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

Amin • Nov 19 '19 • 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.

Vaibhav Yadav • Nov 20 '19

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 • Nov 22 '19

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 • Nov 19 '19

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

View full discussion (14 comments)

DEV Community

Daily Challenge #120 - Growth of a Population

Top comments (14)

Read next

Integrating what3words in Your Angular 18 Application

Demystifying Evolutionary Algorithms: A Practical Guide

The Essential Guide to Inclusive and Responsive Web Design

Article 1: Creating a Grid Formatter for Clean Data Display