Go: package main

import (
	"fmt"
	"sort"
)

func calcScore(n, m []int) (int, int) {
	sort.Ints(n)
	sort.Ints(m)
	
	return n[9] + n[8] + n[7], m[9] + m[8] + m[7]
}

func main(){
	var team_W, team_K []int
	var inp int
	
		for i := 0; i < 10; i++ {		
			fmt.Scan(&inp)
			team_W = append(team_W, inp)
		}

		for j := 0;  j< 10; j++ {		
			fmt.Scan(&inp)
			team_K = append(team_K, inp)
		}

	fmt.Println(calcScore(team_W, team_K))
}

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

using namespace std;

int main(){

  vector<int> w(10);
  vector<int> k(10);
  int w1=0;
  int w2=0;
  int w3=0;
  int k1=0;
  int k2=0;
  int k3=0;
  
  for(int i=0;i<10;++i)
	cin>>w[i];

  for(int i=0;i<10;++i)
	cin>>k[i];

  int temp;
  for(int i=0;i<10;++i){
	if(w1>w[i]){
	  w1=w[i];
	  temp=i;
	}
  }

  for(int i=0;i<10;++i){
	if(w2>w[i]){
	  w2=w[i];
	  temp=i;
	}
  }

  for(int i=0;i<10;++i){
	if(w3>w[i]){
	  w3=w[i];
	  temp=i;
	}
  }

  for(int i=0;i<10;++i){
	if(w1>k[i]){
	  w1=k[i];
	  temp=i;
	}
  }

  for(int i=0;i<10;++i){
	if(w2>k[i]){
	  w2=k[i];
	  temp=i;
	}
  }

  for(int i=0;i<10;++i){
	if(w3>k[i]){
	  w3=k[i];
	  temp=i;
	}
  }

    for(int i=0;i<10;++i){
	if(w1>k[i]){
	  w1=k[i];
	  temp=i;
	}
  }

  for(int i=0;i<10;++i){
	if(w2>k[i]){
	  w2=k[i];
	  temp=i;
	}
  }

  for(int i=0;i<10;++i){
	if(w3>k[i]){
	  w3=k[i];
	  temp=i;
	}
  }

  for(int i=0;i<10;++i){
	if(k1>k[i]){
	  k1=k[i];
	  temp=i;
	}
  }

  for(int i=0;i<10;++i){
	if(k2>k[i]){
	  k2=k[i];
	  temp=i;
	}
  }

  for(int i=0;i<10;++i){
	if(k3>k[i]){
	  k3=k[i];
	  temp=i;
	}
  }
  
  cout<<w1+w2+w3<<" "<<k1+k2+k3<<endl;

  return 0;
  
}

C++: #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <time.h>
#include <limits.h>
//#include <windows.h>
#include <iostream>
#include <algorithm>
#include <set>
#include <queue>
#include <functional>

using namespace std;

typedef unsigned int uint;
typedef long long int llint;
typedef pair<llint,llint> pii;

#define mpq(T) priority_queue<T,vector<T>,greater<T> >
#define FOR(i,a,b) for(int i = (a); i < (b); i++)
#define REP(i,a) for(int i = 0; i < (a); i++)

class BIT
{
private:
	int s;
	llint* d;
public:
	BIT(int size)
	{
		s = size;
		d = (llint*)malloc(sizeof(llint) * s);
		for(int i = 0; i < s; i++)
		{
			d[i] = 0;
		}
	}

	void add(int b,int x)
	{
		for(int i = b + 1; i <= s; i += (i & -i))
		{
			d[i - 1] += x;
		}
	}

	llint sum(int b)
	{
		llint all = 0;
		for(int i = b + 1; i > 0; i -= (i & -i))
		{
			all += d[i - 1];
		}
		return all;
	}

	~BIT()
	{
		free(d);
	}
};

class unionfind
{
private:
	int s;
	int* o;
	int* r;
public:
	unionfind(int dsize)
	{
		s = dsize;
		o = (int*)malloc(sizeof(int) * s);
		r = (int*)malloc(sizeof(int) * s);
		for(int i = 0; i < s; i++)
		{
			o[i] = i;
			r[i] = 0;
		}
	}

	int mfind(int b)
	{
		if(o[b] != b)
		{
			o[b] = mfind(o[b]);
		}
		return o[b];
	}

	void munion(int a,int b)
	{
		int aw = mfind(a);
		int bw = mfind(b);
		if(aw == bw)
		{
			return;
		}
		if(r[aw] > r[bw])
		{
			o[bw] = a;
		}
		else if(r[aw] < r[bw])
		{
			o[aw] = bw;
		}
		else
		{
			o[bw] = aw;
			r[aw]++;
		}
		s--;
	}

	int size()
	{
		return s;
	}

	~unionfind()
	{
		free(o);
		free(r);
	}
};

template<class T> int lbound(T* d,T key,int s,int e)
{
	s--;
	while(e - s > 1)
	{
		int m = (s + e) / 2;
		if(d[m] < key)
		{
			s = m;
		}
		else
		{
			e = m;
		}
	}
	return e;
}

template<class T> int ubound(T* d,T key,int s,int e)
{
	s--;
	while(e - s > 1)
	{
		int m = (s + e) / 2;
		if(key < d[m])
		{
			e = m;
		}
		else
		{
			s = m;
		}
	}
	return e;
}

class zpress
{
private:
	int ms;
	pii* md;
	int n;
	int s;
	llint* d;
	int* t;
public:
	zpress(int dsize = 1000000)
	{
		int ms = dsize;
		md = (pii*)malloc(sizeof(pii) * ms);
		d = (llint*)malloc(sizeof(llint) * ms);
		t = (int*)malloc(sizeof(int) * ms);
		n = 0;
	}

