我如何获得确切的答案？

Question

A breeding group of 20 bighorn sheep is released in a protected area in Colorado. It is expected that with careful management the number of sheep, N, after t years will be given by the formula:

N = 220/(1 + 10(0.83)t ) and that the sheep population will be able to maintain itself without further supervision once the population reaches a size of 80.

Write a program (using a for loop) that writes out the value of N for t starting at zero and going up to 25. How many years must the sheep heard be supervised?

Here is my code:

import java.lang.Math;

class SheepHerd {

public static void main(String[] args){

    for(double t = 0; t <= 25; t++) {

        double N =  220 / (1 +10 * (Math.pow(.83, t)));
        System.out.println(N);

    }
  }
}

The terminal shows me the numbers, and I can see that it takes between 9 and 10 years, but how can I get the exact years?

Answer 1

Since you are already using a double as counter, you could try incrementing it not by 1, but by a smaller value like 0.1:

for(double t = 0; t <= 25; t+=0.1) {
        double N =  220 / (1 +10 * (Math.pow(.83, t)));
        if (N >= 80) {
            System.out.println(N + " sheep after " + t + " years");
            break;
        }

    }

This way you can adjust the granularity of time you want, but with each step you're moving into the more exact direction, computation takes longer.

Answer 2

Add after System.out.println(N);

If (N >= 80)
   break;

This will cause your program to exit the loop after the target number (80) is reached.

The original problem is asking how many Years, so we can only assume it's asking for a whole number of Years. At year 9, you will not have enough sheep, so it cannot be year 9. It must be year 10.

Answer 3

You can solve the equation for t (or let others do this for you: Wolfram alpha solution ) and implement the resulting formula:

class SheepHerd
{
    public static void main(String[] args)
    {

        for (double t = 0; t <= 25; t++)
        {
            double N = 220 / (1 + 10 * (Math.pow(.83, t)));
            System.out.println(
                "for t=" + t + " result is " + N + 
                " check: " + computeYears(N));
        }

        System.out.println(computeYears(80));
    }

    public static double computeYears(double N)
    {
        double a = Math.log(22.0 / N - 0.1);
        double b = Math.log(100.0 / 83.0);
        return -a / b;
    }
}

Answer 4

You could definitely invert that function. If my math doesn't fail me, it would be:

          a
N = -------------
     1 + b * c^t


       1    /  a      \
c^t = --- * | --- - 1 |
       b    \  N      /

              /                        \
       1      |    /  a      \         |
t = ------- * | lg | --- - 1 | - lg(b) |
     lg(c)    |    \  N      /         |
              \                        /

Where in your case a = 220 , b = 10 , c = .83 and get the exact value of t .