Go: package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

var sc = bufio.NewScanner(os.Stdin)

func read() string {
	sc.Scan()
	return sc.Text()
}

func main() {
	sc.Split(bufio.ScanLines)
	max := 0.0
	min := 1000000.0
	for sc.Scan() {
		n, _ := strconv.ParseFloat(sc.Text(), 64)
		if max < n {
			max = n
		}
		if min > n {
			min = n
		}
	}
	fmt.Println(max - min)
}

C++: #include <iostream>

using namespace std;

double high,low,m;
int main() {
	cin >> m;
	high = low = m;
	while(cin >> m){
		if(m>high){
			high = m;
		}else if(m<low){
			low = m;
		}
	}
	cout << high-low << endl; 
	return 0;
}

C++: #include <iostream>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

int main(){
  vector<float> mountains;
  float tmp;
  while(cin >> tmp){
    mountains.push_back(tmp);
  }
  float max, min;
  max = *max_element(mountains.begin(), mountains.end());
  min = *min_element(mountains.begin(), mountains.end());
  cout << max - min << endl;
}

C++: #include<stdio.h>
int main()
{
	double f[50],m=0;
	int n=0;
	while(scanf("%lf",&f[n])!=EOF){
		n++;
	}
	for(int i=0;i<n;i++){
		for(int j=0;j<n;j++){
			if(f[i]-f[j]>m){
				m=f[i]-f[j];
			}
		}
	}
	printf("%.2lf\n",m);
	return 0;
}

C++: #include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

void solve()
{
	double a;
	vector<double> Vec;
	while(cin >> a)
	{
		Vec.push_back(a);
	}
	sort(Vec.begin(), Vec.end());
	int size = Vec.size();
	cout << Vec[size - 1] - Vec[0] << endl;
}

int main()
{
	solve();
	return(0);
}

C++: #include<iostream>

using namespace std;

int main(void)
{
	double min,max;
	double tmp;
	cin>>min;
	max=min;
	while(cin>>tmp)
	{
		if(tmp<min)min=tmp;
		if(tmp>max)max=tmp;
	}
	cout<<max-min<<endl;
}

C++: #include<iostream>

using namespace std;

int main(void){
	double high=0,low=0,data;
	
	cin>>data;
	high=low=data;
	while(cin>>data){
		if(high<data)	high=data;
		if(low>data)	low=data;
	}
	cout<<high-low<<endl;

	return 0;
}

C++: #include <bits/stdc++.h>

#define rep(i, n) for (int i = 0; i < int(n); i++)
#define rrep(i, n) for (int i = int(n) - 1; i >= 0; i--)
#define reps(i, n) for (int i = 1; i <= int(n); i++)
#define rreps(i, n) for (int i = int(n); i >= 1; i--)
#define repc(i, n) for (int i = 0; i <= int(n); i++)
#define rrepc(i, n) for (int i = int(n); i >= 0; i--)
#define repi(i, a, b) for (int i = int(a); i < int(b); i++)
#define repic(i, a, b) for (int i = int(a); i <= int(b); i++)
#define repp(i, n) rep(i, n)
#define reppp(i, n) repp(i, n)
#define rrepp(i, n) rrep(i, n)
#define repss(i, n) reps(i, n)
#define repcc(i, n) repc(i, n)
#define repii(i, a, b) repi(i, a, b)
#define each(x, y) for (auto &x : y)
#define all(a) (a).begin(), (a).end()
#define bit(b) (1ll << (b))

using namespace std;

using i32 = int;
using i64 = long long;
using u64 = unsigned long long;
using f80 = long double;
using vi32 = vector<i32>;
using vi64 = vector<i64>;
using vu64 = vector<u64>;
using vf80 = vector<f80>;
using vstr = vector<string>;

inline void yes() { cout << "Yes" << '\n'; exit(0); }
inline void no() { cout << "No" << '\n'; exit(0); }
inline i64 gcd(i64 a, i64 b) { if (min(a, b) == 0) return max(a, b); if (a % b == 0) return b; return gcd(b, a % b); }
inline i64 lcm(i64 a, i64 b) { return a / gcd(a, b) * b; }
inline u64 xorshift() { static u64 x = 88172645463325252ull; x = x ^ (x << 7); return x = x ^ (x >> 9); }
void solve(); int main() { ios::sync_with_stdio(0); cin.tie(0); cout << fixed << setprecision(16); solve(); return 0; }
template <typename T> class pqasc : public priority_queue<T, vector<T>, greater<T>> {};
template <typename T> class pqdesc : public priority_queue<T, vector<T>, less<T>> {};
template <typename T> inline void amax(T &x, T y) { if (x < y) x = y; }
template <typename T> inline void amin(T &x, T y) { if (x > y) x = y; }
template <typename T> inline T power(T x, i64 n, T e = 1) { T r = e; while (n > 0) { if (n & 1) r *= x; x *= x; n >>= 1; } return r; }
template <typename T> istream& operator>>(istream &is, vector<T> &v) { each(x, v) is >> x; return is; }
template <typename T> ostream& operator<<(ostream &os, vector<T> &v) { rep(i, v.size()) { if (i) os << ' '; os << v[i]; } return os; }
template <typename T, typename S> istream& operator>>(istream &is, pair<T, S> &p) { is >> p.first >> p.second; return is; }
template <typename T, typename S> ostream& operator<<(ostream &os, pair<T, S> &p) { os << p.first << ' ' << p.second; return os; }

