solution
stringlengths 10
159k
| difficulty
int64 0
3.5k
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const int inf = 1e9;
const int mod = 1e9 + 7;
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
int n, k;
cin >> n >> k;
if (k > n || (k == 1 && n > 1))
cout << "-1" << '\n';
else {
if (n == 1) {
cout << 'a' << '\n';
return 0;
} else if (n == 2) {
cout << "ab" << '\n';
return 0;
}
n -= (k - 2);
string s;
for (int i = 0; i < n; i++) {
if (i % 2)
s += 'b';
else
s += 'a';
}
for (int i = 2; i < k; i++) s += 'a' + i;
cout << s << '\n';
}
return 0;
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, res = 0, RES = 99999999;
cin >> n;
string s[n];
for (int a = 0; a < n; a++) {
cin >> s[a];
}
string s1, s2;
bool ANS = true;
for (int b = 0; b < n; b++) {
s1 = s[b];
s1 = s1 + s1;
res = 0;
for (int a = 0; a < n; a++) {
s2 = s[a];
bool ans = false;
int agregar;
for (int c = 0; c <= s1.size() / 2; c++) {
if (s1.substr(c, s2.size()) == s2) {
agregar = s2.size() - c;
if (c == 0) agregar = 0;
ans = true;
}
}
res += agregar;
if (!ans) ANS = false;
}
RES = min(res, RES);
}
if (ANS)
cout << RES << endl;
else
cout << -1 << endl;
return 0;
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int arr[n + 1], pos[n + 1];
for (long long int i = 1; i <= n; i++) {
cin >> arr[i];
pos[arr[i]] = i;
}
char ans[n + 1];
for (long long int i = n; i > 0; i--) {
long long int posn = pos[i];
long long int next = posn - i;
ans[posn] = 'B';
while (next > 0) {
if (ans[next] == 'B' && arr[next] > i) {
ans[posn] = 'A';
break;
}
next = next - i;
}
next = posn + i;
while (next <= n) {
if (ans[next] == 'B' && arr[next] > i) {
ans[posn] = 'A';
break;
}
next = next + i;
}
}
for (long long int i = 1; i <= n; i++) cout << ans[i];
cout << endl;
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const long long SIZE = 1e5 + 5;
const long long mod = 1e9 + 7;
vector<long long> adj[SIZE];
long long in[SIZE], out[SIZE];
long long dp[SIZE];
long long n, m, d;
bool bad[SIZE];
void dfs1(long long u, long long p) {
long long i, v;
for (i = 0; i < adj[u].size(); i++) {
v = adj[u][i];
if (v == p) continue;
dfs1(v, u);
if (in[v]) in[u] = max(in[u], 1 + in[v]);
}
}
void dfs2(long long u, long long p) {
long long i, v;
long long mx, mx1 = -1, mx2 = -1;
for (i = 0; i < adj[u].size(); i++) {
v = adj[u][i];
if (v == p) continue;
if (in[v] >= mx1 && in[v]) {
mx2 = mx1;
mx1 = in[v];
} else if (in[v] > mx2 && in[v])
mx2 = in[v];
}
for (i = 0; i < adj[u].size(); i++) {
v = adj[u][i];
if (v == p) continue;
mx = mx1;
if (mx == in[v]) mx = mx2;
if (out[u] && mx != -1)
out[v] = max(1 + out[u], 2 + mx);
else if (!out[u] && mx != -1)
out[v] = 2 + mx;
else if (mx == -1 && out[u])
out[v] = 1 + out[u];
dfs2(v, u);
}
}
int main() {
long long t = 0, x, y, z, i, j, k, g, p, q, ans = 0, sum = 0, c = 0;
scanf("%lld %lld", &n, &m);
scanf("%lld", &d);
for (i = 1; i <= m; i++) {
scanf("%lld", &x);
bad[x] = 1;
out[x] = 1;
in[x] = 1;
}
for (i = 1; i <= n - 1; i++) {
scanf("%lld %lld", &x, &y);
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs1(1, 0);
dfs2(1, 0);
for (i = 1; i <= n; i++) {
if (in[i]) in[i]--;
if (out[i]) out[i]--;
}
for (i = 1; i <= n; i++) {
dp[i] = max(in[i], out[i]);
if (dp[i] <= d) ans++;
}
printf("%lld\n", ans);
return 0;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
int f[N], nl[N], t[N], n, componente(0), apare[N], sojboi(0);
pair<int, int> v[N];
int radacina(int nod) {
if (t[nod] == 0) {
return nod;
}
t[nod] = radacina(t[nod]);
return t[nod];
}
void reuniune(int x, int y) {
int rx(radacina(x)), ry(radacina(y));
if (rx == ry) {
return;
}
if (nl[rx] < nl[ry]) {
t[rx] = ry;
nl[ry] += nl[rx];
f[nl[ry]]++;
f[nl[rx]]--;
f[nl[ry] - nl[rx]]--;
if (f[nl[rx]] == 0) {
--sojboi;
}
if (f[nl[ry] - nl[rx]] == 0 && nl[ry] - nl[rx] != nl[rx]) {
--sojboi;
}
if (f[nl[ry]] == 1) {
++sojboi;
}
} else {
t[ry] = rx;
nl[rx] += nl[ry];
f[nl[rx]]++;
f[nl[ry]]--;
f[nl[rx] - nl[ry]]--;
if (f[nl[ry]] == 0) {
--sojboi;
}
if (f[nl[rx] - nl[ry]] == 0 && nl[rx] - nl[ry] != nl[ry]) {
--sojboi;
}
if (f[nl[rx]] == 1) {
++sojboi;
}
}
--componente;
}
void adauga(int poz) {
++componente;
nl[poz] = 1;
apare[poz] = true;
f[1]++;
if (f[1] == 1) {
++sojboi;
}
if (poz < n && apare[poz + 1]) {
reuniune(poz, poz + 1);
}
if (poz > 1 && apare[poz - 1]) {
reuniune(poz, poz - 1);
}
}
int main() {
int componentemax(-1), valoare(1);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> v[i].first;
v[i].second = i;
}
sort(v + 1, v + n + 1);
for (int i = 1; i <= n; ++i) {
adauga(v[i].second);
while (v[i].first == v[i + 1].first) {
++i;
adauga(v[i].second);
}
if (sojboi == 1 && componente > componentemax) {
componentemax = componente;
valoare = v[i].first + 1;
}
}
cout << valoare << "\n";
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
void debug_out() { cerr << endl; }
template <class T>
ostream& prnt(ostream& out, T v) {
out << v.size() << '\n';
for (auto e : v) out << e << ' ';
return out;
}
template <class T>
ostream& operator<<(ostream& out, vector<T> v) {
return prnt(out, v);
}
template <class T>
ostream& operator<<(ostream& out, set<T> v) {
return prnt(out, v);
}
template <class T1, class T2>
ostream& operator<<(ostream& out, map<T1, T2> v) {
return prnt(out, v);
}
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2> p) {
return out << '(' << p.st << ' ' << p.nd << ')';
}
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << H;
debug_out(T...);
}
const int N = 7010;
const int NMAX = 100100;
int n, k, m, a, b, q, op, who, val, x, y, z;
bitset<N> pre[N], v[NMAX], step4[N], sqf;
string ans;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> q;
for (int i = 0; i < N; i++)
for (int j = 1; j * j < N; j++)
if (i % j == 0) pre[i][j] = pre[i][i / j] = 1;
sqf.set();
for (int i = 0; i < N; i++)
for (int j = 2; j * j < N; j++)
if (i % (j * j) == 0) sqf[i] = 0;
for (int i = 1; i < N; i++)
for (int j = i; j < N; j += i)
if (sqf[j / i]) step4[i][j] = 1;
for (int i = 1; i <= q; i++) {
cin >> op;
if (op == 1) {
cin >> who >> val;
v[who] = pre[val];
} else if (op == 2) {
cin >> x >> y >> z;
v[x] = v[y] ^ v[z];
} else if (op == 3) {
cin >> x >> y >> z;
v[x] = v[y] & v[z];
} else {
cin >> x >> y;
ans += (step4[y] & v[x]).count() % 2 + '0';
}
}
cout << ans;
}
| 2,500 | CPP |
q = int(input())
for j in range(q):
n = int(input())
students = list(map(int, input().split()))
a = set(students)
ans = {}
while a:
route = []
ai = a.pop()
cur = students[ai-1]
route.append(ai)
while cur != ai:
route.append(cur)
a.discard(cur)
cur = students[cur-1]
ans.update({r: len(route) for r in route})
print(*[ans[s] for s in students])
| 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tt;
cin >> tt;
while (tt--) {
long long n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long ans = n + (n-1);
long long cur = 0;
auto Check = [&](int x, int y, int z) -> bool {
if ((x <= y && z >= y) || (x >= y && z <= y)) return false;
return true;
};
for (int i = 1; i+1 < n; i++) {
if (Check(a[i-1], a[i], a[i+1])) ans++;
if (i+2 < n) {
if (Check(a[i-1], a[i], a[i+1]) && Check(a[i-1], a[i], a[i+2]) &&
Check(a[i-1], a[i+1], a[i+2]) && Check(a[i], a[i+1], a[i+2])) ans++;
}
}
cout << ans << "\n";
}
return 0;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const double eps = 1e-9;
const int MAX_N = 1e6 + 5;
const int inf = 2e9;
const long long Inf = (long long)1e18;
const long long M = (long long)1e9 + 7;
int Int() {
int x;
scanf("%d", &x);
return x;
}
long long Long() {
long long x;
scanf("%lld", &x);
return x;
}
void Char(char* ch) { scanf("%s", ch); }
template <typename t>
inline t abs(t a) {
if (a >= 0) return a;
return -a;
}
template <typename t>
inline t gcd(t a, t b) {
return !b ? a : gcd(b, a % b);
}
template <typename t>
inline t lcm(t a, t b) {
return a * (b / gcd(a, b));
}
template <typename T>
inline T modpow(T b, T p, T Mod) {
T res = 1;
while (p) {
if (p & 1) {
res *= b;
res %= Mod;
}
b *= b;
b %= Mod;
p >>= 1;
}
return res;
}
template <typename T>
inline T ModInv(T b, T Mod) {
return modpow(b, Mod - 2, Mod);
}
template <typename T>
inline T pwr(T b, T p) {
T res = 1;
while (p) {
if (p & 1) {
res *= b;
}
b *= b;
p >>= 1;
}
return res;
}
int e1, e2, d1;
template <typename T>
inline void extgcd(T a, T b) {
if (!b) {
e1 = 1, e2 = 0, d1 = a;
return;
}
extgcd(b, a % b);
T x1 = e2;
T y1 = e1 - (a / b) * e2;
e1 = x1;
e2 = y1;
}
template <typename T>
inline vector<T> Unique(vector<T> v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
return v;
}
vector<string> split(const string& s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) v.emplace_back(x);
return move(v);
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cout << it->substr((*it)[0] == ' ', it->length()) << " = " << a << " ";
err(++it, args...);
}
int dp[6][6];
int main() {
int t = 1, tc = 0;
while (t--) {
int n = Int();
for (int i = 1; i <= n; i++) {
int x = Int(), y = Int();
dp[x][y] = dp[y][x] = 1;
}
for (int i = 1; i <= 5; i++) {
for (int j = i + 1; j <= 5; j++) {
for (int k = j + 1; k <= 5; k++) {
if (dp[i][j] and dp[i][k] and dp[j][k])
return puts("WIN"), 0;
else if (!dp[i][j] and !dp[i][k] and !dp[j][k])
return puts("WIN"), 0;
}
}
}
puts("FAIL");
}
return 0;
}
| 1,300 | CPP |
cases=int(input())
for _ in range(cases):
n=int(input())
print(len(set(map(int,input().split()))))
| 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int tab[n];
cin >> tab[0];
for (int i = 1; i < n; i++) {
int c;
cin >> c;
tab[i] = tab[i - 1] + c;
}
int num;
cin >> num;
for (int i = 0; i < num; i++) {
int beg, en;
cin >> beg >> en;
int c;
if (beg > 1) {
c = tab[en - 1] - tab[beg - 2];
} else {
c = tab[en - 1];
}
cout << c / 10 << endl;
}
return 0;
}
| 1,400 | CPP |
n=int(input())
a=list(map(int,input().split()))
a.sort()
x=a[n-1]
def divisors(n) :
i = 1
d=[]
while i <= n :
if (n % i==0) :
d.append(i)
i+=1
return d
p=divisors(x)
for ele in p:
a.remove(ele)
y=a.pop()
print(x,y) | 1,100 | PYTHON3 |
a=int(input())
b=int(input())
c=int(input())
s1=a+b+c
s2=a*b*c
s3=a*(b+c)
s4=a+(b*c)
s5=(a+b)*c
s=max(s1,s2,s3,s4,s5)
print(s) | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2 * 1000 * 100 + 10;
int a[MAXN], b[MAXN];
int vv[MAXN];
set<pair<int, int> > q;
map<int, int> M;
int cnt;
long long m;
long long ans = 1;
long long find(int aa, int bb) {
long long res = 1;
for (int i = 1; i <= aa; i++) {
long long w = i;
while (bb > 0 and (w % 2 == 0)) {
w /= 2;
bb--;
}
res *= w;
res %= m;
}
return res;
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= 2 * n; i++) cin >> vv[i];
cin >> m;
for (int i = 1; i <= n; i++) {
int aa = vv[i];
if (M.find(aa) == M.end()) M[aa] = ++cnt;
q.insert(make_pair(M[aa], i));
a[M[aa]]++;
}
for (int i = 1; i <= n; i++) {
int bb = vv[n + i];
if (M.find(bb) == M.end()) {
M[bb] = ++cnt;
} else {
if (q.find(make_pair(M[bb], i)) != q.end()) b[M[bb]]++;
}
a[M[bb]]++;
}
for (int i = 1; i <= cnt; i++) {
ans *= find(a[i], b[i]);
ans %= m;
}
cout << ans << endl;
return 0;
}
| 1,600 | CPP |
n, d = map(int, input().split())
m = int(input())
grasshoppers = [tuple(map(int, input().split())) for _ in range(m)]
x1, y1 = 0, d
x2, y2 = d, 0
x3, y3 = n, n - d
x4, y4 = n - d, n
def sign(p1, p2, p3):
return (p1[0] - p3[0]) * (p2[1] - p3[1]) - (p2[0] - p3[0]) * (p1[1] - p3[1])
def pointInTriangle(pt, v1, v2, v3):
b1 = sign(pt, v1, v2) < 0.0
b2 = sign(pt, v2, v3) < 0.0
b3 = sign(pt, v3, v1) < 0.0
return ((b1 == b2) and (b2 == b3))
for x, y in grasshoppers:
if pointInTriangle((x, y), (x1, y1), (x2, y2), (x3, y3)):
print('YES')
continue
elif pointInTriangle((x, y), (x1, y1), (x4, y4), (x3, y3)):
print('YES')
continue
elif pointInTriangle((x, y), (x2, y2), (x3, y3), (x1, y1)):
print('YES')
continue
elif pointInTriangle((x, y), (x3, y3), (x1, y1), (x2, y2)):
print('YES')
continue
elif pointInTriangle((x, y), (x1, y1), (x3, y3), (x4, y4)):
print('YES')
continue
elif pointInTriangle((x, y), (x4, y4), (x1, y1), (x2, y2)):
print('YES')
continue
else:
print('NO') | 1,100 | PYTHON3 |
n = int(input())
cur = {"U": 0, "D": 0, "L": 0, "R": 0}
commands = input()
for i in range(n):
cur[commands[i]] += 1
print(min(cur["U"], cur["D"]) * 2 + min(cur["L"], cur["R"]) * 2)
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, x, ans = INT_MAX;
cin >> n >> k;
for (int i = 1; i * i <= n; i++) {
if (n % i == 0) {
if (i < k) ans = min(((n / i) * k) + i, ans);
if ((n / i) < k) ans = min(ans, (i * k) + (n / i));
}
}
cout << ans << endl;
return 0;
}
| 1,100 | CPP |
n, k = map(int, input().split())
d = 1000000007
n += 1
r = [{} for i in range(n)] # multiples
for i in range(2, n):
if r[i] == {}:
for j in range(i, n, i): r[j][i] = 1
q = i * i
while q < n:
for j in range(q, n, q): r[j][i] += 1
q *= i
c = [1, k] + [0] * 9 # binomial
k -= 1
for i in range(2, 11): c[i] = (c[i - 1] * (k + i)) // i
s = -1
for q in r:
p = 1
for i in q.values(): p = p * c[i]
s += p
print(s % d) | 1,400 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int k;
long long int a;
long long int b;
int q;
vector<long long int> vv;
long long int f[200002];
struct bit {
vector<long long int> BIT;
void add(int i, long long int x) {
i++;
while (i < BIT.size()) {
BIT[i] += x;
i += i & -i;
}
}
long long int sum(int i) {
long long int r = 0;
i++;
while (i) {
r += BIT[i];
i -= i & -i;
}
return r;
}
void resize(int n) { BIT.assign(n + 2, 0); }
};
bit BIT;
bit BITA;
long long int sum = 0;
struct query {
int ty;
int day;
long long int add;
query() {
scanf("%d", &ty);
scanf("%d", &day);
if (ty == 1) {
scanf("%lld", &add);
f[day] += add;
vv.push_back(f[day]);
}
}
void ty1() {
BIT.add(day, -max(0LL, f[day] - a));
BITA.add(day, -min(f[day], a));
sum -= min(f[day], a);
f[day] += add;
f[day] = min(f[day], b);
BIT.add(day, max(0LL, f[day] - a));
BITA.add(day, min(f[day], a));
sum += min(f[day], a);
}
void ty2() {
int d = day;
long long int ans = sum;
ans += BIT.sum(n) - BIT.sum(d + k - 1);
ans -= BITA.sum(d + k - 1) - BITA.sum(d - 1);
printf("%I64d\n", ans);
}
void done() {
if (ty == 1) {
ty1();
} else {
ty2();
}
}
};
vector<query> v;
int main() {
scanf("%d%d%lld%lld%d", &n, &k, &b, &a, &q);
for (int i = 0; i < n; i++) {
f[i] = 0;
}
vv.push_back(0);
for (int i = 0; i < q; i++) {
v.push_back(query());
}
sort(vv.begin(), vv.end());
vv.erase(unique(vv.begin(), vv.end()), vv.end());
BIT.resize(n);
BITA.resize(n);
memset(f, 0, sizeof(f));
for (int i = 0; i < q; i++) {
v[i].done();
}
return 0;
}
| 1,700 | CPP |
a = list(map(int, input().split()))
for i in range(6):
for j in range(i + 1, 6):
for g in range(j + 1, 6):
sum1 = a[i] + a[j] + a[g]
sum2 = 0
for k in range(6):
if k != i and k != j and k != g:
sum2 += a[k]
if sum1 == sum2:
print("YES")
exit(0)
print("NO") | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int i, j, a = 1, b, k;
string s;
int mas[5];
int mass[200];
int main() {
cin >> s;
for (i = 0; i < s.size(); i++) {
if (s[i] == 'h' && mass[int('h')] != 1) mas[0] = a, mass[int('h')] = 1;
if (s[i] == 'e' && mass[int('e')] != 1 && mass[int('h')] == 1)
mas[1] = a, mass[int('e')] = 1;
if (s[i] == 'i' && mass[int('i')] != 1 && mass[int('h')] == 1 &&
mass[int('e')] == 1)
mas[2] = a, mass[int('i')] = 1;
if (s[i] == 'd' && mass[int('d')] != 1 && mass[int('h')] == 1 &&
mass[int('e')] == 1 && mass[int('i')] == 1)
mas[3] = a, mass[int('d')] = 1;
a++;
}
for (i = 0; i < 3; i++) {
if (mas[i] > mas[i + 1] || mas[i] == 0 || mas[i + 1] == 0) k++;
}
if (k == 0) {
for (i = mas[3] - 1; i < s.size(); i++)
if (s[i] == 'i') {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 800 | CPP |
sum=0
c=0
n=eval(input())
w=[]
for i in range(n):
s=input()
l=s.split(" ")
for i in range(len(l)):
l[i]=int(l[i])
w.append(l)
for i in range(n):
for j in range(3):
sum=sum+w[i][j]
if(sum>=2):
c=c+1
sum=0
print(c) | 800 | PYTHON3 |
t = int(input())
m = []
for i in range(t):
m.append(input())
for i in m:
if i[-2] == 'p' and i[-1] == 'o':
print("FILIPINO")
elif (i[-4] == 'd' and i[-3] == 'e' and i[-2] == 's' and i[-1] == 'u') or (i[-4] == 'm' and i[-3] == 'a' and i[-2] == 's' and i[-1] == 'u'):
print("JAPANESE")
elif i[-5] == 'm' and i[-4] == 'n' and i[-3] == 'i' and i[-2] == 'd' and i[-1] == 'a':
print("KOREAN") | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const bool read_file = false;
const char fi[] = "XX.inp";
const char fo[] = "XX.out";
void set_up() {
if (read_file) {
freopen(fi, "r", stdin);
freopen(fo, "w", stdout);
}
cin.clear();
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
void just_do_it();
int main() {
set_up();
just_do_it();
}
bool ok(int x, string s) {
deque<int> d;
if (x == 0) {
d.push_back(0);
} else {
while (x != 0) {
d.push_front(x % 10);
x /= 10;
}
}
int f = -1;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'X') {
if (f == -1) {
f = d[i];
}
if (f != d[i]) {
return false;
}
} else if (s[i] != '_') {
if (d[i] != s[i] - '0') {
return false;
}
}
}
return true;
}
void just_do_it() {
string s;
cin >> s;
int res = 0;
int p;
if (s.size() == 1) {
if (ok(0, s)) {
res++;
}
} else if (s.size() == 2) {
if (ok(25, s)) {
res++;
}
if (ok(50, s)) {
res++;
}
if (ok(75, s)) {
res++;
}
} else {
p = 1;
for (int i = 0; i < s.size() - 1; i++) {
p *= 10;
}
for (int i = p; i < p * 10; i += 25) {
if (ok(i, s)) {
res++;
}
}
}
cout << res << endl;
}
| 1,800 | CPP |
#include <bits/stdc++.h>
int main() {
long long n, m, k, i, ans = 0, res1 = 1, res2 = 1;
scanf("%I64d", &n);
m = n + 2;
k = n + 4;
for (i = 1; i <= 3; i++) {
res1 = res1 * m / i;
m--;
}
for (i = 1; i <= 5; i++) {
res2 = res2 * k / i;
k--;
}
ans = res1 * res2;
printf("%I64d\n", ans);
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1000;
int n, k;
int x[MAX_N], y[MAX_N];
int dt[MAX_N][MAX_N];
int dis(int i, int j) {
return (x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]);
}
int ds[MAX_N * MAX_N], nDs;
int bad[MAX_N][MAX_N], nBad[MAX_N];
int cnt[MAX_N], bd;
int perm[MAX_N];
void rec(int it) {
if (bd > k) {
return;
}
if (it == n) {
throw 1;
}
int i = perm[it];
if (cnt[i] > 0) {
rec(it + 1);
return;
}
int newbad = 0;
for (int j = 0; j < nBad[i]; ++j) {
if (++cnt[bad[i][j]] == 1) {
++bd;
newbad++;
}
}
rec(it + 1);
for (int j = 0; j < nBad[i]; ++j) {
if (--cnt[bad[i][j]] == 0) --bd;
}
if (newbad > 1) {
++cnt[i];
++bd;
rec(it + 1);
--cnt[i];
--bd;
}
}
int cmp(int a, int b) { return nBad[a] < nBad[b]; }
bool check(int L) {
for (int i = 0; i < n; ++i) {
nBad[i] = 0;
for (int j = 0; j < n; ++j) {
if (dt[i][j] > L) {
bad[i][nBad[i]++] = j;
}
}
perm[i] = i;
}
sort(perm, perm + n, cmp);
memset(cnt, 0, sizeof cnt);
bd = 0;
try {
rec(0);
} catch (int e) {
return true;
}
return false;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> x[i] >> y[i];
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < i; ++j) {
dt[i][j] = dt[j][i] = dis(i, j);
ds[nDs++] = dt[i][j];
}
}
sort(ds, ds + nDs);
int l = -1, r = nDs;
while (l + 1 < r) {
int m = (l + r) / 2;
if (check(ds[m]))
r = m;
else
l = m;
}
check(ds[r]);
bool used[MAX_N] = {};
vector<int> ans;
for (int i = 0; i < n; ++i) {
if (cnt[i] > 0) ans.push_back(i + 1), used[i] = true;
}
for (int i = 0; i < n; ++i) {
if (ans.size() < k && !used[i]) {
used[i] = true;
ans.push_back(i + 1);
}
}
for (int i = 0; i < ans.size(); ++i) {
cout << ans[i] << " ";
}
cout << endl;
return 0;
}
| 3,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long double nb;
cin >> nb;
if (nb <= 127)
cout << "byte";
else if (nb <= 32767)
cout << "short";
else if (nb <= 2147483647)
cout << "int";
else if (nb <= 9223372036854775807LL)
cout << "long";
else
cout << "BigInteger";
return 0;
}
| 1,300 | CPP |
import re
f = lambda t: re.sub(r'^0+(\d)', r'\1', t)
g = lambda k: n - p.index(s, k)
t = input()
n = len(t) - 1
p = [int(q) % 3 for q in t][::-1]
s = sum(p) % 3
if s == 0:
print(t)
exit()
u = v = ''
if s in p:
i = g(0)
u = f(t[:i] + t[i + 1:])
s = 3 - s
if p.count(s) > 1:
i = g(0)
j = g(n - i + 1)
v = f(t[:j] + t[j + 1:i] + t[i + 1:])
t = u if len(u) > len(v) else v
print(t if t else -1)
# Made By Mostafa_Khaled | 2,000 | PYTHON3 |
n, m, a = map(int, input().split())
b = m // a
g = n // a
if m % a != 0:
b += 1
if n % a != 0:
g += 1
print(g*b)
| 1,000 | PYTHON3 |
n = int(input())
l = list(input() for i in range(n))
for item in l:
k = len(item[1:-1])
if k>8:
print(item[0]+str(k)+item[-1])
else:
print(item)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
char S[100005], T[100005];
unsigned long long hs[100005], based[100005];
int dp[100005], sum[100005], sum1[100005];
int main() {
scanf("%s %s", S + 1, T);
if (strlen(T) > strlen(S + 1)) {
puts("0");
return 0;
}
unsigned long long ht = 0;
int n = strlen(S + 1);
int m = strlen(T);
for (int i = 0; i < m; i++) ht = ht * 233 + T[i];
hs[0] = 0;
based[0] = 1;
for (int i = 1; i <= n; i++) {
hs[i] = hs[i - 1] * 233 + S[i];
based[i] = based[i - 1] * 233;
}
int k = -1;
for (int i = m; i <= n; i++) {
unsigned long long tmp = hs[i] - hs[i - m] * based[m];
if (tmp == ht) k = i;
if (k - m >= 0) {
dp[i] = (dp[i] + k - m + 1 + sum1[k - m]) % 1000000007;
}
sum[i] = (sum[i - 1] + dp[i]) % 1000000007;
sum1[i] = (sum1[i - 1] + sum[i]) % 1000000007;
}
printf("%d\n", sum[n]);
return 0;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
const string nl = "\n";
long long n, k, ans, hld;
deque<long long> a;
void solve() {
cin >> n >> k;
a.resize(n);
for (auto& i : a) {
cin >> i;
}
ans = hld = 0;
sort(a.rbegin(), a.rend());
for (long long i = 0; i < n; ++i) {
++hld;
if (hld * a[i] >= k) {
++ans;
hld = 0;
}
}
cout << ans << nl;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
long long T;
cin >> T;
while (T--) {
solve();
}
}
| 1,400 | CPP |
for i in range(int(input())):
n,m=map(int,input().split())
if (n*m)<=(n+m):
print('YES')
else:
print('NO') | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, p;
cin >> s >> p;
int q = 0, m = s.size(), n = p.size(), pos = n, neg = 0, res = 0;
vector<int> v(255);
for (int i = 0; i < n; ++i) v[p[i]]++;
for (int i = 0; i < m; ++i) {
if (s[i] == '?') {
q++;
} else {
int x = --v[s[i]];
if (x >= 0) pos--;
if (x < 0) neg++;
}
if (i >= n) {
if (s[i - n] == '?') {
q--;
} else {
int x = ++v[s[i - n]];
if (x > 0) pos++;
if (x <= 0) neg--;
}
}
if (i >= n - 1) res += (neg == 0 && pos == q);
}
cout << res << endl;
}
| 1,500 | CPP |
n=(list(map(int, input().split())))
a=n[0] ; b=n[1]
l=0
while a>0 or b>0:
if a<=0 or b<=0 or (a==1 and b==1):
break
l += 1
if a==1 or b==1:
if a==1:
a+=1
b-=2
else:
a-=2
b+=1
elif a>=b:
a-=2
b+=1
else:
b-=2
a+=1
print(l) | 1,100 | PYTHON3 |
np = int(input().strip())
prob = 0
for i in range(np):
if(sum(map(int, input().strip().split(' '))) >=2):
prob = prob + 1
print(prob) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const double Eps = 1e-8;
struct point {
double x, y;
point() {}
point(double in_x, double in_y) { x = in_x, y = in_y; }
double module() { return sqrt(x * x + y * y); }
double operator*(point &B) { return x * B.x + y * B.y; }
point operator-(point &B) { return point(x - B.x, y - B.y); }
point rotate(double alp) {
return point(x * cos(alp) - y * sin(alp), x * sin(alp) + y * cos(alp));
}
};
point P, Q, S;
double Vp, Vs, r, R;
bool solve(double T) {
Q = P.rotate(T * Vp / R);
double S_len = S.module(), Q_len = R, len = 0;
double alp = acos(S * Q / (S_len * Q_len));
double bel = acos(r / S_len) + acos(r / Q_len);
if (alp < bel)
len = (S - Q).module();
else
len = sqrt(S * S - r * r) + sqrt(Q * Q - r * r) + (alp - bel) * r;
return len / Vs < T + Eps;
}
int main() {
scanf("%lf%lf%lf", &P.x, &P.y, &Vp);
scanf("%lf%lf%lf%lf", &S.x, &S.y, &Vs, &r);
R = P.module();
double l = 0, r = 100000;
while (r - l > Eps) {
double m = (l + r) / 2;
if (solve(m))
r = m;
else
l = m;
}
printf("%.8lf\n", l);
return 0;
}
| 2,400 | CPP |
def solve():
n1, m, a, d = list(map(int, input().split()))
t = list(map(int, input().split()))
from bisect import insort
from math import floor
insort(t, a * n1)
pred = 0
k = 0
kpred = 0
n = 0
step = d // a + 1
sol = 0
fl = 0
for i in t:
if (i > pred):
if fl == 0:
n = (i - pred + (pred % a)) // a
if n != 0:
k += (n // step) * step - step * (n % step == 0) + 1
if k > n1:
k = n1
fl = 1
# print(k)
if (k * a + d >= i) and (n != 0):
pred = k * a + d
else:
pred = i + d
k = floor(pred // a)
sol += 1
# if n==0:
k = min(floor(pred // a), n1)
sol += n // step + (n % step != 0)
else:
sol += 1
pred = i + d
if i == a * n1:
fl = 1
# print(i,pred,sol,n,step,k, fl)
print(sol)
solve() | 2,200 | PYTHON3 |
n = int(input())
a = [int(i) for i in input().split()]
top = max(a) + 1
scores = [0]*top
for i in a:
scores[i] += i
odd = scores[0]
i = even = total = 0
for i in range(1, top):
if even*(i%2) + odd*(not i%2) + scores[i] > odd*(i%2) + even*(not i%2):
even += scores[i]*(i%2)
odd += scores[i]*(not i%2)
else:
total += odd*(i%2) + even*(not i%2)
even = odd = 0
print(total + odd*(not i%2) + even*(i%2)) | 1,500 | PYTHON3 |
# -*- coding: utf-8 -*-
"""
Created on Mon Jun 8 10:55:25 2020
@author: Nada Adel
"""
import os
import sys
from atexit import register
from io import BytesIO
line1 = input()
line1 = line1.split()
n = int(line1[0])
f = int(line1[1])
clients=[]
products=[]
sell=[]
diff={}
min1=0
gain = 0
for i in range(n):
line2=input()
line2=line2.split()
clients.append(int(line2[1]))
products.append(int(line2[0]))
gain = min(clients[i],products[i]*2) - min(clients[i],products[i])
diff[i] = gain
sort_diff = sorted(diff.items(), key=lambda x: x[1], reverse=True)
sum1=0
for key,value in sort_diff:
if f>0:
sum1+=min(clients[key],2*products[key])
f-=1
else:
sum1+=min(clients[key],products[key])
print(sum1)
| 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
vector<int> wanted[maxn], dic;
int a[maxn], b[maxn];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++) {
scanf("%d", b + i);
wanted[a[i]].push_back(b[i]);
}
long long ans = 0;
int need = 0;
for (int i = 1; i <= k; i++) {
sort(wanted[i].begin(), wanted[i].end());
if (wanted[i].size() == 0) need++;
for (int j = 0; j < (int)wanted[i].size() - 1; j++)
dic.push_back(wanted[i][j]);
}
sort(dic.begin(), dic.end());
for (int i = 0; i < need; i++) ans += dic[i];
printf("%lld\n", ans);
return 0;
}
| 900 | CPP |
h1, m1 = (int(i) for i in input().split(':'))
h2, m2 = (int(i) for i in input().split(':'))
time = (h2 - h1) * 60 - m1 + m2
m1 += time // 2
h1 += m1 // 60
m1 = m1 % 60
print(f'{h1:02}:{m1:02}')
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long a[51], b[51];
int main() {
long long n, k;
a[1] = 1;
b[1] = 2;
for (long long i = 2; i <= 50; i++) {
a[i] = a[i - 1] * 2;
b[i] = b[i - 1] * 2;
}
cin >> n >> k;
for (long long i = 1; i <= n; i++) {
if ((k - a[i]) % b[i] == 0) {
cout << i;
break;
}
}
}
| 1,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
int arr[2000], cap[2000];
int main() {
int a, b, c, i, j, k, n, m;
while (scanf("%d", &n) != EOF) {
for (i = 0; i < n; i++) scanf("%d", &arr[i]);
sort(arr, arr + n);
for (i = 0; i < n; i++) cap[i] = 0;
m = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (cap[j] <= arr[i]) {
cap[j]++;
break;
}
}
if (j == m) {
cap[m] = 1;
m++;
}
}
printf("%d\n", m);
}
return 0;
}
| 1,400 | CPP |
s=input()
z=s[::-1]
c=0
for i in range(len(s)):
if s[i]!=z[i]:
c+=1
c=c//2
if c==1 or (c==0 and len(s)%2==1):
print("YES")
else :
print("NO")
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long ans;
long long a[] = {0, 0, 0, 0, 2, 4, 0, 0, 4, 8, 10, 0, 4,
8, 12, 14, 2, 8, 12, 16, 20, 4, 10, 14, 20, 24};
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
cerr << "HELLO WORLD\n";
cin >> n >> m;
if (n < 4 || m < 4) {
if (n < 4 && m < 4) return cout << a[(n - 1) * 5 + m] << '\n', false;
if (m < 4) swap(n, m);
if (n == 1)
return cout << m - (m % 6) + (max(0ll, (m % 6) - 3ll)) * 2ll << '\n',
false;
if (n % 2 == 0) {
if (m % 4 < 3 || !(n % 4) || m > 7)
return cout << (n * m) - ((n & 1) & (m & 1)) << '\n', false;
return cout << (n * m) - 2 << '\n', false;
}
return cout << (n * m) - ((n & 1) & (m & 1)) << '\n', false;
} else
ans = (long long)n * (long long)m;
return cout << ans - ((n & 1) & (m & 1)) << '\n', false;
}
| 2,200 | CPP |
'''
##======================================================================================================================================##
## _____ _ _ _ _____ _ _ _ _ _____ _____ ____ ___ ____ ___ ##
## | / \ | \ / | | | | |\ | | | | | | | | \ | | | ##
## |_____ / \ | \/ | |_____ | | | \ | | __ --- |_____ |____| | | | |___ |___| ##
## | / \ | | | | | | \ | | | | | | | | | | \ ##
## _____| / \ | | _____| \ __ / | \| |_____| _____| | | |___/ |____ | \ ##
##======================================================================================================================================##
------------------------------Samsung_Spider------------------------------
'''
rx, ry = map(int, input().split())
x, y = map(int, input().split())
print(min(abs(x - rx), abs(y - ry)) + abs(abs(x - rx) - abs(y - ry))) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> w, cnt;
vector<vector<pair<int, int>>> g;
long long getdiff(int i) {
return w[i] * 1ll * cnt[i] - (w[i] / 2) * 1ll * cnt[i];
}
void dfs(int v, int p = -1) {
if (g[v].size() == 1 && p != -1) cnt[p] = 1;
for (auto it : g[v]) {
if (it.second == p) continue;
dfs(it.first, it.second);
if (p != -1) cnt[p] += cnt[it.second];
}
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
long long s;
cin >> n >> s;
w = cnt = vector<int>(n - 1);
g = vector<vector<pair<int, int>>>(n);
for (int i = 0; i < n - 1; ++i) {
int x, y;
cin >> x >> y >> w[i];
--x, --y;
g[x].push_back({y, i});
g[y].push_back({x, i});
}
dfs(0);
set<pair<long long, int>> st;
long long cur = 0;
for (int i = 0; i < n - 1; ++i) {
st.insert({getdiff(i), i});
cur += w[i] * 1ll * cnt[i];
}
int ans = 0;
while (cur > s) {
int id = st.rbegin()->second;
st.erase(prev(st.end()));
cur -= getdiff(id);
w[id] /= 2;
st.insert({getdiff(id), id});
++ans;
}
cout << ans << endl;
}
return 0;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
for (int x = min(a, b); x >= 1; x--) {
if (a / x + b / x >= n) {
cout << x << endl;
return 0;
}
}
return 0;
}
| 1,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
void nos() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int n, m;
vector<vector<char> > mat;
void read() {
cin >> n >> m;
mat.clear();
mat.resize(n + 1);
int i, j;
mat[0].resize(m + 1);
for (i = 1; i <= n; i++) {
mat[i].resize(m + 1);
for (j = 1; j <= m; j++) cin >> mat[i][j];
}
}
void solve() {
int i, j;
vector<int> fools(m + 1);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
if (mat[i - 1][j] == 'X' and mat[i][j - 1] == 'X') fools[j]++;
vector<int> sp(m + 1);
for (j = 1; j <= m; j++) sp[j] = sp[j - 1] + fools[j];
int q;
cin >> q;
while (q--) {
int x, y;
cin >> x >> y;
int foolcnt = sp[y] - sp[x];
cout << (foolcnt ? "NO" : "YES") << '\n';
}
}
void restart() {}
int32_t main() {
nos();
read();
solve();
restart();
return 0;
}
| 1,700 | CPP |
a = input()
b = input()
c = False
if (a[0] in b or a[1] in b):
c = True
if (c):
print("YES")
else:
print("NO") | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool prime(int n) {
if (n < 2) {
return false;
}
for (int i = 2; i <= (int)sqrt(n * 1.0); i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
int main() {
int n;
scanf("%d", &n);
int l = 1, r = n;
for (int i = 1; i <= (int)floor(sqrt(n * 1.0)); i++) {
if (n % i == 0 && prime(i) && prime(n / i)) {
if (n / i - i < r - l) {
l = i;
r = n / i;
}
}
}
printf("%d%d", l, r);
return 0;
}
| 0 | CPP |
s=input()
if s=='{}':
print(0)
else:
s=s[1:-1].split(', ')
l=set(s)
print(len(l))
| 800 | PYTHON3 |
#code
remix = input()
remix+="WUB"
i=0
l = []
while(i<len(remix)-2):
if(remix[i]=="W" and remix[i+1]=="U" and remix[i+2]=="B"):
i+=3
else:
j=i
temp = ""
while(remix[j]!="W" or remix[j+1]!="U" or remix[j+2]!="B"):
temp += remix[j]
j+=1
l.append(temp)
i = j
for i in range(len(l)):
print(l[i],end=" ") | 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, LOG = 19, inf = 1e9;
int m;
int phi(int n) {
int res = n;
for (int i = 2; i * i <= n; ++i)
if (n % i == 0) {
while (n % i == 0) {
n /= i;
}
res -= res / i;
}
if (n > 1) {
res -= res / n;
}
return res;
}
int add(int x, int y) { return x + y >= m ? x + y - m : x + y; }
int sub(int x, int y) { return x - y < 0 ? x - y + m : x - y; }
int mul(int x, int y) { return 1ll * x * y % m; }
int deg(int x, int y) {
int res = 1;
for (int z = x; y; y >>= 1, z = mul(z, z))
if (y & 1) res = mul(res, z);
return res;
}
int deg10[N], rev10[N];
int n;
vector<pair<int, int>> g[N];
int from[N], h[N];
int dist_down[N], dist_up[N];
pair<int, int> subtree[N];
vector<int> order;
void dfs_precalc(int v) {
subtree[v].first = (int)order.size();
order.emplace_back(v);
for (auto &e : g[v]) {
int u = e.first, w = e.second;
if (u != from[v]) {
from[u] = v;
h[u] = h[v] + 1;
dist_up[u] = add(dist_up[v], mul(w, deg10[h[u] - 1]));
dist_down[u] = add(mul(dist_down[v], 10), w);
dfs_precalc(u);
order.emplace_back(v);
}
}
subtree[v].second = (int)order.size() - 1;
}
int lenfor[N * 2];
pair<int, int> sp_lca[LOG][N * 2];
void build_lca() {
int k = (int)order.size();
for (int i = 2; i <= k; ++i) {
lenfor[i] = lenfor[i >> 1] + 1;
}
for (int i = 0; i < LOG; ++i) {
for (int j = 0; j < k; ++j) {
sp_lca[i][j] = make_pair(inf, inf);
}
}
for (int i = 0; i < LOG; ++i) {
for (int j = 0; j + (1 << i) - 1 < k; ++j) {
if (i == 0) {
sp_lca[i][j] = make_pair(h[order[j]], order[j]);
} else {
sp_lca[i][j] = min(sp_lca[i - 1][j], sp_lca[i - 1][j + (1 << (i - 1))]);
}
}
}
}
int get_lca(int v, int u) {
int L = subtree[v].first, R = subtree[u].first;
if (L > R) {
swap(L, R);
}
int len = lenfor[R - L + 1];
return min(sp_lca[len][L], sp_lca[len][R - (1 << len) + 1]).second;
}
int get_up(int v, int u) {
return mul(sub(dist_up[v], dist_up[u]), rev10[h[u]]);
}
int get_down(int v, int u) {
return sub(dist_down[u], mul(dist_down[v], deg10[h[u] - h[v]]));
}
int get_dist(int v, int u) {
int lca = get_lca(v, u);
if (v == lca) {
return get_down(v, u);
}
if (u == lca) {
return get_up(v, u);
}
return add(mul(get_up(v, lca), deg10[h[u] - h[lca]]), get_down(lca, u));
}
int get_len(int v, int u) {
int lca = get_lca(v, u);
return h[v] + h[u] - 2 * h[lca];
}
int sz[N];
bool used[N];
void dfs_size(int v, int p) {
sz[v] = 1;
for (auto &e : g[v]) {
int u = e.first, w = e.second;
if (!used[u] && u != p) {
dfs_size(u, v);
sz[v] += sz[u];
}
}
}
int dfs_centroid(int v, int p, int s) {
for (auto &e : g[v]) {
int u = e.first, w = e.second;
if (!used[u] && u != p && sz[u] * 2 > s) {
return dfs_centroid(u, v, s);
}
}
return v;
}
vector<int> control[N];
long long ans = 0;
long long get(vector<int> &a, vector<pair<int, int>> &b) {
unordered_map<int, int> cnt;
for (int i = 0; i < (int)b.size(); ++i) {
++cnt[mul(sub(0, b[i].first), rev10[b[i].second])];
}
long long res = 0;
for (int i = 0; i < (int)a.size(); ++i) {
--cnt[mul(sub(0, b[i].first), rev10[b[i].second])];
res += cnt[a[i]];
++cnt[mul(sub(0, b[i].first), rev10[b[i].second])];
}
return res;
}
int find_centroid(int v) {
dfs_size(v, 0);
int centroid = dfs_centroid(v, 0, sz[v]);
used[centroid] = true;
vector<int> global_a;
vector<pair<int, int>> global_b;
global_a.emplace_back(0);
global_b.emplace_back(0, 0);
control[centroid].emplace_back(centroid);
for (auto &e : g[centroid]) {
int u = e.first, w = e.second;
if (!used[u]) {
int nxt_centroid = find_centroid(u);
vector<int> curr_a;
vector<pair<int, int>> curr_b;
for (int &x : control[nxt_centroid]) {
curr_a.emplace_back(get_dist(x, centroid));
global_a.emplace_back(get_dist(x, centroid));
curr_b.emplace_back(get_dist(centroid, x), get_len(centroid, x));
global_b.emplace_back(get_dist(centroid, x), get_len(centroid, x));
control[centroid].emplace_back(x);
}
ans -= get(curr_a, curr_b);
}
}
ans += get(global_a, global_b);
return centroid;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
if (m == 1) {
cout << 1ll * n * n - n << "\n";
return 0;
}
deg10[0] = 1;
rev10[0] = 1;
rev10[1] = deg(10, phi(m) - 1);
for (int i = 1; i <= n; ++i) {
deg10[i] = mul(deg10[i - 1], 10);
if (i > 1) {
rev10[i] = mul(rev10[i - 1], rev10[1]);
}
}
for (int i = 1; i < n; ++i) {
int v, u, w;
cin >> v >> u >> w;
++v, ++u;
w %= m;
g[v].emplace_back(u, w);
g[u].emplace_back(v, w);
}
dfs_precalc(1);
build_lca();
find_centroid(1);
cout << ans << "\n";
return 0;
}
| 2,700 | CPP |
#include <bits/stdc++.h>
const long long int mo = 1e9 + 7;
const long long int INF = 1e9;
const long double pi = acos(-1);
const int mxn = 2e3 + 50;
const int cons = 1;
using namespace std;
int n, h;
int arr[mxn];
int dp[mxn][mxn];
long long int rec(int ind, int lcount) {
if (dp[ind][lcount] != -1) {
return dp[ind][lcount];
}
if (ind == n + 1) {
if (lcount == 0) {
return dp[ind][lcount] = 1;
} else {
return dp[ind][lcount] = 0;
}
}
long long int temp = arr[ind] + lcount;
if (temp > h || temp < h - 1) {
return dp[ind][lcount] = 0;
}
if (temp == h) {
return dp[ind][lcount] =
(lcount * rec(ind + 1, lcount - 1) + rec(ind + 1, lcount)) % mo;
}
if (temp == h - 1) {
return dp[ind][lcount] = (rec(ind + 1, lcount + 1) +
(lcount + 1) * rec(ind + 1, lcount)) %
mo;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int i;
memset(dp, -1, sizeof(dp));
cin >> n >> h;
for (i = 1; i <= n; i++) {
cin >> arr[i];
}
cout << rec(1, 0) << "\n";
return 0;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
double z;
cin >> x >> y >> z;
z = z / 100;
z = z * x;
x = ceil(z);
if ((x - y) < 0)
cout << 0 << endl;
else
cout << (x - y) << endl;
return 0;
}
| 900 | CPP |
t = int(input())
while t :
a1, b1 = input().split()
a2, b2 = input().split()
a1 = int(a1)
b1 = int(b1)
a2 = int(a2)
b2 = int(b2)
if (a1==a2 and b1+b2==a1) or (a1==b2 and a2+b1==a1) or (b1==a2 and a1+b2==a2) or (b1==b2 and a1+a2==b1) :
print('Yes')
else :
print('No')
t=t-1 | 900 | PYTHON3 |
t = int(input())
for i in range(t):
n = int(input())
p=0
for j in range(1 , ((n//2)+1)):
p = p+ 2**j
j=j+1
print(p) | 800 | PYTHON3 |
#include <bits/stdc++.h>
void err() { std::cout << std::endl; }
template <typename T, typename... Args>
void err(T a, Args... args) {
std::cout << a << ' ';
err(args...);
}
template <template <typename...> class T, typename t, typename... A>
void err(const T<t> &arg, const A &...args) {
for (auto &v : arg) std::cout << v << ' ';
err(args...);
}
using namespace std;
const long long mod = 1000000007;
const int INF = 0x3f3f3f3f;
const double PI = acos(-1.0);
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
const int N = 1e5 + 5;
long long C[3][2];
void solve() {
long long x, y;
cin >> x >> y;
cin >> C[0][0] >> C[2][0] >> C[1][1] >> C[0][1] >> C[2][1] >> C[1][0];
long long ans = 3e18;
int d1 = 0, d2 = 0;
if (x < 0) d1 = 1;
if (x > y) d2 = 1;
ans = min(ans, C[0][d1] * abs(x) + abs(x - y) * C[2][d2]);
d1 = 0, d2 = 0;
if (y < 0) d1 = 1;
if (y > x) d2 = 1;
ans = min(ans, C[0][d1] * abs(y) + abs(x - y) * C[1][d2]);
d1 = 0, d2 = 0;
if (x < 0) d1 = 1;
if (y < 0) d2 = 1;
ans = min(ans, C[1][d1] * abs(x) + abs(y) * C[2][d2]);
cout << ans << endl;
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::cout.tie(0);
int T;
cin >> T;
while (T--) {
solve();
}
return 0;
}
| 1,900 | CPP |
s = input()
a =set()
for i in range(len(s)+1):
for x in 'qwertyuiop[lkjhgfdsazxcvbnm':
y = s[:i]+x+s[i:]
a.add(y)
print(len(a)-len(s)-1) | 900 | PYTHON3 |
a=int(input())
p=[]
import string
st=string.ascii_uppercase[:]
for i in range(a):
p.append(input())
for cell in p:
if "R" in cell and cell[1].isdigit() and "C" in cell:
c=cell.index("C")
row=cell[1:c]
column=cell[c+1:]
fin=""
c=int(column)
while c>0:
c,rem = divmod(c-1,26)
fin = st[rem] + fin
print(fin+row)
else:
for char in cell:
if char.isdigit():
r=cell.index(char)
row=cell[r:]
column=cell[0:r]
exp=len(column)-1
count=0
for cno in column:
p=st.index(cno)
count+=(p+1)*(26**exp)
exp-=1
print("R{}C{}".format(row,count))
break
| 1,600 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n;
vector<long long> res;
void lucky(long long num) {
if (num > 1e10) {
return;
}
int count4 = 0, count7 = 0;
bool isSuper;
string s = to_string(num);
for (unsigned int i = 0; i < s.size(); i++) {
if (s[i] == '4')
count4++;
else
count7++;
}
(count4 == count7) ? isSuper = true : isSuper = false;
if (num > 0 && isSuper) res.push_back(num);
lucky(num * 10 + 4);
lucky(num * 10 + 7);
}
int main() {
ios_base::sync_with_stdio();
cin.tie(0);
cout.tie(0);
cin >> n;
lucky(0);
sort(res.begin(), res.end());
vector<long long>::iterator it = lower_bound(res.begin(), res.end(), n);
long long ans = it - res.begin();
cout << res[ans] << endl;
return 0;
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void CIN(T &a) {
cin >> a;
}
template <class T>
void CIN(T &a, T &b) {
cin >> a >> b;
}
template <class T>
void CIN(T &a, T &b, T &c) {
cin >> a >> b >> c;
}
template <class T>
void CIN(T &a, T &b, T &c, T &d) {
cin >> a >> b >> c >> d;
}
template <class T>
void PI(T a) {
cout << a << endl;
}
template <class T>
void PI(T a, T b) {
cout << a << " " << b << endl;
}
template <class T>
void PIS(T a) {
cout << a << " ";
}
template <class T>
T abs(T a) {
return a < 0 ? -a : a;
}
const int N = 10000010;
long long n, x, y, dx, dy, t;
int b[6][6] = {{2, 1, 1, 0, 1, 0}, {1, 2, 0, 1, 1, 0}, {1, 1, 1, 0, 1, 0},
{1, 1, 0, 1, 1, 0}, {0, 0, 0, 0, 1, 1}, {0, 0, 0, 0, 0, 1}};
struct matrix {
long long a[6][6];
matrix() { memset(a, 0, sizeof(a)); }
void init() {
int i, j;
for (i = 0; i < (int)(6); ++i)
for (j = 0; j < (int)(6); ++j) a[i][j] = b[i][j];
}
void unit() {
memset(a, 0, sizeof(a));
int i;
for (i = 0; i < (int)(6); ++i) a[i][i] = 1;
}
matrix operator*(const matrix &b) const {
matrix ret;
int i, j, k;
for (i = 0; i < (int)(6); ++i)
for (j = 0; j < (int)(6); ++j)
for (k = 0; k < (int)(6); ++k) {
ret.a[i][j] += a[i][k] * b.a[k][j];
ret.a[i][j] %= n;
}
return ret;
}
matrix Pow(long long k) {
matrix ret, p = *this;
ret.unit();
while (k) {
if (k & 1) ret = ret * p;
k >>= 1;
p = p * p;
}
return ret;
}
} mx;
int main() {
CIN(n);
CIN(x, y, dx, dy);
CIN(t);
mx.init();
mx = mx.Pow(t);
long long ex = mx.a[0][0] * x + mx.a[0][1] * y + mx.a[0][2] * dx +
mx.a[0][3] * dy + mx.a[0][5];
long long ey = mx.a[1][0] * x + mx.a[1][1] * y + mx.a[1][2] * dx +
mx.a[1][3] * dy + mx.a[1][5];
ex %= n;
if (ex <= 0) ex += n;
ey %= n;
if (ey <= 0) ey += n;
PI(ex, ey);
return 0;
}
| 2,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, i;
cin >> n >> m;
for (i = 1; i < 2 * n + 1; i++) {
if (2 * n + i < m + 1) cout << 2 * n + i << " ";
if (i < m + 1) cout << i << " ";
}
}
| 1,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y) {
if (y == 0)
return 1;
else if (y % 2 == 0)
return power(x, y / 2) * power(x, y / 2);
else
return x * power(x, y / 2) * power(x, y / 2);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n;
cin >> n;
string s;
cin >> s;
long long int c = 0;
if (n == 1) {
cout << 0 << endl << s << endl;
return 0;
}
for (int i = 1; i <= n - 2; i++) {
if (s[i] == s[i - 1]) {
if (s[i + 1] == 'R' && s[i - 1] == 'B' ||
s[i + 1] == 'B' && s[i - 1] == 'R')
s[i] = 'G';
else if (s[i + 1] == 'B' && s[i - 1] == 'G' ||
s[i + 1] == 'G' && s[i - 1] == 'B')
s[i] = 'R';
else if (s[i + 1] == 'R' && s[i - 1] == 'G' ||
s[i + 1] == 'G' && s[i - 1] == 'R')
s[i] = 'B';
else if (s[i + 1] == 'B' && s[i - 1] == 'B')
s[i] = 'R';
else if (s[i + 1] == 'R' && s[i - 1] == 'R')
s[i] = 'G';
else if (s[i + 1] == 'G' && s[i - 1] == 'G')
s[i] = 'B';
c++;
}
}
if (s[n - 1] == s[n - 2]) {
if (s[n - 2] == 'R')
s[n - 1] = 'G';
else if (s[n - 2] == 'B')
s[n - 1] = 'R';
else if (s[n - 2] == 'G')
s[n - 1] = 'B';
c++;
}
cout << c << endl;
cout << s << endl;
return 0;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n, m;
double a[15][15];
int main() {
int i, j;
scanf("%d%d", &n, &m);
a[1][1] = m;
int cnt = 0;
for (i = 1; i <= n; i++) {
for (j = 1; j <= i; j++) {
if (a[i][j] > 1) {
a[i + 1][j] += (a[i][j] - 1) / 2;
a[i + 1][j + 1] += (a[i][j] - 1) / 2;
cnt++;
} else if (fabs(a[i][j] - 1) < 1e-8)
cnt++;
}
}
printf("%d\n", cnt);
return 0;
}
| 1,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
int getint() {
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
;
int tmp = 0;
for (; ch >= '0' && ch <= '9'; ch = getchar()) tmp = tmp * 10 + ch - 48;
return tmp;
}
const int maxn = 1000000 + 10;
int N, M, L[maxn], T[maxn], P[maxn], w[maxn];
char s[maxn], ss[maxn];
void permutate(int *A, int *B) {
static int C[maxn];
for (int i = (0), _i = (N - 1); i <= _i; i++) C[i] = B[A[i]];
for (int i = (0), _i = (N - 1); i <= _i; i++) A[i] = C[i];
}
void mul(int *T, int x) {
static int ret[maxn];
for (int i = (0), _i = (N - 1); i <= _i; i++) ret[i] = i;
for (; x; x >>= 1) {
if (x & 1) permutate(ret, T);
permutate(T, T);
}
for (int i = (0), _i = (N - 1); i <= _i; i++) T[i] = ret[i];
}
void printt(int *T) {
for (int i = (0), _i = (N - 1); i <= _i; i++) printf("%d ", T[i]);
printf("\n");
}
int main() {
for (; scanf("%s", s) != EOF;) {
N = strlen(s);
scanf("%d", &M);
L[0] = N - 1;
for (int i = 1; i < N; i++) L[i] = i - 1;
while (M--) {
int len = getint(), modd = getint();
for (int i = 0; i < modd; i++) w[i] = 0;
for (int i = 0; i < len; i++) w[i % modd]++;
for (int i = 1; i < modd; i++) w[i] += w[i - 1];
for (int i = len - 1; i >= 0; i--) P[i] = --w[i % modd];
for (int i = len; i < N; i++) P[i] = i;
for (int i = (0), _i = (N - 1); i <= _i; i++) T[i] = L[i];
permutate(T, P);
mul(T, N - len);
permutate(P, T);
for (int i = (0), _i = (N - 1); i <= _i; i++) P[i] = (P[i] + N - len) % N;
for (int i = (0), _i = (N - 1); i <= _i; i++) T[P[i]] = i;
for (int i = (0), _i = (N - 1); i <= _i; i++) ss[i] = s[T[i]];
for (int i = (0), _i = (N - 1); i <= _i; i++) s[i] = ss[i];
printf("%s\n", s);
}
}
return 0;
}
| 2,600 | CPP |
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import random
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
import threading
from collections import defaultdict
threading.stack_size(10**8)
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
sys.setrecursionlimit(300000)
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")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default=2**51, func=lambda a, b: a & b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: math.gcd(a , b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] < key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def binary(x, length):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def countGreater(arr, n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
n,m,i,j,a,b=map(int,input().split())
def check(x1,y1):
if abs(y1 - j) % b != 0:
return -1
if abs(x1 - i) % a != 0:
return -1
z=(y1-j)//b
z1=(x1-i)//a
ans=10**7
for p in range(2*max(m,n)+1):
q=p-(x1-i)//a
if q<0:
continue
if (z+p+q)%2==0:
p1=(z+p+q)//2
if p1<0:
continue
if p+q-p1>=0:
q1=(p+q-z)//2
t=0
if j+b*(p1-q1)==y1:
if p>q:
if 1<=i+min(p,1)*a<=n:
t+=1
elif q>p:
if 1<=i-min(q,1)*a<=n:
t+=1
else:
if 1<=i+min(p,1)*a<=n or 1<=i-min(q,1)*a<=n:
t+=1
if p1>q1:
if 1<=j+min(p1,1)*b<=m:
t+=1
elif q1>p1:
if 1<=j-min(q1,1)*b<=m:
t+=1
else:
if 1 <= j + min(p1, 1) * b <= m or 1 <= j - min(q1, 1) * b <= m:
t += 1
if t>=2:
ans=min(ans,p+q)
if ans==10**7:
ans=-1
return ans
an=10**7
aw=check(n,1)
if aw!=-1:
an=min(an,aw)
aw=check(1,m)
if aw!=-1:
an=min(an,aw)
aw=check(1,1)
if aw!=-1:
an=min(an,aw)
aw=check(n,m)
if aw!=-1:
an=min(an,aw)
if an==10**7:
print("Poor Inna and pony!")
else:
print(an)
| 2,000 | PYTHON3 |
from collections import Counter
s=input()
r1=Counter(s)
if(len(r1) % 2==0):
print("CHAT WITH HER!")
else:
print("IGNORE HIM!") | 800 | PYTHON3 |
s=input()
S=s[0].upper()
print (S+s[1:])
| 800 | PYTHON3 |
for _ in range(int(input())):
A, B = map(int, input().split())
if B == 1:
print('NO')
else:
print('YES')
print(A, A*B, A*(B+1)) | 1,000 | PYTHON3 |
def number(a, b, c):
counter = 0
a, b, c = a - 1, b - 2, c - 4
while a >= 0 and b >= 0 and c >= 0:
a -= 1
b -= 2
c -= 4
counter += 1
return counter*7
a, b, c = int(input()), int(input()), int(input())
print(number(a, b, c)) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 10;
const int mod = 998244353;
int gi() {
int x = 0, o = 1;
char ch = getchar();
while (!isdigit(ch) && ch != '-') ch = getchar();
if (ch == '-') o = -1, ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x * o;
}
int qpow(int a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret = 1ll * ret * a % mod;
a = 1ll * a * a % mod, b >>= 1;
}
return ret;
}
int fac[N], ifac[N], mx, k, a[N], b[N], c[N];
int C(int n, int m) {
if (m < 0 || n < m) return 0;
return 1ll * fac[n] * ifac[m] % mod * ifac[n - m] % mod;
}
int main() {
fac[0] = 1;
for (int i = 1; i < N; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
ifac[N - 1] = qpow(fac[N - 1], mod - 2);
for (int i = N - 1; i; i--) ifac[i - 1] = 1ll * ifac[i] * i % mod;
cin >> k;
for (int i = 1; i <= k; i++) cin >> a[i], mx = max(mx, a[i]), ++b[a[i] + 1];
for (int i = 1; i <= k; i++)
for (int j = a[i] + 1; j <= mx; j += k) ++c[j];
int ans = 1, emp = 0, free = k;
for (int i = 1; i <= mx; i++) {
++emp;
free -= b[i];
if (emp < c[i]) break;
emp -= c[i];
ans = (ans + C(emp + k - 1, k - 1)) % mod;
if (emp >= free) ans = (ans - C(emp - free + k - 1, k - 1) + mod) % mod;
}
cout << ans;
return 0;
}
| 3,300 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops")
#pragma GCC target("avx,avx2,fma")
using namespace std;
const long long sz = 1e5 + 10;
vector<long long> g[sz];
long long now = 0, mn = 0;
bitset<10 * sz> tot;
void dfs(long long u, long long p, long long xr, long long lv) {
bool leaf = 0;
for (long long v : g[u]) {
if (v == p) continue;
if (g[v].size() != 1) {
now++;
tot[now] = 1;
dfs(v, u, xr ^ 1, lv + 1);
} else {
if ((xr ^ 1) != 0)
mn = max(mn, 3LL);
else
mn = max(mn, 1LL);
leaf = 1;
}
}
if (leaf && lv > 1) {
now++;
tot[now] = 1;
}
}
int main() {
long long n;
cin >> n;
for (long long i = 1; i < n; i++) {
long long u, v;
scanf("%lld", &u), scanf("%lld", &v);
g[u].push_back(v);
g[v].push_back(u);
}
long long leaf;
for (long long i = 1; i <= n; i++) {
if (g[i].size() == 1) {
leaf = i;
break;
}
}
dfs(leaf, -1, 0, 0);
long long mx = tot.count();
cout << mn << " " << mx << endl;
return 0;
}
| 1,800 | CPP |
def iinput():
return [int(i) for i in input().split()]
t = int(input())
for _ in range(t):
n = int(input())
candies = iinput()
turns = 0
cur_lim = 0
a = 0
a_flag = True
b = 0
while True:
cur = 0
if a_flag:
for i in range(len(candies)):
cur += candies[i]
a += candies[i]
if cur > cur_lim:
cur_lim = cur
candies = candies[i+1:]
break
else:
candies = []
else:
for i in range(len(candies) - 1, -1, -1):
cur += candies[i]
b += candies[i]
if cur > cur_lim:
cur_lim = cur
candies = candies[:i]
break
else:
candies = []
a_flag = not a_flag
turns += 1
if not candies:
break
print(turns, a, b)
| 1,300 | PYTHON3 |
n, k = map(int, input().split())
A = list(map(int, input().split()))
mods = [A[i]%k for i in range(n)]
alright = True
for i in range(1, n):
if mods[i] != mods[0]:
alright = False
break
if not alright:
print(-1)
else:
s = 0
minA = min(A)
for i in range(n):
s += (A[i] - minA) // k
print(s) | 900 | PYTHON3 |
from sys import stdin, stdout
import math,sys
from itertools import permutations, combinations
from collections import defaultdict,deque,OrderedDict
from os import path
import bisect as bi
import heapq
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()))
def main():
try:
a,b=In()
z=min(a,b)
a=a-z
b=b-z
t=0
if a!=0:
t=a//2
elif b!=0:
t=b//2
print(z,t)
except:
pass
M = 998244353
P = 1000000007
if __name__ == '__main__':
#for _ in range(I()):main()
for _ in range(1):main() | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 19;
int A[N], n, x;
int main() {
scanf("%d", &n);
for (int i = 1; i < n + 1; i++) scanf("%d", &A[i]), x += !A[i];
if (!A[n] && (x != 2 || A[n - 1])) {
puts("YES");
for (int i = 1; i < n - 1; i++) printf("(%d->", A[i]);
printf("%d", A[n - 1]);
for (int i = 1; i < n - 1; i++) printf(")");
if (n != 1) printf("->0");
} else
puts("NO");
}
| 2,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long a;
cin >> a;
long long ans = 0;
while (a > 0) {
ans += a % 2;
a /= 2;
}
ans = pow(2, ans);
cout << ans << "\n";
}
return 0;
}
| 1,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 20;
const int M = 1e6 + 20;
int a[N], dp1[N], dp2[N], dp3[N], p[N], b[N];
int main() {
cout.tie(0);
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
vector<pair<int, int> > v;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
v.push_back({a[i], i});
}
sort(v.begin(), v.end());
int k = 0;
b[k] = 0;
for (int i = 0; i < n; i++) {
if (i && v[i].first != v[i - 1].first) {
k++;
b[k] = 0;
}
a[v[i].second] = k;
b[k]++;
}
int ans = 0;
for (int i = 0; i < n; i++) {
p[i] = -1;
dp1[i] = dp2[i] = dp3[i] = 0;
}
for (int i = 0; i < n; i++) {
if (b[a[i]]) {
b[a[i]]--;
}
if (p[a[i] - 1] != -1 && a[i]) {
if (p[a[i]] == -1) {
dp2[i] = max(dp2[i], dp1[p[a[i] - 1]] + 1);
if (!b[a[i] - 1]) {
dp2[i] = max(dp2[i], dp2[p[a[i] - 1]] + 1);
}
}
if (!b[a[i] - 1]) {
dp3[i] = max(dp3[i], dp2[p[a[i] - 1]] + 1);
}
dp3[i] = max(dp3[i], dp1[p[a[i] - 1]] + 1);
}
if (p[a[i]] != -1) {
dp1[i] = dp1[p[a[i]]] + 1;
dp2[i] = max(dp2[i], dp2[p[a[i]]] + 1);
dp3[i] = max(dp3[i], dp3[p[a[i]]] + 1);
} else {
dp1[i] = 1;
}
dp2[i] = max(dp2[i], dp1[i]);
dp3[i] = max(dp2[i], dp3[i]);
p[a[i]] = i;
ans = max(ans, dp3[i]);
}
cout << n - ans << "\n";
}
return 0;
}
| 2,400 | CPP |
x=int(input())
for z in range(x):
n=int(input())
if n==1:
print(8)
else:
c=(n-1)//4+1
s='8'*c
s1='9'*(n-c)
print(s1+s) | 1,000 | PYTHON3 |
mod = 1000000007
ii = lambda : int(input())
si = lambda : input()
dgl = lambda : list(map(int, input()))
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
ls = lambda : list(input())
import sys
sys.setrecursionlimit(10000000)
s1=si()
s2=si()
l=[]
dst=0
for i in s1:
dst=dst+1 if i=='+' else dst-1
def recur(ind,sz,val):
if sz==0:
l.append(val)
return
elif s2[ind]=='+':
recur(ind+1,sz-1,val+1)
elif s2[ind]=='-':
recur(ind+1,sz-1,val-1)
else:
recur(ind+1,sz-1,val+1)
recur(ind+1,sz-1,val-1)
recur(0,len(s2),0)
c=0
for i in l:
if i==dst:
c+=1
print("%.12f"%(c/len(l))) | 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline bool iseq(double x, double y) {
if (fabs(x - y) < 1e-8) return true;
return false;
}
template <typename T>
inline T hpt(T x1, T y1, T x2, T y2) {
return hypot(x1 - x2, y1 - y2);
}
template <typename T>
inline T gcd(T a, T b) {
if (!b)
return a;
else
return gcd(b, a % b);
}
template <typename T>
inline void extended_euclid(T a, T b, T &x, T &y) {
if (a % b == 0)
x = 0, y = 1;
else {
extended_euclid(b, a % b, x, y);
T temp = x;
x = y;
y = -y * (a / b) + temp;
}
}
template <typename T>
inline T bigmod(T b, T p, T m) {
if (!p)
return 1;
else if (!(p % 2)) {
T x = bigmod(b, p / 2, m);
return (x * x) % m;
} else
return ((b % m) * bigmod(b, p - 1, m)) % m;
}
int prime[5 / 32 + 1];
void setbit(int i) {
int p = i >> 5, q = i & 31;
prime[p] |= (1 << q);
}
bool checkbit(int i) {
int p = i >> 5, q = i & 31;
return prime[p] & (1 << q) ? true : false;
}
void buildprime(int n) {
int i, j, k = sqrt(double(n));
prime[0] = 3;
for (i = 4; i < n; i += 2) setbit(i);
for (i = 3; i <= k; i += 2) {
if (!checkbit(i)) {
int ii = i + i;
for (j = i * i; j < n; j += ii) setbit(j);
}
}
}
int sum, r, n, N, R, C;
int main() {
int i, j, k;
while (scanf("%d", &n) == 1) {
int tot = 0;
for ((i) = (0); (i) < (n); (i)++) {
if (i % 2)
tot += n / 2;
else
tot += (n + 1) / 2;
}
cout << tot << endl;
for ((i) = (0); (i) < (n); (i)++) {
for ((j) = (0); (j) < (n); (j)++) {
if (i % 2) {
if (j % 2)
printf("C");
else
printf(".");
} else {
if (j % 2)
printf(".");
else
printf("C");
}
}
printf("\n");
}
}
return 0;
}
| 800 | CPP |
import sys
x,y,z=map(int,input().split())
if y < x or z < x:
print("NO")
else : print("YES")
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
long long n, ans = 1e9;
long long a[N];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (long long l = n / 2, r = n; l >= 1; l--, r--)
ans = min(ans, a[r] - a[l]);
cout << ans;
return 0;
}
| 2,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, res = 0;
cin >> n;
for (int i(1); i <= n; i++) {
res += (i + 1) / 2;
}
cout << res;
}
| 1,300 | CPP |
'''
import sys
sys.stdin=open('input.txt')
'''
N=int(input())
S=list(map(int, input().split()))
dp=[0,0]
x=0
while x<len(S):
if S[x]%2==0:
dp[1]+=1
else:
dp[0]+=1
x+=1
print (min(dp))
| 900 | PYTHON3 |
n = int(input())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
c = [0]*n
d = [0]*(n+1)
for i in range(n):
c[i] = a[i] - b[i]
d[i+1] = d[i]+i+1
c = list(sorted(c))
combinations = [0]*n
right = n-1
cnt = 0
deff = 0
for i in range(n):
if c[i] > 0:
deff = n - i - 1
break
while c[right] > -c[i]:
right -= 1
cnt += 1
combinations[i] = cnt
res = 0
j = 0
res = sum(combinations)
res += d[deff]
print(res) | 1,400 | PYTHON3 |
def solve():
n=int(input())
arr=[int(v) for v in input().split()]
dp=[[0]*(n+10) for _ in range(2)]
for i in reversed(range(n-1)):
dp[1][i] = dp[1][i+1] + abs(arr[i+1]-arr[i])
if i<n-2:
dp[0][i] = dp[0][i+1] + abs(arr[i+1]-arr[i])
dp[0][i] = min(dp[0][i], dp[1][i+2]+abs(arr[i+2]-arr[i]))
#print(ans, mxabs)
#print(dp)
print(min(dp[0][0], dp[1][1]))
t = int(input())
for _ in range(t):
solve()
| 1,400 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using pi = pair<int, int>;
const int dr[] = {0, -1, -1, -1, 0, 1, 1, 1, 0};
const int dc[] = {1, 1, 0, -1, -1, -1, 0, 1, 0};
struct info {
int par, size;
bool outer;
vector<int> mem;
};
int n, m, t;
vector<pi> grid;
map<pi, int> id;
vector<array<int, 8>> g;
vector<bool> inq, gone;
vector<int> check, ans;
vector<info> dsu;
set<int> candidates;
bool connected() {
vector<bool> vis(n);
queue<int> q;
vis[0] = true;
q.push(0);
int cnt = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int j = 0; j < 8; j++) {
int v = g[u][j];
if (v != -1 && v < n && !vis[v]) {
vis[v] = true;
q.push(v);
cnt++;
}
}
}
return cnt == n;
}
int find(int i) { return dsu[i].par == i ? i : dsu[i].par = find(dsu[i].par); }
void unite(int u, int v) {
int a = find(u), b = find(v);
if (a == b) return;
if (dsu[a].size > dsu[b].size) {
swap(u, v);
swap(a, b);
}
dsu[a].par = b;
dsu[b].size += dsu[a].size;
dsu[b].outer |= dsu[a].outer;
for (int i : dsu[a].mem) {
for (int j = 0; j < 8; j++) {
int k = g[i][j];
if (k != -1 && k < n && !gone[k] && !inq[k]) {
check.push_back(k);
inq[k] = true;
}
}
dsu[b].mem.push_back(i);
}
dsu[a].mem.clear();
}
bool is_candidate(int i) {
bool edge = false;
vector<int> comp(8);
set<int> regions;
for (int j = 0; j < 8; j++) {
comp[j] = find(g[i][j]);
}
for (int j = 0; j < 8; j += 2) {
edge |= dsu[comp[j]].outer;
}
if (!edge) {
return false;
}
for (int j = 0; j < 8; j++) {
int a = comp[(j + 7) % 8], b = comp[j], c = comp[(j + 1) % 8];
if (a != b && (j % 2 == 0 || b == c)) {
if (regions.count(comp[j])) {
return false;
}
regions.insert(comp[j]);
}
}
return true;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> t;
grid.resize(n);
inq.resize(n);
gone.resize(n);
ans.resize(n);
for (int i = 0; i < n; i++) {
cin >> grid[i].first >> grid[i].second;
id[grid[i]] = i;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < 8; j++) {
pi cell(grid[i].first + dr[j], grid[i].second + dc[j]);
if (!id.count(cell)) {
grid.push_back(cell);
id[cell] = n + m++;
}
}
}
g.resize(n + m);
for (int i = 0; i < n + m; i++) {
for (int j = 0; j < 8; j++) {
pi cell(grid[i].first + dr[j], grid[i].second + dc[j]);
g[i][j] = id.count(cell) ? id[cell] : -1;
}
}
id.clear();
if (!connected()) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
dsu.resize(n + m);
for (int i = 0; i < n + m; i++) {
dsu[i] = {i, 1, false, {i}};
}
for (int i = n; i < n + m; i++) {
for (int j = 0; j < 8; j += 2) {
if (g[i][j] >= n) {
unite(i, g[i][j]);
}
}
}
dsu[find(min_element(grid.begin(), grid.end()) - grid.begin())].outer = true;
for (int i = n - 1; i >= 0; i--) {
for (int x : check) {
candidates.erase(x);
if (is_candidate(x)) {
candidates.insert(x);
}
inq[x] = false;
}
check.clear();
ans[i] = *candidates.rbegin();
candidates.erase(ans[i]);
gone[ans[i]] = true;
for (int j = 0; j < 8; j += 2) {
int k = g[ans[i]][j];
if (k >= n || gone[k]) {
unite(ans[i], k);
}
}
}
for (int x : ans) {
cout << x + 1 << '\n';
}
return 0;
}
| 0 | CPP |
from itertools import permutations
#from fractions import Fraction
from collections import defaultdict
from math import*
import os
import sys
from io import BytesIO, IOBase
from heapq import nlargest
from bisect import*
import copy
import itertools
BUFSIZE = 8192
t=int(input())
while t:
t-=1
n=int(input())
arr=list(map(int,input().split()))
d=dict()
d[0],d[1]=0,0
for i in range(n):
d[arr[i]]+=1
if d[0]>=d[1]:
print(n//2)
for i in range(n//2):
print(0,end=' ')
print()
else:
if (n//2)%2==1:
isPrinted=False
count=0
ans=[]
val=n//2
for i in range(n):
if arr[i]==0:
if isPrinted==False:
if count%2==0:
ans.append(arr[i])
isPrinted=True
count+=1
else:
ans[-1]=0
isPrinted=True
else:
if count<val:
if isPrinted==False:
if count<val-1:
ans.append(1)
count+=1
else:
ans.append(1)
count+=1
else:
break
# print(ans)
if isPrinted==False:
ans.append(1)
ans.append(1)
print(len(ans))
# print(ans)
for i in range(len(ans)):
print(ans[i],end=' ')
print()
else:
print(n//2)
for i in range(n//2):
print(1,end=' ')
print()
| 1,100 | PYTHON3 |
def deci(a,b):
for i in range(0,len(b)):
if(a.lower()[i]<b.lower()[i]):
return -1
elif(a.lower()[i]>b.lower()[i]):
return 1
return 0
b=input()
c=input()
x=deci(b,c)
print(x)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long s, x;
int main() {
cin >> s >> x;
long long p = s - x;
if (p % 2) {
cout << 0;
return 0;
}
p /= 2;
for (int j = 63; j >= 0; j--)
if ((x >> j) & 1 && (p >> j) & 1) {
cout << 0;
return 0;
}
long long ans = 1;
for (int i = 63; i >= 0; i--)
if ((x >> i) & 1) ans *= 2;
if (p == 0) ans -= 2;
cout << ans;
return 0;
}
| 1,700 | CPP |
import math
alph="abcdefghijklmnopqrstuvwxyz"
#-----------------------------------
t=int(input())
for i in range(t):
n=int(input())
if n<=2:print(0)
else:
print((n+1)//2-1) | 800 | PYTHON3 |
def main():
r,c = map(int, input().split(' '))
s = []
w = []
r_dir = [1,-1,0,0]
c_dir = [0,0,1,-1]
for i in range(r):
inpt = input()
for j in range(c):
if inpt[j] == "S":
s.append([i,j])
elif inpt[j] == "W":
w.append([i,j])
for pos in s:
for i in range(4):
newpos = [pos[0]+c_dir[i],pos[1]+r_dir[i]]
if newpos in w:
print('No')
return
mat = [['D' for i in range(c)] for i in range(r)]
for p in s:
mat[p[0]][p[1]] = 'S'
for p in w:
mat[p[0]][p[1]] = 'W'
print('Yes')
for i in mat:
print(''.join(i))
main() | 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
void solve() {
set<ll> s;
for (ll i = 0; i < 4; i++) {
ll x;
cin >> x;
s.insert(x);
}
cout << 4 - s.size() << endl;
}
int main() {
ll t = 1;
while (t--) solve();
return 0;
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
string itosm(long long x) {
if (x == 0) return "0";
string ans = "";
while (x > 0) {
ans += ((x % 10) + '0');
x /= 10;
}
reverse(ans.begin(), ans.end());
return ans;
}
long long stoim(string str) {
long long ans = 0;
long long k = 1;
for (int i = str.length() - 1; i >= 0; i--) {
ans += (str[i] - '0') * k;
k *= 10;
}
return ans;
}
const long long infll = 1e18 + 3;
const int inf = 1009000999;
const double eps = 1e-7;
const int maxn = 1e5 + 10000;
const int baseint = 1000200013;
const long long basell = 1e18 + 3;
const long double PI = acos(-1.0);
const long long mod = 1e9 + 1;
long double s, n;
long double x[maxn], v[maxn], t[maxn];
vector<pair<long double, pair<int, int> > > q;
bool check(long double time) {
q.clear();
for (int i = (0); i < (n); i++) {
if (t[i] == 1) {
if (1.0 * x[i] / (s + v[i]) <= time) {
long double tt = (time - ((x[i] - v[i] * time) / s));
if (x[i] - v[i] * time < 0) {
q.push_back(make_pair(-1, make_pair(-1, 0)));
q.push_back(make_pair(1e6 + 1, make_pair(1, 0)));
continue;
}
q.push_back(make_pair(x[i], make_pair(-1, 0)));
q.push_back(make_pair(max(x[i], ceil(x[i] - tt * v[i] + tt * s) - 1),
make_pair(1, 0)));
}
} else {
if (1.0 * (1000000 - x[i]) / (s + v[i]) <= time) {
long double tt = (time - ((1000000 - x[i] - v[i] * time) / s));
if (1000000 - x[i] - v[i] * time < 0) {
q.push_back(make_pair(-1, make_pair(0, -1)));
q.push_back(make_pair(1e6 + 1, make_pair(0, 1)));
continue;
}
q.push_back(make_pair(min(x[i], ceil(x[i] + tt * v[i] - tt * s)),
make_pair(0, -1)));
q.push_back(make_pair(x[i], make_pair(0, 1)));
}
}
}
sort(q.begin(), q.end());
pair<int, int> a = {0, 0};
while (q.size() > 0) {
a.first += q.back().second.first;
a.second += q.back().second.second;
if (a.second > 0 && a.first > 0) return 1;
q.pop_back();
}
return 0;
}
void solve() {
cin >> n >> s;
for (int i = (0); i < (n); i++) {
cin >> x[i] >> v[i] >> t[i];
}
long double l = 0, r = 5e5, m;
while (r - l > eps) {
m = (l + r) / 2;
if (check(m))
r = m;
else
l = m;
}
cout << fixed << setprecision(20) << l;
}
int main() {
srand(time(0));
ios_base::sync_with_stdio(0);
;
solve();
return 0;
}
| 2,500 | CPP |
t = int(input())
for q in range(t):
n = int(input())
mas = list(map(int, input().split()))
s1 = set(mas)
flag = False
for k in range(1, 1024):
s2 = set()
for i in mas:
s2.add(i ^ k)
if s1 == s2:
print(k)
flag = True
break
if not(flag):
print(-1)
| 1,200 | PYTHON3 |
from math import ceil
a1 = int(input())
a2 = int(input())
k1 = int(input())
k2 = int(input())
n = int(input())
if k1 > k2 :
k1 , k2 = k2 , k1
a1 , a2 = a2 , a1
y = a1 * k1
mxc = 0
if n <= y :
mxc = n // k1
else:
mxc = a1 + (n - y ) // k2
x = (a1 * (k1 - 1) + a2 * (k2 - 1))
mnc = n - x
if mnc <= 0 :
mnc = 0
else:
mnc = n - x
print(mnc , (mxc))
| 1,000 | PYTHON3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.