solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
const int OUT_LEN = 1000000;
char obuf[OUT_LEN], *ooh = obuf;
inline void print(char c) {
if (ooh == obuf + OUT_LEN) fwrite(obuf, 1, OUT_LEN, stdout), ooh = obuf;
*ooh++ = c;
}
template <class T>
inline void print(T x) {
static int buf[30], cnt;
if (x == 0)
print('0');
else {
if (x < 0) print('-'), x = -x;
for (cnt = 0; x; x /= 10) buf[++cnt] = x % 10 + 48;
while (cnt) print((char)buf[cnt--]);
}
}
inline void flush() { fwrite(obuf, 1, ooh - obuf, stdout); }
const int N = 1 << 15, M = N << 1, P = 998244353;
int n, k, w[M], inv[M];
inline int Pow(long long x, int y = P - 2) {
int ans = 1;
for (; y; y >>= 1, x = x * x % P)
if (y & 1) ans = ans * x % P;
return ans;
}
inline void DFT(vector<int> &f, int n) {
static unsigned long long F[M];
for (int i = 0, j = 0; i < n; ++i) {
F[i] = f[j];
for (int k = n >> 1; (j ^= k) < k; k >>= 1)
;
}
for (int i = 1; i < n; i <<= 1)
for (int j = 0; j < n; j += i << 1)
for (int k = j; k < j + i; ++k) {
int t = F[k + i] * w[i + k - j] % P;
F[k + i] = F[k] + P - t, F[k] += t;
}
for (int i = 0; i < n; ++i) f[i] = F[i] % P;
}
inline void IDFT(vector<int> &f, int n) {
reverse(f.begin() + 1, f.end()), DFT(f, n);
for (int i = 0, I = Pow(n); i < n; ++i) f[i] = (long long)f[i] * I % P;
}
inline int Calc(int x) {
int ans = 1;
while (ans <= x) ans <<= 1;
return ans;
}
inline vector<int> operator*(const vector<int> &x, const vector<int> &y) {
if (!x.size() || !y.size()) return {0};
if ((unsigned long long)x.size() * y.size() <= 1 << 8) {
vector<int> ans(x.size() + y.size() - 1);
for (unsigned i = 0; i < x.size(); ++i)
for (unsigned j = 0; j < y.size(); ++j)
ans[i + j] = (ans[i + j] + (long long)x[i] * y[j]) % P;
return ans;
}
vector<int> a = x, b = y;
int n = Calc(x.size() + y.size() - 2);
a.resize(n), b.resize(n), DFT(a, n), DFT(b, n);
for (int i = 0; i < n; ++i) a[i] = (long long)a[i] * b[i] % P;
IDFT(a, n);
return a.resize(min((int)x.size() + (int)y.size() - 1, k + 1)), a;
}
inline void operator*=(vector<int> &x, const vector<int> &y) { x = x * y; }
inline vector<int> operator+(const vector<int> &x, const vector<int> &y) {
vector<int> ans = x;
if (y.size() > x.size()) ans.resize(y.size());
for (unsigned i = 0; i < y.size(); ++i) (ans[i] += y[i]) %= P;
return ans;
}
inline void operator+=(vector<int> &x, const vector<int> &y) { x = x + y; }
inline vector<int> operator-(const vector<int> &x, const vector<int> &y) {
vector<int> ans = x;
if (y.size() > x.size()) ans.resize(y.size());
for (unsigned i = 0; i < y.size(); ++i) (ans[i] += P - y[i]) %= P;
return ans;
}
inline vector<int> PolyDiv2(const vector<int> &x) {
vector<int> ans(x.size());
for (unsigned i = 0; i < x.size(); ++i)
ans[i] = (x[i] & 1 ? x[i] + P : x[i]) >> 1;
return ans;
}
inline vector<int> Ext(const vector<int> &a, int n) {
if (n <= (int)a.size()) return vector<int>(a.begin(), a.begin() + n);
vector<int> ans = a;
return ans.resize(n), ans;
}
vector<int> PolyInv(const vector<int> &a, int n = -1) {
if (n == -1) n = a.size();
if (n == 1) return {Pow(a[0])};
vector<int> ans = PolyInv(a, (n + 1) / 2), tmp = Ext(a, n);
int m = Calc(n * 2 - 1);
ans.resize(m), tmp.resize(m), DFT(ans, m), DFT(tmp, m);
for (int i = 0; i < m; ++i)
ans[i] = (2 + (long long)(P - tmp[i]) * ans[i]) % P * ans[i] % P;
IDFT(ans, m);
return ans.resize(n), ans;
}
vector<int> PolySqrt(const vector<int> &a, int n = -1) {
if (n == -1) n = a.size();
if (n == 1) return {1};
vector<int> ans = PolySqrt(a, (n + 1) / 2);
return PolyDiv2(Ext(ans + Ext(a, n) * PolyInv(Ext(ans, n)), n));
}
inline vector<int> D(const vector<int> &a) {
vector<int> ans(a.size() - 1);
for (unsigned i = 1; i < a.size(); ++i) ans[i - 1] = (long long)a[i] * i % P;
return ans;
}
inline vector<int> Int(const vector<int> &a) {
vector<int> ans(a.size() + 1);
for (unsigned i = 0; i < a.size(); ++i)
ans[i + 1] = (long long)a[i] * inv[i + 1] % P;
return ans;
}
inline vector<int> PolyLn(const vector<int> &a) {
return Int(Ext(D(a) * PolyInv(a), a.size() - 1));
}
vector<int> PolyExp(const vector<int> &a, int n = -1) {
if (n == -1) n = a.size();
if (n == 1) return {1};
vector<int> ans = PolyExp(a, (n + 1) / 2);
return Ext(ans * (Ext(a, n) - PolyLn(Ext(ans, n)) + vector<int>{1}), n);
}
int main() {
for (int i = 1; i < M; i <<= 1) {
w[i] = 1, w[i + 1] = Pow(3, (P - 1) / i / 2);
for (int j = 2; j < i; ++j)
w[i + j] = (long long)w[i + j - 1] * w[i + 1] % P;
}
inv[1] = 1;
for (int i = 2; i < M; ++i) inv[i] = (long long)(P - P / i) * inv[P % i] % P;
scanf("%d%d", &n, &k);
vector<int> s = {1, 6, 1}, c;
s.resize(k + 1), s = PolySqrt(s);
c = PolyLn(PolyDiv2(vector<int>{1, 1} + s));
for (int &i : c) i = (long long)i * (n + 1) % P;
c = PolyExp(c) * PolyInv(s);
for (int i = 1; i <= k; ++i) (i > n ? print('0') : print(c[i])), print(' ');
return flush(), 0;
}
| 13 | CPP |
def main():
from sys import stdin, stdout
import math
k = int(stdin.readline())
l = int(stdin.readline())
m = int(stdin.readline())
n = int(stdin.readline())
d = int(stdin.readline())
res = 0
for i in range(1, d + 1):
if i % k == 0 or i % l == 0 or i % m == 0 or i % n == 0:
res += 1
stdout.write(str(res))
if __name__ == '__main__':
main()
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, q, j, a[200005], cnt[200005], noq;
list<int> l;
decltype(l.begin()) fex[200005];
int main() {
scanf("%d%d", &n, &q);
for (int i = 0; i < n; ++i) {
scanf("%d", a + i);
l.push_back(a[i]);
if (!cnt[a[i]]) fex[a[i]] = --l.end();
++cnt[a[i]];
}
if ((noq = !cnt[q]) && !cnt[0]) return puts("NO"), 0;
if (*cnt == n) {
puts("YES");
for (int i = 0; i < n; ++i) printf("%d ", q);
return 0;
}
for (int i = q; i >= 1; --i)
if (cnt[i]) {
for (auto it = fex[i]; it != l.end() && (*it == i || !*it);) {
if (*it == i) --cnt[i];
it = l.erase(it);
}
if (cnt[i]) return puts("NO"), 0;
}
puts("YES");
if (noq) *find(a, a + n, 0) = q;
for (int i = 0; i < n; ++i)
if (a[i]) {
for (j = i - 1; ~j && !a[j]; --j) a[j] = a[i];
for (j = i + 1; j < n && !a[j]; ++j) a[j] = a[i];
}
for (int i = 0; i < n; ++i) printf("%d ", a[i]);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int n;
ll a[100005];
ll SUM = 0;
ll basis[60];
int main(){
scanf("%d",&n);
for (int i = 0; i < n; i++){
scanf("%lld",&a[i]);
SUM ^= a[i];
}
ll ans = 0;
for (int i = 0; i < n; i++){
a[i] &= (~SUM);
for (int j = 59; j >= 0; j--){
if ((a[i] & (1ll<<j)) == 0) continue;
if (basis[j] == 0){
basis[j] = a[i];
break;
}
a[i] ^= basis[j];
}
}
for (int i = 59; i >= 0; i--){
if (basis[i] != 0){
if ((ans & (1ll<<i)) == 0){
ans ^= basis[i];
}
}
}
ans <<= 1;
ans += SUM;
printf("%lld",ans);
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int cnt[1005];
int arr[1005];
int main() {
int m, t, r, a, ans = 0;
cin >> m >> t >> r;
for (int i = 0; i < m; ++i) cin >> arr[i];
for (int i = 0; i < m; ++i) {
int k = 0;
for (int j = arr[i] - 1 + 305; j > arr[i] - t - 1 + 305; --j) {
if (cnt[j] == 1) k++;
}
if (k < r) {
for (int j = arr[i] - 1 + 305; j > arr[i] - t - 1 + 305; --j) {
if (cnt[j] == 0) {
ans++;
cnt[j] = 1;
k++;
}
if (k == r) break;
}
if (k < r) {
cout << -1 << endl;
return 0;
}
}
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
o=0
e=0
n=input()
l=map(int,input().split())
for i in l:
if i%2==0:
e+=1
else:
o+=1
print(min(o,e)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int INF = 0x3f3f3f3f;
int a[N], dp[N], pre[N], suf[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, l, r;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> l >> r, a[l]++, a[r + 1]--;
for (int i = 2; i <= m; i++) a[i] += a[i - 1];
memset(dp, INF, sizeof(dp));
for (int i = 1; i <= m; i++) {
*upper_bound(dp + 1, dp + m + 1, a[i]) = a[i];
pre[i] = lower_bound(dp + 1, dp + m + 1, INF) - dp - 1;
}
memset(dp, INF, sizeof(dp));
for (int i = m; i >= 1; i--) {
*upper_bound(dp + 1, dp + m + 1, a[i]) = a[i];
suf[i] = lower_bound(dp + 1, dp + m + 1, INF) - dp - 1;
}
int ans = 0;
for (int i = 0; i <= m; i++) ans = max(ans, pre[i] + suf[i + 1]);
cout << ans << endl;
return 0;
}
| 12 | CPP |
n = int(input())
check = True
for i in range(n):
pair = list(map(int,input().split()))
if i == 0:
last = max(pair)
else:
if max(pair)<=last:
last = max(pair)
elif min(pair)<=last:
last = min(pair)
else:
print("NO")
check = False
break
if check:
print("YES")
| 8 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimization("unroll-loops")
#pragma GCC optimization("O2")
#pragma GCC target("popcnt")
#pragma GCC target("avx2")
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, d, ans = 0;
cin >> n >> d;
for (int i = 0; i < n; i += 1) {
int a;
cin >> a;
if (i == 0) {
ans = a;
} else {
if (i * a <= d) {
d -= i * a;
ans += a;
} else {
ans += d / i;
d = 0;
}
}
}
cout << ans << endl;
}
}
| 7 | CPP |
x, y = [int(i) for i in input().split()]
z = 7-max(x, y)
a = 6
if z == 2 or z == 4:
z //= 2
a //= 2
if a % z == 0:
a //= z
z = 1
print(str(z) + '/' + str(a))
| 7 | PYTHON3 |
m=int(input())
if m%2==0 and m!=2:
print('yes')
else:
print('no')
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int x[100111];
int num[100111], numl;
int ans[100111];
map<int, int> HASH;
int main() {
int i, temp;
scanf("%d", &n);
memset(num, 0, sizeof(num));
numl = 0;
for (i = 0; i < n; i++) {
scanf("%d", &temp);
if (HASH.count(temp) == 0) {
HASH[temp] = numl;
x[numl] = temp;
numl++;
}
num[HASH[temp]]++;
}
sort(x, x + numl);
ans[0] = num[HASH[x[0]]];
for (i = 1; i < numl; i++) {
ans[i] = ans[i - 1] + num[HASH[x[i]]];
}
int m, q;
int left, right, mid;
scanf("%d", &q);
for (i = 0; i < q; i++) {
scanf("%d", &m);
left = 0;
right = numl - 1;
while (left <= right) {
mid = (left + right) / 2;
if (x[mid] == m ||
(x[mid - 1] < m && x[mid + 1] > m && mid + 1 < numl && mid - 1 >= 0))
break;
if (x[mid] > m)
right = mid - 1;
else
left = mid + 1;
}
while (x[mid] > m && mid >= 0) mid--;
while (x[mid + 1] <= m && mid + 1 < numl) mid++;
if (mid >= 0 && mid < numl) printf("%d\n", ans[mid]);
if (mid < 0) printf("0\n");
if (mid >= numl) printf("%d\n", n);
}
return 0;
}
| 8 | CPP |
N,M=map(int,input().split())
mod=10**9+7
Fact=[0 for i in range(M+1)]
Finv=[0 for i in range(M+1)]
Fact[0]=1
def inv(x):
return pow(x,mod-2,mod)
for i in range(M):
Fact[i+1]=Fact[i]*(i+1)
Fact[i+1]%=mod
Finv[M]=inv(Fact[M])
for i in range(M-1,-1,-1):
Finv[i]=(i+1)*Finv[i+1]
Finv[i]%=mod
def P(n,k):
return (Fact[n]*Finv[n-k])%mod
def C(n,k):
return (Fact[n]*Finv[n-k]*Finv[k])%mod
ans=0
for k in range(N+1):
if k%2==0:
ans+=C(N,k)*P(M-k,N-k)
else:
ans-=C(N,k)*P(M-k,N-k)
ans%=mod
print((ans*P(M,N))%mod)
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using std::min;
int n, m, p[1010];
int main() {
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int x;
scanf("%d", &x);
if (x == 1) p[++n] = i;
}
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (i == 1) {
cnt++;
continue;
}
cnt += min(2, p[i] - p[i - 1]);
}
printf("%d\n", cnt);
return 0;
}
| 8 | CPP |
for _ in range(int(input())):
n, k = map(int, input().split())
stk = input()
left = 0
ans = False
while(left<n):
right = left
while(right<n):
first = stk[:left]
last = stk[(right+1):]
if first==last[::-1] and left>=k:
ans|=True
right+=1
left+=1
if ans:
print("YES")
else:
print("NO") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp, mp2;
map<pair<int, int>, int> Mp;
int main() {
long long n, ans = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
ans += mp[x];
ans += mp2[y];
ans -= Mp[make_pair(x, y)];
Mp[make_pair(x, y)]++;
mp[x]++;
mp2[y]++;
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
n=int(input())
x=0
y=0
s=input()
i=1
m=0
if s[0]=='U':
y+=1
else:
x+=1
while i<n:
if s[i]=='U':
y+=1
if x==y:
if i!=n-1:
if s[i+1]=='U':
m+=1
else:
x+=1
if x==y:
if i!=n-1:
if s[i+1]=='R':
m+=1
i+=1
print(m)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, o;
cin >> n >> o;
vector<pair<int, int> > b;
vector<pair<int, int> > s;
while (n--) {
char c;
int x, y;
cin >> c >> x >> y;
if (c == 'B')
b.push_back({x, y});
else
s.push_back({x, y});
}
sort(b.rbegin(), b.rend());
sort(s.begin(), s.end());
int cnt = 0;
vector<pair<int, int> > an;
for (int i = 0; i < (int)s.size(); i++) {
if (cnt == o) break;
int cur = s[i].second;
while (i + 1 < (int)s.size() && s[i].first == s[i + 1].first) {
cur += s[i + 1].second;
i++;
}
an.push_back({s[i].first, cur});
cnt++;
}
for (int i = (int)an.size() - 1; i >= 0; i--)
cout << "S " << an[i].first << ' ' << an[i].second << endl;
cnt = 0;
for (int i = 0; i < (int)b.size(); i++) {
if (cnt == o) break;
int cur = b[i].second;
cout << "B " << b[i].first << ' ';
while (i + 1 < (int)b.size() && b[i].first == b[i + 1].first) {
cur += b[i + 1].second;
i++;
}
cout << cur << endl;
cnt++;
}
return 0;
}
| 8 | CPP |
n=int(input())
s=input()
a=''
i=j=0
while j<n:
j+=i
if j<n:
a+=s[j]
i+=1
print(a)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int son[600105][26], depth = 0, total, fi[600105], num[26], ans[600105], tot;
int newnode(int x) {
++tot;
for (int i = 0; i <= 25; i++) son[tot][i] = son[x][i];
return tot;
}
void merge(int &x, int y, int dep) {
if (!x || !y) {
x += y;
return;
}
ans[dep]++;
x = newnode(x);
for (int i = 0; i <= 25; i++) merge(son[x][i], son[y][i], dep);
}
void dfs(int x, int y) {
depth = max(depth, y);
ans[y - 1]++;
for (int i = 0; i <= 25; i++) {
int now = 0;
for (int j = 0; j <= 25; j++)
if (son[son[x][j]][i]) merge(now, son[son[x][j]][i], y);
}
for (int i = 0; i <= 25; i++)
if (son[x][i]) dfs(son[x][i], y + 1);
}
int main() {
int n;
scanf("%d", &n);
tot = n;
for (int i = 1; i <= n - 1; i++) {
int j, k;
char ch;
scanf("%d %d %c", &j, &k, &ch);
son[j][ch - 'a'] = k;
}
dfs(1, 1);
int sum = 0, sum1 = 0;
for (int i = 1; i <= depth; i++)
if (sum < ans[i]) sum = ans[i], sum1 = i;
printf("%d\n%d\n", n - sum, sum1);
return 0;
}
| 9 | CPP |
inp=int(input())
array=['7','4']
if inp%4==0:
print("YES")
exit()
elif inp%7==0:
print("YES")
exit()
elif inp%47==0:
print("YES")
exit()
elif inp%77==0:
print("YES")
exit()
elif inp%747==0:
print("YES")
exit()
elif inp%477==0:
print("YES")
exit()
elif inp%447==0:
print("YES")
exit()
elif inp%777==0:
print("YES")
exit()
elif inp%7777==0:
print("YES")
exit()
elif inp%7777==0:
print("YES")
exit()
else:
dummy=(list(str(inp)))
for i in range(len(dummy)):
if dummy[i] not in array:
print("NO")
exit()
print("YES") | 7 | PYTHON3 |
n = int(input())
l = []
l =list( map(int,input().split()))
mt=0
c = 0
while(1):
m = max(l)
mt+=m
l.remove(m)
s = sum(l)
c+=1
if(mt>s):
break
print(c) | 7 | PYTHON3 |
import sys
n = int(sys.stdin.readline()[:-1])
magnet = sys.stdin.readline()[:-1]
last = magnet[-1]
output = 1
for i in range(n-1):
magnet = sys.stdin.readline()[:-1]
if magnet[0] == last:
output +=1
last = magnet[-1]
print(output) | 7 | PYTHON3 |
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
from math import ceil
n = int(input())
a = list(map(int, input().split()))
temp_gcd = min(a)
k = 0
for i in a:
temp_gcd = gcd(temp_gcd, i)
i = 1
while i ** 2 <= temp_gcd:
if temp_gcd % i == 0:
k += 1
if i != temp_gcd // i:
k += 1
i += 1
print(k) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, i, a[111111], mx, mxx;
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] > mx) mx = a[i];
}
int c = 0;
for (i = 2; i <= n; i++) {
if (a[i] == a[i - 1] && a[i] == mx) {
c++;
if (c == 1) c++;
} else {
mxx = max(mxx, c);
c = 0;
}
}
mxx = max(mxx, max(1, c));
cout << mxx;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX >> 1;
const double PI = 3.1415926535897932384626433832795;
const double EPS = 1E-8;
int main() {
int tk;
cin >> tk;
while (tk-- > 0) {
int n, m, x1, y1, x2, y2;
scanf("%d%d%d%d%d%d", &n, &m, &x1, &y1, &x2, &y2);
long long s1 = n - abs(x1 - x2);
long long s2 = m - abs(y1 - y2);
long long ans = 2 * s1 * s2;
ans -= max(0LL, s1 - (n - s1)) * max(0LL, s2 - (m - s2));
printf("%I64d\n", n * 1LL * m - ans);
}
return 0;
}
| 8 | CPP |
#include <iostream>
#include <algorithm>
using namespace std;
int main() {
int N;
cin >> N;
int p[N][3];
for(int i = 0; i < N; i++) {
int ii[3];
for(int j = 0; j < 3; j++) {
cin >> ii[j];
}
sort(ii, ii + 3);
for(int j = 0; j < 3; j++) {
p[i][j] = ii[j];
}
}
bool er[N];
for(int i = 0; i < N; i++) {
er[i] = false;
}
int sum = 0;
for(int i = 0; i < N; i++) {
if(er[i]) continue;
for(int j = i+1; j < N; j++) {
bool ers = true;
if(er[j]) continue;
for(int k = 0; k < 3; k++) {
if(p[i][k] != p[j][k]) {
ers = false;
break;
}
}
if(ers) {
er[j] = true;
sum++;
}
}
}
cout << sum << endl;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
string s[40] = {
"Washington", "Adams", "Jefferson", "Madison", "Monroe",
"Adams", "Jackson", "Van Buren", "Harrison", "Tyler",
"Polk", "Taylor", "Fillmore", "Pierce", "Buchanan",
"Lincoln", "Johnson", "Grant", "Hayes", "Garfield",
"Arthur", "Cleveland", "Harrison", "Cleveland", "McKinley",
"Roosevelt", "Taft", "Wilson", "Harding", "Coolidge",
"Hoover", "Roosevelt", "Truman", "Eisenhower", "Kennedy",
"Johnson", "Nixon", "Ford", "Carter", "Reagan"};
int main() {
int i;
cin >> i;
cout << s[i - 1] << endl;
return 0;
}
| 7 | CPP |
#det = ae - bd
#x = (ce - bf) / det
#y = (af - cd) / det
#-0.000 対策
EPS = 1e-4
while True:
try:
a, b, c, d, e, f = map(float, input().split())
det = a*e - b*d
x = (c*e - b*f) / det + EPS
y = (a*f - c*d) / det + EPS
print('{0:.3f} {1:.3f}'.format(x, y))
except EOFError:
break
| 0 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
int main(){
long n,k=0;
cin>>n;
vector<int> a(n),b(n);
for(auto &i:a)cin>>i,k-=i;
for(auto &i:b)cin>>i,k+=i;
for(int i=0;i<n;++i)if(a[i]<b[i])k-=(b[i]-a[i]+1)/2;
cout<<(k<0?"No":"Yes");
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
map<int, int> ch;
int c, n, m, a[100010], b[2010], ds[100010], d[100010], check[100010], pos,
check2[100010];
int main() {
int i, j, sw, cc = 0;
scanf("%d %d", &n, &m);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= m; i++) {
scanf("%d", &b[i]);
ch[b[i]] = 1;
}
sort(a + 1, a + n + 1);
for (i = 1; i < n; i++) {
check2[i] = cc;
if (a[i + 1] != a[i] + 1) {
pos = i;
check[i] = pos;
cc++;
} else
check[i] = pos;
}
check2[n] = cc;
sort(b + 1, b + m + 1);
for (i = 1; i <= n; i++) {
if (ch[a[i]])
sw = 1;
else
sw = 0;
ds[i] = max(ds[i], d[check[i - 1]] + sw);
c = 0;
for (j = m; j >= 1; j--) {
if (b[j] >= a[i]) continue;
c++;
if (i - (a[i] - b[j]) - 1 >= 0)
ds[i] = max(ds[i], d[check[i - (a[i] - b[j]) - 1]] + c + sw);
}
c = 0;
for (j = 1; j <= m; j++) {
if (a[i] < b[j]) {
c++;
if (i + b[j] - a[i] <= n)
d[i + b[j] - a[i]] = max(d[i + b[j] - a[i]], ds[i] + c);
if (i + b[j] - a[i] <= n && check2[i + b[j] - a[i]] == check2[i])
ds[i + b[j] - a[i]] = max(ds[i + b[j] - a[i]], ds[i] + c);
}
}
d[i] = max(ds[i], d[i]);
d[i] = max(d[i], d[i - 1]);
}
printf("%d", d[n]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int M = 1000005;
int read() {
int x = 0, f = 1;
char c;
while ((c = getchar()) < '0' || c > '9') {
if (c == '-') f = -1;
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return x * f;
}
int n, m, a[M], b[M], p[M], s[M], num[M];
vector<int> v[M];
char t[M];
long long ans;
void add(int x, int i) {
b[i] = i;
while (x > 1) {
v[p[x]].push_back(i);
x /= p[x];
}
}
void del(int x, int i) {
b[i] = i;
while (x > 1) {
if (v[p[x]].empty()) {
b[i] = 0;
return;
}
b[i] = min(b[i], v[p[x]].back());
v[p[x]].pop_back();
x /= p[x];
}
}
signed main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 2; i <= 1e6; i++)
if (!p[i]) {
p[i] = i;
for (int j = i; j <= 1e6; j += i) p[j] = i;
}
scanf("%s", t + 1);
for (int i = 1; i <= n; i++) {
if (t[i] == '*')
add(a[i], i);
else
del(a[i], i);
}
for (int i = n; i >= 1; i--) {
int cnt = 1;
while (m > 0 && s[m] >= b[i]) {
cnt += num[m];
m--;
}
s[++m] = b[i];
num[m] = cnt;
if (i == b[i]) ans += cnt;
}
printf("%lld\n", ans);
}
| 13 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = int(1e9);
const int MOD = int(1e9) + 7;
const double EPS = 1e-14;
const long long INFll = 1ll * INF * INF;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
vector<string> email;
string e;
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '@') {
e.clear();
int j = i - 1;
while (j >= 0 && s[j] != '@' && s[j] != '.') j--;
j++;
for (int q = j; q <= i; ++q) e += s[q];
j = i + 1;
while (j < s.size() && s[j] != '@' && s[j] != '_') e += s[j++];
j--;
bool point = 0, cool = 1;
int f = 0;
if (e[0] == '@' || *(--e.end()) == '@') continue;
vector<int> u(e.size(), 1);
for (int j = 0; j < e.size(); ++j) {
if (e[j] == '@') {
f = j + 1;
continue;
}
if (!f && e[j] == '.') u[j] = 0;
if (e[j] == '.' && point) u[j] = 0;
if (e[j] == '.') point = 1;
if (f && e[j] == '_') u[j] = 0;
if (f && point && e[j] >= '0' && e[j] <= '9') u[j] = 0;
}
if (!point) continue;
f--;
int l = f, r = f;
while (l >= 0 && u[--l])
;
l++;
while (r < e.size() && u[++r])
;
r--;
while (e[l] == '_' || (e[l] >= '0' && e[l] <= '9')) l++;
string temp;
point = 0, f = 0;
int k1 = 0, k2 = 0, k3 = 0;
for (int j = l; j <= r; ++j) {
temp += e[j];
if (e[j] == '.') {
point = 1;
continue;
}
if (e[j] == '@') {
f = 1;
continue;
}
if (!f) k1++;
if (f && !point) k2++;
if (f && point) k3++;
}
if (k1 && k2 && k3) email.push_back(temp);
}
}
long long ans = 0;
for (int i = 0; i < email.size(); ++i) {
int a = 0, b = 0;
bool f = 0;
for (int j = 0; j < email[i].size(); ++j) {
if (email[i][j] == '@') f = 1;
if (!f && email[i][j] != '_' && (email[i][j] < '0' || email[i][j] > '9'))
a++;
if (email[i][j] == '.') {
b = email[i].size() - j - 1;
}
}
ans += 1ll * a * b;
}
cout << ans;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MD = 1e9 + 7;
map<long long, long long> dp;
long long pw(long long a, long long b) {
long long rs = 1;
while (b > 0) {
if (b & 1) {
rs = (rs * a) % MD;
}
a = (a * a) % MD;
b /= 2;
}
return rs;
}
long long solve(long long a) {
if (a == 1) {
return 1;
}
if (dp.find(a) != dp.end()) return dp[a];
dp[a] = pw(2, a - 1);
for (long long i = 1; i * i <= a; ++i) {
if (a % i == 0) {
if (i != 1) {
dp[a] -= solve(a / i);
dp[a] %= MD;
dp[a] += MD;
dp[a] %= MD;
}
long long nx = a / i;
if (nx != -1 && nx != i) {
dp[a] -= solve(a / nx);
dp[a] %= MD;
dp[a] += MD;
dp[a] %= MD;
}
}
}
return dp[a];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long x, y;
cin >> x >> y;
if (y % x != 0) {
cout << 0 << "\n";
return 0;
}
cout << solve(y / x) << "\n";
return 0;
}
| 10 | CPP |
#include <iostream>
#include <cstring>
using namespace std;
int M[52][52];
void fill(int y, int x){
M[y][x] = 0;
if(M[y-1][x]) fill(y-1,x);
if(M[y+1][x]) fill(y+1,x);
if(M[y][x-1]) fill(y,x-1);
if(M[y][x+1]) fill(y,x+1);
if(M[y-1][x-1]) fill(y-1,x-1);
if(M[y+1][x-1]) fill(y+1,x-1);
if(M[y-1][x+1]) fill(y-1,x+1);
if(M[y+1][x+1]) fill(y+1,x+1);
}
int main(){
int w,h,c,i,j;
while(cin>>w>>h,w){
memset(M, 0, sizeof(M));
c=0;
for(i=1;i<=h;i++){
for(j=1;j<=w;j++){
cin >> M[i][j];
}
}
for(i=1;i<=h;i++){
for(j=1;j<=w;j++){
if(!M[i][j]) continue;
fill(i, j);
c ++;
}
}
cout << c << endl;
}
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int &t : a) cin >> t;
sort(begin(a), end(a));
int ans = INT_MAX;
for (int i = 0; i < n / 2; i++) ans = min(a[i + n / 2] - a[i], ans);
cout << ans << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
const int mxn = 100000 + 10;
using namespace std;
int x, y;
int X[128], Y[128];
int vis[128][128];
double dp[128][128];
int K;
int id, n;
double eps;
double hypo(double xx, double yy) { return xx * xx + yy * yy; }
double P(double D, double R) {
if (D <= R * R) return 1;
double xx = 1.0 - (D / (R * R));
return exp(xx);
}
double R;
double solve(int p, int k) {
if (p == n) return k >= K;
double &d = dp[p][k];
int &v = vis[p][k];
if (v == id) return d;
v = id;
d = 0;
double D = hypo(X[p] - x, Y[p] - y);
double pp = P(D, R);
d += pp * solve(p + 1, k + 1);
d += (1.0 - pp) * solve(p + 1, k);
return d;
}
int main() {
int ee;
scanf("%d", &n);
scanf("%d", &K);
scanf("%d", &ee);
scanf("%d", &x);
scanf("%d", &y);
eps = ee / 1000.0;
for (int i = 0; i < n; i++) {
scanf("%d", &X[i]);
scanf("%d", &Y[i]);
}
double low = 0, high = 1e9;
while (fabs(low - high) > 1e-7) {
double mid = (low + high) / 2.0;
++id;
R = mid;
double failprob = 1.0 - solve(0, 0);
if (failprob <= eps || fabs(failprob - eps) < 1e-9)
high = mid;
else
low = mid;
}
printf("%.20lf\n", low);
}
| 10 | CPP |
R, C = map(int, input().split())
ss = []
for i in range(R):
l = input()
ss.append(l.replace(".","D"))
for i in range(R):
for j in range(C):
if ss[i][j] == "S":
if i > 0:
if ss[i-1][j] == "W":
ss = "No"
break
if j > 0:
if ss[i][j-1] == "W":
ss = "No"
break
if i < R-1:
if ss[i+1][j] == "W":
ss = "No"
break
if j < C-1:
if ss[i][j+1] == "W":
ss = "No"
break
if "No" == ss:
break
if "No" != ss:
print("Yes")
for i in ss:
print(i)
else:
print(ss) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, i, j;
cin >> n;
int c[n], t[n];
for (i = 0; i < n; ++i) cin >> c[i];
for (i = 0; i < n; ++i) cin >> t[i];
if (c[0] != t[0]) {
cout << "No";
return 0;
}
if (c[n - 1] != t[n - 1]) {
cout << "No";
return 0;
}
vector<int> cd, td;
for (i = 1; i < n; ++i) {
cd.push_back(c[i] - c[i - 1]);
}
for (i = 1; i < n; ++i) {
td.push_back(t[i] - t[i - 1]);
}
sort(cd.begin(), cd.end());
sort(td.begin(), td.end());
if (cd != td)
cout << "No";
else
cout << "Yes";
return 0;
}
| 11 | CPP |
from collections import Counter
n = int(input())
string = list(input())
C = Counter(string)
if len(Counter(string))<=1:
print("NO")
else:
res = list(C.keys())[:2]
print("YES")
print("".join(res)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
T power(T N, T P) {
return (P == 0) ? 1 : N * power(N, P - 1);
}
long long toInt64(string s) {
long long r = 0;
istringstream sin(s);
sin >> r;
return r;
}
double LOG(long long N, long long B) { return (log10l(N)) / (log10l(B)); }
string itoa(long long a) {
if (a == 0) return "0";
string ret;
for (long long i = a; i > 0; i = i / 10) ret.push_back((i % 10) + 48);
reverse(ret.begin(), ret.end());
return ret;
}
vector<string> token(string a, string b) {
const char *q = a.c_str();
while (count(b.begin(), b.end(), *q)) q++;
vector<string> oot;
while (*q) {
const char *e = q;
while (*e && !count(b.begin(), b.end(), *e)) e++;
oot.push_back(string(q, e));
q = e;
while (count(b.begin(), b.end(), *q)) q++;
}
return oot;
}
int Set(int N, int pos) { return N = N | (1 << pos); }
int Reset(int N, int pos) { return N = N & ~(1 << pos); }
int check(int N, int pos) { return (N & (1 << pos)); }
int toggle(int N, int pos) {
if (check(N, pos)) return N = Reset(N, pos);
return N = Set(N, pos);
}
void PBIT(int N) {
printf("(");
for (int i = 10; i >= 0; i--) {
bool x = check(N, i);
cout << x;
}
puts(")");
}
queue<long long> q[4][100003];
long long k[5], t[5], arr[100003], sav[100003];
int main() {
for (int i = 0; i < (int)3; i++) cin >> k[i];
for (int i = 0; i < (int)3; i++) cin >> t[i];
int n;
cin >> n;
for (int i = 0; i < (int)n; i++) {
cin >> arr[i];
sav[i] = arr[i];
}
for (int i = 0; i < (int)3; i++) k[i] = (k[i] > n) ? n : k[i];
for (int i = 0; i < (int)3; i++)
for (int j = 0; j < (int)n; j++) q[i][j % k[i]].push(j);
for (int i = 0; i < (int)3; i++)
for (int j = 0; j < (int)k[i]; j++) {
long long lp = 0;
while (q[i][j].size()) {
int p = q[i][j].front();
q[i][j].pop();
arr[p] = max(lp, arr[p]) + t[i];
lp = arr[p];
}
}
long long ans = 0;
for (int i = 0; i < (int)n; i++) {
ans = max(ans, arr[i] - sav[i]);
}
cout << ans << endl;
return 0;
}
| 8 | CPP |
y=int(input())
lst=[]
for i in range(0,y):
n,x,a1,b1=map(int,input().split())
a=min(a1,b1)
b=max(a1,b1)
c=n-b
d=min(c,x)
x=x-d
f=max(1,a-x)
lst.append(b+d-f)
print(*lst,sep='\n') | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void next(string &s) {
bool z = true;
for (int i = 0; i < s.size(); i++)
if (s[i] != 'z') z = false;
if (z) {
s.resize(s.size() + 1);
for (int i = 0; i < s.size(); i++) s[i] = 'a';
} else {
for (int i = s.size() - 1; i >= 0; i--)
if (s[i] == 'z')
s[i] = 'a';
else {
s[i]++;
break;
}
}
}
int main() {
int n;
scanf("%d", &n);
string s[n];
for (int i = 0; i < n; i++) {
char c[21];
scanf("%s", c);
s[i] = c;
}
string t;
bool ok;
do {
next(t);
ok = true;
for (int i = 0; i < n; i++) ok = ok && (s[i].find(t) == string::npos);
} while (!ok);
printf("%s", t.c_str());
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100001;
const long long MOD = 1e9 + 7;
const double eps = 1e-9;
int n, m, x, a[N];
struct node {
int l, r, or_sum;
long long res;
vector<pair<int, int> > pref, suff;
node() {
res = 0;
or_sum = -1;
l = -1, r = -1;
}
node(int v, int i) {
l = i, r = i;
or_sum = v;
res = (v >= x);
pref.push_back(make_pair(v, i));
suff.push_back(make_pair(v, i));
}
node operator+(const node& o) const {
if (or_sum == -1) return o;
if (o.or_sum == -1) return *this;
node ret;
ret.l = l;
ret.r = o.r;
ret.or_sum = or_sum | o.or_sum;
ret.res = res + o.res;
ret.pref = pref;
ret.suff = o.suff;
for (int i = 0; i < o.pref.size(); i++) {
if ((or_sum | o.pref[i].first) != ret.pref.back().first)
ret.pref.push_back(
make_pair(or_sum | o.pref[i].first, o.pref[i].second));
else
ret.pref.back().second = o.pref[i].second;
}
for (int i = 0; i < suff.size(); i++) {
if ((o.or_sum | suff[i].first) != ret.suff.back().first)
ret.suff.push_back(make_pair(o.or_sum | suff[i].first, suff[i].second));
else
ret.suff.back().second = suff[i].second;
}
int i = suff.size() - 1;
for (int j = 0; j < o.pref.size(); j++) {
while (i >= 0 && (suff[i].first | o.pref[j].first) >= x) i--;
ret.res += 1ll * (i < 0 ? r - l + 1 : suff[i].second - l) *
(!j ? o.pref[j].second - o.l + 1
: o.pref[j].second - o.pref[j - 1].second);
}
return ret;
}
} seg[4 * N];
void build(int p, int s, int e) {
if (s == e) {
seg[p] = node(a[s], s);
return;
}
build(2 * p, s, (s + e) / 2);
build(2 * p + 1, (s + e) / 2 + 1, e);
seg[p] = seg[2 * p] + seg[2 * p + 1];
}
void update(int p, int s, int e, int i, int v) {
if (s == e) {
seg[p] = node(v, i);
return;
}
if (i <= (s + e) / 2)
update(2 * p, s, (s + e) / 2, i, v);
else
update(2 * p + 1, (s + e) / 2 + 1, e, i, v);
seg[p] = seg[2 * p] + seg[2 * p + 1];
}
node get(int p, int s, int e, int a, int b) {
if (s >= a && e <= b) return seg[p];
if (s > b || e < a) return node();
return get(2 * p, s, (s + e) / 2, a, b) +
get(2 * p + 1, (s + e) / 2 + 1, e, a, b);
}
int main() {
scanf("%d%d%d", &n, &m, &x);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
build(1, 1, n);
for (int i = 0, t, a, b; i < m; i++) {
scanf("%d%d%d", &t, &a, &b);
if (t == 1)
update(1, 1, n, a, b);
else
printf("%lld\n", get(1, 1, n, a, b).res);
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 5;
const long long INF = 1e9 + 7;
long long n, m, ans = 0, a[N], b[N], FA[N], FB[N];
long long D1[40005], D2[40005];
vector<pair<long long, long long> > v;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
a[i] += 10000;
a[i] *= 2;
D1[a[i]]++;
}
for (long long j = 1; j <= m; j++) {
cin >> b[j];
b[j] += 10000;
b[j] *= 2;
D2[b[j]]++;
}
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= m; j++)
if ((a[i] + b[j]) % 2 == 0) {
long long pos = (a[i] + b[j]) / 2;
FA[pos] |= 1LL << i;
FB[pos] |= 1LL << j;
}
for (long long i = 0; i <= 40000; i++)
v.push_back(pair<long long, long long>(
__builtin_popcountll(FA[i]) + __builtin_popcountll(FB[i]), i));
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
for (long long i = 0; i < min(v.size(), (size_t)(1000)); i++)
for (long long j = i + 1; j < min(v.size(), (size_t)(1000)); j++) {
long long sum = 0;
long long fi = FA[v[i].second] | FA[v[j].second];
for (long long k = 1; k <= 60; k++)
if (fi >> k & (long long)(1)) sum += D1[a[k]];
long long se = FB[v[i].second] | FB[v[j].second];
for (long long k = 1; k <= 60; k++)
if (se >> k & (long long)(1)) sum += D2[b[k]];
ans = max(ans, (long long)(__builtin_popcountll(fi) +
__builtin_popcountll(se)));
}
cout << ans;
return 0;
}
| 11 | CPP |
weight = int(input());
if(weight>=1 and weight<=100):
if(weight%2==0 and weight>2):
print("YES")
else:
print("NO")
else:
quit()
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int a1, b1, c1;
int a2, b2, c2;
int d[8];
int f[8];
bool solve(int a1, int b1, int c1, int a2, int b2, int c2) {
if (a1 < 0 || b1 < 0 || c1 < 0) return 0;
if (a2 < 0 || b2 < 0 || c2 < 0) return 0;
f[1] = min({a1, b1, c1, d[1]});
f[4] = min(d[4], a1 - f[1]);
if (d[4] - f[4] > a2 - d[1] + f[1]) return 0;
f[6] = min(d[6], b1 - f[1]);
if (d[6] - f[6] > b2 - d[1] + f[1]) return 0;
f[7] = min(d[7], c1 - f[1]);
if (d[7] - f[7] > c2 - d[1] + f[1]) return 0;
return 1;
}
void solve() {
cin >> a1 >> b1 >> c1;
cin >> a2 >> b2 >> c2;
for (int i = 1; i <= 7; i++) cin >> d[i];
for (f[2] = 0; f[2] <= d[2]; f[2]++)
for (f[3] = 0; f[3] <= d[3]; f[3]++)
for (f[5] = 0; f[5] <= d[5]; f[5]++) {
if (solve(a1 - f[2] - f[3], b1 - f[2] - f[5], c1 - f[3] - f[5],
a2 - (d[2] - f[2]) - (d[3] - f[3]),
b2 - (d[2] - f[2]) - (d[5] - f[5]),
c2 - (d[3] - f[3]) - (d[5] - f[5]))) {
for (int i = 1; i <= 7; i++) cout << f[i] << " ";
cout << '\n';
return;
}
}
cout << -1 << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 12 | CPP |
s=input()
lst=[]
for i in range(len(s)):
if i%2==0:
lst.append(s[i])
lst.sort()
x="+".join(lst)
print(x) | 7 | PYTHON3 |
ii =lambda: int(input())
si =lambda: input()
lii =lambda: list(map(int,input().split()))
n=ii()
arr=lii()
count=0
for i in range(1,n):
if arr[i]>max(arr[:i]) or arr[i]<min(arr[:i]):
count+=1
print(count)
| 7 | PYTHON3 |
# n=int(input());s=[]
# for i in range(n):
# s.append(input())
# a=[];r=[];t=1
# def count(z):
# y=0
# for i in a:
# if i==z:
# y+=1
# return y
# def check(l):
# m=True
# for i in a:
# if i==l:
# m=False
# return m
# for i in s:
# if check(i):
# a.append(i)
# r.append("OK")
# else:
# a.append(i)
# p=i
# p+=str(count(i)-1)
# r.append(p)
# # print(r)
# print(*r,sep="\n")
n=int(input())
d={}
for i in range(0, n):
s=input()
if s in d:
print(s+str(d[s]))
d[s] += 1
else:
print("OK")
d[s] = 1 | 9 | PYTHON3 |
a=int(input())
while True:
b=a+1
l=[]
while b>0:
l.append(b%10)
b=b//10
if len(set(l))==4:
print(a+1)
break
else:
a+=1 | 7 | PYTHON3 |
n = int(input())
s = list(map(int, list(input())))
answer = 0
for i in range(n):
if s[i] % 2 == 0:
answer += i + 1
print(answer)
| 7 | PYTHON3 |
password=input()
a=b=c=0
if len(password)>4:
for i in password:
if a==0 and (ord(i) in range(48,58)): a=1
if b==0 and (ord(i) in range(65,91)): b=1
if c==0 and (ord(i) in range(97,123)): c=1
if a+b+c>2:
print('Correct')
exit()
print ('Too weak')
| 7 | PYTHON3 |
t = int(input())
for tt in range(t):
n = int(input())
k = 3
while n % k > 0:
k = k * 2 + 1
print(n // k) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<int> v[200010];
long long cnt = 0, ch[200010][10], sm[200010][10], tmp[10];
void dfs(int x, int p) {
for (auto e : v[x]) {
if (e != p) {
dfs(e, x);
for (int i = 0; i < k; ++i) {
ch[x][(i + 1) % k] += ch[e][i];
sm[x][(i + 1) % k] += sm[e][i];
}
++ch[x][1 % k];
sm[x][1 % k] += ch[e][0] + 1;
}
}
for (auto e : v[x]) {
if (e != p) {
for (int i = 0; i < k; ++i) {
for (int j = 0; j < k; ++j) {
long long tmp1 = sm[e][(i + k - 1) % k],
tmp2 = sm[x][j] - sm[e][(j + k - 1) % k];
long long ch1 = ch[e][(i + k - 1) % k],
ch2 = ch[x][j] - ch[e][(j + k - 1) % k];
if (i == 1 % k) {
tmp1 += ch[e][0] + 1;
++ch1;
}
if (j == 1 % k) {
tmp2 -= ch[e][0] + 1;
--ch2;
}
cnt += tmp1 * ch2 + tmp2 * ch1;
if (i && j && i + j <= k) {
cnt -= ch1 * ch2;
}
}
}
}
}
}
int main() {
cin >> n >> k;
memset(ch, 0, sizeof ch);
memset(sm, 0, sizeof sm);
for (int i = 1; i < n; ++i) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
dfs(1, 0);
cnt >>= 1;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < k; ++j) {
cnt += sm[i][j];
}
}
cout << cnt << endl;
return 0;
}
| 9 | CPP |
n = int(input())
a = list(map(int, input().split()))
m = 100000000
k = -1
for i in range(1,101):
sum = 0
for j in range(n):
# print(abs(a[j]-i))
if a[j]!=i:
sum = abs(i - a[j]) - 1 + sum
if sum<m:
k = i
m = sum
print(k, m) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int arr[1010];
int main() {
int n;
while (~scanf("%d", &n)) {
for (int i = 0; i < 2 * n; i++) scanf("%d", &arr[i]);
sort(arr, arr + 2 * n);
if (arr[n - 1] == arr[n])
printf("NO\n");
else
printf("YES\n");
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N, arr[200001];
map<int, int> cnt;
vector<int> v;
int check(int cur) {
int ans = 0, prev = 0;
for (;;) {
int pos = lower_bound(v.begin() + prev, v.end(), cur) - v.begin();
if (pos >= 0 && pos < v.size()) {
ans += cur;
cur *= 2;
prev = pos + 1;
} else
break;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N;
for (int i = 0; i < N; i++) {
cin >> arr[i];
cnt[arr[i]]++;
}
for (map<int, int>::iterator it = cnt.begin(); it != cnt.end(); it++)
v.push_back(it->second);
sort(v.begin(), v.end());
int ans = 0;
for (int i = 1; i <= N; i++) ans = max(ans, check(i));
cout << ans << '\n';
return 0;
}
| 11 | CPP |
n=input()
a='heidi'
count=i=0
while i<len(n):
if a[count]==n[i]:
count+=1
i+=1
if count==5:
break
if count==5 and i<=len(n):
print('YES')
else:
print('NO') | 13 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long tt = 1;
while (tt--) {
long long x[101], y[101], ax, ay, bx, by;
cin >> x[0] >> y[0] >> ax >> ay >> bx >> by;
long long xs, ys, t;
cin >> xs >> ys >> t;
long long sz = 0;
for (long long i = 1; i < 65; i++) {
x[i] = ax * x[i - 1] + bx;
y[i] = ay * y[i - 1] + by;
if (x[i] > 2e16 || y[i] > 2e16) break;
sz++;
}
long long ans = 0;
long long x0, y0, cnt, p;
for (long long i = 0; i <= sz; i++) {
x0 = xs, y0 = ys, cnt = 0, p = t;
for (long long j = i; j >= 0; j--) {
long long d = abs(x0 - x[j]) + abs(y0 - y[j]);
if (d <= p) {
cnt++;
x0 = x[j];
y0 = y[j];
p -= d;
} else
break;
}
ans = max(ans, cnt);
x0 = xs, y0 = ys, cnt = 0, p = t;
for (long long j = i; j <= sz; j++) {
long long d = abs(x0 - x[j]) + abs(y0 - y[j]);
if (d <= p) {
cnt++;
x0 = x[j];
y0 = y[j];
p -= d;
} else
break;
}
ans = max(ans, cnt);
}
cout << ans << '\n';
}
return 0;
}
| 8 | CPP |
t = int(input())
for i in range(t):
a = input().split()
x = int(a[0])
y = int(a[1])
z = int(a[2])
if x != y and x != z and y != z:
print ('NO')
continue
if x == y == z:
print ('YES' + '\n' + str(x) + ' ' + str(y) + ' ' + str(z))
continue
if x == y and x > z:
print ('YES' + '\n' + str(x) + ' ' + str(z) + ' ' + str(z))
continue
if x == z and x > y:
print ('YES' + '\n' + str(x) + ' ' + str(y) + ' ' + str(y))
continue
if z == y and z > x:
print ('YES' + '\n' + str(z) + ' ' + str(x) + ' ' + str(x))
continue
print ('NO')
# YES
# 3 2 1
# YES
# 100 100 100
# NO
# YES
# 1000000000 1 0 | 7 | PYTHON3 |
n, m, k = input().split()
n = int(n)
m = int(m)
k = int(k)
if(m >= n and k >= n):
print('Yes')
else:
print('No') | 7 | PYTHON3 |
n, k = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
cnt = 0
for i in range(n):
if a[i] + k <= 5:
cnt +=1
print(cnt//3)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1000000007;
const long double PI = 3.14159265;
long long int powerWithMod(long long int base, long long int exponent,
long long int modulus = LLONG_MAX) {
long long int result = 1;
base %= modulus;
while (exponent > 0) {
if (exponent % 2 == 1) result = (result * base) % modulus;
exponent >>= 1;
base = (base * base) % modulus;
}
return result;
}
long long int modInverse(long long int a, long long int m = MOD) {
return powerWithMod(a, m - 2, m);
}
void stringToUpper(string& strToConvert) {
transform(strToConvert.begin(), strToConvert.end(), strToConvert.begin(),
::toupper);
}
void stringToLower(string& strToConvert) {
transform(strToConvert.begin(), strToConvert.end(), strToConvert.begin(),
::tolower);
}
unordered_map<string, int> R;
int n, l, m;
string s;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> l >> s >> m;
s += s;
for (int i = 0; i < m; i++) {
string s;
cin >> s;
R[s] = i + 1;
}
int L = n * l;
bool ok;
vector<int> ans(n, 0);
for (int ind = L - l; ind < L; ++ind) {
ok = 1;
vector<bool> mk(m + 1, 0);
for (int i = 0; i < n && ok; i++) {
auto it = R.find(s.substr(ind + i * l, l));
if (it == R.end() || mk[it->second]) {
ok = 0;
break;
}
mk[it->second] = 1;
ans[i] = it->second;
}
if (ok) break;
}
if (!ok) {
cout << "NO\n";
return 0;
}
cout << "YES" << endl;
for (auto j : ans) cout << j << ' ';
cout << "\n";
return 0;
}
| 11 | CPP |
n = int(input())
a = {k: v for (k, v) in map(lambda line: tuple(int(c) for c in input().split()), range(n))}
m = int(input())
b = {k: v for (k, v) in map(lambda line: tuple(int(c) for c in input().split()), range(m))}
keys = set(a.keys())
keys |= b.keys()
def max_val(k):
if (k in a) and (k in b):
return max(a[k], b[k])
if k in a:
return a[k]
return b[k]
print(sum(max_val(k) for k in keys)) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9+7;
int main() {
long long n,a,b;
cin >> n >> a >> b;
vector<long long> x(n);
for(int i=0; i<n; i++){
cin >> x.at(i);
}
long long ans = 0;
for(int i=0; i<n-1; i++){
ans += min((x.at(i+1)-x.at(i))*a, b);
}
cout << ans << endl;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long a, b, i, j, ans;
int main() {
cin >> a >> b;
if (a == b) {
cout << 1;
return 0;
}
ans = (a + 1) % 10;
for (j = a + 2; j <= b; j++) {
i = j;
i %= 10;
ans = (ans * i) % 10;
if (ans == 0) break;
}
cout << ans;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int timer[100][2], timing = 0, cnt;
bool cyclic = false, visited[100];
vector<vector<int> > edges;
void IsCyclic(int node, int parent) {
visited[node] = true;
timer[node][0] = ++timing;
for (int j = 0; j < edges[node].size(); j++) {
if (timer[edges[node][j]][0] == -1) {
IsCyclic(edges[node][j], node);
cnt++;
} else if (timer[edges[node][j]][0] != -1 && edges[node][j] != parent)
cyclic = true;
}
timer[node][1] = timing++;
}
int main() {
int n, m, a, b, out = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) {
vector<int> childs;
edges.push_back(childs);
visited[i] = false;
timer[i][0] = timer[i][1] = -1;
}
for (int i = 0; i < m; i++) {
cin >> a >> b;
edges[a - 1].push_back(b - 1);
edges[b - 1].push_back(a - 1);
}
for (int i = 0; i < n; i++) {
if (!visited[i]) {
cnt = 1;
IsCyclic(i, -1);
if (cyclic) {
if (cnt % 2 == 1) out++;
cyclic = false;
}
}
}
if ((n - out) % 2 == 1) out++;
cout << out << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
const int inf = 0x3f3f3f3f, Inf = 0x7fffffff;
const long long INF = 0x7fffffffffffffff;
const double eps = 1e-10;
unsigned int seed = 19260817;
const unsigned int _RAND_MAX_ = 4294967295u;
__inline__ __attribute__((always_inline)) unsigned int Rand() {
return seed = seed * 998244353u + 1000000007u;
}
template <typename _Tp>
_Tp gcd(const _Tp &a, const _Tp &b) {
return (!b) ? a : gcd(b, a % b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp abs(const _Tp &a) {
return a > 0 ? a : -a;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp max(const _Tp &a, const _Tp &b) {
return a < b ? b : a;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp min(const _Tp &a, const _Tp &b) {
return a < b ? a : b;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmax(_Tp &a, const _Tp &b) {
(a < b) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmin(_Tp &a, const _Tp &b) {
(a > b) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) bool _cmp(const _Tp &a,
const _Tp &b) {
return abs(a - b) <= eps;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void read(_Tp &x) {
register char ch(getchar());
bool f(false);
while (ch < 48 || ch > 57) f |= ch == 45, ch = getchar();
x = ch & 15, ch = getchar();
while (ch >= 48 && ch <= 57)
x = (((x << 2) + x) << 1) + (ch & 15), ch = getchar();
if (f) x = -x;
}
template <typename _Tp, typename... Args>
__inline__ __attribute__((always_inline)) void read(_Tp &t, Args &...args) {
read(t);
read(args...);
}
__inline__ __attribute__((always_inline)) int read_str(char *s) {
register char ch(getchar());
while (ch == ' ' || ch == '\r' || ch == '\n') ch = getchar();
register char *tar = s;
*tar = ch, ch = getchar();
while (ch != ' ' && ch != '\r' && ch != '\n' && ch != EOF)
*(++tar) = ch, ch = getchar();
return tar - s + 1;
}
const int N = 200005;
std::deque<int> q;
std::set<int> S;
int main() {
int n, k;
read(n, k);
int x;
for (int i = 1; i <= n; ++i) {
read(x);
if (S.find(x) != S.end()) {
continue;
}
if ((int)q.size() == k) {
S.erase(S.find(q.back()));
q.pop_back();
}
q.push_front(x);
S.insert(x);
}
printf("%d\n", (int)q.size());
while (!q.empty()) {
printf("%d ", q.front());
q.pop_front();
}
printf("\n");
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int l[503], r[503], h, f;
double sum;
double X(double x1, double y1, double x2, double y2, double x3, double y3) {
return (x2 - x1) * (y3 - y1) - (x3 - x1) * (y2 - y1);
}
double F(double x1, double x2, double x3, double x4) {
if (fabs(x1) < 1e-9 || fabs(x3) < 1e-9) return 0.0;
if (x1 < x4 && x3 < x2) {
double ds = fabs(X(x2, -h * 1.0, x1, h * 1.0, x3, -h * 1.0)),
us = fabs(X(x2, -h * 1.0, x4, h * 1.0, x1, h * 1.0)), x, y;
y = -h * 1.0 + (h + h) * 1.0 * ds / (us + ds);
x = x3 + (x4 - x3) * ds / (us + ds);
return fabs(X(0.0, 0.0, 0.0, -h * 1.0, x3, -h * 1.0) +
X(0.0, 0.0, x3, -h * 1.0, x, y) +
X(0.0, 0.0, x, y, x1, h * 1.0) +
X(0.0, 0.0, x1, h * 1.0, 0.0, h * 1.0) +
X(0.0, 0.0, 0.0, h * 1.0, 0.0, -h * 1.0)) /
2.0;
} else {
return fabs(X(0.0, 0.0, 0.0, -h * 1.0, fmin(x3, x2), -h * 1.0) +
X(0.0, 0.0, fmin(x3, x2), -h * 1.0, fmin(x1, x4), h * 1.0) +
X(0.0, 0.0, fmin(x1, x4), h * 1.0, 0.0, h * 1.0) +
X(0.0, 0.0, 0.0, h * 1.0, 0.0, -h * 1.0)) /
2.0;
}
}
int main() {
std::ios::sync_with_stdio(false);
int i, j, k, m, n, fh, hf;
double il, ir, jl, jr, li, lj, ri, rj;
cin >> n >> h >> f;
fh = (f - h) * 1.0;
hf = (f + h) * 1.0;
for (i = 1; i <= n; ++i) {
cin >> l[i] >> r[i];
sum += (r[i] - l[i]) * 1.0 * fh;
}
for (i = 1; i <= n; ++i)
if (l[i] < 0 && r[i] > 0) {
++n;
l[n] = 0;
r[n] = r[i];
r[i] = 0;
}
sum = sum / fh * hf / fh * hf - sum;
for (i = 1; i <= n; ++i)
for (j = 1; j <= n; ++j)
if ((r[i] <= 0) == (r[j] <= 0)) {
if (r[i] > 0) {
li = l[i];
ri = r[i];
lj = l[j];
rj = r[j];
} else {
li = -r[i];
ri = -l[i];
lj = -r[j];
rj = -l[j];
}
il = li / fh * hf;
ir = ri / fh * hf;
jl = lj / fh * hf;
jr = rj / fh * hf;
sum -= F(ri, ir, rj, jr) - F(li, il, rj, jr) - F(ri, ir, lj, jl) +
F(li, il, lj, jl);
}
printf("%.9f\n", sum);
return 0;
}
| 11 | CPP |
a,b=map(int,input().split())
h=a
while a>=b:
h+=a//b
r=a%b
a=a//b+r
print(h)
| 7 | PYTHON3 |
#include <iostream>
#include <cstdio>
#define N 65
using namespace std;
typedef long long ll;
ll M = 1e9 + 7;
ll n, s, c[2][N];
int main()
{
ll i, t;
cin >> n;
while (n--) {
scanf("%lld", &t);
for (i = 0; i < N; i++, t /= 2) {
c[t % 2][i]++;
}
}
for (i = 0; i < N; i++) {
s = ((1LL << i) % M * c[0][i] % M * c[1][i] % M + s) % M;
}
cout << s << endl;
return 0;
} | 0 | CPP |
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10**9)
n=int(input())
Edges=[[] for _ in range(n)]
for i in range(n-1):
a,b=map(int,input().split())
a-=1
b-=1
Edges[a].append(b)
Edges[b].append(a)
while sum([len(Edges[i]) for i in range(n)]):
for i in range(n):
if len(Edges[i])==1:
j=Edges[i][0]
Edges[i].remove(j)
Edges[j].remove(i)
for k in Edges[j]:
Edges[k].remove(j)
if not Edges[k]:
print('First')
exit()
Edges[j]=[]
print('Second') | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int SZ = 531441;
const int W = 12;
int n, m, w;
int cnt[1 << W];
int p3[W + 1];
int a[SZ + 10];
void go(int u, int id, int mask) {
if (id >= w) {
a[mask] += cnt[u];
return;
}
go(u, id + 1, mask + 2 * p3[id]);
go(u, id + 1, mask + ((u >> id) & 1) * p3[id]);
}
int getAns(const string &u, int id, int mask2, int mask3) {
if (id == w) {
return cnt[mask2] * a[mask3];
}
int p1, p2;
if (u[id] == 'A') {
p1 = getAns(u, id + 1, mask2 | (1 << id), mask3);
p2 = getAns(u, id + 1, mask2, mask3 + 2 * p3[id]);
} else if (u[id] == 'O') {
p1 = getAns(u, id + 1, mask2, mask3);
p2 = 0;
} else if (u[id] == 'X') {
p1 = getAns(u, id + 1, mask2, mask3);
p2 = getAns(u, id + 1, mask2 | (1 << id), mask3 + p3[id]);
} else if (u[id] == 'a') {
p1 = getAns(u, id + 1, mask2 | (1 << id), mask3 + p3[id]);
p2 = 0;
} else if (u[id] == 'o') {
p1 = getAns(u, id + 1, mask2, mask3 + p3[id]);
p2 = getAns(u, id + 1, mask2 | (1 << id), mask3 + 2 * p3[id]);
} else {
p1 = getAns(u, id + 1, mask2, mask3 + p3[id]);
p2 = getAns(u, id + 1, mask2 | (1 << id), mask3);
}
return p1 + p2;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> w >> n >> m;
for (int i = 1; i <= n; i++) {
int u;
cin >> u;
cnt[u]++;
}
p3[0] = 1;
for (int i = 1; i <= w; i++) {
p3[i] = p3[i - 1] * 3;
}
for (int i = 0; i < (1 << w); i++) {
go(i, 0, 0);
}
while (m--) {
string u;
cin >> u;
reverse(u.begin(), u.end());
int res = getAns(u, 0, 0, 0);
cout << res << '\n';
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct vert {
long long sumx, sumdiff;
int qua;
int x;
int ord;
vert *lt, *rt;
vert(int _x) : x(_x) {
sumdiff = 0;
sumx = x;
qua = 1;
ord = rand();
lt = rt = 0;
}
};
void norm(vert* r) {
if (r == 0) return;
r->qua = 1;
r->sumx = r->x;
r->sumdiff = 0;
long long ql = 0, qr = 0, qlsx = 0, qrsx = 0;
if (r->lt != 0) {
r->qua += r->lt->qua;
r->sumdiff += r->lt->sumdiff;
r->sumx += r->lt->sumx;
ql = r->lt->qua;
qlsx = r->lt->sumx;
}
if (r->rt != 0) {
r->qua += r->rt->qua;
r->sumdiff += r->rt->sumdiff;
r->sumx += r->rt->sumx;
qr = r->rt->qua;
qrsx = r->rt->sumx;
}
r->sumdiff += ql * qrsx - qr * qlsx + ql * r->x - qlsx + qrsx - qr * r->x;
}
vert* merge(vert* a, vert* b) {
if (a == 0) return b;
if (b == 0) return a;
if (a->ord > b->ord) {
a->rt = merge(a->rt, b);
norm(a);
return a;
} else {
b->lt = merge(a, b->lt);
norm(b);
return b;
}
}
void split(vert* root, int key, vert*& ansl, vert*& ansr) {
if (root == 0) {
ansr = ansl = 0;
return;
}
if (root->x <= key) {
split(root->rt, key, root->rt, ansr);
norm(root);
ansl = root;
} else {
split(root->lt, key, ansl, root->lt);
norm(root);
ansr = root;
}
}
int x[100000];
void insert(vert*& r, int k) {
vert *lt, *rt;
split(r, k, lt, rt);
r = merge(lt, merge(new vert(k), rt));
}
void remove(vert*& r, int k) {
vert *lt, *mt, *rt;
split(r, k, mt, rt);
split(mt, k - 1, lt, mt);
r = merge(lt, rt);
delete mt;
}
long long query(vert*& root, int l, int r) {
vert *lt, *mt, *rt;
split(root, r, mt, rt);
split(mt, l - 1, lt, mt);
long long ans = 0;
if (mt != 0) {
ans = mt->sumdiff;
}
root = merge(merge(lt, mt), rt);
return ans;
}
int n;
int ssx[100000];
vert* mtree = 0;
void check(int& l, vert* root) {
if (root == 0) return;
check(l, root->lt);
assert(ssx[l] == root->x);
check(++l, root->rt);
vert old = *root;
norm(root);
assert(old.qua == root->qua);
assert(old.sumx == root->sumx);
assert(old.sumdiff == root->sumdiff);
}
void assrt() {
for (int i = 0; i < n; i++) ssx[i] = x[i];
sort(ssx, ssx + n);
int c = 0;
check(c, mtree);
}
int main() {
ios_base::sync_with_stdio(false);
int m;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x[i];
insert(mtree, x[i]);
}
cin >> m;
for (int i = 0; i < m; i++) {
int t;
cin >> t;
if (t == 1) {
int p, d;
cin >> p >> d;
p--;
remove(mtree, x[p]);
x[p] += d;
insert(mtree, x[p]);
} else {
int l, r;
cin >> l >> r;
cout << query(mtree, l, r) << "\n";
}
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1e5 + 10;
long long int hsh[N];
long long int binarySearch(long long int *arr, long long int n,
long long int target) {
long long int lo = 0, hi = n - 1;
while (lo <= hi) {
long long int m = (lo + (hi - lo) / 2);
if (arr[m] == target) {
return m;
} else if (arr[m] > target) {
hi = m - 1;
} else {
lo = m + 1;
}
}
return -1;
}
long long int fact(long long int x) {
if (x == 1 || x == 0) return 1;
return (x * (fact(x - 1)));
}
void sieve(long long int *arr, long long int n) {
arr[0] = 1, arr[1] = 1;
for (long long int i = 2; i * i <= n; i++) {
if (arr[i] == 1) {
for (long long int j = i * i; j <= n; j += i) {
arr[j] = 1;
}
}
}
}
long long int gcd(long long int l, long long int b) {
if (l == b) return l;
if (l > b)
return gcd(l - b, b);
else
return gcd(l, b - l);
}
void file_i_o() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long int getposi(vector<long long int> ar, long long int e) {
auto it = find(ar.begin(), ar.end(), e);
if (it != ar.end()) {
return (it - ar.begin());
} else
return -1;
}
int bs(string arr[], string x, long long int n) {
long long int l = 0;
long long int r = n - 1;
while (l <= r) {
long long int m = l + (r - l) / 2;
long long int res;
if (x == (arr[m])) res = 0;
if (res == 0) return m;
if (x > (arr[m]))
l = m + 1;
else
r = m - 1;
}
return -1;
}
long long int match(string s1, string s2) {
long long int j = 0;
long long int flag = 0;
for (long long int i = 0; i < s1.length(); i++) {
if (s1[i] == s2[j]) {
j++;
} else
j = j;
if (j == s2.length()) {
flag = 1;
break;
}
}
return flag;
}
string getbinary(long long int n) {
string r;
while (n != 0) {
r = (n % 2 == 0 ? "0" : "1") + r;
n /= 2;
}
return r;
}
int main(int argc, char const *argv[]) {
clock_t begin = clock();
file_i_o();
long long int l, r;
cin >> l >> r;
if (l == r or l + 1 == r)
cout << -1;
else if (l % 2 == 0)
cout << l << " " << l + 1 << " " << l + 2;
else if (r - (l - 1) > 3)
cout << l + 1 << " " << l + 2 << " " << l + 3;
else
cout << -1;
return 0;
}
| 7 | CPP |
t=int(input())
for _ in range(t):
n,r=map(int,input().split())
m=min(n,r)
print(((m-1)*m//2)+1 if n<=r else m*(m+1)//2) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000;
int dis[N][2], vis[N][2];
int on[N], p[N][2];
map<int, vector<int>> g;
void dfs(int x, int w) {
for (int i : g[x]) {
if (!vis[i][w]) {
vis[i][w] = 1;
dis[i][w] = dis[x][w] + 1;
p[i][w] = x;
dfs(i, w);
}
}
}
void c(bool bole) {
for (int i = 0; i < N; i++) {
for (int j = 0; j < 2; j++) {
dis[i][j] = vis[i][j] = p[i][j] = 0;
if (bole) {
on[i] = 0;
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
for (t = t; t; t--, c(1)) {
int n;
cin >> n;
g.clear();
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
cout << "? " << n;
for (int i = 1; i <= n; i++) {
cout << ' ' << i;
}
cout << endl;
int x, d;
cin >> x >> d;
int s = x, f = x;
on[x] = 1;
for (; d; c(0)) {
int z = (d + 1) / 2;
vis[s][0] = 1;
dfs(s, 0);
vis[f][1] = 1;
dfs(f, 1);
vector<int> ask;
for (int i = 1; i <= n; i++) {
if (!on[i]) {
if (dis[i][0] == z || dis[i][1] == z) {
ask.push_back(i);
}
}
}
if (ask.size() == 0) {
break;
}
cout << "? " << ask.size();
for (int i : ask) {
cout << ' ' << i;
}
cout << endl;
int y;
cin >> y >> z;
x = y;
on[x] = 1;
z = (dis[x][0] == (d + 1) / 2 ? 0 : 1);
while (x != s && x != f) {
x = p[x][z];
on[x] = 1;
}
d >>= 1;
if (z == 0) {
s = y;
continue;
}
f = y;
}
cout << "! " << f << " " << s << endl;
string r;
cin >> r;
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int array[n];
long long int x = 0;
for (long long int i = 0; i < n; i++) {
cin >> array[i];
x ^= array[i];
}
if (x == 0) {
cout << "DRAW\n";
continue;
}
for (long long int i = 32; i >= 0; i--) {
if ((x >> i) % 2 == 1) {
long long int bits[2] = {0};
for (long long int j = 0; j < n; j++) {
bits[(array[j] >> i) & 1]++;
}
if (bits[0] % 2 == 0 && bits[1] % 4 == 3) {
cout << "LOSE\n";
} else {
cout << "WIN\n";
}
break;
}
}
}
return 0;
}
| 10 | CPP |
n=int(input())
s=input().strip()
arr=[]
for i in range(n):
if len(arr)%2==0 or (len(arr)>0 and arr[-1]!=s[i]):
arr.append(s[i])
if len(arr)%2!=0:
arr.pop()
print(n-len(arr))
print(''.join(arr)) | 9 | PYTHON3 |
n=(list(map(int, input().split())))
a=(list(map(int, input().split())))
l=0
i=0
j=0
p=0
m=0
q=n[1]
while 1:
if i>=n[0] or j>=n[0]:
break
if q>=a[j] :
m=j-i+1
q=q-a[j]
if m>l:
l=m
j+=1
else:
m=0
q=q+a[i]
i+=1
print(l) | 8 | PYTHON3 |
inp = lambda: map(int, input().split())
n, k = inp()
a = sorted(inp())
ans = 0
for i in range(n):
ans+=(k*a[i])
if k>1: k-=1
print(ans) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%d %d", &n, &k);
const int maxlevel = 800;
vector<double> fi(maxlevel + 1, 0.0), oldfi(maxlevel + 1);
for (int i = 1; i <= n; i++) {
fi.swap(oldfi);
for (int l = 1; l <= maxlevel; l++) {
fi[l] = 0.0;
fi[l] += (k - 1.0) / (1.0 * k) * oldfi[l];
double p2 = 0.0;
if (l + 1 <= maxlevel)
p2 += (1.0 / (l + 1.0)) * (l + oldfi[l + 1]);
else
p2 += (1.0 / (l + 1.0)) * (l + 0.0);
p2 += (1.0 * l) / (l + 1.0) * oldfi[l];
p2 += l / 2.0;
fi[l] += p2 * (1.0 / k);
}
}
double ret = 1.0 * k * fi[1];
printf("%.10f\n", ret);
return 0;
}
| 10 | CPP |
import math
m,n,a=map(int,input().split())
x=m/a
y=n/a
x=math.ceil(x)
y=math.ceil(y)
print(x*y) | 7 | PYTHON3 |
#include <iostream>
#include <string>
using namespace std;
int main(){
string s[8];
while(true){
bool end = false;
for(int i=0;i<8;i++){
if(!(cin >> s[i])) end = true;
}
if(end) break;
for(int i=0;i<8&&!end;i++){
for(int j=0;j<8&&!end;j++){
if(s[i][j]=='1'){
if(i+3<8&&s[i+3][j]=='1') cout << "B" << endl;
else if(j+3<8&&s[i][j+3]=='1') cout << "C" << endl;
else if(i+2<8&&0<=j-1&&s[i+2][j-1]=='1') cout << "D" << endl;
else if(i+1<8&&j+2<8&&s[i+1][j+2]=='1') cout << "E" << endl;
else if(i+2<8&&j+1<8&&s[i+2][j+1]=='1') cout << "F" << endl;
else if(i+1<8&&0<=j-1&&s[i+1][j-1]=='1') cout << "G" << endl;
else cout << "A" << endl;
end = true;
}
}
}
}
} | 0 | CPP |
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main(){
string a,b;
while(cin>>a>>b){
int n=0;
int la=a.size();
int lb=b.size();
for(int i=1-la;i<lb;i++){
int k=0;
for(int j=0;j<la;j++){
if(j+i<0||j+i>lb-1){
k=0;
}
else if(a[j]==b[j+i]){
k++;
n=max(n,k);
}
else{
k=0;
}
}
}
cout<<n<<endl;
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int di[] = {-1, 0, 1, 0};
const int dj[] = {0, 1, 0, -1};
const long long MOD = 1e9 + 7;
const long long INF = 1e9;
int n, k;
vector<string> line;
bool w = false;
char vowels[] = {'a', 'e', 'i', 'o', 'u'};
bool vowel(char a) {
for (int i = 0; i < 5; i++)
if (a == vowels[i]) return true;
return false;
}
bool match(string a, string b) {
int ck = 0;
int ca = a.length() - 1, cb = b.length() - 1;
while (ck < k) {
while (ca >= 0 && !vowel(a[ca])) ca--;
if (ca < 0 || !vowel(a[ca])) {
w = true;
return false;
}
ck++, ca--;
}
ck = 0;
while (ck < k) {
while (cb >= 0 && !vowel(b[cb])) cb--;
if (cb < 0 || !vowel(b[cb])) {
w = true;
return false;
}
ck++, cb--;
}
return a.substr(ca + 1) == b.substr(cb + 1);
}
string getScheme(int a) {
if (match(line[a], line[a + 1]) && match(line[a + 2], line[a + 3])) {
if (match(line[a + 1], line[a + 2]))
return "aaaa";
else
return "aabb";
}
if (match(line[a], line[a + 2]) && match(line[a + 1], line[a + 3]))
return "abab";
if (match(line[a], line[a + 3]) && match(line[a + 1], line[a + 2]))
return "abba";
return "x";
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n >> k;
line.resize(n * 4);
for (int i = 0; i < n * 4; i++) cin >> line[i];
map<string, int> scheme;
string s;
for (int i = 0; i < n * 4; i += 4) {
s = getScheme(i);
if (s == "x") {
w = true;
break;
}
scheme[s]++;
}
if (!(scheme.size() == 1 ||
scheme.size() == 2 && scheme.begin()->first == "aaaa") ||
w)
cout << "NO" << endl;
else
cout << (scheme.size() == 1 ? scheme.begin()->first
: next(scheme.begin())->first)
<< endl;
cin.ignore(), cin.get();
}
| 7 | CPP |
n = int(input())
a = list(map(int, input().split(' ')))
def sign(n):
return [1, -1][n % 2]
b1 = [abs(a[i]-a[i-1]) for i in range(1, len(a))]
b1 = [sign(i)*b1[i] for i in range(len(b1))]
b2 = [-x for x in b1]
max_ending_here = b1[0]
max_so_far = b1[0]
for i, x in enumerate(b1):
if i == 0:
continue
if i % 2 == 1:
max_ending_here += x
else:
if x > max_ending_here + x:
max_ending_here = x
else:
max_ending_here += x
max_so_far = max(max_so_far, max_ending_here)
b1 = b2
max_ending_here = b1[0]
max_so_far2 = b1[0]
for i, x in enumerate(b1):
if i == 0:
continue
if i % 2 == 0:
max_ending_here += x
else:
if x > max_ending_here + x:
max_ending_here = x
else:
max_ending_here += x
max_so_far2 = max(max_so_far2, max_ending_here)
print(max(max_so_far, max_so_far2))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vll = vector<ll>;
using vvi = vector<vi>;
using vvl = vector<vll>;
using vb = vector<bool>;
const int INF = 2e9 + 5;
const ll LLINF = (1LL << 60) + 5;
void range_add(vector<ll> &v, int l, int r, int k) {
if (l > r) return;
if (l >= 1 && l < v.size()) v[l] += k;
if (r + 1 >= 1 && r + 1 < v.size()) v[r + 1] -= k;
}
int main() {
cin.tie(0), cin.sync_with_stdio(0), cout.tie(0), cout.sync_with_stdio(0);
int n, m;
cin >> n >> m;
vector<int> v(m);
for (int &i : v) cin >> i;
vector<ll> f(n + 1);
for (int i = 0; i + 1 < m; i++) {
int a = v[i], b = v[i + 1];
if (a > b) swap(a, b);
if (a == b) continue;
range_add(f, 1, a - 1, b - a);
range_add(f, b + 1, n, b - a);
range_add(f, a, a, b - 1);
range_add(f, b, b, a);
range_add(f, a + 1, b - 1, b - a - 1);
}
partial_sum(f.begin(), f.end(), f.begin());
for (int i = 1; i <= n; i++) cout << f[i] << ' ';
return cout << endl, 0;
}
| 11 | CPP |
n,x,y=(int(i) for i in input().split())
l=[(n//2,n//2),(n//2,(n//2)+1),((n//2)+1,n//2),((n//2)+1,(n//2)+1)]
if((x,y) in l):
print("NO")
else:
print("YES") | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t, nr, ng, nb;
cin >> t;
while (t--) {
cin >> nr >> ng >> nb;
vector<long long int> r(nr), g(ng), b(nb);
for (int i = 0; i < int(nr); i++) cin >> r[i];
for (int i = 0; i < int(ng); i++) cin >> g[i];
for (int i = 0; i < int(nb); i++) cin >> b[i];
sort(r.begin(), r.end());
sort(g.begin(), g.end());
sort(b.begin(), b.end());
long long int respuesta = 4000000000000000000;
long long int combinaciones[4];
long long int maxg, ming, maxb, minb;
int gM, gm, bM, bm;
for (int i = 0; i < int(nr); i++) {
gM = lower_bound(g.begin(), g.end(), r[i]) - g.begin();
bM = lower_bound(b.begin(), b.end(), r[i]) - b.begin();
gM = gM < ng ? gM : ng - 1;
bM = bM < nb ? bM : nb - 1;
maxg = g[gM];
maxb = b[bM];
gm = upper_bound(g.begin(), g.end(), r[i]) - g.begin();
bm = upper_bound(b.begin(), b.end(), r[i]) - b.begin();
if (gm) gm--;
if (bm) bm--;
ming = g[gm];
minb = b[bm];
combinaciones[0] = (r[i] - maxg) * (r[i] - maxg) +
(maxg - maxb) * (maxg - maxb) +
(maxb - r[i]) * (maxb - r[i]);
combinaciones[1] = (r[i] - maxg) * (r[i] - maxg) +
(maxg - minb) * (maxg - minb) +
(minb - r[i]) * (minb - r[i]);
combinaciones[2] = (r[i] - ming) * (r[i] - ming) +
(ming - maxb) * (ming - maxb) +
(maxb - r[i]) * (maxb - r[i]);
combinaciones[3] = (r[i] - ming) * (r[i] - ming) +
(ming - minb) * (ming - minb) +
(minb - r[i]) * (minb - r[i]);
for (int j = 0; j < int(4); j++)
respuesta = min(respuesta, combinaciones[j]);
}
for (int i = 0; i < int(ng); i++) {
gM = lower_bound(r.begin(), r.end(), g[i]) - r.begin();
bM = lower_bound(b.begin(), b.end(), g[i]) - b.begin();
gM = gM < nr ? gM : nr - 1;
bM = bM < nb ? bM : nb - 1;
maxg = r[gM];
maxb = b[bM];
gm = upper_bound(r.begin(), r.end(), g[i]) - r.begin();
bm = upper_bound(b.begin(), b.end(), g[i]) - b.begin();
if (gm) gm--;
if (bm) bm--;
ming = r[gm];
minb = b[bm];
combinaciones[0] = (g[i] - maxg) * (g[i] - maxg) +
(maxg - maxb) * (maxg - maxb) +
(maxb - g[i]) * (maxb - g[i]);
combinaciones[1] = (g[i] - maxg) * (g[i] - maxg) +
(maxg - minb) * (maxg - minb) +
(minb - g[i]) * (minb - g[i]);
combinaciones[2] = (g[i] - ming) * (g[i] - ming) +
(ming - maxb) * (ming - maxb) +
(maxb - g[i]) * (maxb - g[i]);
combinaciones[3] = (g[i] - ming) * (g[i] - ming) +
(ming - minb) * (ming - minb) +
(minb - g[i]) * (minb - g[i]);
for (int j = 0; j < int(4); j++)
respuesta = min(respuesta, combinaciones[j]);
}
for (int i = 0; i < int(nb); i++) {
gM = lower_bound(g.begin(), g.end(), b[i]) - g.begin();
bM = lower_bound(r.begin(), r.end(), b[i]) - r.begin();
gM = gM < ng ? gM : ng - 1;
bM = bM < nr ? bM : nr - 1;
maxg = g[gM];
maxb = r[bM];
gm = upper_bound(g.begin(), g.end(), b[i]) - g.begin();
bm = upper_bound(r.begin(), r.end(), b[i]) - r.begin();
if (gm) gm--;
if (bm) bm--;
ming = g[gm];
minb = r[bm];
combinaciones[0] = (b[i] - maxg) * (b[i] - maxg) +
(maxg - maxb) * (maxg - maxb) +
(maxb - b[i]) * (maxb - b[i]);
combinaciones[1] = (b[i] - maxg) * (b[i] - maxg) +
(maxg - minb) * (maxg - minb) +
(minb - b[i]) * (minb - b[i]);
combinaciones[2] = (b[i] - ming) * (b[i] - ming) +
(ming - maxb) * (ming - maxb) +
(maxb - b[i]) * (maxb - b[i]);
combinaciones[3] = (b[i] - ming) * (b[i] - ming) +
(ming - minb) * (ming - minb) +
(minb - b[i]) * (minb - b[i]);
for (int j = 0; j < int(4); j++)
respuesta = min(respuesta, combinaciones[j]);
}
cout << respuesta << '\n';
}
return 0;
}
| 10 | CPP |
n=int(input())
table=list()
for i in range(n):
t=list()
for j in range(n):
if j==0 or i==0:
t.append(1)
else:
x=table[i-1][j]+t[j-1]
t.append(x)
table.append(t)
maxi=list()
for k in table:
maxi.append(max(k))
print(max(maxi))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int c, d, n, m, k;
scanf("%d%d%d%d%d", &c, &d, &n, &m, &k);
int ret = n * m * d;
for (int i = 0; i <= m; i++) {
for (int j = 0; j <= n * m; j++) {
if (n * i + j + k >= n * m) {
ret = min(ret, c * i + d * j);
}
}
}
cout << ret << endl;
return 0;
}
| 7 | CPP |
from sys import stdin,stdout
def sin():
return stdin.readline().rstrip()
def listInput():
return list(map(int,sin().split()))
def printBS(li):
if not li: return
for i in range(len(li)-1):
stdout.write("%d "%(li[i]))
stdout.write("%d\n"%(li[-1]))
s=sin()
s1=sin()
pos=0
for i in range(len(s1)):
if s[pos]==s1[i]:
pos+=1
print(pos+1) | 7 | PYTHON3 |
#pragma GCC optimize("Ofast")
#include<bits/stdc++.h>
#define ll long long
#define test(t) ll int t; cin>>t; while(t--)
#define F(i,L,R) for(ll int i=L;i<R;i++)
#define F2(i,L,R) for(ll int i=L;i>=R;i--)
#define get1(a) ll int a; cin>>a;
#define get2(a,b) ll int a,b; cin>>a>>b;
#define get3(a,b,c) ll int a,b,c; cin>>a>>b>>c;
#define getstr(s) string s; cin>>s;
#define pb push_back
#define mp make_pair
#define MAX 1000000001
#define yesnoprinter(cnt) if(cnt==true){cout<<"YES\n";} else{cout<<"NO\n";}
using namespace std;
int main()
{
ios_base::sync_with_stdio(0);
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
test(t)
{
get1(n);
getstr(s);
int i=0;
while(i<n && s[i]!='*')
{
i++;
}
s=s.substr(i);
while(s.back()=='.')
{
s.pop_back();
}
// cout<<s<<"\n";
if(s.size()==0)
{
cout<<"0\n";
continue;
}
n=s.size();
vector<ll int> left(n,0),right(n,0);
left[0]=0,left[n-1]=0,right[0]=0,right[n-1]=0;
ll int ast=1;
F(i,1,n)
{
if(s[i]=='*')
{
left[i]=left[i-1];
ast++;
}
else
{
left[i]=ast+left[i-1];
}
}
ast=1;
for(ll int i=n-2;i>=0;i--)
{
if(s[i]=='*')
{
right[i]=right[i+1];
ast++;
}
else
{
right[i]=ast+right[i+1];
}
}
ll int ans=-1;
// for(auto it: left)
// {
// cout<<it<<" ";
// }
// cout<<"\n";
// for(auto it: right)
// {
// cout<<it<<" ";
// }
// cout<<"\n";
for(int i=0;i<n-1;i++)
{
if(ans==-1)
{
ans=left[i]+right[i+1];
}
else
{
ans=min(ans,left[i]+right[i+1]);
}
// cout<<left[i]<<" ";
}
if(ans==-1)
{
cout<<"0\n";
}
else
{
cout<<ans<<"\n";
}
}
return 0;
} | 11 | CPP |
#include<bits/stdc++.h>
using namespace std;
string str , ans[6003]; int L;
string solve(int id){
if(id == 2 * L) return string();
if(ans[id].size()) return ans[id];
if(str[id] == 'a'){
int sum = 0 , pos = id;
while(pos < 2 * L && sum <= 0) sum += str[pos++] == 'a' ? -1 : 1;
if(pos == 2 * L){
queue < int > stk; int r = -1;
for(int i = id ; i < 2 * L ; ++i)
if(str[i] == 'a') stk.push(i);
else{if(stk.front() > r){r = i; ans[id] += "ab";} stk.pop();}
}
else ans[id] = solve(pos - 1);
}
else{
int sum = 1 , pos = id + 1;
while(pos < 2 * L && sum > 0) sum += str[pos++] == 'a' ? -1 : 1;
string temp = solve(pos); int num = (pos - id) / 2;
for(int i = 0 ; i <= num ; ++i){
int cnta = 0 , cntb = 0; string now;
for(int j = id ; j < pos ; ++j)
if(str[j] == 'a' && ++cnta > i) now += 'a';
else if(str[j] == 'b' && ++cntb > i) now += 'b';
now += temp; if(ans[id] < now) ans[id] = now;
}
}
return ans[id];
}
int main(){cin >> L >> str; solve(0); cout << ans[0]; return 0;} | 0 | CPP |
for i in range(int(input())):
_ , mov = list(map(int,input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
for i in range(mov):
b[b.index(max(b))],a[a.index(min(a))]=sorted([b[b.index(max(b))],a[a.index(min(a))]])
print(sum(a))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, a[90], f[3200][90][90];
int main() {
scanf("%d", &n);
int num = 0;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (x) a[++num] = i;
}
memset(f, 63, sizeof(f));
f[0][0][0] = 0;
for (int i = 1; i <= num; i++) {
f[0][i][a[i]] =
f[0][i - 1][a[i - 1]] + (a[i] - a[i - 1] - 1) * (a[i] - a[i - 1] - 1);
}
for (int i = 1; i <= n * (n - 1) / 2; i++) {
f[i][0][0] = 0;
for (int j = 1; j <= num; j++) {
for (int k = 1; k <= n; k++) {
if (abs(k - a[j]) > i) continue;
f[i][j][k] = f[i - 1][j][k];
for (int l = 0; l <= n; l++) {
f[i][j][k] = min(f[i][j][k], f[i - abs(k - a[j])][j - 1][l] +
(k - l - 1) * (k - l - 1));
}
}
}
}
for (int i = 0; i <= n * (n - 1) / 2; i++) {
int mn = 0x3f3f3f3f;
for (int j = 0; j <= n; j++) mn = min(mn, f[i][num][j] + (n - j) * (n - j));
printf("%d ", ((n - num) * (n - num) - mn) / 2);
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long sum = 0;
vector<long long> a(n);
for (long long i = 0; i < n; ++i) {
cin >> a[i];
sum += a[i];
}
vector<long long> prime;
for (long long i = 2; i * i <= sum; ++i) {
if (sum % i == 0) {
prime.push_back(i);
while (sum % i == 0) sum /= i;
}
}
if (sum > 1) prime.push_back(sum);
long long ans = LLONG_MAX;
for (long long i : prime) {
long long now = 0;
long long cnt = 0;
for (long long j = 0; j < n; ++j) {
cnt += a[j];
now += min(cnt % i, i - cnt % i);
}
ans = min(ans, now);
}
cout << (ans == LLONG_MAX ? -1 : ans) << endl;
return 0;
}
| 11 | CPP |
n=int(input())
a=[int(x) for x in input().strip().split(' ')]
c=[0,0]
fg=0
for i in range(n):
if a[i]==25:
c[0]+=1
elif a[i]==50:
c[1]+=1
if c[0]>0:
c[0]-=1
else:
print("NO")
fg=1
break;
else:
if c[1]>0 and c[0]>0:
c[1]-=1
c[0]-=1
elif c[0]>2:
c[0]-=3
else:
print("NO")
fg=1
break
if fg==0:
print("YES") | 7 | PYTHON3 |
Subsets and Splits