How you can Bounce Balls in C

The problem

A baby is taking part in with a ball on the nth ground of a tall constructing. The peak of this ground, h, is understood.

He drops the ball out of the window. The ball bounces (for instance), to two-thirds of its peak (a bounce of 0.66).

His mom seems to be out of a window 1.5 meters from the bottom.

What number of instances will the mom see the ball go in entrance of her window (together with when it’s falling and bouncing?

Three situations have to be met for a sound experiment:

• Float parameter “h” in meters have to be better than 0
• Float parameter “bounce” have to be better than 0 and fewer than 1
• Float parameter “window” have to be lower than h.

If all three situations above are fulfilled, return a optimistic integer, in any other case return -1.

Be aware:

The ball can solely be seen if the peak of the rebounding ball is strictly better than the window parameter.

Examples:

- h = 3, bounce = 0.66, window = 1.5, result's 3

- h = 3, bounce = 1, window = 1.5, result's -1 

(Situation 2) not fulfilled).

The answer in C

Choice 1:

#embody <stdio.h>
#embody <stdlib.h>

int bouncingBall(double h, double bounce, double window) {
    if ((h <= 0) || (window >= h) || (bounce <= 0) || (bounce >= 1))
        return -1;
    int seen = -1;
    whereas (h > window) {
        seen += 2;
        h = h * bounce;
    }
    return seen;
}

Choice 2:

#embody <math.h>

int bouncingBall(double h, double bounce, double window) {
    if (h <= 0 || bounce <= 0 || bounce >= 1 || window >= h) {
      return -1;
    }
    return 2*ceil(log(window/h)/log(bounce)) - 1;
}

Choice 3:

int bouncingBall(double h, double bounce, double window) {
    if(!(h>0 && bounce>0 && bounce<1 && window<h)) return -1;
    int instances=1; double okay;
    for(okay=h*bounce; okay>window; okay*=bounce) instances+=2;
    return instances;
}

Check instances to validate our resolution

#embody <stdlib.h>
#embody <time.h>
#embody <criterion/criterion.h>

extern int bouncingBall (double h, double bounce, double window);

static void testequal(double h, double bounce, double window, int anticipated) {
    int precise = bouncingBall(h, bounce, window);
    cr_assert_eq(precise, anticipated,
    "for h = %f, bounce = %f, window = %fn"
    "anticipated %d, however received %d",
    h, bounce, window,
    anticipated, precise
  );
}

static int resolution (double h, double bounce, double window) {
    if ((h <= 0) || (window >= h) || (bounce <= 0) || (bounce >= 1))
        return -1;
    int seen = -1;
    whereas (h > window) {
        seen += 2;
        h = h * bounce;
    }
    return seen;
}

static int randomGen(int a, int b){
    int r = rand();
    return r % (b - a) + a;
}

Check(bouncingBall, randomTests) {       
    srand(time(NULL));

  enum {N = 30};

    const double someheights[N] = {
    12, 10.5, 144, 233, 15.25, 61, 98, 15.9, 25.8, 41.8, 67, 109, 17, 28, 46,
        7.5, 12.20, 19, 3, 5, 83, 13, 21, 35.5, 57, 92, 14, 24, 39, 6.5
  };
    const double someBounces[N] = {
    0.6, 0.6, 0.6, 0.6, 0.6, 1.1, 9, 1, 0.6, 0.6, 0.6, 0.75, 0.75, 0.75, 0.75,
        0.75, 12.20, 0.75, 0.75, 0.83, 0.13, 0.21, 0.35, 0.57, 0.9, 0.14, 0.24, 0.39, 0.65, 0.65
  };
    const double somewin[N] = {
    1.5, 1.5, 1.44, 2.33, 1, 6.1, 9.8, 1.9, 2.8, 4.8, 3, 1.09, 1.7, 2.8, 46, 7.5,
        12.20, 1.9, 3, 5, 0.83, 1.3, 2.1, 3.5, 0.57, 0.92, 1.4, 2.4, 3.9, 6.5
  };

    for (int okay = 0; okay < 100; okay++) {
        int i = randomGen(0, N - 1);
        double h = someheights[i];
        double b = someBounces[i];
        double w = somewin[i];
        testequal(h, b, w, resolution(h, b, w));
    }
}

Check(bouncingBall, sampleTests) {       
    testequal(2, 0.5, 1.0, 1);
    testequal(3, 0.66, 1.5, 3);
    testequal(30, 0.66, 1.5, 15);
    testequal(30, 0.75, 1.5, 21);
    testequal(30, 0.4, 10, 3);
    testequal(40, 0.4, 10, 3);
    testequal(10, 0.6, 10, -1);
    testequal(40, 1, 10, -1);
    testequal(-5, 0.66, 1.5, -1);
    testequal(5, -1, 1.5, -1);
    testequal(4, 0.25, 1.0, 1);
}