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 <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[0] + w[1] + w[2],k[0] + k[1] + k[2]);
	outs(ww);
}

C++: #include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
vector<int> K,W;
void init(){
  K.resize(0);
  W.resize(0);
}

void input(){
  for(int i=0;i<10;i++){
    int tmp;
    cin>>tmp;
    W.push_back(tmp);
  }
  for(int i=0;i<10;i++){
    int tmp;
    cin>>tmp;
    K.push_back(tmp);
  }
}

struct A{
  int W,K;
};


A ans(){
  A res;
  sort(W.rbegin(),W.rend());
  res.W=W[0]+W[1]+W[2];
  sort(K.rbegin(),K.rend());
  res.K=K[0]+K[1]+K[2];
  return res;
}

int main(){
  init();
  input();
  A a=ans();
  cout<<a.W<<" "<<a.K<<endl;
}

C++: #include <bits/stdc++.h>
//#include <iostream>
//#include <stdio.h>
//#include <algorithm>
//#include <functional>
using namespace std;

int main() {
	int w[10], k[10];
	int i, j;
	i = 0;
	j = 0;
	while (i < 10) {
		cin >> w[i];
		i++;
	}
	while (j < 10) {
		cin >> k[j];
		j++;
	}
	sort(w,w+10,greater<int>());
	sort(k,k+10,greater<int>());
	printf("%d %d", w[0]+w[1]+w[2], k[0]+k[1]+k[2]);
	return 0;
}

C++: #include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
#define REP(i,n) for (int i=0; i<(n); i++)
#define SORT(c) sort((c).begin(),(c).end())
typedef vector<int> vi;
int main() {
	vi W(10),K(10);
	REP(i,10) scanf("%d",&W[i]);
	REP(i,10) scanf("%d",&K[i]);
	SORT(W); SORT(K);
	int w=0,k=0;
	REP(i,3) w+=W[9-i];
	REP(i,3) k+=K[9-i];
	printf("%d %d\n",w,k);
}