solution
stringlengths 10
159k
| difficulty
int64 0
3.5k
| language
stringclasses 2
values |
|---|---|---|
n,k,m=map(int,input().split())
a=list(map(int,input().split()))
mods=[0]*m
mod=0
for i in range(n):
mod=a[i]%m
mods[mod]+=1
if mods[mod]==k:
break
else:
print('No')
exit()
print('Yes')
results=[None]*k
count=0
for i in range(n):
cur=a[i]
if cur%m==mod:
results[count]=cur
count+=1
if count==k:
print(' '.join(map(str,results)))
break | 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, 1, 0, -1};
const int dxo[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
const int dyo[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
const int inf = 1000000000;
const long long inf_ll = (long long)1 << 60;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = 10 * x + ch - '0';
ch = getchar();
}
return x * f;
}
inline long long readll() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = 10 * x + ch - '0';
ch = getchar();
}
return x * f;
}
long long gcd(long long x, long long y) { return y ? gcd(y, x % y) : x; }
long long power(long long x, long long y) {
long long t = 1;
for (; y; y >>= 1, x = x * x % (1000000007))
if (y & 1) t = t * x % (1000000007);
return t;
}
int n, m, b[(500000 + 5)], fa[(500000 + 5)];
set<int> s[(500000 + 5)];
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
int main() {
n = read();
m = read();
for (int i = (1); i <= (m); i++) fa[i] = i;
for (int i = (1); i <= (n); i++) {
int x = read();
s[x].insert(i);
b[i] = x;
}
int ans = n - 1;
for (int i = (n); i >= (2); i--)
if (b[i] == b[i - 1]) ans--;
printf("%d\n", ans);
m--;
while (m--) {
int x = read(), y = read();
x = find(x);
y = find(y);
if (s[x].size() > s[y].size()) swap(x, y);
for (auto z : s[x]) {
if (z != 1 && b[z - 1] == y) ans--;
if (z != n && b[z + 1] == y) ans--;
}
for (auto z : s[x]) {
b[z] = y;
s[y].insert(z);
}
fa[x] = y;
printf("%d\n", ans);
}
return 0;
}
| 2,300 | CPP |
l=input().split('+')
l.sort()
for i in range(len(l)-1):
print(l[i],end='+')
print(l[len(l)-1]) | 800 | PYTHON3 |
test = int(input())
def odd_or_even(i):
return '1' if i % 2 == 1 else '0'
for case in range(test):
s = input()
if '0' in s and '1' in s:
print(''.join([odd_or_even(i) for i in range(len(s)*2)]))
else:
print(s)
| 1,100 | PYTHON3 |
N = int(input())
if N == 0:
print(1)
exit()
l = [8, 4, 2, 6]
n = (N - 1) % 4
print(l[n])
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int N, K;
string txt;
vector<pair<int, int>> ops;
void ensure(char c, const int b) {
if (txt[b] == c) {
return;
}
for (int p = b + 1; p < N; ++p) {
if (txt[p] == c) {
reverse(txt.begin() + b, txt.begin() + p + 1);
ops.emplace_back(b, p);
return;
}
}
}
void solve(int k) {
int p = 0;
for (int i = 0; i < K - 1; ++i) {
ensure('(', p);
ensure(')', p + 1);
p += 2;
}
int rem = (N - p) / 2;
for (int i = 0; i < rem; ++i) {
ensure('(', p);
++p;
}
for (int i = 0; i < rem; ++i) {
ensure(')', p);
++p;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int T;
cin >> T;
while (T--) {
cin >> N >> K;
cin >> txt;
ops.clear();
solve(K);
cout << ops.size() << '\n';
for (auto [b, e] : ops) {
cout << (1 + b) << ' ' << (1 + e) << '\n';
}
}
}
| 1,700 | CPP |
code = input()
tmp = 0
bar = 0
baz = 0
flag = False
if len(code) < 7:
print('NO')
flag = True
elif len(code) == 7:
for i in range(len(code)):
tmp += int(code[i])
if tmp == 7 or tmp == 0:
flag = True
print('YES')
else:
for i in range(len(code) - 6):
j = i
while j < i + 7:
if int(code[j]) == 0:
bar += 1
else:
baz += 1
j += 1
if bar >= 7 or baz >= 7:
print('YES')
flag = True
break
tmp = 0
bar = 0
baz = 0
if not flag:
print('NO')
| 900 | PYTHON3 |
t = int(input())
for i in range(t):
n = int(input())
p = n//2
if n%2==0:
p = max(0,p-1)
print(p) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k, s, u, v, mid, x, ans, left;
long long int time_req;
cin >> n >> m >> k;
cin >> x >> s;
pair<int, int> s1[m + 1], s2[k + 1];
s1[0].first = x;
s1[0].second = 0;
for (int i = 1; i <= m; i++) {
cin >> u;
s1[i].first = u;
}
for (int i = 1; i <= m; i++) {
cin >> u;
s1[i].second = u;
}
for (int i = 1; i <= k; i++) {
cin >> u;
s2[i].first = u;
}
for (int i = 1; i <= k; i++) {
cin >> u;
s2[i].second = u;
}
long long int min_time = (long long int)n * (long long int)x;
for (int i = 0; i <= m; i++) {
ans = 0;
left = s - s1[i].second;
if (left < 0) continue;
u = 1;
v = k;
if (left < s2[u].second) {
time_req = (long long int)n * (long long int)s1[i].first;
min_time = min(min_time, time_req);
continue;
}
while (u <= v) {
mid = (u + v) / 2;
if (s2[mid].second <= left) {
ans = mid;
u = mid + 1;
} else
v = mid - 1;
}
if (!ans) {
time_req = (long long int)n * (long long int)s1[i].first;
} else {
time_req = ((long long int)n - (long long int)s2[ans].first) *
(long long int)s1[i].first;
}
min_time = min(min_time, time_req);
}
cout << min_time;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, s;
long long num;
void D() {
for (int x = 1; x <= m; x += 2) {
if (x > s) break;
for (int y = 1; y <= n; y += 2) {
int area = x * y;
long long cnt;
if (area > s) break;
if (area == s) {
cnt = ((x + 1) * (y + 1)) / 4;
cnt = cnt * 2 - 1;
cnt *= (m - x + 1) * (n - y + 1);
num += cnt;
} else if (area < s) {
int res = (s - area) / 2;
for (int z = 1; z < x; z += 2) {
if (res < z) break;
if (res % z == 0) {
int newy = y + 2 * (res / z);
if (newy > n)
continue;
else
num += (m - x + 1) * (n - newy + 1);
}
}
for (int z = 1; z < y; z += 2) {
if (res < z) break;
if (res % z == 0) {
int newx = x + 2 * (res / z);
if (newx > m)
continue;
else
num += (m - newx + 1) * (n - y + 1);
}
}
}
}
}
}
int main() {
while (scanf("%d %d %d", &n, &m, &s) != EOF) {
num = 0;
if (s % 2 == 1) D();
cout << num << endl;
}
return 0;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 987654321;
const int MOD = 1000000007;
int order(const vector<int>& A, const vector<int>& B) {
int n = A.size(), ret = 0;
multiset<int> ratings(B.begin(), B.end());
for (int ai = 0; ai < n; ++ai) {
if (*ratings.rbegin() < A[ai]) {
ratings.erase(ratings.begin());
ret++;
} else {
ratings.erase(ratings.lower_bound(A[ai]));
}
}
return ret;
}
int order2(const vector<int>& A, const vector<int>& B) {
int n = A.size(), ret = 0;
multiset<int> ratings(B.begin(), B.end());
for (int ai = 0; ai < n; ++ai) {
if (*ratings.rbegin() <= A[ai])
ratings.erase(ratings.begin());
else {
ratings.erase(ratings.upper_bound(A[ai]));
ret++;
}
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
string str1, str2;
cin >> str1 >> str2;
vector<int> arr1(n), arr2(n);
for (int i = 0; i < (n); ++i) arr1[i] = str1[i] - '0';
for (int i = 0; i < (n); ++i) arr2[i] = str2[i] - '0';
sort(arr1.begin(), arr1.end());
sort(arr2.begin(), arr2.end());
int sol1 = order(arr1, arr2);
int sol2 = order2(arr1, arr2);
cout << sol1 << '\n' << sol2;
return 0;
}
| 1,300 | CPP |
p,q,r,s=map(int,input().split())
a=min(p,r,s)
c=256*a + 32*min((p-a),q)
print(c)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 143;
const long long longinf = 1e18 + 143;
inline int read() {
int x;
scanf(" %d", &x);
return x;
}
const int N = 1e6 + 100;
const int MAX = 20 * N;
int sz = 0;
int sum[MAX], left_child[MAX], rson[MAX];
int copyof(int u) {
int v = ++sz;
sum[v] = sum[u];
left_child[v] = left_child[u];
rson[v] = rson[u];
return v;
}
int build(int l, int r) {
int u = ++sz;
sum[u] = 0;
if (l < r) {
int m = (l + r) / 2;
left_child[u] = build(l, m);
rson[u] = build(m + 1, r);
}
return u;
}
int add(int u, int l, int r, int x, int d) {
if (l > x || r < x) return u;
int v = copyof(u);
if (l == r) {
sum[v] += d;
return v;
}
int m = (l + r) / 2;
left_child[v] = add(left_child[u], l, m, x, d);
rson[v] = add(rson[u], m + 1, r, x, d);
sum[v] = sum[left_child[v]] + sum[rson[v]];
return v;
}
int get(int u, int l, int r, int x) {
if (l > x) return 0;
if (r <= x) {
return sum[u];
}
int m = (l + r) / 2;
return get(left_child[u], l, m, x) + get(rson[u], m + 1, r, x);
}
char a[N];
int t[N], x[N];
int root[N];
int main() {
int q = read();
for (int i = 0; i < q; i++) {
a[i] = read();
t[i] = read();
x[i] = read();
}
vector<int> xs, ts;
for (int i = 0; i < q; i++) {
xs.push_back(x[i]);
ts.push_back(t[i]);
}
sort(xs.begin(), xs.end());
xs.erase(unique(xs.begin(), xs.end()), xs.end());
sort(ts.begin(), ts.end());
ts.erase(unique(ts.begin(), ts.end()), ts.end());
auto getid = [&](vector<int>& v, int x) {
return lower_bound(v.begin(), v.end(), x) - v.begin();
};
for (int i = 0; i < q; i++) {
t[i] = getid(ts, t[i]);
x[i] = getid(xs, x[i]);
}
int T = ts.size();
int emptyRoot = build(0, T - 1);
for (int i = 0; i < xs.size(); i++) {
root[i] = emptyRoot;
}
for (int i = 0; i < q; i++) {
if (a[i] == 1) {
root[x[i]] = add(root[x[i]], 0, T - 1, t[i], +1);
} else if (a[i] == 2) {
root[x[i]] = add(root[x[i]], 0, T - 1, t[i], -1);
} else {
cout << get(root[x[i]], 0, T - 1, t[i]) << "\n";
}
}
return 0;
}
| 2,000 | CPP |
import math as mt
n,m,a=map(int,input().strip().split())
z = int(mt.ceil(n/a)*mt.ceil(m/a))
print(z) | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
string to_string(string s) { return '"' + s + '"'; }
string to_string(char s) { return string(1, s); }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A>
string to_string(A);
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool f = 1;
string r = "{";
for (const auto &x : v) {
if (!f) r += ", ";
f = 0;
r += to_string(x);
}
return r + "}";
}
void debug_out() { cout << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cout << " " << to_string(H);
debug_out(T...);
}
inline int add(int a, int b) {
a += b;
if (a >= MOD) a -= MOD;
return a;
}
inline int sub(int a, int b) {
a -= b;
if (a < 0) a += MOD;
return a;
}
inline int mul(int a, int b) { return (int)((long long)a * b % MOD); }
inline int binpow(int a, int b) {
int res = 1;
while (b > 0) {
if (b & 1) res = mul(res, a);
a = mul(a, a);
b /= 2;
}
return res;
}
inline int inv(int a) { return binpow(a, MOD - 2); }
int gcd(int a, int b, int &x, int &y) {
if (a == 0) {
x = 0, y = 1;
return b;
}
int x1, y1;
int d = gcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
const int N = 5005, INF = 1e9;
int n, dp[N][N][2], a[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i <= n; ++i)
for (int j = 1; j <= (n + 1) / 2; ++j) dp[i][j][0] = dp[i][j][1] = INF;
for (int i = 1; i <= n; ++i) cin >> a[i];
dp[1][1][1] = 0;
for (int i = 2; i <= n; ++i)
for (int j = 1; j <= (n + 1) / 2; ++j) {
dp[i][j][0] =
min(dp[i - 1][j][0], dp[i - 1][j][1] + max(a[i] - a[i - 1] + 1, 0));
if (i > 1 && j > 0)
dp[i][j][1] = min(
dp[i - 2][j - 1][0] + max(a[i - 1] - a[i] + 1, 0),
dp[i - 2][j - 1][1] + max(a[i - 1] - min(a[i], a[i - 2]) + 1, 0));
}
for (int j = 1; j <= (n + 1) / 2; ++j)
cout << min(dp[n][j][0], dp[n][j][1]) << " ";
cout << "\n";
return 0;
}
| 1,900 | CPP |
MOD = 998244353
p = [1] * 200005
for i in range(1, 200005):
p[i] = (p[i - 1] * 10) % MOD
n = int(input())
for i in range(1, n):
res = 2 * 10 * 9 * p[n - i - 1]
res += (n - 1 - i) * 10 * 9 * 9 * p[n - i - 2]
print(res % MOD, end = ' ')
print(10)
| 1,800 | PYTHON3 |
from collections import defaultdict
ma = defaultdict(list)
def solve(arr, n, k):
global ma
for a in arr:
cnt = 0
while a > 0:
ma[a].append(cnt)
a >>= 1
cnt += 1
ret = 10**10
for key in ma.keys():
b = ma[key]
if len(b) >= k:
b.sort()
ret = min(ret, sum(b[:k]))
return ret
def main():
n,k = list(map(int, input().strip().split()))
arr = list(map(int, input().strip().split()))
print (solve(arr, n, k))
if __name__ == "__main__":
main()
| 1,500 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
long long n, m, q, u, v, l, r, c, res, sum[N], p[N], lmt[N], vst[N];
vector<long long> adj[N], vec;
void dfs(int u, int p) {
vst[u] = 1;
vec.push_back(u);
for (auto v : adj[u]) {
if (vst[v] == 2) continue;
if (vst[v] == 1) {
if (v != p) {
long long mn = u;
long long mx = u;
for (int j = vec.size() - 1; j >= 0; j--) {
mn = min(mn, vec[j]);
mx = max(mx, vec[j]);
if (vec[j] == v) break;
}
lmt[mn] = min(lmt[mn], mx - 1);
}
} else
dfs(v, u);
}
vec.pop_back();
vst[u] = 2;
}
void solve() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
vst[i] = 0;
lmt[i] = n;
}
for (int i = 1; i <= n; i++) {
if (vst[i]) continue;
dfs(i, -1);
}
lmt[n] = n;
sum[n] = 1;
for (int i = n - 1; i >= 1; i--) {
if (lmt[i + 1] < lmt[i]) lmt[i] = lmt[i + 1];
sum[i] = lmt[i] - i + 1;
}
sum[0] = 0;
for (int i = 1; i <= n; i++) sum[i] += sum[i - 1];
cin >> q;
for (int i = 1, j; i <= q; i++) {
cin >> l >> r;
j = lower_bound(lmt + l, lmt + r + 1, r) - lmt;
c = r + 1 - j;
res = ((c * (c + 1)) / 2) + sum[j - 1] - sum[l - 1];
cout << res << "\n";
}
}
int main() {
std::ios::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
| 2,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
template <typename T>
bool cmax(T &a, T b) {
return (a < b) ? a = b, 1 : 0;
}
template <typename T>
bool cmin(T &a, T b) {
return (a > b) ? a = b, 1 : 0;
}
template <typename T>
T read() {
T ans = 0, f = 1;
char ch = getchar();
while (!isdigit(ch) && ch != '-') ch = getchar();
if (ch == '-') f = -1, ch = getchar();
while (isdigit(ch))
ans = (ans << 3) + (ans << 1) + (ch - '0'), ch = getchar();
return ans * f;
}
template <typename T>
void write(T x, char y) {
if (x == 0) {
putchar('0'), putchar(y);
return;
}
if (x < 0) {
putchar('-');
x = -x;
}
static char wr[20];
int top = 0;
for (; x; x /= 10) wr[++top] = x % 10 + '0';
while (top) putchar(wr[top--]);
putchar(y);
}
void file() {}
int n, m, k;
long long val[N];
int u[N], v[N];
struct edge {
long long v, id;
bool operator<(const edge &s) const { return v < s.v; }
} e[N];
int pw[N];
const int mo = 1e9 + 7;
long long power(long long x, int y, int Mod) {
long long res = 1;
for (; y; x = x * x % Mod, y >>= 1)
if (y & 1) res = res * x % Mod;
return res;
}
void input() {
n = read<int>(), m = read<int>(), k = read<int>();
for (register int i = (int)(1); i <= (int)(n); ++i)
val[i] = read<long long>();
for (register int i = (int)(1); i <= (int)(m); ++i) {
u[i] = read<int>(), v[i] = read<int>();
e[i] = (edge){val[u[i]] ^ val[v[i]], i};
}
}
int fa[N];
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
int ans, num, sum;
void work() {
int r, x, y;
sort(e + 1, e + m + 1);
pw[0] = 1;
for (register int i = (int)(1); i <= (int)(n); ++i)
pw[i] = (pw[i - 1] << 1) % mo;
sum = power(2, k, mo);
for (register int l = (int)(1); l <= (int)(m); ++l) {
num = n;
for (r = l; r < m && e[r + 1].v == e[l].v; r++)
;
for (register int i = (int)(l); i <= (int)(r); ++i) {
x = u[e[i].id], y = v[e[i].id];
fa[x] = x, fa[y] = y;
}
for (register int i = (int)(l); i <= (int)(r); ++i) {
x = u[e[i].id], y = v[e[i].id];
if (find(x) ^ find(y)) {
num--;
fa[find(y)] = find(x);
}
}
ans = (ans + pw[num]) % mo;
sum--;
l = r;
}
sum = (sum + mo) % mo;
ans = (ans + 1ll * pw[n] * sum % mo) % mo;
write(ans, '\n');
}
int main() {
file();
input();
work();
return 0;
}
| 2,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int x, y, m;
cin >> x >> y >> m;
long long int X = max(x, y);
long long int Y = min(x, y);
if (X >= m) {
cout << "0" << endl;
return 0;
}
if (X <= 0) {
cout << "-1" << endl;
return 0;
}
long long int res = 0;
if (Y < 0) {
res += -Y / X;
}
Y += (res * X);
while (X < m && Y < m) {
Y += X;
res++;
if (X < Y) swap(X, Y);
}
cout << res << endl;
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
int main() {
int a, b;
scanf("%d%d", &a, &b);
if (min(a, b) % 2 == 1)
printf("Akshat\n");
else
printf("Malvika\n");
return 0;
}
| 900 | CPP |
from collections import defaultdict as dc
from collections import Counter
from heapq import *
import math
from bisect import bisect_left,bisect
#bisect gives x and p[x] is element greater than it and out of bound for last one
#p[x-1] gives equal or smaller and no error for any element.
import sys
from collections import deque as dq
from heapq import heapify,heappush,heappop
mod=10**9 +7
def sinp():
p=str(input())
return p
def seive(n):
p=[0]*(n+1)
for i in range(2,n):
if p[i]==0:
for j in range(2*i,n+1,i):
p[i]=1
return p
def inp():
p=int(input())
return p
def line():
p=list(map(int,input().split()))
return p
def read_mat():
n=inp()
a=[]
for i in range(n):
a.append(line())
return a
def digit(n):
s=str(n)
p=0
for i in s:
p+=(int(i))**2
return p
def solve(a,n):
p=[1]*(n+1)
for i in range(n,0,-1):
for z in range(1,int(i**0.5)+1):
if i%z==0:
if a[i-1]>a[z-1]:
p[z]=max(p[z],p[i]+1)
if i!=(i//z) and a[i-1]>a[(i//z)-1]:
p[i//z]=max(p[i//z],p[i]+1)
return max(p)
for test in range(inp()):
n=inp()
a=line()
l=solve(a,n)
print(l)
| 1,400 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, all = 0, ans = 0, x = 0, y = 0, z = 0;
cin >> n;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
if (t == 4)
ans++;
else if (t == 3)
z++;
else if (t == 2)
y++;
else if (t == 1)
x++;
}
ans += min(x, z);
int c = min(x, z);
x -= c;
z -= c;
ans += y / 2;
y = y % 2;
ans += min(y, x / 2);
c = min(y, x / 2);
y -= c;
x -= 2 * c;
if (y == 1 && x >= 0) {
ans++;
y--;
x--;
}
ans += ceil(x / 4.0);
ans += z;
cout << ans;
return 0;
}
| 1,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
cin >> s;
int i = 5, x = 0;
while (i--) {
cin >> t;
if (t[1] == s[1] || t[0] == s[0]) {
x = 1;
}
}
if (x == 1) {
cout << "YES";
} else
cout << "NO";
return 0;
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct point {
long double x, y;
point() {
x = 0;
y = 0;
}
bool operator==(const point& b) { return x == b.x and y == b.y; }
point(long double x1, long double y1) {
x = x1;
y = y1;
}
long double dist(point b) {
return sqrt((b.x - x) * (b.x - x) + (y - b.y) * (y - b.y));
}
bool point_on_sig(point& a, point& b) {
return a.dist(b) == dist(a) + dist(b);
}
long double polar_angle() {
long double alpha = atan2(y, x);
long double pi = 3.141592654;
if (alpha < 0) alpha += 2 * pi;
return alpha;
}
};
struct line {
long double A, B, C;
line() {
A = 0;
B = 0;
C = 0;
}
line(point& a, point& b) {
A = a.y - b.y;
B = b.x - a.x;
C = -A * a.x - B * a.y;
}
line(long double a, long double b, long double c) {
A = a;
B = b;
C = c;
}
point intersect_lines(line& a) {
point p;
p.x = -(((C * a.B) - (a.C * B)) / ((A * a.B) - (a.A * B)));
p.y = -(((A * a.C) - (a.A * C)) / ((A * a.B) - (a.A * B)));
return p;
}
bool intersect(line& b) { return A * b.B - B * b.A != 0; }
long double distance_perpendicular(point& d) {
return abs(A * d.x + B * d.y + C) / (sqrt(A * A + B * B));
}
};
struct vc {
long double x, y;
vc() {
x = 0;
y = 0;
}
vc(long double x_, long double y_) {
x = x_;
y = y_;
}
vc(const point& a) {
x = a.x;
y = a.y;
}
vc minus(const vc& b) { return vc(x - b.x, y - b.y); }
long double len() { return sqrt(x * x + y * y); }
long double scalar(const vc& b) { return x * b.x + y * b.y; }
long double vector(const vc& b) { return x * b.y - y * b.x; }
long double angle(const vc& b) { return atan2(vector(b), scalar(b)); }
};
vector<int> top;
void top_sort(int v, vector<int> nodes[], int used[], int colors[]) {
if (colors[v] == 1) {
cout << -1;
exit(0);
} else if (colors[v] == 0)
colors[v] = 1;
for (int i = 0; i < nodes[v].size(); ++i) {
if (used[nodes[v][i]] == 0) top_sort(nodes[v][i], nodes, used, colors);
}
top.push_back(v + 1);
used[v] = 1;
colors[v] = 2;
}
vector<int> z_function(string s) {
vector<int> z(s.size());
for (int i = 1, l = 0, r = 0; i < s.size(); ++i) {
if (i <= r) z[i] = min(r - i + 1, z[i - l]);
while (i + z[i] < s.size() && s[z[i]] == s[i + z[i]]) ++z[i];
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
return z;
}
vector<int> p_function(string s) {
vector<int> p(s.size());
for (int i = 1; i < s.size(); ++i) {
int j = p[i - 1];
while (j > 0 && s[i] != s[j]) j = p[j - 1];
if (s[i] == s[j]) ++j;
p[i] = j;
}
return p;
}
vector<int> now_ans;
void dfs(int v, vector<int> nodes[], int colors[], int turn) {
if (colors[v] == 1) {
now_ans.push_back(0);
return;
} else if (colors[v] == 0)
colors[v] = 1;
for (int i = 0; i < nodes[v].size(); ++i) {
if (turn == 1)
dfs(nodes[v][i], nodes, colors, 2);
else
dfs(nodes[v][i], nodes, colors, 1);
}
if (nodes[v].empty()) {
now_ans.push_back(turn);
return;
}
colors[v] = 2;
}
int parents[500000];
void create(int v) { parents[v] = v; }
int find_parent(int v) {
if (v == parents[v]) return v;
return find_parent(parents[v]);
}
void join(int a, int b) {
int x = find_parent(a);
int y = find_parent(b);
if (x != y) {
parents[a] = b;
}
}
bool check_list(int v, vector<int> nodes[]) { return nodes[v].empty(); }
void dfs(int v, vector<int> nodes[]) {
int counter = 0;
if (nodes[v].empty()) {
return;
}
for (int i = 0; i < nodes[v].size(); ++i) {
if (check_list(nodes[v][i], nodes)) ++counter;
}
if (counter < 3) {
cout << "No";
exit(0);
}
for (int i = 0; i < nodes[v].size(); ++i) dfs(nodes[v][i], nodes);
}
void fill(char arr[9][9]) {
for (int i = 0; i < 9; ++i) {
for (int j = 0; j < 9; ++j) {
if (arr[i][j] == '.') arr[i][j] = '!';
}
}
}
int main() {
char arr[9][9];
for (int i = 0; i < 9; ++i) {
for (int j = 0; j < 9; ++j) {
char x;
cin >> x;
if (x == ' ') cin >> x;
arr[i][j] = x;
}
}
int x, y;
cin >> x >> y;
--x;
--y;
x %= 3;
y %= 3;
int purpose = x * 3 + y + 1;
if (purpose == 1) {
bool flag = false;
if (arr[0][0] == '.') {
flag = true;
arr[0][0] = '!';
}
if (arr[0][1] == '.') {
flag = true;
arr[0][1] = '!';
}
if (arr[0][2] == '.') {
flag = true;
arr[0][2] = '!';
}
if (arr[1][0] == '.') {
flag = true;
arr[1][0] = '!';
}
if (arr[1][1] == '.') {
flag = true;
arr[1][1] = '!';
}
if (arr[1][2] == '.') {
flag = true;
arr[1][2] = '!';
}
if (arr[2][0] == '.') {
flag = true;
arr[2][0] = '!';
}
if (arr[2][1] == '.') {
flag = true;
arr[2][1] = '!';
}
if (arr[2][2] == '.') {
flag = true;
arr[2][2] = '!';
}
if (!flag) {
fill(arr);
}
}
if (purpose == 2) {
bool flag = false;
if (arr[0][3] == '.') {
flag = true;
arr[0][3] = '!';
}
if (arr[0][4] == '.') {
flag = true;
arr[0][4] = '!';
}
if (arr[0][5] == '.') {
flag = true;
arr[0][5] = '!';
}
if (arr[1][3] == '.') {
flag = true;
arr[1][3] = '!';
}
if (arr[1][4] == '.') {
flag = true;
arr[1][4] = '!';
}
if (arr[1][5] == '.') {
flag = true;
arr[1][5] = '!';
}
if (arr[2][3] == '.') {
flag = true;
arr[2][3] = '!';
}
if (arr[2][4] == '.') {
flag = true;
arr[2][4] = '!';
}
if (arr[2][5] == '.') {
flag = true;
arr[2][5] = '!';
}
if (!flag) {
fill(arr);
}
}
if (purpose == 3) {
bool flag = false;
if (arr[0][6] == '.') {
flag = true;
arr[0][6] = '!';
}
if (arr[0][7] == '.') {
flag = true;
arr[0][7] = '!';
}
if (arr[0][8] == '.') {
flag = true;
arr[0][8] = '!';
}
if (arr[1][6] == '.') {
flag = true;
arr[1][6] = '!';
}
if (arr[1][7] == '.') {
flag = true;
arr[1][7] = '!';
}
if (arr[1][8] == '.') {
flag = true;
arr[1][8] = '!';
}
if (arr[2][6] == '.') {
flag = true;
arr[2][6] = '!';
}
if (arr[2][7] == '.') {
flag = true;
arr[2][7] = '!';
}
if (arr[2][8] == '.') {
flag = true;
arr[2][8] = '!';
}
if (!flag) {
fill(arr);
}
}
if (purpose == 4) {
bool flag = false;
if (arr[3][0] == '.') {
flag = true;
arr[3][0] = '!';
}
if (arr[3][1] == '.') {
flag = true;
arr[3][1] = '!';
}
if (arr[3][2] == '.') {
flag = true;
arr[3][2] = '!';
}
if (arr[4][0] == '.') {
flag = true;
arr[4][0] = '!';
}
if (arr[4][1] == '.') {
flag = true;
arr[4][1] = '!';
}
if (arr[4][2] == '.') {
flag = true;
arr[4][2] = '!';
}
if (arr[5][0] == '.') {
flag = true;
arr[5][0] = '!';
}
if (arr[5][1] == '.') {
flag = true;
arr[5][1] = '!';
}
if (arr[5][2] == '.') {
flag = true;
arr[5][2] = '!';
}
if (!flag) {
fill(arr);
}
}
if (purpose == 5) {
bool flag = false;
if (arr[3][3] == '.') {
flag = true;
arr[3][3] = '!';
}
if (arr[3][4] == '.') {
flag = true;
arr[3][4] = '!';
}
if (arr[3][5] == '.') {
flag = true;
arr[3][5] = '!';
}
if (arr[4][3] == '.') {
flag = true;
arr[4][3] = '!';
}
if (arr[4][4] == '.') {
flag = true;
arr[4][4] = '!';
}
if (arr[4][5] == '.') {
flag = true;
arr[4][5] = '!';
}
if (arr[5][3] == '.') {
flag = true;
arr[5][3] = '!';
}
if (arr[5][4] == '.') {
flag = true;
arr[5][4] = '!';
}
if (arr[5][5] == '.') {
flag = true;
arr[5][5] = '!';
}
if (!flag) {
fill(arr);
}
}
if (purpose == 6) {
bool flag = false;
if (arr[3][6] == '.') {
flag = true;
arr[3][6] = '!';
}
if (arr[3][7] == '.') {
flag = true;
arr[3][7] = '!';
}
if (arr[3][8] == '.') {
flag = true;
arr[3][8] = '!';
}
if (arr[4][6] == '.') {
flag = true;
arr[4][6] = '!';
}
if (arr[4][7] == '.') {
flag = true;
arr[4][7] = '!';
}
if (arr[4][8] == '.') {
flag = true;
arr[4][8] = '!';
}
if (arr[5][6] == '.') {
flag = true;
arr[5][6] = '!';
}
if (arr[5][7] == '.') {
flag = true;
arr[5][7] = '!';
}
if (arr[5][8] == '.') {
flag = true;
arr[5][8] = '!';
}
if (!flag) {
fill(arr);
}
}
if (purpose == 7) {
bool flag = false;
if (arr[6][0] == '.') {
flag = true;
arr[6][0] = '!';
}
if (arr[6][1] == '.') {
flag = true;
arr[6][1] = '!';
}
if (arr[6][2] == '.') {
flag = true;
arr[6][2] = '!';
}
if (arr[7][0] == '.') {
flag = true;
arr[7][0] = '!';
}
if (arr[7][1] == '.') {
flag = true;
arr[7][1] = '!';
}
if (arr[7][2] == '.') {
flag = true;
arr[7][2] = '!';
}
if (arr[8][0] == '.') {
flag = true;
arr[8][0] = '!';
}
if (arr[8][1] == '.') {
flag = true;
arr[8][1] = '!';
}
if (arr[8][2] == '.') {
flag = true;
arr[8][2] = '!';
}
if (!flag) {
fill(arr);
}
}
if (purpose == 8) {
bool flag = false;
if (arr[6][3] == '.') {
flag = true;
arr[6][3] = '!';
}
if (arr[6][4] == '.') {
flag = true;
arr[6][4] = '!';
}
if (arr[6][5] == '.') {
flag = true;
arr[6][5] = '!';
}
if (arr[7][3] == '.') {
flag = true;
arr[7][3] = '!';
}
if (arr[7][4] == '.') {
flag = true;
arr[7][4] = '!';
}
if (arr[7][5] == '.') {
flag = true;
arr[7][5] = '!';
}
if (arr[8][3] == '.') {
flag = true;
arr[8][3] = '!';
}
if (arr[8][4] == '.') {
flag = true;
arr[8][4] = '!';
}
if (arr[8][5] == '.') {
flag = true;
arr[8][5] = '!';
}
if (!flag) {
fill(arr);
}
}
if (purpose == 9) {
bool flag = false;
if (arr[6][6] == '.') {
flag = true;
arr[6][6] = '!';
}
if (arr[6][7] == '.') {
flag = true;
arr[6][7] = '!';
}
if (arr[6][8] == '.') {
flag = true;
arr[6][8] = '!';
}
if (arr[7][6] == '.') {
flag = true;
arr[7][6] = '!';
}
if (arr[7][7] == '.') {
flag = true;
arr[7][7] = '!';
}
if (arr[7][8] == '.') {
flag = true;
arr[7][8] = '!';
}
if (arr[8][6] == '.') {
flag = true;
arr[8][6] = '!';
}
if (arr[8][7] == '.') {
flag = true;
arr[8][7] = '!';
}
if (arr[8][8] == '.') {
flag = true;
arr[8][8] = '!';
}
if (!flag) {
fill(arr);
}
}
for (int i = 0; i < 9; ++i) {
for (int j = 0; j < 9; ++j) {
cout << arr[i][j];
if (j % 3 == 2) cout << ' ';
}
cout << '\n';
if (i % 3 == 2) cout << '\n';
}
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
int arr[5300][5300], n;
bool valid(int x) {
int i, j, t, k, p;
for (i = 0; i < n / x; i++) {
for (j = 0; j < n / x; j++) {
t = arr[i * x][j * x];
for (k = 0; k < x; k++) {
for (p = 0; p < x; p++)
if (arr[i * x + k][j * x + p] != t) return false;
}
}
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int i, l, t, j;
string s;
vector<int> v;
cin >> n;
for (i = 0; i < n; i++) {
cin >> s;
l = s.size();
for (j = 0; j < l; j++) {
if (s[j] >= '0' && s[j] <= '9')
t = s[j] - '0';
else
t = s[j] - 'A' + 10;
arr[i][j * 4 + 3] = (t & 1) ? 1 : 0;
arr[i][j * 4 + 2] = (t & 2) ? 1 : 0;
arr[i][j * 4 + 1] = (t & 4) ? 1 : 0;
arr[i][j * 4] = (t & 8) ? 1 : 0;
}
}
for (i = 2; i <= n; i++) {
if (n % i == 0) {
v.push_back(i);
}
}
reverse(v.begin(), v.end());
l = v.size();
for (i = 0; i < l; i++) {
if (valid(v[i])) {
cout << v[i] << endl;
return 0;
}
}
cout << 1 << endl;
return 0;
}
| 1,800 | CPP |
#include <bits/stdc++.h>
int main() {
int n, k, p;
int tree[1001];
int i, j, b, sum, f, w = 1;
scanf("%d%d", &n, &k);
p = n;
for (i = 1; i <= n; i++) {
scanf("%d", &tree[i]);
}
for (i = 1; i <= n; i++) {
b = tree[i];
sum = 0;
if (b - (i - 1) * k <= 0) continue;
f = b - (i - 1) * k;
for (j = 1; j <= i; j++) {
if (tree[j] != f + (j - 1) * k) sum++;
}
for (j = i + 1; j <= n; j++) {
if (tree[j] != b + (j - i) * k) sum++;
}
if (sum < p) {
p = sum;
w = i;
}
}
printf("%d\n", p);
b = tree[w];
f = b - (w - 1) * k;
for (j = 1; j <= w; j++) {
if (tree[j] != f + (j - 1) * k)
if (tree[j] < f + (j - 1) * k)
printf("+ %d %d\n", j, f + (j - 1) * k - tree[j]);
else
printf("- %d %d\n", j, tree[j] - f - (j - 1) * k);
}
for (j = w + 1; j <= n; j++) {
if (tree[j] != b + (j - w) * k)
if (tree[j] < b + (j - w) * k)
printf("+ %d %d\n", j, b + (j - w) * k - tree[j]);
else
printf("- %d %d\n", j, tree[j] - b - (j - w) * k);
}
return 0;
}
| 1,400 | CPP |
def xorinacci(n,a,b):
if(n==0):
return a
elif(n==1):
return b
elif(n==2):
return a^b
return xorinacci(n%3,a,b)
t=int(input())
while(t>0):
a,b,n=input().split()
a,b,n=int(a),int(b),int(n)
d=xorinacci(n,a,b)
print(d)
t-=1
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4001;
vector<int> adjList[maxn];
int memo[2][1001][1001];
string s;
int k;
int len;
int mod = 1000000007;
int dp(int i, int cnt, int isSmall) {
if (i >= len) return cnt == 0;
if (cnt < 0) return 0;
if (memo[isSmall][i][cnt] + 1) return memo[isSmall][i][cnt];
int ans;
if (isSmall) {
ans = (dp(i + 1, cnt, isSmall) + dp(i + 1, cnt - 1, isSmall)) % mod;
} else {
if (s[i] == '1') {
ans = (dp(i + 1, cnt, 1) + dp(i + 1, cnt - 1, 0)) % mod;
} else {
ans = dp(i + 1, cnt, 0);
}
}
return memo[isSmall][i][cnt] = ans;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
cin >> s;
;
cin >> k;
;
len = s.length();
if (k == 0) {
cout << 1;
return 0;
}
if (k == 1) {
cout << len - 1;
return 0;
}
if (len <= 20) {
int n = 0;
for (int i = s.length() - 1, pow = 1; i >= 0; i--, pow <<= 1) {
if (s[i] == '1') {
n |= pow;
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
int x = i;
int cnt = 0;
while (x > 1) {
x = __builtin_popcount(x);
cnt++;
}
if (cnt == k) {
ans++;
}
}
cout << ans;
return 0;
}
for (int i = 0; i < len; i++) {
for (int j = 0; j <= 1000; j++) {
memo[0][i][j] = -1;
memo[1][i][j] = -1;
}
}
int ans = 0;
for (int i = 1; i <= 1000; i++) {
int x = i;
int cnt = 0;
while (x > 1) {
x = __builtin_popcount(x);
cnt++;
}
if (cnt == k - 1) {
ans = (ans + dp(0, i, 0)) % mod;
}
}
cout << ans;
return 0;
}
| 1,800 | CPP |
n = int(input())
w = list(map(int, input().split()))
mn = 101
mx = 0
ans = 0
r = 0
l = 0
for i in range(n):
if w[i] <= mn:
mn = w[i]
r = i
if w[i] > mx:
mx = w[i]
l = i
if l > r:
ans -= 1
ans += l + (n - r - 1)
print(ans) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, j, l, c = 0, s;
cin >> n >> s;
long long a[n], b[n];
vector<long long> v;
for (i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(b, b + n);
bool bb = true;
if (s == b[n / 2])
return cout << "0", 0;
else if (s < b[n / 2]) {
for (i = n / 2; i >= 0; i--) {
if (b[i] > s) {
c += abs(s - b[i]);
}
}
cout << c << endl;
} else if (s > b[n / 2]) {
for (i = n / 2; i < n; i++) {
if (s > b[i]) {
c += abs(s - b[i]);
}
}
cout << c << endl;
}
return 0;
}
| 1,300 | CPP |
s=input()
k=""
k+=s[0].upper()
for i in s[1:]:
k+=i
print(k) | 800 | PYTHON3 |
# -*- coding: utf-8 -*-
"""
Created on Fri Jul 13 17:28:51 2018
@author: Reda
"""
#Watermelon
w = int(input())
if 1 <= w <= 100:
if w%2 == 0 and w != 2:
print("YES")
else:
print("NO")
else:
print("NO")
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int dp[505][5050];
int main() {
int n, k;
cin >> n >> k;
int c[5000];
int f[5000];
int h[5000];
vector<int> vec;
for (int i = 0; i < n * k; i++) {
cin >> c[i];
}
for (int i = 0; i < n; i++) {
cin >> f[i];
vec.push_back(f[i]);
}
for (int i = 0; i < k; i++) cin >> h[i + 1];
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n * k; j++) {
for (int l = 1; l <= k; l++) {
if (j >= l) dp[i][j] = max(dp[i - 1][j - l] + h[l], dp[i][j]);
}
}
}
long final = 0;
int freq[100005];
int freq1[100005];
memset(freq1, 0, sizeof(freq1));
memset(freq, 0, sizeof(freq));
for (int j = 0; j < n * k; j++) {
freq[c[j]]++;
}
for (int i = 0; i < n; i++) {
freq1[f[i]]++;
}
sort(vec.begin(), vec.end());
vector<int>::iterator itr;
itr = unique(vec.begin(), vec.end());
vec.resize(distance(vec.begin(), itr));
for (int i = 0; i < vec.size(); i++) {
final += dp[freq1[vec[i]]][freq[vec[i]]];
}
cout << final << endl;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MX = 30000, MD = 260;
int n, d, f[MX + 3][555], gem[MX + 3];
int go(int pos, int offset) {
if (pos > MX || pos < 0) return 0;
int &ret = f[pos][offset];
if (ret != -1) return ret;
ret = gem[pos];
for (int i = -1; i <= 1; ++i) {
int npos = pos + d + offset - MD + i;
if (0 <= npos && npos <= MX && npos > pos) {
int noffset = offset + i;
ret = max(ret, gem[pos] + go(npos, noffset));
}
}
return ret;
}
void solve() {
cin >> n >> d;
memset(f, -1, sizeof(f));
memset(gem, 0, sizeof(gem));
for (int i = 0; i < (int)(n); ++i) {
int x;
cin >> x;
gem[x]++;
}
cout << go(d, MD) << endl;
}
int main(int argc, char *argv[]) {
ios_base::sync_with_stdio(false);
cout.precision(10);
cout << fixed;
if (argc > 1 && fopen(argv[1], "r")) freopen(argv[1], "rt", stdin);
solve();
return 0;
}
| 1,900 | CPP |
n = int(input())
x, y = 1, 9
n -= 1
while n > x * y:
n -= x * y
x += 1
y *= 10
a = 10 ** (x - 1) + n // x
print(str(a)[n % x])
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> ans;
map<pair<int, int>, pair<int, int> > alreadyAsked;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
pair<int, int> ask(int l, int r) {
if (alreadyAsked.count(make_pair(l, r))) return alreadyAsked[make_pair(l, r)];
cout << "? " << l + 1 << ' ' << r + 1 << endl;
int x, f;
cin >> x;
if (x == -1) exit(0);
cin >> f;
return alreadyAsked[make_pair(l, r)] = make_pair(x, f);
}
void solve(int l, int r, int rmval) {
if (l > r) return;
int origl = l;
pair<int, int> aux = ask(l, r);
int x = aux.first, f = aux.second;
if (f == r - l + 1) {
for (int i = (l); i < (r + 1); i++) ans[i] = x;
return;
}
if (x == rmval) {
for (int i = (0); i < (f); i++) ans[r - i] = x;
solve(l, r - f, -1);
return;
}
if (f == 1) {
for (int i = (l); i < (r + 1); i++) {
aux = ask(i, i);
ans[i] = aux.first;
}
return;
}
while (l <= r && (l == 0 || ans[l - 1] != x)) {
solve(l, min(l + f - 1, r), x);
l += f;
}
if (l > r) return;
vector<int>::iterator ite =
lower_bound(ans.begin() + origl, ans.begin() + l, x);
f -= (int)((ans.begin() + l) - ite);
assert(f >= 0);
for (int i = (0); i < (f); i++) ans[l + i] = x;
solve(l + f, r, -1);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
ans.resize(n, -1);
solve(0, n - 1, -1);
cout << "!";
for (auto it = ans.begin(); it != ans.end(); it++) cout << ' ' << *it;
cout << endl;
return 0;
}
| 2,700 | CPP |
a=int(input())
for i in range(0,a):
a,b,c=map(int,input().split())
arr=[a,b,c]
arr.sort()
if(a==b or b==c or c==a):
if(arr[0]==arr[1] and not arr[0]==arr[2]):
print("NO")
elif(arr[0]==arr[1] and arr[1]==arr[2]):
print("YES")
print(a,b,c)
elif(arr[1]==arr[2] and not arr[1]==arr[0]):
print("YES")
print(arr[1],arr[0],arr[0])
else:
print("NO") | 800 | PYTHON3 |
def f(n, x):
a = ''
b = ''
for i in range(n):
if x[i] == '2':
a += '1'
b += '1'
elif x[i] == '0':
a += '0'
b += '0'
elif x[i] == '1':
a += '1'
a += '0'*(n-len(a))
b += '0' + x[i+1:]
break
print(a)
return b
def main():
t = int(input())
for _ in range(t):
n = int(input())
x = input()
print(f(n,x))
main()
| 1,200 | PYTHON3 |
n = int(input())
numbers = list(map(int,input().split()))
count_5 = 0
count_0 = 0
for i in numbers:
if i == 5:
count_5+=1
else:
count_0+=1
num =""
for i in range(count_5,0,-1):
num = "5"*i+str("0"*count_0)
if int(num) % 90 == 0:
print(num)
exit()
if count_0 > 0:
print(0)
else:
print(-1) | 1,000 | PYTHON3 |
import sys
s = input()
search_string = "hello"
c = 0
for v in s:
if v == search_string[c]:
c += 1
if c == len(search_string):
print("YES")
sys.exit()
print("NO") | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int binarysearch(int a[], int ele, int n) {
int beg = 0, end = n, mid, ans;
while (beg <= end) {
mid = beg + (end - beg) / 2;
if (a[mid] > ele) {
ans = mid;
end = mid - 1;
} else
beg = mid + 1;
}
return ans;
}
bool comp(vector<int> a, vector<int> b) { return a[1] > b[1]; }
long long rad(long long a, long long b) { return pow(a, 2) + pow(b, 2); }
int main(void) {
int n;
cin >> n;
if (n & 1) {
cout << 7;
n -= 3;
}
for (int i = 0; i < n / 2; i++) cout << 1;
return 0;
}
| 1,200 | CPP |
# ki holo vai ? Bujlam na...
# Court station Bollam r chere dilo
t=int(input())
for __ in range(t):
n,m,p,q=map(int,input().split())
print((m-n)//(p+q)) if ((m-n)%(p+q)==0) else print('-1') | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000010;
int in[N / 10];
int a[N];
void add(int x, int k) {
while (x <= N) {
a[x] += k;
x += x & -x;
}
}
int ask(int x) {
int ans = 0;
while (x) {
ans += a[x];
x ^= x & -x;
}
return ans;
}
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; ++i) cin >> in[i], in[i] += m + 1;
sort(in + 1, in + 1 + n);
int ans = 0;
for (int i = 1; i <= n; ++i) {
add(in[i], 1);
if (ask(in[i]) - ask(in[i] - m) >= k) {
++ans;
add(in[i], -1);
}
}
cout << ans;
return 0;
}
| 1,600 | CPP |
t=int(input())
for _ in range(t):
n=int(input())
arr=list(map(int,input().split()))
arr.sort()
a,b,c=0,0,0
p,q,k=1,1,1
w=arr[n-5:n]
r=arr[0:2]+arr[n-3:n]
s=arr[0:4]+arr[n-1:n]
while(a!=5):
p=p*w[a]
q=q*r[a]
k=k*s[a]
a+=1
print(max(p,q,k))
| 1,200 | PYTHON3 |
import collections as cc
import sys
input=sys.stdin.readline
I=lambda:list(map(int,input().split()))
for tc in range(int(input())):
x,y,n=I()
temp=n//x*x
if temp+y<=n:
print(temp+y)
else:
print(temp-(x-y)) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a = 0, b = 0, c = 0;
cin >> n;
c = n;
while (c > 0) {
a = a + c % 10;
c = c / 10;
}
if (a % 4 == 0) {
cout << n << endl;
} else {
while (1) {
n++;
int a = n;
while (a > 0) {
b = b + a % 10;
a = a / 10;
}
if (b % 4 == 0) {
cout << n << endl;
break;
}
b = 0;
}
}
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mxn = 105;
int main() {
int n, a, b;
int cnt = 0;
scanf("%d%d%d", &n, &a, &b);
if (n > a * b)
printf("-1\n");
else {
for (int i = 1; i <= a; i++) {
for (int j = 1; j <= b; j++) {
if (cnt <= n) {
int x = j + (i - 1) * b;
int y = b - j + b * (i - 1) + 1;
if (i & 1 && x <= n) {
printf("%d ", x);
cnt++;
}
if (i & 1 && x > n) printf("0 ");
if (!(i & 1) && y > n) {
printf("0 ");
}
if (!(i & 1) && y <= n) {
printf("%d ", y);
cnt++;
}
} else
printf("0 ");
}
printf("\n");
}
}
return 0;
}
| 1,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, k, n, a, b;
cin >> t;
while (t--) {
cin >> k >> n >> a >> b;
if (k <= b * n)
cout << "-1" << endl;
else {
long long int temp = k - n * b;
cout << min(n, (temp - 1) / (a - b)) << endl;
}
}
return 0;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
template <class T1, class T2>
ostream& operator<<(ostream& out, std::pair<T1, T2> pair) {
return out << "(" << pair.first << ", " << pair.second << ")";
}
template <class T>
void ResizeVec(T&, vector<int>) {}
template <class T>
void ResizeVec(vector<T>& vec, vector<int> sz) {
vec.resize(sz[0]);
sz.erase(sz.begin());
if (sz.empty()) {
return;
}
for (T& v : vec) {
ResizeVec(v, sz);
}
}
using namespace std;
class TaskB1 {
public:
void solve(std::istream& in, std::ostream& out) {
long long n;
in >> n;
;
long long sqrtn = sqrt(n);
long long res = 0;
for (long long div = 2; div <= sqrtn; div++) {
while (n % div == 0) {
res += n;
n /= div;
}
}
out << res + n + (n == 1 ? 0 : 1) << "\n";
;
}
};
int main() {
std::cin.sync_with_stdio(false);
std::cin.tie(0);
std::cout << std::fixed;
std::cout.precision(20);
TaskB1 solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 1,200 | CPP |
n, m = map(int, input().split())
mn = max(0, n - 2 * m)
for i in range(n + 1):
if i * (i - 1) // 2 >= m:
mx = n - i
break
print(mn, mx) | 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 24) + 5, L = 26, MOD = 1e9 + 7, P = 727, SQ = sqrt(N);
const long long inf = 1e18 + 10, M = 1e6 + 10;
int sum[N], a[L], b[3], dp[N][3];
int main() {
int n, k;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
scanf("%d", &k);
for (int i = 0; i < k; i++) scanf("%d", &b[i]);
if (k == 0) b[0] = -MOD, b[1] = -MOD;
if (k == 1) b[1] = -MOD;
for (int i = 1; i < (1 << n); i++) {
int x = __builtin_ctz(i);
sum[i] = sum[i ^ (1 << x)] + a[x];
}
dp[0][0] = 1;
for (int i = 1; i < (1 << n); i++) {
if (sum[i] == b[0] || sum[i] == b[1]) {
for (int j = 0; j < n; j++) {
if (((1 << j) & i) > 0) {
dp[i][1] = (dp[i][1] + dp[i ^ (1 << j)][0] + dp[i ^ (1 << j)][1]);
if (dp[i][1] > MOD) dp[i][1] -= MOD;
}
}
} else {
for (int j = 0; j < n; j++) {
if (((1 << j) & i) > 0) {
dp[i][0] = (dp[i][0] + dp[i ^ (1 << j)][0]);
if (dp[i][0] > MOD) dp[i][0] -= MOD;
dp[i][1] = (dp[i][1] + dp[i ^ (1 << j)][1]);
if (dp[i][1] > MOD) dp[i][1] -= MOD;
}
}
}
}
return cout << dp[(1 << n) - 1][0], 0;
}
| 2,300 | CPP |
counter = 0
for i in range(int(input())):
fr = list(map(int, input().split()))
p, q = fr[0], fr[1]
if q - p >= 2:
counter += 1
print(counter) | 800 | PYTHON3 |
n = int(input())
l = sorted(list(map(int, input().split())))
m = int(input())
s = sorted(list(map(int, input().split())))
count = 0
for i in range(n):
j = 0
while j<len(s) and s[j] <= l[i]+1:
if abs(l[i] - s[j]) <= 1:
s.pop(j)
count += 1
break
else:
j += 1
print(count)
| 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int SZ = 1e2 + 10;
int n, m;
char arr[SZ][SZ];
bool check_str(int a, int b) {
bool one, two;
one = two = false;
for (int i = 0; i < m; i++) {
if (arr[a][i] == '#' && arr[b][i] == '#') one = true;
if (arr[a][i] == '#' && arr[b][i] != '#') two = true;
if (arr[a][i] != '#' && arr[b][i] == '#') two = true;
}
if (one && two) return false;
return true;
}
bool check_stolb(int a, int b) {
bool one, two;
one = two = false;
for (int i = 0; i < n; i++) {
if (arr[i][a] == '#' && arr[i][b] == '#') one = true;
if (arr[i][a] == '#' && arr[i][b] != '#') two = true;
if (arr[i][a] != '#' && arr[i][b] == '#') two = true;
}
if (one && two) return false;
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cin >> arr[i][j];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (!check_str(i, j)) {
cout << "No";
return 0;
}
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < m; j++) {
if (!check_stolb(i, j)) {
cout << "No";
return 0;
}
}
}
cout << "Yes";
return 0;
}
| 1,300 | CPP |
n=int(input())
ta=list("abcdefghijklmnopqrstuvwxyz")
for x in range(n):
ma=[]
c=0
na=int(input())
p=list(input())
la=len(p)
if la%2==0:
tl=p[0:la//2]
pa=p[la//2:]
for item in tl:
ma.append(ta.index(item)+1)
for item in pa:
ma.append(ta.index(item)+1)
l=len(ma)-1
f=0
for x in range(len(ma)//2):
if abs(ma[f]-ma[l])==2 or abs(ma[f]-ma[l])==0 :
f+=1
l-=1
else:
c=1
print("NO")
break
if c==0:
print("YES")
elif la%2!=0:
tl=p[0:la//2]
pa=p[(la//2)+1:]
for item in ta:
ma.append(ta.index(item)+1)
for item in pa:
ma.append(ta.index(item)+1)
l=len(ma)-1
f=0
for x in range(len(ma)//2):
if abs(ma[f]-ma[l])==2 or abs(ma[f]-ma[l])==0:
f+=1
l-=1
else:
c=1
print("NO")
break
if c==0:
print("YES")
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
int chkmax(T& a, T b) {
if (b > a) {
a = b;
return 1;
}
return 0;
}
template <class T>
int chkmin(T& a, T b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class iterator>
void output(iterator begin, iterator end, ostream& out = cerr) {
while (begin != end) {
out << (*begin) << " ";
begin++;
}
out << endl;
}
template <class T>
void output(T x, ostream& out = cerr) {
output(x.begin(), x.end(), out);
}
void fast_io() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
struct dsu {
vector<int> p, sz1, sz2;
vector<pair<int, int> > st;
int v;
long long ans;
void init(int n, int m) {
v = n + m;
sz1.resize(v);
sz2.resize(v);
p.resize(v);
iota(p.begin(), p.end(), 0);
for (int i = 0; i < n; ++i) {
sz1[i] = 1;
}
for (int i = n; i < v; ++i) {
sz2[i] = 1;
}
}
int get_root(int v) {
if (p[v] == v) {
return v;
} else {
return get_root(p[v]);
}
}
long long func(int v) { return (long long)sz1[v] * (long long)sz2[v]; }
void hang(int u, int v) {
st.push_back({u, v});
p[u] = v;
sz1[v] += sz1[u];
sz2[v] += sz2[u];
ans += func(v);
}
void join(int u, int v) {
u = get_root(u);
v = get_root(v);
if (u == v) {
st.push_back({u, u});
return;
}
ans -= func(u);
ans -= func(v);
if (sz1[u] + sz2[u] < sz1[v] + sz2[v]) {
hang(u, v);
} else {
hang(v, u);
}
}
void roll_back(int cnt) {
for (int i = 0; i < cnt; ++i) {
int u = st.back().first, v = st.back().second;
st.pop_back();
if (u == v) {
continue;
}
p[u] = u;
ans -= func(v);
sz1[v] -= sz1[u];
sz2[v] -= sz2[u];
ans += func(u);
ans += func(v);
}
}
long long S_size() { return ans; }
};
int n;
vector<pair<int, int> > a;
vector<int> cx, cy, p;
vector<long long> ans;
dsu T;
void apply(int q_id) { T.join(a[q_id].first, cx.size() + a[q_id].second); }
void go(int l, int r) {
if (l == r) {
if (p[l] > l) {
apply(l);
}
ans.push_back(T.S_size());
if (p[l] > l) {
T.roll_back(1);
}
} else {
int mid = (l + r) >> 1, cnt = 0;
for (int i = mid + 1; i <= r; ++i) {
if (p[i] < l) {
apply(p[i]);
cnt++;
}
}
go(l, mid);
T.roll_back(cnt);
cnt = 0;
for (int i = l; i <= mid; ++i) {
if (p[i] > r) {
apply(i);
cnt++;
}
}
go(mid + 1, r);
T.roll_back(cnt);
}
}
signed main() {
fast_io();
cin >> n;
for (int i = 0; i < n; ++i) {
int x, y;
cin >> x >> y;
a.push_back({x, y});
cx.push_back(x);
cy.push_back(y);
}
sort(cx.begin(), cx.end());
sort(cy.begin(), cy.end());
cx.erase(unique(cx.begin(), cx.end()), cx.end());
cy.erase(unique(cy.begin(), cy.end()), cy.end());
for (int i = 0; i < n; ++i) {
a[i].first = lower_bound(cx.begin(), cx.end(), a[i].first) - cx.begin();
a[i].second = lower_bound(cy.begin(), cy.end(), a[i].second) - cy.begin();
}
p.resize(n, n);
map<pair<int, int>, int> mp;
for (int i = 0; i < n; ++i) {
if (mp.find(a[i]) == mp.end()) {
mp[a[i]] = i;
} else {
p[mp[a[i]]] = i;
p[i] = mp[a[i]];
mp.erase(a[i]);
}
}
T.init(cx.size(), cy.size());
go(0, n - 1);
output(ans.begin(), ans.end(), cout);
}
| 2,600 | CPP |
n,m=map(int,input().split())
k=0
for i in range(n):
if i%2==0:
print("#"*m)
elif k==0:
print("."*(m-1)+"#")
k=1
else:
print("#"+"."*(m-1))
k=0 | 800 | PYTHON3 |
#include <bits/stdc++.h>
const int MAXN = 5050;
int n, m, k;
int x[MAXN];
int y[MAXN];
int z[MAXN];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &x[i]);
scanf("%d", &m);
for (int i = 0; i < m; i++) scanf("%d", &y[i]);
scanf("%d", &k);
for (int i = 0; i < k; i++) scanf("%d", &z[i]);
int A, B;
scanf("%d%d", &A, &B);
int r1 = x[0];
for (int i = 1; i < n; i++)
if (x[i] > r1) r1 = x[i];
double r2 = 0;
for (int i = 0; i < m; i++)
for (int j = 0; j < k; j++)
if (double((double)r1 * (double)r1 * (double)B * (double)y[i]) /
double((double)A * (double)z[j] + (double)B * (double)y[i]) >
r2)
r2 = double((double)r1 * (double)r1 * (double)B * (double)y[i]) /
double((double)A * (double)z[j] + (double)B * (double)y[i]);
printf("%.8lf\n", sqrt(r2));
return 0;
}
| 1,300 | CPP |
#include <bits/stdc++.h>
int letters[100];
char c;
bool res = true;
int main() {
while (scanf("%c", &c) == 1) {
if (c != ' ') {
if (isupper(c))
++letters[c - 'A'];
else
++letters[c - 'a' + 27];
}
if (c == '\n') break;
}
while (scanf("%c", &c) == 1) {
if (c != ' ') {
if (isupper(c))
--letters[c - 'A'];
else
--letters[c - 'a' + 27];
}
}
for (int i = 0; i < 52; ++i)
if (letters[i] < 0) res = false;
if (res)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 1,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long oria[200004];
long long a[200004];
long long b[200004];
int main() {
long long n, m, cnt = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> oria[i];
if (i == 0)
a[i] = oria[0];
else
a[i] = oria[i] + a[i - 1];
}
long long j = 0;
for (int i = 0; i < m; i++) {
cin >> b[i];
while (b[i] - a[j] > 0) {
j++;
}
cout << j + 1 << " " << b[i] - a[j - 1] << endl;
}
return 0;
}
| 1,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
double dp[N][N][2][2], p;
int L[N], R[N], X[N], h, n;
bool vis[N][N][2][2];
double dpit(int l, int r, int x, int y) {
int dis;
bool debug = l == 3 && r == 3;
if (l > r) return 0;
if (vis[l][r][x][y]) return dp[l][r][x][y];
vis[l][r][x][y] = 1;
double &ret = dp[l][r][x][y];
int Last = min(R[l], r);
if (Last == r)
dis = min(X[Last + 1] - X[Last] - (y == 0 ? h : 0), h);
else
dis = h;
double dpL = (1 - p) * (dpit(R[l] + 1, r, 1, y) + X[Last] - X[l] + dis);
dpL +=
p * (dpit(l + 1, r, 0, y) + min(X[l] - X[l - 1] - (x == 1 ? h : 0), h));
Last = max(L[r], l);
if (Last == l)
dis = min(X[Last] - X[Last - 1] - (x == 1 ? h : 0), h);
else
dis = h;
double dpR = p * (dpit(l, L[r] - 1, x, 0) + X[r] - X[Last] + dis);
dpR += (1 - p) *
(dpit(l, r - 1, x, 1) + min(X[r + 1] - X[r] - (y == 0 ? h : 0), h));
ret = (dpL + dpR) / 2;
return ret;
}
int main() {
scanf("%d%d%lf", &n, &h, &p);
for (int i = 1; i <= n; i++) scanf("%d", X + i);
sort(X + 1, X + 1 + n);
X[0] = X[1] - h;
X[n + 1] = X[n] + h;
for (int i = 1; i <= n; i++) {
if (X[i] - X[i - 1] < h)
L[i] = L[i - 1];
else
L[i] = i;
}
for (int i = n; i >= 1; i--) {
if (X[i + 1] - X[i] < h)
R[i] = R[i + 1];
else
R[i] = i;
}
printf("%.15f\n", dpit(1, n, 0, 1));
return 0;
}
| 2,300 | CPP |
n = int(input())
x = 0
for i in range(n):
oper = input()
if '--' in oper:
x -= 1
elif "++" in oper:
x += 1
print(x) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, top;
long long b, s;
struct node {
long long x, y;
node(long long x = 0, long long y = 0) : x(x), y(y) {}
} sta[300005];
int read() {
char c = getchar();
int x = 0;
while (!isdigit(c)) c = getchar();
while (isdigit(c)) {
x = (x << 3) + (x << 1) + c - '0';
c = getchar();
}
return x;
}
double slope(node a, node b) {
return (double)(a.y - b.y) / (double)(a.x - b.x);
}
long long calc(node a) { return a.x * s + a.y + b; }
int main() {
n = read();
m = read();
sta[++top] = node(0, 0);
while (m--) {
int opt = read();
if (opt == 1) {
int k = read();
b = s = 0;
sta[top = 1] = node(0, 0);
n += k;
} else if (opt == 2) {
int k = read();
node cur(n, -b - s * n);
n += k;
while (top >= 2 && slope(sta[top - 1], sta[top]) > slope(sta[top], cur))
--top;
sta[++top] = cur;
} else {
int B = read(), S = read();
b += B;
s += S;
}
while (top >= 2 && calc(sta[top]) >= calc(sta[top - 1])) --top;
printf("%I64d %I64d\n", sta[top].x + 1, calc(sta[top]));
}
}
| 2,700 | CPP |
n = int(input())
for i in range(n):
word = input()
answer = word
if len(word) > 10:
answer = word[0] + str(len(word)-2) + word[-1]
print(answer)
| 800 | PYTHON3 |
n=int(input())
tmp=input().split()
arr=[]
for i in tmp:
arr.append(int(i))
for i in range(n):
arr[i]+=50000
print(n+1)
print(1,n,50000)
for i in range(n):
print(2,i+1,arr[i]-i) | 1,400 | PYTHON3 |
cases = int(input())
for _ in range(cases):
n = int(input())
arr = []
for i in range(n):
a, b = [int(i) for i in input().strip().split()]
arr.append((a, b, i))
arr.append((b, a, i))
arr.sort()
res = {}
def solve(arr):
n = len(arr)
lo = 0
idx = 0
while idx < n:
first = idx
aa, bb, ii = arr[lo]
while idx < n and arr[idx][0] == arr[first][0]:
a, b, i = arr[idx]
if (a > aa and b > bb) or (a > bb and b > aa):
res[i] = str(ii + 1)
idx += 1
if arr[first][1] < arr[lo][1]:
lo = first
solve(arr)
print(' '.join([res[i] if i in res else "-1" for i in range(n)]))
| 1,700 | PYTHON3 |
n, m = map(int, input().split())
day = 1
while n != 0:
if not day % m == 0:
n -= 1
day += 1
print(day - 1)
| 900 | PYTHON3 |
import sys,os,io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
PI = 3.141592653589793238460
INF = float('inf')
MOD = 1000000007
# MOD = 998244353
def bin32(num):
return '{0:032b}'.format(num)
def add(x,y):
return (x+y)%MOD
def sub(x,y):
return (x-y+MOD)%MOD
def mul(x,y):
return (x*y)%MOD
def gcd(x,y):
if y == 0:
return x
return gcd(y,x%y)
def lcm(x,y):
return (x*y)//gcd(x,y)
def power(x,y):
res = 1
x%=MOD
while y!=0:
if y&1 :
res = mul(res,x)
y>>=1
x = mul(x,x)
return res
def mod_inv(n):
return power(n,MOD-2)
def prob(p,q):
return mul(p,power(q,MOD-2))
def ii():
return int(input())
def li():
return [int(i) for i in input().split()]
def ls():
return [i for i in input().split()]
n = ii()
a = li()
dp = [ [ -INF for i in range( 62)] for j in range(n) ]
dp[0][a[0] + 30] = 0
ans = 0
for i in range(1 , n):
x = a[i] + 30
for j in range(x +1):
dp[i][x] = max( dp[i][x] , dp[i-1][j] + j - 30 , 0 )
ans = max(ans , dp[i][j])
for j in range(x+1 , 62):
dp[i][j] = max ( dp[i][j] , dp[i-1][j ] +a[i] )
ans = max(ans , dp[i][j])
print(ans)
| 2,000 | PYTHON3 |
from sys import stdin, stdout
a = stdin.readline()
b = a.replace("WUB", " ")
print(b)
| 900 | PYTHON3 |
import sys
import math
n = sys.stdin.readline()
m = sys.stdin.readline()
kn = [0] * 26
km = [0] * 26
for i in n:
if(i != "\n"):
kn[ord(i) - ord('a')] += 1
for i in m:
if(i != "\n"):
km[ord(i) - ord('a')] += 1
res = 0
for i in range(26):
v = min(kn[i], km[i])
if(kn[i] == 0 and km[i] > 0):
print(-1)
exit()
res += v
print(res)
| 1,200 | PYTHON3 |
from sys import stdin, stdout
import math,sys,heapq
from itertools import permutations, combinations
from collections import defaultdict,deque,OrderedDict
from os import path
import random
import bisect as bi
def yes():print('YES')
def no():print('NO')
if (path.exists('input.txt')):
#------------------Sublime--------------------------------------#
sys.stdin=open('input.txt','r');sys.stdout=open('output.txt','w');
def I():return (int(input()))
def In():return(map(int,input().split()))
else:
#------------------PYPY FAst I/o--------------------------------#
def I():return (int(stdin.readline()))
def In():return(map(int,stdin.readline().split()))
#sys.setrecursionlimit(1500)
def dict(a):
d={}
for x in a:
if d.get(x,-1)!=-1:
d[x]+=1
else:
d[x]=1
return d
def find_gt(a, x):
'Find leftmost value greater than x'
i = bi.bisect_left(a, x)
if i != len(a):
return i
else:
return -1
def main():
try:
n,k=In()
l=list(In())
l.sort()
ans=0
for x in range(1,n):
if k>=l[x]:
ans+=(k-l[x])//l[0]
print(ans)
except:
pass
M = 998244353
P = 1000000007
if __name__ == '__main__':
for _ in range(I()):main()
#for _ in range(1):main() | 800 | PYTHON3 |
h, l = map(int, input().split(" "))
out = float((h**2) + (l **2)) / (2*h) - h
print(out)
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long int w;
struct data {
long long int x, v;
} a[100005];
bool operator<(const data &a, const data &b) {
long long int t = (a.x * (b.v + w) - b.x * (a.v + w));
if (t > 0)
t = 1;
else if (t == 0)
t = 0;
else
t = -1;
t *= (a.v + w) * (b.v + w);
if (t != 0) return t < 0;
t = (a.x * (b.v - w) - b.x * (a.v - w));
if (t > 0)
t = 1;
else if (t == 0)
t = 0;
else
t = -1;
t *= (a.v - w) * (b.v - w);
return t > 0;
}
long double b[100005];
int fen[100005];
int n;
void update(int p, int val) {
for (int i = p; i <= n; i += i & -i) {
fen[i] += val;
}
}
int sum(int p) {
int ans = 0;
for (int i = p; i; i -= i & -i) {
ans += fen[i];
}
return ans;
}
vector<pair<long double, long long int> > v;
long long int c[100005];
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cin >> n >> w;
for (int i = 1; i <= n; i++) cin >> a[i].x >> a[i].v;
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) b[i] = a[i].x * 1.0 / (a[i].v - w);
for (int i = 1; i <= n; i++)
v.push_back(pair<long double, long long int>(b[i], -i));
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) c[-v[i].second] = i + 1;
long long int res = 0;
for (int i = n; i >= 1; i--) {
res += sum(c[i]);
update(c[i], 1);
}
cout << res << endl;
return 0;
}
| 2,500 | CPP |
for _ in range(int(input())):
n, k = map(int, input().split())
k -= 1
print(k//(n-1)*n+k % (n-1)+1)
| 1,200 | PYTHON3 |
word = input()
if len(word)>1:
if word.isupper() == True:
word = word.lower()
elif word[1:].isupper() == True:
word = word.title()
else:
if word.islower() == True:
word=word.upper()
else:
word=word.lower()
print(word) | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(long long n) {
if (n == 1) return false;
if (n == 2) return true;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
long long t = 1;
while (t--) {
long long n, pre = 0, ans = 1;
cin >> n;
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
set<long long> s, day;
vector<long long> vv;
for (long long i = 0; i < n; i++) {
if (v[i] > 0) {
if (s.find(v[i]) != s.end() || day.find(v[i]) != day.end()) {
ans = 0;
break;
} else {
s.insert(v[i]);
}
} else {
v[i] = abs(v[i]);
day.insert(v[i]);
if (s.find(v[i]) == s.end()) {
ans = 0;
break;
}
s.erase(v[i]);
if (s.empty()) {
day.clear();
vv.push_back(i + 1 - pre);
pre = i + 1;
}
}
}
if (ans && day.size() == 0 && s.size() == 0) {
cout << vv.size() << endl;
for (auto x : vv) cout << x << " ";
} else
cout << -1 << endl;
}
return 0;
}
| 1,400 | CPP |
def equivalentStrings(s1, s2, pairs):
leng = len(s1)
if leng % 2 != 0:
return 'YES' if s1 == s2 else 'NO'
if s1 == s2:
pairs.add((s1, s2))
return 'YES'
if ((s1, s2) in pairs or (s2, s1) in pairs) or (equivalentStrings(s1[:leng // 2], s2[:leng // 2], pairs) == 'YES' and equivalentStrings(s1[leng // 2:], s2[leng // 2:], pairs) == 'YES') or (equivalentStrings(s1[:leng // 2], s2[leng // 2:], pairs) == 'YES' and equivalentStrings(s1[leng // 2:], s2[:leng // 2], pairs) == 'YES'):
pairs.add((s1, s2))
return 'YES'
return 'NO'
s1 = input()
s2 = input()
pairs = set()
print(equivalentStrings(s1, s2, pairs)) | 1,700 | PYTHON3 |
n = int(input())
a = list(map(int, input().split()))
a.sort()
c = set()
if a[0] != 1:
c.add(a[0] - 1)
else:
c.add(a[0])
for i in range(1, n):
if a[i] != 1 and a[i] - 1 not in c:
c.add(a[i] - 1)
elif a[i] not in c:
c.add(a[i])
elif a[i] + 1 not in c:
c.add(a[i] + 1)
print(len(c))
exit(0) | 1,500 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
inline bool checkBit(long long n, int i) { return n & (1LL << i); }
inline long long setBit(long long n, int i) {
return n | (1LL << i);
;
}
inline long long resetBit(long long n, int i) { return n & (~(1LL << i)); }
int fx[] = {0, +1, 0, -1};
int fy[] = {-1, 0, +1, 0};
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline bool isLeapYear(long long year) {
return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
}
inline void normal(long long &a) {
a %= 1000000007;
(a < 0) && (a += 1000000007);
}
inline long long modMul(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a * b) % 1000000007;
}
inline long long modAdd(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a + b) % 1000000007;
}
inline long long modSub(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long modPow(long long b, long long p) {
long long r = 1;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline long long modInverse(long long a) { return modPow(a, 1000000007 - 2); }
inline long long modDiv(long long a, long long b) {
return modMul(a, modInverse(b));
}
inline bool isInside(pair<int, int> p, long long n, long long m) {
return (p.first >= 0 && p.first < n && p.second >= 0 && p.second < m);
}
inline bool isInside(pair<int, int> p, long long n) {
return (p.first >= 0 && p.first < n && p.second >= 0 && p.second < n);
}
inline bool isSquare(long long x) {
long long s = sqrt(x);
return (s * s == x);
}
inline bool isFib(long long x) {
return isSquare(5 * x * x + 4) || isSquare(5 * x * x - 4);
}
inline bool isPowerOfTwo(long long x) {
return ((1LL << (long long)log2(x)) == x);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
int cnt, a, b;
cnt = a = b = inf;
int b1 = 0;
while ((b1 * 7) <= n) {
int a1 = n - (7 * b1);
if (a1 % 4 == 0) {
a1 /= 4;
int cnt1 = a1 + b1;
if (cnt1 == cnt) {
if (b1 < b) {
b = b1;
a = a1;
}
} else if (cnt1 < cnt) {
b = b1;
a = a1;
cnt = cnt1;
}
}
b1++;
}
if (cnt == inf) {
cout << -1 << '\n';
} else {
while (a--) cout << 4;
while (b--) cout << 7;
cout << '\n';
}
}
| 1,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class P, class Q>
ostream& operator<<(ostream& stream, pair<P, Q> v) {
stream << "(" << v.first << ',' << v.second << ")";
return stream;
}
template <class T>
ostream& operator<<(ostream& stream, const vector<T> v) {
stream << "[ ";
for (int i = 0; i < (int)v.size(); i++) stream << v[i] << " ";
stream << "]";
return stream;
}
template <class T>
T smin(T& a, T b) {
if (a > b) a = b;
return a;
}
template <class T>
T smax(T& a, T b) {
if (a < b) a = b;
return a;
}
inline int readChar();
template <class T = int>
inline T readInt();
template <class T>
inline void writeInt(T x, char end = 0);
inline void writeChar(int x);
inline void writeWord(const char* s);
static const int buf_size = 4096;
inline int getChar() {
static char buf[buf_size];
static int len = 0, pos = 0;
if (pos == len) pos = 0, len = fread(buf, 1, buf_size, stdin);
if (pos == len) return -1;
return buf[pos++];
}
inline int readChar() {
int c = getChar();
while (c <= 32) c = getChar();
return c;
}
template <class T>
inline T readInt() {
int s = 1, c = readChar();
T x = 0;
if (c == '-') s = -1, c = getChar();
while ('0' <= c && c <= '9') x = x * 10 + c - '0', c = getChar();
return s == 1 ? x : -x;
}
static int write_pos = 0;
static char write_buf[buf_size];
inline void writeChar(int x) {
if (write_pos == buf_size)
fwrite(write_buf, 1, buf_size, stdout), write_pos = 0;
write_buf[write_pos++] = x;
}
template <class T>
inline void writeInt(T x, char end) {
if (x < 0) writeChar('-'), x = -x;
char s[24];
int n = 0;
while (x || !n) s[n++] = '0' + x % 10, x /= 10;
while (n--) writeChar(s[n]);
if (end) writeChar(end);
}
inline void writeWord(const char* s) {
while (*s) writeChar(*s++);
}
struct Flusher {
~Flusher() {
if (write_pos) fwrite(write_buf, 1, write_pos, stdout), write_pos = 0;
}
} flusher;
const int N = 1e5 + 5;
int s[N];
int gcd(int a, int b) { return !b ? a : gcd(b, a % b); }
int was[N];
int p[N];
int main(void) {
int n;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
n = readInt();
for (int i = 1; i <= n; ++i) s[i] = readInt(), p[i] = i;
while (clock() < 0.1 * CLOCKS_PER_SEC) {
shuffle(p + 1, p + 1 + n, rng);
int cnt = s[p[1]];
int g = 0;
was[p[1]] = 2;
for (int i = 2; i <= n; ++i) {
int gg = gcd(s[p[i]], cnt);
if (gg == cnt) {
was[p[i]] = 1;
g = gcd(g, s[p[i]]);
} else {
cnt = gg;
was[p[i]] = 2;
}
}
if (cnt == 1 && g == 1) {
writeChar('Y');
writeChar('E');
writeChar('S');
writeChar('\n');
for (int i = 1; i <= n; ++i) {
writeInt(was[i], " \n"[i == n]);
}
return 0;
}
}
puts("NO");
return 0;
}
| 2,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
int cc = 0, c[2 * 1000005], tot = 0, n, m, tree[1000005][26], mark[1000005],
b[1000005], bj[1000005], fail[1000005], g[1000005], loc[1000005],
st[1000005], ed[1000005], last[1000005];
vector<int> d[1000005], dui;
void add(int ii, string ss) {
int i, p, w = 0;
for (i = 0; i < (int)ss.size(); i++) {
p = ss[i] - 'a';
if (!tree[w][p]) tree[w][p] = ++tot;
w = tree[w][p];
}
mark[w]++;
b[ii] = w;
}
void bfs() {
int h, t, fa, p, i;
for (h = t = 1; h <= t; h++) {
fa = g[h];
for (i = 0; i < 26; i++)
if (tree[fa][i]) {
p = fail[fa];
while (p && !tree[p][i]) p = fail[p];
if (tree[p][i] && tree[p][i] != tree[fa][i])
fail[tree[fa][i]] = tree[p][i];
g[++t] = tree[fa][i];
d[fail[g[t]]].push_back(g[t]);
}
}
}
void dfs() {
int p;
dui.push_back(0);
st[0] = ++cc;
while (!dui.empty()) {
p = dui[dui.size() - 1];
if (last[p] == d[p].size()) {
ed[p] = ++cc;
dui.pop_back();
} else {
dui.push_back(d[p][last[p]]);
st[d[p][last[p]]] = ++cc;
last[p]++;
}
}
}
void change(int v, int w) {
for (; v <= cc; v += v & (-v)) c[v] += w;
}
void init() {
int i;
string ss;
scanf("%d%d\n", &m, &n);
for (i = 1; i <= n; i++) {
getline(cin, ss);
add(i, ss);
}
bfs();
dfs();
for (i = 0; i <= tot; i++) {
change(st[i], mark[i]);
change(ed[i], -mark[i]);
}
}
int sum(int v) {
int tq = 0;
for (; v; v -= v & (-v)) tq += c[v];
return tq;
}
void calc(string ss) {
long long ans = 0;
int i, p, w = 0;
for (i = 0; i < (int)ss.size(); i++) {
p = ss[i] - 'a';
while (w && !tree[w][p]) w = fail[w];
if (tree[w][p]) w = tree[w][p];
ans += sum(st[w]);
}
cout << ans << endl;
}
void work() {
char op;
int i, tq;
string ss;
for (i = 1; i <= m; i++) {
op = getchar();
if (op == '?') {
getline(cin, ss);
calc(ss);
} else {
scanf("%d\n", &tq);
if (op == '+') {
if (bj[tq]) {
bj[tq] = 0;
change(st[b[tq]], mark[b[tq]]);
change(ed[b[tq]], -mark[b[tq]]);
}
} else {
if (!bj[tq]) {
bj[tq] = 1;
change(st[b[tq]], -mark[b[tq]]);
change(ed[b[tq]], mark[b[tq]]);
}
}
}
}
}
int main() {
init();
work();
}
| 2,800 | CPP |
t = int(input())
for _ in range(t):
n, m = map(int, input().split())
scr = list(input().split())
scr = [int(i) for i in scr]
s = sum(scr)
if s <= m:
print(s)
else:
print(m)
| 800 | PYTHON3 |
n=int(input())
a=[int(x) for x in input().split()]
b=[]
j=1
for i in a:
b.append((i,j))
j+=1
b.sort()
j=0
while j!=n/2:
print(b[j][1], b[n-j-1][1])
j+=1
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const double epsilon = 1e-7;
vector<vector<int>> g(100005);
int sz[100005], fa[100005];
int n, minn = 1e9, cent1, cent2;
void dfs(int x, int f) {
fa[x] = f;
sz[x] = 1;
int mx = 0;
for (auto y : g[x]) {
if (y == f) continue;
dfs(y, x);
sz[x] += sz[y];
mx = max(mx, sz[y]);
}
mx = max(mx, n - sz[x]);
if (mx < minn) {
minn = mx;
cent1 = x;
cent2 = 0;
} else if (mx == minn) {
cent2 = x;
}
}
int S;
void dfs2(int x, int f) {
if (g[x].size() == 1) {
S = x;
return;
}
for (auto y : g[x]) {
if (y == f) continue;
dfs2(y, x);
}
}
void solve() {
cent1 = cent2 = 0;
minn = 1e9;
cin >> n;
for (int i = 1; i < n + 1; ++i) {
g[i].clear();
fa[i] = 0;
}
for (int i = 0; i < n - 1; ++i) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(1, 0);
if (!cent2) {
cout << 1 << " " << g[1][0] << endl;
cout << 1 << " " << g[1][0] << endl;
return;
}
if (fa[cent1] != cent2) swap(cent1, cent2);
dfs2(cent1, cent2);
cout << S << " " << fa[S] << endl;
cout << S << " " << cent2 << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n % 2 != 0) {
cout << -1;
} else {
for (int i = n; i > 0; i--) {
cout << i << " ";
}
}
}
| 800 | CPP |
def sol(arr: list)->tuple:
minl = []
prev = float('inf')
for i in arr:
prev = min(prev,i)
minl.append(prev)
minr = []
prev = float('inf')
for i in reversed(arr):
prev = min(prev,i)
minr.append(prev)
minr.reverse()
for i in range(len(arr)):
if minl[i]<arr[i] and arr[i]>minr[i]:
for l in range(i):
if arr[l]<arr[i]:
break
for r in range(i,len(arr)):
if arr[r]<arr[i]:
break
return [l,i,r]
else:
return []
T = int(input())
tmp = []
p = print
# def print(*args,**kwargs):
# tmp.append((args,kwargs))
# def flush():
# for args,kwargs in tmp:
# p(*args,**kwargs)
# return
for _ in range(T):
n = input()
row = [*map(int,input().split(' '))]
out = sol(row)
if out:
print("YES")
i,j,k = out
print(i+1,j+1,k+1)
else:
print("NO")
# flush() | 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using pi = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vector<int> >;
const long long infl = 1LL << 60;
int mod = 1e9 + 7;
long long dp[2009][2009];
int n, l, r, h;
int a[2009];
long long helper(int d, int t) {
if (d == n + 1) {
if (t <= r && t >= l) return 1;
return 0;
}
if (dp[d][t] != -1) return dp[d][t];
long long x = dp[d + 1][(t + a[d]) % h], y = dp[d + 1][(t + a[d] - 1) % h];
if (x == -1) {
x = helper(d + 1, (t + a[d]) % h);
dp[d + 1][(t + a[d]) % h] = x;
}
if (y == -1) {
y = helper(d + 1, (t + a[d] - 1) % h);
dp[d + 1][(t + a[d] - 1) % h] = y;
}
dp[d][t] = max(max(x, y), 0LL);
if (t <= r && t >= l && d > 1) dp[d][t]++;
return dp[d][t];
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> h >> l >> r;
memset(dp, -1, sizeof(dp));
for (int i = 1; i <= n; i++) cin >> a[i];
cout << helper(1, 0) << endl;
return 0;
}
| 1,700 | CPP |
def solve():
s = input()
if 'aa' in s or 'bb' in s or 'cc' in s:
print(-1)
return
syms = s + '@'
ans = ['@']
for i, sym in enumerate(s):
if sym != '?':
ans.append(sym)
continue
for x in 'abc':
if x != ans[-1] and x != syms[i + 1]:
ans.append(x)
break
print(''.join(ans[1:]))
def solveb():
n = int(input())
perm = [int(x) for x in input().split()]
num___idx = [-1 for _ in range(n + 1)]
for i, num in enumerate(perm):
num___idx[num] = i
curr_max = -1
curr_min = 2 * n
num___pretty = [0 for _ in range(n + 1)]
for num in range(1, n + 1):
curr_max = max(num___idx[num], curr_max)
curr_min = min(num___idx[num], curr_min)
if curr_max - curr_min + 1 == num:
num___pretty[num] = 1
print(*num___pretty[1:], sep='')
def solvec():
n = int(input())
rank___problems_nr = [int(x) for x in input().split()]
weird_prefsums = [0]
last_num = rank___problems_nr[0]
for num in rank___problems_nr:
if num != last_num:
last_num = num
weird_prefsums.append(weird_prefsums[-1])
weird_prefsums[-1] += 1
gold = weird_prefsums[0]
silvers = 0
i = 1
for i in range(1, len(weird_prefsums)):
x = weird_prefsums[i]
if x - gold > gold:
silvers = x - gold
break
bronzes = 0
for j in range(i, len(weird_prefsums)):
x = weird_prefsums[j]
if x > n / 2:
break
if x - gold - silvers > gold:
bronzes = x - gold - silvers
if bronzes == 0 or silvers == 0:
print(0, 0, 0)
return
print(gold, silvers, bronzes)
def solved():
a, b, c, d = (int(x) for x in input().split())
ab_len = min(a, b)
a -= ab_len
b -= ab_len
cd_len = min(c, d)
c -= cd_len
d -= cd_len
if a == 1 and cd_len == 0 and d == 0 and c == 0:
print('YES')
print('0 1 ' * ab_len + '0')
return
if d == 1 and ab_len == 0 and a == 0 and b == 0:
print('YES')
print('3 ' + '2 3 ' * cd_len)
return
if a > 0 or d > 0:
print('NO')
return
cb_len = min(b, c)
b -= cb_len
c -= cb_len
if b > 1 or c > 1:
print('NO')
return
print('YES')
print('1 ' * b + '0 1 ' * ab_len + '2 1 ' * cb_len + '2 3 ' * cd_len + '2' * c)
def get_me(prob, mod):
# return 100, prob
return (100 * pow(prob, mod - 2, mod)) % mod
def solvee():
n = int(input())
mod = 998244353
idx___prob = [int(x) for x in input().split()]
curr_me = get_me(idx___prob[0], mod)
for prob in idx___prob[1:]:
me = get_me(prob, mod)
curr_me *= me
curr_me %= mod
curr_me += me
curr_me %= mod
# curr_q_me = pow(curr_q_me, mod - 2, mod)
print(curr_me)
if __name__ == '__main__':
solvee()
| 2,100 | PYTHON3 |
n = int(input())
x, y, z = map(int, input().split())
sumx = x
sumy = y
sumz = z
for i in range(n-1):
x, y, z = map(int, input().split())
sumx = sumx + x
sumy = sumy + y
sumz = sumz + z
if sumx == 0 and sumy == 0 and sumz == 0:
print("YES")
else:
print("NO")
| 1,000 | PYTHON3 |
s=input().split("WUB")
s=list(s)
for i in s:
if i=="":
s.remove(i)
print(" ".join(s))
| 900 | PYTHON3 |
import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush, nlargest, nsmallest
from math import ceil, floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
# sys.setrecursionlimit(pow(10, 6))
# sys.stdin = open("input.txt", "r")
# sys.stdout = open("output.txt", "w")
mod = pow(10, 9) + 7
mod2 = 998244353
def data(): return sys.stdin.readline().strip()
def out(*var, end="\n"): sys.stdout.write(" ".join(map(str, var))+end)
def l(): return list(sp())
def sl(): return list(ssp())
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]
n = int(data())
s1, s2 = deque(l()[1:]), deque(l()[1:])
state = set()
state.add((tuple(s1), tuple(s2)))
cnt = 0
while True:
t1, t2 = s1.popleft(), s2.popleft()
if t1 > t2:
s1.append(t2)
s1.append(t1)
else:
s2.append(t1)
s2.append(t2)
# print(s1, s2)
if not s1:
out(cnt + 1, 2)
exit()
if not s2:
out(cnt + 1, 1)
exit()
cnt += 1
if (tuple(s1), tuple(s2)) in state or (tuple(s2), tuple(s1)) in state:
out(-1)
exit()
state.add((tuple(s1), tuple(s2)))
| 1,400 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t;
cin >> t;
for (long long int test = 1; test <= t; test++) {
long long int n, t, second;
cin >> n >> t >> second;
long long int both = t + second - n;
t -= both;
second -= both;
cout << max(t, second) + 1, cout << "\n";
}
cerr << "\nTime elapsed : " << 1000 * clock() / CLOCKS_PER_SEC << " ms\n";
return 0;
}
| 900 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int n, m;
int rub[N], RUB[N], t[N], used[N];
bool sw;
bool ck(int x) {
for (int i = 0; i < (m); i++) {
used[i] = min(x, t[i]);
x = used[i];
RUB[i] = t[i] - used[i];
}
for (int i = (m)-1; i >= 0; i--)
for (int j = 0; j < (i); j++) used[j] -= used[i];
int ted = 0;
for (int i = (m)-1; i >= 0; i--) {
ted -= rub[i] + RUB[i + 1];
if (ted < 0) return false;
ted += used[i];
}
ted -= RUB[0];
return (ted >= 0);
}
int f(long long x) {
int cnt = 0;
while (x) {
cnt++;
x /= 2;
}
m = max(m, cnt + 1);
cnt--;
return cnt;
}
int main() {
cin >> n;
for (int i = 0; i < (n); i++) {
long long x, y;
cin >> x;
y = f(x);
if ((1LL << y) == x)
t[y]++;
else
rub[y - 1]++;
}
for (int i = 0; i <= t[0]; i++)
if (ck(i)) cout << i << " ", sw = true;
if (!sw) cout << -1;
return 0;
}
| 2,200 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int MAX = 5e2 + 5;
const long long MAX2 = 11;
const long long MOD = 998244353;
const long long MOD2 = 2010405347;
const long long INF = 2e18;
const int dr[] = {-1, 0, 1, 0, 1, 1, -1, -1, 0};
const int dc[] = {0, -1, 0, 1, 1, -1, 1, -1, 0};
const double pi = acos(-1);
const double EPS = 1e-9;
const int block = 320;
long long tc, n, m,
p[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47}, k = 15, ans;
__int128 bt, nw;
void bf(int pos, int ls, long long rem) {
if (rem == 1) {
if (ans == -1)
ans = nw;
else
ans = min(ans, (long long)nw);
return;
}
if (pos == k) return;
__int128 mul = 1;
ls = min((long long)ls, rem);
for (long long i = 2; i <= ls; ++i) {
mul *= p[pos];
if (mul * nw > bt) break;
if (rem % i == 0) nw *= mul, bf(pos + 1, i, rem / i), nw /= mul;
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
m = 1000000000000000000;
ans = -1;
bt = m, nw = 1;
bf(0, 61, n);
cout << ans << '\n';
return 0;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long Maxn = 6e5 + 7;
const long long Max = 1e3 + 11;
const long long Mod = 1e9 + 7;
const long long Inf = 2e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
long long a, b, r;
cin >> a >> b >> r;
if (a < 2 * r || b < 2 * r) {
cout << "Second" << endl;
return 0;
}
cout << "First" << endl;
return 0;
}
| 1,600 | CPP |
n=int(input())
li=list(map(int,input().split()))
su=n*(n+1)//2
print(su-sum(li))
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v;
vector<pair<int, int> > pre, suf;
int main() {
int n;
scanf("%d", &n);
int l, r;
for (int i = 0; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
v.push_back(make_pair(a, b));
if (i == 0) {
pre.push_back(make_pair(a, b));
l = a;
r = b;
} else {
l = max(l, a);
r = min(r, b);
pre.push_back(make_pair(l, r));
}
}
for (int i = v.size() - 1; i >= 0; i--) {
if (i == v.size() - 1) {
suf.push_back(v[i]);
l = v[i].first;
r = v[i].second;
} else {
l = max(l, v[i].first);
r = min(r, v[i].second);
suf.push_back(make_pair(l, r));
}
}
reverse(suf.begin(), suf.end());
int ans = max(pre[v.size() - 2].second - pre[v.size() - 2].first,
suf[1].second - suf[1].first);
for (int i = 1; i < v.size() - 1; i++) {
l = max(pre[i - 1].first, suf[i + 1].first);
r = min(pre[i - 1].second, suf[i + 1].second);
ans = max(r - l, ans);
}
ans = max(0, ans);
printf("%d\n", ans);
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int64_t N = 1e6 + 5;
const int64_t MAX = 1e18;
vector<int64_t> V;
set<int64_t> sq, s;
int64_t sqroot(int64_t n) {
int64_t low = 0, high = n;
while (low < high) {
int64_t mid = low + (high - low + 1) / 2;
if (mid <= n / mid)
low = mid;
else
high = mid - 1;
}
return low;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
for (int64_t i = 2; i < N; i++) {
sq.insert(i * i);
if (sq.find(i) != sq.end()) continue;
int64_t temp = i;
while (i * i <= MAX / temp) {
temp *= (i * i);
s.insert(temp);
}
}
for (auto x : s) V.push_back(x);
int64_t q;
cin >> q;
while (q--) {
int64_t l, r;
cin >> l >> r;
int64_t res = sqroot(r) - sqroot(l - 1);
int64_t hi = (upper_bound(V.begin(), V.end(), r) - V.begin());
int64_t lo = (lower_bound(V.begin(), V.end(), l) - V.begin());
res += (hi - lo);
cout << res << "\n";
}
return 0;
}
| 2,100 | CPP |
n = int(input())
k = 1
a = input()
for i in range(1, n):
b = input()
if a[0] == a[1] or a[1] == b[0]:
k += 1
a = b
print(k)
| 800 | PYTHON3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.