void solve() {
  vf80 v;
  f80 x;
  while (cin >> x) v.push_back(x);
  sort(all(v));
  cout << v[v.size() - 1] - v[0] << '\n';
}

C++: #include <stdio.h>
#include <math.h>
#include <iostream>

using namespace std;

int main() {

	double a;
	int i = 0;
	double MAX;
	double MIN;
	double kai;

	while(cin >> a) {
		if (i == 0) {
			MAX = a;
			MIN = a;
		} else {
			MAX = max(MAX,a);
			MIN = min(MIN,a);
		}
		i++;
	}

	kai = MAX - MIN;

	cout << kai << endl;

	return 0;
}

C++: #include<iostream>
using namespace std;

int main() {
	double min = 1000000, max = 0,num;
	while (cin >> num) {
		if (min > num)min = num;
		if (max < num)max = num;
	}
	cout << max - min;
	return 0;
}

C++: #include <cstdio>
#include <cstdlib>
#include <cmath>
using namespace std;
double m,h,l;
int main()
{
    while(~scanf("%lf",&m) {
        h=max(m,h);
        l=min(m,l);
    }
    printf("%f\n",fabs(h-l));
    return 0;
}

C++: #include <cstdio>

using namespace std;

double max = 0, min = 1000000000;

signed main()
{
    double index;
    while( scanf( "%lf\n", &index ) != EOF )
    {
        if( max < index ) 
        {
            max = index;
        }
        if( index < min )
        {
            min = index;
        }
    }

    printf( "%.1lf\n", max - min );
    return 0;
}

C++: #include <stdio.h>

int main(void){
double max,min,n;
scanf("%lf",&n);
max=min=n;
while(scanf("%lf",&n)!=EOF){
if(n>max) max=n;
if(n<min) min=n;
}
printf("%f\n",max-min);
return 0;
}

C++: #include "bits/stdc++.h"
using namespace std;

int main() {
	vector<double> vec(0); double temp;
	while (cin >> temp) { vec.push_back(temp); }
	sort(vec.begin(), vec.end());
	cout << vec[vec.size() - 1] - vec[0] << endl;
	return 0;
}

C++: #include<iostream>
using namespace std;
int main() {
	long float syo, dai, c;
	dai = -1;
	syo = 1999999;
	while (cin >> c) {
		if (dai <= c) {
			dai = c;
		}
		if (syo >= c) {
			syo = c;
		}
	}
	cout << dai - syo << endl;
}

C++: #include <cstdio>
#include <cmath>
#include <climits>
#include <algorithm>

using namespace std;

double m,h,l;

int main()
{
    while(~scanf("%lf",&m)) {
        h=max(m,h);
        l=min(m,(double)INT_MAX);
    }
    printf("%f\n",fabs(h-l));
    return 0;
}

C++: #include <iostream>
#include <iomanip>
using namespace std;


int main(){
  float h,l,m;
  cin>>m;
  h=l=m;
  while(cin>>m){
    if(h<m) h=m;
    else if(l>m) l=m;
  }
  cout<<fixed<<setprecision(1)<<h-l<<endl;
  return 0;
}

C++: #include <iostream>
#include <algorithm>
#include <vector>
#include <iterator>
using namespace std;
int main(){
	double a;
	int i=0;
	vector<double> dat;
	while(cin>>a){
		dat.push_back(a);
		i++;}
	sort(dat.begin(),dat.end());
	cout<<dat[i-1]-dat[0]<<endl;
        return 0;
}

C++: #include <iostream>

using namespace std;

int main()
{
    double min, max, tmp;
    cin >> tmp;
    min = max = tmp;

    while (cin >> tmp) {
        if (tmp < min) {
            min = tmp;
        }
        if (tmp > max) {
            max = tmp;
        }
    }

    cout << fixed << (max - min) << endl;

    return 0;
}

C++: #include <cstdio>

int main()
{
  double n, h = 0.0, l = 999999999.0;
  int i = 5;

  while (i--){
    scanf("%f", &n);
    h = max(h, n);
    l = min(l, n);
  }

  printf("%.1f\n", h - l);
}