Language: 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);
}

Compiler output:
a.cc: In function 'void func()':
a.cc:462:13: error: no matching function for call to 'sort(int [10])'
  462 |         sort(w);
      |         ~~~~^~~
In file included from /usr/include/c++/14/algorithm:61,
                 from a.cc:9:
/usr/include/c++/14/bits/stl_algo.h:4762:5: note: candidate: 'template<class _RAIter> void std::sort(_RAIter, _RAIter)'
 4762 |     sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
      |     ^~~~
/usr/include/c++/14/bits/stl_algo.h:4762:5: note:   candidate expects 2 arguments, 1 provided
/usr/include/c++/14/bits/stl_algo.h:4793:5: note: candidate: 'template<class _RAIter, class _Compare> void std::sort(_RAIter, _RAIter, _Compare)'
 4793 |     sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
      |     ^~~~
/usr/include/c++/14/bits/stl_algo.h:4793:5: note:   candidate expects 3 arguments, 1 provided
In file included from /usr/include/c++/14/algorithm:86:
/usr/include/c++/14/pstl/glue_algorithm_defs.h:292:1: note: candidate: 'template<class _ExecutionPolicy, class _RandomAccessIterator, class _Compare> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> std::sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare)'
  292 | sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp);
      | ^~~~
/usr/include/c++/14/pstl/glue_algorithm_defs.h:292:1: note:   candidate expects 4 arguments, 1 provided
/usr/include/c++/14/pstl/glue_algorithm_defs.h:296:1: note: candidate: 'template<class _ExecutionPolicy, class _RandomAccessIterator> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> std::sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator)'
  296 | sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last);
      | ^~~~
/usr/include/c++/14/pstl/glue_algorithm_defs.h:296:1: note:   candidate expects 3 arguments, 1 provided
a.cc:463:13: error: no matching function for call to 'sort(int [10])'
  463 |         sort(k);
      |         ~~~~^~~
/usr/include/c++/14/bits/stl_algo.h:4762:5: note: candidate: 'template<class _RAIter> void std::sort(_RAIter, _RAIter)'
 4762 |     sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
      |     ^~~~
/usr/include/c++/14/bits/stl_algo.h:4762:5: note:   candidate expects 2 arguments, 1 provided
/usr/include/c++/14/bits/stl_algo.h:4793:5: note: candidate: 'template<class _RAIter, class _Compare> void std::sort(_RAIter, _RAIter, _Compare)'
 4793 |     sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
      |     ^~~~
/usr/include/c++/14/bits/stl_algo.h:4793:5: note:   candidate expects 3 arguments, 1 provided
/usr/include/c++/14/pstl/glue_algorithm_defs.h:292:1: note: candidate: 'template<class _ExecutionPolicy, class _RandomAccessIterator, class _Compare> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> std::sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare)'
  292 | sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp);
      | ^~~~
/usr/include/c++/14/pstl/glue_algorithm_defs.h:292:1: note:   candidate expects 4 arguments, 1 provided
/usr/include/c++/14/pstl/glue_algorithm_defs.h:296:1: note: candidate: 'template<class _ExecutionPolicy, class _RandomAccessIterator> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> std::sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator)'
  296 | sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last);
      | ^~~~
/usr/include/c++/14/pstl/glue_algorithm_defs.h:296:1: note:   candidate expects 3 arguments, 1 provided