MeanAverage of all numbers. Sum them all up and divide them by the number of items. Mean of 1,2,3,4,5 = (1+2+3+4+5)/5 = 3
Median Sort the numbers. If the number of numbers is odd, then the middle element is the median. Else, the average of the two middle elements is the median. Median of 1,2,3,4,5 is 3 Median of 1,2,3,4 is (2+3)/2 = 2.5
Mode The number which occurs most frequently in an array. So the modal value in 1,2,2,3,3,3 is 3 The modal value in 1,2,3,3,3,20,20,20,20,25 is 20 (occurs most frequently  4 times) Standard Deviation
A measure of how dispersed the data is. SD = (((x1m)2+(x2m)2+(x3m)2+(x4m)2+...(xNm)2))/N)0.5
Python code to compute Mean, Median, Mode, Standard Deviation, Confidence Interval
import sys
import math
# Assume n = number of entries in the array, data = array of numbers from which we'll find the mean, median, mode, SD, confidence intervals
n = int(sys.stdin.readline())
#n=10
data = map(int, sys.stdin.readline().split())
#data = map(int, '64630 11735 14216 99233 14470 4978 73429 38120 51135 67060'.split())
datad = {}
summ = 0
for val in data:
summ += val
datad[val] = datad.get(val, 0) + 1
#1 Lets compute the Mean = sum/n
mean = float(summ)/n
print "%.1f" % (mean)
#2 Lets compute the median
data2 = sorted(data)
if n%2==0:
print "%.1f" % ((data2[n/21]+data2[n/2])/2.)
else:
print "%.1f" % (data[n/2])
#3 Let us compute the mode (most frequently occurring elements)
datad2 = []
for k in datad.keys():
datad2.append([k, datad[k]])
datad2.sort(key = lambda x: x[0])
datad2.sort(key = lambda x: x[1], reverse = True)
print "%i" % datad2[0][0]
#4 Let us compute the standard deviation dev = 0
for val in data:
dev += (valmean)**2
dev /= float(n)
dev = math.sqrt(dev)
print "%.1f" % dev
#5 Let us compute the lower and upper bounds of the confidence interval
t = 1.96 #0.95
delta_x = t * dev / math.sqrt(n)
#print delta_x
print "%.1f %.1f" % (meandelta_x, mean+delta_x)
Java code to compute Mean, Median, Mode, Standard Deviation, Confidence Interval
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
public class Solution {
public static void main(String[] args) {
/* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */
# Assume n = number of entries in the array, data = array of numbers from which we'll find the mean, median, mode, SD, confidence intervals
Scanner sc = new Scanner(System.in);
int N = sc.nextInt(); // number of integers
int m=N>>1; // half of N
long[] arr = new long[N]; // array to store values
double mean=0,sd=0.0,tt=0,upper=0,lower=0; // variables to store the results
int count=0,tcount=0; // variables to find count and temporary count for mode of numbers
long mode=0,temp=0;
//Lets compute the Mean = sum/n
// loop to find mean
for(int i=0;i<N;++i)
{
arr[i]=sc.nextLong();
mean += arr[i];
}
mean /=N;
// sorting array to find mode
Arrays.sort(arr);
temp = arr[0]; // assuming 1st number to be mode
tcount = 1; // count set to 1
tt = (arr[0]mean); // temp variable to store difference of valuemean
sd += (tt*tt); // accumulating square of every (valuemean) in SD
for(int i=1;i<N;++i)
{
tt = (arr[i]mean);
sd += (tt*tt);
if(temp==arr[i])
{
++tcount;
}
else
{
if(tcount>count)
{
count=tcount;
mode=temp; // updating mode
}
temp=arr[i];
tcount=1;
}
}
sd /=N;
sd = Math.sqrt(sd); // calculating SD
// calculating confidence interval
upper = mean + 1.96*(sd/Math.sqrt(N));
lower = mean  1.96*(sd/Math.sqrt(N));
mean = Math.round(mean*100)/10;
System.out.println(mean/10); // mean
if((N&1)==1) // odd
{
System.out.println(arr[N>>1]); // median
}
else // even
{
tt = (arr[m]+arr[m1]);
tt /= 2;
System.out.println(tt); // meadian
}
System.out.println(mode); // mode
sd = Math.round(sd*100)/10;
System.out.println(sd/10); // standard deviation
lower = Math.round(lower*100)/10;
upper = Math.round(upper*100)/10;
System.out.println(lower/10+" "+upper/10);
}
}
C++ code to compute Mean, Median, Mode, Standard Deviation, Confidence Interval
#include <cmath>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
int main() {
/* Enter your code here. Read input from STDIN. Print output to STDOUT */
int n;
cin>>n;
double a[n];
for(int i=0;i<n;i++) cin>>a[i];
sort(a,a+n);
double sum=0;
double sqrsm=0;
for(int i=0;i<n;i++){
sum+=a[i];
sqrsm+=(a[i]*a[i]);
}
double mean = sum/n;
double sqrsum = sqrsm/n;
double median;
if(n%2==0){
median = (a[n/2]+a[(n1)/2])/2;
}
else median = a[n/2];
int freq[100001];
memset(freq,0,sizeof(freq));
for(int i=0;i<n;i++){
freq[(int)a[i]]++;
}
vector<pair<int,int> > frequencies;
for(int i=0;i<100001;i++){
if(freq[i]!=0)
frequencies.push_back(make_pair(freq[i],i));
}
sort(frequencies.begin(),frequencies.end(),greater<pair<int,int> >());
double mode = frequencies[0].second;
int frequ = frequencies[0].first;
int i=1;
while(i<frequencies.size() && frequ == frequencies[i].first) i++;
mode = frequencies[i1].second;
double sd = sqrt((mean*mean)+sqrsum);
double sd_ = sd/(sqrt(n));
double ci_low = mean(1.96*sd_);
double ci_high = mean+(1.96*sd_);
printf("%.1f\n",mean);
printf("%.1f\n",median);
printf("%.0f\n",mode);
printf("%.1f\n",sd);
printf("%.1f %.1f\n",ci_low,ci_high);
return 0;
}
R Program to compute Mean, Median, Mode, Standard Deviation, Confidence Interval
# Enter your code here. Read input from STDIN. Print output to STDOUT
input < readLines(file('stdin'))
n < as.numeric(input[1])
values < strsplit(input[2], " ")
values < as.numeric(values[[1]])
mu < mean(values)
cat(mu, '\n')
mdn < median(values)
cat(mdn, '\n')
# calculate the mode
temp < table(values)
temp < as.numeric(names(temp)[temp == max(temp)])
mode < min(temp)
cat(mode, '\n')
# calcualte the variance
temp < (values  mu)^2
var < sum(temp)/n
sd < sqrt(var)
cat(sd, '\n')
#caculate the conf interval
se < sd/sqrt(n)
ci < mu + c(1.96, 1.96) * se
cat(ci, '\n')
Ruby Program to compute Mean, Median, Mode, Standard Deviation, Confidence Interval
n=STDIN.read.split.drop(1).map{ii.to_f}.sort
s=n.length
m=n.inject(:+)/s
sd=Math.sqrt(n.inject(0){s,is+(im)*(im)}/s)
[m,(n[(s1)/2]+n[s/2])/2].each{nputs"%.1f"%n}
puts n.group_by{ii}.values.max_by{aa.length}[0].to_i
puts"%.1f"%sd
x=1.96*sd/Math.sqrt(s)
puts [mx,m+x].map{f"%.1f"%f}.join(" ")
