Go: package main

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

var sc = bufio.NewScanner(os.Stdin)

func main() {
	heights := make([]int, 10)
	for i := 0; i < 10; i++ {
		sc.Scan()
		heights[i], _ = strconv.Atoi(sc.Text())
	}

	sort.Sort(sort.Reverse(sort.IntSlice(heights)))
	for i := 0; i < 3; i++ {
		fmt.Println(heights[i])
	}
}

C++: #include <iostream>
#include <vector>
#include <string>
#include <fstream>
#include <list>
#include <cmath>
#include <fstream>
#include <queue>
#include <sstream>
#include <algorithm>
#include <cstring>
using namespace std;
template <class T> void change(T &a, T &b)// 交&#25442;
{
	T temp;
	temp = a;
	a = b;
	b = temp;
}
template <class T> void quicksort(vector<T> &S,int a,int b) // 快速排序
{
     int x = a;
	 int y = b;
	 T mid = S[(a+b)>>1];
     while (x <= y)
     {
           while (S[x] < mid) x++;
           while (S[y] > mid) y--;
           if (x <= y)
           {
              change(S[x], S[y]);
              x++;
              y--;
           }
     }
     if (x < b) quicksort(S, x, b);
     if (y > a) quicksort(S, a, y);
}
vector<int> vi;
int main()
{
	vi.resize(10);
	for(int i = 0; i < 10; i++)
		cin >> vi[i];
	quicksort(vi,0,9);
	cout << vi[9] << endl;
	cout << vi[8] << endl;
	cout << vi[7] << endl;
	return 0;
}

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

