solution
stringlengths 10
159k
| difficulty
int64 0
3.5k
| language
stringclasses 2
values |
|---|---|---|
t = int(input())
for k in range(t):
n, m = map(int, input().split())
a = [list(map(int, input().split())) for K in range(n)]
flag = True
if a[0][0] < 3 and a[0][-1] < 3 and a[-1][0] < 3 and a[-1][-1] < 3:
a[0][0] = 2
a[0][-1] = 2
a[-1][0] = 2
a[-1][-1] = 2
for i in range(1, m - 1):
if a[0][i] > 3:
flag = False
if a[-1][i] > 3:
flag = False
a[0][i] = 3
a[-1][i] = 3
for i in range(1, n - 1):
if a[i][0] > 3:
flag = False
if a[i][-1] > 3:
flag = False
a[i][0] = 3
a[i][-1] = 3
for i in range(1, n - 1):
for j in range(1, m - 1):
if a[i][j] > 4:
flag = False
a[i][j] = 4
else:
flag = False
if flag == True:
print('YES')
for i in range(n):
print(*a[i])
else:
print('NO')
| 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n;
int fir[N], to[N * 2], nxt[N * 2], ecnt;
void add_edge(int u, int v) {
to[++ecnt] = v;
nxt[ecnt] = fir[u];
fir[u] = ecnt;
}
int dep[N];
void dfs(int node, int fa) {
dep[node] = dep[fa] + 1;
for (int e = fir[node]; e; e = nxt[e]) {
if (to[e] == fa) continue;
dfs(to[e], node);
}
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
add_edge(a, b);
add_edge(b, a);
}
dfs(1, 0);
double ans = 0;
for (int i = 1; i <= n; i++) ans += 1.0 / dep[i];
cout << fixed << setprecision(6) << ans;
}
| 2,200 | CPP |
input()
s = input()
i = 0
while i < len(s) and s[i] == '1':
i += 1
print(min(i + 1, len(s)))
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
long long n, m, pp[N], ans[N];
long long t;
struct ANT {
long long pos, dir, id;
bool operator<(const ANT &d) const { return pos < d.pos; }
} ant[N];
long long Get(long long x) {
if (ant[x].dir == -1) {
return (t - ant[x].pos + m - 1) / m;
} else {
return -(t + ant[x].pos) / m;
}
}
int main() {
scanf("%lld%lld%lld", &n, &m, &t);
for (long long i = 0; i < n; ++i) {
scanf("%lld", &ant[i].pos);
--ant[i].pos;
char dd = getchar();
while (dd == ' ') dd = getchar();
ant[i].dir = (dd == 'L') ? -1 : 1;
ant[i].id = i;
}
sort(ant, ant + n);
for (long long i = 0; i < n; ++i)
pp[i] = ((t * ant[i].dir + ant[i].pos) % m + m) % m;
sort(pp, pp + n);
long long bg = 0;
for (long long i = 0; i < n; ++i) bg = (Get(i) + bg) % n;
bg = (bg + n) % n;
for (long long i = bg, j = 0; j < n; ++j, i = (i + 1) % n)
ans[ant[i].id] = pp[j];
for (long long i = 0; i < n; ++i) printf("%lld ", ans[i] + 1);
printf("\n");
return 0;
}
| 2,800 | CPP |
str = input()
l = len(str)
cnt = str.count('a')
sum = 2 * cnt - 1
m = min(l,sum)
print(m) | 800 | PYTHON3 |
def merge(arr):
if len(arr) > 1:
global c
mid = len(arr) // 2
L = arr[:mid]
R = arr[mid:]
merge(L)
merge(R)
i = j = k = 0
while i < len(L) and j < len(R):
if L[i] <=R[j]:
arr[k] = L[i]
i += 1
else:
arr[k] = R[j]
j += 1
c += len(L) - i
k += 1
while i < len(L):
arr[k] = L[i]
i += 1
k += 1
# c += 1
while j < len(R):
arr[k] = R[j]
j += 1
k += 1
for _ in range(int(input())):
c = 0
n=int(input())
a = [int(x) for x in input().split()]
b=int(((n*(n-1))/2)-1)
merge(a)
#print(c)
if(c<=b):
print("YES")
else:
print("NO")
| 900 | PYTHON3 |
a,b=map(int,input().split())
ans=0
while(1):
if(ans//2>=a and ans//3>=b and ans//2+ans//3-ans//6>=a+b):
print(ans)
break
else:
ans+=1
| 1,600 | PYTHON3 |
import sys
import math as mt
input=sys.stdin.buffer.readline
#t=int(input())
#tot=0
t=1
for __ in range(t):
#n=int(input())
n,s=map(int,input().split())
#e=list(map(int,input().split()))
if s>=2*n:
print("YES")
suma=0
for i in range(n-1):
print(2,end=" ")
suma+=2
print(s-suma)
print(1)
else:
print("NO")
| 1,400 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 20 + 1;
int n, m, gn[50][50][50][50];
char boa[N][N];
inline int calc(int mins, int maxs, int mind, int maxd) {
if (mins > maxs || mind > maxd) return 0;
if (gn[mins][maxs][mind][maxd] != -1) return gn[mins][maxs][mind][maxd];
set<int> ex;
for (int x = 0; x < n; x++)
for (int y = 0; y < m; y++) {
int s = x + y, d = x - y + 20;
if (s % 2 == mins % 2 && mins <= s && s <= maxs && mind <= d &&
d <= maxd) {
if (boa[x][y] == 'L')
ex.insert(calc(mins, s - 2, mind, maxd) ^
calc(s + 2, maxs, mind, maxd));
else if (boa[x][y] == 'R')
ex.insert(calc(mins, maxs, d + 2, maxd) ^
calc(mins, maxs, mind, d - 2));
else
ex.insert(
calc(mins, s - 2, mind, d - 2) ^ calc(mins, s - 2, d + 2, maxd) ^
calc(s + 2, maxs, d + 2, maxd) ^ calc(s + 2, maxs, mind, d - 2));
}
}
int mex = 0;
while (ex.count(mex)) ++mex;
return gn[mins][maxs][mind][maxd] = mex;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", boa[i]);
memset(gn, -1, sizeof gn);
int res = calc(0, 40, 0, 40) ^ calc(1, 39, 1, 39);
printf("%s\n", res ? "WIN" : "LOSE");
return 0;
}
| 2,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class A>
istream& operator>>(istream& in, vector<A>& i) {
for (auto& x : i) in >> x;
return in;
};
template <class A, class B>
istream& operator>>(istream& in, pair<A, B>& i) {
in >> i.first >> i.second;
return in;
}
int main() {
int n, m;
cin >> n >> m;
vector<long long> debt(n + 1);
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
debt[u] += w;
debt[v] -= w;
}
vector<tuple<int, int, long long>> answer;
int j = 1;
for (int i = 1; i <= n; i++) {
if (debt[i] <= 0) continue;
while (debt[i]) {
while (debt[j] >= 0 && j <= n) ++j;
long long a = min(debt[i], -debt[j]);
debt[i] -= a;
debt[j] += a;
answer.emplace_back(i, j, a);
}
}
cout << answer.size() << endl;
for (auto& x : answer)
cout << get<0>(x) << ' ' << get<1>(x) << ' ' << get<2>(x) << endl;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
cin >> a;
for (int i = 0; i < a.size(); i++) {
if (a[i] == '.') printf("0");
if (a[i] == '-') {
if (a[i + 1] == '-')
printf("2");
else
printf("1");
a[i + 1] = '?';
}
}
return 0;
}
| 800 | CPP |
x = int(input())
if x%2==1 or x==2:
print('NO')
elif x%2==0:
print('YES') | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void _R(int &x) { scanf("%d", &x); }
void _R(long long &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
void _W(const int &x) { printf("%d", x); }
void _W(const long long &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
const int N = 3e5 + 7, M = 2e6;
const long long mod = 1e9 + 7;
inline int read() {
int ret = 0;
char ch = getchar();
bool f = 1;
for (; !isdigit(ch); ch = getchar()) f ^= !(ch ^ '-');
for (; isdigit(ch); ch = getchar()) ret = (ret << 1) + (ret << 3) + ch - 48;
return f ? ret : -ret;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long ksm(long long a, long long b, long long mod) {
int ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ans;
}
long long inv2(long long a, long long mod) { return ksm(a, mod - 2, mod); }
char str[M], ans[M];
int que[M];
int pos[M];
int main() {
R(str);
int n = strlen(str);
int tot = 0;
int num = 0;
for (int i = 0; i <= n - 1; i++) {
if (str[i] == '0') {
if (num == tot) {
num++;
tot++;
} else {
num++;
}
} else {
tot++;
}
pos[i] = tot;
}
stack<int> s;
s.push(0);
ans[0] = '0';
for (int i = 1; i <= n - 1; i++) {
if (pos[i] == pos[i - 1]) {
ans[s.top()] = '1';
s.pop();
ans[i] = '0';
} else {
ans[i] = '0';
s.push(i);
}
}
for (int i = 0; i <= n - 1; i++) printf("%c", ans[i]);
puts("");
return 0;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
int solve(void) {
string S, U;
cin >> S >> U;
int res = U.length();
for (int i = 0; i < (int)U.length(); i++) S = "." + S + ".";
int szu = U.length(), szs = S.length();
for (int i = 0; i < (int)S.length(); i++) {
if (i + szu == szs) break;
int cnt = 0;
for (int j = 0; j < (int)szu; j++) {
cnt += S[i + j] != U[j];
}
res = min(res, cnt);
}
printf("%d\n", res);
return 0;
}
int main(void) {
solve();
return 0;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using ll = long long;
using ld = long double;
using namespace std;
const int MAXN = 200001;
string s, t;
int c[26];
int n;
void shift(int x) {
cout << x << " ";
string lst = s.substr(n - x);
s = string(lst.rbegin(), lst.rend()) + s.substr(0, n - x);
}
int main() {
ios_base::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(20);
cout.tie(nullptr);
cin.tie(nullptr);
cin >> n;
cin >> s >> t;
for (char ch : s) {
++c[ch - 'a'];
}
for (char ch : t) {
if (--c[ch - 'a'] < 0) {
cout << -1 << "\n";
return 0;
}
}
cout << 3 * n << "\n";
for (int i = n - 1; i >= 0; --i) {
int p = n - 1;
while (s[p] != t[i]) {
--p;
}
shift(n);
shift(p);
shift(1);
}
assert(s == t);
}
| 2,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000;
struct point {
double x, y, v;
int num;
} date[1005];
int cmp(point a, point b) { return a.v < b.v; }
int main() {
int n, numer;
int ans;
while (cin >> n >> numer) {
ans = numer;
for (int i = 0; i < n; i++) {
cin >> date[i].x >> date[i].y >> date[i].num;
date[i].v = sqrt(date[i].x * date[i].x + date[i].y * date[i].y);
ans += date[i].num;
}
if (ans < N) {
cout << "-1" << endl;
continue;
}
sort(date, date + n, cmp);
for (int i = 0; i < n; i++) {
numer += date[i].num;
if (numer >= N) {
printf("%.7lf\n", date[i].v);
goto endW;
}
}
endW:;
}
return 0;
}
| 1,200 | CPP |
n , k = map(int,input().split())
if k <= (n+1)//2:
print((k*2)-1)
else:
# print(int((k - (n + 1) / 2) * 2)+1)
print((2*k)-((n+1)//2)*2)
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long p, k;
long long ans[200100];
int cnt;
int main() {
scanf("%lld %lld", &p, &k);
while (p > 0) {
if (cnt % 2 == 0) {
ans[++cnt] = p % k;
p /= k;
} else {
if (p % k == 0)
ans[++cnt] = 0;
else
ans[++cnt] = k - (p % k);
p = (p - 1) / k + 1;
}
}
printf("%d\n", cnt);
for (int i = 1; i <= cnt; i++) printf("%lld ", ans[i]);
return 0;
}
| 2,000 | CPP |
year=int(input())
while True:
year+=1
if len(list(set(str(year))))==4:
print(year)
break | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
double x, y;
} con[100000 + 5], gen[100000 + 5];
int n, m;
double xxsum, xsum;
double yysum, ysum;
inline double xmulti(Point p1, Point p2, Point p0) {
return (p1.x - p0.x) * (p2.y - p0.y) - (p1.y - p0.y) * (p2.x - p0.x);
}
inline bool in(Point best, Point a, Point b, Point c) {
double a1 = fabs(xmulti(a, b, c)) / 2;
double a2 = fabs(xmulti(a, b, best)) / 2;
double a3 = fabs(xmulti(a, c, best)) / 2;
double a4 = fabs(xmulti(b, c, best)) / 2;
double s = a2 + a3 + a4;
if (fabs(s - a1) <= 1e-3) return 1;
return 0;
}
int main() {
while (~scanf("%d", &n)) {
xxsum = xsum = yysum = ysum = 0.0;
for (int i = 0; i < n; i++) {
scanf("%lf%lf", &gen[i].x, &gen[i].y);
xxsum += gen[i].x * gen[i].x, xsum += gen[i].x * 2;
yysum += gen[i].y * gen[i].y, ysum += gen[i].y * 2;
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%lf%lf", &con[i].x, &con[i].y);
}
double X = xsum / (n * 2.0);
double Y = ysum / (n * 2.0);
bool ok = 0;
Point best;
best.x = X, best.y = Y;
for (int i = 1; i + 1 < m; i++) {
if (in(best, con[0], con[i], con[i + 1])) {
ok = 1;
break;
}
}
if (ok) {
double ans =
xxsum - (xsum * xsum) / (4.0 * n) + yysum - (ysum * ysum) / (4.0 * n);
printf("%.8lf\n", ans);
} else {
double ans = 1000000000000000000.00;
for (int i = 0; i < m; i++) {
int s = i, t = (i + 1) % m;
double dx = con[t].x - con[s].x, dy = con[t].y - con[s].y;
double a = con[s].x, b = con[s].y;
double A = dx * dx + dy * dy,
B = 2 * a * dx + 2 * b * dy - xsum / n * dx - ysum / n * dy;
double k = (-B) / (2 * A);
if (k < 0)
k = 0;
else if (k > 1)
k = 1;
double x = a + dx * k, y = b + dy * k;
double ss = n * (x - xsum / (2.0 * n)) * (x - xsum / (2.0 * n)) +
xxsum - (xsum * xsum) / (4.0 * n) +
n * (y - ysum / (2.0 * n)) * (y - ysum / (2.0 * n)) +
yysum - (ysum * ysum) / (4.0 * n);
ans = min(ans, ss);
}
printf("%.8lf\n", ans);
}
}
return 0;
}
| 0 | CPP |
n,k= input().split()
n=int(n)
k=int(k)
m=list(map(int,input().split()))
x=m[:]
x.sort(reverse=True)
a=[]
for i in range(0,k):
a.append(x[i])
j=0
b=[]
an=0
for i in m:
j+=1
if i in a:
an+=i
a.remove(i)
if(len(a)!=0):
b.append(j)
j=0
b.append(j)
print(an)
print(*b)
| 1,200 | PYTHON3 |
d1,d2,d3=map(int,input().split())
v1=2*(d1+d2)
v2=d1+d2+d3
v3=2*(d2+d3)
v4=2*(d1+d3)
print(min(v1,v2,v3,v4)) | 800 | PYTHON3 |
import atexit
import io
import sys
# _INPUT_LINES = sys.stdin.read().splitlines()
# input = iter(_INPUT_LINES).__next__
# _OUTPUT_BUFFER = io.StringIO()
# sys.stdout = _OUTPUT_BUFFER
#
#
# @atexit.register
# def write():
# sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())
R = lambda : map(int,input().split())
n=int(input())
lst = list(R())
s = ''
rest = 0
for i in range(n):
if lst[i]==0:
rest = rest+1
s = ''
elif lst[i]==1:
if s!='contest':
s = 'contest'
else:
rest = rest+1
s = ''
elif lst[i]==2:
if s!='gym':
s = 'gym'
else:
rest=rest+1
s = ''
else:
if s=='gym':
s = 'contest'
elif s=='contest':
s = 'gym'
elif s=='':
s = ''
print(rest)
| 1,400 | PYTHON3 |
for _ in range(int(input())):
_ = input()
a = set(map(int, input().split()))
print(len(a))
| 1,200 | PYTHON3 |
numOfHits, maxPHit = map(int,input().split(" "))
ithDmg = list(map(int,input().split(" ")))
hitPattern = input()
def getMaxDmg(ithDmg,start,end):
if len(hitPattern) <= maxPHit:
return sum(ithDmg[start:end])
else:
sList = ithDmg[start:end]
sList.sort(reverse = True)
return sum(sList[0:maxPHit])
if maxPHit == numOfHits:
print(sum(ithDmg))
elif numOfHits == 1:
print(sum(ithDmg))
else:
hitPos = 0
totDmg = 0
while hitPos < (len(hitPattern)-1):
if hitPattern[hitPos] == hitPattern[hitPos+1]:
start = hitPos
while hitPos < (len(hitPattern)-1) and hitPattern[hitPos] == hitPattern[hitPos+1]:
hitPos+=1
end = hitPos
totDmg += getMaxDmg(ithDmg,start,end+1)
else:
totDmg += ithDmg[hitPos]
hitPos += 1
if hitPos == (len(hitPattern)-1):
totDmg += ithDmg[hitPos]
print(totDmg)
| 1,300 | PYTHON3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:500000000")
using namespace std;
int A[200005];
int B[200005];
int mod[200005];
int maxR[200005];
map<int, int> q;
int n;
int Tree[4 * 200005];
int ADD[4 * 200005];
void updateTree(int node, int tl, int tr, int l, int r, int add) {
if (l > r) return;
if (l == tl && r == tr) {
ADD[node] += add;
} else {
int tm = (tl + tr) / 2;
updateTree(node << 1, tl, tm, l, min(r, tm), add);
updateTree((node << 1) + 1, tm + 1, tr, max(tm + 1, l), r, add);
Tree[node] = min(Tree[node << 1] + ADD[node << 1],
Tree[(node << 1) + 1] + ADD[(node << 1) + 1]);
}
}
int getMin(int node, int tl, int tr, int l, int r) {
if (l > r) return (2e9 + 100000);
if (l == tl && r == tr)
return Tree[node] + ADD[node];
else {
int tm = (tl + tr) >> 1;
return ADD[node] +
min(getMin(node << 1, tl, tm, l, min(r, tm)),
getMin((node << 1) + 1, tm + 1, tr, max(l, tm + 1), r));
}
}
struct segment {
segment() {}
segment(int L, int R, int value) : L(L), R(R), value(value) {}
int L, R, value;
};
int maxLen = 0, minLen = 0;
segment maxStack[200005], minStack[200005];
int f(int l, int r, int k) {
int L = l;
int R = r;
int res = l - 1;
while (L <= R) {
int m = (L + R) / 2;
int minV = getMin(1, 0, n - 1, m, r);
if (minV <= k)
L = m + 1, res = m;
else
R = m - 1;
}
return res;
}
int main() {
int k, d, i;
int ansL = 0, ansR = 0;
cin >> n >> k >> d;
for (i = 0; i < n; i++) scanf("%d", &A[i]), A[i] += 1e9;
if (d == 0) {
for (i = 0; i < n;) {
int j = i;
while (j < n && A[j] == A[i]) j++;
if (j - 1 - i > ansR - ansL) ansL = i, ansR = j - 1;
i = j;
}
printf("%d %d\n", ansL + 1, ansR + 1);
return 0;
}
for (i = 0; i < n; i++) {
B[i] = A[i] / d;
mod[i] = (A[i] % d + d) % d;
}
q[B[n - 1]] = n - 1;
maxR[n - 1] = n - 1;
for (i = n - 2; i >= 0; i--) {
if (mod[i] == mod[i + 1] &&
(q.find(B[i]) == q.end() || q[B[i]] > maxR[i + 1]))
maxR[i] = maxR[i + 1];
else if (mod[i] == mod[i + 1])
maxR[i] = q[B[i]] - 1;
else
maxR[i] = i;
q[B[i]] = i;
}
ansL = ansR = n - 1;
maxStack[maxLen++] = (segment(n - 1, n - 1, B[n - 1]));
minStack[minLen++] = (segment(n - 1, n - 1, B[n - 1]));
for (int L = n - 2; L >= 0; L--) {
int R = L;
while (maxLen && maxStack[maxLen - 1].value <= B[L]) {
int topValue = maxStack[maxLen - 1].value;
int Left = maxStack[maxLen - 1].L;
int Right = maxStack[maxLen - 1].R;
while (maxLen && maxStack[maxLen - 1].value == topValue) {
Right = max(Right, maxStack[maxLen - 1].L);
maxLen--;
}
updateTree(1, 0, n - 1, Left, Right, B[L] - topValue);
R = max(R, Right);
}
maxStack[maxLen++] = (segment(L, R, B[L]));
R = L;
while (minLen && minStack[minLen - 1].value >= B[L]) {
int topValue = minStack[minLen - 1].value;
int Left = minStack[minLen - 1].L;
int Right = minStack[minLen - 1].R;
while (minLen && minStack[minLen - 1].value == topValue) {
Right = max(Right, minStack[minLen - 1].L);
minLen--;
}
updateTree(1, 0, n - 1, Left, Right, topValue - B[L]);
R = max(R, Right);
}
minStack[minLen++] = (segment(L, R, B[L]));
updateTree(1, 0, n - 1, L + 1, n - 1, -1);
R = f(L + 1, maxR[L], k);
if (R - L >= ansR - ansL) ansL = L, ansR = R;
}
printf("%d %d\n", ansL + 1, ansR + 1);
}
| 3,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
long long a[n + 3][m + 3];
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> a[i][j];
}
}
for (long long k = 0; k < 12; k++) {
vector<long long> ans;
int counter = 0;
for (long long i = 0; i < n; i++) {
int flag = 0;
for (long long j = 0; j < m; j++) {
if ((a[i][j] & (1 << (k))) == 0) {
flag = 1;
ans.push_back(j);
break;
}
}
if (flag == 0) {
for (long long j = 0; j < m; j++) {
if ((a[i][j] & (1 << (k))) > 0) {
counter++;
ans.push_back(j);
break;
}
}
}
}
if (counter % 2 == 1) {
cout << "TAK\n";
for (long long l = 0; l < n; l++) {
cout << ans[l] + 1 << " ";
}
return 0;
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if ((a[i][j] & (1 << (k))) > 0 && (a[i][ans[i]] & (1 << (k))) == 0) {
counter++;
ans[i] = j;
if (counter % 2 > 0) {
cout << "TAK\n";
for (long long l = 0; l < n; l++) {
cout << ans[l] + 1 << " ";
}
return 0;
}
break;
}
}
}
}
cout << "NIE";
return 0;
}
| 1,600 | CPP |
cubes = int(input())
need = 1
i = 1
count = 0
while(cubes>0):
i = i +1
if(cubes-need >=0):
count = count +1
cubes = cubes - need
else:
break
need = need + i
print(count)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct DSU {
vector<pair<int, pair<int, int>>> resParent;
vector<pair<int, int>> resSize;
vector<pair<int, int>> parent;
vector<int> size;
DSU(int n) {
parent = vector<pair<int, int>>(n + 1);
size = vector<int>(n + 1);
for (int i = 1; i <= n; i++) {
make_set(i);
}
}
void make_set(int n) {
parent[n] = {n, 0};
size[n] = 1;
}
pair<int, int> find(int n) {
if (parent[n].first != n) {
pair<int, int> pa = find(parent[n].first);
pa.second ^= parent[n].second;
resParent.emplace_back(n, parent[n]);
parent[n] = pa;
}
return parent[n];
}
bool make_union(int a, int b) {
pair<int, int> pa = find(a);
pair<int, int> pb = find(b);
a = pa.first;
b = pb.first;
int p1 = pa.second;
int p2 = pb.second;
if (a == b) {
return p1 == p2;
}
if (size[a] < size[b]) {
swap(a, b);
}
size[a] += b;
resParent.emplace_back(b, parent[b]);
parent[b] = {a, p1 ^ p2 ^ 1};
resSize.emplace_back(a, b);
return false;
}
};
void solve() {
int n, m;
long long k;
scanf("%d %d %lld", &n, &m, &k);
vector<bool> bi(n + 1);
vector<int> vals(n + 1);
map<pair<int, int>, vector<pair<int, int>>> map;
for (int i = 1; i <= n; i++) {
scanf("%d", &vals[i]);
}
int a, b;
DSU dsu(n);
for (int i = 0; i < m; i++) {
scanf("%d %d", &a, &b);
if (vals[a] != vals[b]) {
map[{min(vals[a], vals[b]), max(vals[a], vals[b])}].push_back({a, b});
continue;
}
if (dsu.make_union(a, b) && !bi[vals[a]]) {
bi[vals[a]] = true;
k--;
}
}
long long ans = 1LL * (k * (k - 1)) / 2;
for (auto& test : map) {
if (bi[test.first.first] || bi[test.first.second]) {
continue;
}
int rp = dsu.resParent.size();
int rs = dsu.resSize.size();
for (auto& arr : test.second) {
if (dsu.make_union(arr.first, arr.second)) {
ans--;
break;
}
}
while (dsu.resSize.size() != rs) {
dsu.size[dsu.resSize.back().first] -= dsu.size[dsu.resSize.back().second];
dsu.resSize.pop_back();
}
while (dsu.resParent.size() != rp) {
dsu.parent[dsu.resParent.back().first] = dsu.resParent.back().second;
dsu.resParent.pop_back();
}
}
printf("%lld\n", ans);
}
int main() {
int t = 1;
while (t--) {
solve();
}
}
| 2,500 | CPP |
def solve(n):
i = 2
while i * i <= n and n % i != 0:
i += 1
if n % i != 0:
i = n
return ((n // i), (n // i) * (i - 1))
for _ in range(int(input())):
n = int(input())
print(*solve(n))
| 1,300 | PYTHON3 |
a = list(input())
b = list(input())
for i in range(len(a)):
if a[i]==b[i]:
a[i]=0
else:
a[i]=1
print(''.join(map(str,a))) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int* arr = new int[n];
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
for (int i = 0; i < n; i++) cout << arr[i] << " ";
return 0;
}
| 900 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a, b, m, r0;
int nxtRand(int r) { return (a * r % m + b) % m; }
int main() {
cin >> a >> b >> m >> r0;
map<int, int> exist;
int curR = r0, ii;
for (ii = 0; !exist.count(nxtRand(curR)); ii++) {
curR = nxtRand(curR);
exist[curR] = ii;
}
curR = nxtRand(curR);
cout << ii - exist[curR] << endl;
}
| 1,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
const int MAXN = 1000010;
long long tt[MAXN], tt2[MAXN];
long long ta[MAXN];
int r[MAXN], a[MAXN];
bool cmp(int x, int y) { return ta[x] < ta[y]; }
int read(int x, int id) {
long long ans;
if (id == 0)
ans = n;
else
ans = -1;
while (x > 0) {
if (id == 0)
ans = min(ans, tt[x]);
else
ans = max(ans, tt[x]);
x -= x & -x;
}
return (int)ans;
}
void update(int x, int val, int id) {
while (x < MAXN) {
if (id == 0)
tt[x] = min(tt[x], (long long)val);
else
tt[x] = max(tt[x], (long long)val);
x += x & -x;
}
}
int l[MAXN];
void update(long long *tt, int x, long long val) {
while (x < MAXN) {
tt[x] += val;
x += x & -x;
}
}
long long read(long long *tt, int x) {
long long ans = 0;
while (x > 0) {
ans += tt[x];
x -= x & -x;
}
return ans;
}
int main() {
while (scanf("%d", &n) == 1) {
for (int i = 0; i < n; i++) scanf("%I64d", &ta[i]);
for (int i = 0; i < n; i++) r[i] = i;
sort(r, r + n, cmp);
int now = 0;
for (int i = 0; i < n; i++) {
if (i == 0 || ta[r[i]] != ta[r[i - 1]]) now++;
a[r[i]] = now;
}
memset(tt, -1, sizeof(tt));
for (int i = 0; i < n; i++) {
l[i] = read(a[i], 1);
update(a[i], i, 1);
}
for (int i = 0; i <= now; i++) tt[i] = n;
for (int i = n - 1; i >= 0; i--) {
r[i] = read(a[i] - 1, 0);
update(a[i], i, 0);
}
memset(tt, 0, sizeof(tt));
memset(tt2, 0, sizeof(tt2));
for (int i = 0; i < n; i++) {
int Llen, Rlen, len;
Llen = i - l[i];
Rlen = r[i] - i;
len = Llen + Rlen - 1;
if (Llen < Rlen) swap(Llen, Rlen);
update(tt, Llen, ta[i] * (len + 1));
update(tt, len + 1, -ta[i] * (len + 1));
update(tt2, Llen, -ta[i]);
update(tt2, len + 1, ta[i]);
if (Rlen <= Llen - 1) {
update(tt, Rlen, Rlen * ta[i]);
update(tt, Llen, -(Rlen)*ta[i]);
}
if (Rlen - 1 >= 1) {
update(tt2, 1, ta[i]);
update(tt2, Rlen, -ta[i]);
}
}
int m;
scanf("%d", &m);
while (m--) {
int num;
scanf("%d", &num);
long long num1 = read(tt, num);
long long num2 = read(tt2, num);
long long ans = num1 + num2 * num;
printf("%.15f\n", ans * 1.0 / (n + 1 - num));
}
puts("");
}
return 0;
}
| 2,500 | CPP |
#include <bits/stdc++.h>
const int MOD = 1e9 + 7;
using namespace std;
template <typename T, typename P>
void reset(T array[], int size, P value) {
for (int i = 0; i < (size); i++) array[i] = value;
}
template <typename T, typename P>
void reset(T *array, int rows, int cols, P value) {
for (int i = 0; i < (rows); i++)
for (int j = 0; j < (cols); j++) *(array + i * cols + j) = value;
}
template <typename T>
void reset(T v[], int size) {
for (int i = 0; i < size; i++) v[i].clear();
}
template <typename T>
T maxArr(T array[], int ending) {
T res = array[0];
for (int i = 0; i < (ending); i++) res = max(array[i], res);
return res;
}
template <typename T>
T minArr(T array[], int ending) {
T res = array[0];
for (int i = 0; i < (ending); i++) res = min(array[i], res);
return res;
}
template <typename T, typename P = long long int>
P sumArr(T array[], int ending) {
P res = 0;
for (int i = 0; i < (ending); i++) res = res + array[i];
return res;
}
template <typename T, typename P = long long int>
P sumArr(T array[], int ending, P mod) {
P res = 0;
for (int i = 0; i < (ending); i++) res = (res + array[i]) % mod;
return res;
}
int stringToNum(string &number) {
int num = 0;
int mul = 1;
for (int i = ((int)(number.size())) - 1; i >= 0; --i) {
num = num + (number[i] - '0') * mul;
mul = mul * 10;
}
return num;
}
int bit(long long int num) {
int res = 0;
for (long long int i = 0; (1ll << i) <= num; ++i) res = i;
return res;
}
const int MAXN = 400 + 10;
const int MAXM = 400 + 10;
const int MAXLOG = 18;
const int MY_MAX = 1000000;
int t, n, k;
std::vector<pair<int, int> > adj[MAXN];
int dp1[MAXN][MAXN];
int dp2[MAXN][MAXN];
int temp1[MAXN];
int temp2[MAXN];
vector<int> poi1[MAXN];
vector<int> poi2[MAXN];
std::vector<int> vec1[MAXN][MAXN];
std::vector<int> vec2[MAXN][MAXN];
unordered_set<int> myset;
int subSize[MAXN];
void dfs1(int u, int par) {
subSize[u] = 1;
for (auto it : adj[u]) {
int v = it.first;
if (v == par) continue;
dfs1(v, u);
subSize[u] = subSize[v] + subSize[u];
}
}
void dfs(int u, int par, int w) {
dp1[u][0] = 0;
dp2[u][0] = 0;
dp1[u][1] = ((int)(adj[u].size()));
for (auto it : adj[u]) vec1[u][1].push_back(it.second);
for (auto it : adj[u]) {
int v = it.first;
int w1 = it.second;
if (v == par) continue;
dfs(v, u, w1);
reset(temp1, MAXN, MY_MAX);
reset(temp2, MAXN, MY_MAX);
reset(poi1, MAXN);
reset(poi2, MAXN);
for (int i = 0; i < (k + 1); i++) temp1[i] = dp1[u][i];
for (int i = 0; i < (k + 1); i++) temp2[i] = dp2[u][i];
for (int i = 0; i < (k + 1); i++) poi1[i] = vec1[u][i];
for (int i = 0; i < (k + 1); i++) poi2[i] = vec2[u][i];
for (int i = 1; i <= (k); i++)
for (int j = (1); j <= int(k - i); j++)
if (temp1[i + j] > dp1[u][i] + dp1[v][j] - 2) {
temp1[i + j] = min(temp1[i + j], dp1[u][i] + dp1[v][j] - 2);
poi1[i + j].clear();
myset.clear();
for (auto it : vec1[u][i])
if (it != w1) poi1[i + j].push_back(it), myset.insert(it);
for (auto it : vec1[v][j])
if (!((myset).find((it)) != (myset).end()) and it != w1)
poi1[i + j].push_back(it);
}
for (int i = 0; i < (k + 1); i++)
if (temp2[i] > dp1[v][i] or temp2[i] > dp2[v][i]) {
poi2[i].clear();
if (dp1[v][i] < dp2[v][i])
poi2[i] = vec1[v][i];
else
poi2[i] = vec2[v][i];
temp2[i] = min(dp1[v][i], dp2[v][i]);
}
for (int i = 0; i < (k + 1); i++) {
dp1[u][i] = temp1[i];
dp2[u][i] = temp2[i];
vec1[u][i] = poi1[i];
vec2[u][i] = poi2[i];
}
}
if (par != -1) {
dp1[u][subSize[u]] = 1;
vec1[u][subSize[u]].clear();
vec1[u][subSize[u]].push_back(w);
} else
dp1[u][subSize[u]] = 0;
}
int sol() {
reset(&dp1[0][0], MAXN, MAXN, MY_MAX);
reset(&dp2[0][0], MAXN, MAXN, MY_MAX);
dfs1(0, -1);
dfs(0, -1, 0);
return 0;
}
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k;
for (int i = 0; i < (n - 1); i++) {
int u, v;
cin >> u >> v;
u--;
v--;
adj[u].push_back(make_pair(v, i + 1));
adj[v].push_back(make_pair(u, i + 1));
}
sol();
cout << min(dp1[0][k], dp2[0][k]) << endl;
if (dp1[0][k] < dp2[0][k])
for (auto it : vec1[0][k]) cout << it << " ";
else
for (auto it : vec2[0][k]) cout << it << " ";
cout << endl;
return 0;
}
| 2,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 3e6 + 7;
const int mod = 998244353;
const double eps = 1e-7;
int ca = 1;
int a[4];
int x, y;
void solve() {
scanf("%d%d", &x, &y);
int ans = 0;
a[0] = a[1] = a[2] = y;
while (a[0] < x || a[1] < x || a[2] < x) {
sort(a, a + 3);
a[0] = a[2] + a[1] - 1;
ans++;
}
cout << ans << endl;
}
int main() {
int t = 1;
while (t--) solve();
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a;
cin >> a;
string array;
cin >> array;
n = array.size();
map<int, int> mapp;
vector<int> line(n);
for (int i = 0; i < n; i++) line[i] = array[i] - '0';
vector<int> partial(n + 1, 0);
for (int i = 0; i < n; i++) partial[i + 1] = partial[i] + line[i];
for (int i = 1; i < n + 1; i++)
for (int j = 0; j < i; j++) {
if (mapp.find(partial[i] - partial[j]) == mapp.end())
mapp[partial[i] - partial[j]] = 1;
else
mapp[partial[i] - partial[j]] += 1;
}
long long result = 0;
if (a == 0) {
int zero = 0, nonzero = 0;
if (mapp.find(0) != mapp.end()) zero = mapp[0];
map<int, int>::iterator it = mapp.begin();
while (it != mapp.end()) {
if ((*it).first != 0) nonzero += (*it).second;
it++;
}
if (zero != 0) result = zero * 1ll * zero + 2 * zero * 1ll * nonzero;
cout << result;
return 0;
}
for (int i = 1; i * i <= a; i++) {
if (((a % i) == 0) && (mapp.find(i) != mapp.end()) &&
(mapp.find(a / i) != mapp.end())) {
if (i * i == a)
result += mapp[i] * 1ll * mapp[i];
else
result += 2 * mapp[i] * 1ll * mapp[a / i];
}
}
cout << result;
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e4 + 7, mod = 998244353, inf = 1e9, MAXN = 1e6 + 7;
const double eps = 1e-9;
mt19937 rnd(time(0));
int n;
vector<int> gr[maxn];
int p[maxn], dist[maxn];
int used[maxn];
int cycle[maxn];
vector<int> path;
void dfs(int u, int pr, int d) {
used[u] = 1;
dist[u] = d;
p[u] = pr;
for (auto v : gr[u]) {
if (v == pr) continue;
if (!used[v]) {
dfs(v, u, d + 1);
} else if (dist[v] < dist[u]) {
int pp = u;
while (pp != v) {
path.push_back(pp);
cycle[pp] = 1;
pp = p[pp];
}
path.push_back(v);
cycle[v] = 1;
}
}
}
int upper[maxn];
int down[maxn];
int sizz[maxn];
int func[maxn];
int dfs1(int u, int pr, int d) {
p[u] = pr;
sizz[u] = 1;
dist[u] = d;
for (auto v : gr[u]) {
if (cycle[v] || v == pr) continue;
sizz[u] += dfs1(v, u, d + 1);
}
return sizz[u];
}
int dow(int u, int pr) {
down[u] = sizz[u];
for (auto v : gr[u]) {
if (cycle[v] || v == pr) continue;
down[u] += dow(v, u);
}
return down[u];
}
int start;
void upp(int u, int pr) {
if (pr == u) {
upper[u] = 1;
} else {
upper[u] = upper[pr] + sizz[start] - sizz[u] + 1 + down[pr] - down[u] -
sizz[u] - 1;
}
for (auto v : gr[u]) {
if (cycle[v] || v == pr) continue;
upp(v, u);
}
}
int get(int u, int pr) {
func[u] = upper[u] + down[u] - 1 + (dist[u] + 1) * (n - sizz[start]);
for (auto v : gr[u]) {
if (cycle[v] || v == pr) continue;
func[u] = max(func[u], get(v, u));
}
return func[u];
}
vector<int> dp[2];
int pref[2 * maxn];
void solve() {
cin >> n;
for (int i = 0; i < n; ++i) {
int a, b;
cin >> a >> b;
gr[a].push_back(b);
gr[b].push_back(a);
}
dfs(0, 0, 0);
for (int i = 0; i < n; ++i) {
if (!cycle[i]) continue;
dfs1(i, i, 0);
start = i;
dow(i, i);
upp(i, i);
get(i, i);
}
vector<int> have;
for (auto v : path) have.push_back(v);
for (auto v : path) have.push_back(v);
for (int i = 0; i < have.size(); ++i) {
pref[i + 1] = pref[i] + sizz[have[i]];
}
dp[0].resize(have.size());
dp[1].resize(have.size());
for (int i = 0; i < have.size(); ++i) {
int v = have[i];
dp[0][i] = func[v];
}
for (int len = 2; len <= have.size() / 2; ++len) {
for (int l = 0; l + len - 1 < have.size(); ++l) {
int r = l + len - 1;
long long L = dp[0][l + 1] + n - pref[r + 1] + pref[l] + down[have[l]];
long long R = dp[0][l] + n - pref[r + 1] + pref[l] + down[have[r]];
dp[1][l] = max(L, R);
}
swap(dp[0], dp[1]);
}
int ans = 0;
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < have.size(); ++j) {
ans = max(ans, dp[i][j]);
}
}
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.precision(20);
cout << fixed;
int t = 1;
for (int i = 0; i < t; ++i) {
solve();
}
return 0;
}
| 2,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, ans = 0, x, sump = 0, sumn = 0;
int n;
cin >> n;
vector<int> dp1n(n);
vector<int> dp1p(n);
vector<int> dp2n(n);
vector<int> dp2p(n);
vector<int> arr;
if (n == 0) {
cout << 0 << endl;
return 0;
}
ans = 0;
for (int i = 0; i < n; i++) {
cin >> x;
arr.push_back(x);
sump += x;
sumn += -1 * x;
}
ans = max(sump, ans);
ans = max(sumn, ans);
dp1n[0] = -1 * arr[0];
dp1p[0] = arr[0];
for (int i = 1; i < n; i++) {
dp1n[i] = dp1n[i - 1] + -1 * arr[i];
dp1p[i] = max(dp1n[i - 1], dp1p[i - 1]) + arr[i];
}
dp2n[n - 1] = -1 * arr[n - 1];
dp2p[n - 1] = arr[n - 1];
for (int i = n - 2; i >= 0; i--) {
dp2n[i] = dp2n[i + 1] + -1 * arr[i];
dp2p[i] = max(dp2n[i + 1], dp2p[i + 1]) + arr[i];
}
for (int i = 0; i < n; i++) {
ans = max(ans, dp2p[i] + dp1p[i] - arr[i]);
}
cout << ans << endl;
return 0;
}
| 1,800 | CPP |
n=int(input())
sum=0
for i in range(n):
opinion=input().split()
a,b,c=int(opinion[0]),int(opinion[1]),int(opinion[2])
if a+b+c>=2:
sum+=1
else:
sum=sum
print(sum) | 800 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
const long long INF = 0x3f3f3f3f3f3f3f3f;
const long long llinf = LLONG_MAX;
const int inf = INT_MAX;
const int nmax = 2e5 + 5;
const int mod = 1e9 + 7;
using namespace std;
int n, x, ans[nmax], bit[nmax], i, j;
void upd(int i) {
for (; i <= n; i += i & (-i)) bit[i]++;
}
int qry(int i) {
int rs = 0;
for (; i >= 1; i -= i & (-i)) rs += bit[i];
return rs;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cerr.tie(0);
cout.tie(0);
cin >> n;
for (i = 1; i <= n; i++) {
cin >> x;
x++;
ans[i] = x - 1 - qry(x);
upd(x);
}
memset(bit, 0, sizeof(bit));
for (i = 1; i <= n; i++) {
cin >> x;
x++;
ans[i] += x - 1 - qry(x);
upd(x);
}
for (i = n; i >= 1; i--) {
ans[i - 1] += ans[i] / (n - i + 1);
ans[i] %= (n - i + 1);
}
memset(bit, 0, sizeof(bit));
for (i = 1; i <= n; i++) {
x = 0;
for (j = (1 << 20); j >= 1; j >>= 1)
if (x + j <= n && x + j - qry(x + j) <= ans[i]) x += j;
cout << x << " ";
upd(x + 1);
}
return 0;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
int i, j, t, n, m, l, r, k, z, y, x;
int a[200005], b[200005], c[400005];
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
scanf("%d", &m);
for (i = 1; i <= m; i++) scanf("%d", &b[i]);
sort(a + 1, a + n + 1);
sort(b + 1, b + m + 1);
for (i = 1; i <= n; i++) c[i] = a[i];
for (i = 1; i <= m; i++) c[i + n] = b[i];
sort(c + 1, c + n + m + 1);
l = r = 1;
x = 3 * n;
y = 3 * m;
for (i = 1; i <= n + m; i++) {
while (l <= n && a[l] <= c[i]) l++;
while (r <= m && b[r] <= c[i]) r++;
t = (l - 1) * 2 + (n - l + 1) * 3;
k = (r - 1) * 2 + (m - r + 1) * 3;
if (t - k > x - y || (t > x && t - k == x + y)) {
x = t;
y = k;
}
}
printf("%d:%d\n", x, y);
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
int d(int n, int x, int i) {
if (!i) return n / x;
int m = n / x;
if (n % x >= i) m++;
return m;
}
int main() {
int n, ans = 0;
scanf("%d", &n);
if (n <= 4)
printf("%d\n", n * (n - 1) / 2);
else {
int m = 2 * n, x = 1;
while (m >= 10) {
x = x * 10;
m = m / 10;
}
m = n / x;
int z = n % x;
ans = x / 2 * m * m;
if (z >= x / 2) {
ans += (2 * m + 1) * min(x / 2 - 1, z - x / 2 + 1);
ans += m * (z - 2 * min(x / 2 - 1, z - x / 2 + 1));
} else {
ans += m * z;
}
printf("%d\n", ans);
}
return 0;
}
| 1,800 | CPP |
n=int(input())
ls=list(map(int,input().rstrip().split()))
m=int(input())
z=10**5+1
li=[0]*z
lx=list(map(int,input().split()))
for i in range(n):
li[ls[i]]=i
x=0
y=0
for i in range(m):
x+=li[lx[i]]+1
y+=n-li[lx[i]]
print(x,y)
| 1,100 | PYTHON3 |
t = int(input())
for i in range(t) :
a, b, c, d = [int(tmp) for tmp in input().split()]
time = 0
if b >= a :
print(b)
elif d >= c :
print("-1")
else :
a -= b
s = c-d
if a%s == 0 :
p = a//s
else :
p = (a//s) + 1
print(b + p*c) | 900 | PYTHON3 |
a,b = map(int,input().split(' '))
i = 0
if(a>b):
i=b
else:
i=a
if(i%2==0):
print("Malvika")
else:
print("Akshat") | 900 | PYTHON3 |
x = int(input())
for i in range(1,x+1):
if(i%2==0):
print("I love ",end='')
else:
print("I hate ",end='')
if(i==x):
print("it ",end='')
else:
print("that ",end='')
print() | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long k;
int main() {
scanf("%d%d%I64d", &n, &m, &k);
--m;
if (k < n)
printf("%I64d %d\n", k + 1, 1);
else {
k -= n;
int t = k / m;
printf("%d %d\n", n - t, t & 1 ? m + 1 - k % m : 2 + k % m);
}
return 0;
}
| 1,300 | CPP |
'''
N, i = int(input()), 1
while N > i:
N, i = N - i, i + 1
print(N)
'''
#or same thing in other way
n=int(input())
k=int((-1+(1+8*n)**0.5)/2)
m=k*(k+1)//2
print([n-m,k][n==m])
| 1,000 | PYTHON3 |
n=int(input())
a=list()
b=list()
for i in range(n):
b=input()
a.append(b)
count=0
for i in a:
if(i.count('1')>=2):
count=count+1
print(count) | 800 | PYTHON3 |
n=int(input())
s=input()
c=s.count('8')
x=n//11
if c>=x:
print(n//11)
elif c < x:
print(c)
else:
print(0) | 800 | PYTHON3 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
char s1[2000 + 1], s2[500 + 1];
int C[2000], P[2000];
int D[2000 + 1][2000 + 1];
int N, M;
int main() {
scanf("%s%s", s1, s2);
N = strlen(s1), M = strlen(s2);
int i, j;
for (i = 0; i < N; i++) {
for (j = 0; j < M; j++) {
while (i + j + C[i] < N && s1[i + j + C[i]] != s2[j]) C[i]++;
if (i + j + C[i] == N) break;
if (j == M - 1) P[i] = i + j + C[i] + 1;
}
if (j < M) C[i] = -1, P[i] = -1;
}
for (i = 0; i <= N; i++) {
for (j = 0; j <= N; j++)
if (N - i < j) D[i][j] = -9999999;
}
for (i = N - 1; i >= 0; i--) {
if (P[i] == -1)
continue;
else {
if (C[i] == 0)
D[i][0] = D[P[i]][0] + 1;
else
D[i][0] = D[i + 1][0];
}
for (j = 1; j <= N; j++) {
if (N - i < j) {
continue;
}
D[i][j] = D[i + 1][j];
if (D[i][j] < D[i + 1][j - 1]) D[i][j] = D[i + 1][j - 1];
if (P[i] == -1) continue;
if (j - C[i] >= 0 && D[i][j] < D[P[i]][j - C[i]] + 1)
D[i][j] = D[P[i]][j - C[i]] + 1;
}
}
for (i = 0; i <= N; i++) {
printf("%d ", D[0][i]);
}
return 0;
}
| 2,200 | CPP |
t = int(input())
result = []
for _ in range(t):
n = int(input())
ones = n // 2
if n % 2 == 0:
result.append("1"*ones)
else:
result.append("7" + "1"*(ones-1))
for i in result:
print(i) | 900 | PYTHON3 |
import sys
string = input()
if('H' in string or 'Q' in string or '9' in string):
print("YES")
else:
print("NO") | 900 | PYTHON3 |
#include <cstdio>
#include <algorithm>
typedef long long ll;
const int Maxn=200000;
const int Maxk=18;
const ll Inf=0x3f3f3f3f3f3f3f3fll;
struct Node{
int num,w,v,id;
friend bool operator <(Node a,Node b){
if(a.v==b.v){
return a.w<b.w;
}
return a.v>b.v;
}
}a[Maxn+5];
int n,q;
int pos[Maxn+5];
ll num[Maxn+5];
struct Segment_Node{
ll v[Maxk+1],w[Maxk+1],c[Maxk+5];
}seg[Maxn<<2|5];
void get_val(Segment_Node &val,int id){
for(int i=1;i<=Maxk;i++){
val.v[i]=val.w[i]=0;
val.c[i]=Inf;
if(a[id].w<(1<<(i-1))){
val.v[i]=1ll*num[id]*a[id].v;
val.w[i]=1ll*num[id]*a[id].w;
}
else if(a[id].w<(1<<i)&&num[id]>0){
val.c[i]=a[id].w;
}
}
}
void push_up(int root){
for(int i=1;i<=Maxk;i++){
seg[root].v[i]=seg[root<<1].v[i]+seg[root<<1|1].v[i];
seg[root].w[i]=seg[root<<1].w[i]+seg[root<<1|1].w[i];
seg[root].c[i]=std::min(seg[root<<1].c[i],seg[root<<1].w[i]+seg[root<<1|1].c[i]);
}
}
void build(int root=1,int left=1,int right=n){
if(left==right){
get_val(seg[root],left);
return;
}
int mid=(left+right)>>1;
build(root<<1,left,mid);
build(root<<1|1,mid+1,right);
push_up(root);
}
void update(int x,int a,int root=1,int left=1,int right=n){
if(left==right){
num[left]+=a;
get_val(seg[root],left);
return;
}
int mid=(left+right)>>1;
if(x<=mid){
update(x,a,root<<1,left,mid);
}
else{
update(x,a,root<<1|1,mid+1,right);
}
push_up(root);
}
void get_cur_dep(ll v,int &dep){
while(dep>1&&(1<<(dep-2))>v){
dep--;
}
}
ll query(ll &v,int &dep,int root=1,int left=1,int right=n){
if(left==right){
ll tmp=std::min(num[left],v/a[left].w);
v-=tmp*a[left].w;
get_cur_dep(v,dep);
return tmp*a[left].v;
}
if(seg[root].w[dep]<=v){
ll ans=seg[root].v[dep];
v-=seg[root].w[dep];
get_cur_dep(v,dep);
return ans;
}
if(seg[root].w[dep-1]<=v&&v<seg[root].c[dep-1]){
ll ans=seg[root].v[dep-1];
v-=seg[root].w[dep-1];
get_cur_dep(v,dep);
return ans;
}
int mid=(left+right)>>1;
return query(v,dep,root<<1,left,mid)+query(v,dep,root<<1|1,mid+1,right);
}
int main(){
scanf("%d%d",&n,&q);
for(int i=1;i<=n;i++){
scanf("%d%d%d",&a[i].num,&a[i].w,&a[i].v);
a[i].id=i;
}
std::sort(a+1,a+1+n);
for(int i=1;i<=n;i++){
pos[a[i].id]=i;
num[i]=a[i].num;
}
build();
for(int t=1;t<=q;t++){
int op;
scanf("%d",&op);
if(op==1||op==2){
op=(op==1?1:-1);
int x,v;
scanf("%d%d",&v,&x);
update(pos[x],op*v);
}
else{
ll w;
scanf("%lld",&w);
int dep=18;
get_cur_dep(w,dep);
printf("%lld\n",query(w,dep));
}
}
return 0;
}
| 3,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
void printarr(int arr[], int n) {
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << endl;
}
void printarr(vector<int> arr) {
int n = arr.size();
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << endl;
}
int gcd(int a, int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int test, ti, n, i, x, y, d, ans, sz, nitr, slc, inp, lrg;
cin >> n;
nitr = n * n;
multiset<int> mp;
multiset<int>::reverse_iterator itr;
vector<int> v;
while (nitr--) {
cin >> inp;
mp.insert(inp);
}
while (!mp.empty()) {
d = *mp.crbegin();
v.push_back(d);
mp.insert(d);
for (auto& x : v) {
mp.erase(mp.find(gcd(x, d)));
mp.erase(mp.find(gcd(x, d)));
}
}
printarr(v);
return 0;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 4000;
int k[4000];
int main() {
int n;
cin >> n;
int a[n];
int b[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
k[i] = a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
k[i + n] = b[i];
}
sort(k, k + 2 * n);
bool c = true;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (binary_search(k, k + 2 * n, a[i] ^ b[j])) {
c != c;
}
}
}
if (c) {
cout << "Karen";
} else {
cout << "Koyomi";
}
}
| 1,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, cases, t, ans;
string s, s2, s3;
long long int ar[(int)(1e6 + 10)], ar2[(int)(1e6 + 10)], cum[(int)(1e6 + 10)];
void brainfuck();
int main() {
ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
cout.tie(NULL);
brainfuck();
return 0;
}
void brainfuck() {
cin >> n >> m;
long long int sum = 0;
int marker = 0;
for (int i = 1; i <= m; i++) {
cin >> ar[i];
cum[i] = cum[i - 1] + ar[i];
if (ar[i] + i - 1 > n) marker = 1;
}
if (cum[m] < n || marker) {
cout << "-1";
return;
}
int pre = n;
ar2[m] = n - ar[m] + 1;
for (long long int i = m - 1; i >= 1; i--) {
ar2[i] = max(min(cum[i - 1] + 1, min(pre - ar[i + 1], pre - ar[i])), i);
pre = ar2[i] + ar[i] - 1;
if (ar2[i] < 1) {
cout << "-1";
return;
}
}
for (int i = 1; i <= m; i++) cout << ar2[i] << " ";
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 10;
int n, m, dp[MAXN], level[MAXN];
int dist[MAXN], val[MAXN * 3];
int local[MAXN], answer[MAXN];
vector<pair<int, int>> adj[MAXN], nex[MAXN];
bool cut_edge[MAXN * 3];
bool mark[MAXN];
void dfs_cut_edge(int v, int par = 0) {
dp[v] = level[v] = level[par] + 1;
mark[v] = true;
for (auto i : adj[v]) {
if (!mark[i.first]) {
dfs_cut_edge(i.first, v);
dp[v] = min(dp[v], dp[i.first]);
if (dp[i.first] > level[v]) cut_edge[i.second] = true;
} else if (i.first != par)
dp[v] = min(dp[v], level[i.first]);
}
}
void bfs(int v) {
queue<int> q;
dist[v] = 1;
q.push(v);
while (q.size()) {
int tp = q.front();
q.pop();
for (auto i : adj[tp]) {
if (!dist[i.first]) {
dist[i.first] = dist[tp] + 1;
q.push(i.first);
}
if (dist[i.first] == (dist[tp] + 1)) nex[tp].push_back(i);
}
}
}
void dfs_(int v, int par = 0) {
mark[v] = true;
for (auto i : nex[v]) {
if (!mark[i.first]) dfs_(i.first, v);
dp[v] = max(dp[v], dp[i.first] + 1);
if (cut_edge[i.second]) val[i.second] = dp[i.first] + 1;
}
}
inline int get_dist(int l, int r, int len) {
if (l > r) return len - l + r;
return r - l;
}
inline int get_(pair<int, int> p, int id, int len) {
return p.first + get_dist(p.second, id, len);
}
void dfs(int v, int par = 0) {
mark[v] = true;
vector<int> cycle;
cycle.push_back(v);
while (true) {
bool re = false;
for (auto i : adj[cycle.back()])
if (!mark[i.first] && !cut_edge[i.second]) {
cycle.push_back(i.first);
mark[i.first] = true;
re = true;
break;
}
if (!re) break;
}
for (auto v : cycle)
for (auto e : adj[v])
if (cut_edge[e.second]) local[v] = max(local[v], val[e.second]);
int len = cycle.size();
deque<pair<int, int>> deq;
auto stackf = [&](int happy) {
for (int i = happy; i; i--) {
int v = cycle[len - i];
pair<int, int> me(local[v], len - i);
while (deq.size() && get_(me, 0, len) >= get_(deq.back(), 0, len))
deq.pop_back();
deq.push_back(me);
}
for (int i = 0; i < len; i++) {
while (deq.size() && get_dist(deq.front().second, i, len) > happy)
deq.pop_front();
if (deq.size())
dp[cycle[i]] = max(dp[cycle[i]], get_(deq.front(), i, len));
if (i == (len - 1)) break;
int v = cycle[i];
pair<int, int> me(local[v], i);
while (deq.size() && get_(me, i + 1, len) >= get_(deq.back(), i + 1, len))
deq.pop_back();
deq.push_back(me);
}
};
stackf(len / 2);
deq.clear();
reverse(cycle.begin(), cycle.end());
stackf((len - 1) / 2);
for (auto i : cycle) answer[i] = max(dp[i], local[i]);
for (auto i : cycle) {
int id = 0, mx = 0, smx = 0;
for (auto e : adj[i])
if (cut_edge[e.second])
if (val[e.second] > mx) {
mx = val[e.second];
id = e.first;
}
for (auto e : adj[i])
if (cut_edge[e.second] && e.first != id) smx = max(smx, val[e.second]);
for (auto e : adj[i])
if (cut_edge[e.second] && !mark[e.first]) {
if (e.first == id) {
val[e.second] = max(dp[i], smx) + 1;
dfs(e.first, i);
} else {
val[e.second] = max(dp[i], mx) + 1;
dfs(e.first, i);
}
}
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back({v, i});
adj[v].push_back({u, i});
}
dfs_cut_edge(1);
bfs(1);
memset(mark, 0, sizeof(mark));
memset(dp, 0, sizeof(dp));
dfs_(1);
memset(mark, 0, sizeof(mark));
memset(dp, 0, sizeof(dp));
dfs(1);
for (int i = 1; i <= n; i++) cout << answer[i] << ' ';
return 0;
}
| 2,900 | CPP |
n = int(input())
L = [int(x) for x in input().split()]
L.sort()
s = 0
for i in range((n//2)):
s += (L[i]+L[-1-i])*(L[i]+L[-1-i])
print(s) | 900 | PYTHON3 |
#include <bits/stdc++.h>
int main() {
int n, i;
scanf("%d", &n);
int sum[n], a, b, c, d;
for (i = 0; i < n; i++) {
scanf("%d %d %d %d", &a, &b, &c, &d);
sum[i] = a + b + c + d;
}
int k = 0;
for (i = 1; i < n; i++) {
if (sum[0] < sum[i]) k++;
}
printf("%d\n", k + 1);
return 0;
}
| 800 | CPP |
q = int(input())
l = []
r = []
d = []
for i in range(q):
x,y,z = [int(a) for a in input().split() ]
l.append(x)
r.append(y)
d.append(z)
def FindMinPos(l,r,d,q):
resTab = []
for i in range(q):
if d[i] >= l[i] and d[i] <= r[i]:
remain = r[i] % d[i]
if remain == 0:
res = r[i] + d[i]
else:
res = r[i] +( d[i] -remain )
else:
res = d[i]
resTab.append(res)
for x in resTab:
print(x)
FindMinPos(l,r,d,q)
| 1,000 | PYTHON3 |
def main():
t = int(input())
for i in range(t):
a, b = map(int, input().split())
for i in range(a):
for j in range(b):
if i == 0 and j == 0:
print("W", end="")
else:
print("B", end="")
print()
if __name__ == "__main__":
main() | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
map<string, vector<string>> adj;
int maxh = 0;
void dfs(string v, int h = 1) {
maxh = max(maxh, h);
for (auto i : adj[v]) dfs(i, h + 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
string a, r, b;
cin >> a >> r >> b;
for (auto &x : a) x = tolower(x);
for (auto &x : b) x = tolower(x);
adj[b].push_back(a);
}
dfs("polycarp");
cout << maxh;
}
| 1,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chmax(T& a, T b) {
a = max(a, b);
}
template <typename T>
struct BIT {
int n;
vector<T> dat;
BIT(int n = 0) { initialize(n); }
void initialize(int nin) {
n = nin;
dat.resize(n, 0);
}
T sum(int i) {
T s = 0;
while (i >= 0) {
s += dat[i];
i = (i & (i + 1)) - 1;
}
return s;
}
T sum_between(int i, int j) { return sum(j) - sum(i - 1); }
void plus(int i, T x) {
while (i < n) {
dat[i] += x;
i |= i + 1;
}
}
int lower_bound(T x) {
if (x < 0) return -1;
int ret = -1;
int k = 1;
while (2 * k <= n) k <<= 1;
for (; k > 0; k >>= 1) {
if (ret + k < n && dat[ret + k] < x) {
x -= dat[ret + k];
ret += k;
}
}
return ret + 1;
}
};
int main() {
int N, Q;
cin >> N >> Q;
vector<int> A(N);
for (int i = 0; i < N; i++) scanf("%d", &A[i]);
vector<int> L(Q), R(Q);
vector<vector<pair<int, int>>> R2LI(N);
for (int i = 0; i < Q; i++) {
scanf("%d %d", &L[i], &R[i]);
L[i]--;
R[i]--;
R2LI[R[i]].emplace_back(L[i], i);
}
vector<vector<int>> ans(Q);
for (int t = 0; t < 2; t++) {
vector<int> up;
BIT<int> bit(N);
vector<vector<int>> r2v(N + 1, {-1});
for (int i = 0; i < N; i++) {
while (up.size() && A[up.back()] < A[i]) {
bit.plus(up.back(), 1);
up.pop_back();
}
up.push_back(i);
int pt = partition_point(up.begin(), up.end(),
[&](int j) { return A[j] != A[i]; }) -
up.begin() - 1;
if (pt >= 0) {
int x = up[pt];
if (bit.sum(x - 1) > 0) {
int l = bit.lower_bound(bit.sum(x - 1));
int m = *upper_bound(up.begin(), up.end(), l);
r2v[i] = {l, m, i};
}
}
}
vector<int> mx = {-1};
for (int i = 0; i < N; i++) {
chmax(mx, r2v[i]);
for (auto [ql, idx] : R2LI[i])
if (ql <= mx[0]) ans[idx] = mx;
}
for (int& a : A) a *= -1;
}
{
vector<int> up, dn;
BIT<int> bit(N);
vector<int> cnt(N);
vector<vector<int>> r2v(N + 1, {-1});
for (int i = 0; i < N; i++) {
while (up.size() && A[up.back()] < A[i]) {
int j = up.back();
cnt[j]++;
if (cnt[j] == 2) bit.plus(j, 1);
up.pop_back();
}
up.push_back(i);
while (dn.size() && A[dn.back()] > A[i]) {
int j = dn.back();
cnt[j]++;
if (cnt[j] == 2) bit.plus(j, 1);
dn.pop_back();
}
dn.push_back(i);
int pt_up = partition_point(up.begin(), up.end(),
[&](int j) { return A[j] != A[i]; }) -
up.begin() - 1;
int pt_dn = partition_point(dn.begin(), dn.end(),
[&](int j) { return A[j] != A[i]; }) -
dn.begin() - 1;
if (pt_up >= 0 && pt_dn >= 0) {
int x = min(up[pt_up], dn[pt_dn]);
if (bit.sum(x - 1) > 0) {
int l = bit.lower_bound(bit.sum(x - 1));
int m1 = *upper_bound(up.begin(), up.end(), l);
int m2 = *upper_bound(dn.begin(), dn.end(), l);
if (m1 > m2) swap(m1, m2);
r2v[i] = {l, m1, m2, i};
}
}
}
vector<int> mx = {-1};
for (int i = 0; i < N; i++) {
chmax(mx, r2v[i]);
for (auto [ql, idx] : R2LI[i])
if (ql <= mx[0]) ans[idx] = mx;
}
}
for (auto& v : ans) {
printf("%d\n", int(v.size()));
for (int a : v) printf("%d ", a + 1);
printf("\n");
}
return 0;
}
| 3,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T _abs(T n) {
return (n < 0 ? -n : n);
}
template <class T>
T _max(T a, T b) {
return (!(a < b) ? a : b);
}
template <class T>
T _min(T a, T b) {
return (a < b ? a : b);
}
template <class T>
T sq(T n) {
return n * n;
}
template <class T>
T gcd(T a, T b) {
return (b != 0 ? gcd<T>(b, a % b) : a);
}
template <class T>
T lcm(T a, T b) {
return (a / gcd<T>(a, b) * b);
}
template <class T>
T power(T N, T P) {
if (P == 0) return 1;
return (P == 1) ? N : N * power(N, P - 1);
}
template <class T>
double dist(T a, T b) {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
template <class T>
string tostring(T n) {
stringstream second;
second << n;
return second.str();
}
template <class T>
string itoa(T a) {
if (!a) return "0";
string ret;
for (T i = a; i > 0; i = i / 10) ret.push_back((i % 10) + 48);
reverse(ret.begin(), ret.end());
return ret;
}
template <class T>
inline T mod(T n, T m) {
return (n % m + m) % m;
}
int test, Case = 0;
template <class T1>
void D(T1 e) {
cout << e << endl;
}
template <class T1, class T2>
void D(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void D(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void D(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << endl;
}
vector<pair<long long, long long> > v;
long long n, m;
int main() {
scanf("%I64d", &n);
for (long long i = 0; i < n; i++) {
long long x;
scanf("%I64d", &x);
v.push_back(make_pair(x, 0));
}
scanf("%I64d", &m);
for (long long i = 0; i < m; i++) {
long long x;
scanf("%I64d", &x);
v.push_back(make_pair(x, 1));
}
sort(v.begin(), v.end());
long long cnt[2] = {3 * n, 3 * m};
long long i, j, c0 = cnt[0], c1 = cnt[1];
for (i = 0; i < (int)v.size();) {
for (j = i; j < (int)v.size(); j++) {
if (v[i].first != v[j].first) break;
cnt[v[j].second]--;
}
if (cnt[0] - cnt[1] > c0 - c1) {
c0 = cnt[0];
c1 = cnt[1];
} else if (cnt[0] - cnt[1] == c0 - c1 and c0 < cnt[0]) {
c0 = cnt[0];
c1 = cnt[1];
}
i = j;
}
printf("%I64d:%I64d\n", c0, c1);
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 555;
int a[N][N];
int sum[N][N];
int n, m;
int ans = -1e9;
int getSum(int x2, int y2, int x1, int y1) {
return sum[x2][y2] - sum[x1 - 1][y2] - sum[x2][y1 - 1] + sum[x1 - 1][y1 - 1];
}
void work(int x1, int y1) {
int x2 = x1 + 2;
int y2 = y1 + 2;
if (x2 > n || y2 > m) return;
int spiral = getSum(x2, y2, x1, y1) - a[x1 + 1][y1] - a[x1 + 1][y1 + 1];
ans = max(ans, spiral);
while (true) {
x1--;
y1--;
x2++;
y2++;
if (x2 > n || y2 > m || x1 < 1 || y1 < 1) return;
spiral = getSum(x2, y2, x1, y1) - spiral - a[x1 + 1][y1];
ans = max(ans, spiral);
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &a[i][j]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
sum[i][j] = a[i][j] + sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) work(i, j);
printf("%d\n", ans);
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[300010], b, c[300100], c1 = 0, d[3000100], d1 = 0, e, f, g, h, le, ri = 0,
ans = 0, ans1[300010], ans2;
bool md[300010] = {0};
int main() {
cin >> b;
for (int m = 1; m <= b; m++) scanf("%d", &a[m]);
for (int m = 2; m < b; m++)
if (a[m] <= a[m + 1] && a[m] <= a[m - 1]) c[++c1] = m;
for (int m = 1; m <= c1; m++)
if (c[m] < ri)
continue;
else {
for (le = c[m] - 1; le > 0; le--)
if (a[le] % a[c[m]]) break;
for (ri = c[m] + 1; ri <= b; ri++)
if (a[ri] % a[c[m]]) break;
if (ans == ri - le - 2) d[++d1] = le + 1;
if (ans < ri - le - 2) {
ans = ri - le - 2;
d1 = 1;
d[d1] = le + 1;
}
}
le = 1;
for (int m = 2; m <= b + 1; m++)
if (a[m] % a[le] == 0 && m <= b)
continue;
else {
if (ans == m - le - 1) d[++d1] = le;
if (ans < m - le - 1) {
ans = m - le - 1;
d1 = 1;
d[d1] = le;
}
le = m;
}
ri = b;
for (int m = b - 1; m >= 0; m--)
if (a[m] % a[ri] == 0 && m)
continue;
else {
if (ans == ri - m - 1) d[++d1] = m + 1;
if (ans < ri - m - 1) {
ans = ri - m - 1;
d1 = 1;
d[d1] = m + 1;
}
ri = m;
}
for (int m = 1; m <= d1; m++)
if (!md[d[m]]) {
md[d[m]] = 1;
ans1[++ans2] = d[m];
}
sort(ans1 + 1, ans1 + 1 + ans2);
printf("%d %d\n%d", ans2, ans, ans1[1]);
for (int m = 2; m <= ans2; m++) printf(" %d", ans1[m]);
return 0;
}
| 2,000 | CPP |
from sys import stdin
def inp():
return stdin.buffer.readline().rstrip().decode("utf8")
def itg():
return int(stdin.buffer.readline())
def mpint():
return map(int, stdin.buffer.readline().split())
# ############################## import
# ############################## main
ans = [87] * 1001
for case in range(itg()):
print(*ans[:itg()])
# Please check!
| 800 | PYTHON3 |
n=int(input())
def f1(n):
ans=0
while n>1:
t=n//2
ans+=(t/n)
n=n-t
return ans+1
def f2(n):
ans=0
while n:
ans+=(1/n)
n-=1
return ans
print(max(f2(n),f2(n))) | 1,000 | PYTHON3 |
import sys
sys.setrecursionlimit(10**5)
int1 = lambda x: int(x)-1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.buffer.readline())
def MI(): return map(int, sys.stdin.buffer.readline().split())
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def BI(): return sys.stdin.buffer.readline().rstrip()
def SI(): return sys.stdin.buffer.readline().rstrip().decode()
for _ in range(II()):
n=II()
aa=LI()
ans=1
par=1
chi=0
for i in range(n-1):
if aa[i+1]<aa[i]:
if par==1:
par,chi=chi,0
ans+=1
else:par-=1
chi+=1
print(ans)
| 1,600 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
typedef priority_queue<long long, vector<long long>, greater<long long>>
minHeap;
const int INF = 1e9 + 9;
const long long LINF = 1e17 + 9;
const long long MD = LINF;
inline long long po(long long a, long long b) {
long long ans = 1;
while (b > 0) {
if (b & 1) ans = (ans * a) % MD;
a = (a * a) % MD;
b /= 2;
}
return ans;
}
const int N = 2e5 + 33;
long long n, m, k, t;
long long arr[N];
string s;
vector<int> g[N];
int ans = 0;
priority_queue<pair<long long, long long>> mp;
int dp[N], par[N];
void dfs(int u, int p = -1, int d = 0) {
dp[u] = d;
par[u] = p;
mp.push({dp[u], u});
for (int v : g[u]) {
if (v == p) continue;
dfs(v, u, d + 1);
}
}
int main() {
ios_base::sync_with_stdio(false);
cout.tie(nullptr);
cin.tie(nullptr);
cout << fixed;
cout << setprecision(7);
cerr << "N"
<< " is " << N << endl;
cin >> n;
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
--a, --b;
g[a].push_back(b);
g[b].push_back(a);
}
dfs(0);
while (!mp.empty()) {
auto x = mp.top();
mp.pop();
if (dp[x.second] > 2) {
ans++;
int v = par[x.second];
dp[v] = 1;
for (int u : g[v]) {
dp[u] = 2;
}
}
}
cout << ans;
return 0;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int q;
cin >> q;
int n;
string s;
while (q--) {
cin >> n;
cin >> s;
if (n == 2) {
if (s[1] <= s[0])
cout << "NO\n";
else
cout << "YES\n2\n" << s[0] << ' ' << s[1] << '\n';
} else {
cout << "YES\n2\n";
cout << s[0] << ' ';
for (int i = 1; i < n; i++) cout << s[i];
cout << '\n';
}
}
}
| 900 | CPP |
n=int(input())
l=list(map(int,input().split()))
c=[]
d=[]
m=min(l)
if(m>=0):
print(sum(l))
else:
for i in range(n):
if(l[i]<0):
c.append(l[i])
else:
d.append(l[i])
print(sum(d)-sum(c)) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, k, i, a[100005], s[100005];
cin >> n >> k;
s[0] = 0;
for (i = 1; i <= n; ++i) {
cin >> a[i];
s[i] = s[i - 1] + i;
}
if (k == s[n]) {
cout << a[n];
return 0;
}
for (i = 1; i <= n; ++i) {
if (k > s[i] && k < s[i + 1]) {
cout << a[k - s[i]];
return 0;
} else if (k == s[i]) {
cout << a[i];
return 0;
}
}
return 0;
}
| 1,000 | CPP |
n = int(input())
c = list(map(int, input().split(" ")))
l = 0
for i in range(n):
if c[i]!=c[0] and i>l:
l = i
if c[n-1]!=c[i] and n-i-1>l:
l = n-i-1
print(l) | 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using std::make_pair;
const int MAXN = 15000 + 10;
int low, high, left, right;
int n;
std::pair<int, int> p[MAXN];
namespace solver1 {
std::vector<std::pair<int, int> > v[MAXN];
std::set<std::pair<std::pair<int, int>, int> > seg;
int ans = 0;
namespace dsu {
int fa[MAXN << 1], cnt;
void init() { cnt = 0; }
int nxt() {
++cnt;
fa[cnt] = cnt;
return cnt;
}
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
bool unite(int u, int v) {
u = find(u), v = find(v);
if (u == v) return 0;
fa[u] = v;
return 1;
}
} // namespace dsu
void work(int y, std::pair<int, int> line) {
auto it = seg.upper_bound({{line.first, MAXN}, MAXN});
if (it != seg.begin() && std::prev(it)->first.second >= line.second) {
--it;
if (it->first.first < line.first) {
seg.insert({{it->first.first, line.first - 1}, it->second});
}
if (line.second < it->first.second) {
seg.insert({{line.second + 1, it->first.second}, it->second});
}
seg.erase(it);
} else {
std::pair<std::pair<int, int>, int> cur = {line, dsu::nxt()};
ans++;
if (it != seg.begin() && std::prev(it)->first.second + 1 == line.first) {
auto t = std::prev(it);
cur.first.first = t->first.first;
ans -= dsu::unite(t->second, cur.second);
seg.erase(t);
}
if (it != seg.end() && line.second + 1 == it->first.first) {
cur.first.second = it->first.second;
ans -= dsu::unite(it->second, cur.second);
seg.erase(it);
}
seg.insert(cur);
}
}
void main() {
p[n + 1] = p[1];
for (int i = 1; i <= n; i++) {
if (p[i].second == p[i + 1].second) {
int l = std::min(p[i].first, p[i + 1].first);
l = std::max(l, left);
int r = std::max(p[i].first, p[i + 1].first);
r = std::min(r, right);
if (l < r) v[p[i].second].push_back(make_pair(l, r - 1));
}
}
for (int i = 0; i < high; i++) {
for (auto x : v[i]) {
work(i, x);
}
if (i == low) {
ans = 0;
dsu::init();
std::set<std::pair<std::pair<int, int>, int> > tmp;
for (auto x : seg) {
tmp.insert({x.first, dsu::nxt()});
ans++;
}
seg = tmp;
}
}
printf("%d\n", ans);
}
} // namespace solver1
int main() {
scanf("%d%d%d%d", &left, &high, &right, &low);
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &p[i].first, &p[i].second);
}
solver1::main();
}
| 2,800 | CPP |
n,m=list(map(int,input().split()))
a=[list(map(int,input().split())) for i in range(n)]
b=[[0 for j in range(m)] for i in range(n)]
b[0][0]=a[0][0]
c=[[0 for j in range(m)] for i in range(n)]
c[n-1][0]=a[n-1][0]
d=[[0 for j in range(m)] for i in range(n)]
d[0][m-1]=a[0][m-1]
e=[[0 for j in range(m)] for i in range(n)]
e[n-1][m-1]=a[n-1][m-1]
for i in range(n):
for j in range(m):
if i==0:
if j!=0:
b[i][j]=b[i][j-1]+a[i][j]
elif j==0:
b[i][j]=b[i-1][j]+a[i][j]
else:
b[i][j]=max(b[i-1][j],b[i][j-1])+a[i][j]
for i in range(n-1,-1,-1):
for j in range(m):
if i==n-1:
if j!=0:
c[i][j]=c[i][j-1]+a[i][j]
elif j==0:
c[i][j]=c[i+1][j]+a[i][j]
else:
c[i][j]=max(c[i+1][j],c[i][j-1])+a[i][j]
for i in range(n):
for j in range(m-1,-1,-1):
if i==0:
if j!=m-1:
d[i][j]=d[i][j+1]+a[i][j]
elif j==m-1:
d[i][j]=d[i-1][j]+a[i][j]
else:
d[i][j]=max(d[i-1][j],d[i][j+1])+a[i][j]
for i in range(n-1,-1,-1):
for j in range(m-1,-1,-1):
if i==n-1:
if j!=m-1:
e[i][j]=e[i][j+1]+a[i][j]
elif j==m-1:
e[i][j]=e[i+1][j]+a[i][j]
else:
e[i][j]=max(e[i+1][j],e[i][j+1])+a[i][j]
f=0
for i in range(n):
for j in range(m):
g1=int(b[i][j-1] if j>0 else -1000000000000)+int(c[i+1][j] if i<n-1 else -1000000000000)+int(d[i-1][j] if i>0 else -1000000000000)+int(e[i][j+1] if j<m-1 else -1000000000000)
g2=int(b[i-1][j] if i>0 else -1000000000000)+int(c[i][j-1] if j>0 else -1000000000000)+int(d[i][j+1] if j<m-1 else -1000000000000)+int(e[i+1][j] if i<n-1 else -1000000000000)
f=max(f,g1,g2)
print(f) | 1,600 | PYTHON3 |
f = [1,4,7]
r = [2,6]
ch = [3,5]
a1,b1,c1 = map(int,input().split())
max = -10**18
for i in range(1,8):
flag = 0
cnt = 0
a,b,c = a1,b1,c1
for j in range(i,8):
if j in f:
if a!=0:
a-=1
cnt+=1
else:
flag = 1
break
if j in r:
if b!=0:
b-=1
cnt+=1
else:
flag = 1
break
if j in ch:
if c!=0:
c-=1
cnt+=1
else:
flag = 1
break
if flag!=1:
z1 = (a//3)
z2 =(b//2)
z3 = (c//2)
k= min(z1,z2,z3)
a,b,c = (a-3*k),(b-2*k),(c-2*k)
new_count = 0
for z in range(1,8):
if z in f:
if a!=0:
a-=1
new_count+=1
else:
break
if z in r:
if b!=0:
b-=1
new_count+=1
else:
break
if z in ch:
if c!=0:
c-=1
new_count+=1
else:
break
cnt+=new_count+7*k
if cnt>max:
max = cnt
print(max)
| 1,400 | PYTHON3 |
#include <bits/stdc++.h>
long long i, a, b, c, n, x, C, M = 1e9 + 7;
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &x), C += x == 1;
a = b = c = 1;
for (i = 2; i <= C; i++) c = (b + a * (i - 1) % M) % M, a = b, b = c;
for (i = C + 1; i <= n; i++) c = c * i % M;
printf("%d\n", c);
}
| 2,300 | CPP |
n = int(input())
m = []
count = 0
for x in range(n):
alpha = input()
beta = list(alpha)
m.append(beta)
for loop in range(n):
for loop1 in range(n):
if(m[loop][loop1] == 'X'):
if(loop-1>=0 and loop1-1>=0 and loop+1<n and loop1+1<n):
if(m[loop-1][loop1-1]=='X' and m[loop+1][loop1-1]=='X' and m[loop+1][loop1+1]=='X' and m[loop-1][loop1+1]=='X'):
count = count + 1
print(count) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int mod = 20190802;
const int Max = 1e6 + 10;
int t, n, m;
map<int, int> mp;
int main() {
while (scanf("%d", &n) != EOF) {
mp.clear();
char order[2], str[20];
while (n--) {
scanf("%s%s", order, str);
int state = 0;
int len = strlen(str);
for (int i = 0; i < len; i++) {
state <<= 1;
if (str[i] % 2 == 1) {
state |= 1;
}
}
if (order[0] == '+') {
mp[state]++;
} else if (order[0] == '-') {
mp[state]--;
if (mp[state] == 0) {
mp.erase(state);
}
} else {
printf("%d\n", mp[state]);
}
}
}
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
vector<int> cr[1000001];
int is[1000001];
int vis[1000001];
int res;
int dfs(int i) {
if (vis[i] >= 0) return vis[i];
int r = 0;
for (auto x : cr[i])
if (is[x]) {
r = max(r, dfs(x));
}
r++;
return vis[i] = r;
}
int main(int argc, char const *argv[]) {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
memset(vis, -1, sizeof(vis));
int n;
cin >> n;
int a[n];
for (int i = 0; i < (int)n; i++) {
cin >> a[i];
is[a[i]] = 1;
}
for (int i = 1; i < (int)1000001; i++)
if (is[i]) {
for (int j = 2 * i; j < 1000001; j += i) {
cr[i].push_back(j);
}
}
for (int i = 1000001 - 1; i >= 0; i--)
if (vis[i] == -1 && is[i]) {
res = max(res, dfs(i));
}
cout << res << endl;
return 0;
}
| 1,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100001, MOD = 1E9 + 7;
int n, u, v, sub[N], l[N], r[N], dst[N] = {-1};
bool chk[N];
long long tot = 1, ans = 0, inv[N];
vector<int> lcl, gbl, adj[N];
void add(long long &u, long long v) {
u += v;
if (u >= MOD) {
u -= MOD;
} else if (u < MOD) {
u += MOD;
}
}
struct bit {
long long bit[N];
void update(int u, long long v) {
for (; u < N; u += u & -u) {
bit[u] += v;
}
}
void update(int l, int r, long long v) {
update(l, v);
update(r + 1, -v);
}
long long query(int u) {
long long ret = 0;
for (; u > 0; u -= u & -u) {
ret += bit[u];
}
return ret;
}
};
struct slope_bit {
bit sl, co;
void update(int l, int r, long long v) {
sl.update(l, r, v);
co.update(l, -v * (l - 1) % MOD);
co.update(r + 1, v * r % MOD);
}
long long query(int l, int r) {
return (sl.query(r) % MOD * r + co.query(r) -
sl.query(l - 1) % MOD * (l - 1) - co.query(l - 1)) %
MOD;
}
} coe, val;
void init() {
inv[1] = 1;
for (int i = 2; i < N; i++) {
inv[i] = MOD - MOD / i * inv[MOD % i] % MOD;
}
}
void add(int u, int s = 1) {
coe.update(l[u], r[u], s * inv[r[u] - l[u] + 1]);
val.update(l[u], r[u], s * dst[u] * inv[r[u] - l[u] + 1] % MOD);
}
int DFS(int u, int p = 0) {
sub[u] = 1;
dst[u] = dst[p] + 1;
for (int &v : adj[u]) {
if (v != p && !chk[v]) {
sub[u] += DFS(v, u);
}
}
return sub[u];
}
void find_ans(int u, int p) {
add(ans, dst[u] * inv[r[u] - l[u] + 1] % MOD * coe.query(l[u], r[u]) % MOD);
add(ans, inv[r[u] - l[u] + 1] * val.query(l[u], r[u]) % MOD);
lcl.push_back(u);
for (int &v : adj[u]) {
if (v != p && !chk[v]) {
find_ans(v, u);
}
}
}
void centroid(int u) {
int sz = DFS(u);
bool rt = false;
while (!rt) {
rt = true;
for (int &v : adj[u]) {
if (!chk[v] && sub[v] < sub[u] && sub[v] >= sz / 2) {
u = v;
rt = false;
break;
}
}
}
DFS(u);
add(u);
gbl.push_back(u);
for (int &v : adj[u]) {
if (!chk[v]) {
find_ans(v, u);
}
for (int &v : lcl) {
add(v);
gbl.push_back(v);
}
lcl.clear();
}
for (int &v : gbl) {
add(v, -1);
}
gbl.clear();
chk[u] = true;
for (int &v : adj[u]) {
if (!chk[v]) {
centroid(v);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
init();
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
(tot *= r[i] - l[i] + 1) %= MOD;
}
for (int i = 1; i < n; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
centroid(1);
cout << (ans * tot % MOD + MOD) % MOD;
}
| 2,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool request(int r1, int r2, int c1, int c2) {
string ans;
cout << "? " << r1 << ' ' << r2 << ' ' << c1 << ' ' << c2 << endl;
cin >> ans;
assert(ans != "BAD");
return (ans == "YES");
}
int main() {
cin.sync_with_stdio(0);
cout.sync_with_stdio(0);
int n;
cin >> n;
char s[4100];
int c1 = 1;
int r1 = 1;
int r2 = n;
int c2 = n;
for (int i = 0; i < n - 1; i++) {
if (request(r1, c1 + 1, n, n)) {
s[i] = 'R';
c1++;
} else {
s[i] = 'D';
r1++;
}
}
for (int i = 2 * n - 2; i-- > n - 1;) {
if (s[i - n + 1] == 'R') {
c1--;
} else {
r1--;
}
if (request(r1, c1, r2 - 1, c2)) {
s[i] = 'D';
r2--;
} else {
s[i] = 'R';
c2--;
}
}
printf("! %s", s);
cout << endl;
return 0;
}
| 2,100 | CPP |
n=int(input())
d=list(map(int,input().split()))
a=[0]
a.extend(d)
an=0
for i in range(n+1):
if a[i]>a[i-1]:
an+=(a[i]-a[i-1])*(n-a[i]+1)
if a[i]<a[i-1]:
an+=(a[i])*(a[i-1]-a[i])
## print(an)
print(an)
| 2,100 | PYTHON3 |
n = int(input())
words=[]
for i in range(0 , n):
s=input()
words.append(s)
for element in words:
if (len(element)<11):
print(element)
else :
x=len(element)
print("{}{}{}".format(element[0],x-2,element[x-1]))
| 800 | PYTHON3 |
def solve(i,j,n,arr,val,c):
while(c>0):
if(j-1>=0):
if(arr[i][j-1]==0):
arr[i][j-1]=val
j-=1
c-=1
else:
arr[i+1][j]=val
i+=1
c-=1
else:
arr[i+1][j]=val
i+=1
c-=1
n=int(input())
per=[int(x) for x in input().split()]
arr=[[0 for j in range(n)] for i in range(n)]
for i in range(n):
arr[i][i]=per[i]
for i in range(n):
x,y=i,i
val=arr[x][y]
count=val-1
solve(x,y,n,arr,val,count)
for ele in arr:
for e in ele:
if(e==0):
print(" ",end="")
else:
print(e,end=" ")
print() | 1,400 | PYTHON3 |
n,m=map(int,input().split())
l=[0]+list(map(int,input().split()))
for i in range(1,m+1):
if l[i]+i-1>n:
print(-1)
exit()
suffix_sum=[0]*(m+2)
for i in range(m+1)[::-1]:
suffix_sum[i]=suffix_sum[i+1]+l[i]
if suffix_sum[1]<n:
print(-1)
exit()
p=[0]*(m+1)
for i in range(1,m+1):
p[i]=max(i,n-suffix_sum[i]+1)
print(*p[1:]) | 1,800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, m, d, one, res = 0;
cin >> n >> k >> m >> d;
long long time = 1;
while (one != 0 && time <= d) {
one = n / (time + (k - 1) * (time - 1));
if (one > m) one = m;
res = max(res, time * one);
time++;
}
cout << res << endl;
}
| 2,000 | CPP |
def solve(nums, k):
l = list()
h = set()
for j in nums:
if j not in h:
if len(l) == k:
h.remove(l[0])
l.pop(0)
l.append(j)
h.add(j)
return l
def main():
_, k = list(map(int, input().split()))
nums = list(map(int, input().split()))
sol = solve(nums, k)
print(len(sol))
for i in reversed(sol):
print(i, end=" ")
main() | 1,000 | PYTHON3 |
n, m = list(map(int, input().split()))
print("Akshat" if not min(n, m) % 2 == 0 else "Malvika")
| 900 | PYTHON3 |
n = int(input())
x, y = map(int, input().split(" "))
if x+y>n+1:
print("Black")
else:
print("White") | 800 | PYTHON3 |
n = int(input())
for i in range(n):
li = list(map(int,input().split()))[:3]
print(min(li)+max(li)) | 800 | PYTHON3 |
from collections import Counter
if __name__ == '__main__':
l = [int(i) for i in input().split(" ")]
h = l[0]
w = l[1]
matrix = [[0 for j in range(w)] for i in range(h)]
r = [int(i) for i in input().split(" ")]
c = [int(i) for i in input().split(" ")]
for i in range(h):
if r[i] == 0:
matrix[i][0] = -1
else:
for j in range(r[i]):
matrix[i][j] = 1
if r[i] < w:
matrix[i][r[i]] = -1
flag = 0
for j in range(w):
if c[j] == 0:
if matrix[0][j] == 1:
print(0)
flag = 1
break
else:
matrix[0][j] = -1
else:
for i in range(c[j]):
if matrix[i][j] == -1:
print(0)
flag = 1
break
else:
matrix[i][j] = 1
if flag == 1:
break
if c[j] < h:
if matrix[c[j]][j] == 1:
print(0)
flag = 1
break
matrix[c[j]][j] = -1
if flag == 1:
break
if flag == 0:
c = 0
for i in matrix:
c += i.count(0)
print((2**c)%1000000007)
| 1,400 | PYTHON3 |
n = int(input())
#sieve = list(range(2, n + 1))
#
#num2remove = set()
#for i in range(len(sieve)):
# for j in range(i+1):
# num2remove.add(sieve[i] * sieve[j])
# i += 1
#
#sieve = [e for e in sieve if e not in num2remove]
res = []
if n == 2:
print(1)
print(2)
elif n == 3:
print(1)
print(3)
else:
if n % 2 == 0:
res = [str(e) for e in [2] * (n // 2)]
else:
res = [str(e) for e in [2] * (n // 2 - 1) + [3]]
print(len(res))
print(' '.join(res))
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007LL;
int n;
int r, s, p;
double pr[102][102][102];
double solve(int id) {
for (int i = 0; i <= r; ++i) {
for (int j = 0; j <= s; ++j) {
for (int k = 0; k <= p; ++k) {
if (id == 0) {
if (i == 0) {
pr[i][j][k] = 0.0;
continue;
} else if (k == 0) {
pr[i][j][k] = 1.0;
continue;
} else if (j == 0) {
pr[i][j][k] = 0.0;
continue;
}
} else if (id == 1) {
if (j == 0) {
pr[i][j][k] = 0.0;
continue;
} else if (i == 0) {
pr[i][j][k] = 1.0;
continue;
} else if (k == 0) {
pr[i][j][k] = 0.0;
continue;
}
} else {
if (k == 0) {
pr[i][j][k] = 0.0;
continue;
} else if (j == 0) {
pr[i][j][k] = 1.0;
continue;
} else if (i == 0) {
pr[i][j][k] = 0.0;
continue;
}
}
int tot = i + j + k;
double p2 = pr[i - 1][j][k] * (double)i * (double)k +
pr[i][j - 1][k] * (double)i * (double)j +
pr[i][j][k - 1] * (double)j * (double)k;
double p3 = (double)tot * (double)(tot - 1) / 2.0 -
(double)i * (double)(i - 1) / 2.0 -
(double)j * (double)(j - 1) / 2.0 -
(double)k * (double)(k - 1) / 2.0;
pr[i][j][k] = p2 / p3;
}
}
}
return pr[r][s][p];
}
int main() {
cin >> r >> s >> p;
n = r + s + p;
printf("%.10lf %.10lf %.10lf\n", solve(0), solve(1), solve(2));
return 0;
}
| 1,900 | CPP |
import sys
import math
n, b, a = list(map(int, sys.stdin.readline().strip().split()))
s = list(map(int, sys.stdin.readline().strip().split()))
A = a
B = b
i = 0
while i < n:
if s[i] == 1 and b > 0 and a < A:
b = b - 1
a = a + 1
elif s[i] == 1 and (b == 0 and a > 0):
a = a - 1
elif s[i] == 1 and a == A:
a = a - 1
elif s[i] == 0 and a > 0:
a = a - 1
elif s[i] == 0 and b > 0:
b = b - 1
else:
print(i)
i = n
if i == n - 1:
print(i + 1)
i = i + 1
| 1,500 | PYTHON3 |
n=int(input())
hard=0
opinion=list(map(int, input().split()))
for i in opinion:
if i==1:
hard+=1
break
if hard==1:
print("hard")
else:
print("easy")
| 800 | PYTHON3 |
killos = int(input())
if killos%2!=0 or killos==2:
print("NO")
else:
print("YES") | 800 | PYTHON3 |
Subsets and Splits