solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
#include<iostream>
#include<string>
#include<vector>
using namespace std;
const int INF = 100000000;
vector<vector<int> > calcNext(const string &S) {
int n = (int)S.size();
vector<vector<int> > res(n+1, vector<int>(2, n));
for (int i = n-1; i >= 0; --i) {
for (int j = 0; j < 2; ++j) res[i][j] = res[i+1][j];
res[i][S[i]-'0'] = i;
}
return res;
}
int main(){
//input
string P,Q;
cin >> P >> Q;
//calc
vector<vector<int> > nextP = calcNext(P);
vector<vector<int> > nextQ = calcNext(Q);
int n=P.length(), m=Q.length();
vector<vector<int> > dp(n+1,vector<int>(m+1,INF));
int i,j,k;
for(i=n; i>=0; i--){
for(j=m; j>=0; j--){
for(k=0; k<=1; k++){
if(nextP[i][k]>=n && nextQ[j][k]>=m){
dp[i][j]=1;
}else if(nextP[i][k]>=n){
dp[i][j]=min(dp[i][j],dp[n][nextQ[j][k]+1]+1);
}else if(nextQ[j][k]>=m){
dp[i][j]=min(dp[i][j],dp[nextP[i][k]+1][m]+1);
}else{
dp[i][j]=min(dp[i][j],dp[nextP[i][k]+1][nextQ[j][k]+1]+1);
}
}
}
}
//output
int nowi=0, nowj=0;
while(dp[nowi][nowj]>1){
for(k=0; k<=1; k++){
if(nextP[nowi][k]+1>n&&nextQ[nowj][k]+1>m){
cout << k;
nowi = n;
nowj = m;
break;
}else if(nextP[nowi][k]+1>n){
if(dp[nowi][nowj]==dp[n][nextQ[nowj][k]+1]+1){
cout << k;
nowi = n;
nowj = nextQ[nowj][k]+1;
break;
}
}else if(nextQ[nowj][k]+1>m){
if(dp[nowi][nowj]==dp[nextP[nowi][k]+1][m]+1){
cout << k;
nowi = nextP[nowi][k]+1;
nowj = m;
break;
}
}else if(dp[nowi][nowj]==dp[nextP[nowi][k]+1][nextQ[nowj][k]+1]+1){
cout << k;
nowi = nextP[nowi][k]+1;
nowj = nextQ[nowj][k]+1;
break;
}
}
}
for(k=0; k<=1; k++){
if(nextP[nowi][k]>=n && nextQ[nowj][k]>=m){
cout << k << endl;
break;
}
}
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
std::cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, m;
cin >> n >> m;
long long int min = m * 2;
if (min >= n) {
min = 0;
} else {
min = n - min;
}
long long int dp[n + 1];
dp[0] = 0;
long long int ind = -1;
for (long long int i = 0; i <= n; i++) {
if (i == 0) {
dp[i] = 0;
} else {
dp[i] = dp[i - 1] + i - 1;
}
if (dp[i] >= m) {
ind = i;
break;
}
}
long long int max;
if (ind == -1) {
max = 0;
} else {
max = n - ind;
}
cout << min << " " << max;
return 0;
}
| 8 | CPP |
a = int(input())
s = 3*a*a
print(s)
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
int fin(int rem) {
for (auto p : mp) {
if (p.first >= rem) return p.first;
}
return -1;
}
int main() {
long long ans = 0, rem = 0, p, x, y, n, RES = 1e9;
cin >> n >> x >> y;
long long a[] = {x, x, x, x, y, y};
sort(a, a + 6);
do {
mp.clear();
ans = 0;
for (int i = 0; i < 6; ++i) {
if ((x = fin(a[i])) == -1) {
++ans;
++mp[n - a[i]];
} else {
++mp[x - a[i]];
if (!--mp[x]) mp.erase(x);
}
}
RES = min(RES, ans);
} while (next_permutation(a, a + 6));
cout << RES;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int A[] = {
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0,
1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1,
1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1,
1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1,
0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1,
0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0,
1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0,
0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0,
1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0,
0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1,
0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,
1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1,
1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,
1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1,
1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1,
0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1,
0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1,
1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1,
1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1,
1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0,
0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1,
0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0,
1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1,
0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1,
0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0,
1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1,
0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1,
1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1,
0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0,
0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0,
1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0,
1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1,
1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0,
1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0,
1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0,
0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0,
1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0,
0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1,
0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1,
1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0,
0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0,
1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0,
0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0,
1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1,
1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1,
1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0,
0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0,
1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0,
1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,
0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1,
1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1,
1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0,
1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1,
0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0,
1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0,
0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1,
1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0,
0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1,
1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1,
0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1,
1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0,
1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0,
1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1,
0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0,
0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1,
1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1,
0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1,
1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1,
0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0,
0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0,
0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1,
0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1,
0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0,
1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1,
1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1,
0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1,
1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1,
0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0,
0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1,
1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0,
0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0,
1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1,
0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0,
1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1,
0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0,
1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0,
1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1,
0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0,
1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0,
0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1,
1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0,
1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1,
1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1,
1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1,
0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0,
0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1,
1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0,
1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0,
0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1,
1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1,
1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1,
0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0,
0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0,
1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,
0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0,
0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1,
1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0,
0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
int main() {
int x, y, z;
cin >> x >> y;
z = x * 64 + y;
if (A[z])
cout << "OUT" << endl;
else
cout << "IN" << endl;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline char nchar() {
static const int bufl = 1 << 20;
static char buf[bufl], *a = NULL, *b = NULL;
return a == b && (b = (a = buf) + fread(buf, 1, bufl, stdin), a == b) ? EOF
: *a++;
}
template <class T>
inline T read() {
T x = 0, f = 1;
char c = nchar();
for (; !isdigit(c); c = nchar())
if (c == '-') f = -1;
for (; isdigit(c); c = nchar()) x = x * 10 + c - '0';
return x * f;
}
template <>
char read<char>() {
char c = nchar();
for (; !isalpha(c); c = nchar())
;
for (char f = nchar(); isalpha(f); f = nchar())
;
return c;
}
int h, q, last;
namespace tree {
map<int, int> sum;
void add(int x, int d) {
for (; x; x >>= 1) sum[x] += d;
}
inline int size(int x) { return 1 << (h - (31 - __builtin_clz(x))); }
long long calc(int x, int mx) {
if (x >= last) return max(mx, sum[x]);
int lc = x << 1, rc = lc + 1, sl = sum[lc], sr = sum[rc], sx = sum[x];
long long ret = 0;
if (sl > sr) swap(lc, rc), swap(sl, sr);
ret = (long long)size(lc) * max(sx - sl, mx);
ret += calc(rc, max(mx, sx - sr));
return ret;
}
long double ans() {
long double ret = calc(1, 0);
ret /= last;
return ret;
}
} // namespace tree
int main() {
h = read<int>(), q = read<int>(), last = 1 << h;
while (q--) {
char o = read<char>();
if (o == 'a') {
int x = read<int>(), y = read<int>();
tree::add(x, y);
} else
printf("%.12lf\n", (double)tree::ans());
}
return 0;
}
| 10 | CPP |
n = int(input())
a = list(map(int, input().split()))
for i in a:
if a[a[a[i-1]-1]-1]==i:
print('yes')
exit()
print('no') | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
vector<pair<int, int> > b;
vector<pair<int, int> > w;
for (int i = 0; i < 8; ++i) {
cin >> s;
for (int j = 0; j < 8; ++j) {
if (s[j] == 'W') {
w.push_back(make_pair(i, j));
} else if (s[j] == 'B') {
b.push_back(make_pair(i, j));
}
}
}
int wpotmin = 10, bpotmin = 10;
for (int i = 0; i < w.size(); ++i) {
bool gre = true;
for (int j = 0; j < b.size(); ++j) {
if (w[i].second == b[j].second && w[i].first > b[j].first) {
gre = false;
}
}
if (gre) {
wpotmin = min(wpotmin, w[i].first);
}
}
for (int i = 0; i < b.size(); ++i) {
bool gre = true;
for (int j = 0; j < w.size(); ++j) {
if (b[i].second == w[j].second && b[i].first < w[j].first) {
gre = false;
}
}
if (gre) {
bpotmin = min(bpotmin, 7 - b[i].first);
}
}
if (wpotmin - 1 < bpotmin) {
cout << "A" << endl;
} else {
cout << "B" << endl;
}
return 0;
}
| 7 | CPP |
t=int(input())
count,count1=0,0
for i in range(t):
x,y=map(int,input().split())
if x>y:
count+=1
elif x<y:
count1+=1
else:
continue
if count==count1:
print('Friendship is magic!^^')
elif count<count1:
print('Chris')
else:
print('Mishka') | 7 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
const int maxn=2*1e5+100;
int a[maxn],b[maxn],s[maxn],vl[maxn],vr[maxn];
int main()
{
int n,t,last,ans2=0,ans1=0;
scanf("%d",&n);
for(int i=0; i<n; i++)
{
scanf("%d %d",&a[i],&b[i]);
s[a[i]]++,s[b[i]]--;
vl[a[i]]++,vr[b[i]]++;
}
for(int i=1; i<=100000; i++)
{
ans2=max(s[i]=s[i-1]+s[i],ans2);
vr[i]+=vr[i-1];
vl[100001-i]+=vl[100002-i];
}
for(int i=0; i<n; i++)ans1=max(n-vl[b[i]]-vr[a[i]],ans1);
printf("%d %d\n",ans1,ans2);
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MaxM = 3e5;
template <class T>
void read(T &);
class SegTree {
struct Node {
int val;
Node *lc, *rc;
Node() { lc = rc = NULL; }
inline void setRange(int L, int R, int setVal) { this->val = setVal; }
inline void pushdown(int L, int R) {
if (this->val) {
int mid = (L + R) >> 1;
this->lc->setRange(L, mid, this->val);
this->rc->setRange(mid + 1, R, this->val);
this->val = 0;
}
}
} * root;
int n, aimL, aimR, optVal;
Node *build(int L, int R) {
Node *no = new Node;
no->val = 0;
if (L == R) return no;
int mid = (L + R) >> 1;
no->lc = build(L, mid);
no->rc = build(mid + 1, R);
return no;
}
void modify(Node *&no, int L, int R) {
if (aimL <= L && R <= aimR) {
no->setRange(L, R, optVal);
return;
}
no->pushdown(L, R);
int mid = (L + R) >> 1;
if (aimL <= mid) modify(no->lc, L, mid);
if (mid < aimR) modify(no->rc, mid + 1, R);
}
int query(Node *&no, int L, int R) {
if (L == R && L == aimL) return no->val;
no->pushdown(L, R);
int mid = (L + R) >> 1, re;
if (aimL <= mid)
re = query(no->lc, L, mid);
else
re = query(no->rc, mid + 1, R);
return re;
}
inline void config(int aL = 0, int aR = 0, int oV = 0) {
aimL = aL;
aimR = aR;
optVal = oV;
}
public:
inline void init(int lim) {
n = lim;
root = build(1, n);
}
inline void Modify(int L, int R, int value) {
if (L > R) return;
config(L, R, value);
modify(root, 1, n);
}
inline int Query(int x) {
config(x);
return query(root, 1, n);
}
} S;
struct Match {
int L, R, winner;
} a[MaxM + 5];
int n, m;
int main() {
read(n);
read(m);
for (int i = 1; i <= m; i++) {
read(a[i].L);
read(a[i].R);
read(a[i].winner);
}
S.init(n);
for (int i = m; i >= 1; i--) {
S.Modify(a[i].L, a[i].winner - 1, a[i].winner);
S.Modify(a[i].winner + 1, a[i].R, a[i].winner);
}
for (int i = 1; i <= n; i++) printf("%d ", S.Query(i));
return 0;
}
template <class T>
void read(T &re) {
char c;
T flag = 1;
while ((c = getchar()) < '0' || c > '9') {
if (c == '-') flag = -1;
}
re = c - '0';
while ((c = getchar()) >= '0' && c <= '9') {
re = (re << 3) + (re << 1) + (c - '0');
}
re *= flag;
}
| 7 | CPP |
def solve(arr,n,ans):
total = 0
for i in range(n-1):
total += max(0,arr[i]-arr[i+1])
ans.append(str(total))
def main():
t = int(input())
ans = []
for i in range(t):
n = int(input())
arr = list(map(int,input().split()))
solve(arr,n,ans)
print('\n'.join(ans))
main()
| 9 | PYTHON3 |
n=input()
x=0
y=len(n)
c='a'
for i in range(0,y):
if int(n[i])%2==0 and n[i]<n[y-1]:
c=n[i]
x=i
break
if c=='a':
for i in range(1,y):
if int(n[y-i-1])%2==0:
c=n[y-i-1]
x=y-i-1
break
if c=='a':
print(-1)
else:
for i in range(0,y):
if i==x:
print(n[y-1],end="")
elif i==y-1:
print(c,end="")
else:
print(n[i],end="")
| 8 | PYTHON3 |
x = input()
z=0
for i in range(int(x)) :
y=sum(map(int, input().split()))
if y > 1 :
z+=1
print (z)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
const long long maxn = 2e3 + 10;
const long long mod = 1e9 + 7;
const long long base = 3e18;
long long dp[maxn][2 * maxn];
long long dp1[maxn][2 * maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
if (fopen("t.inp", "r")) {
freopen("test.inp", "r", stdin);
freopen("test.out", "w", stdout);
}
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
string s, t;
cin >> s >> t;
s = " " + s;
t = " " + t;
long long len = n;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= 2 * n; j++) {
dp[i][j] = 0;
dp1[i][j] = 0;
}
}
dp[0][0 + len] = 1;
for (long long i = 1; i <= n; i++) {
for (int j = 0; j <= 2 * n; j++) {
vector<long long> vt;
vector<long long> vt1;
if (s[i] == '?') {
vt.push_back(1);
vt.push_back(0);
} else if (s[i] == '1') {
vt.push_back(1);
} else {
vt.push_back(0);
}
if (t[i] == '?') {
vt1.push_back(1);
vt1.push_back(0);
} else if (t[i] == '1') {
vt1.push_back(1);
} else {
vt1.push_back(0);
}
for (auto to : vt) {
for (auto to1 : vt1) {
long long x = to;
long long y = to1;
if (i % 2 == 0) x = 1 - x, y = 1 - y;
if (x == y) {
dp[i][j] = (dp[i][j] + dp[i - 1][j]) % mod;
dp1[i][j] = (dp1[i][j] + dp1[i - 1][j]) % mod;
} else if (x) {
if (j + 1 <= 2 * n) {
if (j >= n) {
dp[i][j + 1] = (dp[i][j + 1] + dp[i - 1][j]) % mod;
dp1[i][j + 1] =
((dp1[i][j + 1] + dp1[i - 1][j] - dp[i - 1][j] * i) %
mod +
mod) %
mod;
} else {
dp[i][j + 1] = (dp[i][j + 1] + dp[i - 1][j]) % mod;
dp1[i][j + 1] =
((dp1[i][j + 1] + dp1[i - 1][j] + dp[i - 1][j] * i) %
mod +
mod) %
mod;
}
}
} else {
if (j != 0) {
if (j <= n) {
dp[i][j - 1] = (dp[i][j - 1] + dp[i - 1][j]) % mod;
dp1[i][j - 1] =
((dp1[i][j - 1] + dp1[i - 1][j] - dp[i - 1][j] * i) %
mod +
mod) %
mod;
} else {
dp[i][j - 1] = (dp[i][j - 1] + dp[i - 1][j]) % mod;
dp1[i][j - 1] =
((dp1[i][j - 1] + dp1[i - 1][j] + dp[i - 1][j] * i) %
mod +
mod) %
mod;
}
}
}
}
}
}
}
cout << dp1[n][n] << "\n";
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
string table;
char C[5][5];
cin >> table;
for (int i = 0; i < 5; i++) cin >> C[i];
for (int i = 0; i < 5; i++) {
if (table[0] == C[i][0] || table[1] == C[i][1]) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 7 | CPP |
n=int(input())
x,y=[],[]
z=0
for i in range(n):
m=int(input())
if m>0:
z=1
x.append(m)
else:
z=-1
y.append(-m)
if sum(x) != sum(y):
print('first' if sum(x) > sum(y) else 'second')
elif x!=y:
print('first' if x>y else 'second')
else:
print('first' if z>0 else 'second')
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int N = 300000;
char s[N], l[100], r[100];
int d[N][12], a[N], ans, F[N];
int f[51][2][N][2];
int sz = 1;
int getd(int x) {
int i = 0;
while (x) {
x /= 10;
i++;
}
return i;
}
queue<int> Q;
int isak(char *l) {
int D = strlen(l);
int q = 0;
for (int i = 0; i < D; i++) {
q = d[q][l[i] - '0'];
if (a[q]) return 1;
}
return 0;
}
int gas(char *l) {
int n = strlen(l);
memset(f, 0, sizeof(f));
f[0][1][0][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 0; j < sz; j++)
for (int c = 0; c <= 9; c++) {
int q = d[j][c];
f[i][0][q][1] = (f[i][0][q][1] + f[i - 1][0][j][1]) % mod;
if (a[q])
f[i][0][q][1] = (f[i][0][q][1] + f[i - 1][0][j][0]) % mod;
else
f[i][0][q][0] = (f[i][0][q][0] + f[i - 1][0][j][0]) % mod;
if (c + 48 == l[i - 1]) {
f[i][1][q][1] = (f[i][1][q][1] + f[i - 1][1][j][1]) % mod;
if (a[q])
f[i][1][q][1] = (f[i][1][q][1] + f[i - 1][1][j][0]) % mod;
else
f[i][1][q][0] = (f[i][1][q][0] + f[i - 1][1][j][0]) % mod;
} else if (c + 48 < l[i - 1]) {
f[i][0][q][1] = (f[i][0][q][1] + f[i - 1][1][j][1]) % mod;
if (a[q])
f[i][0][q][1] = (f[i][0][q][1] + f[i - 1][1][j][0]) % mod;
else
f[i][0][q][0] = (f[i][0][q][0] + f[i - 1][1][j][0]) % mod;
}
}
int ans = 0;
for (int i = 0; i < sz; i++)
ans = ((ans + f[n][0][i][1]) % mod + f[n][1][i][1]) % mod;
return ans;
}
int main() {
scanf("%s", s);
scanf("%s%s", l, r);
int D = strlen(l);
D /= 2;
int n = strlen(s);
for (int i = 0; i < n - D + 1; i++) {
int q = 0;
for (int j = 0; j < D; j++) {
int c = s[i + j] - '0';
if (!d[q][c]) d[q][c] = sz++;
q = d[q][c];
}
a[q]++;
}
F[0] = -1;
Q.push(0);
while (!Q.empty()) {
int i = Q.front();
Q.pop();
for (int c = 0; c < 10; c++) {
int &u = d[i][c], v = F[i];
if (v != -1)
v = d[v][c];
else
v = 0;
if (!u) {
u = v;
continue;
}
F[u] = v;
Q.push(u);
}
}
return !printf("%d\n", (gas(r) - gas(l) + isak(l) + mod) % mod);
}
| 12 | CPP |
def hersCode(l, r, n, N):
ok = l
ng = r + 1
while abs(ok - ng) > 1:
mid = abs(ok + ng) // 2
if mid * n <= N:
ok = mid
else:
ng = mid
return ng
N, K = list(map(int, input().split()))
MOD = 10 ** 9 + 7
if N == 1:
print(1)
exit()
L = []
t = 1
n = N
while t <= N:
L.append(t)
t = hersCode(t, N, N // t ,N)
D = [0] * len(L)
L.append(N + 1)
for i in range(len(L) - 1):
D[i] = (L[i + 1] - L[i]) % MOD
DP = [[0] * (len(D)) for _ in range(K)]
for i in range(len(D)):
DP[0][i] = D[i]
for i in range(1, K):
S = [0] * len(D)
S[0] = DP[i - 1][0]
for j in range(1, len(D)):
S[j] = S[j - 1] + DP[i - 1][j]
for j in range(len(D)):
DP[i][j] = S[-1 -j] * D[j] % MOD
print(sum(DP[K - 1]) % MOD)
| 0 | PYTHON3 |
en = input().split(' ')
n = int(en[0])
t = int(en[1])
k = int(en[2])
d = int(en[3])
if int(d/t)*k + k < n:
print('YES')
else:
print('NO')
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct rip {
int v;
int index;
rip() : v(0), index(0) {}
bool operator<(const rip& r) const { return v < r.v; }
};
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
rip A[n];
for (int i = 0; i < n; i++) {
cin >> A[i].v;
A[i].index = i + 1;
}
sort(A, A + n);
if (m < n || n == 2) {
cout << -1 << endl;
continue;
}
ll cost = 0;
for (int i = 0; i < n; i++) {
cost += A[i].v * 2;
}
cout << cost << endl;
for (int i = 0; i < n; i++) {
cout << A[i].index << ' ' << A[(i + 1) % n].index << endl;
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, j, k, l, m, n, s, n1, n2, p1, p2;
while (cin >> s >> n1 >> n2) {
cin >> p1 >> p2;
long long a = s * n1 + 2 * p1;
long long b = s * n2 + 2 * p2;
if (a > b) cout << "Second" << endl;
if (a < b) cout << "First" << endl;
if (a == b) cout << "Friendship" << endl;
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e4;
vector<pair<int, int> > adj[MAX];
map<pair<int, int>, int> M;
int n, m, s, t;
long long L;
long long dis1[MAX], dis2[MAX];
set<pair<int, int> > BAD;
bool visited[MAX];
void dijkstra(int t) {
fill(dis1, dis1 + n + 2, 1000000000000000LL);
dis1[t] = 0;
priority_queue<pair<long long, int> > q;
q.push(make_pair(0, t));
while (!q.empty()) {
pair<long long, int> temp = q.top();
q.pop();
int u = temp.second;
long long d = -temp.first;
for (auto j : adj[u])
if (dis1[j.second] > j.first + dis1[u]) {
dis1[j.second] = j.first + dis1[u];
q.push(make_pair(-dis1[j.second], j.second));
}
}
}
bool func() {
dijkstra(t);
fill(dis2, dis2 + n + 2, 1000000000000000LL);
dis2[s] = 0;
priority_queue<pair<long long, int> > q;
q.push(make_pair(0, s));
while (!q.empty()) {
pair<long long, int> temp = q.top();
q.pop();
int u = temp.second;
if (visited[u]) continue;
visited[u] = true;
long long d = -temp.first;
for (auto j : adj[u]) {
int v = j.second;
long long w = j.first;
if (visited[v]) continue;
if (BAD.find(make_pair(min(u, v), max(u, v))) != BAD.end()) {
M[make_pair(min(u, v), max(u, v))] = max(1LL, L - d - dis1[v]);
w = max(1LL, L - d - dis1[v]);
}
if (dis2[v] > dis2[u] + w) {
dis2[v] = dis2[u] + w;
q.push(make_pair(-dis2[v], v));
}
}
}
return dis2[t] == L;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> L >> s >> t;
for (int i = 1; i <= m; i++) {
int u, v, w;
cin >> u >> v >> w;
if (u > v) swap(u, v);
adj[u].push_back(make_pair(max(1, w), v));
adj[v].push_back(make_pair(max(1, w), u));
if (w == 0) BAD.insert(make_pair(u, v));
M[make_pair(u, v)] = w;
}
if (func()) {
cout << "YES" << endl;
for (auto j : M)
cout << j.first.first << " " << j.first.second << " "
<< (j.second == 0 ? 1000000000000000LL : j.second) << endl;
} else
cout << "NO" << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t = 1;
cin >> t;
while (t--) {
int i, j, k = 0, n, m, l, ans = 0;
string s;
cin >> s;
i = 0;
while (i < s.size()) {
l = 0;
while (i < s.size() && s[i] == 'L') {
l++;
i++;
}
ans = max(ans, l);
while (i < s.size() && s[i] == 'R') i++;
}
cout << ans + 1 << endl;
}
}
| 9 | CPP |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Dec 3 21:38:01 2019
@author: wwy
"""
number = input()
digit = number.count('4') + number.count('7')
if digit == 4 or digit == 7:
print('YES')
else:
print('NO') | 7 | PYTHON3 |
#include <bits/stdc++.h>
template <class T>
using MinHeap = std::priority_queue<T, std::vector<T>, std::greater<T>>;
template <class T>
using MaxHeap = std::priority_queue<T>;
using ll = long long;
using Pii = std::pair<int, int>;
using Pll = std::pair<ll, ll>;
using Pdd = std::pair<double, double>;
template <class T>
bool chmin(T &a, const T b) {
if (a > b) {
a = b;
return true;
} else {
return false;
}
}
template <class T>
bool chmax(T &a, const T b) {
if (a < b) {
a = b;
return true;
} else {
return false;
}
}
template <class T>
void vdeb(const std::vector<T> &da) {
auto n = da.size();
for (size_t i = 0; i < n; i++) {
if (i == n - 1)
std::cout << da[i] << std::endl;
else
std::cout << da[i] << " ";
}
}
template <class T>
void vdeb(const std::vector<std::vector<T>> &da) {
auto n = da.size();
for (size_t i = 0; i < n; i++) {
std::cout << i << " : ";
vdeb(da[i]);
}
}
template <>
void vdeb(const std::vector<std::string> &da) {
auto n = da.size();
for (size_t i = 0; i < n; i++) {
std::cout << da[i] << std::endl;
}
}
using namespace std;
using Real = double;
using Point = pair<Real, Real>;
constexpr Real EPS = 1e-10;
const Real Pi = std::acos(Real(-1.0));
const Real Tau = Pi * 2;
int main() {
int n, k;
cin >> n >> k;
vector<Point> da(n);
for (int i = (0); i < int(n); i++) cin >> da[i].first >> da[i].second;
vector<Real> args(n), dist(n);
for (int i = (0); i < int(n); i++) {
args[i] = atan2(da[i].second, da[i].first);
dist[i] = hypot(da[i].second, da[i].first);
}
vector<pair<Real, int>> event(n * 4);
Real ok = 1e6, ng = 0.0;
for (int times = (0); times < int(40); times++) {
auto now = (ok + ng) / 2;
for (int i = (0); i < int(n); i++) {
if (dist[i] > now) {
event[i * 4] = {0, 0};
event[i * 4 + 1] = {0, 0};
event[i * 4 + 2] = {0, 0};
event[i * 4 + 3] = {0, 0};
} else {
auto tmp = acos(dist[i] / now);
event[i * 4] = {args[i] - tmp, 1};
event[i * 4 + 1] = {args[i] + tmp, -1};
event[i * 4 + 2] = {args[i] - tmp + Tau, 1};
event[i * 4 + 3] = {args[i] + tmp + Tau, -1};
}
}
sort(event.begin(), event.end());
int cnt = 0;
bool flg = false;
for (auto &i : event) {
cnt += i.second;
if (cnt >= k) {
flg = true;
break;
}
}
if (flg) {
ok = now;
} else {
ng = now;
}
}
cout << setprecision(10) << endl;
cout << ok / 2 << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
std::ostream &operator<<(std::ostream &out, vector<T> &v) {
for (typename vector<T>::size_type i = 0; i < v.size(); ++i)
out << v[i] << " ";
out << "\n";
return out;
}
template <typename T, typename N>
std::ostream &operator<<(std::ostream &out, vector<pair<T, N> > &v) {
for (size_t i = 0; i < v.size(); ++i)
out << "(" << v[i].first << ", " << v[i].second << ") ";
out << "\n";
return out;
}
template <typename T>
std::ostream &operator<<(std::ostream &out, vector<vector<T> > &v) {
for (size_t i = 0; i < v.size(); ++i) {
for (size_t j = 0; j < v[i].size(); ++j) {
out << v[i][j] << " ";
}
out << "\n";
}
return out;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, x, y;
cin >> n >> x >> y;
string a;
cin >> a;
int zero_blocks = 0;
int count = 0;
for (int i = 0; i < n; ++i) {
if (a[i] == '1') {
if (count) {
++zero_blocks;
count = 0;
}
} else {
++count;
}
}
if (count) {
++zero_blocks;
}
if (!zero_blocks) {
cout << "0\n";
return 0;
}
if (zero_blocks == 1) {
cout << y << "\n";
return 0;
}
long long min_cost = 0;
if (x < y) {
min_cost = (long long)(zero_blocks - 1) * x + y;
} else {
min_cost = (long long)zero_blocks * y;
}
cout << min_cost << "\n";
return 0;
}
| 7 | CPP |
for _ in range(int(input())):
print(f"1 {int(input()) - 1}") | 7 | PYTHON3 |
R = lambda:map(int,input().split())
n, m, k = R()
def solve(n, m, k):
if n <= min(m,k):
return 'YES'
return 'NO'
print(solve(n,m,k)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 85, MAXM = 1e5 + 10, inf = 1e6;
int a[MAXN], b[MAXN];
int n, m;
int dp[MAXM];
int solve(int idx) {
if (idx > m) return 0;
int &ret = dp[idx];
if (ret != -1) return ret;
ret = inf;
for (int i = 0; i < n; ++i) {
int l = a[i] - b[i];
int r = a[i] + b[i];
if (idx >= l && idx <= r)
ret = min(ret, solve(idx + 1));
else if (idx < l)
ret = min(ret, solve(r + l - idx + 1) + l - idx);
else
ret = min(ret, solve(idx + 1) + 1);
}
return ret;
}
int main() {
memset(dp, -1, sizeof(dp));
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> a[i] >> b[i];
return cout << solve(1) << "\n", 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, q, op;
set<pair<int, int> > s;
int x, y;
int bit[300010];
int v[300010];
void update(int x, int v) {
while (x < 300010) {
bit[x] += v;
x += (x & -x);
}
}
int query(int x) {
int sum = 0;
while (x > 0) {
sum += bit[x];
x -= (x & -x);
}
return sum;
}
void printset() {
printf("Set -------- \n");
for (auto it = s.begin(); it != s.end(); ++it) {
printf("%d - %d\n", it->first, it->second);
}
}
int main(void) {
ios ::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> v[i];
s.insert(make_pair(v[i], i));
}
for (auto it = s.begin(); it != s.end(); ++it) {
if (it->first == 1) {
update(it->first, 1);
} else {
auto it2 = s.lower_bound(make_pair(it->first - 1, -1));
if (it2->second > it->second) {
update(it->first, 1);
}
}
}
cin >> q;
for (int i = 0; i < q; ++i) {
cin >> op >> x >> y;
if (op == 1) {
int ans = query(y) - query(x - 1);
if (query(x) - query(x - 1) == 0) ans++;
cout << ans << "\n";
} else {
{
s.erase(make_pair(v[x], x));
s.insert(make_pair(v[x], y));
if (v[x] > 1) {
auto it = s.lower_bound(make_pair(v[x] - 1, -1));
if (it->second > y) {
if (query(v[x]) - query(v[x] - 1) == 0) update(v[x], 1);
} else {
if (query(v[x]) - query(v[x] - 1) == 1) update(v[x], -1);
}
}
}
{
if (v[x] < n) {
auto it = s.lower_bound(make_pair(v[x] + 1, -1));
if (it->second < y) {
if (query(v[x] + 1) - query(v[x]) == 0) update(v[x] + 1, 1);
} else {
if (query(v[x] + 1) - query(v[x]) == 1) update(v[x] + 1, -1);
}
}
}
{
s.erase(make_pair(v[y], y));
s.insert(make_pair(v[y], x));
if (v[y] > 1) {
auto it = s.lower_bound(make_pair(v[y] - 1, -1));
if (it->second > x) {
if (query(v[y]) - query(v[y] - 1) == 0) update(v[y], 1);
} else {
if (query(v[y]) - query(v[y] - 1) == 1) update(v[y], -1);
}
}
}
{
if (v[y] < n) {
auto it = s.lower_bound(make_pair(v[y] + 1, -1));
if (it->second < x) {
if (query(v[y] + 1) - query(v[y]) == 0) update(v[y] + 1, 1);
} else {
if (query(v[y] + 1) - query(v[y]) == 1) update(v[y] + 1, -1);
}
}
}
swap(v[x], v[y]);
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int x1 = s.find("AB");
int x2 = s.find("BA", x1 + 2);
int y1 = s.find("BA");
int y2 = s.find("AB", y1 + 2);
if ((x1 != -1 && x2 != -1) || (y1 != -1 && y2 != -1))
cout << "YES";
else
cout << "NO";
}
| 7 | CPP |
import sys
tc = int(sys.stdin.readline())
for _ in range(tc):
n = int(sys.stdin.readline())
arr = [list(map(int, sys.stdin.readline().rstrip())) for _ in range(n)]
ans = [0] * 10
res = dict().fromkeys([i for i in range(10)], 0)
bottom = dict().fromkeys([i for i in range(10)], 0)
top = dict().fromkeys([i for i in range(10)], 9876543210)
right = dict().fromkeys([i for i in range(10)], 0)
left = dict().fromkeys([i for i in range(10)], 9876543210)
for i in range(n):
for j in range(n):
res[arr[i][j]] += 1
top[arr[i][j]] = min(top[arr[i][j]], i)
left[arr[i][j]] = min(left[arr[i][j]], j)
for j in range(n - 1, -1, -1):
right[arr[i][j]] = max(right[arr[i][j]], j)
for i in range(n - 1, -1, -1):
for j in range(n):
bottom[arr[i][j]] = max(bottom[arr[i][j]], i)
for k in range(10):
if res[k] >= 2:
for i in range(n):
start = 0
end = 0
r_cnt = 0
for j in range(n):
if arr[i][j] == k:
r_cnt += 1
if r_cnt == 0:
continue
for j in range(n):
if arr[i][j] == k:
start = j
break
for j in range(n - 1, -1, -1):
if arr[i][j] == k:
end = j
break
hor1 = max(start, n - start - 1)
hor2 = max(end, n - end - 1)
ans[k] = max(ans[k], (end - start) * (n - i - 1), (end - start) * i,
hor1 * abs(top[k] - i), hor1 * abs(bottom[k] - i),
hor2 * abs(top[k] - i), hor2 * abs(bottom[k] - i))
for k in range(10):
if res[k] >= 2:
for j in range(n):
start = 0
end = 0
c_cnt = 0
for i in range(n):
if arr[i][j] == k:
c_cnt += 1
if c_cnt == 0:
continue
for i in range(n):
if arr[i][j] == k:
start = i
break
for i in range(n - 1, -1, -1):
if arr[i][j] == k:
end = i
break
ver1 = max(start, n - start - 1)
ver2 = max(end, n - end - 1)
ans[k] = max(ans[k], (end - start) * (n - j - 1), (end - start) * j,
ver1 * abs(right[k] - j), ver1 * abs(left[k] - j),
ver2 * abs(right[k] - j), ver2 * abs(left[k] - j))
print(' '.join(map(str, ans))) | 9 | PYTHON3 |
import sys
n, k = map(int, input().split());
fl = -1;
flats = [-1] * 101
for i in range(k):
flat, floor = map(int, input().split())
flats[flat] = floor
ans = -1
if flats[n] != -1:
print(flats[n])
sys.exit(0)
for i in range(1, 101):
for j in range(1, 101):
if flats[j] != -1 and (j - 1) // i + 1 != flats[j]:
break;
else:
if ans != -1 and (n - 1) // i + 1 != ans:
print(-1)
sys.exit(0)
else:
ans = (n - 1) // i + 1;
print(ans)
| 8 | PYTHON3 |
import math
t = int(input())
for i in range(t):
n = int(input())
fre8 = math.ceil(n/4)
fre9 = n - fre8
print('9'*fre9 + '8'*fre8) | 8 | PYTHON3 |
import sys
n = int(sys.stdin.readline())
arr = list(map(int,sys.stdin.readline().split()))
arr.sort()
ans1 = []
ans2 = []
cnt1 = 0
cnt2 = 0
if n == 1:
print('0')
print(arr[0])
elif n == 2:
print('0')
print(arr[0],arr[1])
elif n%2 == 0:
for i in range(n//2):
ans1.append(arr[i+n//2])
ans1.append(arr[i])
for i in range(1,n-1):
if ans1[i] < ans1[i-1] and ans1[i] < ans1[i+1]:
cnt1 += 1
for i in range(n//2):
ans2.append(arr[i])
ans2.append(arr[i+n//2])
for i in range(1,n-1):
if ans2[i] < ans2[i-1] and ans2[i] < ans2[i+1]:
cnt2 += 1
print(max(cnt1,cnt2))
if cnt1 >= cnt2:
print(" ".join(map(str,ans1)))
else:
print(" ".join(map(str,ans2)))
else:
for i in range(n//2):
ans1.append(arr[i+n//2])
ans1.append(arr[i])
ans1.append(arr[n-1])
for i in range(n//2):
ans2.append(arr[i])
ans2.append(arr[i+n//2])
ans2.append(arr[(n-1)//2])
for i in range(1,n-1):
if ans1[i] < ans1[i-1] and ans1[i] < ans1[i+1]:
cnt1 += 1
for i in range(1,n-1):
if ans2[i] < ans2[i-1] and ans2[i] < ans2[i+1]:
cnt2 += 1
print(max(cnt1,cnt2))
if cnt1 >= cnt2:
print(" ".join(map(str,ans1)))
else:
print(" ".join(map(str,ans2))) | 10 | PYTHON3 |
n=input();a="";
n1=input()
for i in range(len(n)):
if(n[i]==n1[i]):
a=a+"0"
else:
a=a+"1"
print(a) | 7 | PYTHON3 |
n = int(input())
lst1 = []
for i in range(n):
lst1.append([int(i) for i in input().split()])
m = int(input())
lst2 = []
for i in range(m):
lst2.append([int(i) for i in input().split()])
lst1.sort(key = lambda x: x[1])
lst2.sort(key = lambda x: x[0])
num1 = lst2[-1][0] - lst1[0][1]
lst2.sort(key = lambda x: x[1])
lst1.sort(key = lambda x: x[0])
num2 = lst1[-1][0] - lst2[0][1]
num = max(num1, num2)
if num > 0:
print(num)
else:
print(0)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 100;
long long one[N], zero[N];
int main() {
string a, b;
cin >> a >> b;
int cone = 0, czero = 0;
for (int i = 0; i < b.size(); i++) {
one[i] = '1' - b[i];
zero[i] = b[i] - '0';
}
for (int i = 1; i < b.size(); i++) {
one[i] += one[i - 1];
zero[i] += zero[i - 1];
}
long long ans = 0;
for (int i = 0; i < a.size(); i++) {
if (a[i] == '0') {
ans += (zero[b.size() - a.size() + i] - (i == 0 ? 0 : zero[i - 1]));
} else {
ans += (one[b.size() - a.size() + i] - (i == 0 ? 0 : one[i - 1]));
}
}
cout << ans << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int t[107];
int main(void) {
bool ta = 1;
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &t[i]);
}
sort(t, t + n);
int k = 1;
int i = 0;
while (t[i] == t[i + 1]) {
i++;
k++;
}
if (k > n / 2) {
ta = 0;
}
if (!ta) {
printf("Bob");
} else {
printf("Alice");
}
return 0;
}
| 9 | CPP |
s=input().replace('WUB',' ').strip().split()
print(' '.join(s))
| 7 | PYTHON3 |
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
#define inf (1<<27)
struct State {
int x,y,l,r,o,c;
State(int xx,int yy,int ll,int rr,int oo,int cc) {
x=xx,y=yy,l=ll,r=rr,o=oo,c=cc;
}
};
bool operator > (const State &left,const State &right) {
return left.c>right.c;
}
int map[10][10];
int cost[10][10][10][10][51];
int main() {
int W,H,f,m,o;
while(scanf("%d %d",&W,&H),W) {
memset(cost,0x10,sizeof(cost));
scanf("%d %d %d",&f,&m,&o);
for(int j=0;j<H;j++)for(int i=0;i<W;i++) {
scanf("%d",&map[i][j]);
}
if(o<=1){printf("NA\n");continue;}
priority_queue<State,vector<State>,greater<State> > que;
for(int i=0;i<W;i++) {
int oo=o-1,cc=0;
if(map[i][0]<0) {
cc-=map[i][0];
}else {
oo+=map[i][0];
if(oo>m)oo=m;
}
que.push(State(i,0,i,i,oo,cc));
}
int res=inf;
while(!que.empty()) {
State s=que.top();
que.pop();
s.o--;
if(s.y==(H-1)){res=s.c;break;}
if(s.o==0){continue;}
State ns=s;
ns.y++;ns.l=ns.r=ns.x;
if(ns.y<H) {
if(map[ns.x][ns.y]>0) {
ns.o+=map[ns.x][ns.y];
if(ns.o>m)ns.o=m;
}else {
ns.c-=map[ns.x][ns.y];
}
if(cost[ns.x][ns.y][ns.l][ns.r][ns.o]>ns.c) {
cost[ns.x][ns.y][ns.l][ns.r][ns.o]=ns.c;
que.push(ns);
}
}
ns=s;
ns.x++;
if(ns.x<W) {
if(ns.x>ns.r) {
ns.r=ns.x;
if(map[ns.x][ns.y]>0) {
ns.o+=map[ns.x][ns.y];
if(ns.o>m)ns.o=m;
}else {
ns.c-=map[ns.x][ns.y];
}
}
if(cost[ns.x][ns.y][ns.l][ns.r][ns.o]>ns.c) {
cost[ns.x][ns.y][ns.l][ns.r][ns.o]=ns.c;
que.push(ns);
}
}
ns=s;
ns.x--;
if(ns.x>=0) {
if(ns.l>ns.x) {
ns.l=ns.x;
if(map[ns.x][ns.y]>0) {
ns.o+=map[ns.x][ns.y];
if(ns.o>m)ns.o=m;
}else {
ns.c-=map[ns.x][ns.y];
}
}
if(cost[ns.x][ns.y][ns.l][ns.r][ns.o]>ns.c) {
cost[ns.x][ns.y][ns.l][ns.r][ns.o]=ns.c;
que.push(ns);
}
}
}
if(res<=f)printf("%d\n",res);
else printf("NA\n");
}
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) { return '"' + s + '"'; }
string to_string(const char& ch) {
string s = "";
s += ch;
return "'" + s + "', ";
}
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cout << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cout << " " << to_string(H);
debug_out(T...);
}
const long long mod = (long long)1000000007;
const long long inf = (long long)2e18;
const long long maxn = 3e6;
long long spf[maxn + 1];
void precompute() {
for (long long i = 2; i <= maxn; i++) {
if (!spf[i]) {
spf[i] = i;
for (long long j = i + i; j <= maxn; j += i) {
if (!spf[j]) spf[j] = i;
}
}
}
}
bool isprime(long long n) { return spf[n] == n; }
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << setprecision(9);
precompute();
long long n;
cin >> n;
vector<long long> a(n);
for (long long& x : a) cin >> x;
vector<long long> b;
for (long long i = 0; i < n; ++i) {
for (long long j = i + 1; j < n; ++j) {
if (isprime(a[i] + a[j])) {
b.push_back(a[i]);
b.push_back(a[j]);
goto label;
}
}
}
label:;
if (!((long long)(b).size())) {
b.push_back(a[0]);
}
vector<long long> c;
for (long long i = 0; i < n; ++i) {
if (a[i] == 1) {
c.push_back(a[i]);
}
}
for (long long i = 0; i < n; ++i) {
if (isprime(a[i] + 1) && a[i] != 1) {
c.push_back(a[i]);
break;
}
}
42;
42;
if (((long long)(b).size()) < ((long long)(c).size())) swap(b, c);
cout << ((long long)(b).size()) << '\n';
for (long long& x : b) cout << x << " ";
cout << '\n';
return 0;
}
| 10 | CPP |
from collections import Counter
a=list(input())
b=list(input())
a=a+b
n=list(input())
if Counter(a)==Counter(n):
print("YES")
else:
print("NO")
| 7 | PYTHON3 |
#include "bits/stdc++.h"
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
typedef long long ll;
int main() {
int N, A, B;
cin >> N >> A >> B;
vector<int> h(N);
ll lo = 0, hi = 0;
rep(i, N) {
cin >> h[i];
hi += (h[i] + A - 1) / A;
}
while (lo + 1 < hi) {
ll mi = (lo + hi) / 2, c = 0;
//cout << mi << endl;
rep(i, N) {
ll d = (h[i] - B * mi + A - B - 1) /(A - B);
if (d > 0) c += d;
}
if (c > mi) lo = mi;
else hi = mi;
}
cout << hi << endl;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007L;
const int SIZE = 800010;
int cnt[300];
char ans[SIZE];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(15);
int n;
cin >> n;
string s;
cin >> s;
for (int i = 0; i < n; i++) {
cnt[s[i]]++;
}
int odd = 0, even = 0;
for (int i = 0; i < 300; i++) {
if (cnt[i] % 2 != 0)
odd++;
else
even++;
}
int a = n;
for (int i = 1; i <= n; i++) {
int x = n / i;
if (x * i != n) continue;
bool flag = 0;
int o = odd;
int e = even;
if (x % 2) {
if (o > i) flag = 1;
} else {
if (o) flag = 1;
}
if (!flag) {
a = i;
break;
}
}
cout << a << endl;
int x = n / a;
if (x % 2) {
for (int i = 0; i < a; i++) {
int mid = x / 2;
int j = 0;
int idx = 0;
while (j <= mid) {
for (int k = 0; k < 300 && j < mid; k++) {
while (j < mid && cnt[k] >= 2) {
cnt[k] -= 2;
char ch = (char)k;
j++;
ans[idx] = ch;
ans[x - 1 - idx] = ch;
idx++;
}
}
char ch;
bool flag = 0;
for (int k = 0; k < 300; k++) {
if (cnt[k] % 2 != 0) {
flag = 1;
ch = (char)k;
cnt[k] -= 1;
j++;
break;
}
}
if (!flag) {
for (int k = 0; k < 300; k++) {
if (cnt[k] > 0) {
cnt[k] -= 1;
ch = (char)k;
j++;
break;
}
}
}
ans[idx] = ch;
idx++;
}
cout << ans << " ";
}
cout << endl;
} else {
for (int i = 0; i < a; i++) {
int mid = x / 2;
int j = 0;
int idx = 0;
while (j < mid) {
for (int k = 0; k < 300 && j < mid; k++) {
while (j < mid && cnt[k] >= 2) {
cnt[k] -= 2;
char ch = (char)k;
j++;
ans[idx] = ch;
ans[x - 1 - idx] = ch;
idx++;
}
}
}
cout << ans << " ";
}
cout << endl;
}
return 0;
}
| 14 | CPP |
n,l,k=int(input())//2,0,0
for i in input():
if i=="A":l+=1
else:k+=1
if n<l:print("Anton");exit()
elif n<k:print("Danik");exit()
print("Friendship")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
int deg1 = n - 1;
set<pair<int, int> > forb;
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
forb.insert(pair<int, int>(u, v));
forb.insert(pair<int, int>(v, u));
if (u == 1 || v == 1) deg1--;
}
set<int> out;
for (int i = 2; i <= n; i++) out.insert(i);
bool ok = 1;
int ncmp = 0;
while (!out.empty()) {
bool connected = 0;
queue<int> tree;
tree.push(*out.begin());
out.erase(out.begin());
while (!tree.empty()) {
int v = tree.front();
tree.pop();
if (forb.find(pair<int, int>(1, v)) == forb.end()) connected = 1;
vector<int> trash;
for (int x : out) {
if (forb.find(pair<int, int>(v, x)) == forb.end()) {
tree.push(x);
trash.push_back(x);
}
}
for (int x : trash) out.erase(x);
}
if (!connected) {
ok = 0;
break;
}
ncmp++;
}
printf("%spossible\n", (ncmp <= k && deg1 >= k && ok) ? "" : "im");
return 0;
}
| 11 | CPP |
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <cstring>
#include <sstream>
#include <cassert>
#include <ctime>
#include <list>
using namespace std;
static const double EPS = 1e-6;
typedef long long ll;
typedef pair<int,int> PI;
#ifndef M_PI
const double M_PI=acos(-1);
#endif
#define rep(i,n) for(int i=0;i<(int)(n);++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
#define mp(a,b) make_pair(a,b)
#define pb(a) push_back(a)
#define SZ(a) (int((a).size()))
#define F first
#define S second
int dx[]={0,1,0,-1,0,0},dy[]={1,0,-1,0,0,0};
int dz[]={0,0,0,0,1,-1};
int n;
double sx[30],sy[30],sz[30];
double dist(double x,double y,double z,int id){
double tx=x-sx[id];
double ty=y-sy[id];
double tz=z-sz[id];
return sqrt(tx*tx+ty*ty+tz*tz);
}
double rad(double x,double y,double z){
double ret=dist(x,y,z,n-1);
rep(i,n-1)ret=max(ret,dist(x,y,z,i));
return ret;
}
typedef struct _node{
double x,y,z,r;
int wh;
_node(double x,double y,double z,int wh):
x(x),y(y),z(z),wh(wh),r(rad(x,y,z)){};
bool operator<(const _node& rn)const{
if(rn.wh!=wh)return rn.wh<wh;
return rn.r<r;
}
}node;
int tx[]={1,1,1,1,-1,-1,-1,-1};
int ty[]={1,1,-1,-1,1,1,-1,-1};
int tz[]={1,-1,1,-1,1,-1,1,-1};
double len[1000];
void solve(){
rep(i,n)scanf("%lf%lf%lf",sx+i,sy+i,sz+i);
len[0]=100;
for(int i=1;i<1000;++i)
len[i]=len[i-1]/2;
double ans=10000;
rep(i,n)rep(j,i)
ans=min(ans,rad((sx[i]+sx[j])/2,
(sy[i]+sy[j])/2,
(sz[i]+sz[j])/2));
priority_queue<node> q;
q.push(node(50,50,50,0));
int cu=0;
int bwh=-1;
while(!q.empty()){
node cur=q.top();
q.pop();
if(cu==1000 && cur.wh==bwh)continue;
if(cu==1000)cu=0,bwh=cur.wh;
++cu;
double rr=len[cur.wh];
if(ans<cur.r-rr*sqrt(3)*2+EPS)continue;
ans=min(ans,cur.r);
if(cur.wh>25)continue;
//printf("%.5f %.5f %.5f %.5f %.7f %d\n",cur.x,cur.y,cur.z,cur.r,ans,cur.wh);
rep(i,8)
q.push(node(cur.x+rr*tx[i],cur.y+rr*ty[i],cur.z+rr*tz[i],cur.wh+1));
}
printf("%.5f\n",ans);
}
int main(){
while(cin>>n,n)
solve();
} | 0 | CPP |
#include <iostream>
#include <cstdio>
using namespace std;
int main() {
double a,b,c,d,e,f;
while(cin>>a>>b>>c>>d>>e>>f){
double x,y;
y=(a*f-d*c)/(a*e-b*d);
x=(c-b*y)/a;
printf("%.3lf %.3lf\n",x,y);
}
return 0;
} | 0 | CPP |
n = int(input())
for i in range(n):
s = list(input().split("R"))
max = 0
for i in s:
x = len(i)
if x > max:
max = x
print (max+1) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<pair<int, int> > a[200010];
bool F;
pair<int, int> b[200010];
int c1;
bool work(int x) {
if (x == n) return 0;
for (int l = 1; l <= n; ++l) {
c1 = 0;
for (auto it : a[l]) b[++c1] = make_pair(it.first + x, it.second + x);
for (int i = 1; i <= c1; ++i) {
if (b[i].first > n) b[i].first -= n;
if (b[i].second > n) b[i].second -= n;
if (b[i].first > b[i].second) swap(b[i].first, b[i].second);
}
sort(b + 1, b + c1 + 1);
for (int i = 1; i <= c1; ++i)
if (b[i] != a[l][i - 1]) return 0;
}
return 1;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
int x, y, z;
scanf("%d%d", &x, &y);
if (x > y) swap(x, y);
z = min(y - x, n - y + x);
a[z].push_back(make_pair(x, y));
}
for (int i = 1; i <= n; ++i) sort(a[i].begin(), a[i].end());
for (int i = 1; i * i <= n; ++i)
if (n % i == 0) F |= work(i), F |= work(n / i);
puts(F ? "YES" : "NO");
return 0;
}
| 8 | CPP |
q = int(input())
for i in range(q):
n = int(input())
s = input()
if int(s[0]) >= int(s[1:]):
print('NO')
else:
print('YES')
print(2)
print(s[0], s[1:])
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
for (int i = 21; i <= 50; i++) {
cout << ((min(i, 25) + i) % (2 + (i % 3)) > 0) << endl;
}
return 0;
}
| 11 | CPP |
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
#include <iomanip>
using namespace std;
int main()
{
vector< pair< double, int > > athletes;
vector< pair< double, int > > finalists;
for( int i = 0; i < 3; ++i ){
vector< pair< double, int > > party;
for( int j = 0; j < 8; ++j ){
int id;
double time;
cin >> id >> time;
party.push_back( make_pair( time, id ) );
}
sort( party.begin(), party.end(), greater< pair< double, int > >() );
finalists.push_back( party[ 7 ] );
finalists.push_back( party[ 6 ] );
party.pop_back();
party.pop_back();
athletes.insert( athletes.end(), party.begin(), party.end() );
}
sort( athletes.begin(), athletes.end() );
finalists.push_back( athletes[ 0 ] );
finalists.push_back( athletes[ 1 ] );
for( int i = 0; i < 8; ++i ){
cout << finalists[ i ].second << " " << fixed << setprecision( 2 ) << finalists[ i ].first << endl;
}
return 0;
} | 0 | CPP |
n=int(input())
s={}
a=[]
for i in range(n):
x=input()
if x in s:
s[x]=s[x]+1
print(x+str(s[x]))
else:
s[x]=0
print('OK')
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
int dp[N][N][N];
vector<int> a[3], sz(3);
int solve(int i, int j, int k) {
int cal = (i >= sz[0]) + (j >= sz[1]) + (k >= sz[2]);
if (cal > 1) return 0;
if (dp[i][j][k] != -1)
return dp[i][j][k];
else {
int cur = 0, r = 0, g = 0, b = 0;
if (i < sz[0]) r = a[0][i];
if (j < sz[1]) g = a[1][j];
if (k < sz[2]) b = a[2][k];
if (r * g != 0) cur = r * g + solve(i + 1, j + 1, k);
if (g * b != 0) cur = max(cur, g * b + solve(i, j + 1, k + 1));
if (r * b != 0) cur = max(cur, r * b + solve(i + 1, j, k + 1));
return dp[i][j][k] = cur;
}
}
int main(int argc, char const *argv[]) {
for (int i = 0; i < 3; ++i) {
cin >> sz[i];
}
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < sz[i]; ++j) {
int x;
cin >> x;
a[i].push_back(x);
}
}
for (int i = 0; i < 3; ++i) {
sort(a[i].rbegin(), a[i].rend());
}
memset(dp, -1, sizeof(dp));
cout << solve(0, 0, 0) << '\n';
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
char in[35][35];
char temp[500010];
bool cana[35], canb[35];
using namespace std;
int main() {
int m, n, x, q, i, j, l, k;
bool hass = false;
scanf("%d%d%d", &n, &m, &x);
for (i = 0; i < n; i++) scanf("%s", in[i]);
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) {
if (in[i][j] == 'S') {
hass = true;
for (k = 0; k < n; k++)
for (l = 0; l < m; l++) {
if ((i - k) * (i - k) + (j - l) * (j - l) <= x * x &&
in[k][l] != 'S')
canb[in[k][l] - 'a'] = true;
}
} else {
cana[in[i][j] - 'a'] = true;
}
}
scanf("%d%s", &q, temp);
int ans = 0;
for (i = 0; i < q; i++) {
if (temp[i] >= 'A' && temp[i] <= 'Z') {
if (!hass) break;
if (!canb[temp[i] - 'A']) {
if (cana[temp[i] - 'A'])
ans++;
else
break;
}
} else {
if (!cana[temp[i] - 'a']) break;
}
}
if (i < q)
printf("-1\n");
else
printf("%d\n", ans);
return 0;
}
| 8 | CPP |
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main(void){
int n,i,j,a[200010],ans[200010]={},s;
cin >> n;
for (i=1;i<=n;i++) cin >> a[i];
for (i=n;i>=1;i--){
s=0;
for (j=1;i*j<=n;j++) s+=ans[i*j];
if (s%2!=a[i]) ans[i]=1;
}
int m=0;
vector<int> v;
for (i=1;i<=n;i++){
if (ans[i]){
m++;
v.push_back(i);
}
}
cout << m << endl;
for (i=0;i<m;i++) cout << v[i] << endl;
return 0;
} | 0 | CPP |
import sys
import math
#sys.stdin = open('input.txt', 'r')
#sys.stdout = open('output.txt', 'w')
from sys import stdin, stdout
for _ in range(int(stdin.readline())):
n = int(stdin.readline())
a = list(map(int, stdin.readline().split()))
d = {}
b = []
c = []
for i in a:
if i not in d:
d[i] = 0
d[i] += 1
for i in a:
if i % 2 == 0:
b.append(i)
else:
c.append(i)
l = len(b)
m = len(c)
if l % 2 == 0 and m % 2 == 0:
print('YES')
elif l % 2 == 1 and m % 2 == 1:
k = 0
for i in a:
if i + 1 in d or i - 1 in d:
print('YES')
k = 1
break
if k == 0:
print('NO')
else:
print('NO')
| 9 | PYTHON3 |
t = input()
for i in range(int(t)):
a, b = map(int, input().split())
print(a^b)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
long m, n, arr[9];
char matRes[9][9];
char mat[9][9];
long res = 10000000000, max, min, b, maxi, mini, a;
using namespace std;
int main() {
scanf("%ld%ld", &m, &n);
for (a = 0; a < m; a++) scanf("%s", mat[a]);
for (a = 1; a <= n; a++) {
arr[a - 1] = a;
}
maxi = -1;
mini = 100000000;
for (b = 0; b < m; b++) {
if (atoi(mat[b]) > maxi) maxi = atoi(mat[b]);
if (atoi(mat[b]) < mini) mini = atoi(mat[b]);
}
if (res > maxi - mini) res = maxi - mini;
while (next_permutation(arr, arr + n)) {
maxi = -1;
mini = 100000000;
for (a = 0; a < n; a++) {
for (b = 0; b < m; b++) {
matRes[b][a] = mat[b][arr[a] - 1];
}
}
for (b = 0; b < m; b++) {
if (atoi(matRes[b]) > maxi) maxi = atoi(matRes[b]);
if (atoi(matRes[b]) < mini) mini = atoi(matRes[b]);
}
if (res > maxi - mini) res = maxi - mini;
}
printf("%ld\n", res);
}
| 8 | CPP |
#include<bits/stdc++.h>
using namespace std;
const int N=210;
int n,m,cnt[N],one,four;char s[N];
int main()
{
scanf("%d%d",&n,&m);
for (int i=1;i<=n;i++){
scanf("%s",s+1);
for (int j=1;j<=m;j++) cnt[s[j]]++;
}
for (int i='a';i<='z';i++){
if (cnt[i]&1) cnt[i]--,one++;
four+=(cnt[i]>>2);
}
if ((n&1)&&(m&1)){if (one!=1) return puts("No"),0;}
else if (one>0) return puts("No"),0;
if (four<(n>>1)*(m>>1)) return puts("No"),0;
puts("Yes");
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main(){
long long n,ans=3,cnt1=0,cnt2=0,mod=1e9+7;
string s,t;
cin >> n >> s >> t;
s+='.';
for(int i=0;i<n;i++){
if(s[i]!=t[i]){
if(s[i]==s[i+1]){
continue;
}
if(cnt1==0){
cnt1=2;
}else{
cnt1*=3;
}
if(cnt2>0){
ans*=cnt2;
}
ans%=mod;
cnt2=0;
}else{
if(cnt2==0){
cnt2++;
}else{
cnt2*=2;
}
if(cnt1>0){
ans*=cnt1;
}
ans%=mod;
cnt1=0;
}
}
if(cnt1>0){
ans*=cnt1;
}else{
ans*=cnt2;
}
ans%=mod;
cout << ans << endl;
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int t[N];
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
t[0] = 0;
t[n + 1] = 0;
for (int i = 1; i <= n; ++i) {
cin >> t[i];
t[i] = min(t[i - 1] + 1, t[i]);
}
for (int i = n; i > 0; --i) {
t[i] = min(t[i + 1] + 1, t[i]);
}
int res = 0;
for (int i = 1; i <= n; ++i) res = max(res, t[i]);
cout << res << "\n";
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int Int() {
int x;
scanf("%d", &x);
return x;
}
long long Long() {
long long x;
scanf("%lld", &x);
return x;
}
void err(istream_iterator<string> it) { cout << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << ' ';
err(++it, args...);
}
const int N = (int)2e5 + 5;
const int maxN = (int)1e6 + 6;
const long long Mod = (long long)1e9 + 7;
const int inf = (int)2e9;
const long long Inf = (long long)1e18;
int main() {
int test = Int(), tc = 0;
while (test--) {
int n = Int();
int l = 2, r = n, res = 0;
printf("1 %d 1", n - 1);
for (int i = 2; i <= n; ++i) printf(" %d", i);
cout << endl;
res = Int();
int id = 0;
while (l <= r) {
int mid = (l + r) >> 1;
printf("1 %d 1", mid - l + 1);
for (int i = l; i <= mid; ++i) printf(" %d", i);
cout << endl;
int x = Int();
if (x < res)
l = mid + 1;
else {
r = mid - 1;
id = mid;
}
}
printf("1 %d %d", n - 1, id);
for (int i = 1; i <= n; ++i) {
if (i == id) continue;
printf(" %d", i);
}
cout << endl;
int x = Int();
printf("-1 %d\n", x);
cout << endl;
}
return 0;
}
| 9 | CPP |
import math
def sum_digits(n):
ans = 0
while n > 0:
r = n % 10
n = n // 10
ans += r
return ans
a, b, c = [int(i) for i in input().split()]
arr = []
for i in range(1, 91):
tot = b*(int(math.pow(i, a))) + c
if i == sum_digits(tot) and 0 <= tot < 1000000000:
arr.append(tot)
print(len(arr))
print(*arr) | 8 | PYTHON3 |
from math import ceil
T1,T2 = map(int,input().split())
A1,A2 = map(int,input().split())
B1,B2 = map(int,input().split())
a = A1-B1
b = A2-B2
d = T1*a + T2*b
if d == 0:
print('infinity')
exit()
if a*b > 0 or a*d > 0:
print(0)
exit()
x = abs(T1*a)
d = abs(d)
cnt = (x+d-1)//d
if cnt*d == x:
cnt = 2*cnt
else:
cnt = 2*cnt-1
print(cnt) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pp;
typedef pair<ll,ll> pll;
void read(int& x){ scanf("%d",&x); }
void read(ll& x){ scanf("%lld",&x); }
template<typename T,typename... Args>
void read(T& a,Args&... b){ read(a); read(b...); }
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define eb emplace_back
#define x first
#define y second
char S[200010];
int n;
int fail[200010];
void Fail(){
n=strlen(S);
for(int i=1;i<n/2;++i){
int j=fail[i-1];
while(j && S[j]!=S[i]) j=fail[j-1];
if(S[j]==S[i]) ++j;
fail[i]=j;
}
}
ll len[100];
vector<ll> cnt[100];
vector<ll> work(ll to){
if(!to) return vector<ll>(26);
vector<ll> ret(26);
while(to){
int i=0;
for(i=0; len[i]; ++i) if(to < len[i]) break;
if(!i){
for(int j=0; j<to; ++j) ret[S[j]-'a']++;
break;
}
for(int j=0; j<26; ++j) ret[j]+=cnt[i-1][j];
to -= len[i-1];
}
return ret;
}
int main()
{
scanf("%s", S);
Fail();
len[0] = n/2; cnt[0].resize(26);
for(int i=0; i<n/2; ++i) cnt[0][S[i]-'a']++;
cnt[1] = cnt[0]; len[1] = len[0] + n/2-fail[n/2-1];
for(int i=0; i<n/2-fail[n/2-1]; ++i) cnt[1][S[i]-'a']++;
for(int i=2;;++i){
len[i] = len[i-1] + len[i-2];
if(len[i] > ll(1e18)) break;
cnt[i].resize(26);
for(int j=0; j<26; ++j) cnt[i][j]=cnt[i-1][j]+cnt[i-2][j];
}
ll L, R;
read(L, R);
auto vl = work(L-1), vr = work(R);
for(int i=0; i<26; ++i) printf("%lld ", vr[i]-vl[i]);
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef long double ld;
#define sz(x) (ll)x.size()
#define m1(x) memset(x, 1, sizeof(x))
#define m0(x) memset(x, 0, sizeof(x))
#define inf(x) memset(x, 0x3f, sizeof(x))
#define flout(x) cout << fixed << setprecision(x)
#define pb(x) push_back(x)
#define MOD 1000000007
#define MAX 100000000000000000
#define mN 200001
void solve() {
stack<int> s;
int n;
cin >> n;
int a[n];
vector<int> v;
for (int i = 0; i < n; i ++) {
cin >> a[i];
if (s.empty()) {
s.push((a[i]+1));
v.push_back(a[i]);
}
else {
if (a[i] == 1) {
s.push((a[i]+1));
v.push_back(a[i]);
}
else {
while (!s.empty() && s.top() != a[i]) {
s.pop();
v.erase(v.begin() + v.size()-1);
}
s.pop();
v.erase(v.begin() + v.size()-1);
s.push((a[i]+1));
v.push_back(a[i]);
}
}
for (int j = 0; j < v.size()-1; j ++) {
cout << v[j] << ".";
}
cout << v[v.size() - 1] << endl;
}
}
int main() {
ios_base::sync_with_stdio(0); cin.tie(0);
int t;
cin >> t;
// t = 1;
while (t--) {
solve();
}
} | 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, a[100005], num[100005];
int main() {
scanf("%d", &n);
for (register int i = 1; i <= n; ++i) scanf("%d", &a[i]), num[a[i]]++;
for (register int i = 1; i <= 50; ++i)
if (num[i]) {
if (num[i] > n / 2)
printf("Bob\n");
else
printf("Alice\n");
break;
}
return 0;
}
| 9 | CPP |
iniStr = input()
strLen = len(iniStr)
ans=str()
index = 0
while index<strLen :
theLower = iniStr[index].lower()
if theLower=='a' \
or theLower=='e' \
or theLower=='i' \
or theLower=='o' \
or theLower=='u' \
or theLower=='y':
index = index+1
continue
else :
ans = ans +'.'+theLower
index = index+1
print(ans) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
char ch = getchar();
bool f = false;
while (!isdigit(ch)) {
if (ch == '-') {
f = true;
}
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
x = f ? -x : x;
return;
}
template <typename T>
inline void write(T x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 ^ 48);
return;
}
const int N = 2e5 + 105;
int n, ans, sta[N], head[N], nex[N], to[N], dep[N], idx, top = 1, Root = 1, tot;
int ch[N][26];
bool endpos[N];
char s[N];
void add(int u, int v) {
nex[++idx] = head[u];
to[idx] = v;
head[u] = idx;
return;
}
int root[N];
struct Heap {
int val, ls, rs;
} T[N];
int Merge(int x, int y) {
if (!x || !y) return x | y;
if (T[x].val < T[y].val) swap(x, y);
T[x].rs = Merge(T[x].rs, y);
if (rand() & 1) swap(T[x].ls, T[x].rs);
return x;
}
void dfs(int x, int f) {
dep[x] = dep[f] + 1;
if (endpos[x]) T[root[x]].val = dep[x];
for (int i = head[x]; i; i = nex[i]) {
int y = to[i];
dfs(y, x);
root[x] = Merge(root[x], root[y]);
}
if (x && !endpos[x]) {
ans -= T[root[x]].val - dep[x];
T[++tot].val = dep[x];
root[x] = Merge(Merge(T[root[x]].ls, T[root[x]].rs), root[tot]);
endpos[x] = true;
}
return;
}
void Insert(char *str) {
int len = strlen(str), p = Root;
for (int i = 0; i < len; i++) {
int c = str[i] - 'a';
if (!ch[p][c]) ch[p][c] = ++top, add(p, top);
p = ch[p][c];
}
endpos[p] = true;
return;
}
int main() {
srand(time(0));
read(n);
tot = N - 1e5;
for (int i = 1; i <= N; i++) root[i] = i;
for (int i = 1; i <= n; i++) {
scanf("%s", s);
Insert(s);
ans += strlen(s);
}
endpos[1] = true;
dfs(1, 0);
write(ans);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 100;
const long long int mod = 1e9 + 7;
const int inf = 1e9;
const int lg = 19;
int mn[4 * N], mx[2][4 * N], mx1[2][4 * N], mx2[2][4 * N], mx3[2][4 * N];
int n, q, ti = 0, par[N], H[N], h[N], st[N], fi[N];
bool k[N], lazy[4 * N];
vector<pair<int, int>> e;
vector<pair<int, bool>> adj[N];
void upd(int ind) {
swap(mx[0][ind], mx[1][ind]);
swap(mx1[0][ind], mx1[1][ind]);
swap(mx2[0][ind], mx2[1][ind]);
swap(mx3[0][ind], mx3[1][ind]);
lazy[ind] ^= 1;
return;
}
void merge(int i) {
int lc = i * 2, rc = i * 2 + 1;
mn[i] = min(mn[lc], mn[rc]);
mx[0][i] = max(mx[0][lc], mx[0][rc]);
mx1[0][i] = max(mx1[0][lc], mx1[0][rc]);
mx1[0][i] = max(mx1[0][i], mx[0][lc] - 2 * mn[rc]);
mx2[0][i] = max(mx2[0][lc], mx2[0][rc]);
mx2[0][i] = max(mx2[0][i], mx[0][rc] - 2 * mn[lc]);
mx3[0][i] = max(mx3[0][lc], mx3[0][rc]);
mx3[0][i] = max(mx3[0][i], mx[0][lc] + mx2[0][rc]);
mx3[0][i] = max(mx3[0][i], mx[0][rc] + mx1[0][lc]);
mx[1][i] = max(mx[1][lc], mx[1][rc]);
mx1[1][i] = max(mx1[1][lc], mx1[1][rc]);
mx1[1][i] = max(mx1[1][i], mx[1][lc] - 2 * mn[rc]);
mx2[1][i] = max(mx2[1][lc], mx2[1][rc]);
mx2[1][i] = max(mx2[1][i], mx[1][rc] - 2 * mn[lc]);
mx3[1][i] = max(mx3[1][lc], mx3[1][rc]);
mx3[1][i] = max(mx3[1][i], mx[1][lc] + mx2[1][rc]);
mx3[1][i] = max(mx3[1][i], mx[1][rc] + mx1[1][lc]);
return;
}
void add(int l, int r, int b = 0, int e = ti, int ind = 1) {
if (e <= l || b >= r) return;
if (l <= b && e <= r) {
upd(ind);
return;
}
if (lazy[ind]) {
upd(ind * 2);
upd(ind * 2 + 1);
lazy[ind] = false;
}
int mid = (b + e) / 2;
add(l, r, b, mid, ind * 2);
add(l, r, mid, e, ind * 2 + 1);
merge(ind);
return;
}
void build(int b = 0, int e = ti, int ind = 1) {
if (b + 1 == e) {
int x = k[b];
mx1[x][ind] = mx2[x][ind] = -h[b];
mx[x][ind] = mn[ind] = h[b];
x = !k[b];
mx[x][ind] = mx1[x][ind] = mx2[x][ind] = mx3[x][ind] = -inf;
return;
}
int mid = (b + e) / 2;
build(b, mid, ind * 2);
build(mid, e, ind * 2 + 1);
merge(ind);
}
void dfs(int u, int hh, bool b) {
h[ti] = hh;
k[ti] = b;
st[u] = ti;
ti++;
for (auto x : adj[u]) {
if (x.first != par[u]) {
par[x.first] = u;
dfs(x.first, hh + 1, b ^ x.second);
h[ti] = hh;
k[ti] = b;
ti++;
}
}
fi[u] = ti;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int x, y;
bool w;
cin >> x >> y >> w;
x--;
y--;
adj[x].push_back({y, w});
adj[y].push_back({x, w});
e.push_back({x, y});
}
dfs(0, 0, 0);
build();
cin >> q;
while (q--) {
int id;
cin >> id;
id--;
int x = e[id].first;
int y = e[id].second;
if (x == par[y]) swap(x, y);
add(st[x], fi[x]);
cout << max(mx3[0][1], mx3[1][1]) << endl;
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
int ans = 0;
if (a > c) swap(a, c);
if (b > c) swap(b, c);
if (a > b) swap(a, b);
if (c - b < d) ans += d - c + b;
if (b - a < d) ans += d - b + a;
cout << ans;
}
| 7 | CPP |
nA, nB = map(int, input().split())
k, m = map(int, input().split())
lA = list(map(int, input().split()))
lB = list(map(int, input().split()))
maxA = lA[k-1]
minB = lB[len(lB) - m]
if maxA < minB:
print("YES")
else:
print("NO")
| 7 | PYTHON3 |
n=int(input())
r=n
for i in range(n-1):
r+=(n-(2+i))*(2+i)+1
print(r)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 10, inf = 1e9 + 1;
unordered_map<string, long long> mp;
vector<long long> G[maxn], R[maxn], t;
long long a[maxn], r[maxn], l[maxn], c, sccid[maxn];
pair<long long, long long> scc[maxn], dp[maxn];
bool v[maxn];
string lower(const string &s) {
string ret = "";
for (long long i = 0; i < s.length(); ++i) {
if (s[i] >= 'A' && s[i] <= 'Z')
ret += s[i] + 32;
else
ret += s[i];
}
return ret;
}
long long find(string s) {
s = lower(s);
if (mp.find(s) == mp.end()) {
mp[s] = mp.size();
l[mp[s]] = (long long)s.size();
for (long long i = 0; i < s.size(); ++i)
if (s[i] == 'r') ++r[mp[s]];
}
return mp[s];
}
void add_edge(long long u, long long v) {
G[u].push_back(v);
R[v].push_back(u);
}
void dfs(long long now) {
v[now] = true;
for (long long u : G[now])
if (!v[u]) dfs(u);
t.push_back(now);
}
void rdfs(long long now) {
v[now] = true;
scc[c] = min(scc[c], make_pair(r[now], l[now]));
sccid[now] = c;
for (long long u : R[now])
if (!v[u]) rdfs(u);
}
pair<long long, long long> go(long long now) {
if (dp[now] != make_pair(0ll, 0ll)) return dp[now];
dp[now] = scc[now];
for (long long u : R[now]) {
pair<long long, long long> p = go(u);
dp[now] = min(dp[now], p);
}
return dp[now];
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long m;
cin >> m;
for (long long i = 0; i < m; ++i) {
string s;
cin >> s;
a[i] = find(s);
}
long long n;
cin >> n;
while (n--) {
string a, b;
cin >> a >> b;
long long u = find(a), v = find(b);
add_edge(u, v);
}
for (long long i = 1; i <= mp.size(); ++i)
if (!v[i]) dfs(i);
reverse(t.begin(), t.end());
memset(v, false, sizeof(v));
fill(scc, scc + maxn, make_pair(inf, inf));
for (long long u : t)
if (!v[u]) ++c, rdfs(u);
for (long long i = 0; i < maxn; ++i) R[i].clear();
for (long long i = 1; i <= mp.size(); ++i) {
for (long long u : G[i]) {
if (sccid[u] != sccid[i]) R[sccid[i]].push_back(sccid[u]);
}
}
long long rnow = 0, lnow = 0;
for (long long i = 0; i < m; ++i) {
pair<long long, long long> p = go(sccid[a[i]]);
rnow += p.first;
lnow += p.second;
}
cout << rnow << ' ' << lnow << endl;
return 0;
}
| 10 | CPP |
n=int(input())
a=[int(i) for i in input().split()]
b=1
m=n-a[n-1]
for i in range(n-2,-1,-1):
if i+1<m:
b+=1
m=min(i+1-a[i],m)
print(b) | 8 | PYTHON3 |
a, b = map(int, input().split())
ans = []
check = True
while True:
ans.insert(0, b)
if b%2 == 0:
b //= 2
elif str(b)[-1] == '1':
b = int(str(b)[:-1])
else:
check = False
break
if b == a:
ans.insert(0, b)
break
elif a > b:
check = False
break
if check:
print('YES')
print(len(ans))
for x in ans:
print(x, end=' ')
else:
print('NO') | 7 | PYTHON3 |
#sily#872
for _ in range(int(input())):
n=int(input())
a=[int(x)for x in input().split()]
cnt=0
m=0
ss=-1
for i in range(n):
if(a[i]>m):
m=a[i]
if(a[i]==m):
if(i>0 and a[i-1]<a[i]):
ss=i
elif(i<n-1 and a[i]>a[i+1]):
ss=i
if(ss+1):
print(ss+1)
else:
print(-1)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, a[1000001], k;
int main() {
cin >> n >> m;
k = n - m;
if (n == m) cout << -1, exit(0);
for (i = 1; i <= n; i++) a[i] = i;
for (i = n - m; i >= 1; i--) swap(a[i], a[i - 1]);
cout << k << " ";
for (i = 2; i <= n; i++) cout << a[i] << " ";
return 0;
}
| 8 | CPP |
#include <vector>
#include <iostream>
#include <algorithm>
#pragma warning(disable : 4996)
#define mod 1000000007
using namespace std;
int N, Q, s, t, z[100001], fact[100001]; vector<int> seg[262144];
int query(int a, int b, int x1, int x2, int k, int l, int r) {
if (r <= a || b <= l) return 0;
if (a <= l && r <= b) return lower_bound(seg[k].begin(), seg[k].end(), x2) - lower_bound(seg[k].begin(), seg[k].end(), x1);
int lc = query(a, b, x1, x2, 2 * k, l, (l + r) / 2);
int rc = query(a, b, x1, x2, 2 * k + 1, (l + r) / 2, r);
return lc + rc;
}
int main() {
fact[0] = 1;
for (int i = 1; i < 100000; i++) fact[i] = 1LL * fact[i - 1] * i % mod;
while (cin >> N >> Q) {
for (int i = 0; i < N; i++) z[i] = i;
for (int i = 0; i < Q; i++) {
scanf("%d%d", &s, &t);
swap(z[s - 1], z[t - 1]);
}
for (int i = 0; i < 262144; i++) seg[i].clear();
for (int i = 0; i < N; i++) {
int u = i + 131072;
while (u > 0) {
seg[u].push_back(z[i]);
u >>= 1;
}
}
for (int i = 0; i < 131072; i++) sort(seg[i].begin(), seg[i].end());
int ret = 0;
for (int i = N - 1; i >= 0; i--) ret = (ret + 1LL * query(i + 1, N, 0, z[i], 1, 0, 131072) * fact[N - i - 1]) % mod;
printf("%d\n", ret);
}
} | 0 | CPP |
primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
def first_factor(x):
for p in primes:
if ((x % p) == 0):
return p
return 0
t = int(input())
output = ""
for i in range(t):
m = 0
factors = []
tuples = []
res = ""
n = int(input())
A = [int(x) for x in input().split(' ')]
for j in range(n):
p = first_factor(A[j])
if (p not in factors):
factors.append(p)
m += 1
res += str(m) + " "
else:
res += str(factors.index(p) + 1) + " "
output += str(m) + "\n" + res + "\n"
print(output)
| 8 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
int main(){
long N;cin>>N;long a[N][2];for(int i;i<N;i++)cin>>a[i][0]>>a[i][1];
long b=0;for(int i=N-1;i>=0;i--){long p=a[i][0],q=a[i][1];b=(p+b+q-1)/q*q-p;}
cout<<b<<endl;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int joy = 0, joymax = -1000000000, n, k, temp, temp2, i;
cin >> n >> k;
for (i = 0; i != n; i++) {
cin >> temp >> temp2;
joy = temp;
if (temp2 > k) {
joy = joy - (temp2 - k);
}
if (joy > joymax) {
joymax = joy;
}
}
cout << joymax << endl;
return 0;
}
| 7 | CPP |
d1,d2,d3=map(int,input().split())
print(min((d1*2+d2*2),(d1+d2+d3),(d1*2+d3*2),(d2*2+d3*2))) | 7 | PYTHON3 |
#include <iostream>
#include <string>
int main()
{
std::string s;
for (;;) {
std::cin >> s;
if (s[0] == '0') break;
int sum {};
for (int i=0; s[i]; ++i)
sum += s[i] - '0';
std::cout << sum << '\n';
}
} | 0 | CPP |
#include<iostream>
#include<vector>
#include<cstring>
long long owData[4001];
std::vector<int> used;
int main(){
long long x,input[3];
bool Person;
while( std::cin>>x , x ){
Person=false;
used.clear();
memset(owData,0,sizeof(owData));
while( x-- ){
std::cin>>input[0]>>input[1]>>input[2];
if( owData[input[0]] == 0 )used.push_back(input[0]);
owData[input[0]]+=input[1]*input[2];
}
for(auto it = used.begin(); it != used.end(); ++it ){
if( owData[*it] >= 1000000 )
std::cout<< *it <<std::endl, Person=true ;
}
if(!Person)std::cout<<"NA"<<std::endl;
}
return 0;
} | 0 | CPP |
#include<bits/stdc++.h>
using namespace std;
int main()
{ int t,i,f1,f2;
cin>>t;
int s[4];
while(t--)
{ for(i=0;i<4;i++)
cin>>s[i];
f1=max(s[0],s[1]);
f2=max(s[2],s[3]);
sort(s,s+4);
if((f1==s[2] || f1==s[3]) && (f2==s[2] || f2==s[3]))
cout<<"YES\n";
else
cout<<"NO\n";
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<pair<int, int> > graph[200100];
pair<int, pair<int, int> > edges[200100];
pair<int, int> arr[200100];
long long size_arr[200100];
int parent[200100];
long long ans[200100];
int find(int x) {
if (x == parent[x]) {
return x;
} else {
return parent[x] = find(parent[x]);
}
}
void union_func(int a, int b) {
int c = find(a);
int d = find(b);
if (c != d) {
parent[d] = c;
size_arr[c] += size_arr[d];
}
}
int main() {
cin >> n >> m;
int u, v, w;
for (int i = 1; i <= n - 1; i++) {
cin >> u >> v >> w;
graph[u].push_back({w, v});
graph[v].push_back({w, u});
edges[i - 1].first = w;
edges[i - 1].second.first = u;
edges[i - 1].second.second = v;
}
for (int i = 0; i < m; i++) {
cin >> arr[i].first;
arr[i].second = i;
}
sort(arr, arr + m);
sort(edges, edges + n - 1);
for (int i = 1; i <= n; i++) {
parent[i] = i;
size_arr[i] = 1;
}
int j = 0;
long long ans_now = 0;
for (int i = 0; i < m; i++) {
long long max_weight = (long long)arr[i].first;
int cur_idx = arr[i].second;
while (j <= n - 2 && (long long)edges[j].first <= max_weight) {
int edge_1 = edges[j].second.first;
int edge_2 = edges[j].second.second;
long long init_size1 =
size_arr[find(edge_1)] * (size_arr[find(edge_1)] - 1) / 2;
long long init_size2 =
size_arr[find(edge_2)] * (size_arr[find(edge_2)] - 1) / 2;
union_func(edges[j].second.first, edges[j].second.second);
ans_now += size_arr[find(edge_1)] * (size_arr[find(edge_1)] - 1) / 2 -
init_size1 - init_size2;
j++;
}
ans[cur_idx] = ans_now;
}
for (int i = 0; i < m; i++) {
cout << ans[i] << " ";
}
}
| 13 | CPP |
#include <functional>
#include <algorithm>
#include <iostream>
#include <numeric>
#include <queue>
#include <map>
#include <set>
using namespace std;
typedef pair<int, int> pii;
const int MAXN = 1e5 + 10;
int N;
int fa[MAXN];
set<int> Adj[MAXN];
queue<pii> dualEdges;
map<pii, int> edgeCnt;
int find(int x)
{
if (x == fa[x])
return x;
return fa[x] = find(fa[x]);
}
inline void addEdge(int u, int v)
{
Adj[u].insert(v), Adj[v].insert(u);
if (u > v)
swap(u, v);
if (++edgeCnt[make_pair(u, v)] == 2)
dualEdges.emplace(u, v);
}
int main()
{
int u, v;
cin >> N;
for (int i = 1; i <= 2 * N - 2; i++)
cin >> u >> v, addEdge(u, v);
iota(&fa[0], &fa[N + 1], 0);
for (int i = 1; i < N; i++)
{
int x = 0, y = 0;
do
{
if (dualEdges.empty())
{
puts("NO");
return 0;
}
tie(x, y) = dualEdges.front();
dualEdges.pop();
x = find(x), y = find(y);
} while (x == y);
if (Adj[x].size() > Adj[y].size())
swap(x, y);
fa[x] = y, Adj[x].erase(y), Adj[y].erase(x);
edgeCnt.erase(make_pair(min(x, y), max(x, y)));
for(int z : Adj[x])
{
z = find(z);
edgeCnt[make_pair(min(x, z), max(x, z))]--;
if(z == y)
continue;
Adj[z].erase(x);
addEdge(y, z);
}
}
puts("YES");
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = (long long int)1e9 + 7;
long long int gcd(long long int a, long long int b) {
if (a % b == 0) return b;
return gcd(b, a % b);
}
long long int ab(long long int a) {
if (a < 0) return -1 * a;
return a;
}
long long int cei(long long int a, long long int b) {
return ((a - 1) / b) + 1;
}
long long int flo(long long int a, long long int b) { return a / b; }
long long int lc(long long int a, long long int b) {
return ((a * b) / gcd(a, b));
}
long long int power(long long int a, long long int b, long long int m) {
if (b == 0) return 1;
if (b == 1) return a % m;
long long int t = power(a, b / 2, m);
t = (t * t) % m;
if (b & 1) t = (t * a) % m;
return t;
}
long long int modInverse(long long int a, long long int m) {
return power(a, m - 2, m);
}
void fastscan(long long int &number) {
bool negative = false;
register long long int c;
number = 0;
c = getchar();
if (c == '-') {
negative = true;
c = getchar();
}
for (; (c > 47 && c < 58); c = getchar()) number = number * 10 + c - 48;
if (negative) number *= -1;
}
long long int fun(long long int n, long long int d) {
return ((2 + (n - 1) * d) * n) / 2;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
long long int n, i, j, k, l, m, o, p, s = 0, su = 0, s1 = 0, s2 = 0, d, x, y,
z, r, q;
cin >> n;
vector<long long int> v;
for (i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (i == (n / i))
v.push_back(i);
else {
v.push_back(i);
v.push_back(n / i);
}
}
}
sort(v.begin(), v.end());
for (i = v.size() - 1; i >= 0; i--) cout << fun(n / v[i], v[i]) << " ";
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool check(long long n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
int main() {
int n;
cin >> n;
int cnt = 0;
for (int i = 1; i <= n; i++) {
set<int> s;
int flag = 0;
for (int j = 2; j * j <= i; j++) {
if (i % j == 0) {
s.insert(j);
s.insert(i / j);
}
}
for (auto x : s) {
if (check(x)) flag++;
}
if (flag == 2) cnt++;
}
cout << cnt << "\n";
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 5000;
pair<int, int> r[MAX], c[MAX];
int n, m, k;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> k;
for (int i = 0; i < n; ++i) r[i] = make_pair(0, 0);
for (int i = 0; i < m; ++i) c[i] = make_pair(0, 0);
for (int i = 0; i < k; ++i) {
int type, x, a;
cin >> type >> x >> a;
if (type == 1)
r[x - 1] = make_pair(a, i);
else
c[x - 1] = make_pair(a, i);
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (!r[i].first && !c[j].first)
cout << 0 << " ";
else if (!r[i].first)
cout << c[j].first << " ";
else if (!c[j].first)
cout << r[i].first << " ";
else if (r[i].second > c[j].second)
cout << r[i].first << " ";
else
cout << c[j].first << " ";
}
cout << '\n';
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
const int MAXN = 3e5 + 5;
int mn[MAXN << 2], cnt[MAXN << 2], tag[MAXN << 2];
inline void pushup(int x) {
mn[x] = std::min(mn[((x) << 1)], mn[((x) << 1 | 1)]);
cnt[x] = 0;
if (mn[x] == mn[((x) << 1)]) cnt[x] += cnt[((x) << 1)];
if (mn[x] == mn[((x) << 1 | 1)]) cnt[x] += cnt[((x) << 1 | 1)];
}
inline void cover(int x, int d) {
mn[x] += d;
tag[x] += d;
}
inline void pushdown(int x) {
if (tag[x]) {
cover(((x) << 1), tag[x]);
cover(((x) << 1 | 1), tag[x]);
tag[x] = 0;
}
}
inline void modify(int x, int l, int r, int L, int R, int d) {
if (l == L && r == R) {
cover(x, d);
return;
}
int mid = (l + r) >> 1;
pushdown(x);
if (R <= mid)
modify(((x) << 1), l, mid, L, R, d);
else if (L > mid)
modify(((x) << 1 | 1), mid + 1, r, L, R, d);
else
modify(((x) << 1), l, mid, L, mid, d),
modify(((x) << 1 | 1), mid + 1, r, mid + 1, R, d);
pushup(x);
}
inline void build(int x, int l, int r) {
if (l == r) {
mn[x] = l;
cnt[x] = 1;
return;
}
int mid = (l + r) >> 1;
build(((x) << 1), l, mid);
build(((x) << 1 | 1), mid + 1, r);
pushup(x);
}
std::pair<int, int> a[MAXN];
int n;
int stk1[MAXN], stk2[MAXN], tp1, tp2;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d%d", &a[i].first, &a[i].second);
std::sort(a + 1, a + n + 1);
build(1, 1, n);
long long ans = 0;
for (int i = 1; i <= n; ++i) {
while (tp1 && a[stk1[tp1]].second <= a[i].second) {
modify(1, 1, n, stk1[tp1 - 1] + 1, stk1[tp1], -a[stk1[tp1]].second);
--tp1;
}
while (tp2 && a[stk2[tp2]].second >= a[i].second) {
modify(1, 1, n, stk2[tp2 - 1] + 1, stk2[tp2], a[stk2[tp2]].second);
--tp2;
}
modify(1, 1, n, stk1[tp1] + 1, i, a[i].second);
modify(1, 1, n, stk2[tp2] + 1, i, -a[i].second);
stk1[++tp1] = i;
stk2[++tp2] = i;
if (mn[1] == i) {
ans += cnt[1];
}
}
printf("%lld\n", ans);
return 0;
}
| 12 | CPP |
x,i=int(input()),4
def one(x):
for i in range(2,(x//2)+1):
if x%i==0:return True
return False
while 1:
a=i
b=a+x
if one(a) and one(b):exit(print(b,a))
i+=1 | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int n, ans, f[N][N][2];
struct node {
int x, len;
} line[N];
bool cmp(node a, node b) { return a.x < b.x; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &line[i].x, &line[i].len);
}
sort(line + 1, line + n + 1, cmp);
line[0] = (node){(int)(-1e9), 0};
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= i; j++) {
for (int p = 0; p <= 1; p++) {
ans = max(ans, f[i][j][p]);
int r = line[j].x + p * line[j].len;
int nR = -1e9, nk = 0, nq = 0;
for (int k = i + 1; k <= n; k++) {
for (int q = 0; q <= 1; q++) {
int R = line[k].x + q * line[k].len;
if (nR < R) {
nR = R, nk = k, nq = q;
}
f[k][nk][nq] = max(f[k][nk][nq],
f[i][j][p] + min(line[k].len, R - r) + nR - R);
}
}
}
}
}
printf("%d\n", ans);
return 0;
}
| 11 | CPP |
n=int(input())
sl=list(map(int,input().split()))
sl.sort()
a=sl[0:n]
b=sl[n:]
x=a[0]
y=a[n-1]
z=b[0]
d=b[n-1]
m=sl[2*n-1]-sl[0]
k=(y-x)*(d-z)
for i in range(n):
p=(sl[i+n-1]-sl[i])*m
if p<k:
k=p
print(k) | 9 | PYTHON3 |
t = input()
f=[0]
for j in range(len(t)):
a=bin(ord(t[j]))[2:]
if len(a)<8:
a = '0'*(8-len(a))+a
b=int(a[::-1],2)
x=(f[-1]-b)%256
print(x)
f.append(b)
| 7 | PYTHON3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.