solution
stringlengths 10
159k
| difficulty
int64 0
3.5k
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, x, b[1000] = {0};
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> x;
for (int j = x - 1; j < n; j++) {
if (b[j] == 0) {
b[j] = x;
}
}
}
for (int i = 0; i < n; i++) cout << b[i] << ' ';
return 0;
}
| 900 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector")
using namespace std;
using lli = long long;
using ld = long double;
using ii = pair<int, int>;
using vi = vector<int>;
const ld eps = 1e-9;
int sgn(ld a) { return (a > eps) - (a < -eps); }
struct Pt {
ld x, y;
explicit Pt(ld x = 0, ld y = 0) : x(x), y(y) {}
Pt operator+(Pt p) const { return Pt(x + p.x, y + p.y); }
Pt operator-(Pt p) const { return Pt(x - p.x, y - p.y); }
Pt operator*(ld k) const { return Pt(x * k, y * k); }
Pt operator/(ld k) const { return Pt(x / k, y / k); }
ld dot(Pt p) const { return x * p.x + y * p.y; }
ld cross(Pt p) const { return x * p.y - y * p.x; }
ld norm() const { return x * x + y * y; }
ld length() const { return sqrtl(norm()); }
ld angle() const {
ld ang = atan2(y, x);
return ang + (ang < 0 ? 2 * acos(-1) : 0);
}
Pt perp() const { return Pt(-y, x); }
Pt unit() const { return (*this) / length(); }
Pt rotate(ld angle) const {
return Pt(x * cos(angle) - y * sin(angle), x * sin(angle) + y * cos(angle));
}
int dir(Pt a, Pt b) const { return sgn((a - *this).cross(b - *this)); }
int cuad() const {
if (x > 0 && y >= 0) return 0;
if (x <= 0 && y > 0) return 1;
if (x < 0 && y <= 0) return 2;
if (x >= 0 && y < 0) return 3;
return -1;
}
bool operator==(Pt p) const {
return (abs((x) - (p.x)) <= +eps) && (abs((y) - (p.y)) <= +eps);
}
bool operator!=(Pt p) const {
return (!(abs((x) - (p.x)) <= +eps)) || (!(abs((y) - (p.y)) <= +eps));
}
};
using Poly = vector<Pt>;
Poly a;
int n, m;
bool contains(const Poly &a, Pt p) {
int lo = 1, hi = int(a.size()) - 1;
if (a[0].dir(a[lo], a[hi]) > 0) swap(lo, hi);
if (p.dir(a[0], a[lo]) >= 0 || p.dir(a[0], a[hi]) <= 0) return false;
while (abs(lo - hi) > 1) {
int mid = (lo + hi) >> 1;
(p.dir(a[0], a[mid]) > 0 ? hi : lo) = mid;
}
return p.dir(a[lo], a[hi]) < 0;
}
int main() {
cin.tie(0)->sync_with_stdio(0), cout.tie(0);
while (cin >> n) {
a = Poly(n);
for (auto &p : a) cin >> p.x >> p.y;
cin >> m;
bool inside = true;
while (m--) {
Pt p;
cin >> p.x >> p.y;
if (!inside) continue;
if (!contains(a, p)) inside = false;
}
cout << (inside ? "YES" : "NO") << '\n';
}
return 0;
}
| 2,100 | CPP |
input()
events = input().strip()
nor = 10 # number of rooms
alist = [0] * 10
for e in events:
if e == 'L':
for i in range(nor):
if alist[i] == 0:
alist[i] = 1
break
elif e == 'R':
for i in range(nor):
if alist[nor - i - 1] == 0:
alist[nor - i - 1] = 1
break
else:
alist[ int(e) ] = 0
ans = ''
for x in alist:
ans += str(x)
print(ans) | 800 | PYTHON3 |
# -*- coding: utf-8 -*-
"""
Created on Wed Feb 12 19:45:42 2020
@author: Lenovo
"""
#https://codeforces.com/problemset/problem/894/A
def Qaq():
text = input()
output = 0
for i in range(len(text)):
if text[i] == "Q":
for j in range(i+1, len(text)):
if text[j] == "A":
for x in range(j+1, len(text)):
if text[x] == "Q":
output += 1
print(output)
return
Qaq()
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int A[300100];
int e[300100];
int lp[300100];
int dist[300100];
vector<int> G[300100];
vector<int> V;
inline void unionS(int x, int y) { A[y] = x; }
inline int findS(int x) { return (A[x] < 0) ? x : (A[x] = findS(A[x])); }
void elp(int u) {
int init = u;
dist[u] = 0;
V = *new vector<int>();
queue<int> Q;
Q.push(u);
while (Q.size() > 0) {
int x = Q.front();
V.push_back(x);
Q.pop();
for (int i = (0); i < (G[x].size()); i++) {
if (dist[G[x][i]] > dist[x] + 1) {
dist[G[x][i]] = dist[x] + 1;
Q.push(G[x][i]);
}
}
}
for (int i = (0); i < (V.size()); i++) {
if (dist[V[i]] < dist[u]) u = V[i];
dist[V[i]] = 10000000;
}
dist[u] = 0;
Q.push(u);
while (Q.size() > 0) {
int x = Q.front();
Q.pop();
for (int i = (0); i < (G[x].size()); i++) {
if (dist[G[x][i]] > dist[x] + 1) {
dist[G[x][i]] = dist[x] + 1;
Q.push(G[x][i]);
}
}
}
lp[init] = 0;
for (int i = (0); i < (V.size()); i++) {
lp[init] = (((lp[init]) > (dist[V[i]])) ? (lp[init]) : (dist[V[i]]));
}
e[init] = (lp[init] + 1) / 2;
}
int main() {
ios::sync_with_stdio(false);
for (int i = (1); i < (300100); i++) {
A[i] = -1;
dist[i] = 10000000;
}
cin >> n >> m >> q;
int u, v;
for (int i = (1); i <= (m); i++) {
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
if (findS(u) != findS(v)) {
unionS(findS(u), findS(v));
}
}
for (int i = (1); i <= (n); i++) {
if (A[i] < 0) {
elp(i);
}
}
int op, x, y;
for (int qq = (1); qq <= (q); qq++) {
cin >> op;
if (op == 1) {
cin >> x;
cout << lp[findS(x)] << endl;
} else {
cin >> x >> y;
if (findS(x) != findS(y)) {
x = findS(x);
y = findS(y);
lp[x] =
(((lp[x]) >
((((lp[y]) > (e[x] + e[y] + 1)) ? (lp[y]) : (e[x] + e[y] + 1))))
? (lp[x])
: ((((lp[y]) > (e[x] + e[y] + 1)) ? (lp[y])
: (e[x] + e[y] + 1))));
e[x] = (lp[x] + 1) / 2;
unionS(x, y);
}
}
}
return 0;
}
| 2,100 | CPP |
# cook your dish here
for _ in range(int(input())):
n,a,b = map(int,input().split())
t = ""
g = 97
f = 0
for i in range(n):
t+=chr(g+f)
f+=1
f = f%b
print(t) | 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxm = 2e5 + 7;
const int maxn = 1e6 + 7;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
int n;
double a, b, x, y, ans, v;
double dis() { return sqrt(pow(a - x, 2) + pow(b - y, 2)); }
int main() {
cin >> a >> b >> n;
ans = INF;
for (int i = 1; i <= n; i++) {
cin >> x >> y >> v;
ans = min(ans, dis() / v);
}
printf("%lf\n", ans);
return 0;
}
| 900 | CPP |
import sys
n=int(input())
for i in range(n):
str=input()
if(len(str)<=10):
print(str)
else:
t=str[0]
p=int(len(str)-2)
q=str[len(str)-1]
print(t,p,q,end='\n',sep="")
| 800 | PYTHON3 |
t=int(input())
while(t):
t-=1
n=int(input())
if n==0:
print(0)
if n==1:
print(1)
else:
print(int(n/2)+1) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
vector<int> v;
int main() {
while (scanf("%d%d%d", &n, &m, &k) != EOF) {
v.clear();
for (int i = 0; i < k; i++) v.push_back(1);
v.push_back(n);
for (int i = 1; i < k; i++) v.push_back(n + 1);
int l = 2 * n;
if (k == 1) l--;
while (l < n + m + 1) {
v.push_back(l);
if (l + 1 == n + m + 1) break;
for (int i = 1; i < k; i++) v.push_back(l + 1);
l += n;
if (k == 1) l--;
}
printf("%d\n%d", v.size(), v[0]);
for (int i = 1; i < v.size(); i++) printf(" %d", v[i]);
puts("");
}
return 0;
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct __timestamper {};
vector<int> t, h;
vector<vector<int>> g;
vector<long long> dp[3];
long long calc(int v, int p, int out) {
long long& ans = dp[out][v];
if (ans != -1) {
return ans;
}
if (p == -1 && out != 1) {
return -1;
}
if (p != -1 && out == 1) {
return -1;
}
if (p != -1 && out == 0 && h[v] < h[p]) {
return -1;
}
if (p != -1 && out == 2 && h[v] > h[p]) {
return -1;
}
ans = numeric_limits<long long>::max();
long long cur = 0;
vector<long long> changes;
int cnt0 = (out == 0), cnt2 = (out == 2);
for (int u : g[v]) {
if (u == p) continue;
long long ans0 = calc(u, v, 2);
long long ans2 = calc(u, v, 0);
if (ans0 == -1) {
cur += ans2;
cnt2++;
} else {
cur += ans0;
cnt0++;
if (ans2 != -1) {
changes.push_back(ans2 - ans0);
}
}
}
sort(changes.begin(), changes.end());
for (int i = 0; i <= (int)changes.size(); i++) {
ans = min(ans, cur + max(cnt0, cnt2) * 1LL * t[v]);
if (i != (int)changes.size()) {
cnt0--;
cnt2++;
cur += changes[i];
}
};
return ans;
}
int main() {
int n;
while (scanf("%d", &n) == 1) {
t = vector<int>(n);
h = vector<int>(n);
g = vector<vector<int>>(n);
dp[0] = dp[1] = dp[2] = vector<long long>(n, -1);
for (int i = 0; i < n; i++) {
scanf("%d", &t[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &h[i]);
}
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
--a, --b;
g[a].push_back(b);
g[b].push_back(a);
}
printf("%lld\n", calc(0, -1, 1));
}
return 0;
}
| 2,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int n, a[N][N];
deque<int> p[N];
int ptr[N], mat[N];
bool vis[N][N];
void upd(int x) {
while (!p[x].empty() && vis[x][p[x].front()]) p[x].pop_front();
while (!p[x].empty() && vis[x][p[x].back()]) p[x].pop_back();
}
inline void del(int x, int y) { vis[x][y] = vis[y][x] = 1; }
void add(int x, int y) {
mat[y] = x;
while (1) {
upd(y);
if (p[y].empty()) {
cout << -1 << endl;
exit(0);
}
if (p[y].back() != x)
del(p[y].back(), y);
else
break;
}
}
int nxt(int x) {
upd(x);
int y = p[x].front();
p[x].pop_front();
upd(x);
p[x].push_front(y);
return mat[p[x][1]];
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
if (n & 1) {
cout << -1 << endl;
return 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i != j) cin >> a[i][j], p[i].push_back(j);
}
sort(p[i].begin(), p[i].end(),
[&](int x, int y) { return a[i][x] < a[i][y]; });
}
queue<int> q;
for (int i = 1; i <= n; i++) q.push(i);
while (!q.empty()) {
int x = q.front();
q.pop();
while (1) {
upd(x);
int y = p[x].front(), z = mat[y];
if (z && a[y][z] < a[y][x]) assert(0);
if (z) {
mat[y] = 0;
q.push(z);
}
add(x, y);
break;
}
}
int cur = 1;
while (1) {
while (cur <= n) {
upd(cur);
if (p[cur].size() > 1)
break;
else
++cur;
}
if (cur > n) {
for (int i = 1; i <= n; i++) cout << p[i].front() << endl;
return 0;
}
vector<int> c1, c2;
int x = cur, y = cur;
do x = nxt(x), y = nxt(nxt(y));
while (x != y);
do c1.push_back(y), y = nxt(y);
while (x != y);
for (auto &i : c1) {
int y = p[i][0];
c2.push_back(y);
mat[y] = 0;
del(i, y);
}
for (int i = 0; i < int(c1.size()); i++)
add(c1[i], c2[(i + 1) % c1.size()]);
}
return 0;
}
| 3,500 | CPP |
for _ in range(int(input())):
n,m=map(int,input().split())
a=list(map(int,input().split()))
p=set(map(int,input().split()))
mx,hmx=0,0
for i in range(len(a)):
ai=a[i]
#print(i,mx,hmx)
if i+1 in p:
hmx=max(hmx,ai)
if mx>ai:
print('NO')#1',mx,ai,i)
break
elif i in p:
if mx>ai:
print('NO')#2',mx,ai,i)
break
mx=max(mx,hmx,ai)
else:
mx=max(mx,hmx)
if mx>ai:
print('NO')#3',mx,ai,i)
break
mx=ai
else:
print('YES')
| 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long add(long long x, long long y) {
x += y;
while (x >= 998244353) x -= 998244353;
while (x < 0) x += 998244353;
return x;
}
long long mul(long long x, long long y) { return (x * 1ll * y) % 998244353; }
long long binpow(long long x, long long y) {
long long z = 1;
while (y > 0) {
if (y % 2 == 1) z = mul(z, x);
x = mul(x, x);
y /= 2;
}
return z;
}
long long inv(long long x) { return binpow(x, 998244353 - 2); }
long long divide(long long x, long long y) { return mul(x, inv(y)); }
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k;
cin >> n >> k;
vector<long long> a(k);
for (long long i = 0; i < (long long)k; ++i) cin >> a[i];
vector<long long> last(n + 1, -1), fst(n + 1, k);
for (long long i = 1; i <= k; i++) {
last[a[i - 1]] = i;
}
for (long long i = k; i >= 1; i--) {
fst[a[i - 1]] = i;
}
long long ans = 0;
for (long long i = 1; i <= n; i++) {
for (long long j = max(1ll, i - 1); j <= min(i + 1, n); j++) {
if (j == i) {
if (last[i] == -1) ans += 1;
} else
ans += (last[i] <= fst[j]);
}
}
cout << ans << endl;
return 0;
}
| 1,500 | CPP |
import math
def calc(p,r):
l = math.radians(180.0 / p)
return (math.sin(l) * r) / (1.0 - math.sin(l))
p, r = [float(i) for i in input().split()]
print(calc(p,r))
| 1,200 | PYTHON3 |
import math
n = input().split(' ')
r = int(n[1])
n = int(n[0])
rad = ((90 - 180/n)*math.pi)/180
R = r/(1/math.cos(rad)-1)
print(R) | 1,200 | PYTHON3 |
n, m, k = [int(n) for n in input().split()]
a = [int(n) for n in input().split()]
instructions = []
temp = []
for i in range(n+1):
temp.append(0)
for i in range(m):
instructions.append([int(n) for n in input().split()])
queries = []
for i in range(m+1):
queries.append(0)
for i in range(k):
x, y = [int(n) for n in input().split()]
x-=1
y-=1
queries[x]+=1
queries[y+1]-=1
num_queries = 0
for i in range(m):
num_queries += queries[i]
temp[instructions[i][0]-1] += num_queries*instructions[i][2]
temp[instructions[i][1]] -= num_queries*instructions[i][2]
#print(temp[0]+a[0], end=" ")
x = temp[0]
print(x + a[0], end=" ")
for i in range(1, n):
x += temp[i]
print(x + a[i], end=" ")
print() | 1,400 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, kk, dp[1005][1005][12][2];
string s, t;
int main() {
cin >> n >> m >> kk;
cin >> s >> t;
s = '#' + s;
t = '*' + t;
for (int k = 1; k <= kk; ++k) {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
dp[i][j][k][0] = max(dp[i][j - 1][k][0], dp[i - 1][j][k][0]);
if (s[i] == t[j]) {
dp[i][j][k][1] =
max(dp[i - 1][j - 1][k][1] + 1, dp[i - 1][j - 1][k - 1][0] + 1);
}
dp[i][j][k][0] = max(dp[i][j][k][0], dp[i][j][k][1]);
}
}
}
cout << dp[n][m][kk][0];
return 0;
}
| 1,900 | CPP |
s=input()
t=input()
check=1
n=len(t)
for i in range(len(s)):
if s[i]!=t[n-i-1]:
check=0
break
print("YES" if check==1 else "NO")
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c, n, e[200010];
int tal = 0, bc = 0, ac = 0, ab = 0, a0 = 0, b0 = 0, c0 = 0;
int main() {
scanf("%d%d%d%d", &n, &a, &b, &c);
if (a > b) swap(a, b);
if (a > c) swap(a, c);
if (b > c) swap(b, c);
for (int i = 1; i <= n; i++) {
scanf("%d", &e[i]);
if (e[i] > a + b + c) {
printf("-1\n");
return 0;
}
if (e[i] > b + c)
tal++;
else if (e[i] > a + c)
bc++;
else if (a + b > c) {
if (e[i] > a + b)
ac++;
else if (e[i] > c)
ab++;
else if (e[i] > b)
c0++;
else if (e[i] > a)
b0++;
else
a0++;
} else {
if (e[i] > c)
ac++;
else if (e[i] > a + b)
c0++;
else if (e[i] > b)
ab++;
else if (e[i] > a)
b0++;
else
a0++;
}
}
bool deb = false;
if (deb) printf("%d %d %d %d %d %d %d\n", a0, b0, c0, ab, ac, bc, tal);
int ans = 0;
ans += tal;
ans += bc;
a0 -= bc;
ans += ac;
if (b0 < ac) {
a0 -= ac - b0;
b0 = 0;
} else
b0 -= ac;
if (a0 < 0) a0 = 0;
if (a + b > c) {
if (deb) printf("%d %d %d %d:%d\n", a0, b0, c0, ab, ans);
ans += ab;
if (c0 >= ab)
c0 -= ab;
else {
ab -= c0;
c0 = 0;
if (b0 >= ab)
b0 -= ab;
else {
ab -= b0;
b0 = 0;
a0 -= ab;
}
}
if (deb) printf("%d %d %d: %d\n", a0, b0, c0, ans);
if (a0 < 0) a0 = 0;
int tmp = c0;
if (b0 >= tmp)
ans += c0, b0 -= tmp, a0 -= tmp;
else {
tmp -= b0;
a0 -= b0;
b0 = 0;
if (a0 < 0) a0 = 0;
if (a0 >= 2 * tmp)
a0 -= 2 * tmp, ans += c0;
else {
tmp -= (a0 + 1) / 2;
a0 = 0;
ans += (c0 - tmp) + (tmp + 1) / 2;
}
}
if (a0 < 0) a0 = 0;
if (deb) printf("%d %d %d: %d\n", a0, b0, c0, ans);
ans += (b0 + 1) / 2;
if (a0 >= (b0 + 1) / 2)
a0 -= (b0 + 1) / 2;
else
a0 = 0;
if (b0 & 1) a0--;
ans += (a0 + 2) / 3;
printf("%d\n", ans);
} else {
int t1 = b0, tmp = b0;
if (c0 > b0)
c0 -= b0, a0 -= b0, ans += b0;
else {
tmp -= c0, a0 -= c0;
c0 = 0;
if (ab > tmp)
ab -= tmp, a0 -= tmp, ans += b0;
else {
tmp -= ab, a0 -= ab;
ab = 0;
ans += b0 - tmp + (tmp + 1) / 2;
a0 -= (tmp + 1) / 2;
if (tmp & 1) a0--;
}
}
if (a0 < 0) a0 = 0;
int ntt = (a0 + 1) / 2, nt2 = (c0 + ab);
if (nt2 > ntt) {
ans += ntt;
if (c0 > ntt)
c0 -= ntt;
else {
ntt -= c0;
c0 = 0;
ab -= ntt;
}
if (ab < 0) ab = 0;
ans += c0;
ab -= c0;
if (ab < 0) ab = 0;
ans += (ab + 1) / 2;
} else {
ans += nt2;
a0 -= nt2 * 2;
ans += (a0 + 2) / 3;
}
printf("%d\n", ans);
}
return 0;
}
| 2,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool v[4001][4001];
int per[2][4001];
int sum[4001];
int main() {
int c, n, c1, c2;
int rmin = 4010;
cin >> c >> n;
for (int i = 0; i < n; i++) {
cin >> per[0][i] >> per[1][i];
v[per[0][i]][per[1][i]] = true;
v[per[1][i]][per[0][i]] = true;
sum[per[0][i]]++;
sum[per[1][i]]++;
}
for (int i = 0; i < n; i++) {
c1 = per[0][i];
c2 = per[1][i];
for (int j = 1; j <= c; j++) {
if (v[c1][j] && v[c2][j]) {
if (sum[c1] + sum[c2] + sum[j] < rmin) {
rmin = sum[c1] + sum[c2] + sum[j];
}
}
}
}
if (rmin == 4010) {
rmin = 5;
}
cout << rmin - 6;
return 0;
}
| 1,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int a[N], b[N], c[2 * N];
vector<int> e[2 * N];
void dfs(int v, int p) {
c[v] = p;
for (auto u : e[v]) {
if (!c[u]) dfs(u, 3 - p);
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", a + i, b + i);
for (int i = 1; i <= n; i++) {
e[i * 2].push_back(i * 2 - 1);
e[i * 2 - 1].push_back(i * 2);
e[a[i]].push_back(b[i]);
e[b[i]].push_back(a[i]);
}
for (int i = 1; i <= 2 * n; i++)
if (!c[i]) dfs(i, 1);
for (int i = 1; i <= n; i++) printf("%d %d\n", c[a[i]], c[b[i]]);
return 0;
}
| 2,600 | CPP |
t=int(input())
for _ in range(t):
n=int(input())
if n==1:
print(-1)
else:
print(int('2'+'3'*(n-1))) | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long dp1[100005], dp2[100005];
long long ans1[100005], ans2[100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
std::vector<long long> a(n + 1), b(m + 1);
long long x;
for (long long int i = 1; i < n + 1; i++) {
cin >> a[i];
dp1[i] = dp1[i - 1] + a[i];
}
for (long long int i = 1; i < m + 1; i++) {
cin >> b[i];
dp2[i] = dp2[i - 1] + b[i];
}
cin >> x;
for (long long int i = 1; i < n + 1; i++) {
long long cur = 1e18;
for (long long int j = i; j < n + 1; j++) {
long long z1 = dp1[j] - dp1[j - i];
cur = min(cur, z1);
}
ans1[i] = cur;
}
for (long long int i = 1; i < m + 1; i++) {
long long cur = 1e18;
for (long long int j = i; j < m + 1; j++) {
long long z1 = dp2[j] - dp2[j - i];
cur = min(cur, z1);
}
ans2[i] = cur;
}
long long ans = -1;
for (long long int i = 1; i < n + 1; i++) {
for (long long int j = 1; j < m + 1; j++) {
if ((ans1[i] * ans2[j]) <= x) {
ans = max(ans, i * j);
}
}
}
if (ans != -1)
cout << ans;
else
cout << "0";
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
int getFours(int* ones, int* twos, int* fours, int num) {
if (*fours >= num) {
*fours -= num;
num = 0;
} else {
num -= (*fours);
*fours = 0;
}
if (*twos >= num * 2) {
*twos -= num * 2;
num = 0;
} else {
num -= (*twos) / 2;
*twos = (*twos) % 2;
}
if (*ones >= num * 4) {
*ones -= num * 4;
} else {
return 1;
}
return 0;
}
int main() {
int n, k, a[105];
scanf("%d%d", &n, &k);
for (int i = 0; i < k; i++) {
scanf("%d", &a[i]);
}
sort(&a[0], &a[k], greater<int>());
int fours, twos, ones;
fours = n;
twos = 2 * n;
ones = 0;
for (int i = 0; i < k; i++) {
switch (a[i] % 4) {
case 0:
if (getFours(&ones, &twos, &fours, a[i] / 4) == 1) {
printf("NO\n");
return 0;
}
break;
case 1:
if (getFours(&ones, &twos, &fours, a[i] / 4) == 1) {
printf("NO\n");
return 0;
}
if (ones > 0) {
ones--;
} else {
if (fours > 0) {
fours--;
twos++;
} else {
if (twos > 0) {
twos--;
} else {
printf("NO\n");
return 0;
}
}
}
break;
case 2:
if (getFours(&ones, &twos, &fours, a[i] / 4) == 1) {
printf("NO\n");
return 0;
}
if (twos > 0) {
twos--;
} else {
if (fours > 0) {
fours--;
ones++;
} else {
if (ones > 1) {
ones -= 2;
} else {
printf("NO\n");
return 0;
}
}
}
break;
case 3:
if (getFours(&ones, &twos, &fours, a[i] / 4) == 1) {
printf("NO\n");
return 0;
}
if (ones > 0 && twos > 0) {
ones--;
twos--;
} else {
if (ones > 2) {
ones -= 3;
} else {
if (getFours(&ones, &twos, &fours, 1) == 1) {
printf("NO\n");
return 0;
}
}
}
break;
default:
break;
}
}
printf("YES\n");
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, q;
long long a[200010], c[200010], k;
long long f, s;
int ef(int le, int ri, long long va) {
if (le >= ri) {
return le;
}
int mid = (le + ri) / 2;
if (c[mid] < va) {
if (c[mid + 1] > va) return mid;
return ef(mid + 1, ri, va);
} else if (c[mid] > va) {
return ef(le, mid - 1, va);
} else {
return mid;
}
}
int main() {
scanf("%d%d", &n, &q);
int i, j;
for (i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
c[i] = c[i - 1] + a[i];
}
for (i = 1; i <= q; i++) {
scanf("%I64d", &k);
if (s + k >= c[n]) {
printf("%d\n", n);
s = 0;
} else if (s + k < c[1]) {
printf("%d\n", n);
s = s + k;
} else {
s = s + k;
int pos = ef(1, n, s);
printf("%d\n", n - pos);
}
}
return 0;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long int logx = 30;
const long long int N = 2e5 + 5;
const long long int INF = 1e18 + 5;
const long long int mod = 321555123;
const double PI = 3.14159265358979323846;
inline long long int mul(long long int a, long long int b) {
return (a * 1ll * b) % mod;
}
inline long long int sub(long long int a, long long int b) {
long long int c = a - b;
if (c < 0) c += mod;
return c;
}
inline long long int add(long long int a, long long int b) {
long long int c = a + b;
if (c > mod) c -= mod;
return c;
}
template <typename T>
T power(T x, T y, long long int m) {
T ans = 1;
while (y > 0) {
if (y & 1LL) ans = (ans * x) % m;
y >>= 1ll;
x = (x * x) % m;
}
return ans % m;
}
vector<long long int> g[N];
long long int n, in[N], uu[N], vv[N], siz[N], a[N];
long long int root(long long int x) {
while (x != a[x]) {
a[x] = a[a[x]];
x = a[x];
}
return x;
}
void unionx(long long int x, long long int y) {
long long int rx = root(x);
long long int ry = root(y);
if (rx == ry) {
return;
} else {
if (siz[rx] < siz[ry]) {
a[rx] = ry;
siz[ry] += siz[rx];
siz[rx] = 0;
} else {
a[ry] = rx;
siz[rx] += siz[ry];
siz[ry] = 0;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long int m;
cin >> n >> m;
long long int maxi = 0, idx;
vector<pair<long long int, long long int> > ans;
for (long long int i = 1; i <= n; i++) {
a[i] = i;
siz[i] = 1;
}
pair<long long int, pair<long long int, long long int> > p[m];
for (long long int i = 0; i < m; i++) {
long long int u, v;
cin >> u >> v;
uu[i] = u;
vv[i] = v;
in[u]++;
in[v]++;
g[u].push_back(v);
g[v].push_back(u);
maxi = max(maxi, max(in[u], in[v]));
}
for (long long int i = 1; i <= n; i++) {
if (maxi == in[i]) {
idx = i;
break;
}
}
for (auto i : g[idx]) {
if (root(idx) == root(i)) {
continue;
}
unionx(idx, i);
ans.push_back(make_pair(idx, i));
}
for (long long int i = 0; i < m; i++) {
long long int u = uu[i];
long long int v = vv[i];
if (root(u) == root(v)) {
continue;
}
unionx(u, v);
ans.push_back(make_pair(u, v));
}
for (auto i : ans) {
cout << i.first << " " << i.second << endl;
}
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[2000000];
int main() {
int n, d;
cin >> n >> d;
for (int i = 0; i < n; i++) scanf("%d", a + i);
long long res = 0;
for (int i = 0, j = 0; i < n; i++) {
for (; j + 1 < n && a[j + 1] - a[i] <= d; j++)
;
if (j - i > 1) res += 1LL * (j - i) * (j - i - 1) / 2;
}
cout << res << endl;
return 0;
}
| 1,300 | CPP |
# ataux test
import math
for _ in range(int(input())):
n, k = map(int, input().split())
a = [*map(int, input().split())]
x = a[1] - a[0]
for i in range(1, n):
x = math.gcd(a[i]-a[0], x)
k -= a[0]
if k % x == 0:
print("YES")
else:
print("NO")
| 1,800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long int n, sol = 1, acc, t;
int C[1003][1003];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie();
C[0][0] = 1;
for (int i = 1; i <= 1000; i++)
for (int j = 0; j <= i; j++)
C[i][j] =
(j == 0 ? 1LL : 1LL * C[i - 1][j - 1] + C[i - 1][j]) % 1000000007;
cin >> n;
while (n-- && cin >> t) {
acc += t;
sol = 1LL * sol * C[acc - 1][t - 1] % 1000000007;
}
cout << sol % 1000000007;
return 0;
}
| 1,500 | CPP |
import sys
sys.setrecursionlimit(10**5)
int1 = lambda x: int(x)-1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.buffer.readline())
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def LI1(): return list(map(int1, sys.stdin.buffer.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]
def BI(): return sys.stdin.buffer.readline().rstrip()
def SI(): return sys.stdin.buffer.readline().rstrip().decode()
# dij = [(0, 1), (-1, 0), (0, -1), (1, 0)]
dij = [(0, 1), (-1, 0), (0, -1), (1, 0), (1, 1), (1, -1), (-1, 1), (-1, -1)]
inf = 10**16
md = 998244353
# md = 10**9+7
n = II()
aa = []
for _ in range(n):
ca = SI().split()
if ca[0] == "+":
aa.append(int(ca[1]))
else:
aa.append(-1)
def solve(ti):
dp = [[0]*(n+1) for _ in range(n)]
dp[0][0] = 1
for i in range(n-1):
for j in range(i+1):
pre = dp[i][j]
if pre == 0: continue
if i < ti:
if aa[i] > 0:
if aa[i] <= aa[ti]:
dp[i+1][j+1] = (dp[i+1][j+1]+pre)%md
else:
dp[i+1][j] = (dp[i+1][j]+pre)%md
else:
nj = max(0, j-1)
dp[i+1][nj] = (dp[i+1][nj]+pre)%md
dp[i+1][j] = (dp[i+1][j]+pre)%md
else:
if aa[i+1] > 0:
if aa[i+1] < aa[ti]:
dp[i+1][j+1] = (dp[i+1][j+1]+pre)%md
else:
dp[i+1][j] = (dp[i+1][j]+pre)%md
elif j:
dp[i+1][j-1] = (dp[i+1][j-1]+pre)%md
dp[i+1][j] = (dp[i+1][j]+pre)%md
# print(ti)
# p2D(dp)
res = 0
for a in dp[-1]:
res += a
res %= md
return res
ans = 0
for i in range(n):
if aa[i] < 0: continue
ans += solve(i)*aa[i]%md
ans %= md
print(ans)
| 2,200 | PYTHON3 |
def count_banana_cost(k, w):
""" """
cost = 0
for i in range(1, w + 1):
cost += (i * k)
return cost
def must_borrow(cost):
""" Return 0 if must borrow or return borrow number """
if n - banana_cost > 0:
return 0
return abs(n - banana_cost)
k, n, w = list(map(int, input().split()))
banana_cost = count_banana_cost(k, w)
print(must_borrow(banana_cost))
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e6 + 5;
const int MOD = 1e9 + 7;
long long bigmod(long long x, long long n) {
long long res = 1;
while (n > 0) {
if (n % 2 == 1) res = (res * x) % MOD;
x = (x * x) % MOD;
n /= 2;
}
return res;
}
long long fact[mx], inv[mx];
void prep(int k) {
fact[0] = 1;
for (int i = 1; i <= k; i++) fact[i] = (fact[i - 1] * i) % MOD;
for (int i = 1; i < 2005 && i <= k; i++) {
inv[i] = bigmod(fact[i], MOD - 2);
int x = k - i;
inv[x] = bigmod(fact[x], MOD - 2);
}
}
long long nCr(int n, int r) {
if (r > n) return 0;
if (r == 0 || r == n) return 1;
r = min(r, n - r);
long long res = fact[n];
res = (res * inv[r]) % MOD;
return (res * inv[n - r]) % MOD;
}
long long DP[1005][1005];
long long solve(int n, int x) {
if (x == 1) return 1;
if (n == 1) return 0;
if (DP[n][x] != -1) return DP[n][x];
long long res = (solve(n - 1, x) * x) % MOD + (solve(n - 1, x - 1) * x) % MOD;
return DP[n][x] = res % MOD;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int m, n, k;
cin >> n >> m >> k;
long long ans;
if (m == 1)
ans = bigmod(k, n);
else {
memset(DP, -1, sizeof(DP));
prep(k);
ans = 0;
for (int i = 1; i <= n && i <= k; i++) {
for (int j = 0; j <= i; j++) {
long long cnt = 1;
cnt = (cnt * nCr(k, 2 * i - j)) % MOD;
cnt = (cnt * nCr(2 * i - j, i - j)) % MOD;
cnt = (cnt * nCr(i, i - j)) % MOD;
cnt = (cnt * solve(n, i)) % MOD;
cnt = (cnt * solve(n, i)) % MOD;
cnt = (cnt * bigmod(j, n * m - 2 * n)) % MOD;
ans = (ans + cnt) % MOD;
}
}
}
cout << ans << endl;
return 0;
}
| 2,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1009;
int n;
int nxt[maxn][maxn];
int a[maxn];
bool dp[maxn][1 << 8][8];
bool can(int k) {
for (int i = 0; i < maxn; i++) {
for (int j = 0; j < (1 << 8); j++) {
for (int t = 0; t < 8; t++) {
dp[i][j][t] = false;
}
}
}
dp[1][0][0] = true;
for (int i = 1; i <= n; i++) {
for (int m = 0; m < (1 << 8); m++) {
for (int t = 0; t < 8; t++) {
if (!dp[i][m][t]) continue;
dp[i + 1][m][t] = true;
if (m & (1 << a[i])) continue;
if (nxt[i][k / 8] != -1) dp[nxt[i][k / 8]][m | (1 << a[i])][t] = true;
if (t < 7 && nxt[i][k / 8 + 1] != -1)
dp[nxt[i][k / 8 + 1]][m | (1 << a[i])][t + 1] = true;
}
}
}
return dp[n][(1 << 8) - 1][k % 8];
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
a[i]--;
}
for (int i = n; i >= 1; i--) {
nxt[i][1] = i;
nxt[i][2] = -1;
for (int j = n; j > i; j--) {
if (a[j] == a[i]) nxt[i][2] = j;
}
}
for (int i = n; i >= 1; i--) {
for (int j = 3; j <= n; j++) {
if (nxt[i][2] == -1) {
nxt[i][j] = -1;
} else {
nxt[i][j] = nxt[nxt[i][2]][j - 1];
}
}
}
int ans = 0;
for (int x = 0; x < 8; x++) {
for (int i = 1; i <= n; i++) {
if (a[i] == x) {
ans++;
break;
}
}
}
int low = 8, high = n;
while (low <= high) {
int mid = (low + high) / 2;
if (can(mid)) {
ans = mid;
low = mid + 1;
} else {
high = mid - 1;
}
}
printf("%d", ans);
}
| 2,200 | CPP |
#include<bits/stdc++.h>
using namespace std;
const int inf=0x3f3f3f3f;
const int B=5e7;
typedef long long ll;
#define N 6233
inline ll read(){
ll x=0,f=1;
char c=getchar();
while(c<'0'||c>'9'){
if(c=='-')f=-1;
c=getchar();
}
while(c>='0'&&c<='9'){
x=(x<<1)+(x<<3)+c-'0';
c=getchar();
}
return x*f;
}
namespace Maxflow{
int head[N],ecnt,S,T,dep[N];
struct Edge{
int nxt,to,val;
}edge[N<<2];
void add(int a,int b,int c){
edge[++ecnt]={head[a],b,c};
head[a]=ecnt;
}
void adde(int a,int b,int c){
add(a,b,c),add(b,a,0);
}
void init(int _S,int _T){
ecnt=1;
memset(head,0,sizeof(head));
S=_S,T=_T;
}
queue<int> q;
bool bfs(){
memset(dep,0,sizeof(dep));
q.push(S);
dep[S]=1;
while(!q.empty()){
int u=q.front();
q.pop();
for(int i=head[u];i;i=edge[i].nxt){
int v=edge[i].to;
if(edge[i].val&&!dep[v]){
dep[v]=dep[u]+1;
q.push(v);
}
}
}
return dep[T]>0;
}
int dfs(int u,int limit){
if(u==T)return limit;
int flow=0;
for(int i=head[u];i&&limit;i=edge[i].nxt){
int v=edge[i].to;
if(dep[v]==dep[u]+1&&edge[i].val){
int k=dfs(v,min(limit,edge[i].val));
edge[i].val-=k;
edge[i^1].val+=k;
flow+=k;
limit-=k;
}
}
if(!flow)dep[u]=inf;
return flow;
}
int Dinic(){
int maxflow=0;
while(bfs()){
maxflow+=dfs(S,inf);
}
return maxflow;
}
}
int n,m,val[N];
inline int ID(int x,int y){
return (x-1)*(n+1)+y+1;
}
int main(){
n=read(),m=read();
Maxflow::init(n*n*n+123,n*n*n+124);
for(int i=1;i<=m;++i){
int u=read(),v=read(),w=read();
val[u]+=w,val[v]-=w;
for(int j=0;j<n;++j){
Maxflow::adde(ID(v,j),ID(u,j+1),inf);
}
}
for(int i=1;i<=n;++i){
for(int j=0;j<n;++j){
Maxflow::adde(ID(i,j),ID(i,j+1),val[i]*j+B);
}
}
for(int i=1;i<=n;++i){
Maxflow::adde(Maxflow::S,ID(i,0),inf);
Maxflow::adde(ID(i,n),Maxflow::T,inf);
}
Maxflow::Dinic();
Maxflow::bfs();
for(int i=1;i<=n;++i){
for(int j=n;j>=0;--j){
if(Maxflow::dep[ID(i,j)]){
printf("%d ",j);
break;
}
}
}
return 0;
}
| 2,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int smallpos, largepos, i, j, n;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> j;
if (j == 1) smallpos = i;
if (j == n) largepos = i;
}
if ((smallpos == n && largepos == 1) || (smallpos == 1 && largepos == n)) {
cout << n - 1 << endl;
} else
cout << max(max(smallpos - 1, n - smallpos),
max(largepos - 1, n - largepos))
<< endl;
return 0;
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC target("popcnt")
void MP() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
const long long MAX = (long long)1e6 + 15;
const long long MAX2 = 31;
const long double EPS = 1e-8;
const long long sigma = 128;
const long long delta = (long long)1e6 + 3;
const long long MAXB = (1 << 10);
inline bool gt(long long a, long long i) { return (a >> i) & 1; }
const long long MOD = (long long)1e9 + 7;
long long add(long long a, long long b) {
if (a + b > MOD) return a + b - MOD;
return a + b;
}
void solve() {
long long n;
cin >> n;
long long dp[2][4];
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (long long i = (1); i < n + 1; ++i) {
for (long long j = 0; j < 4; ++j) {
dp[i % 2][j] = 0;
for (long long k = 0; k < 4; ++k) {
if (j != k) dp[i % 2][j] = add(dp[i % 2][j], dp[(i + 1) % 2][k]);
}
}
}
cout << (dp[n % 2][0]) << '\n';
}
signed main() {
MP();
solve();
}
| 1,500 | CPP |
def valid(s):
n = len(s)
if n == 1:
return True
for i in range(1,n):
if abs(ord(s[i]) - ord(s[i-1])) == 1:
return False
return True
def solve():
result = []
for _ in range(int(input())):
s = sorted(input())
half1 = []
half2 = []
turn = 1
i = 0
while i < len(s):
j = i
while j < len(s) and s[j] == s[i]:
j += 1
if j == i:
j += 1
if turn == 1:
half1 += s[i:j]
turn = 2
else:
half2 += s[i:j]
turn = 1
i += (j - i)
ans = "No answer"
if not half2:
if valid(half2):
ans = ''.join(half1)
elif valid(half1) and valid(half2):
if abs(ord(half1[-1]) - ord(half2[0])) != 1:
ans = ''.join(half1 + half2)
elif abs(ord(half1[0]) - ord(half2[-1])) != 1:
ans = ''.join(half2 + half1)
result.append(ans)
print ('\n'.join(result))
if __name__ == "__main__":
solve()
| 1,800 | PYTHON3 |
r=input;n=int(r());
l=lambda:map(int, r().split())
s = set([*l()][1:]).union([*l()][1:])
print(["Oh, my keyboard!","I become the guy."][len(s)==n]) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct point {
point() {}
point(point a, point b) : x(b.x - a.x), y(b.y - a.y) {}
int x, y;
};
int operator*(const point& a, const point& b) { return a.x * b.x + a.y * b.y; }
int operator-(const point& a, const point& b) {
return ((a.x - b.x) * (a.x - b.x)) + ((a.y - b.y) * (a.y - b.y));
}
point p[10];
int r[2][10];
bool used[10];
bool check1(int s) {
for (int i = 0, j = 1, k = 2; i < 4; i++) {
if (point(p[r[s][j]], p[r[s][i]]) * point(p[r[s][j]], p[r[s][k]]) != 0)
return false;
j++;
if (j == 4) j = 0;
k++;
if (k == 4) k = 0;
}
for (int i = 0, j = 1; i < 4; i++) {
if ((p[r[s][i]] - p[r[s][j]]) == 0) return false;
j++;
if (j == 4) j = 0;
}
return true;
}
bool check2(int s) {
if (!check1(s)) return false;
for (int i = 1; i < 4; i++)
if ((p[r[s][i - 1]] - p[r[s][i]]) != (p[r[s][0]] - p[r[s][3]]))
return false;
return true;
}
void rec(int c, int s) {
if (c == 4) {
c = 0;
s++;
}
if (s == 2) {
if (check2(0) && check1(1)) {
cout << "YES";
for (int j = 0; j < 2; j++) {
cout << endl;
for (int i = 0; i < 4; i++) cout << r[j][i] + 1 << " ";
}
exit(0);
}
return;
}
for (int i = 0; i < 8; i++)
if (!used[i]) {
used[i] = true;
r[s][c] = i;
rec(c + 1, s);
used[i] = false;
}
}
int main() {
for (int i = 0; i < 8; i++) cin >> p[i].x >> p[i].y;
rec(0, 0);
cout << "NO";
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
int T, n;
int solve() {
int sum = 0, f = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> f;
sum += f;
}
int div = sum / n;
if (div * n == sum) {
cout << 0 << "\n";
} else if (div * n != sum)
cout << 1 << "\n";
return 0;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> T;
while (T--) solve();
return 0;
}
| 800 | CPP |
import sys
n = int(sys.stdin.readline())
arr =list(map(int, sys.stdin.readline().split()))
ans = [0] * n
m = len(arr)
for i in range(m - 1, -1, -1):
if i == m - 1:
ans[i] = arr[i] // 2
ans[n - 1 - i] = arr[i] - ans[i]
else:
if arr[i + 1] < arr[i]:
ans[n - i - 1] = ans[n - i - 2] + abs(arr[i + 1] - arr[i])
ans[i] = arr[i] - ans[n - i - 1]
else:
ans[n - i - 1] = ans[n - i - 2]
ans[i] = arr[i] - ans[n - i - 1]
print(' '.join(map(str, ans))) | 1,300 | PYTHON3 |
N,S = map(int, input().split())
movable = S-N
if movable < N:
print("NO")
else:
print("YES")
q, r = divmod(movable, N)
array = [q+1]*(N-r) + [q+2]*r
print(*array)
print(1)
| 1,400 | PYTHON3 |
#include <bits/stdc++.h>
inline void in(int &MAGNUS) { scanf("%d", &MAGNUS); }
inline void out(int MAGNUS) { printf("%d\n", MAGNUS); }
inline void in(int &MAGNUS, int &CLAR) { scanf("%d%d", &MAGNUS, &CLAR); }
inline void out(int MAGNUS, int CLAR) { printf("%d %d\n", MAGNUS, CLAR); }
inline void inl(long long &LIV) { scanf("%lld", &LIV); }
inline void inl(long long &LIV, long long &MART) {
scanf("%lld%lld", &LIV, &MART);
}
inline void outl(long long LIV) { printf("%lld\n", LIV); }
inline void outl(long long LIV, long long MART) {
printf("%lld %lld\n", LIV, MART);
}
using namespace std;
int main() {
int N;
in(N);
double ans = 0.00;
for (int i = 1; i <= N; i++) {
double x, y;
cin >> x >> y;
ans += y;
}
ans /= N;
printf("%.3lf\n", 5 + ans);
return 0;
}
| 2,200 | CPP |
s=list(input())
for i in range(len(s)):
if(s[i].isupper()):
s[i]=chr(ord(s[i])+32)
i=0
c=len(s)
while(i<c):
if(s[i]=="a" or s[i]=="e" or s[i]=="i" or s[i]=="o" or s[i]=="u" or s[i]=="y"):
del(s[i])
c-=1
i-=1
i+=1
i=0
c=2*len(s)
while(i<c):
s.insert(i,".")
i+=2
q=""
for i in s:
q+=i
print(q) | 1,000 | PYTHON3 |
import sys
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return map(int, minp().split())
def solve():
n = mint()
b = [None]*n
i = 0
for v in mints():
b[i] = (v, i)
i += 1
b.sort()
c = [0]*n # how many moves to sort all after i with same value + all below
ans = int(1e9)
s = None
i = 0
while i < n:
j = i + 1
v = b[i][0]
while j < n and b[j][0] == v:
j += 1
if s is None:
for z in range(i, j):
c[z] = j - z - 1
ans = n - j
else:
k = s
while k < e and b[k][1] < b[i][1]:
k += 1
for z in range(i, j - 1):
c[z] = j - z - 1 + e
if k == e:
c[j - 1] = c[e - 1]
else:
c[j - 1] = s + e - k
v = n - i - j
for z in range(i, j):
while k < e and b[k][1] < b[z][1]:
k += 1
ans = min(ans, z + (e if k == s else c[k - 1]) + v)
s, e, i = i, j, j
print(ans)
for i in range(mint()):
solve()
| 2,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 2 * acos(0);
bool solve(double m, double d, double h, double v, double e) {
double r = d / 2.0;
double vol = r * r * pi * h;
double a = r * r * pi * e * m;
return vol + a - m * v <= 0.0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
double d, h, v, e;
cin >> d >> h >> v >> e;
double lo = 0.0, hi = 1e4 + 1;
for (int i = 0; i < 30; i++) {
double mid = lo + (hi - lo) / 2;
if (solve(mid, d, h, v, e))
hi = mid;
else
lo = mid;
}
if (hi > 1e4) {
cout << "NO" << '\n';
return 0;
}
cout << "YES" << '\n';
cout.precision(12);
cout << fixed << hi << '\n';
return 0;
}
| 1,100 | CPP |
import math
n=int(input())
p=int(1)
t=int(1)
k=int(1)
for i in range(2,10000):
p+=i
k+=p
if k>n:
print(t)
exit(0)
t+=1 | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const double pi =
3.14159265358979323846264338327950288419716939937510582097494459;
int dX[] = {0, 0, 1, -1, 0};
int dY[] = {1, -1, 0, 0, 0};
string alpha = "abcdefghijklmnopqrstuvwxyz";
const int MOD = 1000000007;
const int N = 150;
int n;
double arr[N];
int main() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> arr[i];
sort(arr, arr + n);
reverse(arr, arr + n);
double cur = 0, pre = 1, ans = 0;
for (int i = 0; i < n; ++i) {
double p = arr[i];
cur = cur * (1 - p) + pre * p;
pre *= (1 - p);
ans = max(cur, ans);
}
printf("%.12f", ans);
return 0;
}
| 1,800 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
using namespace std;
const double eps = 1e-12;
const double PI = acos(-1.0);
const long long INF = 1e18;
const long long MOD = 1e9 + 7;
const long long nax = 5e5 + 5;
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
bool isPowerOfTwo(long long int x) { return x && (!(x & (x - 1))); }
void solve() {
long long int i, n, ans, k, m, j;
cin >> n;
m = n / 36;
k = n / 36;
if (n % 36 != 0) m += 1;
if ((m * 36 - n) == 1) {
k += 1;
}
cout << k << " ";
n -= k * 36;
if (n < 0)
cout << "0";
else {
ans = n / 3;
if (n % 3 == 2) ans += 1;
cout << ans;
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long int t = 1, i;
while (t--) solve();
return 0;
}
| 1,400 | CPP |
from sys import stdin,stdout
nsum = lambda x:(x*(x+1))>>1
n,x = map(int, stdin.readline().split())
d = list(map(int, stdin.readline().split()))
presum_hugs = [nsum(d[0])]
presum_days = [d[0]]
for i in range(1,n):
presum_hugs.append(presum_hugs[-1] + nsum(d[i]))
presum_days.append(presum_days[-1] + d[i])
for i in range(n):
presum_hugs.append(presum_hugs[-1] + nsum(d[i]))
presum_days.append(presum_days[-1] + d[i])
ans=0
for start in range((n<<1)-1, n-1, -1):
hi=start
lo = hi-n+1
while lo+1<hi:
mid = (lo+hi)>>1
if presum_days[start]-presum_days[mid-1] > x:
lo = mid
if presum_days[start]-presum_days[mid-1] == x:
break
else:
hi = mid-1
if presum_days[start]-presum_days[hi-1]>=x:
lo=hi
temp = presum_hugs[start] - presum_hugs[lo-1]
extra = (presum_days[start]-presum_days[lo-1])-x
if extra>0:
temp -= nsum(extra)
ans=max(ans, temp)
stdout.write(str(ans) + "\n")
| 1,900 | PYTHON3 |
str = input()
n = len(str)
lst = []
for i in range(int(n/2)+1):
lst.append(str[2*i])
lst.sort()
print('+'.join(lst))
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 2 * acos(0);
int n, r, h;
long long v[100050], aux[100050], ind[100050], bit[100050];
void update(int x, long long val) {
while (x <= n) {
bit[x] = max(bit[x], val);
x += x & -x;
}
}
long long query(int x) {
long long ret = 0;
while (x > 0) {
ret = max(ret, bit[x]);
x -= x & -x;
}
return ret;
}
int main(int argc, char const *argv[]) {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d %d", &r, &h);
v[i] = (long long)r * r * h;
aux[i] = v[i];
}
sort(aux, aux + n);
for (int i = 0; i < n; ++i)
ind[i] = lower_bound(aux, aux + n, v[i]) - aux + 1;
for (int i = 0; i < n; ++i) update(ind[i], query(ind[i] - 1) + v[i]);
printf("%.10lf\n", query(n) * pi);
return 0;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n1, n2;
cin >> n1 >> n2;
int k1, k2;
cin >> k1 >> k2;
cout << ((n1 > n2) ? "First" : "Second") << endl;
return 0;
}
| 800 | CPP |
n = int(input())
m=n
n+=1
while '8' not in str(n):
n+=1
print(n-m) | 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int a[200009], pos[200009];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
pos[a[i]] = i;
}
int l = 0, r = 0, cur = pos[n], val = n;
l = cur - 1, r = cur + 1;
bool flag = 0;
while (val > 1) {
if ((l > 0 && (val - a[l]) == 1)) {
val--;
l--;
continue;
}
if ((r <= n && (val - a[r]) == 1)) {
val--;
r++;
continue;
}
flag = 1;
break;
}
if (flag)
cout << "NO\n";
else
cout << "YES\n";
}
| 1,000 | CPP |
n=int(input())
l=[]
for i in range(0,n):
s=input()
k=s[0:2]
o=s[3:5]
l.append(k)
l.append(o)
c=0
h=[]
d=[]
q=["++"]
for i in range(0,2*n):
if(l[i]=="OO"):
h=l[0:i]
d=l[(i+1):(2*n)]
q=h+q+d
break
else:
c+=1
if(c==2*n):
print("NO")
else:
print("YES")
for i in range(0,n):
print(q[2*i],end="|")
print(q[(2*i)+1]) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200100;
int n, k;
int a[maxn], f1[maxn], f2[maxn], l2[maxn];
bool full[maxn], visited[maxn];
vector<int> adj[maxn];
bool dfs(int x, int v) {
visited[x] = true;
if (a[x] >= v) full[x] = true;
int fre = 0, ere = 0, b2[2] = {0, 0}, tmp = 0;
for (int i = 0; i < adj[x].size(); i++)
if (!visited[adj[x][i]]) {
if (dfs(adj[x][i], v)) return true;
if (!full[adj[x][i]]) {
full[x] = false;
if (tmp == 0)
tmp = adj[x][i];
else
tmp = -1;
ere = max(ere, f1[adj[x][i]]);
} else
fre += f1[adj[x][i]];
if (l2[b2[0]] < l2[adj[x][i]]) {
b2[1] = b2[0];
b2[0] = adj[x][i];
} else if (l2[b2[1]] < l2[adj[x][i]])
b2[1] = adj[x][i];
}
if (a[x] >= v) {
if (full[x] && fre == 0) {
f1[x] = 1;
f2[x] = 1;
l2[x] = 0;
} else {
f1[x] = fre + ere + 1;
if (!full[x]) {
l2[x] = l2[b2[0]] + 1;
l2[x] = max(l2[x], f1[x]);
}
f2[x] = l2[b2[0]] + l2[b2[1]] + fre + 1;
if (tmp != -1) f2[x] = max(f2[x], fre + f2[tmp] + 1);
}
}
if (f1[x] >= k || f2[x] >= k || l2[x] >= k)
return true;
else
return false;
}
bool possible(int x) {
for (int i = 1; i <= n; i++) {
full[i] = false;
visited[i] = false;
f1[i] = 0;
f2[i] = 0;
l2[i] = 0;
}
return dfs(1, x);
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
int l = 1, r = 1e6, mid;
while (l <= r) {
mid = (l + r) / 2;
if (possible(mid))
l = mid + 1;
else
r = mid - 1;
}
while (mid > 0 && !possible(mid)) mid--;
while (possible(mid + 1)) mid++;
printf("%d", mid);
return 0;
}
| 2,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
int last;
bool illegal(int n, int tmp) {
if (n < last) return true;
if (n < 1000) return true;
if (n > 2011) return true;
int cnt = 0;
if (n / 1000 != tmp / 1000) cnt++;
if (n % 1000 / 100 != tmp % 1000 / 100) cnt++;
if (n % 100 / 10 != tmp % 100 / 10) cnt++;
if (n % 10 != tmp % 10) cnt++;
if (cnt > 1) return true;
return false;
}
int v[1200];
int main() {
int n;
scanf("%d", &n);
last = 1000;
int t;
for (int i = 0; i < n; i++) {
scanf("%d", &v[i]);
}
for (int i = 0; i < n; i++) {
for (t = last; t <= 2011; t++) {
if (!illegal(t, v[i])) {
v[i] = t;
last = t;
break;
}
}
if (t > 2011) {
puts("No solution");
return 0;
}
}
for (int i = 0; i < n; i++) {
printf("%d\n", v[i]);
}
return 0;
}
| 1,700 | CPP |
def isprime(n):
return all(n % i for i in range(2, int(n ** .5) + 1))
n = int(input())
if n == 2:
print(1)
elif n & 1 == 0:
print(2)
elif isprime(n):
print(1)
elif isprime(n - 2):
print(2)
else:
print(3) | 1,600 | PYTHON3 |
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
ma = max(a)
mi = min(a)
sums = set()
for i in range(n):
s = a[i]
for j in a[i + 1:]:
s += j
if mi <= s <= ma:
sums.add(s)
c = 0
for i in a:
if i in sums:
c += 1
print(c) | 1,500 | PYTHON3 |
n = int(input())
a = list(map(str, input().split()))
def func(x, y):
ln = len(y)
s = ''
for i in range(ln):
s = s + x[i] + y[i]
return int(s)
num = 0
for i in range(n):
# for j in range(n):
num += func(a[i], a[i])
print((num * n) % 998244353)
| 1,500 | PYTHON3 |
n = int(input())
s = list(map(int, input().split()))
t = False #even
for i in range(n):
for j in range(i + 1, n):
if s[i] > s[j]:
t = not t
m = int(input())
a = []
for h in range(m):
l, r = map(int, input().split())
if ((r - l + 1) / 2) % 2 == 1 or ((r - l + 1) / 2) % 2 == 1.5:
t = not t
a.append(['even', 'odd'][t])
print('\n'.join(a)) | 1,800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
vector<long long> v;
long long x, sum = 0;
for (long long i = 0; i < 3; i++) {
cin >> x;
v.push_back(x);
}
sort(v.begin(), v.end());
for (long long i = 0; i < 2; i++) {
sum += (v[i + 1] - v[i]);
}
cout << sum;
}
| 800 | CPP |
def pos(sa, k, l=0, r=None):
if r is None:
r = len(sa)
m = (l + r) // 2
if l == r:
return l
elif k > sa[m]:
return pos(sa, k, m + 1, r)
elif k < sa[m]:
return pos(sa, k, l, m)
else:
return m
def val(q):
inc = 0
slist = []
for i in q:
if not slist:
slist.append(i)
else:
p = pos(slist, i)
inc += p
slist.insert(p, i)
return inc
t = int(input())
for _ in range(t):
n, m = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
sights = sorted(list(set(a)))
bins = {i:[] for i in sights}
for i in range(len(a)):
bins[a[i]].append(i)
total_inc = 0
row = []
for i in sights:
b = bins[i]
z = 0
while z < len(b):
if len(row) + len(b) - z < m:
row += b[z:][::-1]
z = len(b)
else:
fz = z + m - len(row)
addition = b[z:fz][::-1]
row += addition
total_inc += val(row)
row = []
z = fz
print(total_inc)
| 1,600 | PYTHON3 |
k,b=list(map(int,input().split()))
a=list(map(int,input().split()))
c=0
d=1
for i in a:
c+=((i-d)%k)
d=i
print(c) | 1,000 | PYTHON3 |
import sys
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return map(int,minp().split())
def main():
n,k = mints()
a = [list(minp()) for i in range(3)]
w = [[False]*(n+1) for i in range(3)]
for j in range(3):
if a[j][0] == 's':
a[j][0] = '.'
w[j][0] = True
for i in range(n):
for j in range(3):
if w[j][i]:
if i*3+1>=n or a[j][i*3+1] == '.':
for z in range(max(j-1,0),min(j+2,3)):
if (i*3+1>=n or a[z][i*3+1] == '.') and (i*3+2>=n or a[z][i*3+2] == '.') and (i*3+3>=n or a[z][i*3+3] == '.'):
w[z][i+1] = True
can = w[0][n] or w[1][n] or w[2][n]
#print(w)
if can:
print("YES")
else:
print("NO")
t = mint()
for i in range(t):
main() | 1,700 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> vec[3005];
long long n, m;
long long bribe(long long now) {
long long ex = now - (long long)vec[1].size();
long long i, j, k, l, ret = 0;
priority_queue<long long, vector<long long>, greater<long long> > pq;
for (i = 2; i <= m; i++) {
l = vec[i].size();
for (j = now - 1; j < l; j++) {
ret += vec[i][j];
ex--;
if (ex < 0) return 1e17;
}
for (j = 0; j < now - 1 && j < l; j++) {
pq.push(vec[i][j]);
}
}
while (ex && !pq.empty()) {
ret += pq.top();
pq.pop();
ex--;
}
if (ex) return 1e17;
return ret;
}
int main() {
long long i, j, k, p;
scanf("%lld %lld", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%lld %lld", &k, &p);
vec[k].push_back(p);
}
for (i = 2; i <= m; i++) {
sort(vec[i].begin(), vec[i].end());
reverse(vec[i].begin(), vec[i].end());
}
long long res, ans = 1e17;
long long s = vec[1].size();
for (i = max(s, 1LL); i <= n; i++) {
res = bribe(i);
ans = min(ans, res);
}
printf("%lld\n", ans);
return 0;
}
| 1,700 | CPP |
n = int(input())
a = list(map(int, input().split()))
q = int(input())
for i in range(q):
x, y = map(int, input().split())
x -= 1
if x > 0:
a[x - 1] += y - 1
if x < n - 1:
a[x + 1] += a[x] - y
a[x] = 0
for i in range(n):
print(a[i]) | 800 | PYTHON3 |
###### ### ####### ####### ## # ##### ### #####
# # # # # # # # # # # # # ###
# # # # # # # # # # # # # ###
###### ######### # # # # # # ######### #
###### ######### # # # # # # ######### #
# # # # # # # # # # #### # # #
# # # # # # # ## # # # # #
###### # # ####### ####### # # ##### # # # #
# from __future__ import print_function # for PyPy2
from collections import Counter, OrderedDict
from itertools import permutations as perm
from fractions import Fraction
from collections import deque
from sys import stdin
from bisect import *
from heapq import *
from math import *
g = lambda : stdin.readline().strip()
gl = lambda : g().split()
gil = lambda : [int(var) for var in gl()]
gfl = lambda : [float(var) for var in gl()]
gcl = lambda : list(g())
gbs = lambda : [int(var) for var in g()]
mod = int(1e9)+7
inf = float("inf")
n, m = gil()
cat = [0] + gil()
adj = [[] for _ in range(n+1)]
for _ in range(n-1):
x, y = gil()
adj[x].append(y)
adj[y].append(x)
ans = 0
st = [(1, cat[1], cat[1])]
vis = [0]*(n+1)
while st:
p, cunsec, maxi = st.pop()
vis[p] = 1
if len(adj[p]) > 1 or p == 1:
for c in adj[p]:
if vis[c]:continue
newCunsec = (cunsec+1)*cat[c]
st.append((c, newCunsec, max(maxi, newCunsec)))
elif maxi <= m:
ans += 1
print(ans) | 1,500 | PYTHON3 |
#Problem Set L: Collaborated with Rudrnash Singh
n_k = list(map(int, input().split()))
if n_k[0] >= 1 and n_k[0] <= 1000:
n = n_k[0]
if n_k[1] >= 1 and n_k[1] <= 1000:
k = n_k[1]
def func1(n,k):
for i in range(n):
for j in range(k):
val = (i+j+1)%n
print(i+1, val+1)
if n < (2*k+1):
print("-1")
else:
print(n*k)
func1(n,k)
| 1,400 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
long long a, b;
cin >> a >> b;
long long ans = 0;
while (a > 0 && b > 0) {
ans += (a / b);
a %= b;
if (a == 0) break;
ans += (b / a);
b %= a;
}
cout << ans << endl;
return 0;
}
| 1,600 | CPP |
for _ in range(int(input())):
n,m = map(int,input().split())
ar = [int(i) for i in input().split()]
if sum(ar)==m:
print('YES')
else:
print('NO') | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct Vec {
long long x, y;
int index;
Vec(long long x, long long y) : x(x), y(y) {}
Vec operator+(const Vec &o) const { return Vec(x + o.x, y + o.y); }
Vec operator-(const Vec &o) const { return Vec(x - o.x, y - o.y); }
long long operator*(const Vec &o) const { return x * o.x + y * o.y; }
long long operator%(const Vec &o) const { return x * o.y - y * o.x; }
void println() { cout << "(" << x << ", " << y << ")\n"; }
bool operator<(const Vec &o) const {
if (x != o.x) return x < o.x;
return y < o.y;
}
};
bool leftOf(Vec a, Vec b, Vec pivot) { return (a - pivot) % (b - pivot) < 0; }
bool rightOf(Vec a, Vec b, Vec pivot) { return (a - pivot) % (b - pivot) > 0; }
int getIndexOfLeftmost(vector<Vec> points, Vec last) {
int best = 0;
for (int i = 1; i < points.size(); i++)
if (leftOf(points[i], points[best], last)) best = i;
return best;
}
int getIndexOfRightmost(vector<Vec> points, Vec last) {
int best = 0;
for (int i = 1; i < points.size(); i++)
if (rightOf(points[i], points[best], last)) best = i;
return best;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<Vec> points;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
points.push_back(Vec(x, y));
points[i].index = i;
}
string targetMoves;
cin >> targetMoves;
vector<Vec> chosen;
sort(points.begin(), points.end());
Vec pivot = points[0];
chosen.push_back(points[0]);
points.erase(points.begin());
for (int i = 0; i < targetMoves.size(); i++) {
int nextIndex;
if (targetMoves[i] == 'L') {
nextIndex = getIndexOfRightmost(points, pivot);
} else {
nextIndex = getIndexOfLeftmost(points, pivot);
}
chosen.push_back(points[nextIndex]);
pivot = points[nextIndex];
points.erase(points.begin() + nextIndex);
}
chosen.push_back(points[0]);
for (int i = 0; i < n; i++) {
cout << chosen[i].index + 1 << " \n"[i == n - 1];
}
return 0;
}
| 2,600 | CPP |
n = int(input())
RGB, RBG, GRB, GBR, BRG, BGR = n, n, n, n, n, n
s = input()
for i in range(n):
if i%3==0:
if s[i]=="R":
RGB -= 1
RBG -= 1
elif s[i]=="G":
GRB -= 1
GBR -= 1
else:
BRG -= 1
BGR -= 1
elif i%3==1:
if s[i]=="R":
GRB -= 1
BRG -= 1
elif s[i]=="G":
RGB -= 1
BGR -= 1
else:
RBG -= 1
GBR -= 1
else:
if s[i]=="R":
GBR -= 1
BGR -= 1
elif s[i]=="G":
RBG -= 1
BRG -= 1
else:
RGB -= 1
GRB -= 1
m = min(RBG, RGB, BRG, BGR, GRB, GBR)
print(m)
if m == RBG:
print("RBG"*(n//3)+"RBG"[:n%3])
elif m == RGB:
print("RGB"*(n//3)+"RGB"[:n%3])
elif m == BRG:
print("BRG"*(n//3)+"BRG"[:n%3])
elif m == BGR:
print("BGR"*(n//3)+"BGR"[:n%3])
elif m == GRB:
print("GRB"*(n//3)+"GRB"[:n%3])
elif m == GBR:
print("GBR"*(n//3)+"GBR"[:n%3])
| 1,300 | PYTHON3 |
def check(n):
arr = [0]*10
for i in n:
arr[int(i)]+=1
if arr[4]+ arr[7] == 4 or arr[4]+arr[7] == 7:
print("YES")
else:
print("NO")
n = input()
check(n) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
void solve() {
int n, ans = 0;
scanf("%d", &n);
vector<int> w(n);
for (int i = 0; i < n; i++) scanf("%d", &w[i]);
for (int s = 1; s < 2 * n + 1; s++) {
vector<bool> b(n, false);
int cnt = 0;
for (int i = 0; i < n; i++) {
if (b[i]) continue;
for (int j = 0; j < n; j++) {
if (i == j || b[j] || b[i]) continue;
if (w[i] + w[j] == s) {
b[i] = true;
b[j] = true;
cnt++;
}
}
}
if (ans < cnt) {
ans = cnt;
}
}
printf("%d\n", ans);
return;
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
solve();
}
}
| 1,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long r = n / k;
if (r % 2 == 0)
cout << "NO";
else
cout << "YES";
return 0;
}
| 800 | CPP |
x = input().split(" ")
count = 0
a = int(x[0])
b = int(x[1])
while a <= b:
a *= 3
b *= 2
count += 1
print(count) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
const int N = 101000;
int n, val[N], op[N], my[N], vis[N];
int main() {
scanf("%d", &n);
if (n % 2 == 1) return puts("-1"), 0;
for (int i = n / 2; i < n; i++) val[i] = 1, op[op[i] = i - n / 2] = i;
int x = 0;
vis[x] = 1;
while (1) {
if (my[x] || vis[(2 * x + (val[x] ^ 1)) % n]) {
x = (2 * x + val[x]) % n;
if (x == 0) break;
continue;
}
val[x] ^= 1;
val[op[x]] ^= 1;
my[x] = my[op[x]] = 1;
int y = (2 * x + val[x]) % n;
while (!vis[y]) {
vis[y] = 1;
y = (2 * y + val[y]) % n;
}
}
x = 0;
printf("0");
for (int i = 0; i < n; i++) {
x = (x * 2 + val[x]) % n;
printf(" %d", x);
}
puts("");
}
| 2,800 | CPP |
w = int(input())
if w > 2:
if w % 2 == 0:
ret = 'YES'
else:
ret = 'NO'
else:
ret = 'NO'
print(ret)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
int n;
char c[89];
int cnt;
int main() {
scanf("%d%s", &n, &c);
for (int i = 0; i < n; i++)
if (c[i] == '0') {
putchar(cnt + 48);
cnt = 0;
} else
cnt++;
putchar(cnt + 48);
return 0;
}
| 1,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int w, A[200001];
int main() {
scanf("%d %d\n", &n, &w);
for (int i = 0; i < 2 * n; i++) {
scanf("%d", &A[i]);
}
sort(A, A + 2 * n);
double optimal =
((A[0]) < (A[n] / (double)2) ? (A[0]) : (A[n] / (double)2)) * (double)n;
printf("%lf\n", ((optimal + (2.0 * optimal)) < ((double)w)
? (optimal + (2.0 * optimal))
: ((double)w)));
}
| 1,500 | CPP |
for j in range(int(input())):
n,k=tuple(map(int,input().split()))
a=list(map(int,input().split()))
b=list(map(int,input().split()))
a.sort()
b.sort()
for i in range(k):
if a[i]<b[-(i+1)]:
a[i]=b[-(i+1)]
else:
break
print(sum(a)) | 800 | PYTHON3 |
x = int(input())
count=0
for i in range(0,x):
inp1 = list(map(int,input().split()))
if(inp1.count(1)>1):
count= count+1
print(count)
| 800 | PYTHON3 |
def main():
for _ in range(int(input())):
x,y,a,b = map(int,input().split())
if (y-x) %(a+b) == 0:
n = abs(y-x) //(a+b)
print(n)
else:
print('-1')
main()
| 800 | PYTHON3 |
for _ in range(int(input())):
n = int(input())
d1,d2 = {},{}
l = []
for i in range(n):
x,y = map(int, input().split())
if x in d1:
d1[x]+=1
else:
d1[x]=1
if y in d2:
d2[y]+=1
else:
d2[y]=1
l.append([x,y])
ans = n*(n-1)*(n-2)//6
for i in range(n):
ans -= (d1[l[i][0]]-1)*(d2[l[i][1]]-1)
print(ans)
| 1,700 | PYTHON3 |
def calculaResultado(qtdBranco, qtdAdj, valor1, valor2):
result1 = qtdBranco*valor1 + qtdAdj*valor2
result2 = qtdBranco*valor1 + qtdAdj*2*valor1
if(result1 <= result2):
print(result1)
else:
print(result2)
numeroTestes = int(input())
for count in range(0, numeroTestes):
linhas, colunas, valor1, valor2 = [int(i) for i in input().split()]
qtdBranco = 0
qtdAdj = 0
for linha in range(0, linhas):
linhaInput = input()
linhaInput = linhaInput.replace(' ','')
indice = 0
while(indice < colunas):
if linhaInput[indice] == '.':
qtdBranco += 1
if indice+1 < colunas:
if linhaInput[indice+1] == '.':
qtdAdj += 1
qtdBranco -= 1
indice+=1
indice+=1
calculaResultado(qtdBranco, qtdAdj, valor1, valor2)
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
char s[5005], t[5005];
int a[5005][5005], i, j, ans;
int main(void) {
gets(s);
gets(t);
for (i = 0; s[i]; i++)
for (j = 0; t[j]; j++)
a[i + 1][j + 1] =
(a[i + 1][j] + (t[j] == s[i]) * (a[i][j] + 1)) % 1000000007;
for (i = 0; s[i]; i++) ans = (ans + a[i + 1][j]) % 1000000007;
printf("%d\n", ans);
}
| 1,700 | CPP |
def sum_of_all(n: int) -> int:
if n % 2 == 0:
return (n // 2) * (n + 1)
else:
return ((n + 1) // 2) * n
def sum_of_powers(n: int) -> int:
sum = 0
current_power = 1
while current_power <= n:
sum += current_power
current_power *= 2
return sum
if __name__ == "__main__":
t = int(input())
for i in range(t):
n = int(input())
print(sum_of_all(n) - 2 * sum_of_powers(n))
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 1e6 + 5;
long long ans[N];
int a[66];
long long dp[66][1050];
long long dfs(int pos, int state, bool lead, bool limit, int k) {
if (pos == -1) return state == 0 && !lead;
if (!limit && !lead && dp[pos][state] != -1) return dp[pos][state];
int up = limit ? a[pos] : k - 1;
long long ans = 0;
for (int i = 0; i <= up; i++) {
ans += dfs(pos - 1, lead && i == 0 ? state : state ^ (1 << i),
lead && i == 0, limit && i == a[pos], k);
}
if (!limit && !lead) dp[pos][state] = ans;
return ans;
}
long long solve(int k, long long x) {
int pos = 0;
while (x) {
a[pos++] = x % k;
x /= k;
}
return dfs(pos - 1, 0, true, true, k);
}
struct Node {
long long le, ri;
int id;
Node() {}
Node(long long L, long long R, int ID) {
id = ID;
le = L;
ri = R;
}
};
vector<Node> b[15];
int main() {
int T;
cin >> T;
int id = 0;
while (T--) {
id++;
long long le, ri;
int k;
scanf("%d%lld%lld", &k, &le, &ri);
b[k].push_back(Node(le, ri, id));
}
for (int k = 2; k <= 10; k++) {
memset(dp, -1, sizeof(dp));
for (int i = 0; i < (int)b[k].size(); i++) {
ans[b[k][i].id] = solve(k, b[k][i].ri) - solve(k, b[k][i].le - 1);
}
}
for (int i = 1; i <= id; i++) {
printf("%lld\n", ans[i]);
}
}
| 2,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
long long a[n], i;
for (i = 0; i < n; i++) cin >> a[i];
if (n > m)
cout << 0 << endl;
else {
int ans = 1;
for (i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) ans = (ans * abs(a[i] - a[j])) % m;
cout << ans << endl;
}
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
static const int maxn = 100000 + 10;
inline int read() {
int k = 0, f = 1, c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = -1;
c = getchar();
}
while (c <= '9' && c >= '0') {
k = k * 10 + c - '0';
c = getchar();
}
return k * f;
}
static int root[maxn], tot;
struct node {
int l, r;
int sum;
} tree[maxn << 6];
void ins(int &u, int l, int r, int pos) {
if (!u) u = ++tot;
if (l == r) {
++tree[u].sum;
return;
}
int mid = (l + r) / 2;
if (pos <= mid)
ins(tree[u].l, l, mid, pos);
else
ins(tree[u].r, mid + 1, r, pos);
tree[u].sum = tree[tree[u].l].sum + tree[tree[u].r].sum;
}
int ask(int u, int l, int r, int s, int t) {
if (!u || l > t || r < s) return 0;
if (s <= l && r <= t) return tree[u].sum;
int mid = (l + r) / 2;
return ask(tree[u].l, l, mid, s, t) + ask(tree[u].r, mid + 1, r, s, t);
}
struct data {
int x, r, f;
inline void input() { x = read(), r = read(), f = read(); }
} a[maxn];
inline bool cmp(int i, int j) { return a[i].r > a[j].r; }
static int n, k, r[maxn];
int main() {
n = read(), k = read();
for (int i = 1; i <= n; ++i) a[i].input(), r[i] = i;
sort(r + 1, r + 1 + n, cmp);
long long ans = 0;
for (int u = 1; u <= n; ++u) {
int i = r[u];
for (int j = max(a[i].f - k, 1); j <= min(a[i].f + k, 10000); ++j)
ans += ask(root[j], 1, 1000000000, max(a[i].x - a[i].r, 1),
min(a[i].x + a[i].r, 1000000000));
ins(root[a[i].f], 1, 1000000000, a[i].x);
}
printf("%I64d", ans);
return 0;
}
| 2,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
int i;
scanf("%d%d", &n, &m);
i = 1;
while (true) {
if (m < i) {
break;
}
m -= i;
i++;
if (i == n + 1) {
i = 1;
}
}
printf("%d", m);
return 0;
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int y, k, n, x, c = 0;
vector<int> v;
cin >> y >> k >> n;
for (int x = k; x <= n; x += k) {
if (x > y) v.push_back(x - y);
}
if (v.size() == 0)
cout << "-1\n";
else {
for (int i = 0; i < v.size(); i++) cout << v[i] << " ";
}
return 0;
}
| 1,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int cnt, sum;
Node operator+(Node n) const { return {cnt + n.cnt, sum + n.sum}; }
};
int N, M, K;
vector<pair<int, int> > v[2][2], w;
Node seg[33000];
bool vis[200201];
void Update(int idx, int val, int n, int l, int r) {
if (r < idx || idx < l) return;
if (l == r) {
seg[n].cnt += 1 * val;
seg[n].sum += r * val;
return;
}
int mid = l + r >> 1;
Update(idx, val, n << 1, l, mid);
Update(idx, val, n << 1 | 1, mid + 1, r);
seg[n].cnt = seg[n << 1].cnt + seg[n << 1 | 1].cnt;
seg[n].sum = seg[n << 1].sum + seg[n << 1 | 1].sum;
}
Node Query(int L, int R, int n, int l, int r) {
if (r < L || R < l) return {0, 0};
if (L <= l && r <= R) return seg[n];
int mid = l + r >> 1;
return Query(L, R, n << 1, l, mid) + Query(L, R, n << 1 | 1, mid + 1, r);
}
int Kth(int k, int n, int l, int r) {
if (l == r) return r;
int mid = l + r >> 1;
if (k <= seg[n << 1].cnt) return Kth(k, n << 1, l, mid);
return Kth(k - seg[n << 1].cnt, n << 1 | 1, mid + 1, r);
}
int main() {
scanf("%d %d %d", &N, &M, &K);
for (int i = 1; i <= N; i++) {
int t, a, b;
scanf("%d %d %d", &t, &a, &b);
v[a][b].push_back({t, i});
w.push_back({t, i});
Update(t, 1, 1, 0, 10000);
}
if (v[1][1].size() + v[1][0].size() < K ||
v[1][1].size() + v[0][1].size() < K) {
printf("-1\n");
return 0;
}
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) sort(v[i][j].begin(), v[i][j].end());
sort(w.begin(), w.end());
int S11 = 0, S10 = 0, S01 = 0, j = 0, k = 0;
for (int i = 0; i < min(K, (int)v[1][1].size()); i++) {
S11 += v[1][1][i].first;
Update(v[1][1][i].first, -1, 1, 0, 10000);
}
int res = 2100000000, idx = -1;
for (int i = min(K, (int)v[1][1].size()); i >= 0; i--) {
if (v[1][0].size() < K - i || v[0][1].size() < K - i) continue;
if (i + K - i + K - i > M) continue;
while (j < K - i) {
S10 += v[1][0][j].first;
Update(v[1][0][j].first, -1, 1, 0, 10000);
j++;
}
while (k < K - i) {
S01 += v[0][1][k].first;
Update(v[0][1][k].first, -1, 1, 0, 10000);
k++;
}
int cnt, pos, kcnt, add;
cnt = M - (i + K - i + K - i);
if (cnt > 0) {
pos = Kth(cnt, 1, 0, 10000);
assert(pos >= 1);
kcnt = cnt - Query(0, pos - 1, 1, 0, 10000).cnt;
add = Query(0, pos - 1, 1, 0, 10000).sum + kcnt * pos;
} else
pos = kcnt = add = 0;
int val = S11 + S10 + S01 + add;
if (res > val) {
res = val;
idx = i;
}
if (i) {
S11 -= v[1][1][i - 1].first;
Update(v[1][1][i - 1].first, 1, 1, 0, 10000);
}
}
if (idx == -1) {
printf("-1\n");
return 0;
}
printf("%d\n", res);
vector<int> ans;
for (int i = 0; i < idx; i++) {
ans.push_back(v[1][1][i].second);
vis[v[1][1][i].second] = true;
}
for (int i = 0; i < K - idx; i++) {
ans.push_back(v[1][0][i].second);
vis[v[1][0][i].second] = true;
}
for (int i = 0; i < K - idx; i++) {
ans.push_back(v[0][1][i].second);
vis[v[0][1][i].second] = true;
}
int cnt = M - (idx + K - idx + K - idx);
for (int i = 0; i < w.size(); i++) {
if (vis[w[i].second]) continue;
if (cnt > 0) {
ans.push_back(w[i].second);
vis[w[i].second] = true;
cnt--;
}
}
for (int x : ans) printf("%d ", x);
return 0;
}
| 2,500 | CPP |
n=input()
line=input().split()
list0=[int(i) for i in line]
list0.sort()
list0=[str(i) for i in list0]
print(' '.join(list0)) | 900 | PYTHON3 |
def find_set(v):
if (v == parent[v]):
return v
parent[v] = find_set(parent[v])
return parent[v]
def union_sets(a,b):
a=find_set(a)
b=find_set(b)
if (a!=b):
if (size[a]<size[b]):
a,b = b,a
parent[b] = a
size[a] += size[b]
return True
return False
n = int(input())
parent = [0]*n
size = [1]*n
mustBreak=[]
mustConnect=[]
for i in range(n):
parent[i] = i
for i in range(n-1):
line=input().split(" ")
a = int(line[0])-1
b = int(line[1])-1
result= union_sets(a,b)
if not result:
mustBreak.append((a,b))
for i in range(n):
if parent[i] == i:
mustConnect.append(i)
lenMustBreak = len(mustBreak)
print(lenMustBreak)
if (lenMustBreak != 0):
for i in range(lenMustBreak):
print(str(mustBreak[i][0]+1)+" "+str(mustBreak[i][1]+1)+" "+str(mustConnect[i]+1)+" "+str(mustConnect[i+1]+1))
| 1,900 | PYTHON3 |
for _ in range(int(input())):
s = input()
l=[]
f=0
c=0
for i in s:
if f==0 and i=='1':
f=1
c+=1
elif f==0 and i=='0':
f,c=0,0
elif f==1 and i=='1':
c+=1
elif f==1 and i=='0':
l.append(c)
c,f=0,0
if c>0:
l.append(c)
l.sort(reverse=True)
s=0
for i in l[::2]:
s+=i
print(s) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200025;
const int64_t INF = 1e16;
const int MOD = 1000000007, K = 25;
int64_t modpow(int64_t e, int64_t p, int64_t m = MOD) {
int64_t r = 1;
for (e %= m; p; p >>= 1, e = e * e % m)
if (p & 1) r = r * e % m;
return r;
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n, M;
cin >> n >> M;
vector<int> v(n), ans;
queue<int> q;
for (int &x : v) cin >> x;
int H = 0;
for (int x : v) H = (H + modpow(K, x)) % MOD;
for (int x : v) q.push(M - x);
vector<int> cand = v;
for (int &x : cand) x = (x + v[0]) % M;
sort(cand.begin(), cand.end());
int nowh = 0;
for (int x : v) nowh = (nowh + modpow(K, M - x)) % MOD;
for (int x : cand) {
while (q.size() && q.front() + x >= M) {
int a = q.front();
q.pop();
nowh = (nowh - modpow(K, a) + MOD) % MOD;
nowh = (nowh + modpow(K, a) * modpow(modpow(K, M), MOD - 2)) % MOD;
}
int h = nowh * modpow(K, x) % MOD;
if (H == h) ans.emplace_back(x);
}
sort(ans.begin(), ans.end());
cout << ans.size() << '\n';
for (int x : ans) cout << x << ' ';
cout << '\n';
}
| 2,400 | CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.