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<iostream>
#include<queue>
using namespace std;
int main(){
	priority_queue<int > q1;
	priority_queue<int > q2;
	int i=0;
	int w=0; //q1
	int k=0; //q2
	
	for(i=0;i<10;i++){
		cin>>w;
		q1.push(w);
	}
	for(i=0;i<10;i++){
		cin>>k;
		q2.push(k);
	}
	w=0;
	k=0;
	
	int x=0;
	int y=0;
	
	for(i=0;i<3;i++){
		x=q1.top();
		w+=x;
		q1.pop();
	}
	for(i=0;i<3;i++){
		y=q2.top();
		k+=y;
		q2.pop();
	}
	cout<<w<<" "<<k<<endl;
	
	return 0;
}

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

using namespace std;

int main()
{
    int w[10], k[10];
    int ws, ks;

    ws = ks = 0;
    for (int i = 0; i < 20; i++) {
        if (i < 10)
            cin >> w[i];
        else
            cin >> k[i % 10];
    }
    sort(w, w + 10, greater<int>());
    sort(k, k + 10, greater<int>());
        
    for (int i = 0; i < 3; i++) {
        ws += w[i];
        ks += k[i];
    }

    cout << ws << " " << ks << endl;

    return 0;
}

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

int main() {
  vector<int> w,k;
  int t;
  for(int i=0; i<10; ++i) {
    cin>>t;
    w.push_back(t);
  }
  for(int i=0; i<10; ++i) {
    cin>>t;
    k.push_back(t);
  }
  sort(w.begin(), w.end());
  sort(k.begin(), k.end());
  cout<<w[9]+w[8]+w[7]<<" "<<k[9]+k[8]+k[7]<<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[7] + w[8] + w[9] << " " << k[7] + k[8] + k[9] << 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);
	sort(k);
	char ww[100];
	sprintf(ww,"%d %d",w[0] + w[1] + w[2],k[0] + k[1] + k[2]);
	outs(ww);
}

C++: #include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<algorithm>

using namespace std;

int main(void)
{
  int W[10];
  int K[10];
  int Wpon, Kpon;
  int i;

  memset(W,0,sizeof(W));
  memset(K,0,sizeof(K));

  for (i = 0;i <= 20;i++){
    if (i < 10){
      scanf("%d", &W[i]);
    }
    else if (i > 10){
      scanf("%d", &K[i-9]);
    }
  }

  sort(W, W+10);
  sort(K, K+10);

  Wpon = W[9] + W[8] + W[7];
  Kpon = K[9] + K[8] + K[7];

  printf("%d %d\n", Wpon, Kpon);

  return 0;
}