	void in(llint x)
	{
		in2(x,n);
		n++;
	}

	void in2(llint x,int b)
	{
		md[b] = make_pair(x,b);
	}

	void syori()
	{
		syori2(n);
	}

	void syori2(int k)
	{
		sort(md,md + k);
		llint mae = LLONG_MIN;
		s = 0;
		REP(i,k)
		{
			if(md[i].first != mae)
			{
				d[s] = md[i].first;
				s++;
				mae = md[i].first;
			}
			t[md[i].second] = s - 1;
		}
	}

	llint iti(int b)
	{
		return t[b];
	}

	int size()
	{
		return s;
	}

	int first(llint x)
	{
		return lbound(d,x,0,s);
	}

	int end(llint x)
	{
		return ubound(d,x,0,s);;
	}

	~zpress()
	{
		free(md);
		free(d);
		free(t);
	}
};

class xorshift
{
private:
	unsigned int a,b,c,d;
public:
	xorshift(unsigned int aw = 123456789,unsigned int bw = 362436069,unsigned int cw = 521288629,unsigned int dw = 88675123,unsigned int e = 97)
	{
		a = aw;
		b = bw;
		c = cw;
		d = dw;
		for(unsigned int i = 0; i < e; i++)
		{
			operator()();
		}
	}

	unsigned int operator()()
	{
		unsigned int w = a ^ (a << 11);
		a = b;
		b = c;
		c = d;
		d = (d ^ (d >> 19)) ^ (w ^ (w >> 8));
		return d;
	}
};

llint gcd(llint a,llint b)
{
	while(1)
	{
		llint w = a % b;
		if(w == 0)
		{
			return b;
		}
		a = b;
		b = w;
	}
}

llint sei(llint d,llint p)
{
	if(d < 0)
	{
		d -= ((d + 1) / p - 1) * p;
	}
	else
	{
		d %= p;
	}
	return d;
}

llint inv(llint a,llint p)
{
	llint r0 = sei(a,p);
	llint r1 = p;
	llint a0 = 1;
	llint b0 = 0;
	llint a1 = 0;
	llint b1 = 1;
	while(1)
	{
		llint q = r0 / r1;
		llint w = r0 - q * r1;
		if(w == 0)
		{
			break;
		}
		r0 = r1;
		r1 = w;
		w = a0 - q * a1;
		a0 = a1;
		a1 = w;
	}
	return sei(a1,p);
}

template <llint P> class mod
{
private:
	llint d;
public:
	mod(llint a = 0)
	{
		d = a;
		d = sei(d,P);
	}

	mod operator-() const
	{
		return mod(P - d);
	}

	mod operator+=(const mod& a)
	{
		d = d + a.d;
		d = sei(d,P);
		return *this;
	}

	mod operator-=(const mod& a)
	{
		return operator+=(-a);
	}

	mod operator*=(const mod& a)
	{
		d = d * a.d;
		d = sei(d,P);
		return *this;
	}

	mod operator/=(const mod& a)
	{
		return a * mod(inv(d,P));
	}

	mod operator+(const mod& a) const
	{
		mod w = *this;
		return (w += a);
	}

	mod operator-(const mod& a) const
	{
		mod w = *this;
		return (w -= a);
	}
	
	mod operator*(const mod& a) const
	{
		mod w = *this;
		return (w *= a);
	}

	mod operator/(const mod& a) const
	{
		mod w = *this;
		return (w /= a);
	}
	
	bool operator==(const mod& a) const
	{
		return (d == a.d);
	}

	bool operator!=(const mod& a) const
	{
		return (d != a.d);
	}

	operator llint() const
	{
		return d;
	}
};

/////////////////////////////////////////////////////

FILE* fi;
FILE* fo;

void err(char* a)
{
	printf("%s\n",a);
	getchar();
}

llint in()
{
	llint w;
	fscanf(fi,"%lld",&w);
	return w;
}

void ins(char* a)
{
	fscanf(fi,"%s",a);
}

void out(llint a)
{
	fprintf(fo,"%lld\n",a);
}

void outs(char* a)
{
	fprintf(fo,"%s\n",a);
}

void func();

int main()
{
	fi = stdin;
	fo = stdout;
	func();
	return 0;
}

char s[11111];

int w[10];
int k[10];

void func()
{
	REP(i,10)
	{
		w[i] = in();
	}
	REP(i,10)
	{
		k[i] = in();
	}
	sort(w,w + 10);
	sort(k,k + 10);
	char ww[100];
	sprintf(ww,"%d %d",w[9] + w[8] + w[7],k[9] + k[8] + k[7]);
	outs(ww);
}

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

int main(){
  int W[10],K[10];
  int ans_W=0,ans_K=0;
  for(int i=0;i<10;i++){
    cin >> W[i];
  }
  for(int i=0;i<10;i++){
    cin >> K[i];
  }
  sort(W,W+10,greater<int>());
  sort(K,K+10,greater<int>());
  for(int i=0;i<3;i++){
    ans_W += W[i];
    ans_K += K[i];
  }
  cout << ans_W << " " << ans_K << endl;
}

C++: #include <iostream>
#include <algorithm>
using namespace std;
 
 
int main() {
  int w[10], k[10];
   
  for(int i = 0; i < 10; i++) {
    cin >> w[i];
  }
   
  for(int i = 0; i < 10; i++) {
    cin >> k[i];
  }
 
  sort(w, w+10);
  sort(k, k+10);
 
  cout << w[9]+w[8]+w[7] << " ";
  cout << k[9]+k[8]+k[7] << endl;
   
  return 0;
}