code1
stringlengths 54
12k
| code2
stringlengths 65
12k
| similar
int64 0
1
| __index_level_0__
int64 45
101M
|
|---|---|---|---|
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include <bits/stdc++.h>
#define PI acos(-1)
#define fs first
#define sc second
#define debug freopen("1.in","r",stdin),freopen("1.out","w",stdout);
#define ios ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const ll maxn = 1e6 + 10;
const ll mod = 998244353;
int n, arr[maxn];
ll ans = 1;
ll mul(ll x,ll y,ll z)
{
return x * y % z;
}
ll qpow(ll m, ll k, ll p){
ll res = 1 % p;
while (k){
if (k&1) res = res * m % p;
m = m * m % p;
k >>= 1;
}
return res;
}
int main(){
ios;
cin >> n;
cin >> arr[1];
if (arr[1] != 0){
cout << 0;
return 0;
}
for (int i = 2; i <= n; i ++){
cin >> arr[i];
if (arr[i] == 0){
cout << 0;
return 0;
}
}
sort(arr + 1, arr + 1 + n);
ll tmp = 1, tmpp = 1;
for (int i = 2 ; i <= n; i ++){
if (arr[i] - arr[i - 1] != 1 && arr[i] - arr[i - 1] != 0){
cout << 0;
return 0;
}
if (arr[i] == arr[i + 1])
tmpp ++;
else{
ans = mul(ans, qpow(tmp, tmpp, mod), mod);
tmp = tmpp;
tmpp = 1;
}
}
cout << ans;
return 0;
} | #include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
template <typename T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
typedef long long ll;
typedef vector<ll> VL;
typedef vector<int> VI;
typedef pair<ll,ll> PLL;
typedef pair<int,int> PII;
#define pb push_back
#define F first
#define S second
#define SZ(a) int((a).size())
#define ALL(a) a.begin(),a.end()
#define fr(i,x,y) for(int i=x;i<y;i++)
#define frr(i,x,y) for(int i=x-1;i>=y;i--)
#define inf 1e18+1
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
const int mod=998244353;
ll gcd(ll a,ll b) { return b?gcd(b,a%b):a;}
ll power(ll a,ll b){ll ans=1;while(b!=0){if(b&1){ans*=a;}a=a*a;b>>=1;}return ans;}
ll powerm(ll a,ll b){ll ans=1;while(b!=0){if(b&1){ans*=a;ans%=mod;}a=a*a;a%=mod;b>>=1;}return ans%mod;}
void solve()
{
ll n,zo=0;
cin>>n;
VL arr(n);
map<ll,ll> mp;
fr(i,0,n)
{
cin>>arr[i];
if (i==0&&arr[i]!=0)
{
cout<<"0\n";
return;
}
if(arr[i]==0)
zo++;
mp[arr[i]]+=1;
}
bool fg=false;
ll last=0;
if(zo!=1)
{
cout<<"0\n";
return;
}
ll ans=1;
fr(i,1,n)
{
if(!mp.count(i))
{
if(fg)
{
}
else
{
fg=true;
}
}
else
{
if(fg)
{
cout<<"0\n";
return;
}
else
{
fr(j,0,mp[i])
{
ans*=mp[i-1];
ans%=mod;
}
}
}
}
cout<<ans<<endl;
return;
}
int main()
{
IOS;
ll t=1;
while(t--)
{
solve();
}
return 0;
} | 1 | 1,137,814 |
#include<iostream>
#include<string>
#include<cmath>
#include<iomanip>
using namespace std;
double PI = acos(-1);
int main(){
double a, b, c, deg, rad;
double area, circum, height;
cin >> a >> b >> deg;
rad = 2 * PI * deg / 360;
c = sqrt(a * a + b * b - 2 * a * b * cos(rad));
area = 0.5 * a * b * sin(rad);
circum = a + b + c;
height = b * sin(rad);
cout << setprecision(10) << area << endl;
cout << setprecision(10) << circum << endl;
cout << setprecision(10) << height << endl;
return 0;
} | #include <iostream>
#include <cmath>
const double pi = 3.14159265358979;
using namespace std;
double deg2rad(double degree)
{
return degree/180*pi;
}
int main(void)
{
double a, b, c;
double r, s, length, h;
cin >> a >> b >> r;
r *= pi/180;
h = b * sin(r);
s = a * h / 2;
c = sqrt(a*a + b*b - 2*a*b*cos(r));
length = a + b + c;
cout << fixed << s << " " << length << " " << h << endl;
return 0;
} | 1 | 5,890,345 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
#define forin(in) for(int i=0; i<(int)in.size(); i++) cin>>in[i]
#define forout(out) for(int i=0; i<(int)out.size(); i++) cout<<out[i]<<endl
#define rep(i, n) for(int i=0; i<(n); i++)
int main(){
int h, w, k; cin>> h >> w >> k;
vector<string> c(h);
forin(c);
int cnt = 0, ans = 0;
for(int bit = 0; bit<(1<<h); bit++){
for(int bit2 = 0; bit2<(1<<w); bit2++){
for(int i = 0; i<h; i++)for(int j=0; j<w; j++){
if(c[i][j] == '#' && !(bit & (1<<i)) && !(bit2 & (1<<j))) cnt++;
}
if(cnt == k) ans++;
cnt = 0;
}
}
cout<< ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int H, W, K;
cin >> H >> W >> K;
vector<vector<char>> blocks(H, vector<char>(W));
rep(i, H) {
rep(j, W) {
cin >> blocks.at(i).at(j);
}
}
int ans = 0;
for (int row = 0; row < (1 << H); row++) {
for (int col = 0; col < (1 << W); col++) {
int count = 0;
for (int i = 0; i < H; i++) {
if ((row >> i) & 1) continue;
for (int j = 0; j < W; j++) {
if ((col >> j) & 1) continue;
if (blocks.at(i).at(j) == '#') count++;
}
}
if (count == K) ans++;
}
}
cout << ans << endl;
return 0;
} | 1 | 36,909,581 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, s, n) for (int i = (s); i < (int)(n); i++)
#define all(v) v.begin(), v.end()
using ll = long long;
const ll MOD = 1e9+7; ll LLINF = 1LL << 60; int INF = INT_MAX;
int main(){
int n; cin>>n;
vector<long double> x(n);
vector<string> c(n);
rep(i,0,n) cin>>x[i]>>c[i];
long double sum=0;
rep(i,0,n){
if(c[i]=="JPY") sum+=x[i];
else sum+=x[i]*380000;
}
cout<<sum<<endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
#define REP(i, n) for(int i = 0; i < (int)(n); i++)
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define ALL(x) (x).begin(),(x).end()
const int IINF = 1e9;
const LL LINF = 1e18;
const LL MOD = 1e9+7;
int main() {
int N;
cin >> N;
double k = 0;
REP(i, N) {
double x;
string u;
cin >> x >> u;
k += u == "JPY" ? x : x*380000;
}
printf("%.8f\n", k);
return 0;
} | 1 | 61,014,327 |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for (int i = 0; i < (int)n; i++)
const int inf = 1000000000;
int main() {
int n;
cin >> n;
std::vector<int> vec(n);
for (int i = 0; i < n; i++) {
cin >> vec.at(i);
}
int ans = inf;
for (int i = 1; i <= 100; i++) {
int cost = 0;
rep(j,n) cost += (vec.at(j) - i) * (vec.at(j) - i);
ans = min(ans, cost);
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#define pi 3.14159265358979323846264338327950L
using namespace std;
int main() {
int N, R;
cin >> N;
vector<int> X(N);
for (int i=0; i<N; i++) {
cin >> X[i];
}
sort(X.begin(),X.end());
R=X[N-1]-X[0]+1;
vector<int> P(R);
for (int i=0; i<R; i++) {
P[i]=0;
for (int j=0; j<N; j++) {
P[i]=P[i]+(X[j]-(X[0]+i))*(X[j]-(X[0]+i));
}
}
sort(P.begin(),P.end());
cout << P[0] << endl;
} | 1 | 56,209,981 |
#include<bits/stdc++.h>
#define int long long
#define all(a) a.begin(),a.end()
#define sz(a) a.size()
#define re return
#define MP make_pair
#define pb push_back
#define pii pair<int,int>
#define se second
#define fi first
using namespace std;
signed main(){
ios_base::sync_with_stdio(0);
int a,b,c,d;
cin>>a>>b>>c>>d;
if((abs(a-b)<=d&&abs(b-c)<=d)||abs(a-c)<=d) cout<<"Yes";
else cout<<"No";
re 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll INF = LONG_LONG_MAX / 2;
const ll mod = 1000000000 + 7;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
if (abs(a - c) <= d || (abs(a - b) <= d && abs(b - c) <= d))
cout << "Yes" << endl;
else
cout << "No" << endl;
} | 1 | 1,186,887 |
#include <iostream>
#include <cmath>
using namespace std;
struct Point{
double x, y;
};
void koch(int n, Point a, Point b){
if(n == 0) return ;
Point s, t, u;
double th = M_PI * 60.0 / 180.0;
s.x = (2.0 * a.x + 1.0 * b.x) / 3.0;
s.y = (2.0 * a.y + 1.0 * b.y) / 3.0;
t.x = (1.0 * a.x + 2.0 * b.x) / 3.0;
t.y = (1.0 * a.y + 2.0 * b.y) / 3.0;
u.x = (t.x - s.x) * cos(th) - (t.y - s.y) * sin(th) + s.x;
u.y = (t.x - s.x) * sin(th) + (t.y - s.y) * cos(th) + s.y;
koch(n-1, a, s);
cout << showpoint << s.x << " " << showpoint << s.y << endl;
koch(n-1, s, u);
cout << showpoint << u.x << " " << showpoint << u.y << endl;
koch(n-1, u, t);
cout << showpoint << t.x << " " << showpoint << t.y << endl;
koch(n-1, t, b);
}
int main(){
Point a, b;
int n;
cin >> n;
a.x = 0;
a.y = 0;
b.x = 100;
b.y = 0;
cout << showpoint << a.x << " " << showpoint << a.y << endl;
koch(n, a, b);
cout << showpoint << b.x << " " << showpoint << b.y << endl;
return 0;
} | #include <iostream>
#include <algorithm>
#include <complex>
#include <cmath>
#include <numeric>
#include <memory>
#include <array>
#include <bitset>
#include <deque>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
using point = complex<double_t>;
void print(const point p){
cout<<real(p)<<' '<<imag(p)<<'\n';
}
const point rota = polar(1.0, M_PI/3.0);
void koch(const point first, const point last, size_t n){
if(n==0) print(first);
else{
point mid1 = first+(last-first)/3.0;
point mid3 = first+(last-first)*2.0/3.0;
point mid2 = mid1+(mid3-mid1)*rota;
koch(first, mid1, n-1);
koch(mid1, mid2, n-1);
koch(mid2, mid3, n-1);
koch(mid3, last, n-1);
}
}
int32_t main(){
size_t n; cin>>n;
const point first(0, 0), last(100, 0);
koch(first, last, n);
print(last);
} | 1 | 41,046,430 |
#include <iostream>
using namespace std;
int main(void){
int list[3];
int tmp;
cin >> list[0] >> list[1] >> list[2];
for(int i = 0; i < 2; i++){
for(int j = 1; j < 3; j++){
if(list[i] > list[j]){
tmp = list[i];
list[i] = list[j];
list[j] = tmp;
}
}
}
cout << list[0] << " " << list[1] << " " << list[2] << endl;
return 0;
} | #include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
int main(){
std::vector<int>a;
for (int i = 0; i < 3; ++i){
int t;
std::cin >> t;
a.push_back(t);
}
std::sort(a.begin(), a.end());
std::cout << a[0] << " " << a[1] << " " << a[2] << std::endl;
} | 1 | 72,119,638 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int k;
char arr[100];
cin >> k;
scanf("%s", arr);
if(strlen(arr) <=k){
printf("%s", arr);
}
else{
for(int i=0; i<k; ++i){
cout << arr[i];
}
cout << "...";
}
} | #include<stdio.h>
#include<string.h>
int main()
{
int n;
scanf("%d",&n);
char str[102];
scanf("%s",&str);
int len=strlen(str);
if(len>n)
{
str[n]='.';
str[n+1]='.';
str[n+2]='.';
str[n+3]='\0';
}
printf("%s",str);
return 0;
} | 1 | 51,594,923 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int64_t N, ans = 0;
cin >> N;
vector<int64_t> A(2 * N);
for (int i = 0; i < 2 * N; i++)
{
cin >> A.at(i);
}
sort(A.begin(), A.end());
for (int i = 0; i < 2 * N; i += 2)
{
ans += A.at(i);
}
cout << ans << endl;
} | #include <algorithm>
#include <iostream>
using namespace std;
int a[ 210 ];
int main()
{
int n;
cin >> n;
for ( int i = 0; i < 2 * n; i++ )
{
cin >> a[ i ];
}
sort( a, a + 2 * n );
long long int ans = 0;
for ( int i = 0; i < 2 * n; i += 2 )
{
ans += min( a[ i ], a[ i + 1 ] );
}
cout << ans << endl;
} | 1 | 74,868,943 |
#include<bits/stdc++.h>
using namespace std;
int n,t=0;
void dfs(int k,int end,string s)
{
if(k>end)
if(++t==n)
{
cout<<s;
exit(0);
}
else return ;
for(char ch=s[s.size()-1]-1;ch<=s[s.size()-1]+1;ch++)
if(ch>='0'&&ch<='9')
dfs(k+1,end,s+ch);
}
int main()
{
ios::sync_with_stdio(false);
cin>>n;
for(int i=1;;i++)
for(char c='1';c<='9';c++)
{
string s="";
dfs(2,i,s+c);
}
return 0;
} | #include <bits/stdc++.h>
#define rep(i,n) for(long long i=0; i<n; i++)
#define Rep(i,n) for(long long i=1; i<n; i++)
#define ll long long
#include <math.h>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <queue>
#include <set>
#include <vector>
using namespace std;
#define PI acos(-1)
using P =pair<int,int>;
ll f(ll x,ll c,ll d){
ll res =x;
res -=x/c;
res -=x/d;
res+= x/lcm(c,d);
return res;
}
vector<int> to[100005];
const ll inf =100000000;
vector<ll>a,b,c,d;
ll n,m,q;
ll ans=0;
void bfs(vector<ll> v){
if(v.size()==n+1) {
ll sum=0;
rep(i,q){
if(v[b[i]]-v[a[i]]==c[i])sum+=d[i];
}
ans=max(ans,sum);
return;
}
v.push_back(v.back());
bfs(v);
while(v.back()<m){
v.back()++;
bfs(v);
}
}
int main(){
int k;
cin>>k;
vector<ll> a;
for(int i=1;i<=9;++i)a.push_back(i);
while(1){
if(k<=a.size()){
cout<<a[k-1]<<endl;
return 0;
}
k-=a.size();
vector<ll> old;
swap(old,a);
for(ll x:old){
for(int i=-1;i<=1;i++){
int d=x%10+i;
if(d<0||9<d)continue;
ll nx= x*10+d;
a.push_back(nx);
}
}
}
} | 1 | 27,453,382 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n,m;
cin >> n >> m;
if((n+m) == 15)
cout << '+';
else if((n*m) == 15)
cout << '*';
else
cout << 'x';
} | #include <bits/stdc++.h>
using namespace std;
using int32 = int_fast32_t;
using int64 = int_fast64_t;
const int32 INF = 1e9;
const int32 MOD = 1e9+7;
const int64 LLINF = 1e18;
#define YES(n) cout << ((n) ? "YES\n" : "NO\n" )
#define Yes(n) cout << ((n) ? "Yes\n" : "No\n" )
#define ANS(n) cout << (n) << "\n"
#define REP(i,n) for(int64 i=0;i<(n);++i)
#define FOR(i,a,b) for(int64 i=(a);i<(b);i++)
#define FORR(i,a,b) for(int64 i=(a);i>=(b);i--)
#define ALL(obj) (obj).begin(),(obj).end()
#define pii pair<int32,int32>
#define pll pair<int64,int64>
#define pb(a) push_back(a)
#define mp make_pair
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int32 a,b;
cin >> a >> b;
if(a + b == 15){
cout << "+\n";
}else if(a * b == 15){
cout << "*\n";
}else{
cout << "x\n";
}
return 0;
} | 1 | 68,863,294 |
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define leading zero str.erase(0, min(str.find_first_not_of('0'), str.size()-1));
using namespace __gnu_pbds;
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;
string text="abcdefghijklmnopqrstuvwxyz";
const int maxn=1e6+7;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n,k,s;
cin>>n>>k>>s;
for(int i=0;i<k;i++){
cout<<s<<" ";
}
for(int i=0;i<n-k;i++){
cout<<1000000000-(s==1000000000)<<" ";
}
} | #include <iostream>
#include <string>
#include <math.h>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < n; i++)
int main(){
ll N, K, S;
cin >> N >> K >> S;
ll num = pow(10, 9);
if(num == S){
rep(i, K) cout << S << " ";
rep(i, N-K) cout << 1 << " ";
cout << endl;
}else{
rep(i, K) cout << S << " ";
rep(i, N-K) cout << S+1 << " ";
cout << endl;
}
return 0;
} | 1 | 35,515,786 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define fr(a,b) for(int i=a;i<b;i++)
#define prDouble(x) cout<<fixed<<setprecison(18)<<x
#define mod 1000000007
int solve(std::vector<int>& v, int n, int k)
{
ll dp[n + 2][k + 2];
for (int j = 0; j <= k; j++)
dp[1][j] = (j > v[1]) ? 0 : 1;
for (int i = 2; i <= n; i++)
{
for (int j = 0; j <= k; j++)
{
if (j == 0)
dp[i][j] = dp[i - 1][j];
else
dp[i][j] = (mod + dp[i][j - 1] + dp[i - 1][j] - ((j - v[i] - 1 >= 0) ? dp[i - 1][j - v[i] - 1] : 0)) % mod;
}
}
return dp[n][k];
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
std::vector<int> v(n + 1);
for (int i = 1; i <= n; i++)
cin >> v[i];
cout << solve(v, n, k);
} | #include<bits/stdc++.h>
#define ll long long
#define MOD 1000000007
using namespace std;
int dp[100][100005];
int main()
{
int n,k;
cin>>n>>k;
int a[n];
for(int i=0;i<n;i++)
cin>>a[i];
for(int i=0;i<=a[0];i++)
dp[0][i] = 1;
for(int i=1;i<n;i++){
vector<int>pref(k+1);
pref[0] = dp[i-1][0];
for(int j=1;j<=k;j++){
pref[j] = (pref[j-1]+dp[i-1][j])%MOD;
}
for(int j=0;j<=k;j++){
if(j>a[i])
dp[i][j] = (pref[j]+MOD - pref[j-a[i]-1])%MOD;
else
{
dp[i][j] = pref[j];
}
}
}
cout<<dp[n-1][k];
return 0;
} | 1 | 30,179,485 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
const ll mod = 1000000007;
vector<ll> fac(1000005);
vector<ll> ifac(1000005);
ll modpow(ll x, ll n){
ll ans = 1;
while(n != 0){
if(n & 1)
ans = ans * x % mod;
x = x * x % mod;
n = n >> 1;
}
return ans;
}
ll comb(ll a, ll b){
if(a == 0 && b == 0)
return 1;
if(a < b || a < 0)
return 0;
ll tmp = ifac[a - b] * ifac[b] % mod;
return tmp * fac[a] % mod;
}
int main(){
ll x, y;
cin >> x >> y;
ll ans = 0;
if((x + y) % 3 != 0 || 2 * x < y || 2 * y < x){
cout << "0" << endl;
return 0;
}
ll n, m;
n = (2 * y - x) / 3;
m = (2 * x - y) / 3;
fac[0] = 1;
ifac[0] = 1;
for(ll i = 0; i < max(x, y); i++){
fac[i + 1] = fac[i] * (i + 1) % mod;
ifac[i + 1] = ifac[i] * modpow(i + 1, mod - 2) % mod;
}
cout << comb(n + m, n) << endl;
return 0;
} | #include <bits/stdc++.h>
#include <math.h>
using namespace std;
long long inf=1000000007;
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
}
int main(){
int x,y;
cin>>x>>y;
if((x+y)%3!=0){
cout<<0<<endl;
return 0;
}
int a=(2*y-x)/3;
int b=(x-a)/2;
if(a<0 || b<0){
cout<<0<<endl;
return 0;
}
int n=a+b;
int r=min(a,b);
long long ans=1;
for(int i=0;i<r;i++){
ans*=n;
ans%=inf;
n--;
}
for(int i=1;i<=r;i++){
ans*=modinv(i,inf);
ans%=inf;
}
cout<<ans<<endl;
return 0;
} | 1 | 61,020,742 |
#include <bits/stdc++.h>
using namespace std;
#define int int64_t
#define rep(i, n) for (int i = 0; i < (n); i++)
#define reps(i, n) for (int i = 1; i <= (n); i++)
#define all(x) (x).begin(), (x).end()
#define gsort(x) sort((x).begin(), (x).end(), greater<int>())
#define rv(s) reverse((s).begin(), (s).end())
#define pii pair<int, int>
#define re(s) reverse((s).begin(), (s).end())
#define setout(n, x) setw(n) << setfill(x)
#define Fixed fixed << setprecision(10);
#define pb(x, a) (x).push_back(a)
#define fb(x, a) (x).flont_back(a)
constexpr int INF = 0x3f3f3f3f;
constexpr long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const long long mod = 1e9 + 7;
signed main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int n, cnt = 0;
cin >> n;
vector<int> x;
x.resize(n);
rep(i, n)
{
cin >> x[i];
}
reps(i, n - 1)
{
if (x[i] == x[i - 1])
{
++cnt;
x[i] = 0;
}
}
cout << cnt << '\n';
} | #include<bits/stdc++.h>
using namespace std;
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
typedef vector <int> vi;
typedef pair<int,int> ii;
typedef long long ll;
typedef long double ld;
const int mod = 998244353;
const ll inf = 3e18 + 5;
int add(int a, int b) { return (a += b) < mod ? a : a - mod; }
int mul(int a, int b) { return 1LL * a * b % mod; }
const int n = 1e9;
int main(){
int n;
cin >> n;
vi a(n);
vi b;
int cnt = 1;
for(int i = 0; i < n; i++){
cin >> a[i];
if(i>0){
if(a[i] == a[i-1])
cnt++;
else{
b.push_back(cnt);
cnt=1;
}
}
}
b.push_back(cnt);
int sol = 0;
for(int x : b){
sol+=x/2;
}
cout << sol;
} | 1 | 70,423,866 |
#include <iostream>
#include <vector>
using namespace std;
#define ll long long
int max(int a,int b){
if(a>b){
return a;
}else{
return b;
}
}
int main(void){
int a,b,c;
cin >> a >> b >> c;
cout << max(c -(a-b),0) << endl;
return 0;
} | #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#include <cmath>
#include <iomanip>
using namespace std;
using ll = long long;
#define rep(i,N) for(int i=0;i<(int)N;++i)
#include <iostream>
int main()
{
int A, B, C ;
cin >> A >> B >> C;
cout << C-min(A - B, C) << endl;
} | 1 | 59,146,151 |
#include <iostream>
using namespace std;
int main(){
char str[4] ;
int i1 ;
cin >> str ;
if ( str[0] == str [1] ){
i1++;
}
if ( str[0] == str [2] ){
i1++;
}
if ( str[0] == str [3] ){
i1++;
}
if ( str[1] == str [2] ){
i1++;
}
if ( str[1] == str [3] ){
i1++;
}
if ( str[2] == str [3] ){
i1++;
}
if ( i1 == 2 ){
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;cin>>s;
char st;
int cnt;
for (int i=0; i<4;i++) {
cnt =0;
st = s[i];
for (int j=0;j<4;j++){
if (st == s[j]) cnt++;
}
if (cnt != 2) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
} | 1 | 48,554,142 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
int N, M;
cin >> N >> M;
vector<int> a(M), b(M);
for(int i=0; i<M; i++) cin >> a[i] >> b[i];
vector<int> cnt(N+1, 0);
for(int i=0; i<M; i++)
{
cnt[a[i]]++;
cnt[b[i]]++;
}
string ans = "YES";
for(auto num : cnt)
{
if(num%2==1) ans = "NO";
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<n; i++)
#define REP(i,m,n) for(ll i=(ll)(m);i<(ll)(n);i++)
long long mo = 1e9 + 7;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> Pii;
typedef pair<ll,ll> Pll;
template<class T, class S> void cmin(T &a, const S &b) { if (a > b)a = b; }
template<class T, class S> void cmax(T &a, const S &b) { if (a < b)a = b; }
template<class A>void PR(A a,ll n){rep(i,n){if(i)cout<<' ';cout<<a[i];}cout << "\n";}
ld PI=3.14159265358979323846;
int main(){
ll N, M;
cin >> N >> M;
vector<ll> a(M), b(M), c(N);
rep(i,M){
cin >> a[i] >> b[i];
a[i]--;b[i]--;
c[a[i]]++;
c[b[i]]++;
}
rep(i,N){
if(c[i]%2 == 1){
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
} | 1 | 84,438,677 |
#include <bits/stdc++.h>
using namespace std;
struct D{
int size;
vector<int> num;
D(){
size = 6;
num = vector<int>{1,2,3,4,5,6};
}
D(vector<int> _num){
size = _num.size();
num = _num;
}
void change(vector<int> idx){
auto ret(num);
for(int i = 0; i < size; i++){
ret[i] = num[idx[i]];
}
swap(ret,num);
}
void roll(char c){
vector<int> idx{0,1,2,3,4,5};
switch(c){
case 'S':
idx = vector<int>{4,0,2,3,5,1};
break;
case 'N':
idx = vector<int>{1,5,2,3,0,4};
break;
case 'W':
idx = vector<int>{2,1,5,0,4,3};
break;
case 'E':
idx = vector<int>{3,1,0,5,4,2};
break;
}
change(idx);
}
void roll(int top, int front){
int topidx,frontidx;
for(int i = 0; i < size; i++){
if(num[i] == top){
topidx = i;
}
}
switch(topidx){
case 1:
roll('N');
break;
case 2:
roll('W');
break;
case 3:
roll('E');
break;
case 4:
roll('S');
break;
case 5:
roll('S');
roll('S');
break;
}
vector<int> idx = {0,1,2,3,4,5};
for(int i = 0; i < size; i++){
if(num[i] == front){
frontidx = i;
}
}
switch(frontidx){
case 1:
break;
case 2:
idx = vector<int>{0,2,4,1,3,5};
break;
case 3:
idx = vector<int>{0,3,1,4,2,5};
break;
case 4:
idx = vector<int>{0,4,3,2,1,5};
break;
}
change(idx);
}
};
int main(){
vector<int> a(6);
for(auto &e : a)cin >> e;
D dice(a);
int q; cin >> q;
for(int i = 0; i < q; i++){
D temp = dice;
int top,front; cin >> top >> front;
temp.roll(top,front);
cout << temp.num[2] << endl;
}
return 0;
} | #include <iostream>
using namespace std;
class Dice {
public:
int face[6];
int getRightFace(int up, int front);
};
int Dice::getRightFace(int up, int front)
{
if ((up == face[1] && front == face[2]) ||
(up == face[2] && front == face[4]) ||
(up == face[3] && front == face[1]) ||
(up == face[4] && front == face[3])) {
return face[0];
}
if ((up == face[0] && front == face[3]) ||
(up == face[2] && front == face[0]) ||
(up == face[3] && front == face[5]) ||
(up == face[5] && front == face[2])) {
return face[1];
}
if ((up == face[0] && front == face[1]) ||
(up == face[1] && front == face[5]) ||
(up == face[4] && front == face[0]) ||
(up == face[5] && front == face[4])) {
return face[2];
}
if ((up == face[0] && front == face[4]) ||
(up == face[1] && front == face[0]) ||
(up == face[4] && front == face[5]) ||
(up == face[5] && front == face[1])) {
return face[3];
}
if ((up == face[0] && front == face[2]) ||
(up == face[2] && front == face[5]) ||
(up == face[3] && front == face[0]) ||
(up == face[5] && front == face[3])) {
return face[4];
}
return face[5];
}
int main()
{
Dice dice;
for (int i = 0; i < 6; i++) {
cin >> dice.face[i];
}
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int up, front;
cin >> up >> front;
cout << dice.getRightFace(up, front) << endl;
}
return 0;
} | 1 | 40,879,882 |
#include <iostream>
#include <algorithm>
using namespace std;
int main(){
int dp[50001];
int c[20];
int n;
int m;
cin >> n >>m;
for(int i=0;i<m;i++) cin>> c[i];
sort(c,c+m);
for(int j=0;j<=n;j++) dp[j] = j;
for(int i=1;i<m;i++)
for(int j=1;j<=n;j++)
if(j>=c[i]) dp[j] = min(dp[j],dp[j-c[i]]+1);
cout << dp[n]<<endl;
return 0;
} | #include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <stack>
#include <queue>
#include <algorithm>
using namespace std;
const long long int MOD = 1000000007;
const long long int INF = 100000000;
long long int N,M;
long long int C[30];
long long int dp[21][100000];
int DP(int n,int v)
{
if(n<0||v<0) return INF;
if(dp[n][v]!=-1) return dp[n][v];
return dp[n][v] = min(DP(n-1,v),DP(n,v-C[n])+1);
}
int main()
{
cin >> N >> M;
for(int i = 0; i < M; i++){
cin>>C[i];
}
memset(dp,-1,sizeof(dp));
for(int i = 0; i < 21; i++){
dp[i][0]=0;
}
cout << DP(M - 1,N) << endl;
return 0;
} | 1 | 49,614,639 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
int ans = 1;
cin >> n >> k;
for (int i = 0; i < n; i++) {
ans = min(ans*2, ans+k);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define pb push_back
#define Int long long
using namespace std;
const int MAXN=50005;
const int NAX=1005;
const long MOD=(long)(1e9+7);
Int N,M,K;
Int X,Y,Z;
int main()
{
int start=1;
cin>>N>>K;
int times=N;
while(times--){
if(start<K) start*=2;
else start+=K;
}
cout<<start<<"\n";
} | 1 | 83,424,381 |
#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<math.h>
using namespace std;
int main()
{
int n; cin>>n;
string s,ss; cin>>s>>ss;
for(int i=0;i<n;i++)
{
cout<<s[i]<<ss[i];
}
} | #include <algorithm>
#include <iostream>
#include <vector>
#include <functional>
#include <string>
#include <cmath>
#include <iomanip>
using namespace std;
int main(){
cout << fixed << setprecision(6);
int n; cin >> n;
string s,t; cin >> s >> t;
string out ="";
for (int i = 0; i < n; i++)
{
out += s[i];
out += t[i];
}
cout << out << endl;
return 0;
} | 1 | 7,778,926 |
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)n;i++)
#define Rep(i,s,f) for(int i=(int)s;i<(int)f;i++)
using ll=long long;
using namespace std;
int main()
{
int N,C,K;
cin>>N>>C>>K;
vector<int> T(N);
rep(i,N) cin>>T[i];
sort(T.begin(),T.end());
int prev=T[0];
int cnt=1;
int i=1;
int ans=0;
while (i<N)
{
if(prev+K>=T[i]&&cnt<C)
{
cnt++;
}
else
{
ans++;
cnt=1;
prev=T[i];
}
i++;
}
cout<<ans+1<<endl;
return 0;
} | #include <bits/stdc++.h>
#include <boost/range/algorithm.hpp>
#include <boost/range/numeric.hpp>
#include <boost/integer/common_factor.hpp>
#include <boost/integer/common_factor_rt.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/multiprecision/cpp_int.hpp>
using std::string;
using std::vector;
using std::set;
using std::multiset;
using std::unordered_set;
using std::map;
using std::multimap;
using std::unordered_map;
using std::pair;
using std::cin;
using std::cout;
using boost::multiprecision::cpp_int;
using cpp_dec_float_1000 = boost::multiprecision::number<boost::multiprecision::cpp_dec_float<1000, boost::int128_type>>;
typedef uintmax_t ull;
typedef intmax_t ll;
typedef uint64_t ul;
typedef uint32_t ui;
typedef uint8_t uc;
constexpr char CRLF = '\n';
constexpr char SPACE = ' ';
constexpr char VECTOR_COUT_SEPARATOR = SPACE;
constexpr ll INF = 1000'000'007;
constexpr int MOD = 1000'000'007;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> std::ostream& operator<< (std::ostream& os, const std::vector<T>& vc) { for(auto it = vc.begin(); it != vc.end(); ++it) { if (std::next(it) == vc.end()) os << *it; else os << *it << VECTOR_COUT_SEPARATOR; } return os; }
template<class T1, class T2> inline std::ostream & operator<< (std::ostream & os, const std::pair<T1, T2> & p) { return os << p.first << ' ' << p.second; }
template<class T> T modinv(T a, T m) { T b = m, u = 1, v = 0; while (b) { T t = a / b; a -= t * b; boost::swap(a, b); u -= t * v; boost::swap(u, v); } u %= m; if (u < 0) u += m; return u; }
template<class T> inline bool isSosuu(const T& n) { if (n == T(1)) { return false; } for (T i = 2; i*i <= n; ++i) { if (n % i == 0) { return false; } } return true; }
template<class T> vector<vector<T>> split (const vector<T>& S, T delim) { vector<vector<T>> ret{}; vector<T> buff{}; for (auto c : S) { if (c == delim) { if (!buff.empty()) ret.push_back(buff); buff.clear(); } else { buff.push_back(c); } } if (!buff.empty()) ret.push_back(buff); return ret; }
template<class T> inline void printYesNo(const T& t) { cout << (t ? "Yes" : "No") << CRLF; }
template<class T = int64_t> T modpow(T N, T P, T M) { T ret{1}; N %= M; while (P) { if (P & 0x01) { ret *= N; ret %= M; } P >>= 1; N *= N; N %= M; } return ret; }
int gErr = 0;
#define ASSERT(p) if(!(p)){ gErr = 1; }else{ ; }
struct Tmp
{
public:
int N;
Tmp(int N)
: N(N)
{}
};
void solve(void)
{
int N, C, K; cin >> N >> C >> K;
using Pair = pair<int, int>;
vector<Pair> que{};
que.reserve(N*2);
for (int i = 0; i < N; ++i) {
int t; cin >> t;
que.push_back({t, 1});
que.push_back({t+K, -1});
}
std::sort(que.begin(), que.end(), [](const auto& p1, const auto& p2){
if (p1.first != p2.first) {
return p1.first < p2.first;
} else {
return p1.second > p2.second;
}
});
int cnt{}, finished{};
int res{};
for (const auto& p : que) {
if (p.second > 0) {
++cnt;
if (cnt >= C) {
++res;
cnt -= C;
finished += C;
}
} else {
if (finished == 0) {
auto m = std::min(C, cnt);
++res;
cnt -= m;
finished += m;
}
--finished;
}
}
cout << res << CRLF;
return;
}
int main(void)
{
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
solve();
return 0;
} | 1 | 98,148,239 |
#include <iostream>
#include <string>
#include <cstring>
#include <fstream>
#include <random>
#include <cmath>
#include <iomanip>
#include <climits>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <map>
#include <deque>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <list>
#include <unordered_map>
#include <bitset>
#include <sstream>
#include <new>
#include <typeinfo>
#include <iterator>
typedef long long ll;
typedef unsigned long long ull;
constexpr ll mop = 1000000007;
constexpr ll mop2 = 998244353;
using namespace std;
struct Point {
ll x, y;
Point(){}
Point(ll x, ll y):x(x), y(y){}
};
int main() {
ll h, w;
cin >> h >> w;
queue<Point> blacks;
vector<vector<ll>> distance;
distance.resize(h);
for (ll i = 0; i < h; i++) {
string s;
cin >> s;
distance[i].resize(w);
for (ll j = 0; j < w; j++) {
if (s[j] == '#') {
blacks.push(Point(i, j));
distance[i][j] = 0;
}
else {
distance[i][j] = -1;
}
}
}
ll ans = 0;
while (!blacks.empty()) {
Point now = blacks.front();
blacks.pop();
ll x = now.x;
ll y = now.y;
ll nowDis = distance[x][y];
if (ans < nowDis) {
ans = nowDis;
}
Point tmp[4];
for (ll i = 0; i < 4; i++) {
tmp[i] = now;
}
tmp[0].x++;
tmp[1].x--;
tmp[2].y++;
tmp[3].y--;
for (ll i = 0; i < 4; i++) {
Point& nowtmp = tmp[i];
if (0 <= nowtmp.x && nowtmp.x < h && 0 <= nowtmp.y && nowtmp.y < w && distance[nowtmp.x][nowtmp.y] == -1) {
distance[nowtmp.x][nowtmp.y] = nowDis + 1;
blacks.push(nowtmp);
}
}
}
cout << ans << endl;
} | #include <iostream>
#include <vector>
#include <queue>
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
struct COODINATE
{
public:
int x, y, n;
};
vector<string> Gin;
Graph Gout;
queue<COODINATE> Q;
int search(int x, int y, int n, int h, int w){
if(x<0 || w<=x || y<0 || h<=y || Gout[y][x] != -1){
return 0;
}
if(Gin[y][x] == '#'){
Gout[y][x] = 0;
Q.push(COODINATE{x+1, y, n});
Q.push(COODINATE{x-1, y, n});
Q.push(COODINATE{x, y+1, n});
Q.push(COODINATE{x, y-1, n});
return 0;
}
Gout[y][x] = n+1;
Q.push(COODINATE{x+1, y, n+1});
Q.push(COODINATE{x-1, y, n+1});
Q.push(COODINATE{x, y+1, n+1});
Q.push(COODINATE{x, y-1, n+1});
return n+1;
}
int main(){
int h, w;
cin >> h >> w;
for(int i=0;i<h;i++){
string s;
cin >> s;
Gin.push_back(s);
}
Gout.assign(h, vector<int>(w, -1));
int ans = 0;
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
if(Gin[i][j] == '#'){
Q.push(COODINATE{j, i, 0});
}
}
}
while(!Q.empty()){
COODINATE coodinate = Q.front();
Q.pop();
int num = search(coodinate.x, coodinate.y, coodinate.n, h, w);
if(ans < num){
ans = num;
}
}
cout << ans << endl;
return 0;
} | 1 | 82,629,016 |
#include <vector>
#include <set>
#include <map>
#include <array>
#include <iostream>
#include <cstdio>
#include <cstdint>
#include <algorithm>
#include <numeric>
#include <bitset>
using ll = long long;
using namespace std;
#define rep(i,n) for(ll i=0;i<(n);++i)
inline void yes(bool cond) { cond ? puts("Yes") : puts("No"); }
template<typename Type> inline void chmin(Type& a, Type b) { if (a > b) a = b; }
template<typename Type> inline void chmax(Type& a, Type b) { if (a < b) a = b; }
template<typename Arr, typename Type> inline void fill(Arr& arr, Type v) { std::fill(arr.begin(), arr.end(), v); }
template<typename Type> inline void sort(Type& arr) { std::sort(arr.begin(), arr.end()); }
template<typename Type> inline Type nth(vector<Type>& arr, size_t pos) { std::nth_element(arr.begin(), arr.begin() + pos, arr.end()); return arr[pos]; }
constexpr double BIGP = 1000000007L;
constexpr double INF_I = std::numeric_limits<double>::max();
constexpr double INF_F = std::numeric_limits<float>::infinity();
constexpr double PI = 3.14159265358979323846L;
int main()
{
cin.tie(0); ios::sync_with_stdio(false);
ll N;
cin >> N;
vector<ll> P(N, 0);
vector<ll> Q(N, 0);
rep(i, N)
{
cin >> P[i];
}
rep(i, N)
{
cin >> Q[i];
}
vector<ll> I(N);
iota(I.begin(), I.end(), 1);
ll cnt = 0;
ll iP = -1, iQ = -1;
do
{
if (I == P) iP = cnt;
if (I == Q) iQ = cnt;
++cnt;
} while (std::next_permutation(I.begin(), I.end()));
cout << abs(iP - iQ);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define ull unsigned long long
#define ld long double
#define vi vector<int>
#define vll vector<ll>
#define vc vector<char>
#define vs vector<string>
#define vpii vector<pii>
#define vpll vector<pll>
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; i++)
#define rep1(i, n) for (int i = 1, i##_len = (n); i <= i##_len; i++)
#define repr(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rep1r(i, n) for (int i = ((int)(n)); i >= 1; i--)
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define RSORT(x) sort(rall(x));
#define pb push_back
#define mp make_pair
#define INF (1e9)
#define PI (acos(-1))
#define EPS (1e-7)
ull gcd(ull a, ull b) { return b ? gcd(b, a % b) : a; }
ull lcm(ull a, ull b) { return a / gcd(a, b) * b; }
int n;
vector<vi> a;
vi now;
void dfs(int d) {
if (d == n) {
a.pb(now);
return;
}
rep1(i, n) {
bool used = false;
rep(j, d) if (now[j] == i) used = true;
if (used) continue;
now[d] = i;
dfs(d+1);
}
}
int main(){
cin >> n;
vi p(n), q(n);
rep(i, n) cin >> p[i];
rep(i, n) cin >> q[i];
now = vi(n);
dfs(0);
int pnum = 0, qnum = 0;
rep(i, sz(a)) {
if (a[i] == p) pnum = i;
if (a[i] == q) qnum = i;
}
cout << abs(pnum-qnum) << endl;
return 0;
} | 1 | 99,143,706 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<long long, long long> pll;
#define ff first
#define ss second
#define mp make_pair
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define FastIO ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define reset(x) memset(x,-1,sizeof(x))
#define CheckBit(a,b) (a&(1ll<<b))
#define SetBit(a,b) a=(a|(1ll<<b))
#define UnSetBit(a,b) a=(a&(~(1ll<<b)))
#define maxx 10000006
#define PI 2*acos(0.0)
const long long INF = 2000000000000000000LL;
const int inf = 0x3f3f3f3f;
const long double EPS = 1e-9;
inline ll mulmod(ll a, ll b, ll c) {
ll ret = 0 , cur = a % c ;
while(b) { if(b%2) ret=(ret+cur)%c; cur=(cur<<1)%c; b=b>>1; }
return ret%c;
}
inline ll bigmod(ll b, ll p, ll m){
ll ret = 1, cur = b % m;
while(p) { if(p&1) ret=(ret*cur)%m; cur=(cur*cur)%m; p=p>>1; }
return ret;
}
inline ll modulo(ll a,ll b,ll c) {
ll ret = 1 , cur = a%c ;
while(b) { if(b%2) ret=mulmod(ret,cur,c); cur=mulmod(cur,cur,c); b=b>>1; }
return ret%c ;
}
inline ll power(ll b, ll p){
ll ret = 1, cur = b;
while(p) { if(p&1) ret=(ret*cur); cur=(cur*cur); p=p>>1; }
return ret;
}
ll lcm(ll a,ll b)
{
return (a/__gcd(a,b))*b;
}
ll gcd(ll a,ll b)
{
return __gcd(a,b);
}
void Dufaux()
{
ll a,b,c,d;
cin>>a>>b>>c>>d;
ll ans=max(a,c);
ll ans2=min(b,d);
if(ans>ans2)cout<<"0"<<endl;
else cout<<ans2-ans<<endl;
}
int main()
{
FastIO;
int test=1;
while(test--){
Dufaux();
}
return 0;
} | #include <bits/stdc++.h>
#define PI 3.1415926535897932
#define _GLIBCXX_DEBUG
using namespace std;
int main() {
int A,B,C,D;
cin>>A>>B>>C>>D;
int low=max(A,C);
int up=min(B,D);
cout<<max(0,up-low)<<endl;
} | 1 | 88,777,159 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
#define rep(i, n) for (int i=0; i<(int)(n); i++)
int main(){
int N, K;
cin >> N >> K;
vector<int> p(N);
rep(i,N){
cin >> p.at(i);
}
int ans = 0;
sort(p.begin(), p.end());
rep(i,K){
ans += p.at(i);
}
cout << ans;
return 0;
} | #include <vector>
#include <string>
#include <map>
#include <algorithm>
#include <queue>
#include <iostream>
#include <cmath>
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define FOR(i,a,b) for(ll i=a;i<=(ll)(b);i++)
#define FORD(i,a,b) for(ll i=a;i>=(ll)(b);i--)
typedef long long ll;
using namespace std;
void solve(long long N, long long K, std::vector<long long> p){
sort(p.begin(), p.end());
int res = 0;
REP(i, K) {
res += p[i];
}
cout << res << endl;
}
int main(){
long long N;
scanf("%lld",&N);
long long K;
scanf("%lld",&K);
std::vector<long long> p(N);
for(int i = 0 ; i < N ; i++){
scanf("%lld",&p[i]);
}
solve(N, K, std::move(p));
return 0;
} | 1 | 23,277,590 |
#include <algorithm>
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define ll long long
#define INF 1000000000000000000
typedef pair<ll, ll> pll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
vector<ll> H(N);
rep(i, N) { cin >> H[i]; }
sort(all(H), greater<int>());
ll ans = 0;
rep(i, N) {
if (i < K)
continue;
else {
ans += H[i];
}
}
cout << ans << endl;
} | #define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <algorithm>
#include <cstdlib>
#include <cstdio>
#include <vector>
#include <iterator>
#include <cmath>
#include <iomanip>
#include <cassert>
#include <map>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
int main() {
int N, K;
cin >> N >> K;
if (K >= N) {
cout << "0";
return 0;
}
vector<int> A(N);
rep(i, N) {
cin >> A[i];
}
long long ans = 0;
sort(A.begin(), A.end(), greater<int>());
for (auto itr = A.begin()+K; itr != A.end(); itr++) {
ans += *itr;
}
cout << ans;
} | 1 | 84,850,733 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
typedef int ll;
typedef long double ld;
const ll N = 100005;
char en = '\n';
ll inf = 1e17;
ll mod = 1e9 + 7;
ll power(ll x, ll n, ll mod) {
ll res = 1;
x %= mod;
while (n) {
if (n & 1)
res = (res * x) % mod;
x = (x * x) % mod;
n >>= 1;
}
return res;
}
ll n, q;
ll nxt[N][30];
char arr[N];
ll dp[255][255][255];
string a, b, c;
ll recur(ll posa, ll posb, ll posc) {
if (posa == 0 && posb == 0 && posc == 0)
return 0;
ll &ans = dp[posa][posb][posc];
if (ans != -1)
return ans;
ans = n + 1;
if (posa) {
ll len = recur(posa - 1, posb, posc);
ans = min(ans, nxt[len + 1][a[posa] - 'a']);
}
if (posb) {
ll len = recur(posa, posb - 1, posc);
ans = min(ans, nxt[len + 1][b[posb] - 'a']);
}
if (posc) {
ll len = recur(posa, posb, posc - 1);
ans = min(ans, nxt[len + 1][c[posc] - 'a']);
}
return ans;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, m;
cin >> n >> m;
ll sum1 = 0;
ll sum2 = 0;
for (ll i = 1; i <= n; i++) {
ll x;
cin >> x;
x = (x % mod + mod) % mod;
sum2 += x;
sum2 = (sum2 % mod + mod) % mod;
sum1 += i * x % mod - sum2;
sum1 = (sum1 % mod + mod) % mod;
}
ll stx = sum1;
sum1 = 0;
sum2 = 0;
for (ll i = 1; i <= m; i++) {
ll x;
cin >> x;
x = (x % mod + mod) % mod;
sum2 += x;
sum2 = (sum2 % mod + mod) % mod;
sum1 += i * x % mod - sum2;
sum1 = (sum1 % mod + mod) % mod;
}
cout << stx * sum1 % mod << en;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll MOD = 1000000007LL;
ll mod_inv(ll a, ll m) {
ll b = m, x = 1, y = 0, s, t;
while ( b != 0 ) {
s = y;
y = x - ( a / b ) * y;
x = s;
t = b;
b = a % b;
a = t;
}
return (x % m + m) % m;
}
ll solve() {
ll N, M;
cin >> N >> M;
ll x, y, xp, yp;
vector<ll> dx(N-1), dy(M-1);
for ( int i = 0; i < N; i++ ) {
cin >> x;
if ( i > 0 ) dx[i-1] = x - xp;
xp = x;
}
for ( int i = 0; i < M; i++ ) {
cin >> y;
if ( i > 0 ) dy[i-1] = y - yp;
yp = y;
}
auto edge_sum = [](vector<ll>& v) {
ll n = v.size();
ll n_all = n * (n+1) / 2 % MOD;
ll s = 0;
ll inv2 = mod_inv(2,MOD);
for ( ll i = 0; i < n; i++ ) {
ll n_ex1 = (n-1-i) * (n-i) / 2 % MOD;
ll n_ex2 = i * (i+1) / 2 % MOD;
ll n_c = (n_all + MOD - n_ex1 + MOD - n_ex2) % MOD;
s += (v[i] * n_c) % MOD;
s %= MOD;
}
return s;
};
ll ans = edge_sum(dx) * edge_sum(dy) % MOD;
return ans;
}
int main() {
auto ans = solve();
cout << ans << "\n";
return 0;
} | 1 | 40,260,374 |
#include<bits/stdc++.h>
#define rep(i,x,y) for (int i=(x); i<=(y); i++)
#define per(i,x,y) for (int i=(x); i>=(y); i--)
#define ll long long
#define N 300010
using namespace std;
int n,a,b,now,t1,t2,k1,k2,d[N];
int main(){
bool flag=0;
scanf("%d%d%d",&n,&a,&b);
per (i,b,1) d[b-i+1]=i;
a--; now=b;
if (a){
t1=(n-b)/a+1; k1=(n-b)%a;
t2=(n-b)/a; k2=a-(n-b)%a;
if (k1 && t1>b || k2 && t2>b){ puts("-1"); return 0; }
if (((bool)t1)*k1+((bool)t2)*k2<a){ puts("-1"); return 0; }
rep (t,1,k1){
rep (i,1,t1) d[now+i]=now+t1-i+1;
now+=t1;
}
rep (t,1,k2){
rep (i,1,t2) d[now+i]=now+t2-i+1;
now+=t2;
}
}
rep (i,1,n) printf("%d ",d[i]);
return 0;
} | #include <bits/stdc++.h>
#define pb push_back
#define all(x) x.begin(),x.end()
#define lop(i,s,t) for(int i=s;i<(t);++i)
#define rep(i,s,t) for(int i=s;i<=(t);++i)
#define dec(i,s,t) for(int i=s;i>=(t);--i)
using namespace std;
int n,a,b,cur;
int main(int argc,char *argv[]){
#ifdef CURIOUSCAT
#endif
cin>>n>>a>>b;
if(a==1){
if(b!=n)return puts("-1"),0;
dec(i,n,1)printf("%d ",i);puts("");
return 0;
}
int x=(n-b)/(a-1),y=(n-b)%(a-1);
if(x==0||x>b||(y&&x+1>b))return puts("-1"),0;
dec(i,b,1)printf("%d ",i); cur=b;
rep(z,1,y){ dec(i,x+1,1)printf("%d ",cur+i); cur+=x+1; }
rep(z,1,a-1-y){ dec(i,x,1)printf("%d ",cur+i); cur+=x; }
puts("");
return 0;
} | 1 | 6,519,702 |
#include<iostream>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstring>
#include<vector>
#include<list>
#include<algorithm>
#include<map>
#include<set>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define mp make_pair
#define rep(i, n) for(int i=0;i<n;++i)
#define rrep(i, n) for(int i=n;i>=0;--i)
const int inf=1e9+7;
const ll mod=1e9+7;
const ll mod1=998244353;
const ll big=1e18;
const double PI=2*asin(1);
int main() {
int N, K;
cin>>N>>K;
int ans[N+1];
for(int i=0;i<=N;++i) ans[i] = 0;
for(int i=0;i<N;++i) {
cin>>ans[i];
}
int next[N+1];
bool fin;
for(int i=0;i<K;++i) {
for(int j=0;j<=N;++j) next[j] = 0;
for(int j=0;j<N;++j) {
next[max(0, j-ans[j])]++;
next[min(N, j+ans[j]+1)]--;
}
for(int j=1;j<=N;++j) next[j] += next[j-1];
for(int j=0;j<=N;++j) ans[j] = next[j];
fin = true;
for(int j=0;j<N;++j) {
if(ans[j]<N) fin = false;
}
if(fin) break;
}
for(int i=0;i<N;++i) cout<<ans[i]<<" ";
cout<<endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i=0;i<n;i++)
int main(){
int n, k;
cin >> n >> k;
vector<int> a(n);
vector<int> c(n,n);
rep(i,n){
cin >> a[i];
}
rep(j,k){
vector<int> d(n+1);
rep(i,n){
d[max(i-a[i],0)]++;
d[min(i+a[i]+1,n)]--;
}
vector<int> e(n,d[0]);
rep(i,n-1){
e[i+1]=e[i]+d[i+1];
}
a=e;
if (c==e){
break;
}
}
rep(i,n-1){
cout << a[i] << ' ';
}
cout << a[n-1] << endl;
return 0;
} | 1 | 48,308,319 |
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
#define ll long long
#define rep(i,n) for(ll i=0;i<(n);i++)
#define pll pair<ll,ll>
#define pq priority_queue
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define ios ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
#define lb(c,x) distance(c.begin(),lower_bound(all(c),x))
#define ub(c,x) distance(c.begin(),upper_bound(all(c),x))
using namespace std;
template<class T> inline bool chmax(T& a,T b){if(a<b){a=b;return 1;}return 0;}
template<class T> inline bool chmin(T& a,T b){if(a>b){a=b;return 1;}return 0;}
const ll mod=1e9+7;
int main()
{
string s;
cin >> s;
ll n=s.length();
vector<vector<ll>> dp(n+1,vector<ll>(2));
dp[0][0]=1;
for(ll i=0;i<n;i++){
{
if(s[i]=='1'){
dp[i+1][1]=dp[i][1]+dp[i][0];
}
else{
dp[i+1][1]=dp[i][1];
dp[i+1][0]=dp[i][0];
}
}
{
if(s[i]=='1'){
dp[i+1][1]+=(dp[i][1]*2)%mod;
dp[i+1][1]%=mod;
dp[i+1][0]+=(dp[i][0]*2)%mod;
dp[i+1][0]%=mod;
}
else{
dp[i+1][1]+=(dp[i][1]*2)%mod;
dp[i+1][1]%=mod;
}
}
}
ll ans=(dp[n][1]+dp[n][0])%mod;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < (ll)(n); ++i)
#define rep2(i, s, n) for (ll i = s; i < (ll)(n); i++)
#define repr(i, n) for (ll i = n; i >= 0; i--)
#define pb push_back
#define COUT(x) cout << (x) << "\n"
#define COUTF(x) cout << setprecision(15) << (x) << "\n"
#define ENDL cout << "\n"
#define DF(x) x.erase(x.begin())
#define ALL(x) x.begin(), x.end()
#define SZ(x) (ll) x.size()
#define SORT(x) sort(ALL(x))
#define REVERSE(x) reverse(ALL(x))
#define MAX(x, y, z) max(x, max(y, z))
#define MIN(x, y, z) min(x, min(y, z))
#define ANS cout << ans << "\n"
#define RETURN(x) \
cout << x << "\n"; \
return 0
clock_t CLOCK;
#define START_TIMER CLOCK = clock()
#define SHOW_TIMER cerr << "time: " << (ld)(clock() - CLOCK) / 1000000 << "\n"
#define init() \
cin.tie(0); \
ios::sync_with_stdio(false)
#define LINE cerr << "[debug] line: " << __LINE__ << "\n";
#define debug(x) cerr << "[debug] " << #x << ": " << x << "\n";
#define debugV(v) \
cerr << "[debugV] " << #v << ":"; \
rep(i, v.size()) cerr << " " << v[i]; \
cerr << "\n";
using namespace std;
using ll = long long;
using ld = long double;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
using mll = map<ll, ll>;
using qll = queue<ll>;
using P = pair<ll, ll>;
constexpr ll INF = 0x3f3f3f3f3f3f3f3f;
constexpr ld PI = 3.141592653589793238462643383279;
ll get_digit(ll x) {
return to_string(x).size();
}
ll gcd(ll x, ll y) {
return y ? gcd(y, x % y) : x;
}
ll lcm(ll a, ll b) {
return a / gcd(a, b) * b;
}
vector<P> factorize(ll n) {
vector<P> result;
for (ll i = 2; i * i <= n; ++i) {
if (n % i == 0) {
result.pb({i, 0});
while (n % i == 0) {
n /= i;
result.back().second++;
}
}
}
if (n != 1) {
result.pb({n, 1});
}
return result;
}
vll divisor(ll n) {
vll ret;
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) ret.push_back(n / i);
}
}
SORT(ret);
return (ret);
}
const ll mod = 1000000007;
ll dp[100005][2];
signed main() {
init();
string S;
cin >> S;
dp[0][0] = 1;
ll N = S.size();
rep(i, S.size()) {
if (S[i] == '0') {
dp[i + 1][0] = dp[i][0];
dp[i + 1][1] = dp[i][1];
} else {
dp[i + 1][1] = (dp[i][0] + dp[i][1]) % mod;
}
if (S[i] == '0') {
(dp[i + 1][1] += dp[i][1] * 2 % mod) %= mod;
} else {
(dp[i + 1][0] += dp[i][0] * 2 % mod) %= mod;
(dp[i + 1][1] += dp[i][1] * 2 % mod) %= mod;
}
}
ll ans = (dp[N][0] + dp[N][1]) % mod;
ANS;
return 0;
} | 1 | 997,483 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n, m;
cin>> n >> m;
string input;
vector<string>vec;
for(int i = 1; i <= n; i++)
{
cin>> input;
vec.push_back(input);
}
sort(vec.begin(),vec.end());
for(int i = 0; i < vec.size(); i++)
{
cout<< vec[i];
}
return 0;
} | #include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define vec vector<int>
#define map map<int,int>
#define scn(t) scanf("%d",&t);
#define lscn(t) scanf("%lld",&t);
#define mod 1000000007
#define rep(i,a,b) for(int i=a;i<b;i++)
#define endl "\n"
using namespace std;
const int N=1e5+5;
bool comp(string a,string b)
{
string ab=a+b;
string ba=b+a;
if(ab<ba)
return 1;
else
return 0;
}
int main()
{
int n;
scn(n);
int l;
scn(l);
vector<string> s;
rep(i,0,n)
{
string a;
cin>>a;
s.pb(a);
}
sort(s.begin(),s.end(),comp);
for(auto it: s)
cout<<it;
} | 1 | 48,184,741 |
#include<iostream>
main(){int y,m,d;for(std::cin>>d;std::cin>>y>>m>>d;printf("%d\n",196490-d))d+=195*--y+y/3*5+19*m+m/2+!(++y%3)*(m-1)/2;} | #define _USE_MATH_DEFINES
#include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <cfloat>
#include <climits>
#include <cstring>
#include <cmath>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> i_i;
typedef pair<ll, int> ll_i;
typedef pair<double, int> d_i;
typedef pair<ll, ll> ll_ll;
typedef pair<double, double> d_d;
struct edge { int u, v; ll w; };
ll MOD = 1000000007;
ll _MOD = 1000000009;
double EPS = 1e-10;
void hoge(int& y, int& m, int& d) {
d++;
int x = (y % 3 != 0 && m % 2 == 0) ? 19 : 20;
if (d <= x) return;
d = 1;
m++;
if (m <= 10) return;
m = 1;
y++;
}
int main() {
int n; cin >> n;
while (n--) {
int Y, M, D; cin >> Y >> M >> D;
int cnt = 0;
while (Y < 1000) {
hoge(Y, M, D);
cnt++;
}
cout << cnt << endl;
}
} | 1 | 80,227,647 |
#include <bits/stdc++.h>
using namespace std;
int main(){
string s;
cin >> s;
string t = "keyence";
if(s == t){
cout << "YES" << endl;
return 0;
}
int l = s.size();
bool ok = false;
for(int i = 0; i < l; i++){
for(int j = i; j < l; j++){
string ans = "";
for(int k = 0; k < l; k++){
if(k >= i && k <= j) continue;
ans += s.at(k);
}
if(ans == t) ok = true;
}
}
if(ok) cout << "YES" << endl;
else cout << "NO" << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
string s;
cin >> s;
string key = "keyence";
int n = s.size();
for (int i = 0; i <= n - 7; i++) {
if (i == 0) {
if (s == key) {
cout << "YES" << endl;
return 0;
}
continue;
}
for (int j = 0; j <= n - i; j++) {
string t;
for (int k = 0; k < n; k++) {
if (j <= k && k <= j + i - 1) continue;
t += s[k];
}
if (t == key) {
cout << "YES" << endl;
return 0;
}
}
}
cout << "NO" << endl;
} | 1 | 25,607,944 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define f(i,a,b) for(int i=a;i<=b;i++)
inline ll r() {
ll x=0,f=1;
char c=getchar();
while(c<'0'||c>'9')c=getchar();
if(c=='-')f=-1,c=getchar();
while(isdigit(c))x=x*10+c-'0',c=getchar();
return x*f;
}
#define d r()
ll n;
int main(){
n=d;
if(n>=400&&n<=599)cout<<8;
if(n>=600&&n<=799)cout<<7;
if(n>=800&&n<=999)cout<<6;
if(n>=1000&&n<=1199)cout<<5;
if(n>=1200&&n<=1399)cout<<4;
if(n>=1400&&n<=1599)cout<<3;
if(n>=1600&&n<=1799)cout<<2;
if(n>=1800&&n<=1999)cout<<1;
return 0;
} | #include <stdio.h>
#include <math.h>
#include <stdlib.h>
int main()
{
int n;
scanf("%d", &n);
if (n>=400 && n<=599) printf("8");
else if(n>=600 && n<=799) printf("7");
else if(n>=800 && n<=999) printf("6");
else if(n>=1000 && n<=1199) printf("5");
else if(n>=1200 && n<=1399) printf("4");
else if(n>=1400 && n<=1599) printf("3");
else if(n>=1600 && n<=1799) printf("2");
else if(n>=1800 && n<=1999) printf("1");
} | 1 | 72,214,112 |
#include<iostream>
using namespace std;
int main() {
ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
long long n,m;
cin >> n >>m;
cout << abs((n-2) * (m-2));
} | #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, m; cin >> n >> m;
if (n > m) swap(n, m);
long long ans;
ans = (n == 1) ? abs(m - 2) : (n - 2) * (m - 2);
cout << ans << '\n';
return 0;
} | 1 | 68,735,009 |
#include<bits/stdc++.h>
using namespace std;
const int n = 1e5+3;
char x[n];
int main(void){
char b;
cin>>b;
pair<char,char>x[2];
x[0]=make_pair('A','T');
x[1]=make_pair('C','G');
for(int i=0;i<2;i++)
{
if(x[i].first==b)
cout<<x[i].second<<endl;
else if(x[i].second==b)
cout<<x[i].first<<endl;
}
return 0;} | #include <iostream>
#include <vector>
#include <string>
#include <unordered_set>
#include <unordered_map>
#include <sstream>
#include <algorithm>
#include <cmath>
#include <map>
#include <set>
#include <numeric>
#include <iterator>
using namespace std;
namespace {
}
int main()
{
map<char, char> e{ { 'A', 'T' }, { 'T', 'A' }, { 'C', 'G' }, { 'G', 'C' } };
char b;
cin >> b;
cout << e[b] << endl;
return 0;
} | 1 | 40,101,441 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int MAX = 510000;
const int MOD = 998244353;
const int Inv2 = (MOD+1)/2;
signed main(){
int q,h,s,d,n;cin>>q>>h>>s>>d>>n;
h=min(2*q,h);s=min(2*h,s);d=min(d,2*s);cout<<(n/2)*d+(n%2)*s<<endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); ++i)
using ll = long long;
using P = pair<ll, ll>;
ll n;
int main() {
vector<ll> v(4);
rep (i, 4) {
cin >> v[i];
}
cin >> n;
n *= 4;
vector<ll> want(4, 0);
vector<P> vperL(4);
rep (i, 4) {
vperL[i] = make_pair(v[i] * 12 / pow(2, i), i);
}
ll ans = 0;
sort(vperL.begin(), vperL.end());
rep (i, 4) {
ans += (n/(ll)pow(2, vperL[i].second)) * v[vperL[i].second];
n %= (ll)pow(2, vperL[i].second);
}
cout << ans << endl;
return 0;
} | 1 | 64,613,133 |
#include <stdio.h>
int main () {
int n, a, b, dig1, dig2, dig3, dig4, dig5;
int sum = 0;
scanf("%d %d %d", &n, &a, &b);
for(int i = 1; i <= n; i++) {
dig1 = i%10;
dig2 = (i/10)%10;
dig3 = (i/100)%10;
dig4 = (i/1000)%10;
dig5 = (i/10000)%10;
if ((dig1+dig2+dig3+dig4+dig5) >= a && (dig1+dig2+dig3+dig4+dig5) <= b) {
sum += i;
}
}
printf("%d", sum);
return 0;
} | #include <iostream>
#include <string>
using namespace std;
int main() {
int N;
int A;
int B;
int sum = 0;
string n_str;
cin >> N >> A >> B;
for (int i = 1; i <= N; i++) {
n_str = to_string(i);
int tmp = 0;
for (int j = 0; j < n_str.size(); j++) {
tmp = tmp + (int)n_str[j] - 48;
}
if (tmp >= A && tmp <= B){
sum = sum + i;
}
}
cout << sum << endl;
return 0;
} | 1 | 91,590,577 |
#include <iostream>
#include <map>
#include <algorithm>
#include <vector>
#include <iomanip>
#include <sstream>
#include <cmath>
#include <math.h>
#include <string>
#include <set>
#include <queue>
#include <utility>
using namespace std;
typedef long long ll;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int a[n];
for( int i = 0 ; i < n ; i++ ) cin >> a[i];
sort( a , a + n );
cout << abs( a[n - 1] - a[0] );
} | #include <iostream>
#include <string>
#include <algorithm>
#include <cmath>
#include <deque>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <iomanip>
#include <bitset>
#include <set>
#include <map>
#include <stdio.h>
#include <numeric>
#include <cstring>
#define rep(i,n) for (int i = 0; i < (n); i++)
#define rep1(i,n) for (int i = 1; i < (n); i++)
#define FOR(i,a,b) for (int i=(a); i < (b); i++)
#define MOD 1000000007
using namespace std;
using ll = long long;
using PII = pair<int, int>;
using PLL = pair<ll, ll>;
const int INF = numeric_limits<int>::max();
const ll INFL = numeric_limits<ll>::max();
long long mod(long long val, long long m) {
long long res = val % m;
if (res < 0) res += m;
return res;
}
long long gcd(ll a, ll b)
{
if (a % b == 0) {
return b;
} else {
return gcd(b, a % b);
}
}
long long lcm(ll a, ll b)
{
return a / gcd(a, b) * b ;
}
ll factorial(ll n) {
ll res = 1;
for (ll i = 1; i <= n; i++) {
res *= i;
}
return res;
}
bool fn_is_prime(ll n) {
for (ll i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return n != 1;
}
bool isOK(int index, int key, vector<ll>& a) {
if (a[index] >= key) return true;
else return false;
}
int binary_search(int key, vector<ll>& a) {
int ng = -1;
int ok = a.size();
while (abs(ok - ng) > 1) {
int mid = (ok + ng) / 2;
if (isOK(mid, key, a)) ok = mid;
else ng = mid;
}
return ok;
}
int main()
{
int n; cin >> n;
vector<ll> a(n);
rep(i,n) cin >> a[i];
sort(a.begin(), a.end());
cout << a[n-1] - a[0] << endl;
} | 1 | 28,381,164 |
#include <bits/stdc++.h>
using namespace std;
#define endl "\n"
#define filein freopen("input.txt", "r", stdin);freopen("output.txt", "w", stdout);
void fun1(int* a,int* b){
int sum=*a+*b;
int dif=abs(*a-*b);
*a=sum;
*b=dif;
}
int main() {
int k;
cin>>k;
long long a[100005]={0,1,2,3,4,5,6,7,8,9};
int count=10;
int index=1;
while (count<100001){
long long t=a[index]%10;
for (long long i = t-1; i <=t+1 ; ++i) {
if (i>-1 && i<10)
a[count++]=a[index]*10+i;
}
index++;
}
cout<<a[k];
} | #include <iostream>
#include <queue>
using namespace std;
int main(){
int K;
cin >> K;
queue<long long> q;
for (int i = 1; i < 10; i++){
q.push(i);
}
long long x;
for (int i = 0; i < K; i++){
x = q.front();
q.pop();
if(x%10 != 0){
q.push(10*x + x%10 - 1);
}
q.push(10*x + x%10);
if(x%10 != 9){
q.push(10*x + x%10 + 1);
}
}
printf("%lld\n", x);
} | 1 | 27,478,544 |
#include<string>
#include<iostream>
#include<stdio.h>
using namespace std;
int main(){
string str1,str2,e,v;
int n,m,size;
char ch[1]={};
while(1)
{
cin>>str1;
ch[0]=str1[0];
if(ch[0]=='-')break;
size=str1.size();
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%d",&m);
str2=str1.substr(0,m);
e=str1.erase(0,m);
str1=e+str2;
}
cout<<str1<<endl;
}
return 0;
} | #include<iostream>
#include<vector>
#include<string.h>
using namespace std;
int main()
{
vector<char> s;
char ch[201];
int m;
while(cin>>ch&&ch[0]!='-')
{
for(int i=0;i<strlen(ch);i++)
{
s.push_back(ch[i]);
}
cin>>m;
int h;
for(int i=0;i<m;i++)
{
cin>>h;
for(int i=0;i<h;i++)
{
s.push_back(s[0]);
s.erase(s.begin());
}
}
for(int i=0;i<s.size();i++)
{
cout<<s[i];
}
cout<<endl;
s.clear();
}
return 0;
} | 1 | 38,635,941 |
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for(ll i = (a); i < (b); ++i)
#define rep(i, n) for(ll i = 0; i < (ll)(n); i++)
#define all(x) (x).begin(), (x).end()
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<ll> VLL;
typedef vector<VLL> VVLL;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
inline ll toLL(string s) {
ll v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
const int mod = 1000000007;
struct mint {
ll x;
mint() : x(0) {}
mint(ll x) : x((x % mod + mod) % mod) {}
mint &fix() {
x = (x % mod + mod) % mod;
return *this;
}
mint operator-() const { return mint(0) - *this; }
mint &operator+=(const mint &a) {
if((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint &a) {
if((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint &a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint &a) const { return mint(*this) += a; }
mint operator-(const mint &a) const { return mint(*this) -= a; }
mint operator*(const mint &a) const { return mint(*this) *= a; }
bool operator<(const mint &a) const { return x < a.x; }
bool operator==(const mint &a) const { return x == a.x; }
};
istream &operator>>(istream &i, mint &a) {
i >> a.x;
return i;
}
ostream &operator<<(ostream &o, const mint &a) {
o << a.x;
return o;
}
typedef vector<mint> vm;
typedef vector<vm> vvm;
long long modPow(long long x, long long n) {
if(n == 0)
return 1;
if(n % 2 == 0) {
long long sqrtX = modPow(x, n / 2);
return sqrtX * sqrtX % mod;
} else {
return x * modPow(x, n - 1) % mod;
}
}
const int MAX = 510000;
const int MOD = 1000000007;
long long fac[MAX];
long long finv[MAX];
long long inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for(int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long COM(int n, int k) {
if(n < k)
return 0;
if(n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
long long perm(long long a, long long b) {
if(a < b)
return 0;
long long tmp = finv[a - b] % MOD;
return tmp * fac[a] % MOD;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n, k;
cin >> n >> k;
VLL sum(k + 1, 0);
vm gcdCnt(k + 1, 0);
mint ans = 0;
FOR(i, 1, k + 1) { sum[i] = k / i; }
for(int i = k; i >= 1; i--) {
gcdCnt[i] = modPow(sum[i], n);
ll x = 2;
while(i * x <= k) {
gcdCnt[i] -= gcdCnt[i * x];
x++;
}
ans += (mint)i * gcdCnt[i];
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define S second
#define F first
#define pb push_back
#define all(c) (c).begin(),(c).end()
#define rall(c) (c).rbegin(),(c).rend()
#define lb lower_bound
#define si(c) (int)((c).size())
#define lcm(a, b) (a * (b / __gcd(a,b)))
#define inf (long long)(1e15)
#define mp make_pair
#define time(s) (double(clock()-s)/double(CLOCKS_PER_SEC))
#define debug(args...) _F(#args, args)
#define vi std::vector<int>
#define pii pair<int, int>
#define vpi vector<pii>
clock_t start;
mt19937_64 rng(chrono::system_clock::now().time_since_epoch().count());
template<typename T> void _F(const char *name, T arg1){
cerr << name << " = " << arg1 << endl;
}template<typename T, typename... Args> void _F(const char *names, T arg1, Args... args){
const char *name = strchr(names, ',');
cerr.write(names, name-names) << " = " << arg1 << endl;
_F(name+2, args...);
}
template<typename T1, typename T2> istream& operator>>(istream& in, pair<T1, T2> &q){
in >> q.F >> q.S; return in;
}template<typename T1, typename T2> ostream& operator<<(ostream& out, pair<T1, T2> &q){
out << q.F << " " << q.S; return out;
}template< typename T1, typename T2> pair<T1, T2> operator+(pair<T1, T2> p1, pair<T1, T2> p2){
return {p1.F+p2.F, p1.S+p2.S};
}template< typename T1, typename T2> pair<T1, T2> operator-(pair<T1, T2> p1, pair<T1, T2> p2){
return {p1.F-p2.F, p1.S-p2.S};
}
const int mod = 1e9+7;
int modPow(int x, int p){
int ans = 1;
while(p){
if(p&1)ans = (ans*x)%mod;
x = (x*x)%mod;
p >>= 1;
}
return ans;
}
void solve(){
int n, k;
cin >> n >> k;
int ans[k+1];
int res = 0;
memset(ans, 0, sizeof(ans));
for(int i = k; i >= 1; i--){
for(int j = 2*i; j <= k; j += i)
ans[i] = (ans[i]-ans[j]+mod)%mod;
ans[i] = (ans[i]+modPow(k/i, n))%mod;
res = (res+ans[i]*i)%mod;
}
cout << res << endl;
}
signed main(){
ios_base::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
int t = 1;
start = clock();
cout << fixed << setprecision(12);
for(int i = 1; i <= t; ++i){
solve();
}
return 0;
} | 1 | 71,330,034 |
#include <bits/stdc++.h>
#include <atcoder/all>
using namespace std;
using namespace atcoder;
using ll = long long;
using ld = long double;
#define fi first
#define se second
#define m_p make_pair
#define p_b push_back
#define e_b emplace_back
#define all(x) (x).begin(),(x).end()
#define uniq(x) ((x).erase(unique(all(x)),(x).end()))
#define sz(x) ((int)(x).size())
#define REP(i,m,n) for(int i=(int)(m);i<(int)(n);i++)
#define rep(i,n) REP(i,0,n)
#ifdef LOCAL
#define debug(x) cerr<<"LINE"<<__LINE__<<" : "<<#x<<" = "<<(x)<<endl
#define debug_vec(x) cerr<<"LINE"<<__LINE__<<" : "<<#x<<" = ";\
rep(i,sz(x)){cerr<<x[i]<<" ";}cerr<<endl
#define debug_mat(x) cerr<<"LINE"<<__LINE__<<" : "<<#x<<" = "<<endl;\
rep(i,sz(x)){rep(j,sz(x[i])){cerr<<x[i][j]<<" ";}cerr<<endl;}cerr<<endl
#else
#define debug(x) void(0)
#define debug_vec(x) void(0)
#define debug_mat(x) void(0)
#endif
template<class T> bool chmax(T &a,T b){if(a<b){a=b;return true;}return false;}
template<class T> bool chmin(T &a,T b){if(a>b){a=b;return true;}return false;}
int main(){
ios_base::sync_with_stdio(false);cin.tie(0);
int N,Q;
cin >> N >> Q;
dsu d(N);
rep(_,Q){
int t,u,v;
cin >> t >> u >> v;
if(t==0){
d.merge(u,v);
}
else if(t==1){
if(d.same(u,v)) cout << 1 << endl;
else cout << 0 << endl;
}
}
return 0;
} | #include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <cstdio>
#include <limits>
#include <vector>
#include <cstdlib>
#include <numeric>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <functional>
#include <iomanip>
#include <unordered_map>
#include <memory.h>
#include <cstring>
#include <fstream>
#include <stdio.h>
#include <stdlib.h>
#include <cassert>
#include <atcoder/dsu>
using namespace std;
using namespace atcoder;
int main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
int n, q;
cin >> n >> q;
dsu uf(n + 1);
for (int i = 0; i < q; i++)
{
int t, u, v;
cin >> t >> u >> v;
if (t == 0)
{
uf.merge(u, v);
}
else
{
cout << uf.same(u, v) << '\n';
}
}
return 0;
} | 1 | 25,955,849 |
#include<bits/stdc++.h>
#define dbug printf("I am here\n");
#define Fast ios_base::sync_with_stdio(false); cin.tie(0);
#define vs v.size()
#define ss s.size()
#define sot(v) sort(v.begin(),v.end())
#define rev(v) reverse(v.begin(),v.end())
#define ii pair<int, int>
#define int long long
#define ull unsigned long long
#define pb push_back
#define mpp make_pair
#define Okay 0
#define pi 3.14159
const int inf = 1e6;
const int cont = 1e18;
using namespace std;
bool graph[10][10];
void solve(){
int n, m;
cin>>n>>m;
for(int i=0; i<m; i++){
int a, b;
cin>>a>>b;
a--, b--;
graph[a][b] = graph[b][a] = true;
}
vector<int>order(n);
for(int i=0; i<n; i++)order[i] = i;
int ans = 0;
do{
if(order[0] != 0)break;
bool ok = true;
for(int i=0; i<n-1; i++){
int from = order[i];
int to = order[i+1];
if(graph[from][to] == 0)ok = false;
}
if(ok)ans++;
}while(next_permutation(order.begin(), order.end()));
cout<<ans<<endl;
}
int32_t main() {
Fast;
int tst;
solve();
return Okay;
} | #include <bits/stdc++.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <tuple>
typedef unsigned long long ull;
typedef long long ll;
#define mod 1000000007
#define REP(i, n) for (unsigned long long i = 0; i < (n); i++)
#define FOR(i, a, b) for (unsigned long long i = (a); i <= (b); i++)
#define FORD(i, a, b) for (unsigned long long i = (a); i >= (b); i--)
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define mt make_tuple
#define debug(x) cout << #x << '=' << (x) << endl;
#define debugp(x) cout << #x << "= {" << (x.first) << ", " << (x.second) << "}" << endl;
#define debug2(x, y) cout << "{" << #x << ", " << #y << "} = {" << (x) << ", " << (y) << "}" << endl;
#define debugv(v) \
cout << #v << " : "; \
for (auto x : v) \
cout << x << ' '; \
cout << endl;
#define all(x) x.begin(), x.end()
using namespace std;
const int nmax = 8;
bool graph[nmax][nmax];
int dfs(int v, int N, bool visited[nmax])
{
bool all_visited = true;
for (int i = 0; i < N; ++i)
{
if (visited[i] == false)
all_visited = false;
}
if (all_visited)
{
return 1;
}
int ret = 0;
for (int i = 0; i < N; ++i)
{
if (graph[v][i] == false)
continue;
if (visited[i])
continue;
visited[i] = true;
ret += dfs(i, N, visited);
visited[i] = false;
}
return ret;
}
int main(void)
{
int N, M;
cin >> N >> M;
for (int i = 0; i < M; ++i)
{
int A, B;
cin >> A >> B;
graph[A - 1][B - 1] = graph[B - 1][A - 1] = true;
}
bool visited[nmax];
for (int i = 0; i < N; ++i)
{
visited[i] = false;
}
visited[0] = true;
cout << dfs(0, N, visited) << endl;
return 0;
} | 1 | 93,209,040 |
#include <iostream>
#include <utility>
#include <map>
#include <vector>
#include <algorithm>
#include <queue>
#include <math.h>
#include <stack>
#include <set>
#include <deque>
#include <cmath>
using namespace std;
typedef long long ll;
ll mod = 1e9+7;
#define rep(i,n) for(int i = 0; i < (n); ++i)
int main() {
string s;
cin >> s;
vector<bool> flg(26, false);
int n = s.size();
rep(i, n) flg[s[i] - 'a'] = true;
rep(i, 26) {
if (!flg[i]) {
cout << (char)(i + 'a') << endl;
return 0;
}
}
cout << "None" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for(int i = 0; i < (n); i++)
#define REPS(i, n) for(int i = 1; i <= (n); i++)
#define RREP(i, n) for(int i = (n)-1; i >= 0; i--)
#define RREPS(i, n) for(int i = (n); i > 0; i--)
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define YES cout << "YES" << endl
#define Yes cout << "Yes" << endl
#define yes cout << "yes" << endl
#define NO cout << "NO" << endl
#define No cout << "No" << endl
#define no cout << "no" << endl
using ll = long long;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vs = vector<string>;
using vb = vector<bool>;
using vvi = vector<vi>;
using vvl = vector<vl>;
const int MOD = 1e9 + 7;
const int INF = 1e9 + 7;
const ll INFL = 1e18;
const double PI = 3.141592653589793;
const double EPS = 1e-9;
template<class T> bool chmax(T &a, const T &b) { if(a < b) { a = b; return true; } return false; }
template<class T> bool chmin(T &a, const T &b) { if(a > b) { a = b; return true; } return false; }
signed main()
{
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
string s; cin >> s;
vb v(26, false); REP(i, (int)s.length()) v[s[i]-'a'] = true;
REP(i, 26)
{
if(v[i] == false)
{
cout << char(i + 'a') << endl;
return 0;
}
}
cout << "None" << endl;
} | 1 | 77,532,732 |
#include <bits/stdc++.h>
using namespace std;
string s;
map<int,int>mp, cnt;
int main(){
cin>>s;
int cur = 0, x;
for(int i = 0; i < s.size(); ++i){
cur ^= (1 << (s[i] - 'a'));
if(cur == 0){
if(i == s.size() - 1){
cout<<1<<endl;return 0;
}
}
else{
int x = 1e8;
if(cnt[cur] > 0){
x = min(x, cnt[cur]);
}
for(int j = 0; j < 26; ++j){
if((cur ^ (1 << j)) == 0){ x = 1;break;}
else{
if(cnt[cur ^ (1 << j)] > 0) x = min(x, cnt[cur ^ (1 << j)] + 1);
else{
x = min(x, cnt[cur ^ (1 << (s[i] - 'a'))] + 1);
}
}
}
cnt[cur] = x;
if(i == s.size() - 1){
cout<<x<<endl;return 0;
}
}
}
} | #include <bits/stdc++.h>
using namespace std;
#define LL long long
#define LD long double
#define SC(t,x) static_cast<t>(x)
#define AR(t) vector < t >
#define PII pair < int, int >
#define PLL pair < LL, LL >
#define PIL pair < int, LL >
#define PLI pair < LL, int >
#define MP make_pair
#define PB push_back
#define PF push_front
#define POB pop_back
#define POF pop_front
#define PRF first
#define PRS second
#define INIT(ar,val) memset ( ar, val, sizeof ( ar ) )
#define lp(loop,start,end) for ( int loop = start; loop < end; ++loop )
#define lpd(loop,start,end) for ( int loop = start; loop > end; --loop )
#define lpi(loop,start,end) for ( int loop = start; loop <= end; ++loop )
#define lpdi(loop,start,end) for ( int loop = start; loop >= end; --loop )
#define qmax(a,b) (((a)>(b))?(a):(b))
#define qmin(a,b) (((a)<(b))?(a):(b))
#define qabs(a) (((a)>=0)?(a):(-(a)))
const int INF = 0x3fffffff;
const int SINF = 0x7fffffff;
const long long LINF = 0x3fffffffffffffff;
const long long SLINF = 0x7fffffffffffffff;
const int MINF = 0x3f3f3f3f;
const int MAXN = 200007;
const int BASE = 26;
const int MAXS = ( 1 << BASE ) + 7;
int n;
char s[MAXN];
int sta[MAXN];
int pre[MAXS];
int dp[MAXN];
void init ();
void input ();
void work ();
int main ()
{
init ();
input ();
work ();
}
void init ()
{
ios::sync_with_stdio ( false );
}
void input ()
{
scanf ( "%s", s+1 );
}
void work ()
{
n = strlen ( s+1 );
lpi ( i, 1, n ) sta[i] = sta[i-1] ^ ( 1 << ( s[i] - 'a' ) );
INIT ( pre, MINF );
INIT ( dp, MINF );
dp[0] = 0;
pre[0] = 0;
lpi ( i, 1, n ) {
lp ( j, 0, BASE ) {
dp[i] = qmin ( dp[i], pre[sta[i]^( 1<<j )] + 1 );
}
dp[i] = qmin ( dp[i], pre[sta[i]] + 1 );
pre[sta[i]] = qmin ( pre[sta[i]], dp[i] );
}
cout << dp[n] << endl;
} | 1 | 20,440,816 |
#include <bits/stdc++.h>
#include <chrono>
#include <math.h>
using namespace std;
using ll = long long;
using ld = long double;
using namespace std::chrono;
#define fo(i,z,n) for(int i = z;i<n;i++)
#define Fo(i,z,n) for(ll i = z;i<n;i++)
#define INT_BITS 32
#define mod 1000000007
#define vi vector<int>
#define vll vector<ll>
#define vvi vector<vector<int> >
#define vvl vector<vector<ll> >
#define pb push_back
#define f first
#define int long long
#define float long double
#define all(c) (c).begin(), (c).end()
#define endl '\n'
int32_t main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
int n;
cin >> n;
int a[n];
fo(i,0,n)cin >> a[i];
map<int,int> m;
fo(i,0,n){
m[a[i]]++;
}
vi arr;
for(auto it = m.begin(); it != m.end();it++){
if(it->second == 1)arr.pb(it->first);
}
n = arr.size();
if(n == 0){
cout << 0 << endl;
}
else{
int mq = 1e6+1;
vi dp(mq,1);
for(auto it = m.begin(); it != m.end();it++){
if(it->second > 1){arr.pb(it->first);
dp[it->first] = 0;}
}
sort(all(arr));
n = arr.size();
int ma = arr[n-1];
if(0){}
else{
fo(i,0,n){
for(int j = arr[i]*2; j <= ma;j += arr[i]){
dp[j] = 0;
}
}
int count = 0;
fo(i,0,n){
if(dp[arr[i]])count++;
}
cout << count << endl;
}
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
map<int,int>mp;
int cnt=0;
void Divisors(int n)
{
vector<int>v;
for (int i=1; i<=sqrt(n); i++)
{
if (n%i == 0)
{
if (n/i == i)
v.push_back(i);
else
{
v.push_back(i);
v.push_back(n/i);
}
}
}
sort(v.begin(),v.end());
for(int i=0; i<v.size(); i++)
{
if(mp[v[i]])
{
if(v[i]==n)
{
if(mp[n]>1)
{
cnt++;
break;
}
}
else
{
cnt++;
break;
}
}
}
}
int main()
{
int n, x, i;
cin >> n;
int a[n+5];
for(int i=0; i<n; i++)
{
cin>>a[i];
mp[a[i]]++;
}
for (int i=0; i<n; i++)
{
Divisors(a[i]);
}
cout<<n-cnt<<endl;
} | 1 | 14,443,177 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
if(n%2==0) --n;
cout << n/2 << endl;
} | #include<bits/stdc++.h>
#define all(vc) vc.begin(),vc.end()
#define ll long long
#define MIN(a,b) ((a)<(b)) ? (a) : (b)
#define EVEN(a) (a)%2==0 ? 1 : 0
#define fi first
#define se second
#define speed ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define DEBUG
#pragma GCC optimize("Ofast")
#pragma GCC target ("avx2")
#pragma GCC optimization ("O3")
#pragma GCC optimization ("unroll-loops")
#define mxel(vc) max_element(vc.begin(),vc.end())
#define mnel(vc) min_element(vc.begin(),vc.end())
using namespace std;
int MOD = 1e9+7;
long long int ji[300005];
long long int brut = 1e18;
int Search_Binary (int arr[], int left, int right, int key)
{
int midd = 0;
while (1)
{
midd = (left + right) / 2;
if (key < arr[midd]){
right = midd - 1;
}else if (key > arr[midd]){
left = midd + 1;
}else{
return midd;
}
if (left > right){
return -1;
}
}
}
int fDig(int i)
{
int k;
do
{
k=i;
i/=10;
}while(i);
return k;
}
int gcd (int a, int b) {
while (b) {
a %= b;
swap (a, b);
}
return a;
}
int lcm (int a, int b) {
return a / gcd (a, b) * b;
}
int to_int(string s){
int x;
stringstream geek(s);
geek >> x;
return x;
}
int prim_const( int x){
vector<bool> prime(x, true);
prime[0] = prime[1] = false;
for (int i=2; i * i<=x; ++i){
if (prime[i]){
if (i * 1ll * i <= x){
for (int j=i*i; j<=x; j+=i){
prime[j] = false;
}
}
}
}
if (prime[x] == true){
return 1;
}else{
return 0;
}
}
void solve(int n){
if(n % 2 == 0){
cout << (n/2)-1;
}else{
cout << (n/2);
}
}
long long int j;
long long int drujba=0;
int main()
{
cin.tie(0);cout.tie(0);
int n;
cin >>n;
solve(n);
cerr << "\nTime elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
} | 1 | 67,204,743 |
#include<math.h>
#include <bits/stdc++.h>
#include <algorithm>
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define ll long long int
#define py printf("Yes\n")
#define pn printf("No\n")
#define in cin>>
using namespace std;
int INF = 1001001001;
int main()
{
string s,t;
in s>>t;
sort(s.begin(), s.end());
sort(t.begin(), t.end(), greater<int>());
if(s<t)py;
else pn;
} | #include<bits/stdc++.h>
using namespace std;
int comp(const char &a,const char &b)
{
return a>b;
}
int main()
{
string s;
string t;
cin>>s>>t;
sort(s.begin(),s.end());
sort(t.begin(),t.end(),comp);
if(s<t)cout<<"Yes"<<endl;
else cout<<"No"<<endl;
return 0;
} | 1 | 50,466,445 |
#include<bits/stdc++.h>
using namespace std;
#define debug(x) cout<<#x<<" :"<<x<<endl;
#define ff first
#define ss second
#define ar array
#define int long long
#define ld long double
#define pb push_back
#define mp make_pair
#define pii pair<int,int>
#define vi vector<int>
#define mii map<int,int>
#define pqb priority_queue<int>
#define pqs priority_queue<int,vi,greater<int> >
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
#define mod 1000000007
#define inf 1e18
#define ps(x,y) fixed<<setprecision(y)<<x
#define mk(arr,n,type) type *arr=new type[n];
#define w(x) int x; cin>>x; while(x--)
#define f(i,n) for(int i=0;i<n;i++)
#define MOD 1000000007
#define pi 3.14159265
#define umii unordered_map<int,int>
#define umci unordered_map<char,int>
#define umsi unordered_map<string,int>
void k_007()
{
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("ip1.txt", "r", stdin);
freopen("op1.txt", "w", stdout);
#endif
}
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b)
{
return (a.second < b.second);
}
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int prime(int n) {
int flag = 1;
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {flag = 0; break;}
}
return flag;
}
int power(int x, int y)
{
if (y == 0)
return 1;
else if (y % 2 == 0)
return ((power(x, y / 2) % MOD) * ( power(x, y / 2) % MOD)) % MOD;
else
return ((x % MOD) * (power(x, y / 2) % MOD) * (power(x, y / 2) % MOD)) % MOD;
}
int lcm(int a, int b)
{
return (a * b) / gcd(a, b);
}
int32_t main()
{
k_007();
string s, t;
int n;
cin >> n;
cin >> s >> t;
for (int i = 0; i < n; i++)
{
cout << s[i] << t[i];
}
} | #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define printInt(a) printf("%d\n", a)
#define printll(a) printf("%lld\n", a)
#define printYes() printf("Yes\n")
#define printNo() printf("No\n")
#define scanll(a) scanf("%lld", &a)
#define scanInt(a) scanf("%d", &a)
#define scan2Int(a, b) scanf("%d %d", &a, &b)
#define scan3Int(a, b, c) scanf("%d %d %d", &a, &b, &c)
#define scan4Int(a, b, c, d) scanf("%d %d %d %d", &a, &b, &c, &d)
typedef long long ll;
const int INF = 1001001001;
using namespace std;
int main() {
int n;
scanInt(n);
char s[n+1], t[n+1];
scanf("%s %s", s, t);
rep(i, n) {
printf("%c", s[i]);
printf("%c", t[i]);
}
printf("\n");
return 0;
} | 1 | 13,665,097 |
#include <iostream>
#include <string>
#include <math.h>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < n; i++)
ll func(int num, int cnt){
ll ans = 1;
rep(i, cnt) ans *= num;
return ans;
}
int main(){
int N, P;
cin >> N >> P;
vector<int> A(N);
rep(i, N) cin >> A[i];
int odd_cnt = 0;
rep(i, N) if(A[i] % 2 == 1) odd_cnt++;
if(odd_cnt == 0){
if(P == 1) cout << 0 << endl;
if(P == 0) cout << func(2, N) << endl;
}else{
cout << func(2, N-1) << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define repr(i,n) for(int i = (int)(n); i >= 0; i--)
#define all(v) v.begin(),v.end()
typedef long long ll;
int main(){
ll N,P;
cin >> N >> P;
vector<ll> A(N);
rep(i,N){
cin >> A[i];
}
ll odd = 0;
ll even = 0;
rep(i,N){
if (A[i] % 2 == 0) even++;
else odd++;
}
vector<ll> num(52);
num[0] = 1;
for (ll i = 0; i < 51; i++){
num[i + 1] = num[i] * 2;
}
vector<vector<ll> > pascal(52, vector<ll> (52));
pascal[0][0] = 1;
pascal[1][0] = 1;
pascal[1][1] = 1;
for (ll i = 1; i <= 51; i++){
pascal[i][0] = 1;
pascal[i][i] = 1;
}
for (ll i = 2; i <= 51; i++){
for (ll j = 1; j < i; j++){
pascal[i][j] = pascal[i - 1][j] + pascal[i - 1][j - 1];
}
}
if (P == 0){
ll ans = 0;
ll pre = num[even];
for (ll i = 0; i <= odd; i += 2){
ans += (pre * pascal[odd][i]);
}
cout << ans << endl;
}
else{
ll ans = 0;
ll pre = num[even];
for (ll i = 1; i <= odd; i += 2){
ans += (pre * pascal[odd][i]);
}
cout << ans << endl;
}
} | 1 | 82,004,021 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int R;
cin >> R;
if(R < 1200) {
cout << "ABC\n";
} else if(R<2800) {
cout << "ARC\n";
} else {
cout << "AGC\n";
}
return 0;
} | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define mfill(x,y) memset(x,y,sizeof(x))
#define all(v) v.begin(), v.end()
#define y0 y12345
#define y1 y54321
#ifdef LOCAL
#define debug(...) fprintf(stderr,__VA_ARGS__)
#else
#define debug(...) 42
#endif
using ul = unsigned long;
using ll = long long;
using P = pair<int, int>;
using vint = vector<int>;
template<class T>bool chmax(T &a, const T &b){if(a<b){a=b;return 1;}return 0;}
template<class T>bool chmin(T &a, const T &b){if(a>b){a=b;return 1;}return 0;}
vint dx = {-1, 0, 1, 0}, dy = {0, -1, 0, 1};
vint dx8 = {-1, -1, -1, 0, 1, 1, 1, 0}, dy8 = {-1, 0, 1, 1, 1, 0, -1, -1};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
debug("debug test\n");
int n,m;
cin>>n;
if(n < 1200){
cout << "ABC"<< endl;
}else if(n < 2800){
cout << "ARC"<< endl;
}else{
cout << "AGC"<< endl;
}
return 0;
} | 1 | 80,726,651 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for (int i = 0; i < (n); ++i)
int main(){
int n;
int ans=0;
std::cin >> n;
for (int i = 1; i <=n ; i+=2) {
int temp=i;
int na=0;
for (int j = 1; j <= i ; j++) {
if(temp%j==0){na++;}
}
if(na==8)ans++;
}
std::cout << ans << '\n';
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
const int MOD = (int)1e9 + 7;
const double PI = 3.14159265358979323846;
template <class T, class U>
void chmin(T& t, const U& u) {
if (t > u) t = u;
}
template <class T, class U>
void chmax(T& t, const U& u) {
if (t < u) t = u;
}
int main(void) {
int N;
cin >> N;
int res = 0;
for (int i = 1; i <= N; i += 2) {
int cnt = 0;
for (int j = 1; j <= i; j++) {
if (i % j == 0) ++cnt;
}
if (cnt == 8) ++res;
}
cout << res << endl;
return 0;
} | 1 | 83,345,796 |
#include <iostream>
using namespace std;
int N;
int M;
int main(){
cin >> N >> M;
cout << (N * (N - 1) / 2) + (M * (M - 1) / 2);
} | #include <bits/stdc++.h>
#define mod 1000000007
#define INF LLONG_MAX
#define ll long long
#define ln cout<<endl
#define Yes cout<<"Yes"<<endl
#define NO cout<<"NO"<<endl
#define YES cout<<"YES"<<endl
#define No cout<<"No"<<endl
#define REP(i,m,n) for(ll i=(ll)(m);i<(ll)(n);i++)
#define rep(i,n) REP(i,0,n)
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
using namespace std;
ll dx[4]={1,0,-1,0};
ll dy[4]={0,1,0,-1};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll a,b,c,d,m,n,maxi=0,f=0,mini=INF,sum=0;
string str;
ll k;
ll w,x;
cin>>a>>b;
cout<<a*(a-1)/2+b*(b-1)/2<<endl;
return 0;
} | 1 | 7,489,396 |
#include <iostream>
#include <cstdio>
#include <cmath>
#include <ctime>
#include <cstdlib>
#include <cassert>
#include <vector>
#include <list>
#include <stack>
#include <queue>
#include <deque>
#include <map>
#include <set>
#include <bitset>
#include <string>
#include <algorithm>
#include <utility>
#define llint long long
#define inf 1e18
#define rep(x, s, t) for(llint (x) = (s); (x) < (t); (x)++)
#define Rep(x, s, t) for(llint (x) = (s); (x) <= (t); (x)++)
#define chmin(x, y) (x) = min((x), (y))
#define chmax(x, y) (x) = max((x), (y))
using namespace std;
typedef pair<llint, llint> P;
llint n, m;
llint a[100005], b[100005];
P p[100005];
int main(void)
{
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for(int i = 1; i<= n; i++){
cin >> a[i] >> b[i];
p[i] = P(a[i], i);
}
sort(p+1, p+n+1);
llint ans = 0, rem = m;
for(int i = 1; i <= n; i++){
if(rem <= 0) break;
llint id = p[i].second;
llint x = min(rem, b[id]);
ans += x * a[id], rem -= x;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(void){
long long N,M;cin>>N>>M;
long long A[N],B[N];
vector<pair<long long,long long>>C(N);
for(int i=0;i<N;i++){
cin>>A[i]>>B[i];
C[i].first=A[i];
C[i].second=B[i];
}
sort(C.begin(),C.end());
long long ans=0;
for(long long i=0;i<N;i++){
ans+=min(C[i].second,M)*C[i].first;
M-=C[i].second;
if(M<=0){
break;
}
}
cout<<ans<<endl;
return 0;
} | 1 | 32,286,726 |
#include <array>
#include <vector>
#include <deque>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <string>
#include <algorithm>
#include <numeric>
#include <functional>
#include <iterator>
#include <tuple>
#include <utility>
#include <limits>
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cstdint>
#include <cassert>
using namespace std;
#define FOR(i, start, end) for(int i = (start); i < (end); ++i)
#define REP(i, n) FOR(i, 0, n)
int main()
{
int n;
cin >> n;
int mat[100][100];
REP(i, n) {
REP(j, n) {
mat[i][j] = 0;
}
}
REP(_, n) {
int u, k;
cin >> u >> k;
REP(_, k) {
int v;
cin >> v;
mat[u-1][v-1] = 1;
}
}
REP(i, n) {
REP(j, n) {
cout << mat[i][j];
cout << (j == n-1 ? '\n' : ' ');
}
}
return 0;
} | #include<iostream>
#include<vector>
using namespace std;
int main(){
int n;
cin >> n;
vector<vector<int> > a(n + 1, vector<int>(n + 1, 0));
for (int i = 1; i <= n; i++) {
int u, k;
cin >> u >> k;
for (int j = 0; j < k; j++) {
int v;
cin >> v;
a[u][v] = 1;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cout << a[i][j] << (j != n ? ' ' : '\n');
}
}
return 0;
} | 1 | 18,087,590 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
string s;
cin >> s;
bool ret = s[0] == 'A';
int count = 0;
for (int i = 2; i < s.size() - 1; i++) {
if (s[i] == 'C')count++;
}
if (count != 1)ret = false;
count = 0;
for (int i = 0; i < s.size(); i++) {
if (islower(s[i]))count++;
}
if (count != s.size() - 2)ret = false;
cout << (ret ? "AC" : "WA") << endl;
return 0;
} | #include <bits/stdc++.h>
#define REP(i,n) for (int i = 0; i <(n); ++i)
#define REP2(i,x,n) for (int i = x; i <(n); ++i)
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
using namespace std;
using ll = long long;
using P = pair<int,int>;
static const double PI = acos(-1);
int main(){
string s;
cin >> s;
bool ok = true;
if(s[0] != 'A') ok = false;
else s[0] += 32;
int cnt = 0;
for(int i = 2; i < s.size() -1 ; i++){
if(s[i] == 'C') {
++cnt;
s[i] += 32;
}
}
if(cnt != 1) ok = false;
REP(i, s.size()){
if(isupper(s[i])) ok = false;
}
if(ok) cout << "AC" << endl;
else cout << "WA" << endl;
return 0;
} | 1 | 91,032,070 |
#include <iostream>
using namespace std;
int main(){
int k;
char* s = (char*)calloc(100, sizeof(char));
cin >> k >> s;
for(int i = 0; i < k; i++){
if(s[i] == 0) break;
cout << s[i];
}
int len = 0;
while(*s != 0){
s++;
len++;
}
if(len > k) cout << "..." << endl;
} | #include<bits/stdc++.h>
using namespace std;
using ll=long long int;
int main()
{
int n;
cin>>n;
string s;
cin>>s;
if(s.length()<=n)
cout<<s<<endl;
else
{
cout<<s.substr(0,n)+string(3,'.');
}
} | 1 | 54,291,783 |
#pragma GCC optimize("O3")
#include<iostream>
#include<algorithm>
#include<string>
#include<cmath>
#include<cstdlib>
#include<set>
#include<vector>
#include<sstream>
#include<queue>
#include <iomanip>
#include<unordered_set>
#include <stack>
#include <unordered_map>
#include <map>
#include<numeric>
#include<chrono>
#include <fstream>
constexpr auto INF = 9223372036854775807;
typedef long long int ll;
typedef unsigned long long int ull;
typedef unsigned long int ul;
#define f(i,a,b) for(ll i=(ll)a;i<(ll)b;i+=1)
#define rf(i,a,b) for(ll i=(ll)a;i>=(ll)b;i-=1)
#define endl '\n'
#define N 1000000007
#define M 998244353
#define all(x) x.begin(),x.end()
#define mkp(a,b) make_pair(a,b)
using namespace std;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
inline int mex(unordered_set<int> st)
{
int m = 0;
while (st.find(m) != st.end())
{
m += 1;
}
return m;
}
inline int calculateGrundy(int n)
{
if (n == 1)
return 0;
unordered_set<int> mexi;
for (int i = 1; i <= sqrt(n); i += 1)
{
if (n % i == 0)
{
if (n / i != n)
mexi.insert(calculateGrundy(n / i));
mexi.insert(calculateGrundy(i));
}
}
return mex(mexi);
}
inline ll gcd(ll a, ll b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
ll power(ll x, ll y)
{
ll res = 1;
x = x;
while (y > 0)
{
if (y & 1)
res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
ll sum(ll n)
{
return (n * (n + 1)) / 2;
}
ll sum_digit(ll n)
{
ll ans = 0;
while (n)
{
ans += n % 10;
n /= 10;
}
return ans;
}
ll gp(ll r, ll n)
{
return (pow(r, n) - 1) / (r - 1);
}
int main()
{
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
ll n;
cin>>n;
vector<ll> arr(n,0);
f(i,0,n)
{
cin>>arr[i];
}
ll ans=0;
f(i,1,n)
{
if(arr[i]<arr[i-1])
{
ans+=arr[i-1]-arr[i];
arr[i]=arr[i-1];
}
}
cout<<ans;
return 0;
} | #include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<cmath>
#include<iomanip>
#include<map>
using namespace std;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const long long INF = 1LL << 60;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main(){
int n;
cin>>n;
int64_t a[n];
int64_t cnt=0;
for(int i=0;i<n;i++){
cin>>a[i];
if(i!=0){
if(a[i-1]>a[i]){
cnt+=(a[i-1]-a[i]);
a[i]=a[i-1];
}
}
}
cout<<cnt<<endl;
} | 1 | 52,713,869 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
#define show(x) {for(auto i: x){cout << i << " ";} cout << endl;}
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int N, K;
cin >> N >> K;
vector<int> A(N);
rep(i, N) {
cin >> A[i];
--A[i];
}
ll ans = 0;
ll temp = 0;
map<int, int> mp;
vector<int> cum(N+1);
queue<int> que;
rep(i, N) cum[i+1] = (cum[i] + A[i]) % K;
rep(i, N+1) {
ans += mp[cum[i]];
mp[cum[i]]++;
que.push(cum[i]);
if (sz(que) == K) {
mp[que.front()]--;
que.pop();
}
}
cout << ans << '\n';
return 0;
} | #pragma GCC optimize("O3")
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <cfloat>
#include <climits>
#include <ctime>
#include <cassert>
#include <numeric>
#include <fstream>
#include <functional>
#include <bitset>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using T = tuple<int, int, int>;
template <class T> inline T chmax(T &a, const T b) {return a = (a < b) ? b : a;}
template <class T> inline T chmin(T &a, const T b) {return a = (a > b) ? b : a;}
constexpr int MOD = 1e9 + 7;
constexpr int inf = 1e9;
constexpr long long INF = 1e18;
constexpr double pi = acos(-1);
constexpr double EPS = 1e-10;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n, k; cin>>n>>k;
vector<int> a(n);
for(int i=0; i<n; i++) cin>>a[i];
if(k == 1){
cout << 0 << endl;
return 0;
}
vector<ll> sum(n+1, 0);
for(int i=0; i<n; i++) sum[i+1] = sum[i] + a[i];
map<int, int> cnt;
cnt[0] = 1;
ll ans = 0;
for(int r=1; r<=n; r++){
int x = (sum[r] - r) % k;
ans += cnt[x];
cnt[x]++;
int l = r - k + 1;
if(0 <= l){
int y = (sum[l] - l) % k;
cnt[y]--;
}
}
cout << ans << endl;
return 0;
} | 1 | 19,482,426 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> i_i;
typedef pair<ll, ll> l_l;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
int main() {
int h, w, d;
cin >> h >> w >> d;
char field[505][505];
char buf[2][2];
buf[0][0] = 'R';
buf[0][1] = 'Y';
buf[1][0] = 'G';
buf[1][1] = 'B';
for(int i = 1; i <= h; i++){
for(int j = 1; j <= w; j++){
int MI = i + j;
int MJ = i - j;
MI = (MI + d) / d;
MJ = (MJ + d * w) / d;
field[i][j] = buf[MI % 2][MJ % 2];
cout << field[i][j];
}
cout << endl;
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
string s="RGBY";
int n,i,j,x,y,d,m;
inline int read(){
int x=0,f=1;
char c;
c=getchar();
while(c<'0'||c>'9'){
if(c=='-') f=-1;
c=getchar();
}
while(c>='0'&&c<='9'){
x=x*10+c-48;
c=getchar();
}
return x*f;
}
int main(){
n=read();m=read();d=read();
for(i=0;i<=n-1;i++){
for(j=0;j<=m-1;j++){
x=(m+i+j)/d%2;
y=(m+i-j)/d%2;
cout << s[2*x+y];
}
cout << endl;
}
return 0;
} | 1 | 4,678,307 |
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ull = unsigned long long;
typedef pair< long long, long long > P;
typedef pair< long long, P > PP;
typedef pair< P, P > PPP;
const double DINF = 5e14, eps = 1e-10;
const long long MOD = 1e9 + 7, INF = 5e18;
const int di[4] = { 1,0,-1,0 }, dj[4] = { 0,1,0,-1 };
#define fr first
#define sc second
#define pb push_back
#define eb emplace_back
#define ALL(x) (x).begin(),(x).end()
ll n, l, r, cnt[100010];
bool fl = 0;
vector<int>ans[10000];
int main() {
cin >> n;
for (int i = 1;i <= n;i++) {
if (n * 2 % i == 0) {
if (n * 2 / i == i + 1) {
fl = 1;
l = i, r = i + 1;
break;
}
}
}
if (!fl) {
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
for (int j = 1;j <= l;j++) {
ans[0].eb(j);
}
int now = 0, nex = 1, b = 1, nn = l + 1, t = 0;
while (b <= l) {
for (int i = 0;i < r - b;i++) {
ans[nex].eb(ans[now][t + i]);
nex++;
}
nex = b + 1;
now++;
for (int i = 0;i < l - b;i++) {
ans[now].eb(nn + i);
}
nn += l - b;
b++;
t++;
}
cout << r << endl;
for (int i = 0;i < r;i++) {
cout << ans[i].size() << ' ';
for (int j = 0;j < ans[i].size();j++) {
cout << ans[i][j] << ' ';
}
cout << endl;
}
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
vector<int> v[100010];
int main(){
long long i,j,k,n;
cin >> n;
for(i=0;i<=n;i++){
if(i*(i+1)/2==n){
k = i;
break;
}
if(i==n){
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
cout << k+1 << endl;
int x = 1;
for(i=1;i<=k+1;i++){
for(j=i;j<=k;j++){
v[i].push_back(x);
v[j+1].push_back(x);
x++;
}
}
for(i=1;i<=k+1;i++){
cout << v[i].size() << " ";
for(int j:v[i]){
cout << j << " ";
}
cout << endl;
}
} | 1 | 57,124,813 |
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
#define ll long long
#define rep(i,n) for (ll i = 0; i < (ll)(n); ++i)
#define be(v) (v).begin(), (v).end()
#define dcout cout << fixed << setprecision(20)
ll INF = 1LL << 60;
ll mod = 1e9 + 7;
int main() {
int x,a,b; cin >> x >> a >> b;
if(b<=a) cout << "delicious" << endl;
else if(b-a<=x) cout << "safe" << endl;
else cout << "dangerous" << endl;
} | #include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
using namespace std;
typedef long long ll;
ll MOD = 1e9+7;
#define rep(i,n) for(int i = 0; i < (n); ++i)
int main() {
ll x, a, b;
cin >> x >> a >> b;
if ( a >= b ) cout << "delicious" << endl;
else if ( b - a <= x ) cout << "safe" << endl;
else cout << "dangerous" << endl;
return 0;
} | 1 | 13,763,125 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int A,B,C,D;
cin >> A >> B >> C >> D;
if(A+B > C+D)
cout << "Left" << endl;
if(A+B == C+D)
cout << "Balanced" << endl;
if(A+B < C+D)
cout << "Right" <<endl;
} | #include <bits/stdc++.h>
using namespace std;
signed main(){
int A, B, C, D;
scanf("%d%d%d%d", &A, &B, &C, &D);
if(A + B > C + D){
printf("Left\n");
}
else if(A + B == C + D){
printf("Balanced\n");
}
else{
printf("Right\n");
}
return 0;
} | 1 | 41,441,300 |
#include <iostream>
#include <vector>
#include <string>
#include <cmath>
using namespace std;
using Int = long long int;
using UInt = unsigned long long int;
using VI = vector<long long int>;
int main(void) {
Int a, b;
cin >> a >> b;
cout << (a - 1) * (b - 1) << endl;
return 0;
} | #include<iostream>
#include<vector>
#include<utility>
#include<map>
#include<algorithm>
using namespace std;
using ll = long long;
int main() {
int A, B;
cin >> A >> B;
cout << (A - 1) * (B - 1) << endl;
} | 1 | 59,649,981 |
#include<iostream>
#include<stdio.h>
#include<vector>
#include<float.h>
#include<iomanip>
#include<algorithm>
#include<string>
#include<cstring>
#include<math.h>
#include<cmath>
#include<sstream>
#include<set>
#include<map>
#include<queue>
#include <cassert>
#include <cmath>
#include<cstdint>
#define INF 1e9
#define rep(i,n)for(int i=0;(i)<(int)(n);i++)
#define REP(i,a,b)for(int i=(int)(a);(i)<=(int)(b);i++)
#define VEC(type, c, n) std::vector<type> c(n);for(auto& i:c)std::cin>>i;
#define vec(type,n) vector<type>(n)
#define vvec(m,n) vector<vector<int>> (int(m),vector<int>(n))
#define ALL(a) (a).begin(),(a).end()
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using P = pair<ll, ll>;
string dp[20000];
int main(){
int n, m;
cin >> n >> m;
vector<int> a(m);
int cost[10] = {-1, 2, 5, 5, 4, 5, 6, 3, 7, 6};
rep(i, m)cin >> a[i];
rep(i, n + 100)dp[i] = "-";
dp[0] = "";
rep(i, n){
if(dp[i] == "-")continue;
for(int now : a){
if(dp[i + cost[now]].size() == dp[i].size() + 1){
if(dp[i + cost[now]] < dp[i] + to_string(now))dp[i + cost[now]] = dp[i] + to_string(now);
}
else if(dp[i + cost[now]].size() < dp[i].size() + 1)dp[i + cost[now]] = dp[i] + to_string(now);
}
}
cout << dp[n] << endl;
} | #include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(ll i=0;i<n;i++)
#define repl(i,l,r) for(ll i=(l);i<(r);i++)
#define per(i,n) for(ll i=n-1;i>=0;i--)
#define perl(i,r,l) for(ll i=r-1;i>=l;i--)
#define fi first
#define se second
#define pb push_back
#define ins insert
#define pqueue(x) priority_queue<x,vector<x>,greater<x>>
#define all(x) (x).begin(),(x).end()
#define CST(x) cout<<fixed<<setprecision(x)
#define vtpl(x,y,z) vector<tuple<x,y,z>>
#define rev(x) reverse(x);
using ll=long long;
using vl=vector<ll>;
using vvl=vector<vector<ll>>;
using pl=pair<ll,ll>;
using vpl=vector<pl>;
using vvpl=vector<vpl>;
const ll MOD=1000000007;
const ll MOD9=998244353;
const int inf=1e9+10;
const ll INF=4e18;
const ll dy[8]={1,0,-1,0,1,1,-1,-1};
const ll dx[8]={0,-1,0,1,1,-1,1,-1};
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const ll match[10]={inf,2,5,5,4,5,6,3,7,6};
void update(string &a,string b){
if(a=="x")a=b;
else if(a.size()<b.size())a=b;
else if(a.size()==b.size()){
if(a<b)a=b;
}
}
int main(){
ll n,m;cin >> n >> m;
vl a(m);rep(i,m)cin >> a[i];
string dp[10100];
rep(i,10100){
dp[i]="x";
}
dp[0]="";
rep(i,n+1){
if(dp[i]=="x")continue;
for(auto p:a){
update(dp[i+match[p]],dp[i]+to_string(p));
}
}
cout << dp[n] <<endl;
} | 1 | 76,247,950 |
#include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {int v; istringstream sin(s);sin>>v;return v;}
template<class T> inline string toString(T x) {ostringstream sout;sout<<x;return sout.str();}
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> P;
typedef tuple<int,int,int> tpl;
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define SORT(c) sort((c).begin(),(c).end())
#define REVERSE(c) reverse((c).begin(),(c).end())
#define LB(a,x) lower_bound((a).begin(), (a).end(), x) - (a).begin()
#define UB(a,x) upper_bound((a).begin(), (a).end(), x) - (a).begin()
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define RFOR(i,a,b) for(int i=(a)-1;i>=(b);--i)
#define RREP(i,n) RFOR(i,n,0)
#define en "\n"
const double EPS = 1e-9;
const double PI = acos(-1.0);
const int INT_INF = 2147483647;
const long long LL_INF = 1LL<<60;
const long long MOD = 1000000007;
#define CLR(a) memset((a), 0, sizeof(a))
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
int N;
char S[300][300];
bool check(int x, int y){
FOR(i,1,N)REP(j,i){
if(S[(x+i)%N][(y+j)%N] != S[(x+j)%N][(y+i)%N]) return false;
}
return true;
}
int main(void){
cin >> N;
REP(i,N)REP(j,N) cin >> S[i][j];
int ans = 0;
REP(i,N) if(check(i,0)) ans += N;
cout << ans << endl;
return 0;
} | #include <cstdio>
#include <cstring>
#include <cmath>
#include <cassert>
#include <cstdlib>
#include <cctype>
#include <ctime>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <numeric>
#include <utility>
#include <string>
#include <algorithm>
#include <vector>
#include <map>
#include <queue>
#include <set>
#include <list>
#include <bitset>
#include <complex>
using namespace std;
#define f first
#define s second
#define PB pop_back
#define pb push_back
#define mp make_pair
#define int long long
#define y1 y_golabi
#define sz(s) (int)s.size()
#define seper(n) setprecision(n)
#define all(v) v.begin(),v.end()
#define mem(a,b) memset(a,b,sizeof a)
#define IOS ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
typedef long long ll;
typedef map<int , int> mii;
typedef pair<int , int> pii;
typedef map<string , int> msi;
typedef pair<int , string> pis;
typedef pair<int , pair<int , int> > piii;
const int MAXN = 3e2 + 10;
char ch[MAXN][MAXN];
int n , ans;
bool is_good(int ind , int n)
{
for(int i = ind , ip = 0 ; ip < n ; i ++ , ip ++ , i %= n)
for(int j = 0 , jp = ind ; j < n ; j ++ , jp ++ , jp %= n)
if(ch[i][j] != ch[jp][ip])
return false;
return true;
}
int32_t main()
{
cin >> n;
for(int i = 0 ; i < n ; i ++)
for(int j = 0 ; j < n ; j ++)
cin >> ch[i][j];
for(int i = 0 ; i < n ; i ++)
ans += is_good(i , n) * n;
return cout << ans << endl , 0;
} | 1 | 15,725,613 |
#include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define watch(x) cout << (#x) << " is " << (x) << endl
#define debug cout << "hi" << endl
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
ll gcd(ll a, ll b) {return (!b ? a : gcd(b, a % b));}
bool cmp(int a,int b){return a>b;}
const ll mod = 1e9 + 7;
const int INF32 = 1<<30;
const ll INF64 = 1LL<<60;
const ld pi = 3.141592653589793;
const int N = 5e5 + 10;
void hi(int a){
int temp = a;
int cnt = 0;
while(temp){temp/=10;cnt++;}
cnt = 6-cnt;
for(int i = 0;i<cnt;i++){
cout <<0;
}
}
void solve(){
int n,m;cin >> n >> m;
vector< vector<int> >p(n+10);
vector<int>ans1(m+5);
map<int,int>mapp;
vector<int>c(m+5);
for(int i = 0;i<m;i++){
int a,b;cin >> a >> b;
p[a].push_back(b);
ans1[i] = a;
c[i] = b;
}
for(int i = 1;i<=n;i++){
sort(p[i].begin(),p[i].end());
for(int j = 0;j<p[i].size();j++){
mapp[p[i][j]] = j+1;
}
}
for(int i = 0;i<m;i++){
hi(ans1[i]);cout << ans1[i];
hi(mapp[c[i]]);cout << mapp[c[i]];
cout <<endl;
}
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);cout.tie(NULL);
solve();
return 0;
} | #include "bits/stdc++.h"
#define rep(i,n) for (int i=0; i<(n); ++i)
using namespace std;
using ll =long long;
using P =pair<int,int>;
int main(){
int n,m;
cin >> n >> m;
vector <vector <int>> v(n+1),v2(n+1);
vector <vector <int>> so;
vector <vector <int>> ans(m,vector <int> (2));
int p,y;
rep(i,m){
cin >> p >> y;
v[p].push_back(i);
v2[p].push_back(y);
ans[i][0]=p;
}
int l;
rep(i,n){
l=v[i+1].size();
so.resize(l);
rep(j,l){
so[j].resize(2);
}
rep(j,l){
so[j][0]=v2[i+1][j];
so[j][1]=v[i+1][j];
}
sort(so.begin(),so.end());
rep(j,l){
ans[so[j][1]][1]=j+1;
}
}
string s1,s2,s;
int l1,l2;
rep(i,m){
s1=to_string(ans[i][0]);
s2=to_string(ans[i][1]);
l1=6-s1.size();
l2=6-s2.size();
rep(j,l1){
s1="0"+s1;
}
rep(j,l2){
s2="0"+s2;
}
cout << s1+s2 << endl;
}
return 0;
} | 1 | 81,477,628 |
#include<bits/stdc++.h>
#define ll long long int
using namespace std;
const ll mod=1000000007;
const ll inf=1e18;
vector<vector<ll>> soinsu(ll a){
if(a<=0) return {};
if(a==1) return {{1,1}};
vector<ll> f;
ll b=a;
for(ll i=2;i*i<=a;i++){
if(b%i==0){
f.push_back(i);
b=b/i;
i--;
}
if(b==1)break;
}
if(b!=1)f.push_back(b);
vector<vector<ll>> u;
ll p=f[0];
ll c=1;
for(ll i=1;i<f.size();i++){
if(f[i]==p)c++;
else{
u.push_back({p,c});
p=f[i];
c=1;
}
}
u.push_back({p,c});
return u;
}
int main(){
ll n;
cin >> n;
ll c=0;
for(ll i=1;i<=n;i++){
if(i%2==0)continue;
vector<vector<ll>> v=soinsu(i);
if(v.size()==3){
if(v[0][1]==1 && v[1][1]==1 && v[2][1]==1)c++;
}
if(v.size()==2){
if(v[0][1]==1 && v[1][1]==3)c++;
else if(v[0][1]==3 && v[1][1]==1)c++;
}
if(v.size()==1){
if(v[0][1]==7)c++;
}
}
cout << c << endl;
} | #include<bits/stdc++.h>
using namespace std;
#define ll long long
vector<int>prime(1000005,0);
bool mark[1000005];
int nprime;
void sieve(int n)
{
int limit=sqrt(n*1.0)+1,s=0;nprime=0;
mark[1]=true;
mark[2]=false;
prime[nprime++]=2;
for(int i=3;i<=n;i+=2){
if(!mark[i]){prime[nprime++]=i;
if(i<=limit){
for(int j=i*i;j<=n;j+=i*2){
mark[j]=true;
}
}
}
}
}
ll nod(ll n)
{
ll nod=1,x3=1,sqrtN=sqrt(n)+1;
for(int i=0;prime[i]<=sqrtN&&i<nprime;i++){
if(n%prime[i]==0){
while(n%prime[i]==0){
n/=prime[i];
x3++;
}nod*=x3;x3=1;
}
}
if(n>1)nod*=2;
return nod-1;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll dg[201]={0};
for(int i=1;i<=200;i++){
for(int j=i;j<=200;j+=i){
dg[j]++;
}
}
ll n;
cin>>n;
ll s=0;
for(int i=1;i<=n;i+=2){
if(dg[i]==8)s++;
}
cout<<s;
} | 1 | 92,894,370 |
#include <bits/stdc++.h>
using namespace std;
template<typename T> void drop(const T &x){cout<<x<<'\n';exit(0);}
void solve() {
int n, d;
cin >> n >> d;
vector<vector<int>> x(n, vector<int>(d));
for(int i=0; i<n; ++i) {
for(int j=0; j<d; ++j) {
cin >> x[i][j];
}
}
int ans = 0;
for(int i=0; i<n; ++i) {
for(int j=i+1; j<n; ++j) {
int a = 0, b = 0;
for(int k=0; k<d; ++k) {
a += pow(x[i][k]-x[j][k], 2);
b += pow(x[i][k]-x[j][k], 2);
}
if((int)sqrt(a) == sqrt(b)) ans++;
}
}
cout << ans << '\n';
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int T=1;
while(T--) solve();
return 0;
} | #include <iterator>
#include <list>
#include <algorithm>
#include <iostream>
#include <unordered_set>
#include <unordered_map>
#include <vector>
#include <sstream>
#include <iomanip>
#include <string>
#include <cmath>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <numeric>
using namespace std;
int main() {
int N, D; cin >> N >> D;
vector<vector<int>> points(N, vector<int>(D));
for (int i = 0; i < N; i++) {
for (int j = 0; j < D; j++) {
cin >> points[i][j];
}
}
int ans = 0;
for (int i = 0; i < N - 1; i++) {
for (int k = i + 1; k < N; k++) {
int cur = 0;
for (int j = 0; j < D; j++) {
cur += pow(points[i][j] - points[k][j], 2);
}
double v = sqrt(cur);
if (v - floor(v) == 0)
++ans;
}
}
cout << ans << endl;
return 0;
} | 1 | 23,349,805 |
#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define rep(i,n) for(int i=0;i<(n);++i)
#define repi(i,a,b) for(int i=int(a);i<int(b);++i)
#define all(x) (x).begin(), (x).end()
#define PI 3.14159265358979323846264338327950L
using namespace std;
typedef long long ll;
typedef long double ld;
int main() {
string s,t("keyence");
cin>>s;
int cnt=0,n=s.size();
rep(i,n){
if(s[i]==t[i]) cnt++;
else break;
}
rep(i,n){
if(s[n-1-i]==t[6-i]) cnt++;
else break;
}
if(cnt>=7) cout<<"YES";
else cout<<"NO";
} | #include <bits/stdc++.h>
using namespace std;
int main(void){
string S;
cin >> S;
string T = "keyence",S1 = " ", S2 = " ",T1;
int k = 0;
bool flag = true;
for(int i = 0; i < S.size(); i++){
if(S[i] != T[k] && flag == true){
flag = false;
S1 = S.substr(0,i);
reverse(T.begin(),T.end());
T1 = T.substr(0,7-k);
}
}
reverse(T.begin(),T.end());
reverse(S.begin(),S.end());
string S3 = S1 + S2;
if(S1 == T || S2 == T || S3 == T || S == T) cout << "YES" << endl;
else cout << "NO" << endl;
} | 1 | 74,358,636 |
#include <bits/stdc++.h>
using namespace std;
long long n;
vector<long long> a;
map<long long, long long> mp;
long long solve();
int main() {
cin >> n;
a.resize(n);
for (int i = 0; i < n; ++i) cin >> a[i];
cout << solve() << endl;
return 0;
}
long long solve() {
mp[0] = 1;
long long res = 0, now = 0;
for (int i = 0; i < n; ++i) {
now += a[i];
res += mp[now];
++mp[now];
}
return res;
} | #include <bits/stdc++.h>
using namespace std;
using lint = long long;
signed main(){
lint N; cin >> N;
vector<lint> a(N);
lint sum = 0;
map<lint, lint> MAP;
MAP[0]++;
for(lint i = 0; i < N; i++) cin >> a[i], sum += a[i], MAP[sum]++;
lint ans = 0;
for(auto value : MAP){
ans += (value.second - 1) * value.second / 2;
}
cout << ans << endl;
} | 1 | 73,470,181 |
#include <cstring>
#include <map>
#include <unordered_map>
#include <string>
#include <list>
#include <vector>
#include <algorithm>
#include <queue>
#include <stack>
#include <cstdio>
#include <iostream>
#include <set>
#include <unordered_set>
using namespace std;
#define MAX(a,b) (a>b?a:b)
#define MIN(a,b) (a<b?a:b)
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int ui;
typedef pair<int, int> pii;
int gi() {
int a;
scanf("%d", &a);
return a;
}
ll gli() {
ll a;
scanf("%lld", &a);
return a;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n = gi();
int a = gi();
int b = gi();
printf((b-a)%2 ? "Borys\n" : "Alice\n");
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define fs first
#define sc second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define ALL(A) A.begin(),A.end()
#define RALL(A) A.rbegin(),A.rend()
typedef long long ll;
typedef pair<ll,ll> P;
const ll mod=1000000007;
const ll LINF=1LL<<60;
const int INF=1<<30;
int main(){
int n,a,b;cin>>n>>a>>b;
if ((b - a) % 2 == 0){
cout << "Alice" << endl;
}
else{
cout << "Borys" << endl;
}
return 0;
} | 1 | 75,874,139 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> iint;
typedef pair<ll,ll> llll;
#define ALL(x) (x).begin(),(x).end()
const ll zero = 0;
const ll one = 1;
const ll INF = 9223372036854775807;
const int inINF = 2147483647;
const ll MOD = 1000000007;
const ll MOD2 = 998244353;
void Yes() {printf("Yes\n");}
void No() {printf("No\n");}
void YES() {printf("YES\n");}
void NO() {printf("NO\n");}
int main(){
int N, K;
cin >> N >> K;
vector<int> a(N);
for (int i = 0; i < N; i++) {
cin >> a[i];
}
vector<int> A;
int cnt = 0;
for (int i = 0; i < N; i++) {
if(a[i] < K){
A.push_back(a[i]);
cnt ++;
}
}
int ans = N - cnt;
swap(N, cnt);
vector<vector<bool>> dp1(N+1, vector<bool> (K+1, false));
vector<vector<bool>> dp2(N+1, vector<bool> (K+1, false));
for (int i = 0; i < N+1; i++) {
dp1[i][0] = true;
dp2[i][0] = true;
}
for (int i = 0; i < N; i++) {
for (int j = K; j >= 0; j--) {
if(j - A[i] >= 0 && dp1[i][j-A[i]] == true){
dp1[i+1][j] = true;
}
if(dp1[i][j]){
dp1[i+1][j] = true;
}
if(j - A[N-i-1] >= 0 && dp2[i][j-A[N-i-1]] == true){
dp2[i+1][j] = true;
}
if(dp2[i][j]){
dp2[i+1][j] = true;
}
}
}
for (int i = 0; i < N; i++) {
int tmp = 0;
for (int j = 1; j < A[i]+1; j++) {
if(dp1[i][K-j]){
tmp++;
}
}
if(dp2[N-i-1][0] && tmp > 0){
ans++;
continue;
}
bool check = false;
for (int j = A[i]+1; j <= K; j++) {
if(dp1[i][K-j]){
tmp++;
}
if(dp1[i][K-j+A[i]]){
tmp--;
}
if(dp2[N-i-1][j-A[i]] && tmp > 0){
ans++;
check = true;
break;
}
}
if(check) continue;
for (int j = 0; j < A[i]; j++) {
if(dp1[i][A[i]-1-j]){
tmp--;
}
if(dp2[N-i-1][K-A[i]+j] && tmp > 0){
ans++;
check = true;
break;
}
}
}
printf("%d\n", cnt - ans);
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,N) for(int i=0,i##_max=(N);i<i##_max;++i)
#define repp(i,l,r) for(int i=(l),i##_max=(r);i<i##_max;++i)
#define per(i,N) for(int i=(N)-1;i>=0;--i)
#define perr(i,l,r) for(int i=r-1,i##_min(l);i>=i##_min;--i)
#define all(arr) (arr).begin(), (arr).end()
#define SP << " " <<
#define SPF << " "
#define SPEEDUP cin.tie(0);ios::sync_with_stdio(false);
#define MAX_I INT_MAX
#define MIN_I INT_MIN
#define MAX_UI UINT_MAX
#define MAX_LL LLONG_MAX
#define MIN_LL LLONG_MIN
#define MAX_ULL ULLONG_MAX
typedef long long ll;
typedef pair<int,int> PII;
typedef pair<char,char> PCC;
typedef pair<ll,ll> PLL;
typedef pair<char,int> PCI;
typedef pair<int,char> PIC;
typedef pair<ll,int> PLI;
typedef pair<int,ll> PIL;
typedef pair<ll,char> PLC;
typedef pair<char,ll> PCL;
inline void YesNo(bool b){ cout << (b?"Yes" : "No") << endl;}
inline void YESNO(bool b){ cout << (b?"YES" : "NO") << endl;}
inline void Yay(bool b){ cout << (b?"Yay!" : ":(") << endl;}
const int N_MAX = 5010;
int N,K;
ll v[N_MAX];
bool isNoNeed(int index){
bool dp[2][K];
bool *prev, *next;
prev = dp[0];
next = dp[1];
rep(j,K){
prev[j] = false;
next[j] = false;
}
prev[0] = true;
rep(i,N){
if(i==index)continue;
rep(j,K){
next[j] = (prev[j]||next[j]);
if(prev[j]){
if(j+v[i]<K-v[index]) next[j+v[i]] = true;
else if(j+v[i] < K) return false;
else break;
}
}
swap(prev,next);
}
return true;
}
int main(void){
SPEEDUP
cout << setprecision(15);
int n;cin >> n >> K;
N=0;
rep(i,n){
int x;cin >> x;
if(x>=K)continue;
else v[N++]=x;
}
sort(v,v+N);
int l = 0, r=N;
if(!isNoNeed(l)){
cout << 0 << endl;
return 0;
}
while(r-l>1){
int m = (r+l)/2;
bool isnoneed = isNoNeed(m);
if(isnoneed) l = m;
else r = m;
}
cout << r << endl;
return 0;
} | 1 | 53,459,435 |
#include <stdlib.h>
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;
int main(void){
int N;
int K;
long long A[100010];
long long B[100010];
long long CAN[30];
cin >> N >> K;
for(int i=0;i<N;i++){
cin >> A[i] >> B[i];
}
CAN[0] = K;
int count = 1;
for(int i=0;i<30;i++){
if((K & 1<<i) == 1<<i){
CAN[count] = (K - (1<<i)) | ((1<<i) - 1);
count++;
}
}
long long res = 0;
long long tmp_sum = 0;
for(int i=0;i<count;i++){
for(int ii=0;ii<N;ii++){
if((CAN[i] | A[ii]) == CAN[i]){
tmp_sum += B[ii];
}
}
res = max(res, tmp_sum);
tmp_sum = 0;
}
res = max(tmp_sum, res);
cout << res << endl;
return 0;
} | #include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef pair<double,double> pdd;
#define IOS ios_base::sync_with_stdio(0); cin.tie(0)
#define ALL(a) a.begin(),a.end()
#define SZ(a) ((int)a.size())
#define F first
#define S second
#define REP(i,n) for(int i=0;i<((int)n);i++)
#define pb push_back
#define MP(a,b) make_pair(a,b)
#define SORT_UNIQUE(c) (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
#define GET_POS(c,x) (lower_bound(c.begin(),c.end(),x)-c.begin())
#ifdef leowang
#define debug(...) do{\
fprintf(stderr,"%s - %d : (%s) = ",__PRETTY_FUNCTION__,__LINE__,#__VA_ARGS__);\
_DO(__VA_ARGS__);\
}while(0)
template<typename I> void _DO(I&&x){cerr<<x<<endl;}
template<typename I,typename...T> void _DO(I&&x,T&&...tail){cerr<<x<<", ";_DO(tail...);}
#else
#define debug(...)
#endif
template<typename T1,typename T2>
ostream& operator<<(ostream& out,pair<T1,T2> P){
out<<'('<<P.F<<','<<P.S<<')';
return out;
}
const ll maxn=300005;
const ll maxlg=__lg(maxn)+2;
const ll INF64=8000000000000000000LL;
const int INF=0x3f3f3f3f;
const ll MOD=ll(1e9+7);
const double PI=acos(-1);
ll mypow(ll a,ll b){
ll res=1LL;
while(b){
if(b&1) res=res*a%MOD;
a=a*a%MOD;
b>>=1;
}
return res;
}
int a[maxn],b[maxn];
int main()
{
int n,k;
cin>>n>>k;
k++;
REP(i,n) cin>>a[i]>>b[i];
ll cur=0;
ll ans=0;
for(int i=30;i>=0;i--){
if(k&(1<<i)){
ll nw=cur+(1<<i)-1;
ll meow=0;
REP(j,n) if(nw>=a[j]&&(nw-a[j]==(nw^a[j]))){
meow+=b[j];
}
ans=max(ans,meow);
cur+=(1<<i);
}
}
cout<<ans<<'\n';
return 0;
} | 1 | 70,361,622 |
#include <iostream>
using namespace std;
int main()
{
int x;
cin >> x;
cout << 180*(x -2);
return 0;
} | #include <iostream>
#include <vector>
#include <chrono>
#include <random>
std::mt19937 rng((int) std::chrono::steady_clock::now().time_since_epoch().count());
int main() {
std::ios_base::sync_with_stdio(false); std::cin.tie(NULL);
int n;
std::cin >> n;
std::cout << (n - 2) * 180 << '\n';
} | 1 | 56,982,638 |
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <cfloat>
#include <climits>
#include <ctime>
#include <cassert>
#include <numeric>
#include <fstream>
#include <functional>
#include <bitset>
#define chmin(a, b) ((a)=min((a), (b)))
#define chmax(a, b) ((a)=max((a), (b)))
#define fs first
#define sc second
#define eb emplace_back
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef tuple<int, int, int> T;
const ll MOD=1e9+7;
const ll INF=1e18;
const double pi=acos(-1);
const double eps=1e-10;
int dx[]={1, 0, -1, 0};
int dy[]={0, -1, 0, 1};
int main(){
while(1){
int n; cin>>n;
if(n == 0) return 0;
vector<int> imos(100000, 0);
for(int i=0; i<n; i++){
int h1, m1, s1;
char a1, b1;
cin>>h1>>a1>>m1>>b1>>s1;
int h2, m2, s2;
char a2, b2;
cin>>h2>>a2>>m2>>b2>>s2;
int startTime = h1 * 3600 + m1 * 60 + s1;
int stopTime = h2 * 3600 + m2 * 60 + s2;
imos[startTime]++;
imos[stopTime]--;
}
int ans=imos[0];
for(int i=0; i<=90000; i++){
imos[i+1] += imos[i];
chmax(ans, imos[i+1]);
}
cout << ans << endl;
}
} | #include <iostream>
#include <cstdio>
#include <string>
#include <queue>
#include <functional>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);++i)
#define rep1(i,n) for(int i=1;i<=(n);++i)
#define all(c) (c).begin(),(c).end()
typedef pair<int,int> P;
priority_queue<P,vector<P>,greater<P> > que;
int main(){
while(true){
int n;
cin >> n;
if(n==0) break;
rep(i,n){
string x,y;
cin >> x >> y;
int a=stoi(x.substr(0,2))*3600+stoi(x.substr(3,2))*60+stoi(x.substr(6,2));
int b=stoi(y.substr(0,2))*3600+stoi(y.substr(3,2))*60+stoi(y.substr(6,2));
que.push(P(b,0));
que.push(P(a,1));
}
int now=0,ans=0;
while(!que.empty()){
P q=que.top();
que.pop();
if(q.second==0) now++;
else{
if(now>0) now--;
else ans++;
}
}
cout << ans << endl;
}
} | 1 | 24,654,934 |
#include<bits/stdc++.h>
#define ll long long
using namespace std;
ll n, ans;
int main()
{
ios::sync_with_stdio(false);
cin >> n;
for (ll i = sqrt(n) + 1; i >= 1; i--)
{
if (n % i == 0)
{
ans = i + n / i - 2;
cout << ans << endl;
break;
}
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF = 1e9;
const ll LINF = 1e18;
const int mod = 1e9+7;
#define pi pair<int,int>
#define pl pair<lld,lld>
#define dump(x) cout << #x << " = " << (x) << endl
#define YES(n) cout << ((n) ? "YES" : "NO" ) << endl
#define Yes(n) cout << ((n) ? "Yes" : "No" ) << endl
#define SANKOU(n,a,b) cout << ((n) ? (#a) : (#b) ) << endl
#define mem0(x) memset(x,0,sizeof(x))
#define fillnum(x,n) fill(begin(x),end(x),n)
#define asort(x) sort(x.begin(),x.end())
#define dsort(x,t) sort(x.begin(),x.end(),greater<t>())
#define vuniq(x) x.erase(unique(x.begin(), x.end()), x.end())
#define pb(a) push_back(a)
#define mp(a,b) make_pair(a,b)
ll N;
vector<ll> prime;
ll ans = LINF;
vector<ll> prime_factor(ll N) {
vector<ll> res;
for (ll a = 2; a * a <= N; ++a) {
if (N % a != 0) continue;
while (N % a == 0) {
N /= a;
res.push_back(a);
}
}
if (N != 1) res.push_back(N);
return res;
}
int main() {
cin >> N;
ll ans = LINF;
for (ll i = 1; i*i <= N; i++) {
if(N % i == 0){
ll left = i;
ll right = N / i;
ans = min(ans,left+right-2);
}
}
cout << ans << endl;
} | 1 | 21,228,032 |
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define str to_string
#define endl "\n"
#define PI 3.141592653589
using namespace std;
using lint = long long;
template <class T>ostream &operator<<(ostream &o,const vector<T>&v)
{o<<"{";for(int i=0;i<(int)v.size();i++)o<<(i>0?", ":"")<<v[i];o<<"}";return o;}
vector<lint> ALL(51);
vector<lint> P(51);
lint solve(lint n,lint x){
if(x==0)return 0;
if(n==0)return 1;
if(x==1)return 0;
if(ALL[n]==x)return P[n];
if(x<=ALL[n-1]+1)return solve(n-1,x-1);
if(x==ALL[n-1]+2)return solve(n-1,x-2)+1;
return solve(n-1,ALL[n-1])+1+solve(n-1,x-ALL[n-1]-2);
}
int main(){
P[0]=1;
ALL[0]=1;
for(int i=1;i<=50;i++){
ALL[i]=ALL[i-1]*2+3;
P[i]=P[i-1]*2+1;
}
lint n,x;cin>>n>>x;
cout<<solve(n,x)<<endl;
} | #include <bits/stdc++.h>
#define ll long long int
#define ld long double
#define yorn(f) cout<<((f)?"Yes":"No")<<endl;
#define YORN(f) cout<<((f)?"YES":"NO")<<endl;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define repi(i, n) for (ll i = 1; i < (ll)(n); i++)
#define all(x) (x).begin(), (x).end()
#define put(x) cout << x << endl;
#define println(x) cout << x << endl;
using namespace std;
ll dfs(ll L, ll X, vector<ll>& c, vector<ll>& p) {
if (L == 0) {
return 1;
}
if (X == 0) {
return 0;
}
if (X == c[L] / 2) {
return p[L] - p[L] / 2;
}
if (X == c[L] - 1) {
return p[L];
}
if (X < c[L] / 2) {
return dfs(L - 1, X - 1, c, p);
}
else {
ll res = dfs(L - 1, X - c[L] / 2 - 1, c, p);
res += 1 + p[L] / 2;
return res;
}
}
void Main()
{
ll n, X;
cin >> n >> X;
X--;
vector<ll> c(n + 1);
vector<ll> p(n + 1);
c[0] = 1;
repi(i, n + 1) c[i] = c[i - 1] * 2 + 3;
p[0] = 1;
repi(i, n + 1) p[i] = p[i - 1] * 2 + 1;
ll res = dfs(n, X, c, p);
put(res);
}
signed main(){ Main();return 0;} | 1 | 66,048,292 |
#include<bits/stdc++.h>
#define ll long long
#define ld long double
#define all(v) v.begin(),v.end()
#define sz size()
#define mp make_pair
#define pb push_back
#define rep(p,a,b) for(ll p=a ; p<b ; p++)
#define F first
#define S second
using namespace std;
typedef vector <ll> vl;
typedef pair< ll, ll > pll;
int main()
{
ll t,i,j,k,ans,n;
t=1;
while(t--)
{
cin>>n;
vl v(n);
rep(p, 0, n)cin>>v[p];
cout<<(*max_element(all(v)))-(*min_element(all(v)));
}
return 0;
} | #include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
using namespace std;
using ll = long long;
const int INF = 1001001001;
const ll INF_LL = 1001001001001001001LL;
int main(void){
int n; cin >> n;
vector<int> a(n); rep(i,n) cin >> a[i];
int dif = -1;
rep(i,n){
for(int j = i+1;j<n;j++){
dif = max(dif,abs(a[i]-a[j]));
}
}
cout << dif << endl;
return 0;
} | 1 | 38,699,295 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
using ll = long long;
#define int long long
using P = pair<int,int>;
signed main(){
int n,m;cin >>n >>m;
vector<P> res;
rep(i,n){
int a,b;cin >> a >> b;
res.emplace_back(a,b);
}
sort(res.begin(),res.end());
int cnt = 0;
int ans = 0;
rep(i,n){
auto hoge = res[i];
int val = hoge.first,num = hoge.second;
if(cnt + num >= m){
ans += (m-cnt)*val;
break;
}
cnt += num;
ans += num*val;
}
cout << ans << endl;
return 0;
} | #include <cmath>
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
ll inf = 1000000007;
int main() {
int n, m;
cin >> n >> m;
ll sum = 0;
vector<P>p(n);
for (int i = 0; i < n; i++) {
cin >> p[i].first >> p[i].second;
}
sort(p.begin(), p.end());
ll count = 0;
for (int i = 0; i < n; i++) {
count += p[i].second;
if (count >= m) {
sum += p[i].first * p[i].second;
sum -= p[i].first * (count - m);
break;
}
else {
sum += p[i].first * p[i].second;
}
}
cout << sum << endl;
return 0;
} | 1 | 20,596,480 |
#include <bits/stdc++.h>
using namespace std;
int i,j;
long long k,ans[55];
int main(){
scanf("%lld", &k);
long long t = k / 50;
k = k % 50;
for(i = 0; i < 50; i++)
ans[i] = i + t;
for(i = 0; i < k; i++){
for(j = 0; j < 50; j++){
if(i == j)
ans[j] += 50LL;
else
ans[j]--;
}
}
printf("%d\n", 50);
for(i = 0; i < 50; i++){
if(i == 0)
printf("%lld", ans[i]);
else
printf(" %lld", ans[i]);
}
printf("\n");
} | #include <iostream>
#include <stdio.h>
#include <string.h>
#define int long long
using namespace std;
signed main()
{
int n=50,K;
scanf("%lld",&K);
int avg=K/n,rst=K%n;
printf("%lld\n",n);
for(int i=1;i<=rst;i++) printf("%lld ",n-1+avg-rst+n);
for(int i=rst+1;i<=n;i++) printf("%lld ",n-1+avg-rst);
printf("\n");
} | 1 | 64,250,615 |
#include<bits/stdc++.h>
#define rep(i,n) for(int i = 0;i<n;i++)
using namespace std;
typedef pair<int,int> P;
typedef long long ll;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0;}
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0;}
int main() {
ll x,y;
cin >> x >> y;
ll ans = 0;
while(x<=y) {
ans++;
x *= 2;
}
cout << ans << endl;
} | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<vector<int>> Graph;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
#define pi 3.14159265359
#define inf 2147483647
#define INF 9223372036854775807
#define mod 1000000007
#define mod2 998244353
int main() {
ll X, Y; cin >> X >> Y;
ll ans = 1;
while(X * 2 <= Y) {
X *= 2;
ans++;
}
cout << ans << endl;
return 0;
} | 1 | 84,092,029 |
#include <iostream>
#include <cstdio>
#include <utility>
using namespace std;
class Dice{
int T,S,E,W,N,D;
public:
Dice(int T, int S, int E,
int W, int N, int D)
: T(T), S(S), E(E),
W(W), N(N), D(D) {}
int get_top(){ return T; }
int get_south(){ return S; }
int get_east() { return E; }
void rot(char c){
int tmp;
tmp = T;
switch(c){
case 'N':
T = S; S = D; D = N; N = tmp;
break;
case 'S':
T = N; N = D; D= S; S = tmp;
break;
case 'E':
T = W; W = D; D = E; E = tmp;
break;
case 'W':
T = E; E = D; D = W; W = tmp;
break;
}
}
};
int main(){
int num[6];
for(int i=0;i<6;i++) cin>>num[i];
Dice dice(num[0],num[1],num[2],num[3],num[4],num[5]);
int n;
cin>>n;
for(int i=0;i<n;i++){
int front,top;
cin>>top>>front;;
int counter = 0;
while(front!=dice.get_south()){
if(counter == 3) dice.rot('W');
dice.rot('S');
counter ++;
}
while(top!=dice.get_top()){
dice.rot('W');
}
cout<<dice.get_east()<<endl;
}
return 0;
} | #include <iostream>
#include <string>
using namespace std;
class Dice
{
private:
int top, front, right, left, back, bottom, temp;
public:
void set(int *nums)
{
this->top = nums[0];
this->front = nums[1];
this->right = nums[2];
this->left = nums[3];
this->back = nums[4];
this->bottom = nums[5];
}
int getTop() { return this->top; }
int getFront() { return this->front; }
int getRight() { return this->right; }
int getLeft() { return this->left; }
int getBack() { return this->back; }
int getBottom() { return this->bottom; }
void east()
{
this->temp = this->top;
this->top = this->left;
this->left = this->bottom;
this->bottom = this->right;
this->right = this->temp;
}
void west()
{
this->temp = this->top;
this->top = this->right;
this->right = this->bottom;
this->bottom = this->left;
this->left = this->temp;
}
void north()
{
this->temp = this->top;
this->top = this->front;
this->front = this->bottom;
this->bottom = this->back;
this->back = this->temp;
}
void south()
{
this->temp = this->top;
this->top = this->back;
this->back = this->bottom;
this->bottom = this->front;
this->front = this->temp;
}
};
int main(int argc, char *argv[])
{
Dice dice;
int nums[6];
for (int i = 0; i < 6; i++)
cin >> nums[i];
dice.set(nums);
int q_num, top, front;
cin >> q_num;
while (0 < q_num--)
{
cin >> top >> front;
if (dice.getTop() == top && dice.getFront() == front)
{
cout << dice.getRight() << endl;
continue;
}
else
{
if (dice.getRight() != front && dice.getLeft() != front)
{
while (dice.getFront() != front)
{
dice.south();
}
}
else
{
if (dice.getRight() == front)
{
dice.west();
dice.south();
}
else
{
dice.east();
dice.south();
}
}
if (dice.getTop() != top)
{
while (dice.getTop() != top)
{
dice.east();
}
}
cout << dice.getRight() << endl;
continue;
}
}
return 0;
} | 1 | 71,362,692 |
#include <iostream>
#include <string>
using namespace std;
int main()
{
while (true) {
int n;
cin >> n;
if (n == 0) {
break;
}
int count = 0;
bool leftdown = true;
bool rightdown = true;
bool up = false;
for (int i = 0; i < n; i++) {
string str;
cin >> str;
if (str == "lu") {
leftdown = false;
if (up == false && rightdown == false) {
up = true;
count++;
}
}
else if (str == "ru") {
rightdown = false;
if (up == false && leftdown == false) {
up = true;
count++;
}
}
else if (str == "ld") {
leftdown = true;
if (up == true && rightdown == true) {
up = false;
count++;
}
}
else {
rightdown = true;
if (up == true && leftdown == true) {
up = false;
count++;
}
}
}
cout << count << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using i64 = long long;
#define rep(i,s,e) for(i64 (i) = (s);(i) < (e);(i)++)
#define all(x) x.begin(),x.end()
#define let auto const
int main() {
i64 n;
while(cin >> n, n) {
vector<string> f(n);
rep(i,0,n) cin >> f[i];
i64 now = 0;
i64 state = 0;
i64 ans = 0;
for(auto& x: f) {
if(x == "lu") {
state ^= 1;
}
if(x == "ru") {
state ^= 2;
}
if(x == "ld") {
state ^= 1;
}
if(x == "rd") {
state ^= 2;
}
if((now ^ state) == 3) {
ans++;
now = state;
}
}
cout << ans << endl;
}
} | 1 | 49,728,423 |
#include <iostream>
using namespace std;
const int MAX = 100000;
int parent(int i){
return i/2;
}
int left(int i){
return 2*i;
}
int right(int i){
return 2*i + 1;
}
int main() {
ios::sync_with_stdio(false);
int H, i, A[MAX+1];
cin >> H;
for(i=1; i<=H; i++) cin >> A[i];
for(i=1; i<=H; i++){
cout << "node " << i << ": key = " << A[i] << ", ";
if(parent(i) >=1) cout << "parent key = " << A[parent(i)] << ", ";
if(left(i) <= H) cout << "left key = " << A[left(i)] << ", ";
if(right(i) <= H) cout << "right key = " << A[right(i)] << ", ";
cout << endl;
}
return 0;
} | #include <iostream>
#include <cstdio>
using namespace std;
int parent(int i) { return i / 2; }
int left(int i) { return 2 * i; }
int right(int i) { return 2 * i + 1; }
int main()
{
int H[300];
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &H[i]);
for (int i = 1; i <= n; i++) {
printf("node %d: key = %d, ", i, H[i]);
if (parent(i) >= 1)
printf("parent key = %d, ", H[parent(i)]);
if (left(i) <= n)
printf("left key = %d, ", H[left(i)]);
if (right(i) <= n)
printf("right key = %d, ", H[right(i)]);
printf("\n");
}
return 0;
} | 1 | 73,899,398 |
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
const ll mod = 1000000007;
const int INF = 1001001001;
int main(){
ll n ; cin >> n;
vector<ll> a(n);
rep(i,n){
cin >> a.at(i);
}
sort(a.begin(),a.end());
ll x = a.at(0);
ll y = a.at(n-1);
vector<pair<ll,ll>> op;
ll mxm;
if(x>=0){
ll m = a.at(0);
for(int i=1;i<n-1;i++){
op.push_back(make_pair(m,a.at(i)));
m = m - a.at(i);
}
op.push_back(make_pair(a.at(n-1),m));
mxm = a.at(n-1) - m;
}else if(y<0){
ll m = a.at(n-1);
for(int i=0;i<n-1;i++){
op.push_back(make_pair(m,a.at(i)));
m = m - a.at(i);
}
mxm = m;
}else{
ll m = a.at(0);
auto it = lower_bound(a.begin(),a.end(),0);
ll start = it - a.begin();
for(int i=start;i<n-1;i++){
op.push_back(make_pair(m,a.at(i)));
m = m - a.at(i);
}
op.push_back(make_pair(a.at(n-1),m));
m = a.at(n-1) - m;
for(int i=1;i<start;i++){
op.push_back(make_pair(m,a.at(i)));
m = m - a.at(i);
}
mxm = m;
}
cout << mxm << endl;
for(auto i:op){
cout << i.first << " " << i.second << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(){
long long int N,ans=0,tmpf,tmpb;
cin >> N;
vector<long long int> A(N);
vector<pair<long long int,long long int>> P;
for(int i=0;i<N;i++){
cin >> A[i];
}
sort(A.begin(),A.end());
tmpf = A[0];
tmpb = A.back();
for(int i=1;i<N-1;i++){
if(0<=A[i]){
P.push_back({tmpf,A[i]});
tmpf -= A[i];
}else{
P.push_back({tmpb,A[i]});
tmpb -= A[i];
}
}
P.push_back({tmpb,tmpf});
cout << tmpb - tmpf << endl;
for(int i=0;i<N-1;i++){
cout << P[i].first << " " << P[i].second << endl;
}
} | 1 | 29,374,779 |
#include <iostream>
using namespace std;
int main() {
int x;
cin >> x;
cout << ((x < 1200) ? "ABC" : "ARC") << endl;
return 0;
} | #include <iostream>
int main(){int x;std::cin>>x;std::cout<<((x<1200)?"ABC":"ARC");} | 1 | 10,403,702 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int a,cnt=0,cmp;
vector<int> q;
int w[6]={500,100,50,10,5,1};
while(1){
cin >> a;
if(a==0){break;}
q.push_back(a);
}
int g=q.size();
for(int j=0;j<g;j++){
cmp=1000-q[j];
for(int i=0;i<6;i++){
cnt+=cmp/w[i];
cmp-=w[i]*(cmp/w[i]);
}
cout << cnt << endl;
cnt=0;
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
#define all(c) (c).begin(), (c).end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define pb(e) push_back(e)
#define mp(a, b) make_pair(a, b)
#define fr first
#define sc second
const ll INF = 1e9;
const ll MOD = 1e9 + 7;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int main() {
int n;
int coins[] = {500, 100, 50, 10, 5};
while (cin >> n, n) {
int ans = 0;
int m = 1000 - n;
rep(i, 5) {
ans += m / coins[i];
m %= coins[i];
}
ans += m;
cout << ans << endl;
}
return 0;
} | 1 | 14,603,851 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define MIN(a,b) ((a)>(b)? (b): (a))
#define MAX(a,b) ((a)<(b)? (b): (a))
const long long INF = 1LL << 60;
typedef unsigned long long ll;
const long long MOD = 1000000000 + 7;
int main(){
string a, b, c;
cin >> a >> b >> c;
if(a[a.size()-1] == b[0] && b[b.size()-1] == c[0])
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
} | #include <bits/stdc++.h>
#define PI 3.14159265359
#define NIL -1
using namespace std;
const int64_t MOD = 1e9 + 7;
int main() {
string A, B, C;
cin >> A >> B >> C;
char a, b, c, d;
a = A.at(A.size() - 1);
b = B.at(0);
c = B.at(B.size() - 1);
d = C.at(0);
if ((a == b) && (c == d)) {
cout << "YES" << endl;
}
else {
cout << "NO" << endl;
}
} | 1 | 33,833,475 |
#include <bits/stdc++.h>
using namespace std;
#define all(v) v.begin(), v.end()
#define V vector
#define P pair
typedef long long ll;
const int INT_INF = 1e9;
const ll INF = 1LL << 30;
int main() {
ll n; cin >> n;
V<ll> v(n);
for(int i = 0; i < n; i++){
ll a; cin >> a;
v[i] = a - (i + 1);
}
sort(all(v));
ll b = v[n / 2];
ll ans = 0;
for(int i = 0; i < n; i++){
ans += abs(v[i] - b);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1e9+7;
int main() {
ll n;
cin >> n;
if(n==1){
cout << 0 << endl;
return 0;
}
vector<ll>a(n);
for(ll i=0;i<n;i++){
cin >> a[i];
a[i]-=(i+1);
}
sort(a.begin(),a.end());
ll ans=0;
for(ll i=0;i<n;i++){
if(a[i]<0) ans-=a[i];
else ans+=a[i];
}
ll mcnt=0;
for(ll i=0;i<n;i++){
if(a[i]>0){
break;
}
mcnt++;
}
ll pcnt=n-mcnt;
ll da=0;
if(n%2==1){
ll mid=n/2;
if(mid>mcnt){
while(a[mid]!=0){
a[mcnt]-=da;
ll b=a[mcnt];
a[mcnt]=0;
ans-=b*(pcnt-mcnt);
da+=b;
pcnt--;
mcnt++;
}
}
else {
while(a[mid]!=0){
a[n-pcnt-1]-=da;
ll b=a[n-pcnt-1];
a[n-pcnt-1]=0;
ans-=b*(pcnt-mcnt);
da+=b;
pcnt++;
mcnt--;
}
}
}
else {
ll mid=n/2;
if(mid>mcnt){
while(mcnt!=pcnt){
a[mcnt]-=da;
ll b=a[mcnt];
ans-=b*(pcnt-mcnt);
da+=b;
pcnt--;
mcnt++;
}
}
else {
while(mcnt!=pcnt){
a[n-pcnt-1]-=da;
ll b=a[n-pcnt-1];
ans-=b*(pcnt-mcnt);
da+=b;
pcnt++;
mcnt--;
}
}
}
cout << ans << endl;
} | 1 | 37,027,836 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using P = pair<int, int>;
int modPow(long long a, long long n, long long p) {
if (n == 0) return 1;
if (n == 1) return a % p;
if (n % 2 == 1) return (a * modPow(a, n - 1, p)) % p;
long long t = modPow(a, n / 2, p);
return (t * t) % p;
}
signed main() {
int a, b;
cin >> a >> b;
if (a > b) {
rep (i, a) cout << b;
} else {
rep (i, b) cout << a;
}
cout << endl;
} | #include<bits/stdc++.h>
using namespace std;
int main()
{
int a,b;
cin>>a>>b;
int n=min(a,b);
int m=max(a,b);
for(int i=0;i<m;i++)
cout<<n;
} | 1 | 45,060,100 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int MOD = 1e9 + 7;
void add(int &a, int b)
{
a = (a + b) % MOD;
}
int main()
{
int n, k;
cin >> n >> k;
vector<int> a(n);
for(int i = 0; i < n; i++) cin >> a[i];
vector<vector<int>> dp(n+1, vector<int>(k+1, 0));
dp[0][0] = 1;
for(int i = 1; i <= n; i++)
{
int num = 0;
for(int j = 0; j <= k; j++)
{
add(num, dp[i-1][j]);
dp[i][j] = num;
if(j-a[i-1] >= 0) add(num, -dp[i-1][j-a[i-1]]);
}
}
cout << (dp[n][k]+MOD)%MOD << endl;
} | #include <bits/stdc++.h>
#include <math.h>
using namespace std;
typedef long long ll;
# define M_PI 3.14159265358979323846
const int MOD=1e9+7;
void solve(){
int n,k;
cin>>n>>k;
vector<int>a(n+1);
for(int i=1;i<=n;i++)
cin>>a[i];
int dp[n+1][k+1];
dp[0][0]=1;
for(int i=1;i<=k;i++)
dp[0][i]=0;
for(int i=1;i<=n;i++){
vector<int>sum(k+1);
sum[0]=dp[i-1][0];
for(int j=1;j<=k;j++)
sum[j]=(sum[j-1]+dp[i-1][j])%MOD;
for(int j=0;j<=k;j++){
if(j<=a[i])
dp[i][j]=sum[j];
else{
int non_existing=j-a[i]-1;
dp[i][j]=(sum[j]-sum[non_existing]+MOD)%MOD;
}
}
sum.clear();
}
cout<<dp[n][k];
}
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout<<fixed;
cout<<setprecision(10);
int t=1;
for(int i=1;i<=t;i++){
solve();
}
return 0;
} | 1 | 2,545,132 |
#include <iostream>
using namespace std;
int width, height;
int ans = 0;
char map[20][20];
int checked[20][20];
void search(int x, int y);
int main(){
while (1) {
ans = 0;
for (int y=0; y<20; y++) {
for (int x=0; x<20; x++) {
map[y][x] = '#';
checked[y][x] = 0;
}
}
cin >> width >> height;
if (width==0 && height==0) {
break;
}
int startX, startY;
for (int y=0; y<height; ++y) {
for (int x=0; x<width; ++x) {
cin >> map[y][x];
if (map[y][x] == '@') {
map[y][x] = '.';
startX = x;
startY = y;
}
}
}
search(startX, startY);
cout << ans << endl;
}
return 0;
}
void search(int x, int y) {
ans++;
static const int diffX[] = {0,-1,1,0};
static const int diffY[] = {-1,0,0,1};
checked[y][x] = 1;
for (int ite=0; ite<4; ++ite) {
int nowX = x + diffX[ite];
int nowY = y + diffY[ite];
if (nowX < 0 || nowX >= 20 || nowY < 0 || nowY >= 20) continue;
if (checked[nowY][nowX] == 0 && map[nowY][nowX] == '.') {
search(nowX, nowY);
}
}
} | #include <bits/stdc++.h>
using namespace std;
#define iota(i,n,b,s) for(int i=int(b);i!=int((b)+(s)*(n));i+=(s))
#define range(i,n,m) iota(i,(((n)>(m))?((n)-(m)+1):((m)-(n)+1)),(n),((n)>(m)?-1:1))
#define rep(i,n) iota(i,(n),0,1)
#define INF (1e9)
#define EPS (1e-9)
#define cons(a,b) (make_pair(a,b))
#define car(a) (a.first)
#define cdr(a) (a.second)
#define cadr(a) (car(cdr(a)))
#define cddr(a) (cdr(cdr(a)))
#define all(a) a.begin(), a.end()
#define trace(var) cerr<<">>> "<<#var<<" = "<<var<<endl;
typedef long long INTEGER;
typedef double FLOAT;
template<class S, class T>
ostream& operator<<(ostream& os, pair<S,T> p) {
os << '(' << car(p) << ", " << cdr(p) << ')';
return os;
}
template<class T>
ostream& operator<<(ostream& os, vector<T> v) {
os << v[0];
for (int i=1, len=v.size(); i<len; ++i) os << ' ' << v[i];
return os;
}
int main()
{
entry:;
int w, h; cin >> w >> h;
if (!w && !h) return 0;
int f[h][w];
int ci, cj;
rep (i, h) {
string s; cin >> s;
rep (j, s.size()) {
if (s[j] == '.') {
f[i][j] = 1;
} else if (s[j] == '@') {
f[i][j] = 1;
ci = i;
cj = j;
} else {
f[i][j] = 0;
}
}
}
stack<pair<int,int>> s;
s.push(cons(ci, cj));
int ans = 0;
while (!s.empty()) {
pair<int, int> x = s.top(); s.pop();
if (f[car(x)][cdr(x)] == 0) continue;
f[car(x)][cdr(x)] = 0;
++ans;
if (car(x) > 0) s.push(cons(car(x) - 1, cdr(x)));
if (cdr(x) > 0) s.push(cons(car(x), cdr(x) - 1));
if (car(x) < h - 1) s.push(cons(car(x) + 1, cdr(x)));
if (cdr(x) < w - 1) s.push(cons(car(x), cdr(x) + 1));
}
cout << ans << endl;
goto entry;
return 0;
} | 1 | 91,126,201 |
#include <bits/stdc++.h>
using namespace std;
#define x first
#define y second
#define dbg(x) cout << #x << '=' << x << '\n';
#define ll long long
#define pi pair<int,int>
#define pl pair<long long,long long>
#define lg length()
#define pb push_back
ifstream in("file.in");
ofstream out("file.out");
#define MAXN 100005
#define INF 1e9+5
#define int long long
#define LINF 1000000000000000005
int n,x,y,k[100005],r,v[100005],t[100005],ans,f;
vector <int> g[100005];
void DFS(int nod){
v[nod]=1;
int cnt1=0,cnt0=0;
for(int i : g[nod]){
if(!v[i]){
DFS(i);
if(!t[i]) cnt0++;
else cnt1++;
}
}
if(cnt1 && !cnt0) t[nod]=0;
else if(cnt0==1) t[nod]=1;
else if(cnt0>1) f=1;
}
int32_t main(){
ios_base :: sync_with_stdio(0);
cin >> n;
for(int i=1;i<n;i++){
cin >> x >> y;
g[x].pb(y); g[y].pb(x);
k[x]++; k[y]++;
}
if(n==2){
cout << "Second";
return 0;
}
r=1;
while(k[r]==1) r++;
DFS(r);
if(f || !t[r]) cout << "First";
else cout << "Second";
} | #include <iostream>
#include <vector>
using namespace std;
const int MAXn = 1e5 + 10;
vector<int> g[MAXn];
int n, odd[MAXn], even[MAXn];
int dfs(int v, int par) {
if (g[v].size() == 1 && par != 0)
return 1;
int cnt = 0;
for (int i = 0; i < g[v].size(); i++)
if (g[v][i] != par) {
cnt += dfs(g[v][i], v);
}
if (cnt > 1) {
cout << "First";
exit(0);
}
if (cnt == 1)
return 0;
if (par == 0) {
cout << "First";
exit(0);
}
return 1;
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u>> v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1, 0);
cout << "Second";
} | 1 | 5,635,189 |
#include <bits/stdc++.h>
using namespace std;
#define R (long long)(1e9 + 7)
#define INF (long long)(1e16L + 5)
#define ll long long
#define grid vector<vector<ll>>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int h, w, m;
cin >> h >> w >> m;
vector<pair<int, int>> p(m);
for(pair<int, int>& x : p)
cin >> x.first >> x.second;
map<int, vector<int>> x, y;
for(auto point : p)
{
x[point.first].push_back(point.second);
y[point.second].push_back(point.first);
}
int ans = 0;
for(auto point : p)
{
ans = max(ans, (int)x[point.first].size() + (int)y[point.second].size() - 1);
}
int mx_x = 0;
for(auto e : x)
{
mx_x = max(mx_x, (int)(e.second.size()));
}
map<int, int> ys;
int cnt = 0;
for(auto e : x)
{
if(e.second.size() == mx_x)
{
for(auto y : e.second)
ys[y]++;
cnt++;
}
}
for(int i = 1; i <= max(w, h); i++)
{
if(ys[i] != cnt)
{
ans = max(ans, (int)y[i].size() + mx_x);
}
}
cout << ans << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define pb push_back
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
#define FOR(i, a, b) for (int i = a; i <= (b); i++)
#define ROF(i, a, b) for (int i = a; i >= (b); i--)
using pii = pair<int, int>; using vpii = vector<pii>;
using vi = vector<int>; using vvi = vector<vi>;
using ll = long long;
using pll = pair<ll, ll>; using vpll = vector<pll>;
using vll = vector<ll>; using vvll = vector<vll>;
int main() {
int h, w, m; cin >> h >> w >> m;
vector <map <int, bool> > cy(h + 1);
vi sx(h + 1), sy(w + 1);
FOR(i, 1, m) {
int x, y; cin >> x >> y;
cy[x][y] = 1, sx[x]++, sy[y]++;
}
priority_queue <pii> pq;
FOR(i, 1, w)
pq.push({sy[i], i});
int ans = 0;
FOR(i, 1, h) {
if (sx[i]) {
vpii rm;
int tmx = 0;
while (!pq.empty() && cy[i][pq.top().se]) {
tmx = max(tmx, pq.top().fi - 1);
rm.pb(pq.top()); pq.pop();
}
if (!pq.empty()) tmx = max(tmx, pq.top().fi);
ans = max(ans, sx[i] + tmx);
for (pii j : rm) pq.push(j);
}
}
cout << ans << endl;
} | 1 | 22,075,460 |
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
void solve()
{
ll a[] = {1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51};
ll k;
cin>>k;
cout<<a[k-1]<<endl;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
{
solve();
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vl ;
typedef pair<ll,ll> pl;
#define mp make_pair
#define pb push_back
#define f first
#define s second
#define rep(i,N) for(int i=0; i < (int)N; i++)
#define all(v) (v).begin(),(v).end()
const int MOD = 998244353;
const int INF = 100000002;
const double PI =4*atan(1);
const double eps = 1e-7;
const long long oo = 1e18;
int main(){
vector<int> data = {1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51};
int K;
cin >> K;
cout << data[K-1] << endl;
} | 1 | 80,119,618 |
Subsets and Splits