criyle/codenet-compile-errors huggingface dataset:
Language: C++

#include<bits/stdc++.h>
using namespace std;
 
int main()
{
   long long A,B,K;
   cin>>A>>B>>K;
   
   if(A<=K)
   {
        K=K-A;
        A=0;
        B=max(0,B-K);
   }
   
   else
   {
       A=A-K;
   }
   cout<<A<<" "<<B<<endl;
    return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:13:14: error: no matching function for call to 'max(int, long long int)'
   13 |         B=max(0,B-K);
      |           ~~~^~~~~~~
In file included from /usr/include/c++/14/algorithm:60,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algobase.h:257:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::max(const _Tp&, const _Tp&)'
  257 |     max(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:257:5: note:   template argument deduction/substitution failed:
a.cc:13:14: note:   deduced conflicting types for parameter 'const _Tp' ('int' and 'long long int')
   13 |         B=max(0,B-K);
      |           ~~~^~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare)'
  303 |     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note:   candidate expects 3 arguments, 2 provided
In file included from /usr/include/c++/14/algorithm:61:
/usr/include/c++/14/bits/stl_algo.h:5706:5: note: candidate: 'template<class _Tp> constexpr _Tp std::max(initializer_list<_Tp>)'
 5706 |     max(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5706:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5716:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::max(initializer_list<_Tp>, _Compare)'
 5716 |     max(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5716:5: note:   template argument deduction/substitution failed:
a.cc:13:14: note:   mismatched types 'std::initializer_list<_Tp>' and 'int'
   13 |         B=max(0,B-K);
      |           ~~~^~~~~~~
Language: C++

    #include <bits/stdc++.h>
    using namespace std;
     
    int main()
    {
    	int a,b,k;
        cin >> a >> b >> k;
        cout << 0<<b-(a-k) endl;
        return 0;
    }

Compiler output:
a.cc: In function 'int main()':
a.cc:8:27: error: expected ';' before 'endl'
    8 |         cout << 0<<b-(a-k) endl;
      |                           ^~~~~
      |                           ;
Language: C++

#include <iostream>

int main(){
	using namespace std;
	long a,b,k,i;
	cin >> a >> b >> k;
	for (i = 0; i < k) {
		a--;
		if (a <= 0) {
			a = 0;
			b--;
		}
	}

	cout << endl;
	return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:7:26: error: expected ';' before ')' token
    7 |         for (i = 0; i < k) {
      |                          ^
      |                          ;
Language: C++

#include<bits/stdc++.h>
using namespace std;
int main()
{
  long long int a,b,k;
  cin>>a>>b>>k;
  if(k>a)
    cout<<"0 "<<min(b-k+a,0)<<endl;
  else
    cout<<a-k<<" "<<b<<endl;
  return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:8:20: error: no matching function for call to 'min(long long int, int)'
    8 |     cout<<"0 "<<min(b-k+a,0)<<endl;
      |                 ~~~^~~~~~~~~
In file included from /usr/include/c++/14/algorithm:60,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algobase.h:233:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::min(const _Tp&, const _Tp&)'
  233 |     min(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:233:5: note:   template argument deduction/substitution failed:
a.cc:8:20: note:   deduced conflicting types for parameter 'const _Tp' ('long long int' and 'int')
    8 |     cout<<"0 "<<min(b-k+a,0)<<endl;
      |                 ~~~^~~~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::min(const _Tp&, const _Tp&, _Compare)'
  281 |     min(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note:   candidate expects 3 arguments, 2 provided
In file included from /usr/include/c++/14/algorithm:61:
/usr/include/c++/14/bits/stl_algo.h:5686:5: note: candidate: 'template<class _Tp> constexpr _Tp std::min(initializer_list<_Tp>)'
 5686 |     min(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5686:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5696:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::min(initializer_list<_Tp>, _Compare)'
 5696 |     min(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5696:5: note:   template argument deduction/substitution failed:
a.cc:8:20: note:   mismatched types 'std::initializer_list<_Tp>' and 'long long int'
    8 |     cout<<"0 "<<min(b-k+a,0)<<endl;
      |                 ~~~^~~~~~~~~
Language: C++

#include<bits/stdc++.h>
using namespace std;
int main()
{
  long long int a,b,k;
  cin>>a>>b>>k;
  if(k>a)
    cout<<"0 "<<min(b-k+a,0)<<endl;
  else
    cout<<a-k<<" "<<b<<endl;
  return 0;

Compiler output:
a.cc: In function 'int main()':
a.cc:8:20: error: no matching function for call to 'min(long long int, int)'
    8 |     cout<<"0 "<<min(b-k+a,0)<<endl;
      |                 ~~~^~~~~~~~~
In file included from /usr/include/c++/14/algorithm:60,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algobase.h:233:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::min(const _Tp&, const _Tp&)'
  233 |     min(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:233:5: note:   template argument deduction/substitution failed:
a.cc:8:20: note:   deduced conflicting types for parameter 'const _Tp' ('long long int' and 'int')
    8 |     cout<<"0 "<<min(b-k+a,0)<<endl;
      |                 ~~~^~~~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::min(const _Tp&, const _Tp&, _Compare)'
  281 |     min(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note:   candidate expects 3 arguments, 2 provided
In file included from /usr/include/c++/14/algorithm:61:
/usr/include/c++/14/bits/stl_algo.h:5686:5: note: candidate: 'template<class _Tp> constexpr _Tp std::min(initializer_list<_Tp>)'
 5686 |     min(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5686:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5696:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::min(initializer_list<_Tp>, _Compare)'
 5696 |     min(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5696:5: note:   template argument deduction/substitution failed:
a.cc:8:20: note:   mismatched types 'std::initializer_list<_Tp>' and 'long long int'
    8 |     cout<<"0 "<<min(b-k+a,0)<<endl;
      |                 ~~~^~~~~~~~~
a.cc:11:12: error: expected '}' at end of input
   11 |   return 0;
      |            ^
a.cc:4:1: note: to match this '{'
    4 | {
      | ^
Language: C++

#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define pb(x) push_back(x)
#define rep(a,b) for(ll int a=0;a<b;a++)
#define Tcase int t;cin>>t;while(t--)   
int main(){
  long long int a,b,k;
  cin>>a>>b>>k;
  if(k<=a){
  a=a-k;k=0;
  }
  else{
  a=0;k=k-a;
  }

Compiler output:
a.cc: In function 'int main()':
a.cc:15:4: error: expected '}' at end of input
   15 |   }
      |    ^
a.cc:7:11: note: to match this '{'
    7 | int main(){
      |           ^
Language: C++

#include<iostream>
#include<algorithm>
 
using namespace std;
long long int A,B,K;
 
int main(){
	cin >> A >>B >> K;
  	cout << ((A>K)?(A-K):0) << " " << ((((A>K)?B:B+(A-K))>0)?((((A>K)?B:B+(A-K)):0) << endl;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:9:85: error: expected ')' before ':' token
    9 |         cout << ((A>K)?(A-K):0) << " " << ((((A>K)?B:B+(A-K))>0)?((((A>K)?B:B+(A-K)):0) << endl;
      |                                                                   ~                 ^
      |                                                                                     )
a.cc:9:96: error: expected ')' before ';' token
    9 |         cout << ((A>K)?(A-K):0) << " " << ((((A>K)?B:B+(A-K))>0)?((((A>K)?B:B+(A-K)):0) << endl;
      |                                                                  ~                             ^
      |                                                                                                )
a.cc:9:96: error: expected ':' before ';' token
    9 |         cout << ((A>K)?(A-K):0) << " " << ((((A>K)?B:B+(A-K))>0)?((((A>K)?B:B+(A-K)):0) << endl;
      |                                                                                                ^
      |                                                                                                :
a.cc:9:96: error: expected primary-expression before ';' token
a.cc:9:96: error: expected ')' before ';' token
    9 |         cout << ((A>K)?(A-K):0) << " " << ((((A>K)?B:B+(A-K))>0)?((((A>K)?B:B+(A-K)):0) << endl;
      |                                           ~                                                    ^
      |                                                                                                )
Language: C++

#include <bits/stdc++.h>
#define rep(i, n) for (int i=0;i<(n);i++)
typedef long long ll;
using namespace std;

int main() {
  ll a,b,k;
  cin >> a >> b >> k;
  
  if (a >= k) {
    cout << (a-k) << ' ' << b << endl;
  } else {
	cout << 0 << ' ' << max(b-k+a, 0) << endl;
  }
  
  return 0;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:13:32: error: no matching function for call to 'max(ll, int)'
   13 |         cout << 0 << ' ' << max(b-k+a, 0) << endl;
      |                             ~~~^~~~~~~~~~
In file included from /usr/include/c++/14/algorithm:60,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algobase.h:257:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::max(const _Tp&, const _Tp&)'
  257 |     max(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:257:5: note:   template argument deduction/substitution failed:
a.cc:13:32: note:   deduced conflicting types for parameter 'const _Tp' ('long long int' and 'int')
   13 |         cout << 0 << ' ' << max(b-k+a, 0) << endl;
      |                             ~~~^~~~~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare)'
  303 |     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note:   candidate expects 3 arguments, 2 provided
In file included from /usr/include/c++/14/algorithm:61:
/usr/include/c++/14/bits/stl_algo.h:5706:5: note: candidate: 'template<class _Tp> constexpr _Tp std::max(initializer_list<_Tp>)'
 5706 |     max(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5706:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5716:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::max(initializer_list<_Tp>, _Compare)'
 5716 |     max(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5716:5: note:   template argument deduction/substitution failed:
a.cc:13:32: note:   mismatched types 'std::initializer_list<_Tp>' and 'long long int'
   13 |         cout << 0 << ' ' << max(b-k+a, 0) << endl;
      |                             ~~~^~~~~~~~~~
Language: C++

#include<iostream>
#include<algorithm>
 
using namespace std;
long long int A,B,K;
 
int main(){
	cin >> A >>B >> K;
  	cout << max(A-K,long long int(0)) << " " << ((A-K)>0)?B:B+(A-K) << endl;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:9:25: error: expected primary-expression before 'long'
    9 |         cout << max(A-K,long long int(0)) << " " << ((A-K)>0)?B:B+(A-K) << endl;
      |                         ^~~~
a.cc:9:73: error: invalid operands of types 'long long int' and '<unresolved overloaded function type>' to binary 'operator<<'
    9 |         cout << max(A-K,long long int(0)) << " " << ((A-K)>0)?B:B+(A-K) << endl;
      |                                                                 ~~~~~~~~^~~~~~~
Language: C++

#include<iostream>
#include<algorithm>

using namespace std;
long long int A,B,K;

int main(){
	cin >> A >>B >> K;
  	cout << max(A-K,0) << " " << ((A-K)>0)?B:B+(A-K) << endl;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:9:20: error: no matching function for call to 'max(long long int, int)'
    9 |         cout << max(A-K,0) << " " << ((A-K)>0)?B:B+(A-K) << endl;
      |                 ~~~^~~~~~~
In file included from /usr/include/c++/14/string:51,
                 from /usr/include/c++/14/bits/locale_classes.h:40,
                 from /usr/include/c++/14/bits/ios_base.h:41,
                 from /usr/include/c++/14/ios:44,
                 from /usr/include/c++/14/ostream:40,
                 from /usr/include/c++/14/iostream:41,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algobase.h:257:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::max(const _Tp&, const _Tp&)'
  257 |     max(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:257:5: note:   template argument deduction/substitution failed:
a.cc:9:20: note:   deduced conflicting types for parameter 'const _Tp' ('long long int' and 'int')
    9 |         cout << max(A-K,0) << " " << ((A-K)>0)?B:B+(A-K) << endl;
      |                 ~~~^~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare)'
  303 |     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note:   candidate expects 3 arguments, 2 provided
In file included from /usr/include/c++/14/algorithm:61,
                 from a.cc:2:
/usr/include/c++/14/bits/stl_algo.h:5706:5: note: candidate: 'template<class _Tp> constexpr _Tp std::max(initializer_list<_Tp>)'
 5706 |     max(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5706:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5716:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::max(initializer_list<_Tp>, _Compare)'
 5716 |     max(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5716:5: note:   template argument deduction/substitution failed:
a.cc:9:20: note:   mismatched types 'std::initializer_list<_Tp>' and 'long long int'
    9 |         cout << max(A-K,0) << " " << ((A-K)>0)?B:B+(A-K) << endl;
      |                 ~~~^~~~~~~
a.cc:9:58: error: invalid operands of types 'long long int' and '<unresolved overloaded function type>' to binary 'operator<<'
    9 |         cout << max(A-K,0) << " " << ((A-K)>0)?B:B+(A-K) << endl;
      |                                                  ~~~~~~~~^~~~~~~
Language: C++

#include<iostream>
using namespace std;

int main(){
    long long int a, b, k;
    cin >> a >> b >> k;
    if(a - k > 0){
        cout << a - k << " " << b << endl;
    }
    else{
        cout << 0 << " " << max(0, b - (k - a)) << endl;
    }
    return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:11:32: error: no matching function for call to 'max(int, long long int)'
   11 |         cout << 0 << " " << max(0, b - (k - a)) << endl;
      |                             ~~~^~~~~~~~~~~~~~~~
In file included from /usr/include/c++/14/string:51,
                 from /usr/include/c++/14/bits/locale_classes.h:40,
                 from /usr/include/c++/14/bits/ios_base.h:41,
                 from /usr/include/c++/14/ios:44,
                 from /usr/include/c++/14/ostream:40,
                 from /usr/include/c++/14/iostream:41,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algobase.h:257:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::max(const _Tp&, const _Tp&)'
  257 |     max(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:257:5: note:   template argument deduction/substitution failed:
a.cc:11:32: note:   deduced conflicting types for parameter 'const _Tp' ('int' and 'long long int')
   11 |         cout << 0 << " " << max(0, b - (k - a)) << endl;
      |                             ~~~^~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare)'
  303 |     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note:   candidate expects 3 arguments, 2 provided
Language: C++

#include <bits/stdc++.h>
using namespace std;
int main(){
  long long a, b, k;
  cin >> a >> b >> k;
  if(a>k){
    cout << a-k << " " << 0;
  }
  else{
    cout << "0 ";
    if(b>(k-a)){
      cout << max((b-(k-a)),0);
    }
  }
}

Compiler output:
a.cc: In function 'int main()':
a.cc:12:18: error: no matching function for call to 'max(long long int, int)'
   12 |       cout << max((b-(k-a)),0);
      |               ~~~^~~~~~~~~~~~~
In file included from /usr/include/c++/14/algorithm:60,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algobase.h:257:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::max(const _Tp&, const _Tp&)'
  257 |     max(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:257:5: note:   template argument deduction/substitution failed:
a.cc:12:18: note:   deduced conflicting types for parameter 'const _Tp' ('long long int' and 'int')
   12 |       cout << max((b-(k-a)),0);
      |               ~~~^~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare)'
  303 |     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note:   candidate expects 3 arguments, 2 provided
In file included from /usr/include/c++/14/algorithm:61:
/usr/include/c++/14/bits/stl_algo.h:5706:5: note: candidate: 'template<class _Tp> constexpr _Tp std::max(initializer_list<_Tp>)'
 5706 |     max(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5706:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5716:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::max(initializer_list<_Tp>, _Compare)'
 5716 |     max(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5716:5: note:   template argument deduction/substitution failed:
a.cc:12:18: note:   mismatched types 'std::initializer_list<_Tp>' and 'long long int'
   12 |       cout << max((b-(k-a)),0);
      |               ~~~^~~~~~~~~~~~~
Language: C++

include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> lpair;
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
#define REP(i,m,n) for(int i=(int)(m) ; i < (int) (n) ; ++i )
#define rep(i,n) REP(i,0,n)
#define rREP(i,m,n) for(ll i = (m); i >= (n); i--)
#define ALL(c) (c).begin(), (c).end()
#define print(x) cout << (x) << endl;
#define printa(x,n) for(ll i = 0; i < n; i++){ cout << (x[i]) << " ";} cout<<endl;
int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);
 
    int n,k;cin >> n >> k;
    int ary[3];
    rep(i,3) cin >> ary[i];
    string s;
    cin >> s;
    rep(i,n)
    {
        if (s[i]=='r')
        {
            s[i]='2';
        }
        else if (s[i]=='s')
        {
            s[i] = '0';
        }
        else if (s[i]=='p')
        {
            s[i]='1';
        }
    }
 
    int points[n];
    fill(points, points+n, -1);
    rep(i,n)
    {
        if (i-k<0)
        {
            points[i] = ary[s[i]-'0'];
        }
        else
        {
            if (points[i-k]==-1 || s[i-k]!=s[i])
            {
                points[i] = ary[s[i]-'0'];
            }
        }
    }
    ll ans = 0;
    rep(i,n)
    {
        if (points[i]==-1) continue;
        ans += points[i];
        // cout << points[i] << " ";
    }
    cout << ans << endl;
    
    
}
 

Compiler output:
a.cc:1:1: error: 'include' does not name a type
    1 | include <bits/stdc++.h>
      | ^~~~~~~
a.cc:4:9: error: 'pair' does not name a type
    4 | typedef pair<ll, ll> lpair;
      |         ^~~~
a.cc: In function 'int main()':
a.cc:14:5: error: 'cin' was not declared in this scope
   14 |     cin.tie(0);
      |     ^~~
a.cc:15:5: error: 'ios' has not been declared
   15 |     ios::sync_with_stdio(false);
      |     ^~~
a.cc:20:5: error: 'string' was not declared in this scope
   20 |     string s;
      |     ^~~~~~
a.cc:21:12: error: 's' was not declared in this scope
   21 |     cin >> s;
      |            ^
a.cc:39:5: error: 'fill' was not declared in this scope; did you mean 'll'?
   39 |     fill(points, points+n, -1);
      |     ^~~~
      |     ll
a.cc:61:5: error: 'cout' was not declared in this scope
   61 |     cout << ans << endl;
      |     ^~~~
a.cc:61:20: error: 'endl' was not declared in this scope
   61 |     cout << ans << endl;
      |                    ^~~~
Language: Java

import java.util.Scanner;

/**
 *
 * @author قتادة
 */
public class NewClass {

    public static void num(int a, int b, int k) {
        int count = 0;
        while (count != k) {
            if (a >= 1) {
                a--;
                count++;
            } else if (b >= 1) {
                b--;
                count++;
            }
            else {
                break;
            }
        }
        System.out.println("a =" + a + "b =" + b);
    }

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int a = s.nextInt();
        int b = s.nextInt();
        int k = s.nextInt();
        num(a, b, k);
    }
}


Compiler output:
Main.java:7: error: class NewClass is public, should be declared in a file named NewClass.java
public class NewClass {
       ^
1 error
Language: Java

public static void num(int a,int b,int k){
        int count=0;
        while(count!=k){
            if(a>=1){
                a--;
                count++;
            }
            else if(b>=1){
                b--;
                count++;
            }
          else{
          break;
        }
        }
        System.out.println("a ="+a+"b ="+b);
    }
    public static void main(String[] args) {
      Scanner s=new Scanner(System.in);
        int a=s.nextInt();
        int b=s.nextInt();
        int k=s.nextInt();
        num(a,b,k);
    }

Compiler output:
Main.java:1: error: unnamed classes are a preview feature and are disabled by default.
public static void num(int a,int b,int k){
              ^
  (use --enable-preview to enable unnamed classes)
1 error
Language: Java

import java.util.scanner;
public class Main {
    public static void num(int a,int b,int k){
        int count=0;
        while(count!=k){
            if(a>=1){
                a--;
                count++;
            }
            else if(b>=1){
                b--;
                count++;
            }
        }
        System.out.println("a ="+a+"b ="+b);
    }
    public static void main(String[] args) {
      Scanner s=new Scanner(System.in);
        int a=s.nextInt();
        int b=s.nextInt();
        int k=s.nextInt();
        num(a,b,k);
    }
}

Compiler output:
Main.java:1: error: cannot find symbol
import java.util.scanner;
                ^
  symbol:   class scanner
  location: package java.util
Main.java:18: error: cannot find symbol
      Scanner s=new Scanner(System.in);
      ^
  symbol:   class Scanner
  location: class Main
Main.java:18: error: cannot find symbol
      Scanner s=new Scanner(System.in);
                    ^
  symbol:   class Scanner
  location: class Main
3 errors
Language: Java

public class NewClass {
    public static void num(int a,int b,int k){
        int count=0;
        while(count!=k){
            if(a>=1){
                a--;
                count++;
            }
            else if(b>=1){
                b--;
                count++;
            }
        }
        System.out.println("a ="+a+"b ="+b);
    }
    public static void main(String[] args) {
        int a=3;
        int b=4;
        int k=3;
        num(a,b,k);
    }
}

Compiler output:
Main.java:1: error: class NewClass is public, should be declared in a file named NewClass.java
public class NewClass {
       ^
1 error
Language: C++

A, B, K = map(int, input().split())

ans = [None] * 2

ans[0] = str(max(A - K, 0))
ans[1] = str(max(B - max(K - A, 0), 0))

print(" ".join(ans))


Compiler output:
a.cc:1:1: error: 'A' does not name a type
    1 | A, B, K = map(int, input().split())
      | ^
Language: Java

import java.util.Scanner;
class Main{
 static public void main(String[] args){
   Scanner scan = new Scanner(System.in);
   int A = scan.nextInt();
   int B = scan.nextInt();
   int K = scan.nextInt();
   for (int i= 0;i<k;i++){
     if(A==0 && B==0) break;
     else if(A>=1) A--;
     else B--;
  }
   System.out.println(A + " " + B);
 }
}

Compiler output:
Main.java:8: error: cannot find symbol
   for (int i= 0;i<k;i++){
                   ^
  symbol:   variable k
  location: class Main
1 error
Language: Java

class Main{
 static public void main(String[] args){
   int A,B,K;
   for (int i= 0;i<k;i++){
     if(A==0 && B==0) break;
     else if(A>=1) A--;
     else B--;
  }
   System.out.println(A + " " + B);
 }
}

Compiler output:
Main.java:4: error: cannot find symbol
   for (int i= 0;i<k;i++){
                   ^
  symbol:   variable k
  location: class Main
1 error
Language: C++

#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
  long a,b,k;
  cin>>a>>b>>k;
  if(a>=k){
    cout<<a-k<<" "<<b<<endl;
  }
  else if(k>a+b){
    cout<<0<<" "<<0<<emdl;
  }
  else{
    cout<<0<<" "<<a+b-k<<endl;
  }
}


Compiler output:
a.cc: In function 'int main()':
a.cc:11:22: error: 'emdl' was not declared in this scope
   11 |     cout<<0<<" "<<0<<emdl;
      |                      ^~~~
Language: C++

#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
  long a,b,k;
  cin>>a>>b>>k;
  if(a>=k) cout<<a-k<<" "<<b<<endl;
  else if(k>=a+b) cout<<0<<" "<<0<<emdl;
  else cout<<0<<" "<<a+b-k<<endl;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:8:36: error: 'emdl' was not declared in this scope
    8 |   else if(k>=a+b) cout<<0<<" "<<0<<emdl;
      |                                    ^~~~
Language: C++

#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
  int a,b,k;
  cin>>a>>b>>k;
  if(a>=k) cout<<a-k<<" "<<b<<endl;
  else if(k>a+b) cout<<0<<" "<<0<<emdl;
  else cout<<0<<" "<<a+b-k<<endl;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:8:35: error: 'emdl' was not declared in this scope
    8 |   else if(k>a+b) cout<<0<<" "<<0<<emdl;
      |                                   ^~~~
Language: C++

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(),(x).end()

int main() {
  LL a, b, k;
  cin >> a >> b >> k;

  if (a >= k) {
    cout << a - k << " " << b << endl;
  } else {
    cout << 0 << " " << max(0, b - k + a) << endl;
  }
}

Compiler output:
a.cc: In function 'int main()':
a.cc:14:28: error: no matching function for call to 'max(int, LL)'
   14 |     cout << 0 << " " << max(0, b - k + a) << endl;
      |                         ~~~^~~~~~~~~~~~~~
In file included from /usr/include/c++/14/algorithm:60,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algobase.h:257:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::max(const _Tp&, const _Tp&)'
  257 |     max(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:257:5: note:   template argument deduction/substitution failed:
a.cc:14:28: note:   deduced conflicting types for parameter 'const _Tp' ('int' and 'LL' {aka 'long long int'})
   14 |     cout << 0 << " " << max(0, b - k + a) << endl;
      |                         ~~~^~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare)'
  303 |     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note:   candidate expects 3 arguments, 2 provided
In file included from /usr/include/c++/14/algorithm:61:
/usr/include/c++/14/bits/stl_algo.h:5706:5: note: candidate: 'template<class _Tp> constexpr _Tp std::max(initializer_list<_Tp>)'
 5706 |     max(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5706:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5716:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::max(initializer_list<_Tp>, _Compare)'
 5716 |     max(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5716:5: note:   template argument deduction/substitution failed:
a.cc:14:28: note:   mismatched types 'std::initializer_list<_Tp>' and 'int'
   14 |     cout << 0 << " " << max(0, b - k + a) << endl;
      |                         ~~~^~~~~~~~~~~~~~
Language: C++

#include <iostream>
using namespace std;

int main() {
  int a, b, c;
  cin >> a >> b >> k;
  if (a+b <= k){
    cout << 0 << "" << 0 << endl;
    return 0;
  }
  if (a > k){
    cout << a-k << "" << b << endl;
    return 0;
  }
  if (a <= k){
    cout << 0 << "" << b-k+a << endl;
    return 0;
  }
  cout << a + b + c << " " << s << endl;
  return 0
}

Compiler output:
a.cc: In function 'int main()':
a.cc:6:20: error: 'k' was not declared in this scope
    6 |   cin >> a >> b >> k;
      |                    ^
a.cc:19:31: error: 's' was not declared in this scope
   19 |   cout << a + b + c << " " << s << endl;
      |                               ^
a.cc:20:11: error: expected ';' before '}' token
   20 |   return 0
      |           ^
      |           ;
   21 | }
      | ~
Language: C++

#include<bits/stdc++.h>
using namespac std;
using ll = long long;
main()
{
  	ll a,b,k;
  	cin >> a >> b >> k;
  	while(k--)
    {
      	if(a == 0)
          break;
      	a--;
    }
  	while(k--)
    {
      	if(b == 0)
          break;
      	b--;
    }
  cout << a << " " << b;
}

Compiler output:
a.cc:2:7: error: expected nested-name-specifier before 'namespac'
    2 | using namespac std;
      |       ^~~~~~~~
a.cc:4:1: warning: ISO C++ forbids declaration of 'main' with no type [-Wreturn-type]
    4 | main()
      | ^~~~
a.cc: In function 'int main()':
a.cc:7:9: error: 'cin' was not declared in this scope; did you mean 'std::cin'?
    7 |         cin >> a >> b >> k;
      |         ^~~
      |         std::cin
In file included from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:146,
                 from a.cc:1:
/usr/include/c++/14/iostream:62:18: note: 'std::cin' declared here
   62 |   extern istream cin;           ///< Linked to standard input
      |                  ^~~
a.cc:20:3: error: 'cout' was not declared in this scope; did you mean 'std::cout'?
   20 |   cout << a << " " << b;
      |   ^~~~
      |   std::cout
/usr/include/c++/14/iostream:63:18: note: 'std::cout' declared here
   63 |   extern ostream cout;          ///< Linked to standard output
      |                  ^~~~
Language: C++

a,b,k = map(int,input().split())
     
for i in range(k):
  if a > 0:
    a -= 1
  elif b > 0:
    b -= 1
     
print(str(a) + " " + str(b))

Compiler output:
a.cc:1:1: error: 'a' does not name a type
    1 | a,b,k = map(int,input().split())
      | ^
Language: C++

#include<bits/stdc++.h>
using namespace std;
int main()
{
  int a,b,c;
  cin>>a>>b>>c;
  int rem =a-c;
  if(rem>0)
  {cout<<rem<<" "<<b<<endl;}
  else
  {
    int rem2=b+rem;
    if(rem2<0)rem2=0;
    cout<<0<< " "<<rem2<<endl;
    
  }

Compiler output:
a.cc: In function 'int main()':
a.cc:16:4: error: expected '}' at end of input
   16 |   }
      |    ^
a.cc:4:1: note: to match this '{'
    4 | {
      | ^
Language: C++

#include<bits/stdc++.h>
using namespace std;
int main(){
  int a,b,k;
  cin>>a>>b>>c;
  if (k<=a){
cout<<a-k<<b;
  }
  else if(a<=k<=a+b){
 cout<<0<<a+b-k;
  }
 else{
   cout<<0<<0;
 }
  return 0;
}
  

Compiler output:
a.cc: In function 'int main()':
a.cc:5:14: error: 'c' was not declared in this scope
    5 |   cin>>a>>b>>c;
      |              ^
Language: C++

#include<bits/stdc++.h>
using namespace std;
int main () {
  long long A, B, K;
  cin >> A >> B >> K;
  if (A < K) {
    cout << 0 << ' ' << max(0, B + A - K) << endl;
  }else cout << A - K << ' ' << B << endl;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:7:28: error: no matching function for call to 'max(int, long long int)'
    7 |     cout << 0 << ' ' << max(0, B + A - K) << endl;
      |                         ~~~^~~~~~~~~~~~~~
In file included from /usr/include/c++/14/algorithm:60,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algobase.h:257:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::max(const _Tp&, const _Tp&)'
  257 |     max(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:257:5: note:   template argument deduction/substitution failed:
a.cc:7:28: note:   deduced conflicting types for parameter 'const _Tp' ('int' and 'long long int')
    7 |     cout << 0 << ' ' << max(0, B + A - K) << endl;
      |                         ~~~^~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare)'
  303 |     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note:   candidate expects 3 arguments, 2 provided
In file included from /usr/include/c++/14/algorithm:61:
/usr/include/c++/14/bits/stl_algo.h:5706:5: note: candidate: 'template<class _Tp> constexpr _Tp std::max(initializer_list<_Tp>)'
 5706 |     max(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5706:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5716:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::max(initializer_list<_Tp>, _Compare)'
 5716 |     max(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5716:5: note:   template argument deduction/substitution failed:
a.cc:7:28: note:   mismatched types 'std::initializer_list<_Tp>' and 'int'
    7 |     cout << 0 << ' ' << max(0, B + A - K) << endl;
      |                         ~~~^~~~~~~~~~~~~~
Language: Java

import java.util.Scanner;

class Main {
 public static void main(String[] args){
   //変数の初期化
   Scanner scanner = new Scanner(System.in);
   
   //入力
   System.out.print("input: ");
   int inputA = scanner.nextInt();
   int inputB = scanner.nextInt();
   int K = scanner.netInt();
   
   for(int i = 1; i <= K; i++) {
     if(inputA >= 1) {
       inputA--;
     } else if(inputA < 1 && inputB >= 1) {
       inputB--;
     } else {

     }
   }
   
   //出力
   System.out.println("output: " + inputA);
   System.out.println("output: " + inputB);
   
 }
}

Compiler output:
Main.java:12: error: cannot find symbol
   int K = scanner.netInt();
                  ^
  symbol:   method netInt()
  location: variable scanner of type Scanner
1 error
Language: C++

#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int (i)=0; (i)<(n); (i)++)
#define rrep(i,n) for(int i = 1; i <= (n); ++i)
#define ll long long
#define pii pair<int,int> 
#define Yes cout << "Yes" << endl
#define No cout << "No" << endl
int inf=1000001000;
ll INF=100000000000000000;
ll MOD=1000000007;
//int 2×10の9乗
//vector<vector<int>> a(n, vector<int>(m));
//rep(i,n) rep(j,m) cin >> a[i][j]; 
//cout << fixed << setprecision(10) << ans << endl;
//sort小さい順(昇順)
//g++ code.cpp   ./a.out 
 
int main() {
    ll a,b,k;
    cin >> a >> b >> k;
    if(a>k){
        cout << a-k << " " << b << endl;
    }   
    else {
        cout << 0 << " " << max(0,a+b-k) << endl;
    }
}


Compiler output:
a.cc: In function 'int main()':
a.cc:26:32: error: no matching function for call to 'max(int, long long int)'
   26 |         cout << 0 << " " << max(0,a+b-k) << endl;
      |                             ~~~^~~~~~~~~
In file included from /usr/include/c++/14/algorithm:60,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algobase.h:257:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::max(const _Tp&, const _Tp&)'
  257 |     max(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:257:5: note:   template argument deduction/substitution failed:
a.cc:26:32: note:   deduced conflicting types for parameter 'const _Tp' ('int' and 'long long int')
   26 |         cout << 0 << " " << max(0,a+b-k) << endl;
      |                             ~~~^~~~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare)'
  303 |     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note:   candidate expects 3 arguments, 2 provided
In file included from /usr/include/c++/14/algorithm:61:
/usr/include/c++/14/bits/stl_algo.h:5706:5: note: candidate: 'template<class _Tp> constexpr _Tp std::max(initializer_list<_Tp>)'
 5706 |     max(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5706:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5716:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::max(initializer_list<_Tp>, _Compare)'
 5716 |     max(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5716:5: note:   template argument deduction/substitution failed:
a.cc:26:32: note:   mismatched types 'std::initializer_list<_Tp>' and 'int'
   26 |         cout << 0 << " " << max(0,a+b-k) << endl;
      |                             ~~~^~~~~~~~~
Language: C++

#incluse <bits/stdc++.h>
using namespace std;

int main () {
  int A,B,C;
  cin>>A>>B>>C;
  for(int i=0;i<C;i++){
    if(A>0){
      A--;
    }
    else if(B>0){
      B--;
    }
  }
  cout<<A<<B<<endl;
}

Compiler output:
a.cc:1:2: error: invalid preprocessing directive #incluse; did you mean #include?
    1 | #incluse <bits/stdc++.h>
      |  ^~~~~~~
      |  include
a.cc: In function 'int main()':
a.cc:6:3: error: 'cin' was not declared in this scope
    6 |   cin>>A>>B>>C;
      |   ^~~
a.cc:1:1: note: 'std::cin' is defined in header '<iostream>'; this is probably fixable by adding '#include <iostream>'
  +++ |+#include <iostream>
    1 | #incluse <bits/stdc++.h>
a.cc:15:3: error: 'cout' was not declared in this scope
   15 |   cout<<A<<B<<endl;
      |   ^~~~
a.cc:15:3: note: 'std::cout' is defined in header '<iostream>'; this is probably fixable by adding '#include <iostream>'
a.cc:15:15: error: 'endl' was not declared in this scope
   15 |   cout<<A<<B<<endl;
      |               ^~~~
a.cc:1:1: note: 'std::endl' is defined in header '<ostream>'; this is probably fixable by adding '#include <ostream>'
  +++ |+#include <ostream>
    1 | #incluse <bits/stdc++.h>
Language: C++

#include <bits/stdc++.h>
using namespace std;

long long a, b, k;

int main(){
    ios::sync_with_stdio(0);
    cin.tie(0);
    cin >> a >> b >> k;
    if(k >= a) k -= a, a = 0;
    else a -= k, k = 0;
    b = max(0, b - k);
    cout << a << " " << b << "\n";
    return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:12:12: error: no matching function for call to 'max(int, long long int)'
   12 |     b = max(0, b - k);
      |         ~~~^~~~~~~~~~
In file included from /usr/include/c++/14/algorithm:60,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algobase.h:257:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::max(const _Tp&, const _Tp&)'
  257 |     max(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:257:5: note:   template argument deduction/substitution failed:
a.cc:12:12: note:   deduced conflicting types for parameter 'const _Tp' ('int' and 'long long int')
   12 |     b = max(0, b - k);
      |         ~~~^~~~~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare)'
  303 |     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note:   candidate expects 3 arguments, 2 provided
In file included from /usr/include/c++/14/algorithm:61:
/usr/include/c++/14/bits/stl_algo.h:5706:5: note: candidate: 'template<class _Tp> constexpr _Tp std::max(initializer_list<_Tp>)'
 5706 |     max(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5706:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5716:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::max(initializer_list<_Tp>, _Compare)'
 5716 |     max(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5716:5: note:   template argument deduction/substitution failed:
a.cc:12:12: note:   mismatched types 'std::initializer_list<_Tp>' and 'int'
   12 |     b = max(0, b - k);
      |         ~~~^~~~~~~~~~
Language: C++

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <queue>
#include <ctime>
#include <cassert>
#include <complex>
#include <string>
#include <cstring>
#include <chrono>
#include <random>
#include <queue>
#include <bitset>
using namespace std;

int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  long long a, b, k;
  cin >> a >> b >> k;
  a -= k;
  if(a < 0) {
    b += a;
    a = 0;
    b = max(b, 0);
  }
  cout << a << ' ' << b << '\n';
}

Compiler output:
a.cc: In function 'int main()':
a.cc:32:12: error: no matching function for call to 'max(long long int&, int)'
   32 |     b = max(b, 0);
      |         ~~~^~~~~~
In file included from /usr/include/c++/14/string:51,
                 from /usr/include/c++/14/bits/locale_classes.h:40,
                 from /usr/include/c++/14/bits/ios_base.h:41,
                 from /usr/include/c++/14/ios:44,
                 from /usr/include/c++/14/ostream:40,
                 from /usr/include/c++/14/iostream:41,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algobase.h:257:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::max(const _Tp&, const _Tp&)'
  257 |     max(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:257:5: note:   template argument deduction/substitution failed:
a.cc:32:12: note:   deduced conflicting types for parameter 'const _Tp' ('long long int' and 'int')
   32 |     b = max(b, 0);
      |         ~~~^~~~~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare)'
  303 |     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note:   candidate expects 3 arguments, 2 provided
In file included from /usr/include/c++/14/algorithm:61,
                 from a.cc:4:
/usr/include/c++/14/bits/stl_algo.h:5706:5: note: candidate: 'template<class _Tp> constexpr _Tp std::max(initializer_list<_Tp>)'
 5706 |     max(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5706:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5716:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::max(initializer_list<_Tp>, _Compare)'
 5716 |     max(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5716:5: note:   template argument deduction/substitution failed:
a.cc:32:12: note:   mismatched types 'std::initializer_list<_Tp>' and 'long long int'
   32 |     b = max(b, 0);
      |         ~~~^~~~~~
Language: C++

#include <iostream>
using namespace std;
int main(){
	long long a,b,k;
	cin >> a >> b >> k;
	a=max(a-k,0);
	if(a!=0){
		cout<<a<<" "<<b<<endl;
		return 0;
	}
	long long j=k-a;
	b=max(b-j,0);
	cout<<a<<" "<<b<<endl;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:6:14: error: no matching function for call to 'max(long long int, int)'
    6 |         a=max(a-k,0);
      |           ~~~^~~~~~~
In file included from /usr/include/c++/14/string:51,
                 from /usr/include/c++/14/bits/locale_classes.h:40,
                 from /usr/include/c++/14/bits/ios_base.h:41,
                 from /usr/include/c++/14/ios:44,
                 from /usr/include/c++/14/ostream:40,
                 from /usr/include/c++/14/iostream:41,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algobase.h:257:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::max(const _Tp&, const _Tp&)'
  257 |     max(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:257:5: note:   template argument deduction/substitution failed:
a.cc:6:14: note:   deduced conflicting types for parameter 'const _Tp' ('long long int' and 'int')
    6 |         a=max(a-k,0);
      |           ~~~^~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare)'
  303 |     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note:   candidate expects 3 arguments, 2 provided
a.cc:12:14: error: no matching function for call to 'max(long long int, int)'
   12 |         b=max(b-j,0);
      |           ~~~^~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:257:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::max(const _Tp&, const _Tp&)'
  257 |     max(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:257:5: note:   template argument deduction/substitution failed:
a.cc:12:14: note:   deduced conflicting types for parameter 'const _Tp' ('long long int' and 'int')
   12 |         b=max(b-j,0);
      |           ~~~^~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare)'
  303 |     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note:   candidate expects 3 arguments, 2 provided