solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000111;
set<int> x, y;
int marks[MAXN];
set<int> pop;
int main() {
int n, l, xx, yy;
scanf("%d%d%d%d", &n, &l, &xx, &yy);
int xw = 0, yw = 0;
for (int i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
pop.insert(a);
if (pop.find(a - xx) != pop.end()) xw = 1;
if (pop.find(a - yy) != pop.end()) yw = 1;
if (a - xx >= 0) x.insert(a - xx);
if (a + xx <= l) x.insert(a + xx);
if (a - yy >= 0) y.insert(a - yy);
if (a + yy <= l) y.insert(a + yy);
}
if (xw == 1 && yw == 1) {
puts("0");
return 0;
}
if (xw == 1) {
printf("1\n%d\n", *(y.begin()));
return 0;
}
if (yw == 1) {
printf("1\n%d\n", *(x.begin()));
return 0;
}
for (auto x1 : x) {
if (y.find(x1) != y.end()) {
printf("1\n%d\n", x1);
return 0;
}
}
puts("2");
printf("%d %d\n", *(x.begin()), *(y.begin()));
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
constexpr int maxn = 55;
template <typename T>
using mat = vector<vector<T>>;
int n;
vector<int> vec[maxn] = {};
mat<long double> add_edge(mat<long double> v, int nr_ops) {
mat<long double> ret(nr_ops + 2, vector<long double>(nr_ops + 2, 0));
assert(v.size() == nr_ops + 1);
for (auto& x : v) assert(x.size() == nr_ops + 1);
ret[0][0] = 1;
for (int i = nr_ops + 1; i; --i) {
for (int j = 1; j <= i; ++j) {
for (int pc = j - 1; pc < i; ++pc) ret[i][j] += v[pc][j - 1];
for (int pc = i; pc <= nr_ops; ++pc) ret[i][j] += v[i][j];
ret[i][j] /= nr_ops + 1.0;
}
}
assert(v.size() == v[0].size());
return ret;
}
long double number_of_splits(int x, int y, int p, int q) {
static long double fact[4 * maxn] = {};
if (fact[0] == 0) {
fact[0] = 1;
for (int i = 1; i < 4 * maxn; ++i) fact[i] = i * fact[i - 1];
}
return (1.0 / fact[x + y + p + q]) * fact[x + y] * (1.0 / fact[x]) *
(1.0 / fact[y]) * (1.0 / fact[p]) * (1.0 / fact[q]) * fact[p + q] *
fact[x + p] * fact[y + q];
}
mat<long double> join_states(mat<long double> a, int nr_ops_a,
mat<long double> b, int nr_ops_b) {
assert(a.size() == nr_ops_a + 1);
assert(b.size() == nr_ops_b + 1);
mat<long double> ret(nr_ops_a + nr_ops_b + 1,
vector<long double>(nr_ops_a + nr_ops_b + 1, 0.0));
for (int ia = 0; ia <= nr_ops_a; ++ia)
for (int ib = 0; ib <= nr_ops_b; ++ib)
for (int ja = 0; ja <= ia; ++ja)
for (int jb = 0; jb <= ib; ++jb)
ret[ia + ib][ja + jb] +=
number_of_splits(nr_ops_a - ia, ia, nr_ops_b - ib, ib) *
a[ia][ja] * b[ib][jb];
assert(ret.size() == ret[0].size());
return ret;
}
pair<int, mat<long double>> dfs(int curr, int prev) {
int sz = 0;
mat<long double> ret(1, vector<long double>(1, 1.0));
for (auto next : vec[curr]) {
if (next == prev) continue;
auto tmp = dfs(next, curr);
ret = join_states(ret, sz, add_edge(tmp.second, tmp.first), tmp.first + 1);
sz += tmp.first + 1;
}
assert(ret.size() == ret[0].size());
return make_pair(sz, ret);
}
int main() {
cin >> n;
for (int i = 0, x, y; i < n - 1; ++i) {
cin >> x >> y;
vec[x].push_back(y);
vec[y].push_back(x);
}
for (int i = 1; i <= n; ++i) {
auto buf = dfs(i, -1).second;
long double sol = 0;
for (int j = buf[n - 1].size() - 1; j >= 0; --j) {
sol = sol / 2.0 + buf[n - 1][j];
}
cout << fixed << setprecision(20) << sol << endl;
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 10000;
int a[N];
int t[N];
int listI[N];
int ind;
int main() {
int n;
scanf("%d", &n);
int cntA = 0, cntB = 0;
for (int i = 0; i < 2 * n; i++) scanf("%d", &a[i]);
for (int i = 10; i < 100; i++) {
int cnt = 0;
for (int s = 0; s < 2 * n; s++) {
if (a[s] == i) cnt++;
}
if (cnt > 1) {
cnt = 2;
for (int s = 0; s < 2 * n; s++) {
if (a[s] == i) {
if (cnt == 1)
t[s] = 1;
else if (cnt == 2)
t[s] = 2;
cnt--;
}
}
} else if (cnt == 1)
listI[ind++] = i;
}
for (int i = 0; i < ind; i++) {
int cur = (i % 2 == 0 ? 1 : 2);
for (int s = 0; s < 2 * n; s++) {
if (a[s] == listI[i]) {
t[s] = cur;
}
}
}
for (int i = 0; i < 2 * n; i++) {
if (t[i] == 1)
cntA++;
else if (t[i] == 2)
cntB++;
}
for (int s = 0; s < 2 * n; s++) {
if (t[s] == 0) {
if (cntA < cntB) {
t[s] = 1;
cntA++;
} else {
t[s] = 2;
cntB++;
}
}
}
int tA = 0, tB = 0;
for (int i = 10; i < 100; i++) {
bool hA = false, hB = false;
for (int s = 0; s < 2 * n; s++) {
if (t[s] == 1 && a[s] == i) hA = true;
if (t[s] == 2 && a[s] == i) hB = true;
}
if (hA) tA++;
if (hB) tB++;
}
cout << tA * tB << endl;
for (int i = 0; i < 2 * n; i++) cout << t[i] << ' ';
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.length();
long long ans = 0;
for (int i = 1; i < n; i++) {
if (s[i] == '@') {
long long cnt1 = 0, cnt2 = 0;
bool ok = 1, t = 0, had = 0;
for (int j = i - 1; j >= 0; j--) {
if (s[j] == '@' || s[j] == '.') break;
if (isalpha(s[j])) cnt1++;
}
for (int j = i + 1; j < n; j++) {
if (isalpha(s[j]) || s[j] >= '0' && s[j] <= '9') had = 1;
if (t) {
if (isalpha(s[j]))
cnt2++;
else
break;
}
if (s[j] == '.') {
if (!t && had)
t = 1;
else
break;
} else if (s[j] == '@' || s[j] == '_') {
if (!t) ok = 0;
break;
}
}
if (ok) ans += cnt1 * cnt2;
}
}
cout << ans;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
using cd = complex<double>;
const long long INF = 1e18;
const long long mod = 998244353;
const double Pi = acos(-1);
void Fastio() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
int k, n;
string s;
int min0 = 1e9, max0 = -1, min1 = 1e9, max1 = -1;
signed main() {
Fastio();
cin >> n >> k;
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '0') {
min0 = min(min0, i);
max0 = max(max0, i);
} else {
min1 = min(min1, i);
max1 = max(max1, i);
}
}
if (max0 == -1 or max1 == -1) {
cout << "tokitsukaze";
return 0;
}
if (max0 - min0 + 1 <= k or max1 - min1 + 1 <= k) {
cout << "tokitsukaze";
return 0;
}
if (max0 - min0 + 1 >= k + 2 or max1 - min1 + 1 >= k + 2) {
cout << "once again";
return 0;
}
if (min0 >= k or n - max0 - 1 >= k or min1 >= k or n - max1 - 1 >= k) {
cout << "once again";
return 0;
}
cout << "quailty";
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
map<char, pair<int, int> > mp;
mp['U'] = make_pair(0, 1);
mp['D'] = make_pair(0, -1);
mp['L'] = make_pair(-1, 0);
mp['R'] = make_pair(1, 0);
int a, b;
cin >> a >> b;
pair<int, int> fin_pos = make_pair(a, b);
string s;
cin >> s;
bool fg = false;
if (not a and not b) fg = true;
pair<int, int> npos = make_pair(0, 0), dx = make_pair(0, 0);
auto add_pair = [](pair<int, int> _a, pair<int, int> _b) {
return make_pair(_a.first + _b.first, _a.second + _b.second);
};
for (char c : s) {
dx = add_pair(dx, mp[c]);
}
for (char c : s) {
npos = add_pair(npos, mp[c]);
if (npos == fin_pos or ([&]() {
if (dx.first == 0 and dx.second == 0) return false;
if (dx.first != 0 and (fin_pos.first - npos.first) % dx.first != 0)
return false;
if (dx.second != 0 and
(fin_pos.second - npos.second) % dx.second != 0)
return false;
if (dx.first == 0) {
return (fin_pos.first == npos.first) and
(fin_pos.second - npos.second) / dx.second >= 0;
} else if (dx.second == 0) {
return (fin_pos.second == npos.second) and
(fin_pos.first - npos.first) / dx.first >= 0;
}
int t1 = (fin_pos.first - npos.first) / dx.first;
int t2 = (fin_pos.second - npos.second) / dx.second;
return t1 >= 0 and t1 == t2;
})()) {
fg = true;
break;
}
}
cout << (fg ? "Yes" : "No") << endl;
return 0;
}
| 7 | CPP |
/*
* GCA : "Computer is artificial subject absolutely,Math is God"
*/
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <climits>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <cctype>
#include <utility>
#include <ctime>
using namespace std;
#ifdef DEBUG
#define VAR(a,b) __typeof(b) a=(b)
#define debug(...) printf("DEBUG: "),printf(__VA_ARGS__)
#else
#define VAR(a,b) __typeof(b) a=(b)
#define debug(...)
#endif
typedef unsigned int uint;
typedef long long int Int;
typedef unsigned long long int UInt;
#define Set(a,s) memset(a,s,sizeof(a))
#define Pln() printf("\n")
#define For(i,x)for(int i=0;i<x;i++)
#define CON(x,y) x##y
#define M 25
#define PB push_back
#define oo INT_MAX
#define FOR(a,b) for(VAR(a,(b).begin());a!=(b).end();++a)
#define eps 1e-9
#define X first
#define Y second
inline bool xdy(double x,double y){return x>y+eps;}
inline bool xddy(double x,double y){return x>y-eps;}
inline bool xcy(double x,double y){return x<y-eps;}
inline bool xcdy(double x,double y){return x<y+eps;}
const Int mod=1000000007;
int nx,ny;
char mz[M][M];
set<string> sid;
int dx[8]={0,1,1,1,0,-1,-1,-1};
int dy[8]={1,1,0,-1,-1,-1,0,1};
char store[M*M];
int ox,oy;
string ans;
bool vis[M][M];
void dfs(int x,int y,int d,int dep){
store[dep]=mz[y][x];
int nex=(x+dx[d]+nx)%nx;
int ney=(y+dy[d]+ny)%ny;
store[dep+1]=0;
string ss(store);
if(sid.count(ss)&&ss.length()>=2){
if(ss.length()>ans.length())ans=ss;
else if(ss.length()==ans.length()&&ss<ans){
ans=ss;
}
}
sid.insert(ss);
vis[x][y]=1;
if(!vis[nex][ney])dfs(nex,ney,d,dep+1);
vis[x][y]=0;
}
void solve(){
Set(vis,0);
for(int i=0;i<ny;i++){
for(int j=0;j<nx;j++){
for(int k=0;k<8;k++){
vis[j][i]=1;
dfs(j,i,k,0);
vis[j][i]=0;
}
}
}
if(ans.size())
puts(ans.c_str());
else puts("0");
}
int main() {
ios_base::sync_with_stdio(0);
while(~scanf("%d%d",&ny,&nx)&&ny&&nx){
sid.clear();
ans="";
for(int i=0;i<ny;i++)scanf("%s",mz[i]);
solve();
}
} | 0 | CPP |
#include<iostream>
using namespace std;
long long n,a,b,c;
int main()
{
cin>>a>>b;
if(a>9 ||b>9)
cout<<-1<<endl;
else
cout<<a*b<<endl;
} | 0 | CPP |
#include <bits/stdc++.h>
template <int MOD>
struct ModInt {
using lint = long long;
int val;
ModInt(lint v = 0) : val(v % MOD) {
if (val < 0) val += MOD;
};
ModInt operator+() const { return ModInt(val); }
ModInt operator-() const { return ModInt(MOD - val); }
ModInt inv() const { return this->pow(MOD - 2); }
ModInt operator+(const ModInt& x) const { return ModInt(*this) += x; }
ModInt operator-(const ModInt& x) const { return ModInt(*this) -= x; }
ModInt operator*(const ModInt& x) const { return ModInt(*this) *= x; }
ModInt operator/(const ModInt& x) const { return ModInt(*this) /= x; }
ModInt pow(lint n) const {
auto x = ModInt(1);
auto b = *this;
while (n > 0) {
if (n & 1) x *= b;
n >>= 1;
b *= b;
}
return x;
}
ModInt& operator+=(const ModInt& x) {
if ((val += x.val) >= MOD) val -= MOD;
return *this;
}
ModInt& operator-=(const ModInt& x) {
if ((val -= x.val) < 0) val += MOD;
return *this;
}
ModInt& operator*=(const ModInt& x) {
val = lint(val) * x.val % MOD;
return *this;
}
ModInt& operator/=(const ModInt& x) { return *this *= x.inv(); }
bool operator==(const ModInt& b) const { return val == b.val; }
bool operator!=(const ModInt& b) const { return val != b.val; }
friend std::istream& operator>>(std::istream& is, ModInt& x) noexcept {
return is >> x.val;
}
friend std::ostream& operator<<(std::ostream& os, const ModInt& x) noexcept {
return os << x.val;
}
};
constexpr int MOD = 1e9 + 7;
using mint = ModInt<MOD>;
template <class T>
std::vector<T> vec(int len, T elem) {
return std::vector<T>(len, elem);
}
template <class T>
void shift(std::vector<T>& v) {
int n = v.size();
for (int i = 0; i + 1 < n; ++i) {
v[i] = v[i + 1];
}
}
int main() {
int n, x;
std::string t;
std::cin >> n >> x >> t;
auto sdp = vec(3, vec(n + 1, vec(n + 1, mint(0))));
auto pdp = sdp, adp = sdp;
auto cnts = vec(3, mint(0));
auto lenpow = vec(3, mint(0));
for (int i = 0; i < 2; ++i) {
std::string s(1, '0' + i);
for (int l = 0; l <= n; ++l) {
sdp[i][l][l] = 2;
pdp[i][l][l] = 2;
adp[i][l][l] = 1;
if (s == t.substr(l, 1)) {
sdp[i][l][l + 1] = 1;
pdp[i][l][l + 1] = 1;
adp[i][l][l + 1] = 1;
}
}
cnts[i] = adp[i][0][n];
lenpow[i] = 2;
}
if (x == 0) {
std::cout << cnts[0] << std::endl;
return 0;
}
for (int q = 2; q <= x; ++q) {
lenpow[2] = lenpow[1] * lenpow[0];
for (int l = 0; l <= n; ++l) {
for (int r = l; r <= n; ++r) {
pdp[2][l][r] = 0;
sdp[2][l][r] = 0;
adp[2][l][r] = 0;
for (int k = l; k <= r; ++k) {
pdp[2][l][r] += (k == r ? pdp : adp)[1][l][k] * pdp[0][k][r];
sdp[2][l][r] += sdp[1][l][k] * (k == l ? sdp : adp)[0][k][r];
adp[2][l][r] += adp[1][l][k] * adp[0][k][r];
}
}
}
cnts[2] = cnts[1] * lenpow[0] + cnts[0] * lenpow[1];
for (int k = 1; k < n; ++k) {
cnts[2] += sdp[1][0][k] * pdp[0][k][n];
}
shift(sdp);
shift(pdp);
shift(adp);
shift(lenpow);
shift(cnts);
}
std::cout << cnts[1] << std::endl;
return 0;
}
| 12 | CPP |
from bisect import *
from collections import *
from itertools import *
import functools
import sys
import math
from decimal import *
from copy import *
from heapq import *
from fractions import *
getcontext().prec = 30
MAX = sys.maxsize
MAXN = 300010
MOD = 10**9+7
spf = [i for i in range(MAXN)]
spf[0]=spf[1] = -1
def sieve():
for i in range(2,MAXN,2):
spf[i] = 2
for i in range(3,int(MAXN**0.5)+1):
if spf[i]==i:
for j in range(i*i,MAXN,i):
if spf[j]==j:
spf[j]=i
def fib(n,m):
if n == 0:
return [0, 1]
else:
a, b = fib(n // 2)
c = ((a%m) * ((b%m) * 2 - (a%m)))%m
d = ((a%m) * (a%m))%m + ((b)%m * (b)%m)%m
if n % 2 == 0:
return [c, d]
else:
return [d, c + d]
def charIN(x= ' '):
return(sys.stdin.readline().strip().split(x))
def arrIN(x = ' '):
return list(map(int,sys.stdin.readline().strip().split(x)))
def ncr(n,r):
num=den=1
for i in range(r):
num = (num*(n-i))%MOD
den = (den*(i+1))%MOD
return (num*(pow(den,MOD-2,MOD)))%MOD
def flush():
return sys.stdout.flush()
'''*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*'''
for _ in range(int(input())):
n = int(input())
print(n) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
cout << (k / n) + (k % n != 0) << '\n';
}
| 7 | CPP |
t=int(input())
for i in range(t):
n=int(input())
a=list(map(int, input().split(" ")))
al=min(a)
c=0
for j in range(n):
if a[j]==al:
c+=1
print(n-c) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 17;
const int MX = (int)1e6 + 17;
const int MOD = (int)1e9 + 7;
const long long oo = LLONG_MAX;
const int INF = INT_MAX;
const long double Pi = 3.14159265358979323846264338327950288419716939937510;
const int di[4] = {-1, 0, 1, 0};
const int dj[4] = {0, 1, 0, -1};
inline long long IN() {
long long x = 0, ch = getchar(), f = 1;
while (!isdigit(ch) && (ch != '-') && (ch != EOF)) ch = getchar();
if (ch == '-') {
f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
inline void OUT(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10)
OUT(x / 10), putchar(x % 10 + '0');
else
putchar(x + '0');
}
void IOI2017() {
freopen(
"partition"
".in",
"r", stdin);
freopen(
"partition"
".out",
"w", stdout);
}
int n;
int ans[2 * N];
vector<int> t[8 * N];
struct node {
int l, r, id;
} a[2 * N];
bool cmp(node a, node b) {
if (a.l != b.l)
return a.l < b.l;
else
return a.r < b.r;
}
void build(int v = 1, int tl = 1, int tr = n) {
if (tl == tr)
t[v].push_back(a[tl].r);
else {
int tm = (tl + tr) / 2;
build(v * 2, tl, tm);
build(v * 2 + 1, tm + 1, tr);
merge(t[v * 2].begin(), t[v * 2].end(), t[v * 2 + 1].begin(),
t[v * 2 + 1].end(), back_inserter(t[v]));
}
}
int get(int l, int r, int val, int v = 1, int tl = 1, int tr = n) {
if (tl > r || tr < l) return 0;
if (l <= tl && tr <= r)
return lower_bound(t[v].begin(), t[v].end(), val) - t[v].begin();
int tm = (tl + tr) / 2;
return get(l, r, val, v * 2, tl, tm) + get(l, r, val, v * 2 + 1, tm + 1, tr);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].l >> a[i].r;
a[i].id = i;
}
sort(a + 1, a + 1 + n, cmp);
build();
for (int i = 1, cur; i <= n; i++) {
cur = get(i, n, a[i].r);
ans[a[i].id] = cur;
}
for (int i = 1; i <= n; i++) cout << ans[i] << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, maxn = 100005;
int n, m, fa[maxn], num[maxn], a[maxn], dp[maxn];
int find(int x) {
if (x == fa[x]) return x;
return fa[x] = find(fa[x]);
}
void unite(int x, int y) {
x = find(x), y = find(y);
if (x == y) return;
fa[x] = y;
num[y] += num[x];
}
void ZeroOne_Pack(int cost, int weight) {
for (int i = n; i >= cost; i--) dp[i] = min(dp[i], dp[i - cost] + weight);
}
void Multiple_Pack(int cost, int weight, int amount) {
int k = 1;
while (k < amount) {
ZeroOne_Pack(k * cost, k * weight);
amount -= k;
k *= 2;
}
ZeroOne_Pack(amount * cost, amount * weight);
}
bool check(int x) {
while (x) {
if (x % 10 != 4 && x % 10 != 7) return 0;
x /= 10;
}
return 1;
}
int main() {
while (~scanf("%d%d", &n, &m)) {
for (int i = 1; i <= n; i++) fa[i] = i, num[i] = 1;
while (m--) {
int u, v;
scanf("%d%d", &u, &v);
unite(u, v);
}
for (int i = 1; i <= n; i++)
if (find(i) == i) a[num[i]]++;
memset(dp, INF, sizeof(dp));
dp[0] = 0;
for (int i = 1; i <= n; i++)
if (a[i]) Multiple_Pack(i, 1, a[i]);
int ans = INF;
for (int i = 1; i <= n; i++)
if (check(i)) ans = min(ans, dp[i]);
if (ans == INF)
printf("-1\n");
else
printf("%d\n", ans - 1);
}
return 0;
}
| 11 | CPP |
# f = open('test.py')
# def input():
# return f.readline().replace('\n','')
# import heapq
# from collections import defaultdict
def read_list():
return list(map(int,input().strip().split(' ')))
def print_list(l):
print(' '.join(map(str,l)))
N = int(input())
for _ in range(N):
a,b,c = read_list()
if a>=c:
r1 = -1
else:
r1 = 1
if c/b>=a:
r2 = -1
else:
r2 = b
print(r1,r2)
| 7 | PYTHON3 |
from collections import Counter
n = int(input())
c = Counter(input())
print(('1' if c['1'] else '')+('0'*c['0']))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long n;
cin >> n;
vector<pair<long long, long long>> v(n);
for (long long i = 0; i < n; i++) cin >> v[i].first >> v[i].second;
sort(v.begin(), v.end());
long long dp[n][2];
for (long long i = 0; i < n; i++) dp[i][0] = dp[i][1] = INT_MAX;
dp[0][1] = v[0].second;
for (long long i = 1; i < n; i++) {
long long temp = 0;
for (long long j = i - 1; j >= 0; j--) {
temp += (v[j + 1].first - v[j].first) * (i - j);
dp[i][0] = min(dp[i][0], dp[j][1] + temp);
}
dp[i][1] = min(dp[i][1], min(dp[i - 1][0], dp[i - 1][1]) + v[i].second);
}
cout << min(dp[n - 1][1], dp[n - 1][0]);
return 0;
}
| 11 | CPP |
if __name__=="__main__":
k=int(input())
print('ACL'*k)
| 0 | PYTHON3 |
li = list(map(int,input().strip().split()))
k = li[0]
n = li[1]
w = li[2]
ans = 0
va = 0
for i in range(1,w+1):
ans = ans+(k*i)
if(n>=ans):
print("0")
else:
ans = ans-n
print(ans) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 101111, max_m = 12, bsize = 320, inf = 1111111111;
struct block {
pair<int, int> a[bsize][max_m];
};
int n, m, q, l[bsize], r[bsize], dx[222], dy[222], num[max_n];
string s[max_n];
block b[bsize];
pair<int, int> p(2, 2);
bool is_in(int num, int x, int y) {
return 0 <= x && x <= r[num] - l[num] && 0 <= y && y < m;
}
void get(int num, int x, int y, int px, int py) {
if (b[num].a[x][y] != p) {
return;
}
if (y >= s[l[num] + x].length()) exit(0);
int nx = x + dx[s[l[num] + x][y]];
int ny = y + dy[s[l[num] + x][y]];
if (!is_in(num, nx, ny)) {
b[num].a[x][y] = make_pair(nx, ny);
return;
}
if (b[num].a[nx][ny] != p) {
b[num].a[x][y] = b[num].a[nx][ny];
return;
}
if (nx == px && ny == py) {
b[num].a[x][y] = make_pair(inf, inf);
return;
}
get(num, nx, ny, x, y);
b[num].a[x][y] = b[num].a[nx][ny];
}
void update(int num) {
for (int i = l[num]; i <= r[num]; ++i) {
for (int j = 0; j < m; ++j) {
b[num].a[i - l[num]][j] = p;
}
}
for (int i = l[num]; i <= r[num]; ++i) {
for (int j = 0; j < m; ++j) {
get(num, i - l[num], j, -3, -3);
}
}
}
void write(int num) {
for (int i = l[num]; i <= r[num]; ++i) {
for (int j = 0; j < m; ++j) {
cout << "(" << b[num].a[i - l[num]][j].first << ", "
<< b[num].a[i - l[num]][j].second << ") ";
}
cout << endl;
}
}
int main() {
dx['<'] = 0;
dy['<'] = -1;
dx['>'] = 0;
dy['>'] = 1;
dx['^'] = -1;
dy['^'] = 0;
ios_base::sync_with_stdio(false);
cin >> n >> m >> q;
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
for (int i = 0; i < bsize; ++i) {
l[i] = i * bsize;
r[i] = min(n - 1, (i + 1) * bsize - 1);
for (int j = l[i]; j <= r[i] && j < max_n; ++j) {
num[j] = i;
}
update(i);
}
while (q--) {
char c1, c2;
int x, y;
cin >> c1 >> x >> y;
--x;
--y;
if (c1 == 'A') {
int num_b = num[x];
x -= l[num_b];
while (true) {
if (num_b < 0) {
cout << x + 1 << " " << y + 1 << "\n";
break;
}
int nx = b[num_b].a[x][y].first;
int ny = b[num_b].a[x][y].second;
if (nx == inf && ny == inf) {
cout << "-1 -1\n";
break;
}
if (ny < 0 || ny >= m) {
cout << l[num_b] + nx + 1 << " " << ny + 1 << "\n";
break;
}
--num_b;
if (num_b < 0)
x = -1;
else
x = r[num_b] - l[num_b];
y = ny;
}
} else {
cin >> c2;
s[x][y] = c2;
update(num[x]);
}
}
return 0;
}
| 10 | CPP |
l=[[2],[3],[2,2,3],[5],[5,3],[7],[7,2,2,2],[7,3,3,2]]
n=int(input())
s=input()
ans=[]
for i in s:
#print("i = ",i)
if(int(i) in {0,1}):
continue
else:
ans.extend(l[int(i)-2])
ans.sort(reverse=True)
print("".join(map(str,ans))) | 7 | PYTHON3 |
n=int(input())
p=[int(i) for i in input().split()]
p.insert(0,0)
visited=[False]*(n+1)
mas_vix=[0]
def DFS(node):
global visited
global mas_vix
if visited[node]==True:
for i in range(len(visited)):
visited[i]=False
mas_vix.append(node)
return
visited[node]=True
DFS(p[node])
for i in range(1,len(p)):
DFS(i)
mas_vix.remove(0)
print(*mas_vix) | 8 | PYTHON3 |
s = input()
print(["NO", "YES"]["H" in s or "Q" in s or "9" in s]) | 7 | PYTHON3 |
# -*- coding: utf-8 -*-
"""
Created on Sun Mar 3 23:50:56 2019
@author: loyuli
"""
n = int(input())
s = list(map(int, input().split()))
odd = []
even = []
for i in s:
if i % 2 == 0:
even.append(i)
else:
odd.append(i)
odd.sort()
even.sort()
if abs(len(odd) - len(even)) <= 1:
print(0)
else:
m = min(len(odd), len(even))
if len(odd) > len(even):
print(sum(odd[:-m-1]))
else:
print(sum(even[:-m-1])) | 8 | PYTHON3 |
n, t = map(int, input().split())
min, tmin = None, None
for i in range(n):
s, d = map(int, input().split())
if s > t:
a = s-t
else:
a = (t-s) % d
if a != 0:
a = d - a
if min == None or a < tmin:
min = i+1
tmin = a
print(min)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long x1, y8477234, x2, y2, x3, y3, ix3, iy3;
int i;
long long sqr(long long x) { return (x * x); }
bool check(long long xx, long long yy) {
long long aa = xx * x3 + yy * y3;
long long bb = xx * ix3 + yy * iy3;
long long cc = sqr(x3) + sqr(y3);
if (cc == 0) return ((xx == 0) && (yy == 0));
return ((aa % cc == 0) && (bb % cc == 0));
}
int main() {
cin >> x1 >> y8477234 >> x2 >> y2 >> x3 >> y3;
ix3 = -y3;
iy3 = x3;
for (i = 0; i < 4; i++) {
swap(x1, y8477234);
x1 = -x1;
if (check(x2 - x1, y2 - y8477234)) break;
}
if (i < 4)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 9 | CPP |
n = int(input())
s = input()
if n == 1: print("Yes" if s == '1' else "No")
else: print("Yes" if s[:2] != '00' and s[-2:] != '00' and s.find('000') == -1 and s.find('11') == -1 else "No")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b;
cin >> a >> b;
cout << a + b;
return 0;
}
| 14 | CPP |
#include<iostream>
#include<algorithm>
#include<map>
const int MAX_N = 100;
int bit[MAX_N+1], n;
int sum(int i){
int s = 0;
while(i > 0){
s += bit[i];
i -= i & -i;
}
return s;
}
void add(int i, int x){
while(i <= n){
bit[i] += x;
i += i & -i;
}
}
int main(){
int a[MAX_N], b[MAX_N];
while(std::cin >> n, n){
for(int i=0;i<MAX_N+1;i++){
bit[i] = 0;
}
for(int i=0;i<n;i++){
std::cin >> a[i];
}
for(int i=0;i<n;i++){
b[i] = a[i];
}
std::sort(b, b+n);
std::map<int, int> m;
for(int i=0;i<n;i++){
m[b[i]] = i+1;
}
int t = 0;
for(int i=0;i<n;i++){
t += i - sum(m[a[i]]);
add(m[a[i]], 1);
}
std::cout << t << std::endl;
}
} | 0 | CPP |
#include<bits/stdc++.h>
using namespace std;
int main() {
int i, y;
double r, w, c, x;
while (1){
i = 0;
cin >> r >> w >> c >> x;
if (r == 0 && w == 0 && c == 0 && x == 0){break;}
y = r / (double)w;
while(y != c){
if (y > c) {
w= w + 0.1;
}else if (y < c) {
r = r + x;
i++;
}
y = r / (double)w;
}
cout << i << endl;
}
}
| 0 | CPP |
n,s,t=map(int,input().split())
p=list(map(int,input().split()))
p.insert(0,-1)
i=s; cnt=0; f=0
while i!=t:
i=p[i]
if i==s: f=1; break
cnt+=1
print(-1 if f else cnt) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <int POS, class TUPLE>
void deploy(std::ostream &os, const TUPLE &tuple) {}
template <int POS, class TUPLE, class H, class... Ts>
void deploy(std::ostream &os, const TUPLE &t) {
os << (POS == 0 ? "" : ", ") << get<POS>(t);
deploy<POS + 1, TUPLE, Ts...>(os, t);
}
template <class... Ts>
std::ostream &operator<<(std::ostream &os, const std::tuple<Ts...> &t) {
os << "(";
deploy<0, std::tuple<Ts...>, Ts...>(os, t);
os << ")";
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::vector<T> &v) {
int remain = v.size();
os << "{";
for (auto e : v) os << e << (--remain == 0 ? "" : ", ");
os << "}";
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::set<T> &v) {
int remain = v.size();
os << "{";
for (auto e : v) os << e << (--remain == 0 ? "" : ", ");
os << "}";
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::queue<T> &q) {
os << "{";
for (; !q.empty(); q.pop()) {
os << q.front() << (q.size() != 1 ? ", " : "");
}
os << "}";
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::priority_queue<T> &q) {
os << "{";
for (; !q.empty(); q.pop()) {
os << q.top() << (q.size() != 1 ? ", " : "");
}
os << "}";
return os;
}
template <class T, class K>
std::ostream &operator<<(std::ostream &os, std::pair<T, K> &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <class T, class K>
std::ostream &operator<<(std::ostream &os, std::map<T, K> &mp) {
int remain = mp.size();
os << "{";
for (auto e : mp)
os << "(" << e.first << " -> " << e.second << ")"
<< (--remain == 0 ? "" : ", ");
os << "}";
return os;
}
template <class T, class K>
std::ostream &operator<<(std::ostream &os, std::unordered_map<T, K> &mp) {
int remain = mp.size();
os << "{";
for (auto e : mp)
os << "(" << e.first << " -> " << e.second << ")"
<< (--remain == 0 ? "" : ", ");
os << "}";
return os;
}
const int64_t MAX = 100500;
bool used[MAX];
bool edge_used[MAX];
vector<tuple<int, int>> edges[MAX];
vector<tuple<int, int, int>> ans;
bool recur(int64_t pos, int64_t parent) {
if (used[pos]) return true;
used[pos] = true;
int dat = -1;
for (auto t : edges[pos]) {
int e = get<0>(t);
int edge_index = get<1>(t);
if (edge_used[edge_index]) continue;
edge_used[edge_index] = true;
if (!recur(e, pos)) continue;
if (dat != -1) {
ans.push_back(make_tuple(dat, pos, e));
dat = -1;
} else {
dat = e;
}
}
if (dat == -1) return true;
ans.push_back(make_tuple(dat, pos, parent));
return false;
}
int main() {
memset(used, false, sizeof(used));
memset(edge_used, false, sizeof(used));
int n, m;
scanf("%d %d", &n, &m);
for (int64_t i = 0; i < ((int64_t)(m)); ++i) {
int a, b;
scanf("%d %d", &a, &b);
edges[a].push_back(make_tuple(b, i));
edges[b].push_back(make_tuple(a, i));
}
if (m % 2) {
printf("No solution\n");
return 0;
}
recur(1, -1);
for (int64_t i = 0; i < ((int64_t)(((int64_t)((ans).size())))); ++i)
printf("%d %d %d\n", get<0>(ans[i]), get<1>(ans[i]), get<2>(ans[i]));
}
| 9 | CPP |
lucky=[4,7,47,74,444,447,474,477,744,747,774,777]
x=int(input())
count=0
for i in lucky:
if x%i==0:
print('YES')
count=1
break
if i>x:
break
if count==0:
print('NO') | 7 | PYTHON3 |
n = int(input())
ans = 0
polygon = {'Tetrahedron':4, 'Cube': 6, 'Octahedron':8, 'Dodecahedron':12, 'Icosahedron':20}
for _ in range(n):
type = input()
ans += polygon[type]
print(ans) | 7 | PYTHON3 |
t=int(input())
for i in range(t):
n,k=map(int,input().split())
total=n
if(n%2==0):
print(n+(2*k))
continue
fac=0
for j in range(total,1,-1):
if(total%j==0):
fac=j
print(n+fac+(2*(k-1))) | 7 | PYTHON3 |
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <vector>
using namespace std;
const int N=100010;
int tp,tt;
bool vis[N];
vector <int> q[N];
int v[N],head[N],to[N*2],nxt[N*2],in[N],a[N],b[N];
inline int gi() {
int x=0,o=1;
char ch=getchar();
while(ch!='-'&&(ch<'0'||ch>'9')) ch=getchar();
if(ch=='-') o=-1,ch=getchar();
while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
return x*o;
}
inline int dfs(int x,int fa) {
if(vis[x]) return 0;
vis[x]=1,v[++tp]=q[x].size();
for(int i=head[x];i;i=nxt[i])
if(to[i]!=fa) return dfs(to[i],x);
return x;
}
int main() {
int n;
cin>>n;
for(int i=1;i<n;i++)
++in[a[i]=gi()],++in[b[i]=gi()];
for(int i=1;i<n;i++) {
int x=a[i],y=b[i];
if(in[x]>1&&in[y]>1) {
to[++tt]=y,nxt[tt]=head[x],head[x]=tt;
to[++tt]=x,nxt[tt]=head[y],head[y]=tt;
}
if(in[x]==1) q[y].push_back(x);
if(in[y]==1) q[x].push_back(y);
}
if(n==2) return puts("1\n2"),0;
for(int i=1;i<=n;i++)
if(in[i]>1) {
int x=dfs(i,0);
if(!x) return puts("-1"),0;
memset(vis,0,sizeof(vis));
tp=0,x=dfs(x,0);
for(int j=1;j<=n;j++)
if(in[j]>1&&!vis[j]) x=0;
if(!x) return puts("-1"),0;
break;
}
int l=1,r=tp,t=0;
while(l<=r) {
if(v[l]<v[r]) break;
if(v[l]>v[r]) {t=1;break;}
++l,--r;
}
if(t) reverse(v+1,v+1+tp);
--v[1],--v[tp];
++tp,t=2;
cout<<1<<' ';
for(int i=1;i<=tp;i++) {
int x=v[i];
for(int j=1;j<=x;j++) printf("%d ",t+j);
printf("%d ",t),t+=x+1;
}
return 0;
} | 0 | CPP |
input()
a = list(map(int,input().split()))
input()
b = list(map(int,input().split()))
def func(a,b):
for item in a:
for item1 in b:
sum1= (item+item1)
if sum1 not in a and sum1 not in b:
print(item,item1)
return
func(a,b)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int x;
scanf("%d", &x);
int y;
y = x / 100;
x %= 100;
if(x == 0 || x > 12){
if(y != 0 && y <= 12) printf("MMYY\n");
else printf("NA\n");
} else {
if(y != 0 && y <= 12) printf("AMBIGUOUS");
else printf("YYMM\n");
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int MOD = 1000000007;
long long int INFL = 1ll << 60;
long long int INF = 1 << 28;
int main() {
int n;
cin >> n;
string s, t, p;
for (int i = 0; i < n; i++) {
bool can = true;
cin >> s >> t >> p;
int a = 0;
for (auto x : t)
if (s[a] == x) a++;
if (a < s.size()) can = false;
map<char, int> m;
for (auto x : s) m[x]++;
for (auto x : t) m[x]--;
for (auto x : p) m[x]++;
for (auto x : m)
if (x.second < 0) can = false;
cout << ((can) ? "YES" : "NO") << endl;
}
}
| 9 | CPP |
import sys
input=sys.stdin.readline
from collections import *
from math import *
t=int(input())
while(t):
t-=1
n=int(input())
flag=0
p,c=map(int,input().split())
if(c>p):
flag=1
for i in range(n-1):
x,y=map(int,input().split())
if(x>=p and y>=c and y<=x and (y-c)<=(x-p)):
p=x
c=y
continue
flag=1
if(flag==0):
print("YES")
else:
print("NO")
| 7 | PYTHON3 |
a,m=map(int,input().split())
ans="No"
for _ in range(m):
if a%m==0:
ans="Yes"
break
else:
a+=a%m
print(ans) | 7 | PYTHON3 |
t = int(input())
for _ in range(t):
a,b = map(int,input().split())
print((a//b)*b+min(a%b,b//2)) | 8 | PYTHON3 |
s = input()
s = s.replace('WUB', ' ')
ss = s.split(' ')
ss = filter(lambda x: x, ss)
print(" ".join(ss))
| 7 | PYTHON3 |
#include "bits/stdc++.h"
using namespace std;
typedef vector<int> vi;
typedef pair<int,int> pii;
typedef long long ll;
#define dump(x) cerr << #x << " = " << (x) << endl
#define rep(i,n) for(int i=0;i<(n);i++)
#define all(a) (a).begin(),(a).end()
#define pb push_back
int main(){
string s;
int n;
map<string,vi> mp;
vector<string> sent;
while(cin>>s>>n){
if(mp[s].size()==0)sent.pb(s);
mp[s].pb(n);
}
sort(all(sent));
rep(i,sent.size()){
cout<<sent[i]<<endl;
vi a;
rep(j,mp[sent[i]].size()){
a.pb(mp[sent[i]][j]);
}
sort(all(a));
rep(i,a.size()){
if(i!=0)cout<<" ";
cout<<a[i];
}
cout<<endl;
}
} | 0 | CPP |
testCases = int(input())
for t in range(testCases):
numStudents, numSwaps, rivalA, rivalB = tuple(map(int, input().split(" ")))
initDistance = abs(rivalA - rivalB)
maxMovement = numStudents - initDistance - 1
maxFinalDistance = initDistance + min(maxMovement, numSwaps)
print(maxFinalDistance)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
int n, q;
struct sgt {
struct node {
int l, r, tag, sum;
};
node a[500005];
void tag(int k) {
a[k].tag = a[k].tag ^ 1;
a[k].sum = a[k].r - a[k].l + 1 - a[k].sum;
}
void pushup(int k) { a[k].sum = a[k * 2].sum + a[k * 2 + 1].sum; }
void pushdown(int k) {
if (!a[k].tag) return;
tag(k * 2);
tag(k * 2 + 1);
a[k].tag = 0;
}
void build(int k, int l, int r) {
a[k].l = l;
a[k].r = r;
a[k].tag = a[k].sum = 0;
if (l == r) return;
int mid = (l + r) / 2;
build(k * 2, l, mid);
build(k * 2 + 1, mid + 1, r);
pushup(k);
}
void update(int k, int x, int y) {
if (x <= a[k].l & a[k].r <= y) {
tag(k);
return;
}
pushdown(k);
int mid = (a[k].l + a[k].r) / 2;
if (x <= mid) update(k * 2, x, y);
if (mid < y) update(k * 2 + 1, x, y);
pushup(k);
}
int query(int k, int x, int y) {
if (x <= a[k].l && a[k].r <= y) return a[k].sum;
pushdown(k);
int mid = (a[k].l + a[k].r) / 2, ans = 0;
if (x <= mid) ans = ans + query(k * 2, x, y);
if (mid < y) ans = ans + query(k * 2 + 1, x, y);
return ans;
}
};
sgt t[25];
int main() {
scanf("%d", &n);
for (int i = 0; i <= 20; i++) t[i].build(1, 1, n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
for (int j = 0; j <= 20; j++)
if (x & (1 << j)) t[j].update(1, i, i);
}
scanf("%d", &q);
while (q--) {
int opt, l, r, x;
long long ans = 0;
scanf("%d", &opt);
if (opt == 1) {
scanf("%d%d", &l, &r);
for (int j = 0; j <= 20; j++)
ans = ans + t[j].query(1, l, r) * (1ll << j);
printf("%lld\n", ans);
} else if (opt == 2) {
scanf("%d%d%d", &l, &r, &x);
for (int j = 0; j <= 20; j++)
if (x & (1 << j)) t[j].update(1, l, r);
}
}
}
| 11 | CPP |
a, b = map(int, input().split())
print(b - a if b % a else a + b)
| 0 | PYTHON3 |
# 学習用
import bisect
A , B , Q = map(int, input().split())
INF = 10 ** 18
Sa = [-INF] + [int(input()) for s in range(A)] + [INF]
Tb = [-INF] + [int(input()) for s in range(B)] + [INF]
Xq = [int(input()) for s in range(Q)]
for x in Xq:
b , d = bisect.bisect_right(Sa,x) , bisect.bisect_right(Tb,x)
res = INF
for S in [Sa[b -1] , Sa[b]]:
for T in [Tb[d-1], Tb[d]]:
d1 , d2 = abs(S-x) + abs(T -S) , abs(T-x)+abs(S-T)
res = min(res , d1 , d2)
print(res) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
const int N = 303;
bool state[N][N][N];
int ways[N][N][N];
int main() {
ios_base::sync_with_stdio(false);
string s;
cin >> s;
int n = s.size();
state[n][0][0] = true;
vector <bool> isZero(n), isOne(n);
for (int i = 0; i < n; i++) {
isZero[i] = s[i] == '0';
isOne[i] = !isZero[i];
}
for (int suffLen = n; suffLen >= 0; suffLen--) {
for (int zeros = n; zeros >= 0; zeros--) for (int ones = n; ones >= 0; ones--) {
if (state[suffLen][zeros][ones]) {
int p1 = n - suffLen;
int p2 = p1 + 1;
if (suffLen >= 2) {
for (int p : {p1, p2}) {
state[suffLen - 2][zeros + isZero[p]][ones + isOne[p]] = true;
}
}
if (suffLen >= 1) {
if (zeros >= 1) {
state[suffLen - 1][zeros][ones] = true;
state[suffLen - 1][zeros - 1 + isZero[p1]][ones + isOne[p1]] = true;
}
if (ones >= 1) {
state[suffLen - 1][zeros][ones] = true;
state[suffLen - 1][zeros + isZero[p1]][ones - 1 + isOne[p1]] = true;
}
}
if (zeros >= 2) state[suffLen][zeros - 2][ones] = true;
if (ones >= 2) state[suffLen][zeros][ones - 2] = true;
if (zeros >= 1 && ones >= 1) state[suffLen][zeros - 1][ones - 1] = true;
}
}
}
vector <int> suffZeros(n + 1, 0), suffOnes(n + 1, 0);
for (int i = 1; i <= n; i++) {
suffZeros[i] = suffZeros[i - 1] + isZero[n - i];
suffOnes[i] = suffOnes[i - 1] + isOne[n - i];
}
map <pair<int,int>,tuple<int,int,int>> minLenState;
for (int suffLen = 0; suffLen <= n; suffLen++) {
for (int zeros = 0; zeros <= n; zeros++) for (int ones = 0; ones <= n; ones++) {
if (state[suffLen][zeros][ones]) {
int zerosTotal = zeros + suffZeros[suffLen];
int onesTotal = ones + suffOnes[suffLen];
pair <int,int> p = {zerosTotal, onesTotal};
if (!minLenState.count(p)) {
minLenState[p] = tuple <int,int,int> {suffLen, zeros, ones};
}
}
}
}
ways[0][0][0] = 1;
for (int suffLen = 0; suffLen <= n; suffLen++) {
for (int zeros = 0; zeros <= n; zeros++) for (int ones = 0; ones <= n; ones++) {
if (suffLen == 0) {
if (zeros >= 1) {
ways[suffLen][zeros][ones] += ways[suffLen][zeros - 1][ones];
}
if (ones >= 1) {
ways[suffLen][zeros][ones] += ways[suffLen][zeros][ones - 1];
}
ways[suffLen][zeros][ones] %= MOD;
} else {
int last = isOne[n - suffLen];
ways[suffLen][zeros][ones] = ways[suffLen-1][zeros][ones];
if (last == 0) {
if (ones >= 1) {
ways[suffLen][zeros][ones] = (ways[suffLen][zeros][ones] + ways[suffLen][zeros][ones-1]) % MOD;
}
} else {
if (zeros >= 1) {
ways[suffLen][zeros][ones] = (ways[suffLen][zeros][ones] + ways[suffLen][zeros-1][ones]) % MOD;
}
}
}
}
}
int ans = 0;
for (auto &entry : minLenState) {
int suffLen, zeros, ones;
tie(suffLen, zeros, ones) = entry.second;
if (suffLen + zeros + ones == 0) {
continue;
}
ans = (ans + ways[suffLen][zeros][ones]) % MOD;
}
cout << ans;
return 0;
}
| 0 | CPP |
a,b=(int(x) for x in input().split())
minima=min(a,b)
maxima=max(a,b)
ans=maxima-minima
ans//=2
print(f"{minima} {ans}")
| 7 | PYTHON3 |
a,b,t=map(int,input().split())
t//=a
print(b*t) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using li = long long;
using ld = long double;
void solve(bool);
signed main() {
cin.sync_with_stdio(false);
cin.tie(nullptr);
solve(true);
return 0;
}
vector<vector<li>> ed;
vector<vector<li>> e;
vector<li> depth;
vector<li> parent;
void dfs(li v, li p = -1) {
for (li u : ed[v]) {
if (u == p) continue;
depth[u] = depth[v] + 1;
parent[u] = v;
e[v].push_back(u);
dfs(u, v);
}
}
const li MOD = 1e9 + 7;
void add(li& to, li x) {
to += x;
if (to >= MOD) {
to -= MOD;
}
}
struct maxcalc {
vector<pair<li, li>> pushTo, popFrom;
li mx(vector<pair<li, li>>& vec) {
return vec.empty() ? 0 : vec.back().second;
}
void push(vector<pair<li, li>>& to, li x) {
li y = max(x, mx(to));
to.emplace_back(x, y);
}
void push(li x) { push(pushTo, x); }
void pop() {
if (popFrom.empty()) {
while (!pushTo.empty()) {
li x = pushTo.back().first;
pushTo.pop_back();
push(popFrom, x);
}
}
assert(!popFrom.empty());
popFrom.pop_back();
}
li get() { return max(mx(pushTo), mx(popFrom)); }
};
struct sufmax {
vector<pair<li, li>> nums;
li value = 0;
void doAdd(li x, li cnt) {
while (!nums.empty() && nums.back().first < x) {
cnt += nums.back().second;
add(value, MOD - (nums.back().second * nums.back().first) % MOD);
nums.pop_back();
}
nums.emplace_back(x, cnt);
add(value, x * cnt % MOD);
}
};
li z(vector<li> a, li k) {
li n = a.size();
if (n < k) {
return 0;
}
li ans = 0;
vector<li> b;
for (li i = 0; i + k - 1 < n; ++i) {
li mx = 0;
for (li j = i; j < i + k; ++j) {
mx = max(mx, a[j]);
}
ans += mx;
b.push_back(mx);
}
return ans + z(b, k);
}
void solve(bool __attribute__((unused)) read) {
li n, k;
if (read) {
cin >> n >> k;
} else {
n = rand() % 10 + 2;
k = min<li>(n, rand() % 10 + 2);
}
--k;
vector<li> a(n);
for (li i = 0; i < n; ++i) {
if (read) {
cin >> a[i];
} else {
a[i] = rand() % 10 + 1;
}
}
vector<maxcalc> maxcalcs(n / k + 1);
for (li i = 0; i < n; ++i) {
maxcalcs[i / k].push(a[i]);
}
li answer = 0;
for (li start = 0; start < k; ++start) {
sufmax s;
li last = start;
for (li i = start; i < n; i += k) {
last = max(last, i);
}
for (li i = last; i >= start; i -= k) {
if (i + k - 1 >= n) {
continue;
}
s.doAdd(maxcalcs[i / k].get(), 1);
if (i > 0) {
s.doAdd(a[i - 1], 0);
add(answer, s.value);
}
}
for (li t = start; t < n; t += k) {
maxcalcs[t / k].pop();
if (t + k < n) {
maxcalcs[t / k].push(a[t + k]);
}
}
}
cout << answer << endl;
}
| 12 | CPP |
n = int(input())
x = [int(a) for a in input().split()]
t = 0
for i in x:
t += i/100 * 1/n
print(t * 100)
| 8 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int tmp=0,ans=0;
string s;
cin >> s;
for(int i=0;i<s.size();i++){
if(s[i]=='A'||s[i]=='C'||s[i]=='G'||s[i]=='T'){tmp++;if(tmp>ans)ans=tmp;}
else tmp=0;
}
cout << ans << endl;
return 0;
} | 0 | CPP |
import math
n,h=[int(x) for x in input().split(' ')]
for i in range(n-1):
print(math.sqrt((i+1)/(n))*h,end=" ")
print()
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sqr(T x) {
return x * x;
}
template <class T>
string const toString(T const &x) {
return (ostringstream() << x).str();
}
int main() {
int n;
cin >> n;
string s;
cin >> s;
int res = 0;
map<char, int> cnt;
for (int i = 0; i < s.size(); i += 2) {
++cnt[s[i]];
int const x = --cnt[tolower(s[i + 1])];
if (x < 0) {
++res;
++cnt[tolower(s[i + 1])];
}
}
cout << res << endl;
return 0;
}
| 7 | CPP |
# map(int, input().split())
# list(map(int, input().split()))
# for _ in range(int(input())):
for _ in range(int(input())):
n,s = map(int, input().split())
a = list(map(int, input().split()))
c = [a[i] for i in range(n)]
skip = False
ans = 0
for i in range(1,n):
c[i] += c[i-1]
if a[ans] < a[i]:
ans = i
if c[i] > s:
skip = True
break
if (skip):
print(ans+1)
else:
print(0) | 8 | PYTHON3 |
t = int(input())
for q in range(t):
n = int(input())
l = list(map(int, input().split()))
odd = 0
even = 0
for i in l:
if i % 2 == 0:
even += 1
else:
odd += 1
if odd % 2 == 1:
l.sort()
res = "NO"
for i in range(1, len(l)):
if l[i] - l[i - 1] == 1:
res = "YES"
break
print(res)
else:
print("YES")
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> h[1001];
int32_t main() {
long long n, m, nr = 2;
cin >> n >> m;
for (long long i = 0; i < n; i++) cin >> h[i].first >> h[i].second;
sort(h, h + n);
long long ans = 2;
for (long long i = 1; i < n; i++) {
long long d =
2 * h[i].first - h[i].second - 2 * h[i - 1].first - h[i - 1].second;
if (2 * m == d)
ans++;
else if (2 * m < d)
ans += 2;
}
cout << ans << '\n';
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
cin >> a;
int n = a.length(), l, flag = 0;
for (int i = n; i > 0; i--) {
set<string> s;
l = 0;
for (int j = 0; j + i <= n; j++) {
s.insert(a.substr(j, i));
l++;
}
if (s.size() < l) {
printf("%d", i);
flag = 1;
break;
}
s.clear();
}
if (!flag) printf("0");
}
| 7 | CPP |
n,k,l,c,d,p,nl,np=map(int,input().split(" "))
drinks=(k*l)//nl
slices=(c*d)
salt=p//np
x=(min(drinks,slices,salt))
x=x//n
print(x) | 7 | PYTHON3 |
t=int(input())
s=[]
for hhh in range(0,t):
n=int(input())
a1=n-n//2
a2=n-1
m=a2-a1
if n%2==0:
s.append(m)
else:
s.append(m+1)
for i in s:
print(i)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (auto i = begin(v); i != end(v); i++)
os << *i << (i == end(v) - 1 ? "" : " ");
return os;
}
template <class T>
istream& operator>>(istream& is, vector<T>& v) {
for (auto i = begin(v); i != end(v); i++) is >> *i;
return is;
}
vector<vector<int>> g;
vector<int> visited;
vector<int> bad_parents;
bool total_stop = false;
int full_bt_depth(int i) {
visited[i] = true;
vector<int> sizes;
for (int u : g[i]) {
if (visited[u]) continue;
sizes.push_back(full_bt_depth(u));
}
if (sizes.size() == 0) return 1;
if (sizes.size() == 1) {
if (sizes[0] != 1) total_stop = true;
bad_parents.push_back(i);
return -1;
}
if (sizes.size() == 2) {
if (sizes[0] == sizes[1] && sizes[0] != -1) {
return sizes[0] + 1;
}
if (sizes[0] == -1 && sizes[1] == -1) total_stop = true;
return -1;
}
if (sizes.size() == 3) {
sort((sizes).begin(), (sizes).end());
if (sizes[0] == sizes[1] && (sizes[1] + 1) == sizes[2]) {
bad_parents.push_back(i);
return -1;
}
}
total_stop = true;
return -1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
if (n == 2) {
cout << "2\n 1 2";
return 0;
}
int n_vtx = (1 << n) - 1;
g.resize(n_vtx);
visited.resize(n_vtx);
int first_a = -1, first_b = -1;
for (int i = 0; i < (n_vtx - 2); i++) {
int a, b;
cin >> a >> b;
if (first_a == -1) first_a = a;
if (first_b == -1) first_b = b;
a--, b--;
g[a].push_back(b);
g[b].push_back(a);
}
queue<int> leaves;
for (int i = 0; i < n_vtx; i++) {
if (g[i].size() == 1) {
leaves.push(i);
visited[i] = true;
}
}
vector<int> last_row;
while (leaves.size() > 0) {
int sz = leaves.size();
last_row.clear();
while (sz-- > 0) {
int q = leaves.front();
leaves.pop();
last_row.push_back(q);
for (int u : g[q]) {
visited[u]++;
if (visited[u] + 1 == g[u].size()) {
leaves.push(u);
}
}
}
}
for (int x : last_row) {
visited.assign(visited.size(), 0);
full_bt_depth(x);
}
if (total_stop || bad_parents.size() == 0) {
cout << 0;
return 0;
} else {
sort((bad_parents).begin(), (bad_parents).end());
cout << bad_parents.size() << "\n";
for (int u : bad_parents) cout << u + 1 << " ";
}
return 0;
}
| 12 | CPP |
import sys
from functools import reduce
from collections import Counter
import time
import datetime
from math import sqrt,gcd
# def time_t():
# print("Current date and time: " , datetime.datetime.now())
# print("Current year: ", datetime.date.today().strftime("%Y"))
# print("Month of year: ", datetime.date.today().strftime("%B"))
# print("Week number of the year: ", datetime.date.today().strftime("%W"))
# print("Weekday of the week: ", datetime.date.today().strftime("%w"))
# print("Day of year: ", datetime.date.today().strftime("%j"))
# print("Day of the month : ", datetime.date.today().strftime("%d"))
# print("Day of week: ", datetime.date.today().strftime("%A"))
def ip(): return int(sys.stdin.readline())
def sip(): return sys.stdin.readline()
def mip(): return map(int,sys.stdin.readline().split())
def mips(): return map(str,sys.stdin.readline().split())
def lip(): return list(map(int,sys.stdin.readline().split()))
def matip(n,m):
lst=[]
for i in range(n):
arr = lip()
lst.append(arr)
return lst
def factors(n): # find the factors of a number
return list(set(reduce(list.__add__, ([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0))))
def minJumps(arr, n): #to reach from 0 to n-1 in the array in minimum steps
jumps = [0 for i in range(n)]
if (n == 0) or (arr[0] == 0):
return float('inf')
jumps[0] = 0
for i in range(1, n):
jumps[i] = float('inf')
for j in range(i):
if (i <= j + arr[j]) and (jumps[j] != float('inf')):
jumps[i] = min(jumps[i], jumps[j] + 1)
break
return jumps[n-1]
def dic(arr): # converting list into dict of count
return Counter(arr)
def prime(n):
if n<2:
return False
for i in range(2,int(n**(0.5))+1,2):
if n%i==0:
return False
return True
# --------------------------------------------------------- #
# sys.stdin = open('input.txt','r')
# sys.stdout = open('output.txt','w')
# --------------------------------------------------------- #
n = ip()
dick = {}
while n:
n-=1
k = sip()
if k not in dick:
dick[k] = 1
else:
dick[k] += 1
val = 1
for item in dick:
if dick[item]>val:
val = dick[item]
print(val) | 7 | PYTHON3 |
# Description of the problem can be found at http://codeforces.com/problemset/problem/478/B
n, m = map(int, input().split())
x = n - m + 1
r = n % m
a = (m - r) * ((n // m) * (n // m - 1)) // 2 + r * ((n // m + 1) * (n // m)) // 2
print(a, (x * (x - 1)) // 2) | 8 | PYTHON3 |
# 0148A. Insomnia cure
# http://codeforces.com/problemset/problem/148/A
import sys
input = sys.stdin.readline
def main():
*A, d = tuple(map(int, [input().rstrip() for _ in range(5)]))
D = {i for i in range(1, d + 1)}
for i in A:
m = 1
while i * m <= d:
D.discard(i * m)
m += 1
print(d - len(D))
if __name__ == "__main__":
main() | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int a[100011];
vector<int> adj[100011];
int main() {
int n, m, i, j;
long long ans = 0, mn = 0;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> a[i];
if (i && a[i] != a[i - 1]) {
adj[a[i]].push_back(a[i - 1]);
adj[a[i - 1]].push_back(a[i]);
ans += abs(a[i] - a[i - 1]);
}
}
for (i = 1; i <= n; i++) {
sort(adj[i].begin(), adj[i].end());
long long d = 0;
int mid = adj[i].size() / 2;
for (j = 0; j < adj[i].size(); j++) {
d += abs(adj[i][mid] - adj[i][j]) - abs(i - adj[i][j]);
}
mn = min(mn, d);
}
cout << ans + mn << endl;
return 0;
}
| 9 | CPP |
n_k = input().split()
n = int(n_k[0])
k = int(n_k[1])
grades = [int(i) for i in input().split()]
passers = 0
for i in range(n):
if grades[i] >= grades[k-1] and grades[i] > 0:
passers += 1
print(passers) | 7 | PYTHON3 |
'''
INPUT SHORTCUTS
N, K = map(int,input().split())
N ,A,B = map(int,input().split())
string = str(input())
arr = list(map(int,input().split()))
N = int(input())
'''
import random
def main():
t=int(input())
for _ in range(t):
n=int(input())
arr=[]
for _ in range(n):
arr.append(input())
ans=0
for i in range(n):
if arr[i] in arr[i+1:]:
ans+=1
j=0
while arr[i] in arr[i+1:]+arr[:i]:
arr[i]=arr[i][:3]+str(j)
j+=1
print(ans)
for i in range(n):
print(arr[i])
main() | 8 | PYTHON3 |
from collections import defaultdict
database = defaultdict(int)
t = int(input())
for _ in range(0,t):
s = input()
if s in database.keys():
print(s + str(database[s]))
database[s]+=1
else:
print('OK')
database[s] = 1 | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, s = 0, d = 0;
cin >> n;
bool six = true;
while (n != 1) {
if (n % 2 == 0) {
n /= 2;
d++;
} else if (n % 3 == 0) {
n /= 3;
s++;
} else if (n % 3 != 0 && n % 2 != 0) {
six = false;
break;
}
}
if (s >= d && six)
cout << (2 * s) - d << endl;
else
cout << -1 << endl;
}
}
| 8 | CPP |
ans = 1
n = int(input())
for i in range(1, n + 1):
ans *= i
for j in range(2, n // 2 + 1):
ans //= j
ans //= j
ans //= 2
for i in range(1, n // 2):
ans *= i
ans *= i
print(ans)
| 11 | PYTHON3 |
t=int(input())
while t>0:
t-=1
r,g,b,w=map(int,input().split())
if r%2==0 and g%2==0 and b%2==0 and w%2==0:
print("Yes")
elif (r%2!=0 and g%2==0 and b%2==0 and w%2==0)or (r%2==0 and g%2!=0 and b%2==0 and w%2==0)or (r%2==0 and g%2==0 and b%2!=0 and w%2==0) or (r%2==0 and g%2==0 and b%2==0 and w%2!=0):
print("Yes")
elif r>0 and g>0 and b>0:
if ((w+3)%2==0 and (g-1)%2==0 and (b-1)%2==0 and (r-1)%2==0)or ((w+3)%2!=0 and (g-1)%2==0 and (b-1)%2==0 and (r-1)%2==0)or ((w+3)%2==0 and (g-1)%2!=0 and (b-1)%2==0 and (r-1)%2==0)or ((w+3)%2==0 and (g-1)%2==0 and (b-1)%2!=0 and (r-1)%2==0)or ((w+3)%2==0 and (g-1)%2==0 and (b-1)%2==0 and (r-1)%2!=0):
print("Yes")
elif r>1 and g>1 and b>1:
if ((w+6)%2==0 and (g-2)%2==0 and (b-2)%2==0 and (r-2)%2==0) or ((w+6)%2!=0 and (g-2)%2==0 and (b-2)%2==0 and (r-2)%2==0) or ((w+6)%2==0 and (g-2)%2!=0 and (b-2)%2==0 and (r-2)%2==0) or ((w+6)%2==0 and (g-2)%2==0 and (b-2)%2!=0 and (r-2)%2==0) or ((w+6)%2==0 and (g-2)%2==0 and (b-2)%2==0 and (r-2)%2!=0) :
print("Yes")
else:
print("No")
else:
print("No")
else:
print("No")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int M = 350;
const int MAX = M * M;
int n, m, q;
int to[MAX][15][2];
char belt[MAX][15];
int a, b;
pair<int, int> dfs(int x, int y, int c, int d) {
if (c < a || c > b || d < 1 || d > m) return pair<int, int>(c, d);
if (to[c][d][0] != -2) return pair<int, int>(to[c][d][0], to[c][d][1]);
int c1 = c;
int d1 = d;
if (belt[c][d] == '^')
--c1;
else if (belt[c][d] == '>')
++d1;
else
--d1;
if (c1 == x && d1 == y) return pair<int, int>(-1, -1);
pair<int, int> t = dfs(c, d, c1, d1);
to[c][d][0] = t.first;
to[c][d][1] = t.second;
return t;
}
void update(int a, int b) {
for (int i = b; i >= a; --i)
for (int j = 1; j <= m; ++j) {
to[i][j][0] = to[i][j][1] = -2;
}
for (int i = b; i >= a; --i)
for (int j = 1; j <= m; ++j) {
pair<int, int> t = dfs(-1, -1, i, j);
to[i][j][0] = t.first;
to[i][j][1] = t.second;
}
}
void find(int a, int b) {
for (int i = 0;; ++i) {
if (a == -1) break;
if (to[a][b][0] == a && to[a][b][1] == b) break;
int a1 = to[a][b][0];
int b1 = to[a][b][1];
a = a1;
b = b1;
}
printf("%d %d\n", a, b);
}
int main() {
cin >> n >> m >> q;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) cin >> belt[i][j];
for (int i = 1; i <= n; ++i) {
to[i][0][0] = i;
to[i][0][1] = 0;
to[i][m + 1][0] = i;
to[i][m + 1][1] = m + 1;
}
for (int i = 1; i <= m; ++i) {
to[0][i][0] = 0;
to[0][i][1] = i;
}
for (int i = 1; i <= n; i += M) {
a = i;
b = i + M - 1;
b = min(n, b);
update(a, b);
}
for (int i = 0; i < q; ++i) {
char x;
cin >> x;
if (x == 'A') {
cin >> a >> b;
find(a, b);
} else {
int y, z;
cin >> y >> z;
cin >> x;
belt[y][z] = x;
a = M * ((y - 1) / M) + 1;
b = min(M * ((y - 1) / M) + M, n);
update(a, b);
}
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
struct point {
double x, y;
point(double _x = 0, double _y = 0) : x(_x), y(_y) {}
void read() { scanf("%lf%lf", &x, &y); }
};
point polygon[30];
int sign(double x) {
if (fabs(x) < eps) return 0;
return (x > 0) ? 1 : -1;
}
double cross(const point &a, const point &b, const point &c, const point &d) {
return (b.x - a.x) * (d.y - c.y) - (b.y - a.y) * (d.x - c.x);
}
double dist(const point &a, const point &b) {
return hypot(a.x - b.x, a.y - b.y);
}
pair<point, bool> getIntersection(const point &a, const point &b,
const point &c, const point &d) {
if (sign(cross(a, b, c, d)) == 0) return make_pair(point(0, 0), false);
double a1 = b.x - a.x, b1 = c.x - d.x, c1 = c.x - a.x;
double a2 = b.y - a.y, b2 = c.y - d.y, c2 = c.y - a.y;
double tmp = a1 * b2 - a2 * b1;
double x = (c1 * b2 - c2 * b1) / tmp;
double y = (c2 * a1 - c1 * a2) / tmp;
if (sign(x) >= 0 && sign(x - 1) < 0 && sign(y) >= 0 && sign(y - 1) < 0) {
return make_pair(point(a.x + x * (b.x - a.x), a.y + x * (b.y - a.y)), true);
} else {
return make_pair(point(0, 0), false);
}
}
int main() {
point start, end;
start.read();
end.read();
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) polygon[i].read();
int flag = 0;
point a, b;
int la, lb;
for (int i = 0; i < n; i++) {
pair<point, bool> tmp =
getIntersection(start, end, polygon[i], polygon[(i + 1) % n]);
if (tmp.second) {
if (flag == 0) {
a = tmp.first;
la = i;
} else {
b = tmp.first;
lb = i;
}
flag++;
}
}
if (flag < 2) {
printf("%.10lf\n", dist(start, end));
return 0;
}
if (sign(dist(start, a) - dist(start, b)) > 0) {
swap(a, b);
swap(la, lb);
}
double ans = dist(start, a) + dist(a, b) * 2 + dist(b, end);
double s1 = dist(start, a) + dist(a, polygon[(la + 1) % n]);
for (int i = (la + 1) % n; i != lb; i = (i + 1) % n)
s1 += dist(polygon[i], polygon[(i + 1) % n]);
s1 += dist(polygon[lb], b) + dist(b, end);
ans = min(ans, s1);
double s2 = dist(start, a) + dist(a, polygon[la]);
for (int i = la; i != (lb + 1) % n; i = (i + n - 1) % n)
s2 += dist(polygon[i], polygon[(i + n - 1) % n]);
s2 += dist(polygon[(lb + 1) % n], b) + dist(b, end);
ans = min(ans, s2);
printf("%.10lf\n", ans);
return 0;
}
| 11 | CPP |
import sys
from collections import deque
from math import gcd
for _ in range(int(input())):
n = int(input())
s = input()
A = [[1,1] for _ in range(n+1)]
# A[i][p] = max city reachable left from city-i, parity = p
# A[i][0] = 1+A[i-1][1] if s[i-1]=="R" else 0
# A[i][1] = 1+A[i-1][0] if s[i-1]=="L" else 0
for i in range(1,n+1):
if s[i-1] == "L":
A[i][0] = 1+A[i-1][1]
else:
A[i][1] = 1+A[i-1][0]
B = [[1,1] for _ in range(n+1)]
for i in range(n-1,-1,-1):
if s[i] == "R":
B[i][0] = 1+B[i+1][1]
else:
B[i][1] = 1+B[i+1][0]
ans = [a[0]+b[0]-1 for a,b in zip(A,B)]
print(*ans)
| 10 | PYTHON3 |
#include <iostream>
using namespace std;
int main(){
int i,m,f,r;
char x;
for(i=0;i<50;i++)
{
cin>>m>>f>>r;
if(m==-1 && f==-1 && r==-1)break;
if(m==-1 || f==-1 ||m+f<30){
x='F';
}
else if(m+f>=80)x='A';
else if(m+f>=65 && m+f<80)x='B';
else if(m+f>=50 && m+f<65 || r>=50)x='C';
else if(m+f>=30 && m+f<50)x='D';
cout<<x<<endl;
}
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, k, ans;
int x1, y1, x2, y2;
cin >> a >> b >> c >> d;
k = a % b;
a = (a - 1) / b;
x1 = c % b;
y1 = (c - 1) / b;
x2 = d % b;
y2 = (d - 1) / b;
if (b == 1)
ans = 1;
else {
if (x1 == 1) {
if (y1 == y2 || x2 == 0 || (y2 == a && x2 == k))
ans = 1;
else
ans = 2;
} else {
if (y1 == y2)
ans = 1;
else if (x2 == 0 || (y2 == a && x2 == k) || (y2 - y1 == 1))
ans = 2;
else
ans = 3;
}
}
if (ans == 3)
if ((x1 == 0 && x2 == b - 1) || (x1 != 0 && x2 + 1 == x1)) ans = 2;
cout << ans;
return 0;
}
| 7 | CPP |
t = int(input())
for _ in range(t):
n,m = list(map(int,input().split(' ')))
matrix = []
for i in range(n):
matrix.append(list(map(int,input().split(' '))))
f = 1
for i in range(n):
for j in range(m):
if (i == 0 or i == n-1) and (j== 0 or j == m-1):
if matrix[i][j] > 2:
f = 0
break
else:
matrix[i][j] = 2
elif (0<i<n-1 and (j ==0 or j == m-1)) or (0<j<m-1 and (i==0 or i==n-1)):
if matrix[i][j] > 3:
f = 0
break
else:
matrix[i][j] = 3
else:
if matrix[i][j] > 4:
f = 0
break
else:
matrix[i][j] = 4
if f == 0:break
if f != 0:
print('YES')
for i in range(n):
for j in range(m):
print(matrix[i][j],end=' ')
print('')
else:
print('NO') | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
map<string, int> m;
for(int i=0; i<n; i++) {
cin >> s;
m[s]++;
}
int num = 0;
for(auto p : m) num = max(num, p.second);
for(auto p : m) if(p.second == num) cout << p.first << endl;
return 0;
} | 0 | CPP |
t=int(input())
while t>0:
t-=1
n=int(input())
k=n//2;
k=0;
sum=0
for i in range(n,0,-1):
sum=sum+k*(k+1)//2+i*(i-1)//2
#print(sum)
k+=1
print(sum) | 9 | PYTHON3 |
#include <iostream>
#include <algorithm>
#include <queue>
#include <cctype>
using namespace std;
#define SIZE_MAX 20
#define N_MAX 11
#define INF 99999999
int W, H;
char M[SIZE_MAX][SIZE_MAX];
int N;
int D[N_MAX][N_MAX];
struct A {
int x, y, cost;
A(int x, int y, int cost) : x(x), y(y), cost(cost) {}
};
void bfs(int n, int sx, int sy) {
const int dx[4] = {1,0,-1,0};
const int dy[4] = {0,1,0,-1};
bool vsted[SIZE_MAX][SIZE_MAX];
queue<A> que;
A a(sx, sy, 0);
que.push(a);
for(int i = 0; i < H; ++i) {
fill(vsted[i], vsted[i] + W, false);
}
vsted[sy][sx] = true;
while(!que.empty()) {
a = que.front(); que.pop();
if(isupper(M[a.y][a.x])) {
int t = M[a.y][a.x] - 'A';
if(D[n][t] == INF) {
D[n][t] = D[t][n] = a.cost;
}
}
for(int i = 0; i < 4; ++i) {
int nx = a.x + dx[i];
int ny = a.y + dy[i];
if(nx < 0 || nx >= W) continue;
if(ny < 0 || ny >= H) continue;
if(M[ny][nx] == 'x') continue;
if(vsted[ny][nx]) continue;
vsted[ny][nx] = true;
que.push(A(nx, ny, a.cost + 1));
}
}
}
void show() {
for(int i = 0; i < N; ++i) {
for(int j = 0; j < N; ++j) {
if(D[i][j] == INF) cout << "IF" << " ";
else cout << D[i][j] << " ";
}
cout << endl;
}
}
void makeD(int rx, int ry) {
for(int i = 0; i < N; ++i) {
for(int j = 0; j < N; ++j) {
D[i][j] = i == j ? 0 : INF;
}
}
bfs(0, rx, ry);
for(int y = 0; y < H; ++y) {
for(int x = 0; x < W; ++x) {
if(isupper(M[y][x])) bfs(M[y][x]-'A', x, y);
}
}
}
void solve(int rx, int ry) {
makeD(rx, ry);
int dp[1 << N_MAX][N_MAX];
for(int i = 0; i < 1<<N_MAX; ++i) {
fill(dp[i], dp[i] + N_MAX, INF);
}
dp[1 << 0][0] = 0;
for(int s = 1 << 0 + 1; s < (1 << N); ++s) {
}
}
int calcCost(int v[]) {
int now = 0;
int cost = 0;
for(int i = 0; i < N-1; ++i) {
cost += D[now][v[i]];
now = v[i];
}
return cost;
}
void solve2(int rx, int ry) {
makeD(rx, ry);
int v[N_MAX];
for(int i = 1; i < N; ++i) {
v[i-1] = i;
}
int ans = INF;
do {
ans = min(ans, calcCost(v));
} while(next_permutation(v, v + (N-1)));
if(ans == INF) ans = -1;
cout << ans << endl;
}
int main() {
while((cin >> W >> H) && (W || H)) {
N = 1;
int rx, ry;
for(int i = 0; i < H; ++i) {
for(int j = 0; j < W; ++j) {
cin >> M[i][j];
if(M[i][j] == 'o') { rx = j; ry = i; }
if(M[i][j] == '*') M[i][j] = 'A' + N++;
}
}
solve2(rx, ry);
}
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
long long r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long fpow(long long n, long long k, int p = (int)1e9 + 7) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
const int MOD = (int)1e9 + 7;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = 2 * acos((long double)0);
const int MAXN = 600010;
char T[MAXN];
int nlen;
int RA[MAXN], tempRA[MAXN];
int SA[MAXN], tempSA[MAXN];
int c[MAXN];
int Phi[MAXN], PLCP[MAXN];
int LCP[MAXN];
void countingsort(int k) {
int sum = 0, maxi = max(300, nlen);
memset(c, 0, sizeof(c));
for (int i = 0; i < nlen; i++) c[i + k < nlen ? RA[i + k] : 0]++;
for (int i = 0; i < maxi; i++) {
int t = c[i];
c[i] = sum;
sum += t;
}
for (int i = 0; i < nlen; i++)
tempSA[c[SA[i] + k < nlen ? RA[SA[i] + k] : 0]++] = SA[i];
for (int i = 0; i < nlen; i++) SA[i] = tempSA[i];
}
void constructSA() {
int r;
for (int i = 0; i < nlen; i++) RA[i] = T[i];
for (int i = 0; i < nlen; i++) SA[i] = i;
for (int k = 1; k < nlen; k <<= 1) {
countingsort(k);
countingsort(0);
tempSA[SA[0]] = r = 0;
for (int i = 1; i < nlen; i++)
tempRA[SA[i]] =
(RA[SA[i]] == RA[SA[i - 1]] && RA[SA[i] + k] == RA[SA[i - 1] + k])
? r
: ++r;
for (int i = 0; i < nlen; i++) RA[i] = tempRA[i];
if (RA[SA[nlen - 1]] == nlen - 1) break;
}
}
void computeLCP() {
int L = 0;
Phi[SA[0]] = -1;
for (int i = 1; i < nlen; i++) Phi[SA[i]] = SA[i - 1];
for (int i = 0; i < nlen; i++) {
if (Phi[i] == -1) {
PLCP[i] = 0;
continue;
}
while (T[i + L] == T[Phi[i] + L] && T[i + L] != '$') L++;
PLCP[i] = L;
L = max(L - 1, 0);
}
for (int i = 0; i < nlen; i++) LCP[i] = PLCP[SA[i]];
}
const int maxn = 600010;
int n;
char s[maxn];
int cost[maxn];
int pos[maxn];
int COST[maxn];
int maxlen[maxn];
int MAXLEN[maxn];
long long SUMCOST[maxn];
int l[maxn];
int r[maxn];
long long calc(int l, int r) {
if (!l) return SUMCOST[r];
return SUMCOST[r] - SUMCOST[l - 1];
}
void solve() {
memset(pos, -1, sizeof(pos));
scanf("%d", &n);
for (int i = (0); i < (n); i++) {
scanf("%s", s);
int d = strlen(s);
for (int j = (0); j < (d); j++) {
pos[nlen] = i;
maxlen[nlen] = d - j;
T[nlen++] = s[j];
}
T[nlen++] = '$';
}
for (int i = (0); i < (n); i++) scanf("%d", cost + i);
constructSA();
computeLCP();
for (int i = (0); i < (nlen); i++) {
if (~pos[i]) {
COST[RA[i]] = cost[pos[i]];
MAXLEN[RA[i]] = maxlen[i];
}
}
for (int i = (0); i < (nlen); i++) {
if (!i)
SUMCOST[i] = COST[i];
else
SUMCOST[i] = SUMCOST[i - 1] + COST[i];
}
for (int i = (0); i < (nlen); i++) l[i] = r[i] = i;
for (int i = (1); i < (nlen); i++) {
int cur = i;
while (cur && LCP[i] <= LCP[cur - 1]) cur = l[cur - 1];
l[i] = cur;
}
for (int i = (nlen - 1) - 1; i >= (0); i--) {
int cur = i;
while (cur < nlen - 1 && LCP[i] <= LCP[cur + 1]) cur = r[cur + 1];
r[i] = cur;
}
long long ans = 0;
for (int i = (1); i < (nlen); i++) {
ans = max(ans, LCP[i] * calc(l[i] - 1, r[i]));
if (MAXLEN[i] > LCP[i] && (i == nlen - 1 || MAXLEN[i] > LCP[i + 1]))
ans = max(ans, MAXLEN[i] * calc(i, i));
}
printf("%I64d", ans);
}
int main() {
solve();
return 0;
}
| 12 | CPP |
def main():
t = int(input())
for _ in range(t):
n, k = list(map(int, input().strip().split()))
a = list(map(int, input().strip().split()))
maxx = max(a)
for i in range(n): a[i] = maxx - a[i]
k -= 1
if k&1:
maxx = max(a)
for i in range(n): a[i] = maxx - a[i]
print(" ".join(list(map(str, a))))
if __name__ == "__main__": main()
| 8 | PYTHON3 |
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
int H, W;
std::vector<std::string> S;
void count_area(long* n, int x, int y, char ch)
{
S[y][x] = ' ';
++n[(x+y)%2];
if (x > 0 && S[y][x-1] == ch) {
count_area(n, x-1, y, ch);
}
if (x < W-1 && S[y][x+1] == ch) {
count_area(n, x+1, y, ch);
}
if (y > 0 && S[y-1][x] == ch) {
count_area(n, x, y-1, ch);
}
if (y < H-1 && S[y+1][x] == ch) {
count_area(n, x, y+1, ch);
}
}
int main()
{
std::cin >> H >> W;
S.reserve(H);
for (int i = 0; i < H; ++i) {
std::string s;
std::cin >> s;
S.push_back(s);
}
for (int i = 0; i < H; ++i) {
auto& s = S[i];
for (int j = i%2; j < s.size(); j += 2) {
if (s[j] == '.')
s[j] = '#';
else
s[j] = '.';
}
}
long total = 0;
for (int y = 0; y < H; ++y) {
for (int x = 0; x < W; ++x) {
if (S[y][x] != ' ') {
long n[2] = {0,0};
count_area(n, x, y, S[y][x]);
total += n[0] * n[1];
}
}
}
std::cout << total << "\n";
}
| 0 | CPP |
a = input().lower()
b = input().lower()
if a<b:
print("-1")
elif a>b:
print("1")
else:
print(0) | 7 | PYTHON3 |
n, m = input().split()
n = int(n)
m = int(m)
a = []
b = []
c = []
ans = 0
for i in range(n):
x, y = input().split()
a.append(int(x))
b.append(int(y))
c.append(int(x)-int(y))
if sum(b) > m:
print(-1)
else:
tmp = sum(a)
c.sort()
c = c[::-1]
while tmp > m:
tmp += -c[ans]
ans += 1
print(ans)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300010;
int sufp[N], freq[N][2];
int mi = 0, ma = 0, par = 0;
void add(int x) {
if (x >= mi and x <= ma) {
if (x % 2 == par)
mi = 0;
else
mi = 1;
} else if (x > ma) {
mi = x - ma;
} else {
mi = mi - x;
}
if (x % 2) par = 1 - par;
ma += x;
}
void reset() { mi = ma = par = 0; }
int main() {
int n;
scanf("%d", &n);
vector<int> v, p;
for (int i = 0; i < n; i++) {
long long x;
scanf("%lld", &x);
v.push_back(__builtin_popcountll(x));
p.push_back(v.back() % 2);
}
for (int i = n - 1; i >= 0; i--) {
sufp[i] = p[i];
if (i + 1 < n) sufp[i] ^= sufp[i + 1];
}
for (int i = 0; i < n; i++) {
freq[i][0] += sufp[i] == 0;
freq[i][1] += sufp[i] == 1;
if (i) {
freq[i][0] += freq[i - 1][0];
freq[i][1] += freq[i - 1][1];
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
int pos = i;
reset();
while (pos >= 0 and (mi > 1 or ma < 60)) {
add(v[pos]);
if (mi == 0) ans++;
pos--;
}
if (pos < 0) continue;
int base = sufp[pos + 1];
ans += freq[pos][par ^ base];
}
printf("%lld\n", ans);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1 << 17;
vector<int> adj[maxn];
int maxlog, parent[maxn][18], qnt[maxn], level[maxn], a, b, aux, N, M;
bool mark[maxn];
inline void sparse() {
for (int i = 1; i <= maxlog; i++) {
for (int j = 1; j <= N; j++) {
if (parent[j][i - 1] != -1) {
parent[j][i] = parent[parent[j][i - 1]][i - 1];
}
}
}
}
inline int LCA(int u, int v) {
if (level[v] < level[u]) swap(u, v);
int diff = level[v] - level[u];
for (int i = 0; i < maxlog; i++) {
if ((diff >> i) & 1) {
v = parent[v][i];
}
}
if (u == v) return u;
for (int i = maxlog; i >= 0; i--) {
if (parent[u][i] != parent[v][i]) {
u = parent[u][i];
v = parent[v][i];
}
}
return parent[u][0];
}
inline int find(int a, int b, int k) {
int ans = a;
if (level[a] - level[LCA(a, b)] < k) {
k = level[a] + level[b] - 2 * level[LCA(a, b)] - k;
ans = b;
}
for (int i = maxlog; i >= 0; i--) {
if ((1 << i) <= k) {
ans = parent[ans][i];
k -= (1 << i);
}
}
return ans;
}
void DFS(int idx, int p, int d) {
mark[idx] = true;
parent[idx][0] = p;
level[idx] = d;
for (auto& u : adj[idx]) {
if (!mark[u]) {
DFS(u, idx, d + 1);
}
}
}
inline void BFS() {
memset(mark, false, (sizeof(bool)) * (N + 1));
priority_queue<pair<int, int>, vector<pair<int, int> > > fila;
for (int i = 1; i <= N; i++) {
qnt[i] = 1;
if (adj[i].size() == 1) {
fila.push({level[i], i});
mark[i] = true;
}
}
while (!fila.empty()) {
int idx = fila.top().second;
fila.pop();
for (auto& u : adj[idx]) {
if (level[u] < level[idx]) {
qnt[u] += qnt[idx];
if (!mark[u]) {
fila.push({level[u], u});
mark[u] = true;
}
}
}
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
memset(parent, -1, sizeof parent);
cin >> N;
maxlog = log2(N) + 1;
for (int i = 0; i < N - 1; i++) {
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
DFS(1, -1, 0);
sparse();
BFS();
cin >> M;
while (M--) {
cin >> a >> b;
aux = level[a] + level[b] - 2 * level[LCA(a, b)] - 1;
if (aux & 1) {
aux = (aux >> 1) + 1;
if (false) cerr << "Is the " << aux << " element from a to b" << endl;
int lo = find(a, b, aux - 1), mid = find(a, b, aux),
hi = find(a, b, aux + 1);
if (level[lo] > level[hi]) swap(lo, hi);
if (false) cerr << "The middle is: " << mid << endl;
if (false) cerr << "hml: " << lo << ' ' << mid << ' ' << hi << endl;
if (false) cerr << qnt[lo] << ' ' << qnt[mid] << ' ' << qnt[hi] << endl;
if (a == b) {
cout << qnt[1] << endl;
} else if (level[mid] < level[lo] && level[mid] < level[hi]) {
cout << qnt[1] - (qnt[lo] + qnt[hi]) << endl;
} else {
cout << qnt[lo] - (qnt[lo] - qnt[mid]) - qnt[hi] << endl;
}
} else
cout << 0 << endl;
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct Thing {
int a, b, c;
};
struct Planet {
string name;
vector<Thing> things;
};
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<Planet> arr(n);
for (int i = 0; i < n; ++i) {
cin >> arr[i].name;
arr[i].things.resize(m);
for (int j = 0; j < m; ++j)
cin >> arr[i].things[j].a >> arr[i].things[j].b >> arr[i].things[j].c;
}
vector<vector<vector<pair<int, int> > > > other(n);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
other[i].push_back(vector<pair<int, int> >(m));
for (int t = 0; t < m; ++t) {
other[i][j][t].first = arr[j].things[t].b - arr[i].things[t].a;
other[i][j][t].second = min(k, arr[i].things[t].c);
}
sort(other[i][j].begin(), other[i][j].end());
}
}
int cnt = 0;
int trum, temp_cnt;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (i == j) continue;
trum = 0;
temp_cnt = 0;
for (int t = m - 1; t >= 0; --t) {
if (other[i][j][t].first < 0) continue;
if (other[i][j][t].second <= k - trum) {
temp_cnt += other[i][j][t].first * other[i][j][t].second;
trum += other[i][j][t].second;
} else {
temp_cnt += other[i][j][t].first * (k - trum);
break;
}
}
cnt = max(cnt, temp_cnt);
}
}
cout << cnt;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long w, h;
int main(int argc, char *argv[]) {
cin >> w >> h;
++w;
++h;
long long result = 0;
for (int i = 1; 2 * i < w; ++i) {
for (int j = 1; 2 * j < h; ++j) result += (w - 2 * i) * (h - 2 * j);
}
cout << result << endl;
return 0;
}
| 8 | CPP |
n = input()
c = 0
for i in n:
if i == '4' or i == '7':
c += 1
#print(c)
if c == 4 or c == 7:
print('YES')
else:
print('NO')
| 7 | PYTHON3 |
from sys import stdin, stdout
import math
import heapq
import collections
input = stdin.readline
def inputnum():
return(int(input()))
def inputnums():
return(map(int,input().split()))
def inputlist():
return(list(map(int,input().split())))
def inputstring():
return([x for x in input()])
def inputstrings():
return([x for x in input().split()])
def inputstringnum():
return([ord(x)-ord('a') for x in input()])
def inputmatrixchar(rows):
arr2d = [[j for j in input().strip()] for i in range(rows)]
return arr2d
def inputmatrixint(rows):
arr2d = []
for _ in range(rows):
arr2d.append([int(i) for i in input().split()])
return arr2d
t = int(input())
for q in range(t):
x, y, k = inputnums()
a = k*y + k - 1
if a%(x-1)== 0:
a = a//(x-1) + k
else:
a = a//(x-1) + k + 1
print(a) | 7 | PYTHON3 |
Answers = []
for _ in range(int(input())):
N = int(input())
X = sorted(list(map(int, input().split())))
Count = 0
This = 0
Temp = 0
for i in range(N):
This = max(This, X[i])
Temp += 1
if Temp == This:
Count += 1
Temp = 0
Answers.append(str(Count))
print("\n".join(Answers))
# Hope the best for Ravens
# Never give up
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, k = 0, l = 0;
cin >> n;
int ab[n];
for (i = 0; i < n; i++) {
cin >> ab[i];
if (ab[i] == 1)
k++;
else
l++;
}
if (k == 0) {
cout << "0";
return 0;
}
j = min(k, l);
k = k - j;
k = k / 3;
cout << j + k;
}
| 7 | CPP |
f=lambda x:1 if int(x)%2 else 0
n=input()
c=sum(map(f,input().split()))%2
if c:
print("NO")
else:
print("YES") | 0 | PYTHON3 |
n=int(input())
x=list(input().split())
y={}
s=0
for i in range(n):
if x[i]=='0':continue
y[x[i]]=0
print(len(y)) | 7 | PYTHON3 |
def sum_digits(n):
s = 0
while n:
s += n % 10
n //= 10
return s
getI = int(input())
gh = sum_digits(getI)
if gh % 4 == 0:
print(getI)
else:
while (gh % 4 != 0):
getI +=1
gh = sum_digits(getI)
print(getI)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int Q = 5;
const long long K = 10000;
long long F[Q];
map<long long, long long> G[Q];
long long query(long long l, int num, vector<long long> *lst = NULL) {
if (num < 0) return 0;
if (lst == NULL && G[num].count(l)) return G[num][l];
if (lst == NULL && l >= K) return F[num];
long long res = 0;
long long p = l;
for (int i = 1; i <= min(l, K) + 1; ++i) {
p += query(p, num - 1);
if (i != min(l, K) + 1) {
if (lst != NULL) lst->push_back(p);
p++;
}
}
return G[num][l] = p - l;
}
int main() {
F[0] = K;
for (int i = 1; i < Q; ++i) F[i] = F[i - 1] * (K + 1) + K;
long long l = 1;
for (int i = Q - 1; ~i; --i) {
vector<long long> lst;
query(l, i, &lst);
cout << lst.size() << " ";
for (int j = 0; j < lst.size(); ++j) cout << lst[j] << " ";
cout << endl;
int p;
cin >> p;
if (p == -1)
break;
else if (p == 0)
;
else
l = lst[p - 1] + 1;
}
}
| 13 | CPP |
#include <bits/stdc++.h>
int a[100005], b[100005];
int mini(int a, int b) {
if (a < b) {
return a;
}
return b;
}
int main() {
int n, m, i, j, max;
scanf("%d %d", &n, &m);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (i = 0; i < m; i++) {
scanf("%d", &b[i]);
}
max = 0;
if (a[0] < b[0]) {
max = b[0] - a[0];
}
if (a[n - 1] - b[m - 1] > max) {
max = a[n - 1] - b[m - 1];
}
i = 0;
j = 0;
while (a[i] < b[0]) {
i++;
}
j = 0;
while (i < n) {
if (j == m - 1) {
break;
}
if (a[i] >= b[j] && a[i] <= b[j + 1]) {
if (mini(a[i] - b[j], b[j + 1] - a[i]) > max) {
max = mini(a[i] - b[j], b[j + 1] - a[i]);
}
i++;
} else {
j++;
}
}
printf("%d", max);
return 0;
}
| 9 | CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.