# HackerRank Day 5: Normal Distribution II | 10 Days of Statistics solution

In this Hackerrank Day 5: Normal Distribution II 10 Days of Statistics problem in the final grades for a physical exam taken by a large group of students have a mean of 70 and a standard deviation of 10. if we can approximate the distribution of these grades by a normal distribution, what percentage of the students

1. Score higher than 80.
2. Passed the test if the grade > 60.
3. Failed the test if the grade < 60.

## Problem solution in Python programming.

```import math
mean, std = 70, 10
cdf = lambda x: 0.5 * (1 + math.erf((x - mean) / (std * (2 ** 0.5))))

print(round((1-cdf(80))*100,2))
print(round((1-cdf(60))*100,2))
print(round((cdf(60))*100,2))```

## Problem solution in Java Programming.

```import java.io.*;
import java.util.*;

public class Solution {

public static void main(String[] args) {
double u = 70.0;
double o = 10.0;
double a = 80.0;
double b = 60.0;

double r1 = 1 - 0.5*(1+erf((a-u)/(o*Math.sqrt(2))));

double r3 = 0.5*(1+erf((b-u)/(o*Math.sqrt(2))));
double r2 = 1 - r3;

System.out.println(String.format( "%.2f", r1*100));
System.out.println(String.format( "%.2f", r2*100));
System.out.println(String.format( "%.2f", r3*100));

}

public static double erf(double x) {
// constants
final double a1 =  0.254829592;
final double a2 = -0.284496736;
final double a3 =  1.421413741;
final double a4 = -1.453152027;
final double a5 =  1.061405429;
final double p  =  0.3275911;

// Save the sign of x
double sign = 1;
if (x < 0) {
sign = -1;
}
x = Math.abs(x);

// A&S formula 7.1.26
double t = 1.0/(1.0 + p*x);
double y = 1.0 - (((((a5*t + a4)*t) + a3)*t + a2)*t + a1)*t*Math.exp(-x*x);

return sign*y;
}

}```

## Problem solution in C++ programming.

```#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
/*
double func(double x, double mu, double sd) {
double a = sqrt(sd)*sqrt(2.0*M_PI);
double b = -1*pow(x-mu,2.0)/(2.0*sd);
return (1 / a)*pow(2.71828,b);
}
*/
double erf(double z) {
double t = 1.0 / (1.0 + 0.5 * abs(z));

// use Horner's method
double ans = 1 - t * exp( -z*z   -   1.26551223 +
t * ( 1.00002368 +
t * ( 0.37409196 +
t * ( 0.09678418 +
t * (-0.18628806 +
t * ( 0.27886807 +
t * (-1.13520398 +
t * ( 1.48851587 +
t * (-0.82215223 +
t * ( 0.17087277))))))))));
if (z >= 0) return  ans;

return -1*ans;
}

double func(double x, double mu, double sd) {
return 0.5 * ( 1 + erf((x - mu)/(sqrt(2)*sd)) );
}

int main() {
double mu = 70.0;
double sd = 10.0;

double b = func(80.0,mu,sd);
double c = func(60.0,mu,sd);

printf("%0.2f\n",100.0*(1-b));
printf("%0.2f\n",100.0*(1-c));
printf("%0.2f\n",100.0*c);

return 0;
}```

## Problem solution in C programming.

```#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>

// F_x (X <= x)
double cumulative_distribution (double x, double mean, double variance) {
static const double sqrt_2 = sqrt (2);
static const double one_half = 1.0 / 2.0;

return one_half * (1 + erf ((x - mean) / (sqrt (variance) * sqrt_2)));
}

int main () {
double mean, variance;
scanf ("%lf %lf", &mean, &variance);
variance *= variance;

printf ("%.2lf\n%.2lf\n%.2lf\n",
100.0 * (1.0 - cumulative_distribution (grade_1, mean, variance)),
100.0 * (1.0 - cumulative_distribution (grade_2, mean, variance)),
100.0 * (cumulative_distribution (grade_2, mean, variance)));

return 0;
}```

## Problem solution in JavaScript programming.

```function processData(input) {
function erf(x) {
let a1 = 0.254829592,
a2 = -0.284496736,
a3 = 1.421413741,
a4 = -1.453152027,
a5 = 1.061405429,
p = 0.3275911;

let sign = 1;

if (x < 0)
sign = -1;

x = Math.abs(x);

let t = 1.0 / (1.0 + p * x);
let y = 1.0 - (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t * Math.exp(-x * x);

return sign * y;
}

function cumulativeDistribution(m, sd, x) {
return 1 / 2 * (1 + erf((x - m) / (sd * Math.sqrt(2))));
}

input = input.split('\n');
input[0] = input[0].split(' ');

let m = parseFloat(input[0][0]),
sd = parseFloat(input[0][1]),
a = parseFloat(input[1]),
bc = parseFloat(input[2]);

console.log(((1 - cumulativeDistribution(m, sd, a)) * 100).toFixed(2));
console.log(((1 - cumulativeDistribution(m, sd, bc)) * 100).toFixed(2));
console.log(((cumulativeDistribution(m, sd, bc)) * 100).toFixed(2));
}

process.stdin.resume();
process.stdin.setEncoding("ascii");
_input = "";
process.stdin.on("data", function (input) {
_input += input;
});

process.stdin.on("end", function () {
processData(_input);
});```