int main()
{
   long long int N, Case = 0;
   vector <long int> V;
   for(int i = 0; i < 10; i++)
   {
     long int Temp; cin >> Temp; V.push_back(Temp);
   }
   sort(V.rbegin(),V.rend());
   cout << V[0] << endl << V[1] << endl << V[2] << endl;
   return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef vector<char> vc;
typedef vector<ll> vll;
typedef vector<vector<int>> vvi;
typedef vector<vector<string>> vvs;
typedef vector<vector<char>> vvc;
typedef vector<vector<bool>> vvb;
typedef pair<int,int> P;
#define vrep(v,n) for(int i=0;i<n;i++){cin >> v.at(i);} //配列vにn個の要素を入力する
#define rep(i, l, n) for (int i = l; i < (int)(n); i++)
#define repn(i, l, n) for (int i = l; i <= (int)(n); i++)
#define pb push_back 

const int mod = 1000000007;
const int inf = 1e9;

int main(){
    vi m(10);
    rep(i,0,10){
        cin >> m[i];
    }
    sort(m.rbegin(), m.rend());
    rep(i,0,3){
        cout << m[i] << endl;
    }
    
}

C++: #include<stdio.h>
int main()
{
    int a[50],i;
    while(scanf("%d\n",&a[i])!=EOF)
    {
        int t,j;
        for(i=0; i<9; i++)
        {
            for(j=1; j<10; j++)
            {
                if(a[i]<a[j])
                {
                    t=a[i];
                    a[i]=a[j];
                    a[j]=t;
                }
            }
            for(i=0; i<4; i++)

                printf("%d\n",a[i]);
        }
    }
    return 0;
}

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

int main(){
	int h[10];
	
	for(int i = 0; i < 10, i++){
		cin >> h[i];
	}
	sort(h.begin(),h.end());
	
	for(int i = 0; i < 3, i++){
		cout << h[i] << endl;
	}
	
    return 0;
}

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

int main(){
  vector<int> a;
  int x;
  for(int i=0;i<10;i++){
    cin >> x;
      a.push_back(x);
  }
  sort(a.begin() ,a.end(),greater<int>());
  for(int i=0;i<3;i++){
    cout << a[i] << endl;
  }
  return 0;
}

C++: #include <iostream>
#include <algorithm>
#include <c++/array>

using namespace std;

int main() {
    array<int, 10> A;
    for (int i = 0; i < 10; ++i) {
        cin >> A[i];
    }

    sort(A.begin(), A.end(), std::greater<int>());

    for (int i = 0; i < 3; ++i) {
        cout << A[i] << endl;
    }

    return 0;
}

C++: fn main(){
    let mut hs: Vec<i32> = vec![];
    for _i in 0..10{
        let n=readln();
        hs.push(n);
    }
    hs.sort();
    for i in (7..10).rev(){
        println!("{}",hs[i]);
    }
}
    

// --- template ---
#[allow(unused_imports)]
use std::cmp::{max, min};
#[allow(unused_imports)]
 
pub trait FromLn {
    fn fromln(s: &str) -> Self;
}
pub fn readln<T: FromLn>() -> T {
    let mut buf = String::new();
    let _ = ::std::io::stdin().read_line(&mut buf).unwrap();
    T::fromln(buf.trim())
}
pub fn readlns<T: FromLn>(n: usize) -> Vec<T> {
    let mut vs = vec![];
    for _ in 0..n {
        vs.push(readln());
    }
    vs
}
macro_rules! fromln_primitives {
    ($($t:ty),*) => { $(
        impl FromLn for $t {
            fn fromln(s: &str) -> $t {
                s.parse().unwrap()
            }
        }
    )* }
}
fromln_primitives!(
    String,
    bool,
    f32,
    f64,
    isize,
    i8,
    i16,
    i32,
    i64,
    usize,
    u8,
    u16,
    u32,
    u64
);
impl<T> FromLn for Vec<T>
where
    T: FromLn,
{
    fn fromln(s: &str) -> Vec<T> {
        s.split_whitespace().map(T::fromln).collect()
    }
}
impl FromLn for Vec<char> {
    fn fromln(s: &str) -> Vec<char> {
        s.chars().collect()
    }
}
macro_rules! fromln_tuple {
    ($($t:ident),*) => {
        impl<$($t),*> FromLn for ($($t),*) where $($t: FromLn),* {
            fn fromln(s: &str) -> ($($t),*) {
                let mut it = s.split_whitespace();
                let t = ($($t::fromln(it.next().unwrap())),*);
                assert_eq!(it.next(), None);
                t
            }
        }
    }
}
fromln_tuple!(A, B);
fromln_tuple!(A, B, C);
fromln_tuple!(A, B, C, D);
fromln_tuple!(A, B, C, D, E);
fromln_tuple!(A, B, C, D, E, F);

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

int main(){

	int h[9];
	int i,j;
	int temp;

	h[0]=1819;
	h[1]=2003;
	h[2]=876;
	h[3]=2840;
	h[4]=1723;
	h[5]=1673;
	h[6]=3776;
	h[7]=2848;
	h[8]=1592;
	h[9]=922;

	for(i=0; i<10; i++){
		for(j=0; j<10; j++){

			if(h[i]>h[j]){
			temp=h[i];
			h[i]=h[j];
			h[j]=temp;
		
			}
		}
	}
	
	cout << "最も高い山は :" << h[0] << endl;

	cout << "２番目に高い山は :" << h[1] << endl;

	cout << "３番目に高い山は :" << h[2] <<endl;


	return 0;


}

C++: #include <stdio.h>
#include <stdlib.h>
#include <math.h>
#pragma warning(disable:4996)

int main()
{

	int MontainIn[10];

	for (int nCnt = 0; nCnt < 10; nCnt++)
		scanf("%d", &MontainIn[nCnt]);

	for (int nCnt = 0; nCnt < 10; nCnt++)
	{
		for (int nCnt2 = 0 ; nCnt2 < 10; nCnt2++)
		{
			if (nCnt2 == nCnt)
				continue;

			if (MontainIn[nCnt] > MontainIn[nCnt2])
			{
				MontainIn[nCnt] ^= MontainIn[nCnt2];
				MontainIn[nCnt2] ^= MontainIn[nCnt];
				MontainIn[nCnt] ^= MontainIn[nCnt2];
			}
		}
	}

	for (int nCnt = 0; nCnt < 3; nCnt++)
		printf("%d\n", MontainIn[nCnt]);

	return 0;
}

C++: #include<iostream>
using namespace std;
int main(){
	int t1,t2,t3,T;
	for(int i=0;i<10;i++){
		cin>>T;
		if(T>=t1){
			t3=t2;
			t2=t1;
			t1=T;
		}
		else if(T>=t2){
			t3=t2;
			t2=T;
		}
		else if(T>=t3){
			t3=T;
		}
	}
	cout<<t1<<endl<<t2<<endl<<t3<<endl;
	return 0;
}

C++: #include<stdio.h>
    main()
    {
        int a[15];
        int i,j,k;
        for(i=0;i<10;i++)
        {
            scanf("%d",&a[i]);
        }

        for(i=0;i<9;i++)
        {
            for(j=i+1;j<9;j++)
            {
                if(a[i]<a[j])
                {
                    k=a[i];
                    a[i]=a[j];
                    a[j]=k;
                }


            }
        }
        printf("%d\n%d\n%d\n",a[0],a[1],a[2]);
        return 0;

    }

C++: #include <iostream>
#include <queue>
#include <vector>
#include <set>
#include <algorithm>
#include <stdio.h>
//#define int long long
inline int in() { int32_t x; scanf("%d", &x); return x ;}
using namespace std;
const int INF = 1e18;
const int MAX_N = 1e5 + 5;
struct top3
{
    int a[4] = {0 , 0 , 0 , 0};
    void add(int x)
    {
        a[3] = x;
        sort(a , a + 4 , greater<int>());
    }
}tp;
int32_t main()
{
    int x;
    
    while (scanf("%d",&x) != EOF)
    {
        tp.add(x);
    }
    
    cout << tp.a[0] << endl << tp.a[1] << endl << tp.a[2] << endl;
}