solution
stringlengths 10
159k
| difficulty
int64 0
3.5k
| language
stringclasses 2
values |
|---|---|---|
a=str(input())
b="WUB"
a=a.replace(b," ")
i=0
while(i<len(a)):
if(a[i]!=" "):
c=i
break
i+=1
j=i
k=""
while(j<len(a)):
k+=a[j]
j+=1
r=0
v=" "
t=" "
while(r<len(k)):
k=k.replace(v,t)
r+=1
print(k)
| 900 | PYTHON3 |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
tc = []
t = int(input())
for t in range(t):
tc.append(input())
for x in tc:
i = len(x) - 1
v = []
while i >= 0:
if x[i] != '0':
v.append(x[i] + '0'*(len(x) - 1 - i))
i -= 1
print(len(v))
print(' '.join(v)) | 800 | PYTHON3 |
l,r=map(int,input().split())
print("YES")
for i in range(l,r,2):
print(str(i)+" "+str(i+1)) | 1,000 | PYTHON3 |
def gcd(a, b):
while a % b != 0:
a, b = b, a % b
return b
l = input().split(' ')
a, b, c, d = int(l[0]), int(l[1]), int(l[2]), int(l[3])
if a * d > b * c:
p = a * d - b * c
q = a * d
else:
p = b * c - a * d
q = b * c
e = gcd(p, q)
p //= e
q //= e
print(str(p) + "/" + str(q))
| 1,400 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300030, mod = 998244353;
inline int read() {
int x = 0, f = 0;
char ch = getchar();
while (ch < '0' || ch > '9') f |= ch == '-', ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return f ? -x : x;
}
int n, m, ans;
struct graph {
int el, head[maxn], to[maxn], nxt[maxn], deg[maxn], q[maxn], h, r, id[maxn],
at[maxn], cnt, tot1, tot2, pre[maxn];
bool f1[maxn], f2[maxn];
inline void add(int u, int v) {
to[++el] = v;
nxt[el] = head[u];
head[u] = el;
}
void topo() {
for (int u = (1); u <= (n); u++)
for (int i = head[u]; i; i = nxt[i]) deg[to[i]]++;
h = 1;
r = 0;
for (int i = (1); i <= (n); i++)
if (!deg[i]) q[++r] = i;
while (h <= r) {
int u = q[h++];
at[id[u] = ++cnt] = u;
for (int i = head[u]; i; i = nxt[i]) {
int v = to[i];
if (!--deg[v]) q[++r] = v;
}
}
}
void work(graph &G) {
for (int t = (1); t <= (n); t++) {
int u = at[t];
for (int i = G.head[u]; i; i = G.nxt[i]) {
int v = G.to[i];
deg[v]++;
if (deg[v] == 1) {
tot1--;
if (pre[v]) tot2--;
for (int j = head[v]; j; j = nxt[j]) {
int w = to[j];
pre[w]++;
if (pre[w] == 1 && !deg[w] && id[w] < id[u]) tot2++;
}
}
if (deg[v] == 2) {
for (int j = head[v]; j; j = nxt[j]) {
int w = to[j];
pre[w]--;
if (!pre[w] && !deg[w] && id[w] < id[u]) tot2--;
}
}
}
if (!tot1) f1[u] = true;
if (tot1 == 1 && !tot2) f2[u] = true;
tot1++;
if (pre[u]) tot2++;
}
}
} G1, G2;
int main() {
n = read();
m = read();
for (int i = (1); i <= (m); i++) {
int u = read(), v = read();
G1.add(u, v);
G2.add(v, u);
}
G1.topo();
G1.work(G2);
for (int i = (1); i <= (n); i++) G2.at[i] = G1.at[n - i + 1];
for (int i = (1); i <= (n); i++) G2.id[G2.at[i]] = i;
G2.work(G1);
for (int i = (1); i <= (n); i++)
if ((G1.f1[i] && (G2.f1[i] || G2.f2[i])) || (G1.f2[i] && G2.f1[i])) ans++;
printf("%d\n", ans);
}
| 2,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void ckmax(T& x, T y) {
x = (y > x ? y : x);
}
template <typename T>
inline void ckmin(T& x, T y) {
x = (y < x ? y : x);
}
const int MAXN = 2e5;
const int INF = 1e9;
const int BOUND = 448;
int n, mxa, a[MAXN + 5];
int cnt[MAXN + 5], mp[MAXN * 2 + 5];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
ckmax(mxa, a[i]);
cnt[a[i]]++;
}
int mx = 0, semx = 0;
for (int i = 1; i <= mxa; ++i) {
if (cnt[i] > cnt[mx]) {
semx = mx;
mx = i;
} else if (cnt[i] > cnt[semx]) {
semx = i;
}
}
if (!semx) {
cout << 0 << endl;
return 0;
}
if (cnt[semx] == cnt[mx]) {
cout << n << endl;
return 0;
}
int ans = 0;
for (int v = 1; v <= mxa; ++v) {
if (v == mx) continue;
if (cnt[v] <= BOUND) continue;
for (int i = 0; i <= n * 2; ++i) {
mp[i] = INF;
}
mp[n] = 0;
int presum = 0;
for (int i = 1; i <= n; ++i) {
int x = 0;
if (a[i] == mx)
x = 1;
else if (a[i] == v)
x = -1;
presum += x;
ckmax(ans, i - mp[presum + n]);
ckmin(mp[presum + n], i);
}
}
for (int frq = 1; frq <= BOUND; ++frq) {
for (int i = 1; i <= mxa; ++i) {
cnt[i] = 0;
}
for (int i = 1; i <= n; ++i) {
mp[i] = 0;
}
int l = 1;
for (int r = 1; r <= n; ++r) {
mp[cnt[a[r]]]--;
cnt[a[r]]++;
mp[cnt[a[r]]]++;
while (cnt[a[r]] > frq) {
mp[cnt[a[l]]]--;
cnt[a[l]]--;
mp[cnt[a[l]]]++;
++l;
}
if (mp[frq] >= 2) {
ckmax(ans, r - l + 1);
}
}
}
cout << ans << endl;
return 0;
}
| 2,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int M = 998244353;
char s[1000005];
int a, b, c, d, i, j;
long long fac[1000005], inv[1000005], ans;
long long C(long long n, long long m) {
return fac[n] * inv[m] % M * inv[n - m] % M;
}
int main() {
scanf("%s", s + 1);
for (i = 1; s[i]; ++i) {
if (s[i] == '?') ++b;
if (s[i] == ')') ++d;
}
inv[0] = inv[1] = fac[0] = 1;
for (i = 2; i <= 1000000; ++i) inv[i] = inv[M % i] * (M - M / i) % M;
for (i = 1; i <= 1000000; ++i) {
fac[i] = fac[i - 1] * i % M;
inv[i] = inv[i - 1] * inv[i] % M;
}
for (i = 1; s[i]; ++i) {
if (s[i] == '?') ++a, --b;
if (s[i] == '(') ++c;
if (s[i] == ')') --d;
for (j = max(c, d); j - c <= a && j - d <= b; ++j)
ans = (ans + C(a, j - c) * C(b, j - d) % M * j) % M;
}
cout << (ans % M + M) % M;
}
| 2,600 | CPP |
#include <bits/stdc++.h>
char inputLine[(50000 + 10)];
short level[(50000 + 10)];
int leftCost[(50000 + 10)];
int rightCost[(50000 + 10)];
int countUnknown;
int countLine;
bool canDo;
struct bracket {
int diff;
int position;
bool operator<(const bracket& r) const { return diff > r.diff; }
};
std::priority_queue<bracket, std::vector<bracket>, std::less<bracket> >
priorityQ;
void initialize() {
canDo = true;
memset(inputLine, 0, sizeof(inputLine));
memset(level, 0, sizeof(level));
return;
}
void readInput() {
char c = 0;
scanf("%s", inputLine);
countLine = strlen(inputLine);
int leftCount = 0;
int rightCount = 0;
long long totalCost = 0;
for (int i = 0; i < countLine; i++) {
if (inputLine[i] == '(')
leftCount++;
else if (inputLine[i] == ')')
rightCount++;
else {
int leftCost = 0;
int rightCost = 0;
scanf("%d%d", &leftCost, &rightCost);
totalCost += rightCost;
inputLine[i] = ')';
rightCount++;
struct bracket temp;
temp.position = i;
temp.diff = leftCost - rightCost;
priorityQ.push(temp);
}
if (leftCount < rightCount) {
if (priorityQ.empty()) {
canDo = false;
} else {
totalCost += priorityQ.top().diff;
inputLine[priorityQ.top().position] = '(';
priorityQ.pop();
rightCount--;
leftCount++;
}
}
}
if (!canDo || leftCount != rightCount)
printf("-1\n");
else {
printf("%I64d\n", totalCost);
printf("%s", inputLine);
printf("\n");
}
return;
}
int main() {
initialize();
readInput();
return 0;
}
| 2,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MOD = 1e9 + 7;
const int N = 1e6 + 10;
vector<vector<int>> G;
int n, m, cat[N], instack[N], stk[N], top, low[N], ti;
int tarjan(int x) {
int now = ++ti;
low[x] = now;
instack[x] = 1;
stk[top++] = x;
for (auto i : G[x]) {
if (!instack[i]) {
int ret = tarjan(i);
if (ret) return ret;
}
low[x] = min(low[x], low[i]);
}
if (low[x] == now) {
cat[x] = x;
while (stk[--top] != x) cat[stk[top]] = x;
return x;
} else
return 0;
}
void solve() {
int x = tarjan(1);
int sz = ti - low[x] + 1;
if (sz == n)
printf("No\n");
else {
printf("Yes\n%d %d\n", n - sz, sz);
for (int i = 1; i <= n; ++i)
if (cat[i] != x) printf("%d ", i);
printf("\n");
for (int i = 1; i <= n; ++i)
if (cat[i] == x) printf("%d ", i);
printf("\n");
}
}
void clear() {
G.clear();
G.resize(n + 1);
ti = top = 0;
memset(instack, 0, sizeof(int) * (n + 1));
memset(cat, 0, sizeof(int) * (n + 1));
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
G.reserve(N);
int T;
cin >> T;
while (T--) {
cin >> n >> m;
clear();
for (int i = 0, a, b; i < m; ++i) {
cin >> a >> b;
if (a != b) G[b].push_back(a);
}
solve();
}
return 0;
}
| 2,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC target("avx2")
#pragma GCC optimization("unroll-loops")
#pragma GCC optimize("O2")
constexpr int dx[] = {-1, 0, 1, 0, 1, 1, -1, -1};
constexpr int dy[] = {0, -1, 0, 1, 1, -1, 1, -1};
constexpr long long INF = 1999999999999999997;
constexpr int inf = INT_MAX;
constexpr int MAXSIZE = int(1e6) + 5;
constexpr auto PI = 3.14159265358979323846L;
constexpr auto oo = numeric_limits<int>::max() / 2 - 2;
constexpr auto eps = 1e-6;
constexpr auto mod = 1000000007;
constexpr auto MOD = 1000000007;
constexpr auto MOD9 = 1000000009;
constexpr auto maxn = 100006;
void fastio() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
map<int, vector<int>> f;
vector<int> v[MAXSIZE];
int parent[MAXSIZE];
int find_set(int a) {
if (a == parent[a]) return a;
return parent[a] = find_set(parent[a]);
}
void union_set(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (a > b) {
auto temp = a;
a = b;
b = temp;
};
parent[b] = a;
f[a].push_back(b);
f[b].push_back(a);
}
}
bool visited[MAXSIZE];
int main() {
fastio();
int n;
cin >> n;
for (int i = 1; i <= n; i++) parent[i] = i;
for (int i = 1; i <= n - 1; i++) {
int a, b;
cin >> a >> b;
a = find_set(a);
b = find_set(b);
parent[b] = a;
v[a].push_back(b);
}
int root = find_set(1);
function<void(int)> dfs = [&](int root) {
cout << root << " ";
for (auto i : v[root]) {
dfs(i);
}
};
dfs(root);
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool arr[4][4];
int main() {
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '0') {
bool bol = true;
for (int j = 0; j < 4 && bol; j++) {
for (int k = 0; k < 3 && bol; k++) {
if (!arr[k][j] && !arr[k + 1][j]) {
cout << k + 1 << " " << j + 1 << endl;
arr[k][j] = 1;
arr[k + 1][j] = 1;
bol = false;
}
}
}
} else {
bool bol = true;
for (int j = 0; j < 4 && bol; j++) {
for (int k = 0; k < 3 && bol; k++) {
if (!arr[j][k] && !arr[j][k + 1]) {
cout << j + 1 << " " << k + 1 << endl;
arr[j][k] = 1;
arr[j][k + 1] = 1;
bol = false;
}
}
}
}
for (int j = 0; j < 4; j++) {
bool bol = true;
for (int k = 0; k < 4; k++) {
if (!arr[j][k]) bol = false;
}
if (bol) {
for (int k = 0; k < 4; k++) {
arr[j][k] = 0;
}
}
}
for (int k = 0; k < 4; k++) {
bool bol = true;
for (int j = 0; j < 4; j++) {
if (!arr[j][k]) bol = false;
}
if (bol) {
for (int j = 0; j < 4; j++) {
arr[j][k] = 0;
}
}
}
}
return 0;
}
| 1,400 | CPP |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define fi first
#define se second
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define repi(i,a,b) for(int i=a;i>=b;i--)
#define vi vector<int>
#define vvi vector<vector<int> >
#define vll vector<long long int>
#define vvll vector<vector<long long> >
#define vb vector<bool>
#define pii pair<int,int>
#define tiii tuple<int,int,int>
#define mod 1000000007
#define mem1(x) memset(x,1,sizeof(x))
#define mem0(x) memset(x,0,sizeof(x))
#define memn1(x) memset(x,-1,sizeof(x))
#define fastio ios_base::sync_with_stdio(false),cin.tie(NULL)
#define inf 1e17+1
template<class x> x gcd(x a, x b) {return (b == 0) ? a : gcd(b, a % b);}
template<class x> x powerm(x a, x n) {if (n == 0)return 1; x b = powerm(a, n / 2) % mod; return (n & 1) ? ((b * b) % mod * a) % mod : (b * b) % mod;}
const int cnst = 7001;
void solve() {
int n;
cin >> n;
ll a[n + 1];
rep(i, 1, n) {
cin >> a[i];
}
ll ans = 0;
bool cnt[n + 2];
mem0(cnt);
rep(i, 2, n - 1) {
if ( (a[i] - a[i - 1]) * (a[i] - a[i + 1]) > 0 ) {
ans++;
cnt[i] = 1;
}
}
int m = 0;
rep(i, 1, n) {
vector<ll> tryy;
tryy.pb(a[i]);
tryy.pb(a[i] - 1);
tryy.pb(a[i] + 1);
if (i > 1) {
tryy.pb(a[i - 1]);
tryy.pb(a[i - 1] - 1);
tryy.pb(a[i - 1] + 1);
}
if (i < n) {
tryy.pb(a[i + 1]);
tryy.pb(a[i + 1] - 1);
tryy.pb(a[i + 1] + 1);
}
for (ll x : tryy) {
int tmp = cnt[i] + cnt[i - 1] + cnt[i + 1];
if ( i > 1 && i < n ) {
if ( (x - a[i - 1]) * (x - a[i + 1]) > 0 ) {
tmp--;
}
}
if (i > 2) {
if ( (a[i - 1] - a[i - 2]) * (a[i - 1] - x) > 0 ) {
tmp--;
}
}
if (i < n - 1) {
if ( (a[i + 1] - a[i + 2]) * (a[i + 1] - x) > 0 ) {
tmp--;
}
}
m = max(m, tmp);
}
}
cout << (ans - m) << endl;
}
int main() {
#ifndef ONLINE_JUDGE
//for reading input from input.txt
freopen("input.txt", "r", stdin);
//for writing output in output.txt
freopen("output.txt", "w", stdout);
#endif
int t = 1;
cin >> t;
while (t--) {
solve();
}
} | 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int BS(long long int n, long long int m) {
long long int level, lo = 1LL, hi = 1e10, mid, res = 0LL, tot, bad, add, x;
while (lo <= hi) {
mid = lo + (hi - lo) / 2;
x = mid;
add = (x - 1) * m;
bad = (x * m) + ((x * (x + 1)) / 2);
tot = n - bad + add;
if (tot <= 0) {
res = mid;
hi = mid - 1;
} else
lo = mid + 1;
}
return res;
}
int main() {
long long int i, j, k, n, m, ans, day;
scanf("%lld %lld", &(n), &(m));
if (n <= m) {
cout << n << endl;
return 0;
}
day = m;
ans = day + BS(n, m);
cout << ans << endl;
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long inf = 1e9;
const long long N = 1000 + 5;
long long ar[N], done[N], cnt[N];
long long n;
long long mex() {
for (long long i = 0; i < n; i++) cnt[i] = 0;
for (long long i = 0; i < n; i++) cnt[ar[i]] = 1;
long long mex = 0;
while (cnt[mex]) mex++;
return mex;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
cin >> t;
while (t--) {
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> ar[i];
}
vector<long long> ans;
while (1) {
long long m = mex();
if (m < n) {
ar[m] = m;
ans.push_back(m + 1);
} else {
long long ind = 0;
while (ind < n && ar[ind] == ind) ind++;
if (ind == n) break;
long long p = -1;
for (long long i = 0; i < n && p == -1; i++)
if (ar[i] == ind) p = i;
ar[p] = n;
ans.push_back(p + 1);
}
}
cout << ans.size() << '\n';
for (auto &inx : ans) cout << inx << " ";
cout << '\n';
}
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int INF = 0x3f3f3f3f;
const double PI = acos(-1.0);
const double eps = 1e-10;
const int M = 1e4 + 3;
const int maxn = 1e3 + 10;
vector<int> G[N];
int vis[N], cnt = 0;
void dfs(int u, int p) {
vis[u] = 1;
for (int v : G[u])
if (v != p) {
dfs(v, u);
if (!(vis[v] & 1))
cnt++;
else
vis[u] += vis[v];
}
}
int main() {
int n;
scanf("%d", &n);
if (n & 1) {
puts("-1");
return 0;
}
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d %d", &u, &v);
u--;
v--;
G[u].push_back(v);
G[v].push_back(u);
}
dfs(0, -1);
printf("%d\n", cnt);
return 0;
}
| 1,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int fx[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
const int fxx[8][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0},
{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
template <typename T, typename TT>
ostream& operator<<(ostream& s, pair<T, TT> t) {
return s << "(" << t.first << "," << t.second << ")";
}
template <typename T>
ostream& operator<<(ostream& s, vector<T> t) {
s << "[";
for (int i = 0; i < ((int)(t.size())) - 1; i++) s << t[i] << ", ";
s << t[((int)(t.size())) - 1] << "]";
return s;
}
const int MOD = 1e9 + 7;
template <typename T>
inline T gcD(T a, T b) {
if (a < b) swap(a, b);
while (b) {
a = a % b;
b ^= a;
a ^= b;
b ^= a;
};
return a;
}
template <typename T>
inline T pow_mod(T a, T b) {
T res = 1;
while (b) {
if (b & 1) res = (res * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
return res;
}
const int MAXN = 110;
int mat[MAXN][MAXN];
void shiftRow(int i, int N, int M) {
int a = mat[i][M];
for (int j = M; j > 1; j--) {
mat[i][j] = mat[i][j - 1];
}
mat[i][1] = a;
}
void shiftColumn(int i, int N, int M) {
int a = mat[N][i];
for (int j = N; j > 1; j--) {
mat[j][i] = mat[j - 1][i];
}
mat[1][i] = a;
}
void init(int N, int M) {
for (int i = 1; i < N + 1; i++) {
for (int j = 1; j < M + 1; j++) {
mat[i][j] = 0;
}
}
}
struct Query {
int t, r, c, x;
};
Query query[MAXN * MAXN];
int main() {
int n, m, q;
cin >> n >> m >> q;
init(n, m);
for (int i = 0; i < q; i++) {
int t, r, c, x;
t = r = c = x = 0;
cin >> t;
if (t == 1) {
cin >> r;
} else if (t == 2) {
cin >> c;
} else if (t == 3) {
cin >> r >> c >> x;
}
query[i] = (Query){t, r, c, x};
}
reverse(query, query + q);
for (int i = 0; i < q; i++) {
Query qq = query[i];
if (qq.t == 1) {
shiftRow(qq.r, n, m);
} else if (qq.t == 2) {
shiftColumn(qq.c, n, m);
} else if (qq.t == 3) {
mat[qq.r][qq.c] = qq.x;
}
}
for (int i = 1; i < n + 1; i++) {
for (int j = 1; j < m + 1; j++) cout << mat[i][j] << ' ';
cout << endl;
}
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
bool Max(T1 &a, T2 b) {
return a < b ? a = b, 1 : 0;
}
template <typename T1, typename T2>
bool Min(T1 &a, T2 b) {
return a > b ? a = b, 1 : 0;
}
template <int MOD>
struct ModInt {
unsigned x;
ModInt() : x(0) {}
ModInt(signed sig) : x(sig) {}
ModInt(signed long long sig) : x(sig % MOD) {}
int get() const { return (int)x; }
ModInt pow(unsigned p) {
ModInt res = 1, a = *this;
while (p) {
if (p & 1) res *= a;
a *= a;
p >>= 1;
}
return res;
}
ModInt &operator+=(ModInt that) {
if ((x += that.x) >= MOD) x -= MOD;
return *this;
}
ModInt &operator-=(ModInt that) {
if ((x += MOD - that.x) >= MOD) x -= MOD;
return *this;
}
ModInt &operator*=(ModInt that) {
x = (unsigned long long)x * that.x % MOD;
return *this;
}
ModInt &operator/=(ModInt that) { return (*this) *= that.pow(MOD - 2); }
ModInt operator+(ModInt that) const { return ModInt(*this) += that; }
ModInt operator-(ModInt that) const { return ModInt(*this) -= that; }
ModInt operator*(ModInt that) const { return ModInt(*this) *= that; }
ModInt operator/(ModInt that) const { return ModInt(*this) /= that; }
};
const int N = 52, M = 100;
ModInt<1000000007> f[N][N], f2[N][N];
ModInt<1000000007> invf[N];
ModInt<1000000007> inv[N];
ModInt<1000000007> C(ModInt<1000000007> n, int k) {
ModInt<1000000007> ret = invf[k];
for (int i = 0; i < (k); ++i) {
ret *= n - i;
}
return ret;
}
void solve() {
int n, m;
cin >> n >> m;
invf[0] = 1;
for (int i = 1; i <= (n); ++i)
invf[i] = invf[i - 1] * i, inv[i] = (ModInt<1000000007>)1 / i;
invf[n] = (ModInt<1000000007>)1 / invf[n];
for (int i = n - 1; i >= (1); --i) invf[i] = invf[i + 1] * (i + 1);
f[0][1] = 1;
for (int i = 1; i <= (n); ++i)
for (int j = 1; j <= (i + 1); ++j) {
for (int ltn = 0; ltn <= (i - 1); ++ltn)
for (int lm = j; lm <= (ltn + 1); ++lm)
if (f[ltn][lm].x)
for (int rm = j; rm <= (lm > j ? j : i - ltn); ++rm) {
f2[i][j] += f[ltn][lm] * f[i - 1 - ltn][rm];
}
if (f2[i][j].x) {
for (int i2 = n; i2 >= (0); --i2)
for (int j2 = i2 + 1; j2 >= (1); --j2) {
ModInt<1000000007> comb = 1;
for (int cnt = 1; i2 + cnt * i <= n; cnt++) {
comb *= f2[i][j] + cnt - 1;
comb *= inv[cnt];
f[i2 + cnt * i][j2 + cnt * j] += f[i2][j2] * comb;
}
}
}
}
cout << f[n][m].x << '\n';
}
void init() {}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.setf(ios::fixed);
cout.precision(20);
init();
int TC = 1;
for (int TI = 1; TI <= (TC); ++TI) {
solve();
}
return 0;
}
| 2,900 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const double pi = acos(-1.0);
const int Max = 2010;
const int INF = 1e9 + 7;
struct point {
int h, m;
} points[2][Max];
int rem[2][Max];
int n, x;
int p[2] = {0, 0};
int solve(int type) {
int H = x;
int ans = 0;
memset(rem, 0, sizeof rem);
while (1) {
int nt = -1;
int m = 0;
for (int i = 0; i < p[type]; i++) {
if (points[type][i].h <= H && !rem[type][i] && points[type][i].m > m) {
nt = i;
m = points[type][i].m;
}
}
if (nt == -1) return ans;
ans++;
rem[type][nt] = 1;
H += m;
type ^= 1;
}
}
int main() {
scanf("%d%d", &n, &x);
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
scanf("%d%d", &points[a][p[a]].h, &points[a][p[a]].m);
p[a]++;
}
cout << max(solve(0), solve(1)) << endl;
return 0;
}
| 1,500 | CPP |
# cook your dish here
t = int(input())
while(t):
n,m = map(int, input().split())
if(n%m==0):
print("YES")
else:
print("NO")
t-=1 | 800 | PYTHON3 |
T=int(input())
for i in range(T):
n,pos=list(map(int,input().split()))
print(pos*2)
| 800 | PYTHON3 |
x=int(input())
for i in range(x):
d=''
z=[]
y=input()
if len(y)<=10:
print(y)
else:
z.append(y[0])
z.append(y[len(y)-1])
d=d+str(z[0])
d=d+str(len(y)-2)
d=d+str(z[1])
print(d) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int q = 1e9 + 7;
const int maxn = 1e5 + 5;
inline int Plus(int x, int y) { return (x += y) >= q ? x - q : x; }
inline void Pe(int &x, int y) { x = Plus(x, y); }
inline int Multi(int x, int y) { return 1ll * x * y % q; }
inline void Me(int &x, int y) { x = Multi(x, y); }
inline int mi(int x, int y) {
int ret = 1;
for (; y; y >>= 1, Me(x, x))
if (y & 1) Me(ret, x);
return ret;
}
inline int Inv(int x) { return mi(x, q - 2); }
namespace num {
int fac[maxn], ifac[maxn], inv[maxn];
void init() {
for (int i = 0; i < 2; ++i) fac[i] = ifac[i] = inv[i] = 1;
for (int i = 2; i < maxn; ++i) {
fac[i] = Multi(fac[i - 1], i);
inv[i] = Multi(q - q / i, inv[q % i]);
ifac[i] = Multi(ifac[i - 1], inv[i]);
}
}
inline int C(int n, int m) {
return n < m ? 0 : Multi(Multi(fac[n], ifac[m]), ifac[n - m]);
}
int x = (init(), 0);
} // namespace num
int f, w, h;
int main() {
using namespace num;
cin >> f >> w >> h;
if (w == 0) puts("1"), exit(0);
if (f == 0) printf("%d\n", w > h), exit(0);
int s = 0, t = 0;
for (int i = 1; i <= w; ++i) {
Pe(s, Multi(C(w - 1, i - 1), C(f + 1, i)));
if ((long long)(w - 1) - (long long)i * h >= 0)
Pe(t, Multi(C(w - 1 - i * h, i - 1), C(f + 1, i)));
}
int ans = Multi(t, Inv(s));
printf("%d\n", ans);
return 0;
}
| 2,300 | CPP |
import os, sys, math
from io import BytesIO, IOBase
ma = lambda: map(int, input().split(" "))
arr=[]
for i in range(26):
arr.append(chr(97+i))
for i in range(26):
for j in range(26):
arr.append((chr(97+i)+chr(97+j)))
for i in range(26):
for j in range(26):
for k in range(26):
x=chr(i+97)+chr(j+97)+chr(k+97)
arr.append(x)
def main():
for _ in range(int(input())):
n=int(input())
s=input()
i=0
while arr[i] in s:
i+=1
print(arr[i])
# Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == '__main__':
main() | 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[100001], c[100001] = {0}, d[100001], n, i, j, k, max = 0;
cin >> n;
d[1] = 1;
d[n] = 1;
c[1] = 1;
c[n] = 1;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 2; i < n; i++) c[i] = min(c[i - 1] + 1, min(a[i + 1] + 1, a[i]));
for (i = n - 1; i >= 1; i--)
d[i] = min(d[i + 1] + 1, min(a[i - 1] + 1, a[i]));
for (i = 1; i <= n; i++)
if (d[i] < c[i]) c[i] = d[i];
for (i = 1; i <= n; i++)
if (c[i] > max) max = c[i];
cout << max;
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
constexpr int MAXN = 1e6;
constexpr int size = 1000;
int n, x, y;
map<int, int> mAll, losers, score;
set<int> s;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
int siz = (n * (n - 1)) / 2 - 1;
for (int i = 0; i < siz; i++) {
cin >> x >> y;
mAll[y]++;
mAll[x]++;
losers[y]++;
}
vector<int> missing;
for (auto i : mAll)
if (i.second < n - 1) missing.push_back(i.first);
for (auto i : losers) score[i.second]++;
if (score[losers[missing[0]]] > 1)
cout << missing[1] << " " << missing[0] << endl;
else
cout << missing[0] << " " << missing[1] << endl;
return 0;
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n, x, m;
cin >> n >> x >> m;
long long l = x, r = x, a, b, i;
for (i = 0; i < m; i++) {
cin >> a >> b;
if (a <= l && b >= l) l = a;
if (a <= r && b >= r) r = b;
}
cout << r - l + 1 << endl;
}
}
| 1,300 | CPP |
z,zz=input,lambda:list(map(int,z().split()));
szz,graph,mod=lambda:sorted(zz()),{},10**9+7
zzz=lambda:[int(i) for i in stdin.readline().split()]
from string import *
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f
from bisect import bisect as bs
from bisect import bisect_left as bsl
from itertools import accumulate as ac
def lcd(xnum1,xnum2):return (xnum1*xnum2//gcd(xnum1,xnum2))
def prime(x):
p=ceil(x**.5)+1
for i in range(2,p):
if (x%i==0 and x!=2) or x==0:return 0
return 1
def dfs(u,visit,graph):
visit[u]=True
for i in graph[u]:
if not visit[i]:
dfs(i,visit,graph)
###########################---Test-Case---#################################
"""
"""
###########################---START-CODING---##############################
n,m=zz()
cat=[0]+zzz()
for i in range(1,n):
x,y=zz()
try:graph[x]
except:graph[x]=[]
try:graph[y]
except:graph[y]=[]
graph[x].append(y)
graph[y].append(x)
vis=[0]*(n+1)
ans=0
quee=[(1,0)]
c=0
while c<len(quee):
x,num=quee[c]
vis[x]=True
if num+cat[x]>m:
c+=1
continue
flg=True
for i in graph[x]:
if not vis[i]:
flg=False
quee.append((i,cat[x]*(cat[x]+num)))
if flg:ans+=1
c+=1
print(ans)
| 1,500 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int bonus[155], n;
char str[155];
long long dp[155][155][155];
bool vst[155][155];
long long fuck[155];
void MM(long long &a, long long b) {
if (a < b) a = b;
}
void calc(int l, int r) {
if (vst[l][r]) return;
vst[l][r] = true;
if (l > r) {
dp[l][r][0] = 0;
return;
}
if (l == r) {
dp[l][r][0] = bonus[1];
dp[l][r][1] = 0;
return;
}
if (str[l] == str[r]) {
calc(l + 1, r - 1);
int len = r - l + 1 - 2;
for (int k = (0); k < (len + 1); k++) {
MM(dp[l][r][k + 2], dp[l + 1][r - 1][k]);
MM(dp[l][r][0], dp[l + 1][r - 1][k] + bonus[k + 2]);
}
}
for (int i = l; i + 1 <= r; i++) {
calc(l, i);
calc(i + 1, r);
int len1 = i - l + 1, len2 = r - i;
for (int k = (0); k < (len1 + 1); k++)
MM(dp[l][r][k], dp[l][i][k] + dp[i + 1][r][0]);
for (int k = (0); k < (len2 + 1); k++)
MM(dp[l][r][k], dp[l][i][0] + dp[i + 1][r][k]);
}
}
int main() {
while (scanf("%d", &n) != EOF) {
for (int i = (1); i < (n + 1); i++) {
scanf("%d", bonus + i);
if (bonus[i] < 0) bonus[i] = -(1 << 30);
}
scanf(" %s", str + 1);
memset(dp, 0xf0, sizeof(dp));
memset(vst, false, sizeof(vst));
for (int i = (1); i < (n + 1); i++)
for (int j = (1); j < (n + 1); j++)
if (i <= j) {
calc(i, j);
}
memset(fuck, 0xf0, sizeof(fuck));
fuck[0] = 0;
for (int i = (0); i < (n); i++) {
for (int j = i + 1; j <= n; j++) {
for (int k = j; k <= n; k++) {
MM(fuck[k], fuck[i] + dp[j][k][0]);
}
}
}
long long ma = 0;
for (int i = (0); i < (n + 1); i++) MM(ma, fuck[i]);
cout << ma << '\n';
}
}
| 2,600 | CPP |
#!/usr/bin/python
# http://codeforces.com/problemset/problem/169/A
# 2-pointer
# is it possible to sort the array a (in increasing order) by reversing exactly one segment of a
# define function
def test(n, a):
b = sorted(a)
c = a
count = 0
flag = False
start = 0
end = 0
result = []
if a == b:
result.append('yes')
result.append('1 1')
else:
for i in range(len(a)):
if a[i] != b[i] and flag is False:
flag = True
start = i
continue
if flag is True and a[i] != b[i]:
end = i
# swap all element between start and end index
s = start
e = end
while s < e:
c[s], c[e] = c[e], c[s]
s += 1
e -= 1
if c == b:
result.append('yes')
result.append('{} {}'.format(start + 1, end + 1))
else:
result.append('no')
return result
# call function
n = int(input())
a = [int(i) for i in input().split()]
result = test(n, a)
for item in result:
print(item)
| 1,300 | PYTHON3 |
for _ in range(int(input())):
x,y,z=map(int,input().split())
m = max(x,y,z)
c = [x,y,z].count(m)
if c>=2:
if c==2:
if x==z==m:
print('YES')
print(x,y,1)
elif z==y==m:
print('YES')
print(x,1,z)
else:
print('YES')
print(1,y,z)
else:
print('YES')
print(x,y,z)
else:
print('NO') | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << ' ' << H;
debug_out(T...);
}
const int INF = 1e9;
const long long MOD = 1e9 + 7;
const int N = 1e5 + 5, MO = 500, SQ = 320;
int n, q, A[N], QL[N], QR[N], P[N], T[N], C[N], K[N], Q[N];
vector<int> B, X, Y;
bool CMP(int i, int j) {
if (QL[i] / MO != QL[j] / MO) return QL[i] < QL[j];
return (QL[i] / MO) % 2 ? QR[i] > QR[j] : QR[i] < QR[j];
}
void Update(int x, int y) { T[C[x]]--, C[x] += y, T[C[x]]++; }
void Insert(int x, int y) {
if (x >= SQ && !K[x]) Y.push_back(x);
K[x] += y;
}
int Huf() {
X.clear(), Y.clear();
for (int i : B)
if (C[i] >= SQ) X.push_back(C[i]), K[C[i]]++;
sort(X.begin(), X.end());
int huf = 0, c = 0, x = 0, y = 0;
for (int i = 1; i < SQ; i++)
if (K[i] + T[i]) {
K[i] += T[i];
if (c) huf += i + c, K[i]--, Insert(i + c, 1), c = 0;
if (K[i] & 1) c = i, K[i]--;
if (K[i]) huf += i * K[i], Insert(i + i, K[i] >> 1), K[i] = 0;
}
while (x < (int)(X.size()) || y < (int)(Y.size())) {
while (x + 1 < (int)(X.size()) && X[x + 1] == X[x]) x++;
while (y + 1 < (int)(Y.size()) && Y[y + 1] == Y[y]) y++;
int i = 0;
if (x == (int)(X.size()))
i = Y[y++];
else if (y == (int)(Y.size()))
i = X[x++];
else if (X[x] < Y[y])
i = X[x++];
else
i = Y[y++];
if (c) huf += i + c, K[i]--, Insert(i + c, 1), c = 0;
if (K[i] & 1) c = i, K[i]--;
if (K[i]) huf += i * K[i], Insert(i + i, K[i] >> 1), K[i] = 0;
}
return huf;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
mt19937 Rnd(time(0));
cin >> n;
for (int i = 0; i < n; i++) cin >> A[i], C[A[i]]++;
for (int i = 0; i < N; i++)
if (C[i] >= SQ) B.push_back(i);
for (int i = 0; i < n; i++) C[A[i]]--;
cin >> q;
for (int i = 0; i < q; i++) cin >> QL[i] >> QR[i], QL[i]--, P[i] = i;
sort(P, P + q, CMP);
int L = 0, R = 0;
for (int i = 0; i < q; i++) {
int l = QL[P[i]], r = QR[P[i]];
while (l < L) Update(A[--L], +1);
while (R < r) Update(A[R++], +1);
while (L < l) Update(A[L++], -1);
while (r < R) Update(A[--R], -1);
Q[P[i]] = Huf();
}
for (int i = 0; i < q; i++) cout << Q[i] << endl;
return 0;
}
| 3,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = double;
const int N = 1000005;
int n, m, t;
array<int, N> a, b, vis;
array<vector<int>, N> g;
vector<int> p, q;
void dfs(int u) {
if (vis[u] != 0) {
return;
}
vis[u] = 1;
for (int v : g[u]) {
dfs(v);
}
}
auto main() -> int {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> t;
while ((t--) != 0) {
cin >> n;
p.clear();
q.clear();
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
cin >> b[i];
}
for (int i = 1; i <= n; i++) {
p.push_back(i);
q.push_back(i);
g[i].clear();
vis[i] = 0;
}
sort(p.begin(), p.end(), [](int x, int y) { return a[x] < a[y]; });
sort(q.begin(), q.end(), [](int x, int y) { return b[x] < b[y]; });
for (int i = 1; i < n; i++) {
g[p[i - 1]].push_back(p[i]);
g[q[i - 1]].push_back(q[i]);
}
dfs(p.back());
for (int i = 1; i <= n; i++) {
cout << vis[i];
}
cout << endl;
}
return 0;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
double intersect(const vector<long long>& d, int i, int j) {
return (d[i] - d[j] + 0.0) / (j - i);
}
int main() {
ios_base::sync_with_stdio(false);
int n, w;
cin >> n >> w;
int A = 0;
vector<pair<pair<int, int>, int> > p(n);
for (int i = 0; i < n; ++i) {
cin >> p[i].first.second >> p[i].first.first;
A = max(A, p[i].first.second);
p[i].second = i;
}
sort(p.begin(), p.end());
int cur = 0;
vector<pair<int, int> > query;
for (int c = 0; c <= p.back().first.first + 1; ++c) {
while (cur < n && p[cur].first.first == c - 1) {
query.push_back(make_pair(0, p[cur].first.second));
++cur;
}
query.push_back(make_pair(1, c));
}
vector<long long> d(A + 1);
vector<pair<long long, long> > ans;
int block_size = sqrt(query.size() + 0.0);
int people_count = n;
for (int pos = 0; pos < query.size(); pos += block_size) {
int end_pos = min((int)query.size(), pos + block_size);
vector<int> add;
for (int i = pos; i < end_pos; ++i) {
if (query[i].first == 0 && query[i].second > 0)
add.push_back(query[i].second);
}
sort(add.begin(), add.end());
vector<pair<int, int> > segment;
if (add.size() > 0) segment.push_back(make_pair(1, add[0]));
for (int i = 0; i + 1 < add.size(); ++i) {
if (add[i] + 1 <= add[i + 1])
segment.push_back(make_pair(add[i] + 1, add[i + 1]));
}
if (add.size() > 0 && add.back() < A)
segment.push_back(make_pair(add.back() + 1, A));
if (segment.size() == 0) segment.push_back(make_pair(1, A));
vector<long long> coef(segment.size()), position(segment.size(), -1);
vector<vector<pair<double, int> > > envelope(segment.size());
for (int i = 0; i < segment.size(); ++i) {
for (int j = segment[i].first + 1; j <= segment[i].second; ++j) {
while (!envelope[i].empty() &&
intersect(d, j, envelope[i].back().second) <
envelope[i].back().first)
envelope[i].pop_back();
if (envelope[i].empty())
envelope[i].push_back(
make_pair(intersect(d, segment[i].first, j), j));
else
envelope[i].push_back(
make_pair(intersect(d, j, envelope[i].back().second), j));
}
int k = 0;
while (k < envelope[i].size() && envelope[i][k].first < 0) ++k;
position[i] = k - 1;
}
for (int i = pos; i < end_pos; ++i) {
if (query[i].first == 0) {
--people_count;
if (query[i].second == 0) continue;
int k = 0;
while (k < segment.size() && segment[k].second <= query[i].second) {
++coef[k];
int st = position[k] + 1;
while (st < envelope[k].size() &&
envelope[k][st].first < coef[k] + 0.0)
++st;
position[k] = st - 1;
++k;
}
} else {
long long cur_ans = -1, price = -1;
for (int k = 0; k < segment.size(); ++k) {
long long current = 0;
if (position[k] == -1)
current = d[segment[k].first] + coef[k] * segment[k].first;
else
current = d[envelope[k][position[k]].second] +
coef[k] * envelope[k][position[k]].second;
if (cur_ans == -1 || cur_ans < current) {
cur_ans = current;
if (position[k] == -1)
price = segment[k].first;
else
price = envelope[k][position[k]].second;
}
}
ans.push_back(make_pair(
cur_ans + (long long)w * people_count * query[i].second, price));
}
}
for (int i = 0; i < segment.size(); ++i) {
for (int j = segment[i].first; j <= segment[i].second; ++j)
d[j] += coef[i] * j;
}
}
for (int i = 0; i < ans.size(); ++i)
cout << ans[i].first << " " << ans[i].second << "\n";
return 0;
}
| 3,000 | CPP |
n=int(input())
orda = ord('A')
ordc = ord('C')
ordt = ord('T')
ordg = ord('G')
ordtest=[orda,ordc,ordt,ordg]
s=[]
mn=-1
for i in input():
s.append(ord(i))
for i in range(n-3):
mc = 0
for i2 in range(4):
cc = abs(ordtest[i2]-s[i+i2])
##print(i,cc,s[i+i2])
c1 = (26-cc)%26
c2 = (cc-26)%26
mc += min(c1,c2)
##print(mc, mn>mc)
if mn==-1 or mn>mc:
mn=mc
print(mn) | 1,000 | PYTHON3 |
n = int(input())
if n <= 2:
print("NO")
for i in range(2, n):
m = n - i
if i % 2 == 0 and m % 2 == 0:
print("YES")
break
else:
print("NO")
break
| 800 | PYTHON3 |
length = int(input())
row = input()
numbers = []
n = 0
for x in row:
if x == "W" and n != 0:
numbers.append(str(n))
n = 0
elif x == "B":
n += 1
if n != 0:
numbers.append(str(n))
print(len(numbers))
print(" ".join(numbers)) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool visited[10000007];
vector<long long> g[10000007];
long long ct = 0;
long long pow(long long a, long long b, long long m) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans;
}
void dfs(long long i) {
if (visited[i]) return;
ct++;
visited[i] = true;
for (auto &it : g[i]) dfs(it);
}
int32_t main() {
long long n, k, u, v, x, ct2;
cin >> n >> k;
ct2 = pow(n, k, 1000000007);
for (long long i = 0; i < n - 1; i++) {
cin >> u >> v >> x;
if (x == 0) {
g[u - 1].push_back(v - 1);
g[v - 1].push_back(u - 1);
}
}
long long ct1 = 0;
memset(visited, false, sizeof(visited));
for (long long i = 0; i < n; i++) {
if (visited[i]) continue;
ct = 0;
dfs(i);
ct2 -= pow(ct, k, 1000000007);
;
ct2 += 1000000007;
ct2 %= 1000000007;
}
cout << ct2;
}
| 1,500 | CPP |
n = int(input())
users = set()
collide = dict()
for i in range(n):
name = input()
if name in users:
if name in collide: collide[name] += 1
else: collide[name] = 1
name += str(collide[name])
print(name)
else: print('OK')
users.add(name) | 1,300 | PYTHON3 |
n = int(input())
for _ in range(n):
s = str(input())
l = len(s)
if l <=10:
print(s)
else:
print(s[0] +str(len(s)-2)+s[len(s)-1])
| 800 | PYTHON3 |
for _ in range(int(input())):
a,b,n = map(int,input().split())
if a>n or b>n:
print(0)
else:
y = max(a,b)
x = a+b
t = 1
while True:
if x > n:
print(t)
break
else:
t+=1
k = x
x+=y
y = k | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long Maxn = 5e5 + 7;
const long long Max = 1e3 + 7;
const long long Mod = 1e9 + 7;
const long long Inf = 1e9 + 7;
long long n, m, a[Max][Max], dis[Max][Max][10], d[10][10], ans = Inf;
long long X[] = {1, 0, -1, 0};
long long Y[] = {0, 1, 0, -1};
queue<pair<long long, long long> > q;
vector<pair<long long, long long> > V[10];
long long change(char t) {
if (t == '.') return 1;
if (t == '#') return 0;
return t - '0' + 1;
}
void bfs(long long cnr) {
while (q.size()) {
pair<long long, long long> pos = q.front();
long long x = pos.first, y = pos.second;
q.pop();
for (long long i = 0; i < 4; i++) {
long long xx = X[i] + x, yy = Y[i] + y;
if (a[xx][yy] && dis[xx][yy][cnr] > (dis[x][y][cnr]) + 1) {
q.push(make_pair(xx, yy));
dis[xx][yy][cnr] = dis[x][y][cnr] + 1;
}
}
}
}
void dist_country(long long p, long long x, long long y) {
for (long long i = 2; i <= 4; i++)
d[p][i] = min(dis[x][y][i], d[p][i]), d[i][p] = min(dis[x][y][i], d[i][p]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> m;
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
dis[i][j][4] = dis[i][j][2] = dis[i][j][3] = Inf;
char t;
cin >> t;
a[i][j] = change(t);
if (a[i][j] > 1)
V[a[i][j]].push_back(make_pair(i, j)), dis[i][j][a[i][j]] = -1;
}
}
for (long long i = 2; i <= 4; i++)
for (long long j = 2; j <= 4; j++) d[i][j] = Inf;
for (long long i = 2; i <= 4; i++) {
for (long long j = 0; j < V[i].size(); j++) q.push(V[i][j]);
bfs(i);
}
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= m; j++) {
if (a[i][j] == 1)
ans = min(ans, dis[i][j][4] + dis[i][j][2] + dis[i][j][3]);
else if (a[i][j] > 1)
dist_country(a[i][j], i, j);
}
ans++;
ans = min(ans, d[2][3] + d[2][4]);
ans = min(ans, d[2][3] + d[3][4]);
ans = min(ans, d[4][2] + d[4][3]);
if (ans >= Mod)
cout << -1 << endl;
else
cout << ans << endl;
}
| 2,200 | CPP |
#!/usr/bin/env python3
if __name__=="__main__":
b = list(input().split('+'))
b.sort()
print('+'.join(b))
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline int max(int a, int b) { return a > b ? a : b; }
inline int min(int a, int b) { return a < b ? a : b; }
char s[5005], ch[] = {'U', 'L', 'R', 'D'};
int typ[5005], mk[5005][5005], to[5005][4], w[5005][4];
int dir[4][2] = {{-1, 0}, {0, -1}, {0, 1}, {1, 0}};
struct node {
int r, c;
node() {}
node(int r_, int c_) : r(r_), c(c_) {}
node operator+(int k) { return node(r + dir[k][0], c + dir[k][1]); }
void operator+=(int k) {
r += dir[k][0];
c += dir[k][1];
}
} nod[5005];
int n, m, tot;
inline bool ok(node u) { return u.r >= 0 && u.r < n && u.c >= 0 && u.c < m; }
int main() {
while (scanf("%d %d", &n, &m) == 2) {
tot = 0;
getchar();
for (int i(0); i < (n); ++i) {
gets(s);
for (int j(0); j < (m); ++j) {
if (s[j] != '.') {
for (int k(0); k < (4); ++k)
if (s[j] == ch[k]) {
typ[tot] = k;
mk[i][j] = tot;
nod[tot] = node(i, j);
++tot;
break;
}
} else
mk[i][j] = -1;
}
}
for (int i(0); i < (tot); ++i)
for (int j(0); j < (4); ++j) {
node v(nod[i] + j);
w[i][j] = -1;
while (ok(v)) {
if (mk[v.r][v.c] != -1) {
w[i][j] = mk[v.r][v.c];
break;
}
v += j;
}
}
int len(-1), num(0);
for (int i(0); i < (tot); ++i) {
int t(i), tmp(0);
memcpy(to, w, sizeof(w));
while (t != -1) {
++tmp;
for (int j(0); j < (4); ++j)
if (to[t][j] != -1) to[to[t][j]][3 - j] = to[t][3 - j];
t = to[t][typ[t]];
}
if (tmp > len)
len = tmp, num = 1;
else if (tmp == len)
++num;
}
printf("%d %d\n", len, num);
}
return 0;
}
| 2,300 | CPP |
n,x,y=(map(int,(input().split())))
string=input()
count=0
for i in range(n-x,n):
if i==n-1-y:
if string[i]=="0":
count+=1
else:
if string[i]=="1":
count+=1
print(count) | 1,100 | PYTHON3 |
a=int(input())
b=int(input())
c=int(input())
d=int(input())
e=int(input())
f=int(input())
k=min(b,c,d)
x=k*f
x=x+e*min(a,d-k)
k=min(a,d)
y=k*e
y=y+f*min(b,c,d-k)
print(max(x,y))
| 800 | PYTHON3 |
#rOkY
#FuCk
############################### kOpAl ##################################
def check(s):
x=s
y=''.join(reversed(s))
if(x==y):
return True
return False
def ans(s):
c='a'
m=s
n=''
n=c+s
if(check(n)==False):
print(n)
else:
n=s+c
if(check(n)==False):
print(n)
t=int(input())
while(t>0):
s=str(input())
f=''.join(dict.fromkeys(s))
if(f=='a'):
print('NO')
else:
print('YES')
ans(s)
t-=1
| 800 | PYTHON3 |
a = int(input())
b = int(input())
c = int(input())
if a == 1:
if c == 1:
print(a + b + c)
else:
print((a + b) * c)
elif b == 1:
if a < c:
print((a + 1) * c)
else:
print((c + 1) * a)
elif c == 1:
print(a*(b + 1))
else :
print(a*b*c)
| 1,000 | PYTHON3 |
s=input()
c=0
p=0
for i in s:
if i.islower():
c+=1
else:
p+=1
r=""
if(c>=p):
for i in s:
r+=i.lower()
else:
for i in s:
r+=i.upper()
print(r)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t-- > 0) {
long long x, y, k;
cin >> x >> y >> k;
long long total_stick = k * y + k;
long long temp = x - 1;
long long now = 1;
long long count = 0;
count = (total_stick - 1) / temp;
if (temp * count < total_stick - 1) count++;
cout << count + k << endl;
}
}
| 1,000 | CPP |
x=int(input())
y=list(map(int,input().split(" ")))
d=y[0]
e=0
for i in range(len(y)-1):
if e+(y[i]-y[i+1])<0:
d+=abs(e+(y[i]-y[i+1]))
e=0
else:
e+=y[i]-y[i+1]
print(d)
| 1,100 | PYTHON3 |
n = int(input())
A = input().split()
an = 0
se = set()
for a in A:
a = set(list(a))
a = list(a)
a.sort()
se.add("".join(a))
print(len(se)) | 900 | PYTHON3 |
# python 3
"""
"""
# from operator import itemgetter
def palindromic_times(time_str) -> None:
hours, minutes = list(map(int, time_str.split(":")))
# print(hours, minutes)
while True:
minutes += 1
if minutes == 60:
hours += 1
minutes = 0
if hours == 24:
hours = 0
minutes_str = str(minutes)
hours_str = str(hours)
if len(minutes_str) == 1:
minutes_str = "0" + minutes_str
if len(hours_str) == 1:
hours_str = "0" + hours_str
if hours_str[0] == minutes_str[1] and hours_str[1] == minutes_str[0]:
break
return hours_str + ":" + minutes_str
if __name__ == "__main__":
"""
Inside of this is the test.
Outside is the API
"""
time = input()
print(palindromic_times(time))
| 1,000 | PYTHON3 |
position = input()
streak = 0
last = -1
dangerous = False
for player in position:
if player != last:
last = player
streak = 1
else:
streak += 1
if streak >= 7:
dangerous = True
break
if dangerous:
print("YES")
else:
print("NO")
| 900 | PYTHON3 |
a=int(input())
b=[i for i in range (0,a)]
for j in range (0,a):
b[j]=input()
for o in range(0,a) :
k=0
for y in range (0,o):
if b[o]==b[y]:
k=k+1
break
if k:
print("Yes")
if k==0:
print("No") | 800 | PYTHON3 |
import sys, os
from io import BytesIO, IOBase
from math import floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque
from heapq import merge, heapify, heappop, heappush, nsmallest
from bisect import bisect_left as bl, bisect_right as br, bisect
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
stdin, stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
mod = pow(10, 9) + 7
mod2 = 998244353
def inp(): return stdin.readline().strip()
def iinp(): return int(inp())
def out(var, end="\n"): stdout.write(str(var)+"\n")
def outa(*var, end="\n"): stdout.write(' '.join(map(str, var)) + end)
def lmp(): return list(mp())
def mp(): return map(int, inp().split())
def smp(): return map(str, inp().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(m, val) for j in range(n)]
def remadd(x, y): return 1 if x%y else 0
def ceil(a,b): return (a+b-1)//b
S1 = 'abcdefghijklmnopqrstuvwxyz'
S2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def isprime(x):
if x<=1: return False
if x in (2, 3): return True
if x%2 == 0: return False
for i in range(3, int(sqrt(x))+1, 2):
if x%i == 0: return False
return True
n, m, k = mp()
hor = [lmp() for i in range(n)]
ver = [lmp() for i in range(n-1)]
if k%2:
ml = l2d(n, m, -1)
for i in ml: print(*i)
exit()
k//=2
dp = [l2d(n, m) for i in range(k+1)]
for f in range(1, k+1):
for i in range(n):
for j in range(m):
a = inf
if i!=0:
a = min(a, 2*ver[i-1][j]+dp[f-1][i-1][j])
if i!=n-1:
a = min(a, 2*ver[i][j]+dp[f-1][i+1][j])
if j!=0:
a = min(a, 2*hor[i][j-1]+dp[f-1][i][j-1])
if j!=m-1:
a = min(a, 2*hor[i][j]+dp[f-1][i][j+1])
dp[f][i][j] = a
for i in dp[-1]:
outa(*i) | 1,800 | PYTHON3 |
n,k=input().split()
n=int(n)
k=int(k)
se=[[] for i in range(k)]
se1=[[] for i in range(k)]
a=list(map(int,input().split()))
#print(a)
#print(se)
flag2=0
if(n<k):
print('NO')
else:
for i in range(n):
p=i%k
if a[i] not in se[p]:
se[p].append(a[i])
se1[p].append(i)
else:
flag=0
j=0
while(a[i] in se[j]):
j+=1
if(j==k):
flag=1
break
if(flag==1):
print("NO")
flag2=1
break
else:
se[j].append(a[i])
se1[j].append(i)
if(flag2==0):
print("YES")
b=[0]*n
for i in range(k):
for j in se1[i]:
b[j]=i+1
for i in range(n):
print(b[i],end=" ") | 1,400 | PYTHON3 |
x=int(input())
r=x%4
if r==1:
print(0,"A")
elif r==3:
print(2,"A")
elif r==2:
print(1,"B")
else :
print(1,"A")
| 800 | PYTHON3 |
#codeforces way to long
n1 = input()
n = int(n1)
lst = list()
for i in range(0,n) :
lst.append(input())
for word in lst :
if len(word)<=10 :
print(word)
else :
l = len(word)
rl = l - 2
st = str(rl)
reqword = word[0] + st + word[l-1]
print(reqword)
| 800 | PYTHON3 |
from math import ceil
t = int(input())
for _ in range(t):
a,b,c,d,k = map(int, input().split())
a1 = ceil(a/c)
a2 = ceil(b/d)
if (a1 + a2 <= k):
print(a1, a2)
else:
print("-1") | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
long long ans = 1;
for (int i = 0; i < n - k; i++) ans = (ans * (n - k)) % 1000000007;
for (int i = 0; i < k - 1; i++) ans = (ans * k) % 1000000007;
cout << ans << endl;
return 0;
}
| 1,500 | CPP |
import sys
f_in = sys.stdin
f_out = sys.stdout
num = int(f_in.readline())
strings = f_in.readline()
grp=[[],[],[]]
warning = 0
for i in range(0,num):
if grp[0] == [] or grp[0][-1] <= strings[i]:
grp[0].append(strings[i])
grp[2].append('0')
elif grp [1] == [] or grp[1][-1] <= strings[i]:
grp[1].append(strings[i])
grp[2].append('1')
else :
warning = 1
ans = ''.join(grp[2])
if warning == 1:
f_out.write('NO\n')
else :
f_out.write('YES\n')
f_out.write(ans + '\n')
f_in.close()
f_out.close()
| 1,800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int E = 30005;
int n, m, k;
char s[200005];
int h[26];
int pass;
int c;
int dp[26][E + 2];
int mark[26][E + 2];
int f(int i, int sum) {
if (i == 26) {
int a = sum, b = k - sum - h[c];
long long ans = 1e9;
if (max(n - a, 0) + max(m - b, 0) <= h[c])
ans = 1LL * max(n - a, 0) * max(m - b, 0);
if (max(n - b, 0) + max(m - a, 0) <= h[c])
ans = min(ans, 1LL * max(n - b, 0) * max(m - a, 0));
return int(ans);
}
if (i == c) return f(i + 1, sum);
if (mark[i][sum] == pass) return dp[i][sum];
mark[i][sum] = pass;
dp[i][sum] = f(i + 1, sum);
if (sum + h[i] < E) dp[i][sum] = min(dp[i][sum], f(i + 1, sum + h[i]));
return dp[i][sum];
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%d %d %d %s", &n, &m, &k, s);
memset(h, 0, sizeof h);
for (int i = 0; i < k; i++) h[int(s[i] - 'A')]++;
int mn = 1e9;
for (int i = 0; i < 26; i++) {
c = i;
pass++;
mn = min(mn, f(0, 0));
}
printf("%d\n", mn);
}
}
| 2,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long ans[100005], g[200005], p[200005];
int main() {
long long n, cnt = 0, i = 0, N;
cin >> n;
N = n;
n *= 2;
deque<long long> d;
while (n--) {
i++;
char a;
long long q;
cin >> a;
if (a == '-') {
g[i] = -1;
cin >> q;
p[i] = q;
if (d.size() == 0) {
cout << "NO\n";
return 0;
}
ans[d[d.size() - 1]] = q;
d.pop_back();
} else {
g[i] = 1;
cnt++;
d.push_back(cnt);
}
}
set<long long> s;
set<long long>::iterator ii;
long long j = 0;
for (i = 1; i <= 2 * N; i++) {
if (g[i] == 1) {
j++;
s.insert(ans[j]);
} else {
ii = s.begin();
if ((*ii) != p[i]) {
cout << "NO\n";
return 0;
}
s.erase((*ii));
}
}
cout << "YES\n";
for (i = 1; i <= N; i++) {
cout << ans[i] << " ";
}
return 0;
}
| 1,700 | CPP |
def binaryToDecimal(n):
return int(n,2)
count=0
val2=str(input())
val=binaryToDecimal(val2)
cop=val
i=0
g=1
while(1):
if(g>=val):
break
count=count+1
g=g*4
print(count)
| 1,000 | PYTHON3 |
s=list(map(str,input().split(' ')))
g=[['lios','liala'],['etr','etra'],['initis','inites']]
if len(s)==1:
n=len(s[0])
if s[0][n-len(g[0][0]):]==g[0][0] or s[0][n-len(g[0][1]):]==g[0][1] or s[0][n-len(g[1][0]):]==g[1][0] or s[0][n-len(g[1][1]):]==g[1][1] or s[0][n-len(g[2][0]):]==g[2][0] or s[0][n-len(g[2][1]):]==g[2][1]:
print('YES')
else:
print('NO')
else:
j=0
f=1
c=None
i=0
nc=0
while i<len(s):
if i==0:
n=len(s[i])
if s[i][n-len(g[j][0]):]==g[j][0] or s[i][n-len(g[j][1]):]==g[j][1]:
if s[i][n-len(g[j][0]):]==g[j][0]:
c=0
elif s[i][n-len(g[j][1]):]==g[j][1]==g[j][1]:
c=1
if j==1:
nc=nc+1
i=i+1
else:
j=j+1
else:
n=len(s[i])
if s[i][n-len(g[j][c]):]==g[j][c]:
if j==1:
nc=nc+1
i=i+1
else:
j=j+1
if j==3:
f=0
break
if f and nc==1:
print('YES')
else:
print('NO') | 1,600 | PYTHON3 |
q=int(input())
while q>0:
n=int(input())
a=[int(x) for x in input().split()]
a.sort()
if a[0]==a[1] and a[-1]==a[-2]:
k=a[0]*a[-1]
flag=False
for i in range(2,2*n,2):
if not(a[i]==a[i+1] and a[-i-1]==a[-i-2] and a[i]*a[-i-1]==k):
flag=True
break
if flag:
print("NO")
else:
print("YES")
else:
print("NO")
q-=1
| 1,200 | PYTHON3 |
n = int(input())
a=0
b=0
if n%2 == 0:
a=4
b=n-4
else:
if n%3 == 0:
a=6
b=n-6
elif n%3 == 1:
a=4
b=n-4
else:
a=8
b=n-8
print(a, b) | 800 | PYTHON3 |
n, k = list(map(int, input().split())) # n is the number of messages and k is the number of conversations that can be shown
ids = list(map(int, input().split()))
screen = [None] * k
convs = 0
if k >= 1:
for i in ids:
if i not in screen:
screen[1:] = screen[0:k-1]
screen[0] = i
else:
continue
for i in screen:
if i:
convs += 1
print(convs)
print(*screen[0:convs])
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
class DebugStream {
} LOG;
template <typename T>
DebugStream &operator<<(DebugStream &s, const T &) {
return s;
}
mt19937 rnd(time(NULL));
const int maxN = 1e6 + 9, maxV = 1e6 + 9, MOD = 1e9 + 7, SQ = 335, lg = 20,
bs = 29;
int n, p, M, m, le[maxN], ri[maxN], cle[maxN], cri[maxN],
cc = 0, comp[maxN], freq[maxN], lado[maxN];
bool vi[maxN];
vector<int> adj[maxN], farg[maxN], cadj[maxN];
stack<int> kosa;
void prec(int nd) {
if (vi[nd]) return;
vi[nd] = 1;
for (auto sn : adj[nd]) prec(sn);
kosa.push(nd);
}
void dfs(int nd) {
comp[nd] = cc;
for (auto sn : farg[nd])
if (comp[sn] == -1) dfs(sn);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> p >> M >> m;
for (int i = 0, u, v; i < n; i++) {
cin >> u >> v;
u--, v--;
adj[u << 1 | 1].push_back(v << 1);
adj[v << 1 | 1].push_back(u << 1);
farg[u << 1].push_back(v << 1 | 1);
farg[v << 1].push_back(u << 1 | 1);
}
for (int i = 0; i < p; i++) cin >> le[i] >> ri[i], le[i]--;
for (int i = 0, u, v; i < m; i++) {
cin >> u >> v;
u--, v--;
farg[u << 1 | 1].push_back(v << 1);
farg[v << 1 | 1].push_back(u << 1);
adj[u << 1].push_back(v << 1 | 1);
adj[v << 1].push_back(u << 1 | 1);
}
for (int i = 0; i < p * 2; i++) prec(i), comp[i] = -1;
while (kosa.size()) {
dfs(kosa.top());
cle[cc] = 0, cri[cc] = maxN - 20;
cc++;
while (kosa.size() && comp[kosa.top()] != -1) kosa.pop();
}
for (int i = 0; i < 2 * p; i++) {
if (i % 2 == 0) {
cle[comp[i]] = max(cle[comp[i]], le[i / 2]);
cri[comp[i]] = min(cri[comp[i]], ri[i / 2]);
}
for (auto sn : adj[i])
if (comp[i] != comp[sn]) cadj[comp[i]].push_back(comp[sn]);
}
for (int i = cc - 1; i >= 0; i--) {
for (auto sn : cadj[i]) {
cle[i] = max(cle[i], cle[sn]);
cri[i] = min(cri[i], cri[sn]);
}
cri[i] = max(cri[i], cle[i]);
}
for (int i = 0; i < p; i++) {
if (comp[i << 1] == comp[i << 1 | 1]) {
cout << "-1\n";
exit(0);
}
freq[cle[comp[i << 1]]]++, freq[cri[comp[i << 1]]]--;
freq[cle[comp[i << 1 | 1]]]++, freq[cri[comp[i << 1 | 1]]]--;
int izq = max(cle[comp[i << 1]], cle[comp[i << 1 | 1]]);
int dere = min(cri[comp[i << 1]], cri[comp[i << 1 | 1]]);
if (izq < dere) freq[izq]--, freq[dere]++;
}
for (int i = 1; i < M; i++) freq[i] += freq[i - 1];
int bueno = int(max_element(freq, freq + M) - freq);
if (freq[bueno] < p) {
cout << "-1\n";
return 0;
}
vector<int> ans;
for (int i = 0; i < p; i++) {
if (comp[i << 1] < comp[i << 1 | 1]) lado[i] = 1;
int escogido = comp[i << 1 | lado[i]];
if (cle[escogido] > bueno || bueno >= cri[escogido]) lado[i] ^= 1;
if (!lado[i]) ans.push_back(i);
}
cout << ans.size() << ' ' << bueno + 1 << '\n';
for (auto el : ans) cout << el + 1 << ' ';
cout << '\n';
}
| 2,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
pair<int, int> a[400];
int b[400];
int go() {
for (int i = 0; i < n; i++) a[i].second = i;
sort(a, a + n);
int n1 = 0, n2 = 0;
for (int i = 0; i < n;) {
int j;
for (j = i; j < n && a[i].first == a[j].first; j++)
;
int c = j - i;
if (c >= 2) {
n1++, n2++;
b[a[i].second] = 1;
b[a[i + 1].second] = 2;
} else if (n1 < n2) {
n1++;
b[a[i].second] = 1;
} else {
n2++;
b[a[i].second] = 2;
}
i = j;
}
int ans = n1 * n2;
for (int i = 0; i < n; i++) {
if (b[i]) continue;
if (n1 < n2) {
n1++;
b[i] = 1;
} else {
n2++;
b[i] = 2;
}
}
return ans;
}
int main() {
scanf("%d", &n);
n *= 2;
for (int i = 0; i < n; i++) scanf("%d", &a[i].first);
printf("%d\n", go());
for (int i = 0; i < n; i++) printf("%d ", b[i]);
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int n, w, m;
int pos = 1, cup = 1;
double a[51];
int cnt[51];
vector<pair<int, double> > ans;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
scanf("%d%d%d", &n, &w, &m);
double t = (double)n * (double)w / (double)m;
for (int i = 1; i <= m; ++i) a[i] = t;
double rest = (double)w;
while (pos <= n) {
if (a[cup] - rest <= 1e-6) {
rest -= a[cup];
cnt[pos]++;
if (cnt[pos] > 2) return puts("NO"), 0;
ans.push_back(make_pair(pos, a[cup]));
cup++;
ans.push_back(make_pair(-1, 0));
if (rest <= 1e-6) pos++, rest = (double)w;
} else {
a[cup] -= rest;
cnt[pos]++;
if (cnt[pos] > 2) return puts("NO"), 0;
ans.push_back(make_pair(pos, rest));
pos++;
rest = (double)w;
}
}
puts("YES");
for (int i = 0; i < ans.size(); ++i) {
if (ans[i].first == -1)
puts("");
else
printf("%d %.6lf ", ans[i].first, ans[i].second);
}
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
void _io() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
void _init();
const int MAXN = 1000005;
const long long mod = 998244353;
int n, q, a[MAXN], p[MAXN], ans[MAXN];
int occur[MAXN];
unordered_set<int> num[MAXN];
vector<int> g[MAXN];
struct NODE {
int l, k, id;
NODE(int a, int b, int c) : l(a), k(b), id(c) {}
};
vector<NODE> Q[MAXN];
int ta[MAXN];
void add(int k, int p) {
if (k <= 0) return;
for (int i = k; i <= n; i += i & (-i)) ta[i] += p;
}
int get(int k) {
int res = 0;
for (int i = k; i > 0; i -= i & (-i)) res += ta[i];
return res;
}
void add(int v) {
add(occur[v], -1);
num[occur[v]].erase(v);
occur[v]++;
add(occur[v], 1);
num[occur[v]].insert(v);
}
void del(int v) {
add(occur[v], -1);
num[occur[v]].erase(v);
occur[v]--;
add(occur[v], 1);
num[occur[v]].insert(v);
}
int deal(int l, int k) {
int low = l, high = n;
while (low < high) {
int mid = (low + high) >> 1;
if (get(mid) - get(l - 1) >= k)
high = mid;
else
low = mid + 1;
}
if (get(low) - get(l - 1) < k) return -1;
return *num[low].begin();
}
void dfs(int u) {
add(a[u]);
for (auto x : Q[u]) {
ans[x.id] = deal(x.l, x.k);
}
for (auto v : g[u]) {
dfs(v);
}
del(a[u]);
}
void _work() {
cin >> n >> q;
for (int i = 1; i <= n; i++) Q[i].clear(), g[i].clear(), cin >> a[i];
for (int i = 2; i <= n; i++) {
cin >> p[i];
g[p[i]].emplace_back(i);
}
for (int v, l, k, i = 1; i <= q; i++) {
cin >> v >> l >> k;
Q[v].emplace_back(l, k, i);
}
dfs(1);
for (int i = 1; i <= q; i++) cout << ans[i] << ' ';
cout << '\n';
}
int main() {
_io();
_init();
int T = 1;
cin >> T;
while (T--) {
_work();
}
return 0;
}
void _init() {}
| 2,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, x, c, a[1005], m[1005], M[1005];
bool win() {
if (!a[1]) return 0;
for (int i = 2; i <= n; ++i) {
if (!a[i]) return 0;
if (a[i] < a[i - 1]) return 0;
}
return 1;
}
void f(int x) {
if (x <= (c >> 1)) {
for (int i = 1; i <= n; ++i)
if (!a[i] || a[i] > x) {
if (M[i] <= x && m[i] >= x) {
printf("%d\n", i);
fflush(stdout);
a[i] = x;
break;
}
}
return;
}
for (int i = n; i; --i)
if (!a[i] || a[i] < x) {
if (M[i] <= x && m[i] >= x) {
printf("%d\n", i);
fflush(stdout);
a[i] = x;
break;
}
}
}
int main() {
scanf("%d%d%d", &n, &x, &c);
for (int i = 0; i <= n + 1; ++i) m[i] = 0x7fffffff, M[i] = -m[i];
while (x--) {
int t;
scanf("%d", &t);
f(t);
if (win()) break;
}
return 0;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
long long int beauties[n];
long long int totalBeauty = 0;
long long int capitalBeauty = 0;
for (int i = 0; i < n; i++) {
cin >> beauties[i];
totalBeauty += beauties[i];
}
bool is_capital[n];
memset(is_capital, 0, sizeof(is_capital));
for (int i = 0; i < k; i++) {
int d;
cin >> d;
d--;
is_capital[d] = true;
capitalBeauty += beauties[d];
}
long long int nonCapitalBeauty = totalBeauty - capitalBeauty;
long long int total = 0;
long long int capitalTotal = 0;
;
for (int i = 0; i < n; i++) {
;
if (is_capital[i]) {
long long int otherNonCapital = nonCapitalBeauty * beauties[i];
long long int otherCapital = (capitalBeauty - beauties[i]) * beauties[i];
capitalTotal += otherCapital;
;
;
total += otherNonCapital + otherCapital;
} else {
int nexti = (i + 1) % n;
if (is_capital[nexti]) {
continue;
} else {
total += beauties[nexti] * beauties[i];
;
}
}
}
cout << total - (capitalTotal / 2);
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 100;
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
long double t, a, b, c, d;
long long ans;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> t;
while (t--) {
cin >> a >> b >> c;
d = floor((b + c - a) / 2);
if (d < 0) {
d = -1;
}
ans = c - d;
if (ans < 0) {
ans = 0;
}
cout << ans << endl;
}
return 0;
}
| 1,300 | CPP |
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
ans = [a[i] for i in range(n) if i in (0, n - 1) or a[i] != sorted(a[i - 1:i + 2])[1]]
print(len(ans))
print(*ans) | 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
inline int read() {
int s = 0;
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) s = s * 10 + ch - '0', ch = getchar();
return s;
}
vector<pair<int, int> > G[N];
int n, x;
int deg[N], ver[N], vis[N];
long long f[N][2], val[N], sum;
multiset<long long> s[N];
inline void ins(int u, long long x) {
val[u] += x;
s[u].insert(x);
}
inline void era(int u, long long x) {
val[u] -= x;
s[u].erase(s[u].find(x));
}
inline void del(int u) {
for (auto &[v, w] : G[u]) {
if (deg[v] <= x) break;
ins(v, w);
}
}
void dfs(int u, int fa) {
vis[u] = x;
int cnt = deg[u] - x;
while ((int)s[u].size() && (int)s[u].size() > cnt) era(u, *(--s[u].end()));
for (auto &[v, w] : G[u]) {
if (v == fa) continue;
if (deg[v] <= x) break;
dfs(v, u);
}
vector<long long> tmp, del;
long long res = 0;
for (auto &[v, w] : G[u]) {
if (v == fa) continue;
if (deg[v] <= x) break;
long long x = f[v][1] + w - f[v][0];
if (x <= 0) {
cnt--, res += f[v][1] + w;
continue;
}
res += f[v][0], ins(u, x), del.push_back(x);
}
while ((int)s[u].size() && (int)s[u].size() > cnt) {
tmp.push_back(*(--s[u].end()));
era(u, *(--s[u].end()));
}
f[u][0] = res + val[u];
while ((int)s[u].size() && (int)s[u].size() > cnt - 1) {
tmp.push_back(*(--s[u].end()));
era(u, *(--s[u].end()));
}
f[u][1] = res + val[u];
for (auto i : tmp) ins(u, i);
for (auto i : del) era(u, i);
}
int main() {
n = read();
for (int i = 1; i < n; i++) {
int u = read(), v = read(), w = read();
sum += w;
G[u].push_back({v, w});
G[v].push_back({u, w});
deg[u]++, deg[v]++;
}
printf("%lld ", sum);
for (int i = 1; i <= n; i++) {
ver[i] = i;
sort(G[i].begin(), G[i].end(), [](pair<int, int> &x, pair<int, int> &y) {
return deg[x.first] > deg[y.first];
});
}
sort(ver + 1, ver + n + 1, [](int x, int y) { return deg[x] < deg[y]; });
int pos = 1;
for (x = 1; x < n; x++) {
while (pos <= n && deg[ver[pos]] == x) del(ver[pos]), pos++;
long long ans = 0;
for (int i = pos; i <= n; i++) {
int u = ver[i];
if (vis[u] == x) continue;
dfs(u, 0);
ans += f[u][0];
}
printf("%lld ", ans);
}
return 0;
}
| 3,400 | CPP |
#include <bits/stdc++.h>
int main() {
long long int n, k, r, min, max;
scanf("%lld%lld", &n, &k);
if (k == 0 || k - n == 0) {
printf("0 0");
return 0;
}
r = n / 3;
min = 1;
if (n % 3 == 1) {
if (k <= r)
max = k * 2;
else if (k == r + 1)
max = r * 2;
else
max = 3 * r - k + 1;
} else if (n % 3 == 2) {
if (k <= r)
max = k * 2;
else if (k == r + 1)
max = r * 2 + 1;
else if (k == r + 2)
max = r * 2;
else
max = 3 * r - k + 2;
} else if (n % 3 == 0) {
if (k <= r)
max = k * 2;
else
max = 3 * r - k;
}
printf("%lld %lld", min, max);
}
| 1,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int b[100005][2];
void sort_by_marks(int data[][2], int n) {
auto ptr = (pair<int, int>*)data;
sort(ptr, ptr + n);
}
int main() {
int n, k;
cin >> n >> k;
int qua = 0;
int ost = 0;
int temp;
priority_queue<int> qu;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 100) {
b[i][1] = -1;
b[i][0] = 0;
qua += 10;
} else {
b[i][0] = a[i] / 10;
b[i][1] = a[i] % 10;
ost += 9 - b[i][0];
qua += b[i][0];
qu.push(b[i][1]);
}
}
bool completed = false;
int size = qu.size();
for (int i = 0; i < size; i++) {
int t = qu.top();
qu.pop();
t = 10 - t;
k -= t;
if (k >= 0) {
qua++;
} else {
completed = true;
break;
}
}
if (completed || k < 10) {
cout << qua;
} else {
k /= 10;
if (ost > k) {
qua += k;
} else {
qua += ost;
}
cout << qua;
}
return 0;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:225450978")
#pragma GCC optimize("Ofast")
using namespace std;
const long long Mod = 1000000007LL, INF = 1e9, LINF = 1e18;
const long double Pi = 3.141592653589793116, EPS = 1e-9,
Gold = ((1 + sqrt(5)) / 2);
long long keymod[] = {1000000007LL, 1000000009LL, 1000000021LL, 1000000033LL};
long long keyCount = sizeof(keymod) / sizeof(long long);
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcountll(s);
}
auto TimeStart = chrono::steady_clock::now();
auto TimeEnd = chrono::steady_clock::now();
void ControlIO(int argc, char* argv[]);
void TimerStart();
void TimerStop();
void Exit();
int n, T;
int p[5001], t[5001];
double afterIntro[5001], maxStocked[5001];
double dp[5001][5001];
void Input() {
cin >> n >> T;
for (int i = 1; i <= n; i++) {
cin >> p[i] >> t[i];
double Last = 1.0;
afterIntro[i] = 1.0;
maxStocked[i] = 1.0;
for (int x = 1; x < t[i]; x++) {
afterIntro[i] -= Last * p[i] / 100;
maxStocked[i] *= (100 - p[i]);
maxStocked[i] /= 100;
Last *= (100 - p[i]);
Last /= 100.0;
}
}
}
void Solve() {
dp[0][0] = 1.0;
for (int i = 1; i <= n; i++) {
double Curr = 0.0;
for (int j = 0; j <= T; j++) {
if (j - t[i] >= 0) {
dp[i][j] += dp[i - 1][j - t[i]] * afterIntro[i];
Curr -= dp[i - 1][j - t[i]] * maxStocked[i];
}
dp[i][j] += Curr * p[i] / 100;
Curr *= (100 - p[i]);
Curr /= 100;
if (j < T) Curr += dp[i - 1][j];
}
dp[i - 1][T] += Curr;
}
double expected = 0;
for (int i = 1; i <= n; i++) expected += dp[i][T] * i;
for (int i = 0; i < T; i++) expected += dp[n][i] * n;
cout << fixed << setprecision(12) << expected;
}
int main(int argc, char* argv[]) {
ControlIO(argc, argv);
ios_base::sync_with_stdio(0);
cin.tie(NULL);
Input();
TimerStart();
Solve();
TimerStop();
return 0;
}
void ControlIO(int argc, char* argv[]) {}
void TimerStart() {}
void TimerStop() {}
void Exit() {
TimerStop();
exit(0);
}
| 2,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
pair<int, int> p[N];
int a[N];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i].first);
p[i].second = i;
}
sort(p + 1, p + n + 1);
int b = 0;
for (int i = 1; i <= n; i++) {
b = max(b, p[i].second);
a[p[i].second] = max(0, b - p[i].second);
}
for (int i = 1; i <= n; i++) printf("%d ", a[i] - 1);
printf("\n");
return 0;
}
| 1,500 | CPP |
a=list(map(int,input().split()))
if a[0]+a[1]==a[2]+a[3]:
print('YES')
elif a[2]+a[1]==a[0]+a[3]:
print('YES')
elif a[0]+a[2]==a[1]+a[3]:
print('YES')
elif a[0]+a[2]+a[1]==a[3]:
print('YES')
elif a[0]+a[3]+a[1]==a[2]:
print('YES')
elif a[0]+a[2]+a[3]==a[1]:
print('YES')
elif a[3]+a[2]+a[1]==a[0]:
print('YES')
else:
print('NO')
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
const int modulo = 1000000007;
long long n, m, k;
long long f[maxn][maxn * maxn], g[maxn][maxn], C[maxn][maxn];
void input() {
cin >> n >> m >> k;
C[1][0] = C[1][1] = 1;
for (register int i = 2; i <= n; i++) {
C[i][0] = 1;
for (register int j = 1; j <= i; j++) {
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % modulo;
}
}
}
long long pwr(long long x, long long k) {
long long re = 1;
x %= modulo;
while (k) {
if (k & 1) re = 1ll * re * x % modulo;
x = 1ll * x * x % modulo;
k >>= 1;
}
return re;
}
void solve() {
long long ans = 0, a = m / n, b = m % n;
int lm = min(k, n);
f[0][0] = 1;
for (register int i = 1; i <= n; i++) {
for (register int j = 0; j <= n; j++) {
g[i][j] = pwr(C[n][j], a + (b >= i));
}
}
for (register int i = 1; i <= n; i++) {
for (register int p = 0; p <= k; p++) {
for (register int j = 0, ed = min(lm, p); j <= ed; j++) {
f[i][p] = (f[i][p] + f[i - 1][p - j] * g[i][j]) % modulo;
}
}
}
cout << f[n][k] << endl;
}
int main() {
input();
solve();
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1e9 + 7, N = 7850;
void add_to(int &x, int y) {
x += y;
if (x >= Mod) x -= Mod;
}
void inm_to(int &x, int y) { x = (long long)x * y % Mod; }
int inm(int x, int y) { return (long long)x * y % Mod; }
int power(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) inm_to(ans, a);
inm_to(a, a);
b >>= 1;
}
return ans;
}
int inv(int x) { return power(x, Mod - 2); }
int i, R, prob[4], sum, a[N][N], ans[N], j, id[105][105], ids, x, y, last, ct,
k;
pair<int, int> ec[N];
int dx[4] = {-1, 0, +1, 0};
int dy[4] = {0, -1, 0, +1};
int main() {
cin >> R;
int D = R + 1;
for (i = 0; i < 4; ++i) cin >> prob[i], add_to(sum, prob[i]);
sum = inv(sum);
for (i = 0; i < 4; ++i) inm_to(prob[i], sum);
for (i = -R; i <= R; ++i)
for (j = -R; j <= R; ++j)
if (i * i + j * j <= R * R) {
id[i + D][j + D] = ++ids;
ec[ids] = {i, j};
}
for (i = 1; i <= ids; ++i) {
tie(x, y) = ec[i];
a[i][i] = a[i][ids + 1] = 1;
for (j = 0; j < 4; ++j)
a[i][id[x + dx[j] + D][y + dy[j] + D]] = Mod - prob[j];
a[i][0] = 0;
}
for (i = 1; i <= ids; ++i) {
last = min(ids, i + 2 * R + 1);
x = inv(a[i][i]);
for (j = i; j <= last; ++j) inm_to(a[i][j], x);
inm_to(a[i][ids + 1], x);
for (j = i + 1; j <= last; ++j) {
ct = a[j][i];
for (k = i; k <= last; ++k) add_to(a[j][k], Mod - inm(a[i][k], ct));
add_to(a[j][ids + 1], Mod - inm(a[i][ids + 1], ct));
}
}
for (i = ids; i; --i) {
ans[i] = inm(a[i][ids + 1], inv(a[i][i]));
last = max(1, i - 2 * R - 1);
for (j = last; j < i; ++j) {
add_to(a[j][ids + 1], Mod - inm(a[j][i], ans[i]));
a[j][i] = 0;
}
}
cout << ans[id[D][D]] << '\n';
return 0;
}
| 3,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
double dp[101][101][101], ways[3 * 101];
int main() {
int r, s, p;
scanf("%d%d", &r, &s);
scanf("%d", &p);
for (int i = 0; i < (int)3 * 101; i++) ways[i] = (i * (i - 1)) / 2;
for (int i = 1; i < (int)101; i++) {
dp[i][0][0] = 1.0;
for (int j = 0; j < (int)101; j++)
for (int k = 0; k < (int)101; k++) {
if (j + k == 0) continue;
double div = ways[i + j + k] - ways[i] - ways[j] - ways[k];
dp[i][j][k] = (i * k * dp[i - 1][j][k]) / div;
if (j) dp[i][j][k] += (i * j * dp[i][j - 1][k]) / div;
if (k) dp[i][j][k] += (k * j * dp[i][j][k - 1]) / div;
}
}
printf("%.10lf %.10lf %.10lf\n", dp[r][s][p], dp[s][p][r], dp[p][r][s]);
return 0;
}
| 1,900 | CPP |
n = int(input())
a = ''.join(str(x) for x in (int(x) % 2 for x in input().split()))
i0, i1 = a.find('0') + 1, a.find('1') + 1
print(i0 if a.find('0', i0) == -1 else i1)
| 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int cnt[101];
int main() {
int n, m, t, sum = 0;
cin >> n >> m >> t;
cnt[t]++;
cout << 0 << ' ';
sum += t;
for (int i = 1; i < n; i++) {
cin >> t;
int sum_del = 0, ans = 0;
for (int j = 101; j >= 1; j--) {
if (sum - sum_del - cnt[j] * j + t <= m) {
int k = max(-(m - (sum - sum_del + t)), 0);
ans += (k / j + bool(k % j));
break;
} else {
ans += cnt[j];
sum_del += cnt[j] * j;
}
}
cout << ans << ' ';
cnt[t]++;
sum += t;
}
}
| 1,700 | CPP |
for i in range(int(input())):
a, b = map(int, input().split())
p = abs(b - a)
print(p // 10 + (p % 10 != 0)) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, t1, t2, cou = 0;
vector<bool> visited(100005, false);
map<long long, set<long long>> tree;
vector<long long> cats(100005);
void dfs(long long node, long long k) {
if (visited[node] || k + cats[node] > m) return;
if (!cats[node]) {
k = 0;
}
visited[node] = true;
if (tree[node].size() == 1 && visited[*tree[node].begin()] == true) {
cou++;
}
for (const auto neighbour : tree[node]) {
dfs(neighbour, k + cats[node]);
}
}
void solve() {
cin >> n >> m;
for (long long i = 1; i < n + 1; i++) {
cin >> cats[i];
}
long long temp;
for (long long i = 1; i < n; i++) {
cin >> t1 >> t2;
tree[t1].insert(t2);
tree[t2].insert(t1);
}
dfs(1, 0);
cout << cou << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
solve();
}
| 1,500 | CPP |
from math import log2
def recursive_function(minimum_amt, expected_bacteria_amt):
remainder = expected_bacteria_amt % 2 ** int(log2(expected_bacteria_amt))
if remainder == 0:
return minimum_amt
elif remainder == 1:
return minimum_amt + 1
else:
return recursive_function(minimum_amt+1, remainder)
expected_bacteria_amt = int(input())
if log2(expected_bacteria_amt) == int(log2(expected_bacteria_amt)):
minimum_amt = 1
else:
minimum_amt = recursive_function(1, expected_bacteria_amt)
print(minimum_amt) | 1,000 | PYTHON3 |
p = input()
c = list('HQ9')
for i in p:
if i in c:
print('YES')
break
else:
print('NO') | 900 | PYTHON3 |
a, b = (map(int, input().split()))
if a<b:
raznue = a
else:
raznue = b
if a<b:
para = (b - a)//2
else:
para = (a - b)//2
print(f'{raznue} {para}') | 800 | PYTHON3 |
from collections import defaultdict as dd
import sys
input=sys.stdin.readline
t=int(input())
while t:
n=int(input())
#n,m=map(int,input().split())
l=list(map(int,input().split()))
i=0
j=1
ll=[l[0]]
ans=0
lol=0
while j<n and i<n:
if(l[j]==l[j-1]):
j+=1
i+=1
elif(l[j]>l[j-1]):
if(j!=i and lol==-1):
ll.append(l[j-1])
i=j-1
lol=1
j+=1
else:
if(j!=i and lol==1):
ll.append(l[j-1])
i=j-1
lol=-1
j+=1
if(ll[-1]!=l[n-1]):
ll.append(l[n-1])
ans=len(ll)
if(ans==1):
ans+=1
ll.append(ll[0])
print(ans)
print(*ll)
t-=1
| 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const float eps = 1e-8;
const long long lloo = 1e18;
const int oo = 1e9;
const int base = int(1e9) + 7;
int sl[100010][4], sum[200010][4];
long long f[100010][4];
int n;
string s;
int a[200010];
int main() {
int n;
cin >> n;
cin >> s;
s = s + s;
for (int i = 0; i < s.size(); i++) {
switch (s[i]) {
case 'A':
a[i] = 0;
break;
case 'C':
a[i] = 1;
break;
case 'G':
a[i] = 2;
break;
case 'T':
a[i] = 3;
break;
}
}
for (int i = 0; i < 2 * n; i++)
for (int j = 0; j < 4; j++) sum[i + 1][j] = sum[i][j] + (a[i] == j);
f[0][1] = 0;
sl[0][1] = 1;
for (int i = 1, _b = n; i <= _b; i++)
for (int j = 0; j < 4; j++) {
long long smax = 0, luu = 0;
for (int z = 0; z < 4; z++) smax = max(smax, f[i - 1][z]);
for (int z = 0; z < 4; z++)
if (f[i - 1][z] == smax) luu = (sl[i - 1][z] + luu) % base;
f[i][j] = smax + sum[i + n - 1][j] - sum[i - 1][j];
sl[i][j] = luu;
}
long long smax = 0, luu = 0;
for (int j = 0; j < 4; j++) smax = max(smax, f[n][j]);
for (int j = 0; j < 4; j++)
if (f[n][j] == smax) luu = (luu + sl[n][j]) % base;
cout << luu;
}
| 1,500 | CPP |
s = input().split()
l = []
for i in range(len(s)):
l.append(int(s[i]))
l.sort()
k = []
for i in range(len(s)-1):
k.append( str(l[len(s)-1] - l[i]) )
c = ' '.join(k)
print(c) | 800 | PYTHON3 |
import datetime as DT
def bus(a, t_a, b, t_b, t):
t1 = DT.datetime.strptime(t, '%H:%M')
t2 = DT.datetime(1900, 1, 1)
t_start = ((t1 - t2).total_seconds() / 60.0) - 300
t_end = t_start + t_a
t_elapsed = 0
z = 0
while(t_elapsed <= 23 * 60 + 59 - 300):
start = t_elapsed
end = start + t_b
if(max(t_start, start) < min(t_end, end)):
z += 1
t_elapsed += b
return z
if __name__ == "__main__":
a = input().split(' ')
b = input().split(' ')
t = input()
print(bus(int(a[0]), int(a[1]), int(b[0]), int(b[1]), t))
| 1,600 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1009, MOD = 1e9 + 7;
int n, m, a[MAX], s, ans = 1, pw[MAX], c[MAX][MAX];
int main() {
pw[0] = pw[1] = 1;
for (int i = 2; i < MAX; i++) pw[i] = 2LL * pw[i - 1] % MOD;
for (int i = 0; i < MAX; i++)
for (int j = 0; j <= i; j++)
c[i][j] =
((!i || !j || i == j) ? 1 : c[i - 1][j] + c[i - 1][j - 1]) % MOD;
cin >> n >> m;
for (int i = 1; i <= m; i++) cin >> a[i];
sort(a + 1, a + m + 1);
s = n - m;
for (int i = 2; i <= m; i++) {
ans = 1LL * ans * c[s][a[i] - a[i - 1] - 1] % MOD *
pw[a[i] - a[i - 1] - 1] % MOD;
s -= a[i] - a[i - 1] - 1;
}
ans = 1LL * ans * c[s][a[1] - 1] % MOD;
cout << ans;
}
| 1,900 | CPP |
s=input()
s1=input()
if len(s)!=len(s1):
print('NO')
else:
x=0
for i in range(len(s)):
if s[i]!=s1[len(s)-1-i]:
print('NO')
break
else:
x+=1
if x==len(s):
print('YES') | 800 | PYTHON3 |
def Main():
n, a, b, c = map(int, input().split())
dp = [0] * 4001
dp[a] = 1
dp[b] = 1
dp[c] = 1
for i in range(n+1):
if i - a >= 0 and dp[i-a] > 0 and dp[i-a]+1 > dp[i]:
dp[i] = dp[i-a]+1
if i - b >= 0 and dp[i-b] > 0 and dp[i-b]+1 > dp[i]:
dp[i] = dp[i-b]+1
if i - c >= 0 and dp[i-c] > 0 and dp[i-c]+1 > dp[i]:
dp[i] = dp[i-c]+1
print(dp[n])
if __name__ == "__main__":
Main()
| 1,300 | PYTHON3 |
import sys
input = sys.stdin.readline
def Ctask(left, right,n):
q = left.index(max(left))
z = right.index(min(right))
if q == 0:
f = min(right[1:]) - max(left[1:])
elif q == n - 1:
f = min(right[:n-1]) - max(left[:n-1])
else:
f = min(min(right[:q]), min(right[q+1:])) - max(max(left[:q]),max(left[q+1:]))
if z == 0:
s = min(right[1:]) - max(left[1:])
elif z == n - 1:
s = min(right[:n-1]) - max(left[:n-1])
else:
s = min(min(right[:z]), min(right[z+1:])) - max(max(left[:z]),max(left[z+1:]))
return print(max(max(f,s),0))
def main():
n = int(input())
left = []
right = []
for i in range(n):
a, b = map(int, input().split())
left.append(a)
right.append(b)
return Ctask(left, right, n)
if __name__=="__main__":
main() | 1,600 | PYTHON3 |
Subsets and Splits