DEV Community

Daily Challenge #120 - Growth of a Population

dev.to staff on November 19, 2019

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 n...

Read full post

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

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.

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

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

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

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

erezwanderman • Nov 19 '19

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

SavagePixie • Nov 20 '19

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 • Aug 18 '21

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