solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long ext_euc(long long a, long long b, long long& x, long long& y) {
long long tmp;
long long xr = 0;
long long yr = 1;
x = 1;
y = 0;
while (a != 0) {
tmp = x;
x = xr - (b / a) * x;
xr = tmp;
tmp = y;
y = yr - (b / a) * y;
yr = tmp;
tmp = a;
a = b % a;
b = tmp;
}
x = xr;
y = yr;
return b;
}
long long inv_mod(long long a, long long m) {
long long tmp;
long long xr = 0;
long long x = 1;
long long b = m;
while (a != 0) {
tmp = x;
x = xr - (b / a) * x;
xr = tmp;
tmp = a;
a = b % a;
b = tmp;
}
return (xr + m) % m;
}
long long choose(long long a, long long n, long long m) {
if (a < n) return 0;
if (a == n) return 1;
long long top = 1, bot = 1;
for (int i = 0; i < n; ++i) {
top *= (a - i);
top %= m;
bot *= (i + 1);
bot %= m;
}
return (top * inv_mod(bot, m)) % m;
}
int main() {
int n;
cin >> n;
vector<long long> Ls(n + 1), Rs(n + 1);
map<int, long long> Loc;
vector<int> in;
Ls[0] = -1;
Rs[0] = 998244353;
long long denominator = 1;
for (int i = n; i > 0; --i) {
cin >> Ls[i] >> Rs[i];
Rs[i]++;
in.push_back(i);
in.push_back(-1 * i);
denominator *= Rs[i] - Ls[i];
denominator %= 998244353;
}
for (int i = 1; i <= n; ++i) {
if (Ls[i] < Ls[i - 1]) Ls[i] = Ls[i - 1];
Loc[i] = Ls[i];
}
for (int i = n; i >= 1; --i) {
if (Rs[i] < Rs[i - 1]) Rs[i - 1] = Rs[i];
Loc[-1 * i] = Rs[i];
}
sort(in.begin(), in.end(),
[&Loc](int& a, int& b) { return Loc[a] < Loc[b]; });
long long range_low = Loc[in[0]];
long long range_high = Loc[in[0]];
int low = 0;
int high = 1;
int lhigh = 1;
vector<long long> end_at(n + 2, 0);
end_at[0] = 1;
vector<long long> cpy(n + 2, 0);
int i = 0;
while (i < in.size() - 1 && Loc[in[i + 1]] == Loc[in[i]]) {
++i;
if (in[i] > 0)
high++;
else
low++;
}
++i;
lhigh = high;
while (i < in.size()) {
if (in[i] > 0)
high++;
else
low++;
while (i < in.size() - 1 && Loc[in[i + 1]] == Loc[in[i]]) {
++i;
if (in[i] > 0)
high++;
else
low++;
}
range_low = range_high;
range_high = Loc[in[i]];
for (int j = low; j <= lhigh; ++j) {
for (int k = 0; k <= j; ++k) {
cpy[j] += end_at[k] *
choose(range_high - range_low + j - k - 1, j - k, 998244353);
cpy[j] %= 998244353;
}
}
lhigh = high;
for (int l = 0; l <= n; ++l) {
end_at[l] = cpy[l];
cpy[l] = 0;
}
++i;
}
long long nom = end_at[n];
denominator = inv_mod(denominator, 998244353);
cout << (nom * denominator) % 998244353 << endl;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const int mod = 1e9 + 7;
int a[maxn];
int dp[10005][2005];
int l[2][2005], r[2][2005];
void solve() {
int n;
cin >> n;
int maxval = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
maxval = max(maxval, a[i]);
}
maxval *= 2;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= maxval; j++) {
dp[i][j] = maxval * 2;
}
}
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= maxval; j++) {
if (dp[i][j] == maxval * 2) {
continue;
}
dp[i + 1][max(0, j - a[i])] =
min(dp[i + 1][max(0, j - a[i])], dp[i][j] + a[i]);
if (j + a[i] <= maxval) {
dp[i + 1][j + a[i]] = min(dp[i + 1][j + a[i]], max(0, dp[i][j] - a[i]));
}
}
}
int ans = maxval;
for (int i = 0; i <= maxval; i++) {
ans = min(ans, dp[n][i] + i);
}
cout << ans << endl;
}
int main() {
int T;
cin >> T;
while (T--) {
solve();
}
return 0;
}
| 13 | CPP |
n = int(input())
if n==1:
print(n)
else:
res = 0
for i in range(1, n+1):
res+=2*i - 1
for i in range(1, n):
res+=2*i - 1
print(res) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, r, count = 0;
cin >> k >> r;
for (int i = 1;; i++) {
count++;
if ((k * i) % 10 == r || (k * i) % 10 == 0) break;
}
cout << count;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const string ele[101] = {
"", "H", "He", "Li", "Be", "B", "C", "N", "O", "F", "Ne", "Na",
"Mg", "Al", "Si", "P", "S", "Cl", "Ar", "K", "Ca", "Sc", "Ti", "V",
"Cr", "Mn", "Fe", "Co", "Ni", "Cu", "Zn", "Ga", "Ge", "As", "Se", "Br",
"Kr", "Rb", "Sr", "Y", "Zr", "Nb", "Mo", "Tc", "Ru", "Rh", "Pd", "Ag",
"Cd", "In", "Sn", "Sb", "Te", "I", "Xe", "Cs", "Ba", "La", "Ce", "Pr",
"Nd", "Pm", "Sm", "Eu", "Gd", "Tb", "Dy", "Ho", "Er", "Tm", "Yb", "Lu",
"Hf", "Ta", "W", "Re", "Os", "Ir", "Pt", "Au", "Hg", "Tl", "Pb", "Bi",
"Po", "At", "Rn", "Fr", "Ra", "Ac", "Th", "Pa", "U", "Np", "Pu", "Am",
"Cm", "Bk", "Cf", "Es", "Fm"};
map<string, int> re;
vector<int> avl[20];
int p[20], tar[20];
int starttime = clock();
void init() {
for (int i = 1; i <= 100; ++i) {
re[ele[i]] = i;
}
}
int n, k;
bool dfs(int s, int used) {
if (s == k) {
cout << "YES\n";
return true;
}
if (clock() - starttime > 2.8 * CLOCKS_PER_SEC) return false;
for (int i = 0; i < avl[s].size(); ++i) {
if ((avl[s][i] & used) == 0) {
if (dfs(s + 1, used | avl[s][i])) {
string ans;
for (int j = 0; j < n; ++j) {
if ((avl[s][i] >> j) & 1) {
ans += ele[p[j]] + '+';
}
}
ans.erase(ans.length() - 1);
ans += "->";
ans += ele[tar[s]];
cout << ans << endl;
return true;
}
}
}
return false;
}
int main() {
srand(1315056);
ios::sync_with_stdio(false);
init();
cin >> n >> k;
string str;
for (int i = 0; i < n; ++i) {
cin >> str;
p[i] = re[str];
}
for (int i = 0; i < k; ++i) {
cin >> str;
tar[i] = re[str];
}
random_shuffle(tar, tar + k);
for (int i = 0; i < (1 << n); ++i) {
int sum = 0;
for (int j = 0; j < n; ++j) {
if ((i >> j) & 1) {
sum += p[j];
}
}
for (int j = 0; j < k; ++j) {
if (sum == tar[j]) {
avl[j].push_back(i);
}
}
}
if (!dfs(0, 0)) cout << "NO\n";
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
int n, m, i, j, K, l, p, x, y;
int f[100010], s[100010];
int get(int i) { return f[i] == i ? i : f[i] = get(f[i]); }
int main() {
scanf("%d%d%d", &n, &m, &K);
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
f[get(x)] = get(y);
}
for (int i = 1; i <= n; i++) s[get(i)]++;
int ans = 1;
for (int i = 1; i <= n; i++)
if (s[i]) p++, ans = 1LL * ans * s[i] % K;
for (int i = 1; i <= p - 2; i++) ans = 1LL * ans * n % K;
if (p == 1)
printf("%d\n", 1 % K);
else
printf("%d\n", int(ans));
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[5009];
int b[5009];
int p[100000], pr[100000];
int cnt = 0;
void prime(int n) {
for (int i = 0; i < n; i++) p[i] = 1;
p[0] = p[1] = 0;
for (int i = 2; i * i < n; i++)
if (p[i])
for (int j = i * i; j < n; j += i) p[j] = 0;
cnt = 0;
for (int i = 2; i < n; i++)
if (p[i]) pr[cnt++] = i;
}
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int g[5009];
int init(int n, int m) {
int k = 0;
for (int i = 0; pr[i] * pr[i] <= n; i++)
if (n % pr[i] == 0) {
int j = 0;
while (n % pr[i] == 0) n /= pr[i], j++;
if (binary_search(b, b + m, pr[i]))
k -= j;
else
k += j;
}
if (n > 1) {
if (binary_search(b, b + m, n))
k -= 1;
else
k += 1;
}
return k;
}
int main() {
int m, n;
prime(100000);
while (scanf("%d%d", &n, &m) != EOF) {
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < m; i++) scanf("%d", &b[i]);
int ans = 0;
for (int i = n - 1; i >= 0; i--) {
g[0] = a[0];
for (int j = 1; j <= i; j++) g[j] = gcd(g[j - 1], a[j]);
if (init(g[i], m) <= 0)
for (int j = 0; j <= i; j++) a[j] /= g[i];
}
for (int i = 0; i < n; i++) ans += init(a[i], m);
printf("%d\n", ans);
}
return 0;
}
| 10 | CPP |
n = int(input())
chemForces = dict()
allSum = 0
for i in range(n):
newChem = input().split()
i,k = int(newChem[0]), int(newChem[1])
allSum += k
chemForces.update({i:k})
m = int(input())
topChemist = dict()
for j in range(m):
newTop = input().split()
j, t = int(newTop[0]), int(newTop[1])
allSum += t
topChemist.update({j : t})
intersection = set.intersection(set(chemForces), set(topChemist))
for i in intersection:
chemF = chemForces.get(i)
topC = topChemist.get(i)
if chemF <= topC:
allSum -= chemF
else:
allSum -= topC
print(allSum) | 8 | PYTHON3 |
n=int(input())
s="I hate"
print(s,end=" ")
for i in range(2,n+1):
if i%2==0:
print("that I love",end=" ")
else:
print("that I hate",end=" ")
print("it") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k;
int temp;
int n;
int array[100001];
map<int, int> below;
struct sqr {
int x;
} sqrs[100000];
bool compare(sqr a, sqr b) {
if (a.x <= b.x) return 1;
return 0;
}
int posi;
int posj;
int main() {
cin >> n >> k;
for (i = ((0)); i < ((n)); ++i) {
cin >> sqrs[i].x;
}
if (k > n) {
cout << -1 << endl;
} else {
sort(sqrs, sqrs + n, compare);
cout << sqrs[n - k].x << " " << sqrs[n - k].x << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long c[55][55], a[55], d[205][55][55], mod = 1e9 + 7;
int main() {
long long n, p, num1 = 0, num2 = 0;
cin >> n >> p;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == 50)
num1++;
else
num2++;
}
for (int i = 0; i <= 50; i++) {
c[i][0] = c[i][i] = 1;
for (int j = 1; j < i; j++) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
}
}
d[0][num1][num2] = 1;
for (int i = 1; i <= 4 * n; i++) {
for (int j = 0; j <= num1; j++) {
for (int k = 0; k <= num2; k++) {
if (i % 2 == 1) {
for (int t = 0; t <= num1; t++) {
for (int q = 0; q <= num2; q++) {
if (j + t <= num1 && q + k <= num2 && t * 50 + q * 100 <= p) {
d[i][j][k] = d[i][j][k] % mod + d[i - 1][j + t][k + q] % mod *
c[j + t][t] % mod *
c[k + q][q] % mod;
d[i][j][k] %= mod;
}
}
}
} else {
for (int t = 0; t <= num1; t++) {
for (int q = 0; q <= num2; q++) {
if (j >= t && k >= q && t * 50 + q * 100 <= p && t + q > 0) {
d[i][j][k] = d[i][j][k] % mod + d[i - 1][j - t][k - q] % mod *
c[num1 - j + t][t] % mod *
c[num2 - k + q][q] % mod;
d[i][j][k] %= mod;
}
}
}
}
}
}
}
for (int i = 0; i <= 4 * n; i++) {
if (d[i][0][0]) {
cout << i << endl;
cout << d[i][0][0] % mod << endl;
return 0;
}
}
cout << -1 << endl;
cout << 0 << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N, X[16], Y[16];
bool isparallel(int a, int b, int c, int d)
{
auto dx1 = X[a] - X[b];
auto dy1 = Y[a] - Y[b];
auto dx2 = X[c] - X[d];
auto dy2 = Y[c] - Y[d];
return (dx1 * dy2 == dy1 * dx2);
}
bool matched[16];
int rec(int);
int parallel_rec(int latte, int malta, int idx, int sz)
{
if(idx == N) {
return (rec(latte + 1));
}
if(matched[idx]) {
return (parallel_rec(latte, malta, idx + 1, sz));
}
int ret = parallel_rec(latte, malta, idx + 1, sz);
for(int j = idx + 1; j < N; j++) {
if(matched[j]) continue;
if(isparallel(latte, malta, idx, j)) {
matched[idx] = true;
matched[j] = true;
ret = max(ret, parallel_rec(latte, malta, idx + 1, sz + 1) + sz);
matched[j] = false;
matched[idx] = false;
}
}
return (ret);
}
int rec(int idx)
{
if(idx == N) {
return (0);
}
if(matched[idx]) {
return (rec(idx + 1));
}
int ret = rec(idx + 1);
for(int j = idx + 1; j < N; j++) {
if(matched[j]) continue;
matched[idx] = true;
matched[j] = true;
ret = max(ret, parallel_rec(idx, j, 0, 1));
matched[j] = false;
matched[idx] = false;
}
return (ret);
}
int main()
{
cin >> N;
for(int i = 0; i < N; i++) {
cin >> X[i] >> Y[i];
}
cout << rec(0) << endl;
} | 0 | CPP |
#include<bits/stdc++.h>
using namespace std;
int H,W,N;
int main(){
cin>>W>>H>>N;
vector<vector<int>>G(H+1);
vector<set<int>>A(H+1);
for(int i=0;i<=H;i++){
G[i].push_back(W);
A[i].insert(W);
}for(int i=0;i<N;i++){
int x,y;cin>>x>>y;x--;y--;
G[y].push_back(x);
A[y].insert(x);
}for(int i=0;i<H;i++)
sort(G[i].begin(),G[i].end());
int a=0;int ans=W;
for(int i=0;i<H;i++){
auto itr=upper_bound(G[i].begin(),G[i].end(),a);
int k=distance(G[i].begin(),itr);if(G[i][k]<ans)ans=G[i][k];
bool x=false;int b=a;
for(int j=b+1;j<G[i][k];j++)
if(!A[i+1].count(j)){a=j;x=true;break;}
if(!x || ans<a)
break;
}cout<<ans<<endl;
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e7 + 6;
int low[N], isp[N];
vector<int> pri;
void getprime() {
fill_n(isp + 2, N - 2, 1);
for (int i = (2); i < (N); ++i) {
if (isp[i]) pri.push_back(i);
for (auto p : pri) {
if (p * i >= N) break;
low[p * i] = p;
isp[p * i] = 0;
if (i % p == 0) break;
}
}
}
int n, a[N];
long long cnt[N];
bool ck(long long mid) {
for (auto p : pri) {
long long ned = cnt[p];
for (long long tmp = mid / p; tmp; tmp /= p) ned -= tmp;
if (ned > 0) return 0;
}
return 1;
}
int main() {
getprime();
scanf("%d", &n);
for (int i = (0); i < (n); ++i) {
scanf("%d", a + i);
cnt[a[i]]++;
}
for (int i = (N - 1) - 1; i >= (2); --i) cnt[i] += cnt[i + 1];
for (int i = (N - 1) - 1; i >= (2); --i)
if (!isp[i]) {
cnt[low[i]] += cnt[i];
cnt[i / low[i]] += cnt[i];
}
long long l = 1, r = 0, ans;
for (int i = (0); i < (n); ++i) r += a[i];
for (long long mid = l + r >> 1; l <= r; mid = l + r >> 1)
ck(mid) ? r = (ans = mid) - 1 : l = mid + 1;
printf("%lld\n", ans);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 100005;
struct point {
double x, y;
} p[N];
long long n;
bool check(double r) {
double mn = 1e38, mx = -1e38;
for (long long i = 1; i <= n; i++) {
if (r * r - (p[i].y - r) * (p[i].y - r) < -1e-9) return false;
double d = sqrt(r * r - (p[i].y - r) * (p[i].y - r));
mn = min(mn, p[i].x + d);
mx = max(mx, p[i].x - d);
}
return mn - mx >= -1e-9;
}
signed main() {
cin >> n;
for (long long i = 1; i <= n; i++) cin >> p[i].x >> p[i].y;
double mx = 0;
for (long long i = 1; i <= n; i++)
mx = max(mx, max(abs(p[i].x), abs(p[i].y)));
double ymn = 1e18, ymx = -1e18;
for (long long i = 1; i <= n; i++)
ymn = min(ymn, p[i].y), ymx = max(ymx, p[i].y);
if (ymn < 0 && ymx > 0) {
cout << -1 << endl;
return 0;
}
for (long long i = 1; i <= n; i++) p[i].y = abs(p[i].y);
double l = 0, r = mx * mx * 10;
while (r - l > 1e-8 && (r - l) / r > 1e-10) {
double mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
if (r > mx * mx * 5) {
cout << -1 << endl;
} else {
printf("%.10lf\n", r);
}
}
| 10 | CPP |
# Board Moves
import sys
def solve():
return None
def main():
q = []
for line in sys.stdin.readlines():
q.append(line.rstrip())
# for i in range(len(q)):
# q[i] = q[i].rstrip().split(' ')
# q[i] = [int(x) for x in q[i]]
for i in range(1, len(q)):
k = int(q[i]) // 2
# print(k)
# solve(q[i])
total = 0
i = 0
while (i != k):
total += (i+1)**2 * 8
i+=1
print(total)
if __name__ == '__main__':
main() | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long bigmod(long long b, long long p, long long m) {
if (p == 0) return 1;
long long ret;
if ((p % 2) == 0) {
ret = bigmod(b, p / 2, m) % m;
ret = (ret * ret) % m;
} else {
ret = bigmod(b, p - 1, m) % m;
ret = (ret * (b % m)) % m;
}
return ret;
}
int main() {
long long n, m;
while (cin >> n >> m) {
long long ans = bigmod(3, n, m);
ans = (ans - 1 + m) % m;
cout << ans << endl;
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("O2,unroll-loops,no-stack-protector,fast-math")
using namespace std;
const int MAXN = 500010;
long long n, m, k, p, q, r, ans;
int A[MAXN], B[MAXN], C[MAXN];
int maxb[MAXN], maxc[MAXN];
long long seg[MAXN << 2];
int lazy[MAXN << 2], Mn[MAXN << 2], Mx[MAXN << 2];
vector<int> vec[MAXN];
void add_lazy(int id, long long len, int lz) {
seg[id] = len * lz;
lazy[id] = Mn[id] = Mx[id] = lz;
}
void shift(int id, int tl, int tr) {
if (!lazy[id]) return;
int mid = (tl + tr) >> 1;
add_lazy(id << 1, mid - tl, lazy[id]);
add_lazy(id << 1 | 1, tr - mid, lazy[id]);
lazy[id] = 0;
}
void update(int id, int tl, int tr, int l, int r, int val) {
if (tr <= l || r <= tl || Mn[id] >= val) return;
if (l <= tl && tr <= r && Mx[id] <= val) {
add_lazy(id, tr - tl, val);
return;
}
shift(id, tl, tr);
int mid = (tl + tr) >> 1;
update(id << 1, tl, mid, l, r, val);
update(id << 1 | 1, mid, tr, l, r, val);
seg[id] = seg[id << 1] + seg[id << 1 | 1];
Mn[id] = min(Mn[id << 1], Mn[id << 1 | 1]);
Mx[id] = max(Mx[id << 1], Mx[id << 1 | 1]);
}
long long get(int id, int tl, int tr, int l, int r, long long val) {
if (r <= tl || tr <= l || Mx[id] <= val) return 0;
if (l <= tl && tr <= r && Mn[id] >= val) return seg[id] - val * (tr - tl);
shift(id, tl, tr);
int mid = (tl + tr) >> 1;
return get(id << 1, tl, mid, l, r, val) +
get(id << 1 | 1, mid, tr, l, r, val);
}
void Add(int x, int y) { update(1, 1, MAXN, 1, x + 1, y); }
long long Get(int x, int y) { return get(1, 1, MAXN, x + 1, MAXN, y); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> p >> q >> r;
for (int i = 1; i <= n; i++)
cin >> A[i] >> B[i] >> C[i], vec[A[i]].push_back(i);
for (int a = p; a; a--) {
maxb[a] = maxb[a + 1];
maxc[a] = maxc[a + 1];
for (int id : vec[a]) {
maxb[a] = max(maxb[a], B[id]);
maxc[a] = max(maxc[a], C[id]);
}
}
for (int a = 1; a <= p; a++) {
ans += (q - maxb[a]) * (r - maxc[a]) - Get(maxb[a], maxc[a]);
for (int id : vec[a]) Add(B[id], C[id]);
}
cout << ans << '\n';
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m;
cin >> n >> m;
long long int a[n], b[n];
for (long long int i = 0; i < n; i++) {
cin >> a[i];
}
for (long long int i = 0; i < n; i++) {
cin >> b[i];
}
sort(a, a + n);
sort(b, b + n);
vector<long long int> v;
long long int ans = 9e18;
for (long long int i = 0; i < n; i++) {
long long int val = b[0] - a[i] + m;
val %= m;
for (long long int j = 0; j < n; j++) {
v.push_back((a[j] + val) % m);
}
sort(v.begin(), v.end());
long long int ok = 1;
for (long long int j = 0; j < n; j++) {
if (v[j] != b[j]) {
ok = 0;
break;
}
}
v.clear();
if (ok) {
ans = min(ans, val);
}
}
cout << ans << endl;
return 0;
}
| 8 | CPP |
# -*- coding: utf-8 -*-
"""
Created on Tue Apr 7 13:34:02 2020
@author: dell
"""
result = 0
s1 = input().lower()
s2 = input().lower()
if s1<s2:
print(-1)
elif s1>s2:
print(1)
else:
print(0) | 7 | PYTHON3 |
#include <iostream>
using namespace std;
int Fairfield(int y,int m,int d){
if(m <= 2){
y--;
m += 12;
}
return 365*y+y/4-y/100+y/400+153*(m+1)/5+d-428;
}
int main(){
int y1,m1,d1,y2,m2,d2;
while(true){
cin >> y1 >> m1 >> d1 >> y2 >> m2 >> d2;
if(y1 == -1 && m1 == -1 && d1 == -1 &&
y2 == -1 && m2 == -1 && d2 == -1) break;
cout << Fairfield(y2,m2,d2) - Fairfield(y1,m1,d1) << endl;
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long inf = (long long)1e9 + 70;
const long long mod = 1e9 + 7;
const int maxn = 1e5 + 1000;
const double PI = acos(-1);
vector<complex<double> > a;
vector<complex<double> > b;
vector<complex<double> > p1;
vector<complex<double> > p2;
void FFTa(int startout, int startin, int step, complex<double> w, int n) {
if (n == 1) {
b[startout] = a[startin];
return;
}
FFTa(startout, startin, 2 * step, w * w, n / 2);
FFTa(startout + n / 2, startin + step, 2 * step, w * w, n / 2);
complex<double> pw = 1;
for (int i = 0; i < n / 2; i++) {
complex<double> even = b[startout + i];
complex<double> odd = b[startout + i + n / 2];
b[startout + i] = even + pw * odd;
b[startout + i + n / 2] = even - pw * odd;
pw *= w;
}
}
void FFT(int n, bool forward) {
b.clear();
b = vector<complex<double> >(n);
if (forward)
FFTa(0, 0, 1, polar(1.0, 2 * PI / 1.0 / n), n);
else
FFTa(0, 0, 1, polar(1.0, -2 * PI / 1.0 / n), n);
}
void multiply() {
a.clear();
int n = 1;
int enddegree = p1.size() + p2.size();
while (n <= p1.size() + p2.size()) {
n *= 2;
}
a = vector<complex<double> >(n);
for (int i = (0); i < (p1.size()); i++) {
a[i] = p1[i];
}
FFT(n, true);
vector<complex<double> > d;
for (complex<double> c : b) d.push_back(c);
a.clear();
a = vector<complex<double> >(n);
for (int i = (0); i < (p2.size()); i++) {
a[i] = p2[i];
}
FFT(n, true);
for (int i = (0); i < (n); i++) {
a[i] = b[i] * d[i];
}
FFT(n, false);
p1 = vector<complex<double> >(enddegree);
for (int i = (0); i < (enddegree); i++) {
double d = b[i].real();
if (abs(d) < 1e-10) d = 0;
d = d / n;
p1[i] = d;
}
}
vector<complex<double> > polynomials[105];
void perform(int i, int j) {
if (i == j) {
p1.clear();
for (complex<double> c : polynomials[i]) {
p1.push_back(c);
}
return;
}
p1.clear();
int mid = (i + j) / 2;
perform(i, mid);
vector<complex<double> > temp;
for (complex<double> c : p1) {
temp.push_back(c);
}
perform(mid + 1, j);
p2.clear();
for (complex<double> c : temp) {
p2.push_back(c);
}
multiply();
}
int main() {
if (fopen("input.txt", "r")) freopen("input.txt", "r", stdin);
int(n);
scanf("%d", &n);
int(m);
scanf("%d", &m);
int sum = 0;
p1.push_back(1);
for (int i = (0); i < (n); i++) {
int(t);
scanf("%d", &t);
t--;
sum += t;
for (int j = (0); j < (m); j++) {
if (j != t) {
polynomials[i].push_back(1.0 / (m - 1));
} else {
polynomials[i].push_back(0);
}
}
}
perform(0, n - 1);
double ans = 0;
for (int i = 0; i < sum; i++) {
ans += p1[i].real();
}
ans *= (m - 1);
printf("%.10f\n", ans + 1);
return 0;
}
| 9 | CPP |
t = int(input())
for j in range(t):
l,r = map(int,input().split())
if(r//l >=2):
print(l,2*l)
else:
print(-1,-1)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int sum = a.back();
vector<int> f(n);
f[n - 1] = a.back();
for (int i = n - 2; i >= 0; i--) {
sum += a[i];
f[i] = max(f[i + 1], sum - f[i + 1]);
}
cout << sum - f[0] << " " << f[0];
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, q, i, cnt = 0;
cin >> n;
vector<int> v;
for (i = 0; i < n; i++) {
cin >> a;
v.push_back(a);
}
sort(v.begin(), v.end());
cin >> q;
long long m;
for (i = 0; i < q; i++) {
cin >> m;
cnt = upper_bound(v.begin(), v.end(), m) - v.begin();
cout << cnt << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a1, a2, a3, a4;
cin >> a1 >> a2 >> a3 >> a4;
if (a3 > a1 || a3 > a2 || a4 > a1 || a4 > a2 || a3 - a4 > 1 || a4 - a3 > 1) {
cout << -1;
return 0;
}
string s;
s = '4';
--a1;
int i = 0;
while (a1 && a2 && a3 && a4) {
if (s[i] == '4') {
s += '7';
--a2, --a3, ++i;
}
if (s[i] == '7') {
s += '4';
--a1, --a4, ++i;
}
}
if (!a1) {
if (s[s.length() - 1] == '4') {
if ((!a2 && (a3 || a4)) || a3 > 1 || a4 > 1) {
cout << -1;
return 0;
}
if (a2 && a3 == 1) {
s += '7';
a3 = 0;
--a2;
}
if (!a2 && a4) {
cout << -1;
return 0;
}
if (a2 && a4 == 1) {
s = "7" + s;
--a2;
a4 = 0;
}
for (int i = 0; i < s.length(); ++i) {
if (i + 1 == s.length())
for (int i = 0; i < a2; ++i) printf("7");
printf("%c", s[i]);
}
return 0;
}
}
if (!a2) {
if (s[s.length() - 1] == '4') {
if (a3 || a4) {
cout << -1;
return 0;
}
for (int i = 0; i < a1; ++i) printf("4");
cout << s;
return 0;
}
if (s[s.length() - 1] == '7') {
if ((!a1 && (a3 || a4)) || a3 || a4 > 1) {
cout << -1;
return 0;
}
if (a1 && a4 == 1) {
s += '4';
--a1;
a4 = 0;
}
for (int i = 0; i < a1; ++i) printf("4");
cout << s;
return 0;
}
}
if (!a3) {
if (!a4) {
for (int i = 0; i < a1; ++i) printf("4");
if (s[s.length() - 1] != '4') {
cout << s;
for (int i = 0; i < a2; ++i) printf("7");
} else {
for (int i = 0; i < s.length(); ++i) {
if (i + 1 == s.length())
for (int j = 0; j < a2; ++j) printf("7");
printf("%c", s[i]);
}
}
return 0;
}
if (s[s.length() - 1] == '4') {
if ((a4 && !a2) || a4 > 1) {
cout << -1;
return 0;
} else if (a4 == 1 && a2) {
--a2;
--a4;
printf("7");
}
for (int i = 0; i < a1; ++i) printf("4");
for (int i = 0; i < s.length(); ++i) {
if (i + 1 == s.length())
for (int j = 0; j < a2; ++j) printf("7");
printf("%c", s[i]);
}
return 0;
}
if (s[s.length() - 1] == '7') {
if ((a4 && !a1) || a4 > 1) {
cout << -1;
return 0;
}
if (a4 == 1 && a1) {
s += "4";
--a1;
--a4;
}
for (int i = 0; i < a1; ++i) printf("4");
cout << s;
for (int j = 0; j < a2; ++j) printf("7");
return 0;
}
}
if (!a4) {
if (!a3) {
for (int i = 0; i < a1; ++i) printf("4");
cout << s;
for (int i = 0; i < a2; ++i) printf("7");
return 0;
}
if (s[s.length() - 1] == '4') {
if ((a3 && !a2) || a3 > 1) {
cout << -1;
return 0;
} else if (a3 == 1 && a2) {
s += "7";
--a2;
--a3;
}
for (int i = 0; i < a1; ++i) printf("4");
cout << s;
for (int j = 0; j < a2; ++j) printf("7");
return 0;
}
if (s[s.length() - 1] == '7') {
if (a3) {
cout << -1;
return 0;
}
for (int i = 0; i < a1; ++i) printf("4");
cout << s;
for (int i = 0; i < a2; ++i) printf("7");
return 0;
}
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
long long a = m, b = n, arr[n + 5], f = 0;
if (n == m) return cout << -1, 0;
cout << n - m << " ";
for (int i = 1; i < n - m; i++) cout << i << " ";
for (int i = n - m + 1; i <= n; i++) cout << i << " ";
cout << '\n';
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, a[1000002], i, j, l, r, p, ans = 1, d[1000002][5];
vector<vector<int> > v(200000);
int main() {
scanf("%d%d%d", &n, &m, &k);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
v[a[i]].push_back(i);
}
for (i = 1; i <= m; i++) {
l = r = 0;
p = 0;
for (j = 0; j < (int)v[i].size() - 1; j++) {
d[r][0] = v[i][j];
d[r][1] = v[i][j + 1];
p += v[i][j + 1] - v[i][j] - 1;
r++;
while (l < r && p > k) {
p -= d[l][1] - d[l][0] - 1;
l++;
}
if (p <= k) {
ans = max(ans, j + 1 - l + 1);
}
}
}
printf("%d\n", ans);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, x, y, res;
vector<int> g[200200], o[200200];
bool u[3][200200], w[200200], ok = true;
char r[200200];
void dfs(int i, int z) {
u[z][i] = true;
w[i] = true;
for (int j = 0; j < g[i].size(); j++) {
int k = g[i][j];
if (w[k]) ok = false;
if (!u[z][k]) dfs(k, z);
}
w[i] = false;
}
void ofs(int i, int z) {
u[z][i] = true;
for (int j = 0; j < o[i].size(); j++) {
int k = o[i][j];
if (!u[z][k]) ofs(k, z);
}
}
int main() {
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
g[x].push_back(y);
o[y].push_back(x);
}
for (i = 1; ok && i <= n; i++)
if (!u[0][i]) dfs(i, 0);
if (!ok) {
puts("-1");
return 0;
}
memset(u, 0, sizeof(u));
for (i = 1; i <= n; i++)
if (!u[0][i] && !u[1][i] && !u[2][i]) {
dfs(i, 0);
ofs(i, 0);
r[i - 1] = 'A';
res++;
} else {
r[i - 1] = 'E';
if (!u[1][i]) dfs(i, 1);
if (!u[2][i]) ofs(i, 2);
}
printf("%d\n", res);
puts(r);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 1e18;
const long long int N = 1e5 + 5;
long long int mod = 998244353;
void dfs(long long int curr, long long int par, vector<bool> &vis,
vector<long long int> &col, vector<vector<long long int>> &g,
long long int &edges, long long int &node) {
if (!vis[curr]) {
node++;
}
vis[curr] = true;
col[curr] = 1;
for (auto &nbr : g[curr]) {
if (col[nbr] == 0) {
edges++;
dfs(nbr, curr, vis, col, g, edges, node);
} else if (col[nbr] == 1 and par != nbr) {
edges++;
}
}
col[curr] = 2;
}
void null() {
long long int n, m, k;
cin >> n >> m >> k;
vector<vector<long long int>> g(n + 1);
vector<bool> vis(n + 1, false);
vector<long long int> col(n + 1, 0);
long long int ans = 0;
vector<long long int> a(k);
for (long long int i = 0; i < k; i++) {
cin >> a[i];
}
for (long long int i = 0; i < m; i++) {
long long int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
long long int maxa = 0;
for (int i = 0; i < k; i++) {
long long int edges = 0, node = 0;
dfs(a[i], 0, vis, col, g, edges, node);
ans += (node * (node - 1)) / 2 - edges;
maxa = max(maxa, node);
}
long long int rem = 0, z = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
long long int edges = 0, node = 0;
dfs(i, 0, vis, col, g, edges, node);
z += edges;
rem += node;
}
}
ans += (rem * (rem - 1)) / 2 + maxa * rem - z;
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
cout << setprecision(4);
cout << fixed;
long long int t = 1;
clock_t start, end;
start = clock();
while (t--) {
null();
}
end = clock();
double time_taken = double(end - start) / double(CLOCKS_PER_SEC);
}
| 7 | CPP |
n = int(input())
count = 0
while (n > 0):
n = n - 1
a = list(map(int, input().split()))
if sum(a) > 1:
count += 1
print(count) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 2e18;
long long dp[1010][1010];
int n, m;
long long k;
char s[1010];
int to[1010];
void add(long long& x, long long y) {
x += y;
if (x > INF) x = INF;
return;
}
bool solve(int l, int r) {
for (int i = 1; i <= n; i++) {
to[i] = 0;
for (int j = i; j <= n; j++)
if (s[j] > s[l + j - i]) {
to[i] = j;
break;
} else if (s[j] < s[l + j - i]) {
to[i] = 0;
break;
} else if (j - i == r - l) {
to[i] = j;
break;
}
}
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++) {
if (to[j]) add(dp[i][to[j]], dp[i - 1][j - 1]);
add(dp[i][j], dp[i][j - 1]);
}
return dp[m][n] >= k;
}
struct Trie {
int ch[26];
int l, r;
} T[1000010];
int tot = 1;
int trans(int x, int c, int l, int r) {
if (!T[x].ch[c]) {
T[x].ch[c] = ++tot;
T[tot].l = l;
T[tot].r = r;
}
return T[x].ch[c];
}
int L[1000010], R[1000010], N;
void dfs(int u) {
if (T[u].l) {
L[++N] = T[u].l;
R[N] = T[u].r;
}
for (int i = 0; i < 26; i++)
if (T[u].ch[i]) dfs(T[u].ch[i]);
return;
}
int main() {
scanf("%d %d %I64d", &n, &m, &k);
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) {
int now = 1;
for (int j = i; j <= n; j++) now = trans(now, s[j] - 'a', i, j);
}
dfs(1);
int l = 1, r = N + 1;
while (l + 1 < r) {
int mid = (l + r) >> 1;
if (solve(L[mid], R[mid]))
l = mid;
else
r = mid;
}
for (int i = L[l]; i <= R[l]; i++) printf("%c", s[i]);
printf("\n");
return 0;
}
| 9 | CPP |
import sys,os,io,time,copy,math
if os.path.exists('input.txt'):
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
def main():
arr=[]
for i in range(4):
x=input()
a=[]
for s in x:
a.append(s)
arr.append(a)
flag=0
for i in range(3):
for j in range(3):
count_hash=0
count_dot=0
if arr[i][j]=='#':
count_hash+=1
if arr[i][j+1]=='#':
count_hash+=1
if arr[i+1][j]=='#':
count_hash+=1
if arr[i+1][j+1]=='#':
count_hash+=1
if arr[i][j]=='.':
count_dot+=1
if arr[i][j+1]=='.':
count_dot+=1
if arr[i+1][j]=='.':
count_dot+=1
if arr[i+1][j+1]=='.':
count_dot+=1
if count_hash>flag:
flag=count_hash
if count_dot>flag:
flag=count_dot
if flag>=3:
print("YES")
else:
print("NO")
main()
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000007;
int dp[500010], color[500010];
int n;
long long N, ans;
int mypow(int x, int n) {
int res = 1;
while (n) {
if (n & 1) res = 1ll * res * x % inf;
x = 1ll * x * x % inf;
n >>= 1;
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &color[i]);
N += color[i];
}
dp[0] = 0;
dp[1] = 1ll * (N - 1) * (N - 1) % inf * mypow(N, inf - 2) % inf;
for (int i = 1; i < 110000; i++)
dp[i + 1] = ((((dp[i] + dp[i]) % inf - dp[i - 1]) % inf -
1ll * (N - 1) * mypow(N - i, inf - 2) % inf) %
inf +
inf) %
inf;
for (int i = 1; i <= n; i++) ans = (ans + dp[color[i]]) % inf;
cout << ans << endl;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 7;
long long read() {
long long s = 0, w = 1;
char c;
while (c = getchar(), c > '9' || c < '0')
if (c == '-') w = -1;
while (c >= '0' && c <= '9') s = s * 10 + c - '0', c = getchar();
return s * w;
}
void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 | '0');
}
void wsp(long long x) {
write(x);
putchar(' ');
}
void wln(long long x) {
write(x);
putchar('\n');
}
long long n, m;
long long a[N];
priority_queue<long long> q;
signed main() {
n = read();
m = read();
for (long long i = 1; i <= n; i++) a[i] = read();
for (long long i = n; i; i--) {
if (a[i] < 0)
q.push(a[i]);
else {
while (a[i] && !q.empty()) {
long long x = q.top();
q.pop();
long long V = min(-x, a[i]);
x += V;
a[i] -= V;
if (x) q.push(x);
}
}
}
while (!q.empty()) a[++*a] = -q.top(), q.pop();
n = *a;
for (long long i = 2; i <= n; i++) a[i] += a[i - 1];
while (m--) {
long long x = read();
x = upper_bound(a + 1, a + n + 1, x) - a;
wln(n - x + 1);
}
}
| 12 | CPP |
n = int(input())
cnt = 0
for _ in range(n):
d1, d2 = map(int,input().split())
if d1 == d2:
cnt += 1
else:
cnt = 0
if cnt == 3:
print("Yes")
exit()
print("No") | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, a[310][310], dp[2 * 310][310][310];
int dfs(int s, int x1, int x2) {
int y1 = s - x1, y2 = s - x2, ans, ret = -999999999;
if (x1 > n || x2 > n || y1 > n || y2 > n) return -999999999;
if (dp[s][x1][x2] != -999999999) return dp[s][x1][x2];
if (x1 == n && x2 == n && y1 == n && y2 == n) return a[n][n];
if (x1 == x2)
ans = a[x1][y1];
else
ans = a[x1][y1] + a[x2][y2];
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) ret = max(ret, dfs(s + 1, x1 + i, x2 + j));
return dp[s][x1][x2] = ret + ans;
}
int main() {
scanf("%d", &n);
int i, j, k;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) scanf("%d", &a[i][j]);
for (i = 1; i <= 2 * n; i++)
for (j = 1; j <= n; j++)
for (k = 1; k <= n; k++) dp[i][j][k] = -999999999;
printf("%d\n", dfs(2, 1, 1));
}
| 9 | CPP |
#include <iostream>
using namespace std;
int main()
{
string S="";
cin >> S;
if (S=="AAA" or S=="BBB") cout << "No";
else cout << "Yes";
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, p, h[123456], gr[123456], mi = 0, ma = 1e13, mid;
priority_queue<pair<long long, int> > pq;
char go(long long trg) {
long long tot = 0, use = 0;
for (int i = (0); i < (n); i++)
tot += max(0LL, h[i] + m * gr[i] - trg + p - 1) / p;
if (tot > m * k) return 0;
while (!pq.empty()) pq.pop();
for (int i = (0); i < (n); i++) pq.push(make_pair(-(trg / gr[i]), i));
for (int i = (0); i < (m); i++) {
while (-pq.top().first == i) {
int at = pq.top().second;
pq.pop();
long long nwuse = ((i + 1) * gr[at] - trg + p - 1) / p;
use += nwuse - max(0LL, i * gr[at] - trg + p - 1) / p;
long long nxt = (trg + nwuse * p) / gr[at];
pq.push(make_pair(-nxt, at));
}
if (use > k * i) return 0;
}
return 1;
}
int main() {
scanf("%lld %lld %lld %lld", &n, &m, &k, &p);
for (int i = (0); i < (n); i++) scanf("%lld %lld", h + i, gr + i);
while (mi != ma) {
mid = (mi + ma) / 2;
if (go(mid))
ma = mid;
else
mi = mid + 1;
}
printf("%lld\n", mi);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
typedef pair<int,int>P;
typedef pair<P,int>P1;
#define pb push_back
#define fi first
#define sc second
int n,k;
vector<int>x,y,z;
bool used[5000005];
int main(){
cin >> n >> k;
int m = n/2;
int a = k+m;
int b = k+2*n-1;
while(a < b){
x.pb(a); y.pb(b);
used[a-k] = used[b-k] = 1;
a++; b-=2;
}
vector<int>zan;
rep(x,2*n) if(!used[x]) zan.pb(x);
rep(i,zan.size()/2) {
x.pb(zan[i]+k);
y.pb(zan[zan.size()-1-i]+k);
}
for(int i=2*n;i<3*n;i++) z.pb(k+i); reverse(z.begin(),z.end());
rep(i,n){
if(x[i]+y[i] > z[i]){ puts("-1"); return 0;}
}
rep(i,n) cout << x[i] << " " << y[i] << " " << z[i] << endl;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
const int MAXN = 4010;
vector<pair<int, int> > seg;
vector<int> unq, edl[MAXN];
int dp[MAXN][MAXN];
int hs[MAXN][MAXN];
int trf[MAXN][MAXN];
inline int dfs(int l, int r) {
if (l >= r) return dp[l][r] = 0;
if (~dp[l][r]) return dp[l][r];
dp[l][r] = dfs(l + 1, r), trf[l][r] = -1;
for (auto v : edl[l])
if (v < r) {
if (dp[l][r] < dfs(l, v) + dfs(v, r)) {
trf[l][r] = v;
dp[l][r] = dfs(l, v) + dfs(v, r);
}
}
return (dp[l][r] += bool(hs[l][r]));
}
inline void print(int l, int r) {
if (l >= r) return;
if (hs[l][r]) {
cout << hs[l][r] << ' ';
}
if (dp[l][r] <= 0) return;
if (trf[l][r] != -1) {
print(l, trf[l][r]);
print(trf[l][r], r);
} else {
print(l + 1, r);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
int n;
cin >> n;
for (register int i = (1); i <= (n); ++i) {
int o, r;
cin >> o >> r;
unq.push_back(o - r);
unq.push_back(o + r);
seg.push_back(pair<int, int>(o - r, o + r));
}
sort((unq).begin(), (unq).end());
unq.erase(unique((unq).begin(), (unq).end()), unq.end());
for (register int i = (0); i <= (n - 1); ++i) {
auto& sg = seg[i];
sg.first = lower_bound((unq).begin(), (unq).end(), sg.first) - unq.begin();
sg.second =
lower_bound((unq).begin(), (unq).end(), sg.second) - unq.begin();
hs[sg.first][sg.second] = i + 1, edl[sg.first].push_back(sg.second);
}
memset(dp, -1, sizeof(dp));
cout << dfs(0, (int((unq).size())) - 1) << '\n';
print(0, (int((unq).size())) - 1);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n, ctr, len, sum = 0;
string m, q;
cin >> len;
cin >> m;
long long int i;
for (i = 0; i < len; i++) sum += m[i] - 48;
long long int j = 2;
for (i = 0; i < len && j > 0; i++) {
if (m[i] % 2 == 1) {
q += m[i];
j--;
}
}
if (j == 0 && q.size() == 2)
cout << q << "\n";
else
cout << -1 << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 7 | CPP |
#include<iostream>
#include<cmath>
#include<iomanip>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
const int inf=0x3f3f3f3f;
int dp[3005][3005];
int main()
{
string a,b;
cin>>a>>b;
int x,y,i,j;
x=a.length();
y=b.length();
for(i=x-1;i>=0;i--)
{
for(j=y-1;j>=0;j--)
{
if(a[i]==b[j])
dp[i][j]=dp[i+1][j+1]+1;
else
dp[i][j]=max(dp[i+1][j],dp[i][j+1]);
}
}
i=0;
j=0;
while(i<x&&j<y)
{
if(a[i]==b[j])
{
cout<<a[i];
i++;
j++;
}
else if(dp[i][j]==dp[i+1][j])
i++;
else j++;
}
return 0;
} | 0 | CPP |
from sys import stdin, stdout
def read_ints():
return map(int, stdin.readline().split(' '))
n, k = read_ints()
a = list(read_ints())
a.sort()
l = (k - 1) // n
lo = l
while lo > 0 and a[lo - 1] == a[lo]:
lo -= 1
hi = l
while hi + 1 < n and a[hi + 1] == a[hi]:
hi += 1
length = hi - lo + 1
acc = k - lo * n
r = (acc - 1) // length
stdout.write('{} {}'.format(a[l], a[r]))
| 9 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
int n,x,sum;
string s;
int main(){
cin>>n;
for(x=1;sum<n;x++)sum+=x;
x--;
for(int i=0;i<x;i++)s+=')';
for(int i=0;i<x;i++)s+='(';
swap(s[x],s[x-(sum-n)]);
cout<<s<<endl;
return 0;
} | 0 | CPP |
n=input()
s=input()
z=0
o=0
for i in range(len(s)):
if s[i]=='0':
z+=1
elif s[i]=='1':
o+=1
if o:
print(1,end='')
for i in range(z):
print(0,end='')
else:
print(0)
| 7 | PYTHON3 |
"""
Author - Satwik Tiwari .
2nd NOV , 2020 - Monday
"""
#===============================================================================================
#importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from functools import cmp_to_key
# from itertools import *
from heapq import *
from math import gcd, factorial,floor,ceil,sqrt
from copy import deepcopy
from collections import deque
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
#==============================================================================================
#fast I/O 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")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
#===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
def wrapped_func(*args, **kwargs):
if stack: return f(*args, **kwargs)
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
continue
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped_func
#### END ITERATE RECURSION ####
#===============================================================================================
#some shortcuts
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
# def graph(vertex): return [[] for i in range(0,vertex+1)]
def zerolist(n): return [0]*n
def nextline(): out("\n") #as stdout.write always print sring.
def testcase(t):
for pp in range(t):
solve(pp)
def printlist(a) :
for p in range(0,len(a)):
out(str(a[p]) + ' ')
def google(p):
print('Case #'+str(p)+': ',end='')
def lcm(a,b): return (a*b)//gcd(a,b)
def power(x, y, p) :
y%=(p-1) #not so sure about this. used when y>p-1. if p is prime.
res = 1 # Initialize result
x = x % p # Update x if it is more , than or equal to p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) : # If y is odd, multiply, x with result
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
def ncr(n,r): return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))
def isPrime(n) :
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
inf = pow(10,20)
mod = 998244353
#===============================================================================================
# code here ;))
def solve(case):
n,k = sep()
a = lis()
b = lis()
have = {}
for i in range(k):
have[b[i]] = 1
pos = {}
for i in range(n):
pos[a[i]] = i
if(len(b) == 1 and len(a)<3):
if(b[0] in a):
print(1)
else:
print(0)
return
ans = 1
for i in range(k):
# print(i)
# print(have)
left = -1
right = -1
ind = pos[b[i]]
del have[b[i]]
# print(ind)
if(ind == 0):
if(a[ind+1] in have):
ans = 0
break
elif(ind == n-1):
if(a[ind-1] in have):
ans = 0
break
else:
if(a[ind-1] in have and a[ind+1] in have):
ans = 0
break
if(a[ind-1] not in have and a[ind+1] not in have):
ans*=2
# print(i,ans)
ans%=mod
print(ans%mod)
"""
2
13
1 1 1 1 1 4 3 4 4 3 4 3
13
1 1 1 2 2 2 3 3 3 4 4 4
"""
# testcase(1)
testcase(int(inp()))
| 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c, sum = 0;
scanf("%lld%lld%lld", &a, &b, &c);
a += c;
b += c;
if (b > a) {
sum += a * 2 + 1;
} else if (a > b) {
sum += b * 2 + 1;
} else {
sum = a * 2;
}
printf("%lld", sum);
}
| 7 | CPP |
n = int(input())
a = []
for i in range(n):
a.append(int(input()))
for x in a:
for y in a:
if (x != y):
x_count = a.count(x)
y_count = a.count(y)
if (x_count == y_count and x_count + y_count == n):
print("YES\n%d %d" % (x, y))
exit()
print("NO") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
Point(long long x, long long y) : x(x), y(y) {}
long long x, y;
};
Point operator-(Point const& a, Point const& b) {
return Point(a.x - b.x, a.y - b.y);
}
long long normsq(Point d) { return d.x * d.x + d.y * d.y; }
long long cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
long long dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
bool ccw(Point p, Point q, Point r) { return cross(q - p, r - p) > 0; }
bool collinear(Point p, Point q, Point r) {
return fabs(cross(q - p, r - p)) == 0;
}
bool operator<(Point const& a, Point const& b) {
return atan2(a.y, a.x) < atan2(b.y, b.x);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<pair<Point, int>> p;
for (int i = 0; i < n; ++i) {
int x, y;
cin >> x >> y;
p.push_back({{x, y}, i + 1});
}
sort(p.begin(), p.end());
long double mn = 1e18;
pair<int, int> ans;
for (int i = 1; i <= n; ++i) {
long double a1 = atan2(p[i - 1].first.y, p[i - 1].first.x);
long double a2 = atan2(p[i % n].first.y, p[i % n].first.x);
long double adiff =
min(abs(a2 - a1), abs(a2 + 2 * acos((long double)-1) - a1));
if (adiff < mn) {
mn = adiff;
ans = {p[i - 1].second, p[i % n].second};
}
}
cout << ans.first << " " << ans.second << endl;
return 0;
}
| 9 | CPP |
n,x = map(int,input().split())
a = list(map(int, input().split()))
a.sort()
ans = 0
for i in range(n):
x-=a[i]
if x>=0:
ans += 1
if x>0:
ans-=1
print(ans)
| 0 | PYTHON3 |
'''
Online Python Compiler.
Code, Compile, Run and Debug python program online.
Write your code in this editor and press "Run" button to execute it.
'''
n=int(input());
abc=[1,2,3,4]
for x in range(n):
ans=0
a=0
n=int(input())
count=0
a=int(n%10)
b=(a-1)*10
while(n>0):
count=count+1
n=n//10
for i in range(count):
ans=ans+abc[i]
print(ans+b)
| 7 | PYTHON3 |
n,m = (int(x) for x in input().split())
l=[]
for i in range(n):
l.append(input())
ms=[max(s[x] for s in l) for x in range(m)]
print (sum(1 for s in l if (sum (1 for x,y in zip(s,ms) if x==y) > 0))) | 7 | PYTHON3 |
#8:47
MOD=10**9+7
INT_MAX=10**20+7
def INPUT():return list(int(i) for i in input().split())
def LIST_1D_ARRAY(n):return [0 for _ in range(n)]
def LIST_2D_ARRAY(m,n):return [[0 for _ in range(n)]for _ in range(m)]
def power(a,x):
res=1
while(x>0):
if x&1:
res=(res*a)%MOD
a=(a*a)%MOD
x//=2
return res%MOD
def NCR_MOD(n,r):
num=1
for i in range(n,n-r,-1):num=(num*i)%MOD
for j in range(1,r+1):num=(num*power(j,MOD-2))%MOD
return num
import math
from collections import deque
#################################################################################
def calc(n,x,A):
odd=0
even=0
for i in range(n):
if A[i]&1:
odd+=1
else:
even+=1
if odd==0:
return "NO"
if n>x:
if x&1:
if odd>=1:
return "YES"
return "NO"
else:
if odd<x:
return "YES"
else:
if even>0:
return "YES"
else:
return "NO"
else:
if odd&1:
return "YES"
return "NO"
for _ in range(int(input())):
n,x=INPUT()
A=INPUT()#b/w 1 to 1000
print(calc(n,x,A))
print()
| 7 | PYTHON3 |
#include <iostream>
int n,h,a,m;
signed main(){std::cin>>n;while(n--){std::cin>>h;if (h >= m)a++,m=h;}std::cout<<a;}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long dp[105][2];
char s[105];
int d[105];
int n;
long long ans;
void add(long long &x, long long y) { x = x + y; }
int main() {
scanf("%s", s);
n = strlen(s);
int wh = -1;
for (int i = 1; i <= n; i++) {
if (s[i] == 'B') {
wh = i;
break;
}
}
if (wh == -1) {
puts("1");
return 0;
}
for (int i = 0; i < n; i++) d[i + 1] = (s[(i + wh) % n] == 'A');
dp[0][0] = 1;
for (int i = 0; i < n; i++) {
if (d[i + 1] == 0) {
dp[i + 1][0] = dp[i][0];
} else {
if (d[i]) {
dp[i + 1][1] = dp[i][0] + dp[i][1];
} else {
dp[i + 1][0] = dp[i - 1][0] + dp[i - 1][1];
dp[i + 1][1] = dp[i][0] + dp[i][1];
}
}
}
ans += dp[n][0];
memset(dp, 0, sizeof(dp));
dp[0][1] = 1;
for (int i = 0; i < n; i++) {
if (d[i + 1] == 0) {
dp[i + 1][0] = dp[i][0];
} else {
if (d[i]) {
dp[i + 1][1] = dp[i][0] + dp[i][1];
} else {
dp[i + 1][0] = dp[i - 1][0] + dp[i - 1][1];
dp[i + 1][1] = dp[i][0] + dp[i][1];
}
}
}
ans += dp[n][1];
printf("%I64d\n", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
double eps = 0.0000001;
double x1, y1, r1;
double x2, y2, r2;
cin >> x1 >> y1 >> r1;
cin >> x2 >> y2 >> r2;
double d = sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
if (d > r1 + r2 + eps) {
printf("%lf", (d - r1 - r2) / 2);
return 0;
} else {
if (d < fabs(r1 - r2) + eps) {
printf("%lf", (fabs(r1 - r2) - d) / 2);
} else {
cout << 0;
}
return 0;
}
}
| 8 | CPP |
n = int(input())
for i in range(n):
ch = int(input())
if ch <= 3: print(-1)
else:
sum = ch // 4
ch = ch % 4
if ch==0 or ch == 2: print(sum)
elif ch == 1:
if sum >= 2: print(sum - 1)
else: print(-1)
elif ch == 3:
if sum >= 3: print(sum - 1)
else: print(-1) | 9 | PYTHON3 |
'''problem e1'''
n=int(input())
seq=input()
l1=[]
l2=[]
possible = True
l1.append(seq[0])
i=0
for i in range(1,n):
if(seq[i] >=seq[i-1]):
l1.append(seq[i])
else:
l2.append(seq[i])
break
i+=1
while i<n:
if seq[i]>=l1[len(l1)-1]:
l1.append(seq[i])
elif seq[i]>=l2[len(l2)-1]:
l2.append(seq[i])
else:
possible = False
break;
i+=1
i=0
j=0
if possible:
print('YES')
for char in seq:
if i<len(l1) and char == l1[i]:
print('0',end='')
i+=1
else:
print('1',end='')
j+=1
else:
print('NO')
| 11 | PYTHON3 |
import sys
H, W = map(int, input().split())
G = [sys.stdin.readline() for _ in range(H)]
counts = [[[-1] * 4 for _ in range(W + 1)] for _ in range(H + 1)]
for h in range(H):
for w in range(W):
if G[h][w] == ".":
counts[h][w][0] = counts[h][w-1][0] + 1
counts[h][w][1] = counts[h-1][w][1] + 1
dih = H - h - 1
diw = W - w - 1
if G[dih][diw] == ".":
counts[dih][diw][2] = counts[dih][diw+1][2] + 1
counts[dih][diw][3] = counts[dih+1][diw][3] + 1
ans = 0
for h in range(H):
for w in range(W):
if G[h][w] == ".":
ans = max(ans, sum(counts[h][w]) + 1)
print(ans) | 0 | PYTHON3 |
m,n = input().split()
m=int(m)
n=int(n)
if m>=n:
if n%2==0:
print('Malvika')
else:
print('Akshat')
if m<n:
if m%2==0:
print('Malvika')
else:
print('Akshat') | 7 | PYTHON3 |
array = input().split()
for _ in array:
if array.count(_) == 1:
print(_)
break | 0 | PYTHON3 |
#include <bits/stdc++.h>
using std::max;
using std::min;
const int inf = 0x3f3f3f3f, Inf = 0x7fffffff;
const long long INF = 0x3f3f3f3f3f3f3f3f;
__inline__ __attribute__((always_inline)) unsigned int rnd() {
static unsigned int seed = 416;
return seed ^= seed >> 5, seed ^= seed << 17, seed ^= seed >> 13;
}
template <typename _Tp>
_Tp gcd(const _Tp &a, const _Tp &b) {
return (!b) ? a : gcd(b, a % b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp abs(const _Tp &a) {
return a >= 0 ? a : -a;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmax(_Tp &a, const _Tp &b) {
(a < b) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmin(_Tp &a, const _Tp &b) {
(b < a) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void read(_Tp &x) {
char ch(getchar());
bool f(false);
while (!isdigit(ch)) f |= ch == 45, ch = getchar();
x = ch & 15, ch = getchar();
while (isdigit(ch)) x = (((x << 2) + x) << 1) + (ch & 15), ch = getchar();
f && (x = -x);
}
template <typename _Tp, typename... Args>
__inline__ __attribute__((always_inline)) void read(_Tp &t, Args &...args) {
read(t);
read(args...);
}
template <typename _Tp, typename... Args>
__inline__ __attribute__((always_inline)) _Tp min(const _Tp &a, const _Tp &b,
const Args &...args) {
return a < b ? min(a, args...) : min(b, args...);
}
template <typename _Tp, typename... Args>
__inline__ __attribute__((always_inline)) _Tp max(const _Tp &a, const _Tp &b,
const Args &...args) {
return a < b ? max(b, args...) : max(a, args...);
}
__inline__ __attribute__((always_inline)) int read_str(char *s) {
char ch(getchar());
while (ch == ' ' || ch == '\r' || ch == '\n') ch = getchar();
char *tar = s;
*tar = ch, ch = getchar();
while (ch != ' ' && ch != '\r' && ch != '\n' && ch != EOF)
*(++tar) = ch, ch = getchar();
return tar - s + 1;
}
const int N = 100005;
const int MAXN = 10000005;
bool pr[MAXN];
int _p[MAXN >> 3], _pos;
int md[MAXN];
void sieve() {
for (int i = 2; i < MAXN; ++i) {
if (!pr[i]) {
_p[++_pos] = i;
md[i] = i;
}
for (int j = 1; j <= _pos && i * _p[j] < MAXN; ++j) {
pr[i * _p[j]] = true;
md[i * _p[j]] = _p[j];
if (!(i % _p[j])) break;
}
}
}
std::vector<int> p[N], d[N];
int c[MAXN], cnt[1 << 8], mul[1 << 8];
int calc(int id) {
int siz = ((int)p[id].size()), ans = 0;
for (int i = 0; i < siz; ++i) mul[1 << i] = p[id][i];
for (int i = 1; i < 1 << siz; ++i) {
cnt[i] = cnt[i >> 1] + (i & 1);
mul[i] = mul[i ^ ((i) & (-(i)))] * mul[((i) & (-(i)))];
if (cnt[i] & 1)
ans += c[mul[i]];
else
ans -= c[mul[i]];
}
return ans;
}
int a[N];
int _val[11], _cnt[11], pos, cur_id;
void dfs(int dep, int val) {
if (dep == pos + 1) {
d[cur_id].push_back(val);
return;
}
for (int i = 0; i <= _cnt[dep]; ++i) {
dfs(dep + 1, val);
if (i < _cnt[dep]) val *= _val[dep];
}
}
bool ban[N], vis[N];
int deg[N];
int f(int mid) {
while (ban[mid]) --mid;
if (!mid) return false;
int qwq = 0;
for (int i = 1; i <= mid; ++i)
if (!ban[i]) {
++qwq;
for (auto it : d[i]) ++c[it];
}
int ans = 0;
for (int i = 1; i <= mid; ++i)
if (!ban[i] && calc(i) != qwq) ++ans;
for (int i = 1; i <= mid; ++i)
if (!ban[i])
for (auto it : d[i]) --c[it];
return ans;
}
std::vector<int> getnodes(int mid) {
while (ban[mid]) --mid;
std::vector<int> nd;
int qwq = 0;
for (int i = 1; i <= mid; ++i)
if (!ban[i]) {
++qwq;
for (auto it : d[i]) ++c[it];
}
for (int i = 1; i <= mid; ++i)
if (!ban[i] && calc(i) != qwq) nd.push_back(i);
for (int i = 1; i <= mid; ++i)
if (!ban[i])
for (auto it : d[i]) --c[it];
return nd;
}
int main() {
mul[0] = 1;
sieve();
int n, k;
read(n, k);
for (int i = 1; i <= n; ++i) {
read(a[i]);
++c[a[i]];
int cur = a[i], last = 0;
pos = 0;
while (cur > 1) {
if (md[cur] != last)
p[i].push_back(md[cur]), _val[++pos] = md[cur], _cnt[pos] = 1;
else
++_cnt[pos];
last = md[cur];
cur /= last;
}
cur_id = i;
dfs(1, 1);
}
for (int j = 1; j <= _pos; ++j)
for (int i = (MAXN - 1) / _p[j]; i >= 1; --i) c[i] += c[i * _p[j]];
std::vector<int> nd;
for (int i = 1; i <= n; ++i) {
if ((deg[i] = calc(i)) <= n - 2) {
nd.push_back(i);
for (int j = 1; j <= n && ((int)nd.size()) < 3; ++j)
if (i != j && gcd(a[i], a[j]) == 1) nd.push_back(j);
break;
}
}
if (nd.empty()) {
std::vector<int> clique, rest;
for (int i = 1; i <= n; ++i)
if (deg[i] == n)
clique.push_back(i);
else
rest.push_back(i);
if (((int)clique.size()) > k) clique.resize(k);
for (int i = 1; i <= n && ((int)clique.size()) < k; ++i) {
if (!vis[i] && deg[i] == n - 1) {
clique.push_back(i);
for (auto it : rest)
if (gcd(a[it], a[i]) == 1) vis[it] = true;
}
}
for (auto it : clique) printf("%d ", it);
printf("\n");
return 0;
}
assert(((int)nd.size()) == 3);
if (k == 3) {
for (auto it : nd) printf("%d ", it);
printf("\n");
return 0;
}
for (auto it : nd) ban[it] = true;
for (auto id : nd)
for (auto it : d[id]) --c[it];
std::vector<int> clique;
for (int i = 1; i <= n; ++i)
if (!ban[i] && ((deg[i] = calc(i)) == n - 3)) clique.push_back(i);
if (((int)clique.size()) >= k) {
clique.resize(k);
for (auto it : clique) printf("%d ", it);
printf("\n");
return 0;
}
memset(c, 0, sizeof(c));
int l = 1, r = n;
while (l < r) {
int mid = (l + r) >> 1;
if (f(mid) + 3 >= k)
r = mid;
else
l = mid + 1;
}
std::vector<int> v1 = getnodes(l - 1);
std::vector<int> v2 = getnodes(l);
assert(f(l - 1) == ((int)v1.size()));
assert(f(l) == ((int)v2.size()));
assert(((int)v1.size()) + 3 < k);
assert(((int)v2.size()) + 3 >= k);
std::sort(v1.begin(), v1.end());
std::vector<int> qwq;
for (auto it : v2) {
auto _ = std::lower_bound(v1.begin(), v1.end(), it);
if (_ == v1.end() || *_ != it) qwq.push_back(it);
}
std::sort(qwq.begin(), qwq.end());
assert(((int)v1.size()) + ((int)qwq.size()) == ((int)v2.size()));
if (((int)v1.size()) + 3 + 1 == k && ((int)qwq.size()) != 1)
v1.push_back(nd[0]), v1.push_back(nd[1]);
else
v1.push_back(nd[0]), v1.push_back(nd[1]), v1.push_back(nd[2]);
while (((int)v1.size()) < k) {
v1.push_back(qwq.back());
qwq.pop_back();
}
assert(((int)v1.size()) == k);
for (auto it : v1) printf("%d ", it);
printf("\n");
return 0;
}
| 13 | CPP |
import math
n = int(input())
half = n//2
# perms = math.factorial(half)
rotations = half
# ways to rotate a string of len 2 , 1,2 or 2,1
res = math.factorial(n-1)//half
print(res) | 11 | PYTHON3 |
n=int(input())
l=list(map(int , input().rstrip().split()))
p=sorted(l)
k=[]
sum1=0
for i in range(n):
sum1=sum1+((p[(n-1)-i]*i)+1)
j=l.index(p[(n-1)-i])
k.append(j+1)
l[j]='a'
print(sum1)
for i in k:
print(i,end=" ")
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct l {
long long n;
int i;
};
long long gcd(long long x, long long y) {
if (x > y) swap(x, y);
if (!x)
return y;
else
return gcd(y % x, x);
}
bool ss(l x, l y) {
if (x.n == y.n)
return x.i < y.i;
else
return x.n < y.n;
}
long long lcm(long long x, long long y) { return (x / gcd(x, y)) * y; }
long long fast_power(long long base, long long power) {
if (power == 1)
return base;
else if (power % 2)
return base * fast_power(base * base, power / 2);
else
return fast_power(base * base, power / 2);
}
long long nCr(long long n, long long r) {
if (r > n) return 0;
if (2 * r > n) r = n - r;
if (!r) return 1;
long long ans = n;
for (int i = 2; i <= r; i++) {
ans *= (n - i + 1);
ans /= i;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, k;
cin >> n >> m >> k;
int arr[n + 1];
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
cout << arr[n - m] - arr[n - m - 1] << endl;
}
| 7 | CPP |
import math
n, k =map(int, input().split())
r = 2 * n
g = 5 * n
b = 8 * n
res = 0
res += math.ceil(r / k)
res += math.ceil(g / k)
res += math.ceil(b / k)
print(res) | 7 | PYTHON3 |
n, m, r = map(int, input().split())
s = list(map(int, input().split()))
b = list(map(int, input().split()))
if min(s) < max(b):
print(((r // min(s)) * max(b)) + (r % min(s)))
else:
print(r)
# UBCF
# CodeForcesian
# ♥
# اساس | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 100, M = 20, LG = 30, base = 2;
const int MOD = 1e9 + 7, mod = 1e9 + 9;
const long long INF = 1e9, inf = 1e18;
long long n, m, x, ans, dp[N];
pair<long double, long long> p[N];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> p[i].second >> p[i].first;
sort(p, p + n);
for (int i = 0; i < n; i++) {
x = upper_bound(dp, dp + ans, p[i].second) - dp;
if (ans == x) ans++;
dp[x] = p[i].second;
}
cout << n - ans << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
const int N = (int)1e6 + 7, mod = 1000000007, M = 2e9;
int n, m, arr[102][102], t, x;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
t = M;
for (int j = 0; j < m; j++) {
cin >> arr[i][j];
t = min(t, arr[i][j]);
}
x = max(x, t);
}
cout << x;
return 0;
}
| 8 | CPP |
N = int(input())
S = [input() for _ in range(N)]
R = {}
for i in range(N):
R[i] = []
for j in range(N):
if S[i][j] == "1":
R[i].append(j)
def dfs(x):
L = [0] * N
L[x] = 1
S = [x]
K = [0] * N
cnt = 0
while S:
cnt += 1
T = [0] * N
ST = []
while S:
t = S.pop()
T[t] = 1
for i in R[t]:
if L[i] == 1:
if K[i] == 0:
return -1
else:
L[i] = 1
else:
L[i] = 1
K[i] = 1
ST.append(i)
S = ST
K = T
return cnt
ma = -1
for i in range(N):
ma = max(ma, dfs(i))
print(ma)
| 0 | PYTHON3 |
#include "bits/stdc++.h"
using namespace std;
int main(){
double d;cin>>d;
printf("%.10lf\n",max<double>(d*sqrt(2),(int)(d)+1));
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> x(n);
for (int i = 0; i < n; i++) {
cin >> x[i];
}
sort(x.begin(), x.end());
vector<int> res = {x[0]};
for (int i = 0; i < n; i++) {
for (int j = 0; j < 31; j++) {
int le = x[i] - (1 << j);
int re = x[i] + (1 << j);
bool l = binary_search(x.begin(), x.end(), le);
bool r = binary_search(x.begin(), x.end(), re);
if (l && r && (int)res.size() < 3) {
res = {le, re, x[i]};
}
if (l && (int)res.size() < 2) {
res = {le, x[i]};
}
if (r && (int)res.size() < 2) {
res = {re, x[i]};
}
}
}
cout << res.size() << endl;
for (auto i : res) cout << i << " ";
return 0;
}
| 10 | CPP |
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int main(){
ll n;
map<ll,ll> d;
cin>>n;
for(int i=0;i<n;i++){
ll a;
cin>>a;
d[a]++;
}
int f=1;
cin>>n;
for(int i=0;i<n;i++){
ll a;
cin>>a;
if(d[a]>0)d[a]--;
else f=0;
}
cout<<(f?"YES":"NO")<<endl;
return 0;
}
| 0 | CPP |
s=input()
S=[]
for i in s:
S.append(i)
init=S[0]
count=1
flag=1
for i in range(1,len(S)):
if S[i]!=init:
init=S[i]
count=1
else:
count+=1
if count>=7:
print('YES')
flag=0
break
if flag:
print('NO') | 7 | PYTHON3 |
import sys
input = sys.stdin.readline
t = int(input())
a=list(map(int,input().split()))
k=0
out=[]
for i in range(t):
swap=i
for j in range(i,t):
if a[swap]>a[j]:
swap=j
if swap==i:
continue
a[i],a[swap]=a[swap],a[i]
out.append([i,swap])
print(len(out))
for i in out:
print(i[0],i[1])
| 7 | PYTHON3 |
def main():
size = int(input())
nums = [int(input()) for i in range(size)]
for i in range(size):
if nums[i] % 4 == 0:
print("YES")
evens = [x for x in range(0, nums[i]+1) if x % 2 == 0 and x != 0]
odds = [x for x in range(0, nums[i]) if x % 2 != 0]
odds[-1] += len(evens)
print(' '.join(str(x) for x in evens + odds))
else:
print("NO")
main()
| 8 | PYTHON3 |
for _ in range(int(input())):
a0,a1,a2=[int(x) for x in input().split()]
b0,b1,b2=[int(x) for x in input().split()]
print(min(a2,b1)*2+(b2>a0+(a2-min(a2,b1)))*min(b2-(a0+(a2-min(a2,b1))),a1)*-2) | 8 | PYTHON3 |
N,K=map(int,input().split())
P=list(map(int,input().split()))
P.sort()
P=P[0:K]
print(sum(P))
| 0 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int r,c;
cin>>r>>c;
vector<vector<int>> a(r+1,vector<int>(c+1,0));
for(int i=0;i<r;i++){
int sum=0;
for(int j=0;j<c;j++){
cin>>a[i][j];
a[i][c]+=a[i][j];
a[r][j]+=a[i][j];
cout<<a[i][j]<<" ";
}
a[r][c]+=a[i][c];
cout<<a[i][c]<<endl;
}
for(int i=0;i<c;i++) cout<<a[r][i]<<" ";
cout<<a[r][c]<<endl;
}
| 0 | CPP |
import re
s = input()
if re.match(r"^.*h.*e.*l.*l.*o.*$", s):
print("YES")
else:
print("NO") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 50;
bool g[maxn][maxn] = {};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
n = min(n, maxn);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
--a, --b;
if (a >= maxn || b >= maxn) continue;
g[a][b] = g[b][a] = true;
}
vector<bool> sor(n, false);
for (int i = n - 5; i < n; i++) sor[i] = true;
do {
vector<int> v;
for (int i = 0; i < n; i++)
if (sor[i]) v.push_back(i);
int db = 0;
for (int i = 0; i < 4; i++)
for (int j = i + 1; j < 5; j++) db += g[v[i]][v[j]];
if (db == 0 || db == 10) {
for (int &x : v) cout << x + 1 << ' ';
cout << '\n';
return 0;
}
} while (next_permutation(sor.begin(), sor.end()));
cout << "-1\n";
return 0;
}
| 12 | CPP |
t = int(input())
out = []
for x in range(t):
n = int(input())
a = input()
b = a.split()
b = list(map(int, b))
avg = sum(b) / len(b)
if avg % 1 != 0:
out.append(-1)
else:
k = 0
b = sorted(b, reverse=True)
for y in range(len(b)):
if b[y] > avg:
k += 1
out.append(k)
for x in range(t):
print(out[x])
| 8 | PYTHON3 |
from sys import stdin, stdout
from decimal import *
a = Decimal(input())
print([a, '%d' % a][int(a) == a]) | 8 | PYTHON3 |
#include<iostream>
using namespace std;
using ll=long long;
ll MOD=1e9+7;
ll mod_pow(ll a,ll n){
ll ret=1;
while(n>0){
if(n & 1){
ret=ret*a%MOD;
}
a=a*a%MOD;
n>>=1;
}
return ret;
}
ll mod_inv(ll x){
return mod_pow(x,MOD-2);
}
int main(){
ll n,k;
cin>>n>>k;
ll sum=1;
ll M=1;
ll N=1;
ll N_1=1;
ll C;
ll H;
//i=0は1通り
//重複組み合わせ
//(n-m)Hm=(n-1)Cm
ll max=min(k,n);
for(ll i=1;i<=max;i++){
M=M*i%MOD;
N=N*(n-i+1)%MOD;
ll mM=mod_inv(M);
C=N*mM%MOD;
N_1=N_1*(n-i)%MOD;
H=N_1*mM%MOD;
sum+=C*H%MOD;
sum%=MOD;
}
cout<<sum<<endl;
return 0;
} | 0 | CPP |
n = int(input())
l = list(map(int, input().split()))
l.sort()
c = 0
for i in range(0, n):
c += l[2 * i]
print(c) | 0 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
using namespace std;
const int N = 64, M = 32;
bool dp[N][N * N / 2][M];
pair<int, int> par[N][N * N / 2][M];
int a[M];
int g[N][N];
set<pair<int, int> > s;
int vis[N];
void add(int v, int deg) {
set<pair<int, int> > t;
memset(vis, 0, sizeof vis);
while (s.size()) {
int u = s.rbegin()->second;
vis[u] = 1;
int d = s.rbegin()->first;
s.erase({d, u});
d--;
g[u][v] = 1;
if (d) t.insert({d, u});
}
for (int i = 1; i < v; i++) {
if (vis[i] == 0) {
g[v][i] = 1;
deg--;
}
}
s = t;
if (deg > 0) {
s.insert({deg, v});
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
dp[1][a[1]][1] = 1;
for (int i = 2; i < N; i++) {
for (int j = i * (i - 1) / 2; j < N * N / 2; j++) {
for (int k = 1; k <= n; k++) {
if (j >= a[k] && dp[i - 1][j - a[k]][k] == 1) {
dp[i][j][k] = 1;
par[i][j][k] = {j - a[k], k};
}
if (j >= a[k] && dp[i - 1][j - a[k]][k - 1] == 1) {
dp[i][j][k] = 1;
par[i][j][k] = {j - a[k], k - 1};
}
}
}
}
int ras = 0, x = 0, y = 0;
for (int i = a[1] + 1; i < N; i++) {
if (dp[i][i * (i - 1) / 2][n] == 1) {
ras = i;
x = i * (i - 1) / 2;
y = n;
break;
}
}
if (ras == 0) {
return cout << "=(" << '\n', 0;
;
}
cout << ras << '\n';
int ww = ras;
vector<pair<int, int> > d;
while (ras != 1) {
int z = par[ras][x][y].first, t = par[ras][x][y].second;
d.push_back({a[y], ras});
x = z, y = t;
ras--;
}
d.push_back({a[1], ras});
while (d.size()) {
sort(d.begin(), d.end());
for (int i = 0; i < d.back().first; i++) {
g[d.back().second][d[i].second] = 1;
}
for (int i = d.back().first; i < d.size() - 1; i++) {
d[i].first--;
g[d[i].second][d.back().second] = 1;
}
d.pop_back();
}
for (int i = 1; i <= ww; i++) {
for (int j = 1; j <= ww; j++) {
cout << g[i][j];
}
cout << '\n';
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
void work();
int main() { work(); }
const int maxn = 111111;
int num[maxn << 2];
int pri[maxn << 2];
int p[maxn], si[maxn];
bool cmp(int a, int b) { return si[a] > si[b]; }
void updateFather(int pos) {
num[pos] = num[pos << 1] + num[pos << 1 | 1];
pri[pos] = pri[pos << 1] + pri[pos << 1 | 1];
}
void update(int p, int x, int l = 0, int r = 10000, int pos = 1) {
if (l == r) {
num[pos] += x;
pri[pos] += x * p;
return;
}
int m = (l + r) / 2;
if (p <= m)
update(p, x, l, m, pos << 1);
else
update(p, x, m + 1, r, pos << 1 | 1);
updateFather(pos);
}
int query(int k, int l = 0, int r = 10000, int pos = 1) {
if (k == 0) return 0;
if (l == r) return pri[pos] / num[pos] * k;
if (k == num[pos]) return pri[pos];
int m = (l + r) / 2;
if (k <= num[pos << 1])
return query(k, l, m, pos << 1);
else
return pri[pos << 1] + query(k - num[pos << 1], m + 1, r, pos << 1 | 1);
}
void work() {
int n;
while (scanf("%d", &n) == 1) {
memset(num, 0, sizeof(num));
memset(pri, 0, sizeof(pri));
map<int, multiset<int>> vote;
for (int i = 0; i < (n); i++) {
int a, b;
scanf("%d%d", &a, &b);
if (a) vote[a].insert(b);
update(b, 1);
}
int L = 0;
for (auto it = (vote).begin(); it != (vote).end(); it++) {
p[L++] = it->first;
si[it->first] = it->second.size();
}
sort(p, p + L, cmp);
int ans = 2e9;
int vnum = 0, vsum = 0;
int end = 0;
for (int i = (n); i >= (1); i--) {
while (end < L && si[p[end]] >= i) end++;
for (int j = 0; j < (end); j++) {
auto it = vote[p[j]].begin();
int price = *it;
vnum++;
vsum += price;
update(price, -1);
vote[p[j]].erase(it);
}
ans = min(ans, vsum + query(max(i - vnum, 0)));
}
printf("%d\n", ans);
}
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
string arr1[m], arr2[m];
for (int i = 0; i < m; i++) {
cin >> arr1[i];
cin >> arr2[i];
}
string arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (arr[i] == arr1[j] || arr[i] == arr2[j]) {
if (arr1[j].length() <= arr2[j].length()) {
cout << arr1[j] << " ";
} else {
cout << arr2[j] << " ";
}
break;
}
}
}
}
| 8 | CPP |
N = int(input())
P = list(map(float, input().split()))
dp = [[0] * 3010 for _ in range(3010)]
dp[0][1] = 1
dp[0][0] = 1
# dp[i][j] iまでのコインを使って、j枚の表が出る確率
for i in range(N):
for j in range(i+1):
dp[i+1][j+1] += dp[i][j] * P[i]
dp[i+1][j] += dp[i][j] * (1-P[i])
print(sum(dp[N][N//2+1:]))
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int s, n, a;
scanf("%d %d\n", &s, &n);
vector<int> v;
v.assign(s, 0);
for (int i = 0; i < s; i++) scanf(" %d", &v[i]);
sort(v.begin(), v.end());
bool p = true;
for (int i = 0; i < s - 1; i++) {
if ((n - v[i]) >= 0)
n -= v[i];
else {
p = false;
break;
}
}
if (p)
printf("YES\n");
else
printf("NO\n");
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
int n = s.size(), cnt = 0;
for (; (1 << (cnt + 1)) - 1 < n; cnt++)
;
cnt--;
vector<vector<bool> > dp(n + 1, vector<bool>(n + 1, false));
dp[0][0] = 1;
string ans;
int ans_size = n - ((1 << (cnt + 1)) - 1);
for (int i = 0; i < ans_size; i++) {
char best = 'z';
for (int j = i; j < n; j++) {
if (dp[i][j]) {
best = min(best, s[j]);
for (int l = 0; l < cnt + 1; l++) {
if ((j - i) & (1 << l)) continue;
dp[i][j + (1 << l)] = 1;
}
}
}
ans.push_back(best);
for (int j = i; j < n; j++) {
if (dp[i][j] && s[j] == best) {
dp[i + 1][j + 1] = 1;
}
}
}
cout << ans << "\n";
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ui = unsigned int;
using ul = unsigned long;
using ull = unsigned long long;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int a[n], i;
for (i = 0; i < n; i++) cin >> a[i];
int m;
cin >> m;
int b[m];
for (i = 0; i < m; i++) cin >> b[i];
sort(a, a + n);
sort(b, b + m);
int j, count = 0;
for (i = 0, j = 0; i < n && j < m;) {
if (abs(a[i] - b[j]) <= 1) {
count++;
i++;
j++;
} else {
if (a[i] > b[j]) {
j++;
} else if (a[i] < b[j])
i++;
else if (a[i + 1] != a[i])
i++;
else
j++;
}
}
cout << count;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long dp[35][35][55];
long long get(int n, int m, int k) {
if (k <= 0 || n * m == k) return 0;
long long &ans = dp[n][m][k];
if (ans)
return ans;
else
ans = 0x3f3f3f3f;
for (int i = 1; i < n; i++) {
for (int j = 0; j <= k; j++) {
ans = min(ans, get(i, m, j) + get(n - i, m, k - j) + m * m);
}
}
for (int i = 1; i < m; i++) {
for (int j = 0; j <= k; j++) {
ans = min(ans, get(n, i, j) + get(n, m - i, k - j) + n * n);
}
}
return ans;
}
int main() {
int n;
scanf("%d", &n);
int w, l, c;
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &w, &l, &c);
long long ans = get(w, l, c);
cout << ans << endl;
}
return 0;
}
| 11 | CPP |
for _ in range(int(input())):
l = int(input())
n = list(map(int, list(input())))
nw = []
for d in n:
if d % 2 == 1:
nw.append(d)
if len(nw) < 2:
print(-1)
else:
print(*nw[:2], sep="")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
typedef long long int ll;
typedef long double ld;
#define pb push_back
#define pii pair < int , int >
#define F first
#define S second
#define endl '\n'
#define int long long
#define sync ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#define kill(x) return cout<<x<<'\n', 0;
using namespace std;
const int N=5e3+100;
ll dp[N][N];
ll zar[N];
int32_t main(){
ll n,mod;
cin >> n >> mod;
ll k=n/2;
if (n%2==1){
for (int i=2;i<=k+1;i++){
zar[i]=i-1;
}
zar[n+1]=1;
for (int i=n;i>k+1;i--){
zar[i]=zar[i+1]+1;
}
}
else{
for (int i=2;i<=k;i++){
zar[i]=i-1;
}
zar[n+1]=1;
for (int i=n;i>k+1;i--) zar[i]=zar[i+1]+1;
zar[k+1]=zar[k+2];
}
dp[1][0]=1;
for (int i=2;i<=n;i++){
for (int j=0;j<N;j++){
dp[i][j]=dp[i-1][j];
if (zar[i]<=j) dp[i][j]+=dp[i][j-zar[i]];
dp[i][j]%=mod;
}
}
ll ans=0;
for (int i=0;i<n;i++){
ll z=dp[n][i];
z*=(n-i);
ans+=z%mod;
ans%=mod;
}
cout << ans << endl;
}
| 0 | CPP |
#include <bits/stdc++.h>
int main() {
int n, i, j, t;
scanf("%d", &n);
int c[n + 1];
for (i = 1; i < n + 1; i++) {
scanf("%d", &c[i]);
}
for (i = 1; i <= ((n - i) + 1); i = i + 2) {
t = c[i];
c[i] = c[((n - i) + 1)];
c[((n - i) + 1)] = t;
}
for (i = 1; i < n + 1; i++) {
printf("%d ", c[i]);
}
return 0;
}
| 8 | CPP |
t = int(input())
res = []
for i in range(t):
a, b = [int(x) for x in input().split()]
if a > b and (a - b) % 2 == 0:
res.append(1)
elif b > a and (b - a) % 2 == 1:
res.append(1)
elif a == b:
res.append(0)
else:
res.append(2)
for item in res:
print(item)
| 7 | PYTHON3 |
from collections import Counter
n = int(input())
s = input()
keys = Counter()
need = 0
for i in range(0, n*2-2, 2):
keys[s[i]] += 1
neededkey = s[i+1].lower()
if keys[neededkey]:
keys[neededkey] -= 1
else:
need += 1
print(need)
| 7 | PYTHON3 |
t=int(input())
res=0
for i in range(t):
count=0;
a,b,c=map(int,input().split(" "))
if (a==1):
count+=1
if (b==1):
count+=1
if (c==1):
count+=1
if (count>1):
res+=1
print(res)
| 7 | PYTHON3 |
Subsets and Splits