solution
stringlengths 10
159k
| difficulty
int64 0
3.5k
| language
stringclasses 2
values |
|---|---|---|
n = int(input())
ls = list(map(int, input().split()))
res = 0
for i in range(n):
if ls[i]!=-1: break
else: res+=1
else: print(res); exit()
index = i
cnt = 0
for i in range(index, n):
cnt+=ls[i]
if cnt<0: res+=1
cnt = max(0, cnt)
print(res)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int df, ma, mb, mab, mbc, mabc;
};
node t[1 << 19];
struct segtree {
int n, h;
segtree() {}
segtree(int sz) {
h = 32 - __builtin_clz(sz);
n = 1 << h;
}
void pulll(int i) {
node& l = t[i << 1];
node& r = t[i << 1 | 1];
node& p = t[i];
p.df = l.df + r.df;
p.ma = max(l.ma, l.df + r.ma);
p.mb = max(l.mb, -2 * l.df + r.mb);
p.mab = max(max(l.mab, -l.df + r.mab), l.ma + r.mb - 2 * l.df);
p.mbc = max(max(l.mbc, -l.df + r.mbc), l.mb + r.ma + l.df);
p.mabc =
max(max(l.mabc, r.mabc), max(l.mab + r.ma + l.df, l.ma + r.mbc - l.df));
}
void assign(int i, char c) {
i += n;
if (c == ')') {
t[i].df = -1;
} else {
t[i].df = 1;
}
for (i /= 2; i > 0; i /= 2) {
pulll(i);
}
}
int query() { return t[1].mabc; }
};
const int NMAX = 200100;
int n, q;
char s[NMAX];
segtree st(NMAX);
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> q;
cin >> s;
for (int i = 0; s[i]; ++i) {
st.assign(i, s[i]);
}
cout << st.query() << "\n";
for (int i = 0; i < q; ++i) {
int a, b;
cin >> a >> b;
swap(s[--a], s[--b]);
st.assign(a, s[a]);
st.assign(b, s[b]);
cout << st.query() << "\n";
}
return 0;
}
| 2,700 | CPP |
n = int(input())
while(n>0):
s = input()
l = len(s)
if(l<=10):
print(s)
else:
l = l-2
print(s[0] ,str(l),s[-1], sep='')
n = n-1 | 800 | PYTHON3 |
def jujk(n):
for i in range(1, (n//2)+2):
if i % 3 == 0:
continue
for j in range(1, (n//2) + 2 - i):
if (j % 3) == 0 or (n-i-j) % 3 == 0:
continue
else:
print(i, j, n-i-j)
return
else:
print(-1)
n = int(input())
jujk(n)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 9;
using ll = long long;
int n, kk, vv;
ll a[N][N], b[N][N];
int x[N], y[N];
int main() {
ios::sync_with_stdio(false);
cin >> kk;
n = 1 << kk;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> a[i][j];
cin >> vv;
for (int i = 0; i < vv; i++) cin >> x[i] >> y[i];
for (int i = vv - 1; i >= 0; --i) x[i] -= x[0], y[i] -= y[0];
for (int t = 0; t < kk; t++) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) b[i][j] = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int q = 0; q < vv; q++) {
int nx = (i + x[q]) & (n - 1), ny = (j + y[q]) & (n - 1);
b[nx][ny] ^= a[i][j];
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) a[i][j] = b[i][j];
for (int i = 0; i < vv; i++)
x[i] = (x[i] * 2) & (n - 1), y[i] = (y[i] * 2) & (n - 1);
}
int ans = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) ans += !!a[i][j];
cout << ans << endl;
return 0;
}
| 3,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long INF = LLONG_MAX;
const double PI = acos(-1);
const long long MOD = 1e9 + 7;
const long long N = 1e5 + 10;
void solve();
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
void solve() {
long long x1, x2, y1, y2;
cin >> x1 >> y1 >> x2 >> y2;
long long lol = (y2 - y1 + 2) / 2;
long long xD = x2 - x1 + 1;
long long haha = (x2 - x1) / 2;
cout << lol * xD - haha << "\n";
return;
}
| 1,900 | CPP |
n=int(input())
I=[]
for i in range(n):
k=[int(i) for i in input().split()]
I.append(k)
def output(l):
return (23-l[0])*60+60-l[1]
for i in range(n):
print(output(I[i]))
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[101];
int u = 0, l = 0;
cin >> s;
for (int i = 0; i < strlen(s); i++) {
if (s[i] >= 97 && s[i] <= 122)
l++;
else
u++;
}
if (u > l) {
for (int i = 0; i < strlen(s); i++) {
if (s[i] >= 97 && s[i] <= 122) s[i] = s[i] - 32;
}
} else {
for (int i = 0; i < strlen(s); i++) {
if (s[i] >= 65 && s[i] <= 90) s[i] = s[i] + 32;
}
}
cout << s << endl;
return 0;
}
| 800 | CPP |
# maa chudaaye duniya
for _ in range(int(input())):
n = int(input())
arr = list(map(int, input().split()))
odd1, odd2 = -1, -1
evei = -1
o, e = 0, 0
for i in range(n):
if arr[i]%2 == 0:
e += 1
evei = i+1
break
else:
if o == 0:
odd1 = i+1
o+= 1
elif o == 1:
odd2 = i+1
o += 1
if e >= 1:
print(1)
print(evei)
elif o >= 2:
print(2)
print(odd1, odd2)
else:
print(-1)
| 800 | PYTHON3 |
from math import sin, pi
f = lambda n, r: round(r * sin(pi/n)/(1 - sin(pi/n)), 7)
n, r = map(int, input().split())
print(f(n, r)) | 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 505;
const long mod = 1e9 + 7;
int fail[N] = {};
int ch[N][2] = {};
int dp[2][N][N] = {};
string str;
int n;
long long fac(int x) {
long long ret = 1;
for (int i = 2; i <= x; i++) ret = ret * i % mod;
return ret;
}
long long inv(int x) {
return x == 1 ? 1 : (mod - mod / x) * inv(mod % x) % mod;
}
void build() {
int p = 0, len = str.size();
str = "@" + str;
fail[0] = 0;
fail[1] = 0;
for (int i = 2; i <= len; i++) {
while (p && str[p + 1] != str[i]) p = fail[p];
if (str[p + 1] == str[i]) p++;
fail[i] = p;
}
ch[0][0] = str[1] == '(';
ch[0][1] = str[1] == ')';
for (int i = 1; i < len; i++) {
ch[i][0] = (str[i + 1] == '(' ? i + 1 : ch[fail[i]][0]);
ch[i][1] = (str[i + 1] == ')' ? i + 1 : ch[fail[i]][1]);
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> str;
int len = str.size();
build();
dp[0][0][0] = 1;
for (int i = 1; i <= n + n; i++) {
int now = i & 1;
for (int j = 0; j < len; j++) {
for (int k = 0; k <= n; k++) {
if (k < n)
dp[now][ch[j][0]][k + 1] =
(dp[now][ch[j][0]][k + 1] + dp[now ^ 1][j][k]) % mod;
if (k > 0)
dp[now][ch[j][1]][k - 1] =
(dp[now][ch[j][1]][k - 1] + dp[now ^ 1][j][k]) % mod;
dp[now ^ 1][j][k] = 0;
}
}
}
int ans =
fac(n + n) * inv(fac(n)) % mod * inv(fac(n)) % mod * inv(n + 1) % mod;
for (int i = 0; i < len; i++) ans = (ans - dp[0][i][0]) % mod;
if (ans < 0) ans += mod;
cout << ans << '\n';
return 0;
}
| 2,300 | CPP |
__author__ = 'cmashinho'
n = int(input())
needMeat = []
meatPrice = []
for _ in range(n):
a, b = map(int, input().split())
needMeat.append(a)
meatPrice.append(b)
answer = 0
minPrice = min(meatPrice)
i = 0
while i < n:
it = False
if meatPrice[i] == minPrice:
for j in range(i, n):
answer += needMeat[j] * minPrice
break
else:
for j in range(i, n):
if meatPrice[i] <= meatPrice[j]:
answer += needMeat[j] * meatPrice[i]
else:
it = True
i = j
break
if it:
continue
else:
i += 1
print(answer)
| 900 | PYTHON3 |
def pangram (input_string):
alphabet = "abcdefghijklmnopqrstuvwxyz"
input_string = input_string.lower().strip()
letter_dict = {}
for letter in input_string:
if letter in letter_dict:
letter_dict[letter] += 1
else:
letter_dict[letter] = 1
for i in alphabet:
if i not in letter_dict:
return "NO"
return "YES"
n = int(input())
s = input()
print(pangram(s)) | 800 | PYTHON3 |
n, m=map(int, input().split())
l=list (map(int, input ().split()))
arr=[]
for i in range(n):
arr.append([l[i], i+1])
j=0
while len(arr)>1:
if arr[j] [0]<=m:
arr.pop(j)
else:
x=[arr[j] [0]-m, arr[j] [1]]
arr.pop(j)
arr.append(x)
print (arr[0][1]) | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
char ch[N];
int s[N], r[N];
int n, m, sa[N], rk[N], h[N], he[N], t[N * 2], c[N];
void radix(int val[], int src[], int dest[]) {
for (int i = 0; i <= m; ++i) c[i] = 0;
for (int i = 1; i <= n; ++i) ++c[val[i] + 1];
for (int i = 1; i <= m; ++i) c[i] += c[i - 1];
for (int i = 1; i <= n; ++i) dest[++c[val[src[i]]]] = src[i];
}
int _lcp(int x, int y) {
int p = 0;
for (; ch[x + p] && ch[x + p] == ch[y + p]; ++p)
;
return p;
}
void run() {
int pos;
m = (n == 255 ? 256 : 255);
for (int i = 1; i <= n; ++i) rk[i] = ch[i], t[i + n] = 0, t[i] = i;
radix(rk, t, sa);
for (int d = 1; m != n; d <<= 1) {
pos = 0;
for (int i = n - d + 1; i <= n; ++i) t[++pos] = i;
for (int i = 1; i <= n; ++i)
if (sa[i] > d) t[++pos] = sa[i] - d;
radix(rk, t, sa);
for (int i = 1; i <= n; ++i) t[i] = rk[i];
rk[sa[1]] = m = 1;
for (int i = 2; i <= n; ++i)
rk[sa[i]] =
(m += (t[sa[i]] != t[sa[i - 1]] || t[sa[i] + d] != t[sa[i - 1] + d]));
}
for (int i = 1; i <= n; ++i)
if (rk[i] != 1) {
pos = max(h[i - 1] - 1, 0);
h[i] = pos + _lcp(i + pos, sa[rk[i] - 1] + pos);
} else
h[i] = 0;
for (int i = 1; i <= n; ++i) he[i] = h[sa[i]];
}
vector<int> pd[N * 2], *p = pd + N;
int get(int key, int l, int r) {
if (l > r || p[key].empty()) return 0;
return upper_bound(p[key].begin(), p[key].end(), r) -
lower_bound(p[key].begin(), p[key].end(), l);
}
int main() {
scanf("%d%s", &n, ch + 1);
for (int i = n; i; --i)
if (ch[i] == ')')
s[i] = s[i + 1] + 1;
else
s[i] = s[i + 1] - 1;
for (int i = 1; i <= n + 1; ++i) p[s[i]].push_back(i);
for (int i = n + 1; i; --i) {
int &p = r[i];
for (p = i + 1; p <= n + 1 && s[p] >= s[i]; p = r[p])
;
}
run();
long long ans = 0;
for (int i = 1; i <= n; ++i) {
ans += get(s[sa[i]], sa[i] + he[i] + 1, r[sa[i]] - 1);
}
printf("%I64d\n", ans);
return 0;
}
| 2,600 | CPP |
a, b, c = map(int, input().split())
if a == b:
print('YES')
elif c == 0:
print('NO')
else:
if b >= a:
if c <= 0:
print('NO')
elif (b - a) % c == 0:
print('YES')
else:
print('NO')
else:
if c >= 0:
print('NO')
else:
if (a - b) % c == 0:
print('YES')
else:
print('NO') | 1,100 | PYTHON3 |
a = input()
firstLetterUppercase = False
countOfUppercaseLetters = 0
for i in range(0,len(a)):
if i == 0:
if a[i].istitle() == False:
firstLetterUppercase = True
else:
countOfUppercaseLetters+=1
pass
else:
if a[i].istitle():
countOfUppercaseLetters+=1
else:
pass
if firstLetterUppercase:
if countOfUppercaseLetters == len(a)-1:
print(a.capitalize())
else:
print(a)
else:
if countOfUppercaseLetters == len(a):
print(a.lower())
else:
print(a) | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
int f[300], n, m;
char a[300][300];
bool check(int x, int y, int z, int t) {
for (int i = x; i <= z; i++)
for (int j = y; j <= t; j++)
if (a[i][j] != a[x][y]) return 0;
return 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j], f[a[i][j]]++;
if (n % 3 && m % 3) {
cout << "NO";
return 0;
}
if (f['R'] == m * n / 3 && f['G'] == f['R'] && f['B'] == f['G']) {
if (n % 3 == 0) {
if (check(0, 0, n / 3 - 1, m - 1) &&
check(n / 3, 0, 2 * n / 3 - 1, m - 1) &&
check(2 * n / 3, 0, n - 1, m - 1)) {
cout << "YES";
return 0;
}
}
if (m % 3 == 0) {
if (check(0, 0, n - 1, m / 3 - 1) &&
check(0, m / 3, n - 1, 2 * m / 3 - 1) &&
check(0, 2 * m / 3, n - 1, m - 1)) {
cout << "YES";
return 0;
}
}
}
cout << "NO";
}
| 1,600 | CPP |
from collections import Counter
n = int(input())
alph = list('abcdefghijklmnopqrstuvwxyz')
for i in range(n):
a = input()
maxcnt = 0
for j in a:
cnt = a.count(j)
if cnt > maxcnt:
maxcnt = cnt
if len(a) == 1:
print('Yes')
elif maxcnt > 1:
print('No')
else:
check = True
ind = alph.index(max(a))
for l in alph[ind+1-len(a):ind+1]:
if l not in a:
check = False
break
if check:
print('Yes')
else:
print('No')
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long int bg = 9982443530987;
vector<vector<long long int> > vec(400000), newvec(400000);
set<pair<long long int, long long int> > vec1;
set<long long int> set1;
long long int vis[400000], f[400000], f2[400000];
void dfs(long long int i, long long int k) {
long long int j, s = 0;
vis[i] = 1;
f[i] = k;
for (j = 0; j < vec[i].size(); j++) {
if (vis[vec[i][j]] == 0) dfs(vec[i][j], k + 1);
}
}
void dfs2(long long int i, long long int k) {
long long int j, s = 0;
vis[i] = 1;
f2[i] = k;
for (j = 0; j < vec[i].size(); j++) {
if (vis[vec[i][j]] == 0) dfs2(vec[i][j], k + 1);
}
}
int dfs3(long long int i, long long int b) {
long long int j, s = 0;
vis[i] = 1;
for (j = 0; j < vec[i].size(); j++) {
if (vis[vec[i][j]] == 0) {
long long int h = dfs3(vec[i][j], b), a = min(i, vec[i][j]),
b = max(i, vec[i][j]);
s += h;
if (h == 1) {
vec1.insert(make_pair(a, b));
set1.insert(a);
set1.insert(b);
}
}
}
if (i == b || s > 0)
return 1;
else
return 0;
}
pair<long long int, long long int> dfs4(long long int i) {
long long int j, s = 0;
vis[i] = 1;
vector<pair<long long int, long long int> > gg;
for (j = 0; j < newvec[i].size(); j++) {
if (vis[newvec[i][j]] == 0) gg.push_back(dfs4(newvec[i][j]));
}
sort(gg.begin(), gg.end());
if (gg.size() == 0)
return make_pair(1, i);
else
return make_pair(gg[gg.size() - 1].first + 1, gg[gg.size() - 1].second);
}
void boom() {
long long int i, n, h = bg, j, m, k;
cin >> n;
for (i = 0; i < n - 1; i++) {
long long int a, b;
cin >> a >> b;
vec[a - 1].push_back(b - 1);
vec[b - 1].push_back(a - 1);
}
dfs(0, 1);
long long int a = 0, dis1 = 0;
for (i = 0; i < n; i++) {
if (dis1 <= f[i]) {
a = i;
dis1 = f[i];
}
}
for (i = 0; i < n; i++) vis[i] = 0;
dfs2(a, 1);
long long int b = 0, dis2 = 0;
for (i = 0; i < n; i++) {
if (dis2 <= f2[i] && i != a) {
b = i;
dis2 = f2[i];
}
}
for (i = 0; i < n; i++) vis[i] = 0;
int y = dfs3(a, b);
for (i = 0; i < n; i++) {
for (j = 0; j < vec[i].size(); j++) {
long long int h1 = min(i, vec[i][j]), h2 = max(i, vec[i][j]);
if (vec1.find(make_pair(h1, h2)) == vec1.end())
newvec[i].push_back(vec[i][j]);
}
}
set<long long int>::iterator yy = set1.begin();
vector<pair<long long int, long long int> > final;
for (i = 0; i < n; i++) vis[i] = 0;
for (; yy != set1.end(); yy++) {
pair<long long int, long long int> dd = dfs4(*yy);
final.push_back(dd);
}
sort(final.begin(), final.end());
cout << dis2 + final[final.size() - 1].first - 2 << '\n';
for (i = final.size() - 1; i >= 0; i--)
if (final[i].second != a && final[i].second != b) {
cout << a + 1 << " " << b + 1 << " " << final[i].second + 1;
break;
}
}
int main() {
long long int t;
t = 1;
while (t--) boom();
return 0;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> vec;
int s = 1;
if (k == 1) {
cout << n << endl;
return 0;
}
while (1) {
int e = 0;
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
s++;
vec.push_back(i);
if (s == k) {
vec.push_back(n / i);
e = 1;
break;
} else {
n = n / i;
e = 1;
break;
}
}
}
if (e == 0) break;
if (s == k) break;
}
if (s != k)
cout << -1 << endl;
else
for (int i = 0; i < vec.size(); i++) cout << vec[i] << " ";
cout << endl;
}
| 1,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
for (int j = 1; j < 20; j++) {
a[i] -= j;
if (a[i] < 0) {
a[i] = j - 1;
break;
}
}
}
int xr = 0;
for (int i = 0; i < n; i++) {
xr ^= a[i];
}
if (xr == 0) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
| 2,100 | CPP |
t = int(input())
for _ in range(t):
n = int(input())
s = input()
if s[0:4] == '2020' or s[n - 4:n] == '2020':
print('YES')
elif s[0:3] == '202' and s[-1] == '0':
print('YES')
elif s[0:2] == '20' and s[n - 2:n] == '20':
print('YES')
elif s[0] == '2' and s[n - 3:n] == '020':
print('YES')
else:
print('NO') | 800 | PYTHON3 |
s=input()
m=s.split()
n=int(m[0])
if m[2]=='week':
if n==5 or n==6:
print(53)
else:
print(52)
else:
if n==30:
print(11)
elif n<30:
print(12)
else:
print(7) | 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 112345;
int a[maxn];
long long f[maxn];
vector<int> adj[maxn];
int MAIN() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
scanf("%d", &a[i]);
}
long long all = 0;
for (int i = 0; i < m - 1; ++i) {
int delta = abs(a[i] - a[i + 1]);
all += delta;
if (a[i] != a[i + 1]) {
f[a[i]] += delta;
f[a[i + 1]] += delta;
adj[a[i]].push_back(a[i + 1]);
adj[a[i + 1]].push_back(a[i]);
}
}
long long best = all;
for (int i = 1; i <= n; ++i) {
int sz = adj[i].size();
if (sz == 0) continue;
sort(adj[i].begin(), adj[i].end());
int mid = adj[i][sz / 2];
long long d = 0;
for (int j = 0; j < sz; ++j) {
d += abs(adj[i][j] - mid);
}
best = min(best, all - f[i] + d);
}
cout << best << endl;
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(16);
int ret = MAIN();
return ret;
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
char string_in_buffer[(int)260];
void fast_scan(int &first) { scanf("%d", &first); }
void fast_scan(long long &first) { scanf("%lld", &first); }
void fast_scan(unsigned long long &first) { scanf("%llu", &first); }
void fast_scan(double &first) { scanf("%lf", &first); }
void fast_scan(long double &first) { scanf("%Lf", &first); }
void fast_scan(char &first) {
scanf("%c", &first);
if (first == '\n') {
fast_scan(first);
}
}
void fast_scan(string &first) {
scanf("%s", string_in_buffer);
first = string(string_in_buffer);
}
template <class TFirst, class TSecond>
void fast_scan(pair<TFirst, TSecond> &p) {
fast_scan(p.first);
fast_scan(p.second);
}
template <class T>
void fast_scan(vector<T> &v) {
for (auto &first : v) fast_scan(first);
}
void fast_print(const int &first) { printf("%d", first); }
void fast_print(const unsigned int &first) { printf("%u", first); }
void fast_print(const long long &first) { printf("%lld", first); }
void fast_print(const unsigned long long &first) { printf("%llu", first); }
void fast_print(const double &first) { printf("%.15lf", first); }
void fast_print(const long double &first) { printf("%.15Lf", first); }
void fast_print(const char &first) { printf("%c", first); };
void fast_print(const string &first) { printf("%s", first.c_str()); }
void fast_print(const char v[]) { fast_print((string)v); }
template <class TFirst, class TSecond>
void fast_print(const pair<TFirst, TSecond> &p) {
fast_print(p.first);
fast_print(' ');
fast_print(p.second);
}
template <class T>
void fast_print(const vector<T> &v) {
if (v.empty()) return;
fast_print(v[0]);
for (int i = 1; i < v.size(); i++) {
fast_print(' ');
fast_print(v[i]);
}
}
template <class T>
void fast_print(const vector<vector<T>> &v) {
if (v.empty()) return;
fast_print(v[0]);
for (int i = 1; i < v.size(); i++) {
fast_print('\n');
fast_print(v[i]);
}
}
template <class T>
void fast_print(const T &v) {
for (const auto &first : v) {
fast_print(first);
fast_print(' ');
}
}
using namespace std;
namespace smart_io {
string print_start = "";
string sep = " ";
bool first_print = false;
void precall_print() {
fast_print(print_start);
print_start = "\n";
first_print = true;
}
void _print(deque<string>) {}
template <class T, class... Args>
void _print(deque<string> names, T elem, Args... args) {
if (!first_print) {
fast_print("\n");
} else {
first_print = false;
}
fast_print(names.front());
fast_print(" = ");
fast_print(elem);
names.pop_front();
_print(names, args...);
}
} // namespace smart_io
template <class T>
ostream &operator,(ostream &os, const T &object) {
if (!smart_io::first_print) {
fast_print(smart_io::sep);
} else {
smart_io::first_print = false;
}
fast_print(object);
return os;
}
template <class T>
istream &operator,(istream &is, T &object) {
fast_scan(object);
return is;
}
namespace escape__from__random__aetuhoetnuhshe {
using namespace std::chrono;
mt19937 rng(duration_cast<milliseconds>(system_clock::now().time_since_epoch())
.count());
uniform_real_distribution<> prob_dist(0.0, 1.0);
}; // namespace escape__from__random__aetuhoetnuhshe
namespace typedefs {}
namespace numbers_operation {
template <class T>
T floor_mod(T a, T b) {
if (a >= 0 && b >= 0) return a % b;
if (a <= 0 && b <= 0) return a % b;
return abs(b) - (abs(a) % abs(b));
}
} // namespace numbers_operation
using namespace numbers_operation;
using namespace typedefs;
using namespace escape__from__random__aetuhoetnuhshe;
const long long MOD = 1e9 + 7;
template <long long MOD>
struct Ring {
long long value = 0;
Ring() {}
Ring(int _value) {
value = _value;
value = floor_mod(value, MOD);
}
Ring(long long _value) {
value = _value;
value = floor_mod(value, MOD);
}
Ring pow(const long long &p) const {
if (p < 0) return 0;
if (p == 0) return 1;
if (p & 1) {
return Ring(value).pow(p - 1) * value;
} else {
Ring sub = Ring(value).pow(p / 2);
return sub * sub;
}
}
Ring inv() const { return pow(MOD - 2); }
void operator*=(const Ring<MOD> &b) {
value *= b.value;
value = floor_mod(value, MOD);
}
friend Ring operator*(Ring<MOD> a, const Ring<MOD> &b) {
a *= b;
return a;
}
void operator+=(const Ring<MOD> &b) {
value += b.value;
value = floor_mod(value, MOD);
}
friend Ring operator+(Ring a, const Ring &b) {
a += b;
return a;
}
void operator-=(const Ring<MOD> &b) {
value -= b.value;
value = floor_mod(value, MOD);
}
friend Ring operator-(Ring a, const Ring &b) {
a -= b;
return a;
}
void operator/=(const Ring<MOD> &b) { (*this) *= b.inv(); }
friend Ring operator/(Ring a, const Ring &b) {
a /= b;
return a;
}
bool operator==(const Ring<MOD> &b) { return value == b.value; }
friend void fast_print(const Ring<MOD> &b) { fast_print(b.value); }
};
vector<Ring<MOD>> fact;
vector<Ring<MOD>> invfact;
Ring<MOD> binom(int n, int k) { return fact[n] / (fact[n - k] * fact[k]); }
signed main(signed argc, char *argv[]) {
fact.push_back(1);
invfact.push_back(1);
for (int i = 1; i < (int)1e6 + 100; i++) {
fact.push_back(Ring<MOD>(i) * fact.back());
invfact.push_back(fact.back().inv());
}
int n, m;
cin, n, m;
Ring<MOD> rez = 0;
Ring<MOD> A = Ring<MOD>(n).pow(n - 2);
Ring<MOD> NINV = Ring<MOD>(n).inv();
Ring<MOD> B = Ring<MOD>(m).pow(n - 1);
Ring<MOD> MINV = Ring<MOD>(m).inv();
for (int l = 1; l < n; l++) {
if (l > m) continue;
A *= NINV;
B *= MINV;
if (l == n - 1) {
rez += binom(n - 2, l - 1) * binom(m - 1, l - 1) * fact[l - 1];
} else {
Ring<MOD> linv = invfact[l - 1];
rez += (fact[n - 2] * linv * invfact[n - 2 - (l - 1)]) *
(fact[m - 1] * linv * invfact[m - 1 - (l - 1)]) * (l + 1) * A * B *
fact[l - 1];
}
}
smart_io::precall_print();
cout, rez;
}
| 2,400 | CPP |
#include <bits/stdc++.h>
const int N = 110;
int a[N][N], r[N], c[N];
int main() {
int n, m;
while (~scanf("%d%d", &n, &m)) {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
scanf("%d", &a[i][j]);
}
}
int ans(-1), r0;
for (int k = 0; k <= a[0][0]; ++k) {
r[0] = k;
bool f = true;
for (int j = 0; j < m; ++j) {
c[j] = a[0][j] - r[0];
if (c[j] < 0) f = false;
}
if (!f) continue;
for (int i = 1; i < n; ++i) {
r[i] = a[i][0] - c[0];
for (int j = 0; j < m; ++j) {
if (a[i][j] - c[j] != a[i][0] - c[0]) f = false;
}
if (r[i] < 0) f = false;
if (!f) break;
}
if (!f) continue;
int tmp(0);
for (int i = 0; i < n; ++i) tmp += r[i];
for (int j = 0; j < m; ++j) tmp += c[j];
if ((ans == -1 || ans > tmp)) ans = tmp, r0 = k;
}
if (ans != -1) {
printf("%d\n", ans);
r[0] = r0;
for (int j = 0; j < m; ++j)
if (a[0][j] - r[0]) {
c[j] = a[0][j] - r[0];
for (int k = 0; k < c[j]; ++k) printf("col %d\n", j + 1);
}
for (int i = 0; i < n; ++i)
for (int k = 0; k < a[i][0] - c[0]; ++k) printf("row %d\n", i + 1);
} else {
puts("-1");
}
}
return 0;
}
| 1,700 | CPP |
x=input()
if(len(x)>1):
y=x[0].upper() + x[1:]
print(y)
else:
x=x.upper()
print(x)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long k;
int a, b;
long long ap, bp;
int ar[3][3];
int br[3][3];
bool visited[3][3];
long long aap, bap;
void update(int x, int y) {
if (x == 1 && y == 2) {
bp++;
bap++;
}
if (x == 1 && y == 3) {
ap++;
aap++;
}
if (x == 2 && y == 1) {
ap++;
aap++;
}
if (x == 2 && y == 3) {
bp++;
bap++;
}
if (x == 3 && y == 1) {
bp++;
bap++;
}
if (x == 3 && y == 2) {
ap++;
aap++;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
aap = 0;
bap = 0;
cin >> k >> a >> b;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) cin >> ar[i][j];
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) cin >> br[i][j];
}
int ca = a, cb = b;
long long tlength = 0;
while (!visited[ca - 1][cb - 1]) {
tlength++;
visited[ca - 1][cb - 1] = 1;
update(ca, cb);
if (tlength == k) break;
int cca = ca, ccb = cb;
cca = ar[ca - 1][cb - 1];
ccb = br[ca - 1][cb - 1];
ca = cca;
cb = ccb;
}
long long cyc = 2520;
aap = 0;
bap = 0;
for (int i = 0; i < min(k - tlength, cyc); i++) {
update(ca, cb);
int cca = ca, ccb = cb;
cca = ar[ca - 1][cb - 1];
ccb = br[ca - 1][cb - 1];
ca = cca;
cb = ccb;
}
if (cyc > k - tlength) {
cout << ap << " " << bp << "\n";
return 0;
}
long long numCycles = (k - tlength) / cyc - 1;
ap += numCycles * aap;
bp += numCycles * bap;
for (int i = 0; i < k - tlength - numCycles * cyc - cyc; i++) {
update(ca, cb);
int cca = ca, ccb = cb;
cca = ar[ca - 1][cb - 1];
ccb = br[ca - 1][cb - 1];
ca = cca;
cb = ccb;
}
cout << ap << " " << bp << "\n";
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
inline int add(int a, int b) {
if ((a += b) >= mod) a -= mod;
return a;
}
inline void _add(int &a, int b) {
if ((a += b) >= mod) a -= mod;
}
inline int dec(int a, int b) {
if ((a -= b) < 0) a += mod;
return a;
}
inline int mult(int a, int b) {
long long t = 1ll * a * b;
if (t >= mod) t %= mod;
return t;
}
inline int power(int a, int b) {
int out = 1;
while (b) {
if (b & 1) out = mult(out, a);
a = mult(a, a);
b >>= 1;
}
return out;
}
int fac[55], n, T, pre[55][55][55][3], cnt[3], g[55], t[55];
int main() {
scanf("%d%d", &n, &T);
pre[1][0][0][0] = pre[0][1][0][1] = pre[0][0][1][2] = 1;
for (int i = 2; i <= n; i++) {
for (int c1 = 0; c1 < i; c1++) {
for (int c2 = 0; c1 + c2 < i; c2++) {
int c3 = i - 1 - c1 - c2;
for (int k = 0; k < 3; k++) {
if (k)
pre[c1 + 1][c2][c3][0] =
add(pre[c1 + 1][c2][c3][0], mult(pre[c1][c2][c3][k], c1 + 1));
if (k != 1)
pre[c1][c2 + 1][c3][1] =
add(pre[c1][c2 + 1][c3][1], mult(pre[c1][c2][c3][k], c2 + 1));
if (k != 2)
pre[c1][c2][c3 + 1][2] =
add(pre[c1][c2][c3 + 1][2], mult(pre[c1][c2][c3][k], c3 + 1));
}
}
}
}
for (int i = 1; i <= n; i++) {
scanf("%d%d", &t[i], &g[i]);
g[i]--;
cnt[g[i]]++;
}
vector<vector<vector<int> > > f[2502];
for (int i = 0; i <= T; i++) {
f[i].resize(cnt[0] + 1);
for (int j = 0; j <= cnt[0]; j++) {
f[i][j].resize(cnt[1] + 1);
for (int k = 0; k <= cnt[1]; k++) f[i][j][k].resize(cnt[2] + 1);
}
}
f[0][0][0][0] = 1;
for (int i = 1; i <= n; i++) {
if (T < t[i]) continue;
for (int j = T - t[i]; ~j; j--) {
for (int k = cnt[0] - (g[i] == 0); ~k; k--) {
for (int l = cnt[1] - (g[i] == 1); ~l; l--) {
if (k + l <= i)
for (int s = cnt[2] - (g[i] == 2); ~s; s--) {
if (f[j][k][l][s]) {
if (g[i] == 0)
_add(f[j + t[i]][k + 1][l][s], f[j][k][l][s]);
else if (g[i] == 1)
_add(f[j + t[i]][k][l + 1][s], f[j][k][l][s]);
else
_add(f[j + t[i]][k][l][s + 1], f[j][k][l][s]);
}
}
}
}
}
}
int ans = 0;
for (int i = 0; i <= cnt[0]; i++) {
for (int j = 0; j <= cnt[1]; j++) {
for (int k = 0; k <= cnt[2]; k++) {
int sum = 0;
for (int l = 0; l < 3; l++) sum = add(sum, pre[i][j][k][l]);
_add(ans, mult(sum, f[T][i][j][k]));
}
}
}
printf("%d\n", ans);
return 0;
}
| 2,100 | CPP |
#Simple non-optimized class of matrices. Used with small dense matrices.
import functools
import itertools
import math
class NotAMatrixError(Exception):
pass
class MatrixSizeError(Exception):
def __init__(self, s1, s2):
print('sizes do not match : ', s1, ', ', s2)
class NotSquareError(Exception):
pass
class Matrix(list):
def __init__(self, L):
if type(L) == type(self):
self = L
return
n = len(L)
m = len(L[0])
for i in range(n):
if len(L[i]) != m:
raise NotAMatrixError()
list.__init__(self, L)
self.n = n
self.m = m
self.degrees = []
def check_size(self, M, mode):
n, m = len(M), len(M[0])
for i in range(n):
if len(M[i]) != m:
raise NotAMatrixError()
if mode == 'add' and (self.n != n or self.m != m):
raise MatrixSizeError((self.n, self.m), (n,m))
if mode == 'lul' and self.m != n:
print(self.m, n, self.m != n)
raise MatrixSizeError((self.n, self.m), (n,m))
def __add__(self, M):
self.check_size(M, mode = 'add')
return Matrix([[self[i][j]+M[i][j] for j in range(self.m)]for i in range(self.n)])
def __iadd__(self, M):
self.check_size(M, mode = 'add')
for i in range(self.n):
for j in range(self,m):
self[i][j] += M[i][j]
def __mul__(self, M):
self.check_size(M, mode = 'mul')
l = len(M[0])
return Matrix([[sum(self[i][k]*M[k][j] for k in range(self.m))
for j in range(l)] for i in range(self.n)])
def issquare(self):
return self.n == self.m
def primary(self):
if self.n != self.m:
raise NotSquareError()
return Matrix([[int(i==j) for j in range(self.m)] for i in range(self.n)])
def __pow__(self, n):
if self.n != self.m:
raise NotSquareError()
if n == 0:
return self.primary()
elif n == 1:
return self
if len(self.degrees) == 0:
self.degrees.append(self*self)
for i in range(n.bit_length() - len(self.degrees) - 1):
self.degrees.append(self.degrees[-1] * self.degrees[-1])
s = [(n>>i)&1 for i in range(1,n.bit_length())]
res = functools.reduce(lambda x,y:x*y, itertools.compress(self.degrees, s))
return res*self if n%2 else res
def drop_degrees(self):
self.degrees.clear()
class Remainder(int):
def __new__(self, n, p):
obj = int.__new__(self, n%p)
obj.p = p
return obj
def __mul__(self, m): return Remainder(int.__mul__(self, m), self.p)
def __add__(self, m): return Remainder(int.__add__(self, m), self.p)
def __sub__(self, m): return Remainder(int.__sub__(self, m), self.p)
def __rmul__(self, m): return Remainder(int.__rmul__(self, m), self.p)
def __radd__(self, m): return Remainder(int.__radd__(self, m), self.p)
def __rsub__(self, m): return Remainder(int.__rsub__(self, m), self.p)
def __neg__(self): return Remainder(int.__neg__(self), self.p)
def __pow__(self, m): return Remainder(int.__pow__(self, m, self.p), self.p)
def solve(n, sx, sy, dx, dy, t):
o, l, j = Remainder(0, n), Remainder(1, n), Remainder(2, n)
N = [[j, l, l, o, l, o],
[l, j, o, l, l, o],
[l, l, l, o, l, o],
[l, l, o, l, l, o],
[o, o, o, o, l, l],
[o, o, o, o, o, l]]
M = Matrix(N)
sx, sy, dx, dy = map(lambda x: Remainder(x, n), [sx, sy, dx, dy])
v = Matrix([[sx], [sy], [dx], [dy], [o], [l]])
return M ** t * v
n, sx, sy, dx, dy, t = [int(x) for x in input().split()]
ans = solve(n, sx, sy, dx, dy, t)
print(int(ans[0][0] - 1) + 1, int(ans[1][0] - 1) + 1)
| 2,300 | PYTHON3 |
import sys
ip=lambda :sys.stdin.readline().rstrip()
from collections import defaultdict
def f(n):
isv[n]=True
if n in s:
s.remove(n)
a=[]
for i in s:
if not isv[i] and i not in d[n]:
a.append(i)
for i in a:
if i in s:
s.remove(i)
for i in a:
f(i)
n,m=map(int,ip().split())
d=defaultdict(lambda :dict())
s=set()
isv=[False]*(n)
for i in range(n):
s.add(i)
for _ in range(m):
u,v=map(int,ip().split())
u-=1
v-=1
d[u][v]=True
d[v][u]=True
ans=0
for i in range(n):
if not isv[i]:
f(i)
ans+=1
print(ans-1) | 1,900 | PYTHON3 |
from functools import reduce
def main():
N=int(input())
for _ in range(N):
r,c=map(int,input().split())
M=[list(map(int,input().split())) for _ in range(r)]
L=[reduce(lambda x,y:x^y, (M[s-k][k] for k in range(max(s-r+1,0),min(s,c-1)+1))) for s in range(r+c-1)]
print("Jeel" if all(x==0 for x in L) else "Ashish")
main()
| 2,700 | PYTHON3 |
s = sum(map(int, input().split()))
if s > 0 and s % 5 == 0:
print(s // 5)
else:
print(-1)
| 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
int maxn = 1e9, minn = -1e9;
long long modpow(long long base, long long exp, int modulus) {
base %= modulus;
long long result = 1;
while (exp > 0) {
if (exp & 1) result = (result * base) % modulus;
base = (base * base) % modulus;
exp >>= 1;
}
return result;
}
int sqr(int x) { return x * x; }
bool is_prime(int x) {
for (int i = 2; i * i <= x; ++i) {
if (x % i == 0) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long x = 1234567, y = 123456, z = 1234;
int n;
scanf("%d", &n);
bool ans = false;
for (long long i = 0; i <= n; i += x) {
for (long long j = 0; j <= n; j += y) {
long long c = n - i - j;
if (c % z == 0 && c >= 0) ans = true;
}
}
if (ans)
cout << "yes";
else
cout << "no";
return 0;
}
| 1,300 | CPP |
x = int(input())
a = [int(x) for x in input().split()]
s = 0
mx = 0
for x in a:
if x > mx:
mx = x
s += x
k = mx
while (True):
s1 = 0
for x in a:
s1 += k - x
if s1 > s:
print(k)
exit(0)
k += 1
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool prime(long long int n) {
if (n < 2) return false;
for (long long int x = 2; x * x <= n; x++) {
if (n % x == 0) return false;
}
return true;
}
long long int largestDigit(long long int n) {
long long int largest = 0;
while (n) {
long long int r = n % 10;
largest = max(r, largest);
n = n / 10;
}
return largest;
}
long long int smallestDigit(long long int n) {
long long int smallest = 10;
while (n) {
long long int r = n % 10;
smallest = min(r, smallest);
n = n / 10;
}
return smallest;
}
long long int numOfFactors(long long int n) {
long long int f = 1, e = 0;
while (n % 2 == 0) {
e++;
n = n / 2;
}
f = f * (e + 1);
e = 0;
long long int o = n;
for (long long int i = 3; n > 1 && i <= sqrt(o); i += 2) {
e = 0;
while (n % i == 0) {
e++;
n = n / i;
}
f = f * (e + 1);
}
return f;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
ios::sync_with_stdio(0);
cin.tie(0);
;
long long int n;
cin >> n;
bool flag = true;
long long int cnt = 0;
while (n--) {
long long int n;
string s;
cin >> n >> s;
if (cnt == 20000 && s != "North") {
cout << "NO\n";
flag = false;
break;
}
if (cnt == 0 && s != "South") {
cout << "NO\n";
flag = false;
break;
}
if (s == "North") {
cnt -= n;
}
if (s == "South") {
cnt += n;
}
if (cnt < 0 || cnt > 20000) {
cout << "NO\n";
flag = false;
break;
}
}
if (cnt == 0 && flag)
cout << "YES\n";
else if (cnt != 0 && flag) {
cout << "NO\n";
}
}
| 1,300 | CPP |
def find(a,b,x,y,n):
t = min(b - y, n)
b -= min(b - y, n)
n -= t
if n > 0:
if b > y:
t = min(b - y, n)
b -= t
n -= t
if a > x:
t = min(a - x, n)
a -= t
n -= t
return a*b
for ik in range(int(input())):
a,b,x,y,n=map(int,input().split())
ans=min(find(a,b,x,y,n),find(b,a,y,x,n))
print(ans) | 1,100 | PYTHON3 |
# stdin = open("testdata.txt")
# def input():
# return stdin.readline().strip()
# from math import log, log2
t = int(input())
for _ in range(t):
n = int(input())
seq = list(input())
stack = []
count = 0
i = 0
while i < len(seq):
char = seq[i]
if char == '(':
stack.append('(')
elif stack:
stack.pop()
else:
count += 1
seq.append(')')
i += 1
print(count)
| 1,000 | PYTHON3 |
# import os
n = int(input())
a = ''.join(input().split())
s = a[-1]
a = a[:-1]
while a and a[-1] == s:
a = a[:-1]
print(len(a))
| 800 | PYTHON3 |
n,k=input(). split(' ')
n=int(n);k=int(k);c=[]
a=[c.append(int(i)) for i in input().split(' ')]
del a;co=0;
for i in range(n):
if(c[i]>=c[k-1] and c[i]!=0):
co=co+1;
print(co) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
scanf("%d", &n);
int l = 1, r = 1 + n / 2;
int ll, rr, hh;
printf("? %d\n", l);
fflush(stdout);
scanf("%d", &ll);
printf("? %d\n", r);
fflush(stdout);
scanf("%d", &rr);
if (ll == rr) {
puts("! 1");
fflush(stdout);
return 0;
}
ll -= rr;
rr = -ll;
while (l + 1 < r) {
int md = l + r >> 1;
printf("? %d\n", md);
fflush(stdout);
int hh;
scanf("%d", &hh);
int oo = md + n / 2;
if (oo > n) oo -= n;
printf("? %d\n", oo);
fflush(stdout);
scanf("%d", &oo);
hh -= oo;
if (hh == 0) {
printf("! %d\n", md);
fflush(stdout);
return 0;
} else if (hh * ll > 0) {
l = md;
ll = hh;
} else {
r = md;
rr = hh;
}
}
puts("! -1");
fflush(stdout);
}
| 2,000 | CPP |
#include <bits/stdc++.h>
int dis[1001], com[1001], res[1001], tot[1001];
int main() {
int m, k;
memset(res, 0x3f, sizeof res);
scanf("%d%d", &m, &k);
for (int i = 0; i < m; ++i) scanf("%d", &dis[i]);
for (int i = 0; i < m; ++i) scanf("%d", &com[i]);
res[0] = 0, tot[0] = com[0];
for (int i = 0; i < m; ++i) {
int t = res[i];
int c = tot[i];
for (int j = i + 1; j <= m; ++j) {
t += dis[j - 1];
c -= dis[j - 1];
if (c < 0) {
int x = -c / com[i];
if (c % com[i]) ++x;
c += x * com[i];
t += x * k;
}
c += com[j];
if (res[j] > t)
res[j] = t, tot[j] = c;
else if (res[j] == t && tot[j] < c)
tot[j] = c;
}
}
printf("%d\n", res[m]);
return 0;
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int N = (int)1e5 + 10;
struct Node {
Node *left, *right;
int sum;
Node() : left(NULL), right(NULL), sum(0){};
Node(int sum) : sum(sum) { right = left = NULL; };
};
typedef Node *tree;
tree val[100007];
int sum(tree T) {
if (!T) return 0;
return T->sum;
}
void update(tree &T, int tl, int tr, int l, int r, int add) {
if (tr < l || r < tl) return;
if (!T) T = new Node(0);
if (l <= tl && tr <= r)
T->sum += add;
else {
int tm = (tl + tr) >> 1;
update(T->left, tl, tm, l, r, add);
update(T->right, tm + 1, tr, l, r, add);
}
}
int get(tree &T, int tl, int tr, int pos) {
if (!T) return 0;
if (tl == tr) return T->sum;
int tm = (tl + tr) >> 1;
if (pos <= tm)
return get(T->left, tl, tm, pos) + T->sum;
else
return get(T->right, tm + 1, tr, pos) + T->sum;
}
struct query {
int tp, time, x;
};
int n;
query q[N];
vector<int> numx;
int main() {
for (int i = 0; i <= 100005; ++i) val[i] = NULL;
cin >> n;
numx.resize(n);
for (int i = 0; i < n; ++i) {
cin >> q[i].tp >> q[i].time >> q[i].x;
numx[i] = q[i].x;
}
sort(numx.begin(), numx.end());
for (int i = 0; i < n; ++i) {
q[i].x = lower_bound(numx.begin(), numx.end(), q[i].x) - numx.begin();
}
for (int i = 0; i < n; ++i) {
if (q[i].tp == 1) update(val[q[i].x], 1, inf, q[i].time, inf, 1);
if (q[i].tp == 2) update(val[q[i].x], 1, inf, q[i].time, inf, -1);
if (q[i].tp == 3) cout << get(val[q[i].x], 1, inf, q[i].time) << endl;
}
return 0;
}
| 2,000 | CPP |
"""
n=int(z())
for _ in range(int(z())):
x=int(z())
l=list(map(int,z().split()))
n=int(z())
l=sorted(list(map(int,z().split())))[::-1]
a,b=map(int,z().split())
l=set(map(int,z().split()))
led=(6,2,5,5,4,5,6,3,7,6)
vowel={'a':0,'e':0,'i':0,'o':0,'u':0}
color4=["G", "GB", "YGB", "YGBI", "OYGBI" ,"OYGBIV",'ROYGBIV' ]
"""
#!/usr/bin/env python
#pyrival orz
import os
import sys
from io import BytesIO, IOBase
input = sys.stdin.readline
############ ---- Input Functions ---- ############
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s) - 1]))
def invr():
return(map(int,input().split()))
def main():
try:
n, m = invr()
a = inlt()
s = 0
for _ in range(m):
t = inlt()
if t[0] == 1:
a[t[1]-1] = t[2] - s
elif t[0] == 2:
s += t[1]
else:
print(a[t[1]-1] + s)
except Exception as e:
print(e)
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main() | 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long double n, m, o;
cin >> n >> m;
o = fmod(m, (pow(2, n)));
unsigned long long int p = o;
cout << p;
return 0;
}
| 900 | CPP |
n = int(input())
ls = list(map(int,input().split()))
m = int(input())
ls1 = list(map(int,input().split()))
ls.sort(reverse = True)
sum = 0
for i in range(0,n):
sum += ls[i]
for i in range(0,m):
print(sum-ls[ls1[i]-1]) | 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_L = 1000 * 2 + 10;
pair<int, int> tasks[MAX_L];
int n, temp;
int main() {
int count = 0, start1 = -1, start2 = -1;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> temp;
tasks[i].first = temp;
tasks[i].second = i + 1;
}
sort(&tasks[0], &tasks[n]);
for (int i = 0; i < n - 1; i++) {
if (tasks[i].first == tasks[i + 1].first) {
count++;
if (start1 == -1)
start1 = i;
else if ((start1 != -1) && (start2 == -1))
start2 = i;
}
}
if (count < 2)
cout << "NO" << endl;
else {
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
if (i)
cout << " " << tasks[i].second;
else
cout << tasks[i].second;
}
cout << endl;
for (int i = 0; i < n; i++) {
if (i != start1) {
if (i)
cout << " " << tasks[i].second;
else
cout << tasks[i].second;
} else {
if (i)
cout << " " << tasks[i + 1].second << " " << tasks[i].second;
else
cout << tasks[i + 1].second << " " << tasks[i].second;
i++;
}
}
cout << endl;
for (int i = 0; i < n; i++) {
if (i != start2) {
if (i)
cout << " " << tasks[i].second;
else
cout << tasks[i].second;
} else {
if (i)
cout << " " << tasks[i + 1].second << " " << tasks[i].second;
else
cout << tasks[i + 1].second << " " << tasks[i].second;
i++;
}
}
cout << endl;
}
}
| 1,300 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:25600000")
using namespace std;
int n;
map<string, int> mp;
vector<pair<int, string> > vv;
int ls[1024];
int mr[1024];
int main() {
int n;
cin >> n;
for (long long i = 0; i < n; i++) {
string s;
int x;
cin >> s >> x;
if (mp.find(s) == mp.end()) mp[s] = x;
mp[s] = max(mp[s], x);
}
for (map<string, int>::iterator it = mp.begin(); it != mp.end(); ++it) {
vv.push_back(make_pair(it->second, it->first));
}
sort((vv).begin(), (vv).end());
n = vv.size();
for (long long i = 0; i < n; i++)
for (long long j = 0; j < n; j++)
if (vv[j].first <= vv[i].first)
++ls[i];
else
++mr[i];
cout << n << endl;
for (long long i = 0; i < n; i++) {
cout << vv[i].second << " ";
if (ls[i] * 100 >= 99 * n) {
cout << "pro\n";
continue;
}
if (ls[i] * 100 >= 90 * n && mr[i] * 100 > 1 * n) {
cout << "hardcore\n";
continue;
}
if (ls[i] * 100 >= 80 * n && mr[i] * 100 > 10 * n) {
cout << "average\n";
continue;
}
if (ls[i] * 100 >= 50 * n && mr[i] * 100 > 20 * n) {
cout << "random\n";
continue;
}
if (mr[i] * 100 > n * 50) {
cout << "noob\n";
continue;
}
}
}
| 1,400 | CPP |
import sys
import math
import bisect
def main():
n = int(input())
A = list(map(int, input().split()))
A.sort(reverse=True)
ans = 0
for i in range(n):
if i % 2 == 0:
ans += A[i] ** 2
else:
ans -= A[i] ** 2
ans *= math.pi
print('%.10f' % (ans))
if __name__ == "__main__":
main()
| 1,000 | PYTHON3 |
t=int(input())
for i in range(t):
x=input()
x=max(list(map(int,input().split(" "))))
y=max(list(map(int,input().split(" "))))
if x>y:
print("YES")
else:
print("NO")
| 800 | PYTHON3 |
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO, IOBase
def main():
for _ in range(int(input())):
s = list(input().strip())
n = len(s)
ans = 0
for i in range(1,n):
fl = 0
for j in range(max(0,i-2),i):
if s[j] == s[i]:
fl = 1
if not fl:
continue
ans += 1
s[i] = -1
print(ans)
#Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == '__main__':
main() | 1,300 | PYTHON3 |
def solve():
n = int(input())
for i in range(n):
a, b = sorted(map(int, input().split()))
c, d = sorted(map(int, input().split()))
if b == d and a + c == b:
print("Yes")
else:
print("No")
pass
solve() | 900 | PYTHON3 |
import sys,functools,collections,bisect,math,heapq
input = sys.stdin.readline
#print = sys.stdout.write
mod = 10**9 + 7
sys.setrecursionlimit(300000)
@functools.lru_cache(None)
def fac(n):
ans = 1
while n:
ans *= n
ans %= mod
n -=1
return ans
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int,input().strip().split()))
a.sort()
d = collections.Counter(a)
x = 10**34-1
for i in range(n):
x = x&a[i]
if d[x] <= 1:
print(0)
continue
else:
ans = (d[x]*(d[x]-1))
ans %= mod
ans *= fac(n-2)
ans %= mod
print(ans) | 1,400 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int r, l;
};
int p[2000010], a[2000010], b[2000010], ans[2000010], flag[2000010], R[2000010],
L[2000010], lR[2000010], lL[2000010], n, w[2000010], sum[2000010],
maxx[2000010], psum[2000010], ansum;
vector<int> c[1000010];
void build(int num, int r, int l) {
if (r == l) {
R[num] = r - 1;
L[num] = l + 1;
return;
}
int mid = (r + l) >> 1;
build(num << 1, r, mid);
build((num << 1) | 1, mid + 1, l);
return;
}
void putr(int num) {
lR[num * 2] = lR[num * 2 + 1] = R[num * 2] = R[num * 2 + 1] = lR[num];
lR[num] = 0;
}
void putl(int num) {
lL[num * 2] = lL[num * 2 + 1] = L[num * 2] = L[num * 2 + 1] = lL[num];
lL[num] = 0;
}
node find(int num, int r, int l, int x) {
if (r == l) {
node ans;
ans.r = R[num];
ans.l = L[num];
return ans;
}
if (lR[num]) putr(num);
if (lL[num]) putl(num);
int mid = (r + l) >> 1;
if (x <= mid) return find(num << 1, r, mid, x);
return find((num << 1) | 1, mid + 1, l, x);
}
void updater(int num, int r, int l, int x, int y, int p) {
if (x <= r && l <= y) {
R[num] = p;
lR[num] = p;
return;
}
if (lR[num]) putr(num);
if (lL[num]) putl(num);
int mid = (r + l) >> 1;
if (x <= mid) updater(num << 1, r, mid, x, y, p);
if (mid < y) updater((num << 1) | 1, mid + 1, l, x, y, p);
}
void updatel(int num, int r, int l, int x, int y, int p) {
if (x <= r && l <= y) {
L[num] = p;
lL[num] = p;
return;
}
if (lR[num]) putr(num);
if (lL[num]) putl(num);
int mid = (r + l) >> 1;
if (x <= mid) updatel(num << 1, r, mid, x, y, p);
if (mid < y) updatel((num << 1) | 1, mid + 1, l, x, y, p);
}
void change(int num, int r, int l, int x, int y, int z) {
if (x <= r && l <= y) {
if (ans[num] != 0)
ans[num] = min(ans[num], z);
else
ans[num] = z;
return;
}
int mid = (r + l) >> 1;
if (x <= mid) change(num << 1, r, mid, x, y, z);
if (mid < y) change((num << 1) | 1, mid + 1, l, x, y, z);
}
void add1(int num, int r, int l, int x, int y) {
if (r == l) {
psum[num] += y;
if (psum[num])
maxx[num] = r;
else
maxx[num] = 0;
return;
}
int mid = (r + l) / 2;
if (x <= mid)
add1(num * 2, r, mid, x, y);
else
add1(num * 2 + 1, mid + 1, l, x, y);
maxx[num] = max(maxx[num * 2], maxx[num * 2 + 1]);
}
void comeback(int x, int y) {
node ans = find(1, 1, n, x);
flag[x] = 0;
if (w[ans.r] == 1) {
change(1, 1, n, ans.r, (ans.r + ans.l) / 2, y);
}
if (w[ans.l] == 1) {
change(1, 1, n, (ans.r + ans.l) / 2 + 1, ans.l, y);
}
updatel(1, 1, n, ans.r, x, ans.l);
updater(1, 1, n, x, ans.l, ans.r);
if (x - ans.r > 1) add1(1, 1, n, (x - ans.r) / 2, -1);
if (ans.l - x > 1) add1(1, 1, n, (ans.l - x) / 2, -1);
if (ans.l - ans.r > 1) add1(1, 1, n, (ans.l - ans.r) / 2, 1);
}
void add(int x, int y) {
node ans = find(1, 1, n, x);
if (w[x] == 1) change(1, 1, n, (ans.r + x) / 2 + 1, (x + ans.l) / 2, y);
if (!flag[x]) {
if (x - ans.r > 1) add1(1, 1, n, (x - ans.r) / 2, 1);
if (ans.l - x > 1) add1(1, 1, n, (ans.l - x) / 2, 1);
if (ans.l - ans.r > 1) add1(1, 1, n, (ans.l - ans.r) / 2, -1);
}
flag[x] = 1;
if (x != 1) updatel(1, 1, n, ans.r, x - 1, x);
if (x != n) updater(1, 1, n, x + 1, ans.l, x);
}
void getans(int num, int r, int l, int x) {
if (ans[num]) x = min(ans[num], x);
if (r == l) {
sum[r] = x;
return;
}
int mid = (r + l) / 2;
getans(num * 2, r, mid, x);
getans(num * 2 + 1, mid + 1, l, x);
}
int main() {
int i, j, tot = 0;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
p[++tot] = a[i];
}
sort(p + 1, p + tot + 1);
int l1 = unique(p + 1, p + tot + 1) - p - 1;
for (i = 1; i <= n; i++) {
b[i] = lower_bound(p + 1, p + l1 + 1, a[i]) - p;
c[b[i]].push_back(i);
}
build(1, 1, n);
for (i = 1; i <= n; i++) flag[i] = 1;
for (i = 1; i <= l1; i++) {
int h = c[i].size();
for (j = 0; j < h; j++) {
int x = c[i][j];
}
for (j = 0; j < h; j++) {
int x = c[i][j];
w[x] = 1;
if (w[x + 1] == 1 || w[x - 1] == 1 || x == 1 || x == n) add(x, p[i]);
if (w[x + 1] == 0 && w[x - 1] == 0 && x != 1 && x != n) comeback(x, p[i]);
if (w[x - 1] == 0 && w[x - 2] != 0 && x - 1 != 1) comeback(x - 1, p[i]);
if (w[x - 1] == 1) add(x - 1, p[i]);
if (w[x + 1] == 0 && w[x + 2] != 0 && x + 1 != n) comeback(x + 1, p[i]);
if (w[x + 1] == 1) add(x + 1, p[i]);
}
ansum = max(ansum, maxx[1]);
}
printf("%d\n", ansum);
getans(1, 1, n, 1000000007);
for (i = 1; i <= n; i++) printf("%d ", sum[i]);
}
| 3,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > ed[5005];
int vis[5005];
int dp[5005][5005], papa[5005][5005];
int rec(int i, int h) {
if (i == 1 && h == 1) return 0;
if (i == 1 || h == 1) return 1e9 + 5;
if (dp[i][h] != -1) return dp[i][h];
int mini = 1e9 + 5;
for (pair<int, int> p : ed[i]) {
if (!vis[p.first]) continue;
int y = p.second + rec(p.first, h - 1);
if (y < mini) {
mini = y;
papa[i][h] = p.first;
}
}
return dp[i][h] = mini;
}
void dfs(int u) {
vis[u] = 1;
for (pair<int, int> v : ed[u]) {
if (!vis[v.first]) dfs(v.first);
}
}
int n, m, T, i;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m >> T;
for (i = 0; i < m; i++) {
int u, v, t;
cin >> u >> v >> t;
ed[v].push_back(pair<int, int>(u, t));
}
dfs(n);
vector<int> res;
int x;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) dp[i][j] = -1;
for (int i = 1; i <= n; i++) {
int a = rec(n, i);
if (a <= T) {
x = i;
}
}
i = n;
while (x > 0) {
res.push_back(i);
i = papa[i][x];
x--;
}
cout << (int)res.size() << "\n";
for (int j = res.size() - 1; j >= 0; j--) cout << res[j] << " ";
}
| 1,800 | CPP |
t = int(input())
i=1
for i in range(t):
a,b = map(int, input().split())
if(a==b):
print((2*a)**2)
elif(a>b):
if(a>(2*b)):
print(a**2)
else:
print((2*b)**2)
else:
if((2*a)<b):
print(b**2)
else:
print((2*a)**2) | 800 | PYTHON3 |
n = int(input())
a = list(map(int,input().split()))
b = [0]*(max(a)+1)
for i in a:
b[i]+=1
ans=1
for i in range(n-1,-1,-1):
c = [j for j in b]
c.sort()
ind = c.count(0)
if (c.count(c[ind])==len(c)-ind-1 and c[-1]-1==c[ind]) or (c.count(c[-1])==len(c)-1-ind and c[ind]==1) or (c.count(c[-1])==len(c)-ind and c[-1]==1) or (len(c)-ind==1):
ans=i+1
break
else:
b[a[i]]-=1
print(ans) | 1,500 | PYTHON3 |
#include<bits/stdc++.h>
#define int long long
using namespace std;
int32_t main()
{
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin>>t;
while(t--)
{int n,k;
cin>>n>>k;
int ok=1;
int poss=0;
for(int i=0;i<n-1;i++)
{ok=ok*2;
if(ok>=k){poss=1;break;}
}
if(ok<k){cout<<"-1\n";continue;}
vector<int> v;
k--;
for(int i=0;i<n-1;i++)
{//Should I take i+1
int poss=0;
int z=1;
for(int j=0;j<n-i-2;j++)
{z=z*2;
if(z>k){break;}
}
if(z>k)
{v.push_back(i+1);
}
else
{k-=z;
}
}
v.push_back(n);
int visited[n];
memset(visited,0,sizeof(visited));
for(auto x:v)
{
visited[x-1]=1;
cout<<x<<" ";
for(int i=x-1;i>0;i--)
{
if(visited[i-1]==1){break;}
cout<<i<<" ";
}
}
cout<<"\n";
}
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
const long long offset = N + 1;
const long long MAX = N + offset + 1;
long long bit[MAX];
long long read(long long i) {
long long ans = 0;
i += offset;
while (i > 0) {
ans += bit[i];
i -= (i & (-i));
}
return ans;
}
void update(long long i) {
i += offset;
while (i < MAX) {
bit[i] += 1;
i += (i & (-i));
}
return;
}
long long n, arr[N];
long long pref[N];
long long brute(long long m) {
vector<pair<long long, long long> > subs;
long long cnt = 0;
for (long long i = 1; i <= n; ++i) {
vector<long long> temp;
for (long long j = i; j <= n; ++j) {
temp.push_back(arr[j]);
sort(temp.begin(), temp.end());
long long idx = (temp.size() - 1) / 2;
if (temp[idx] >= m) {
++cnt;
subs.push_back({i, j});
}
}
}
return cnt;
}
long long calc(long long m) {
for (long long i = 1; i < n + 1; ++i) {
long long temp = (arr[i] >= m) ? 1 : -1;
pref[i] = pref[i - 1] + temp;
}
memset(bit, 0, sizeof(bit));
update(0);
long long ans = 0;
for (long long i = 1; i <= n; ++i) {
long long got = read(pref[i] - 1);
ans = ans + got;
update(pref[i]);
}
return ans;
}
int32_t main() {
long long m;
cin >> n >> m;
for (long long i = 1; i <= n; ++i) cin >> arr[i];
long long ans = calc(m);
ans -= calc(m + 1);
cout << ans << endl;
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, even = 0, odd = 0, ans = 0, a;
cin >> n;
while (n--) {
cin >> a;
if (a % 2 != 0)
odd++;
else
even++;
}
if (odd <= even)
ans += odd;
else {
ans += even;
ans += (odd - even) / 3;
}
cout << ans;
return 0;
}
| 1,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (s.length() == 1) {
int temp = s[s.length() - 1] - 48;
if (temp % 4 == 0)
cout << 4;
else
cout << 0;
} else {
int temp = s[s.length() - 1] - 48 + 10 * (s[s.length() - 2] - 48);
if (temp % 4 == 0) {
cout << 4;
} else
cout << 0;
}
return 0;
}
| 1,200 | CPP |
n,k,m = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.sort(reverse = True)
for i in range(1,len(a)):
a[i] += a[i-1]
for i in range(n):
if n-1-i <= m:
a[i] = float(a[i] + min(m-(n-1-i), k*(i+1)))/(i+1)
print(max(a[max(n-1-m,0):]))
| 1,700 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
char s[11];
int a[10][2][2] = {{{0, 1}, {1, 1}}, {{1, 0}, {0, 0}}, {{1, 0}, {1, 0}},
{{1, 1}, {0, 0}}, {{1, 1}, {0, 1}}, {{1, 0}, {0, 1}},
{{1, 1}, {1, 0}}, {{1, 1}, {1, 1}}, {{1, 0}, {1, 1}},
{{0, 1}, {1, 0}}};
int i, j, k, len, b[2][25];
int main() {
scanf("%s", s);
len = strlen(s);
for (i = 0; i < len; i++)
for (j = 0; j < 2; j++)
for (k = 0; k < 2; k++) b[k][2 * i + 1 + j] = a[s[i] - 48][k][j];
for (i = 0; i < 2; i++)
for (j = 1; j <= len; j++)
if (b[i][j] != b[i][2 * len - j + 1]) {
puts("No");
return 0;
}
puts("Yes");
return 0;
}
| 1,900 | CPP |
n = int(input())
s = input().strip()
print('YES' if s[:-10].count('8')*2 > n-10 else 'NO')
| 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long a[100005];
long long ans = 1e9, sum_tec;
void dfs(long long pr, long long pt) {
long long pocl = a[2] + pt;
for (long long i = 3; i <= n; ++i) {
if (abs(a[i] - (pocl + pr)) == 1) {
pocl = pocl + pr;
sum_tec++;
} else if (a[i] != pocl + pr) {
sum_tec = 1e12;
return;
} else
pocl += pr;
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 1; i <= n; ++i) cin >> a[i];
if (n <= 2) {
cout << 0 << endl;
return 0;
}
for (long long i = -1; i <= 1; ++i) {
for (long long j = -1; j <= 1; ++j) {
sum_tec = 0;
dfs((a[2] + i) - (a[1] + j), i);
ans = min(ans, sum_tec + abs(i) + abs(j));
}
}
if (ans == (long long)1e9)
cout << -1 << endl;
else
cout << ans << endl;
return 0;
}
| 1,500 | CPP |
n=int(input())
row=input()
s=1
for i in range(1,n):
if row[i]==row[i-1]:
continue
else:
s+=1
print(n-s) | 800 | PYTHON3 |
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO, IOBase
def main():
n = int(input())
arr = list(map(int,input().split()))
su = [0]
for i in arr:
su.append(su[-1]+i)
dct = {}
pairs = {}
for ind,val in enumerate(su):
if dct.get(val) != None:
pairs[dct[val]+1] = ind-1
dct[val] = ind
ans,r = 0,-1
for i in sorted(pairs.keys()):
if i > r:
ans += 1
r = pairs[i]
else:
r = min(r,pairs[i])
print(ans)
#Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == '__main__':
main() | 1,500 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<vector<int>> a(n);
vector<int> d(n);
for (int i = 0; i < n; i++) {
vector<int> t(3);
a[i] = t;
cin >> d[i];
}
a[0][0] = 1;
a[0][1] = 1;
a[0][2] = 1;
if (d[0] == 3 || d[0] == 2) a[0][2] = 0;
if (d[0] == 3 || d[0] == 1) a[0][1] = 0;
for (int i = 1; i < n; i++) {
int upMin = min(a[i - 1][0], min(a[i - 1][1], a[i - 1][2]));
a[i][0] = upMin + 1;
a[i][1] = upMin + 1;
a[i][2] = upMin + 1;
if (d[i] == 3 || d[i] == 2) a[i][2] = min(a[i - 1][0], a[i - 1][1]);
if (d[i] == 3 || d[i] == 1) a[i][1] = min(a[i - 1][0], a[i - 1][2]);
}
cout << min(a[n - 1][0], min(a[n - 1][1], a[n - 1][2]));
return 0;
}
| 1,400 | CPP |
testCase = int(input())
while testCase != 0:
testCase -= 1
word = input()
counter = 0
stringLength = len(word)
if stringLength <= 10:
print(word)
else:
print(word[0] + str(stringLength - 2) + word[stringLength - 1]) | 800 | PYTHON3 |
import sys
input = sys.stdin.readline
I = lambda : list(map(int,input().split()))
t,=I()
for _ in range(t):
s=input().strip()
x,=I()
n=len(s)
w=['1']*len(s)
pos=1
for i in range(n):
if s[i]=='0':
if i>=x:
w[i-x]='0'
if i<=n-x-1:
w[i+x]='0'
con=""
for i in range(n):
st=0
if i>=x:
st+=int(w[i-x])
if i<=n-x-1:
st+=int(w[i+x])
con+='1' if st else '0'
if con!=s:
pos=0
#print(con,s,w)
if pos:
print(''.join(w))
else:
print(-1) | 1,500 | PYTHON3 |
import sys
inf = float("inf")
# sys.setrecursionlimit(10000000)
# abc='abcdefghijklmnopqrstuvwxyz'
# abd={'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod, MOD = 1000000007, 998244353
# words = {1:'one',2:'two',3:'three',4:'four',5:'five',6:'six',7:'seven',8:'eight',9:'nine',10:'ten',11:'eleven',12:'twelve',13:'thirteen',14:'fourteen',15:'quarter',16:'sixteen',17:'seventeen',18:'eighteen',19:'nineteen',20:'twenty',21:'twenty one',22:'twenty two',23:'twenty three',24:'twenty four',25:'twenty five',26:'twenty six',27:'twenty seven',28:'twenty eight',29:'twenty nine',30:'half'}
# vow=['a','e','i','o','u']
# dx,dy=[0,1,0,-1],[1,0,-1,0]
# import random
# from collections import deque, Counter, OrderedDict,defaultdict
# from heapq import nsmallest, nlargest, heapify,heappop ,heappush, heapreplace
# from math import ceil,floor,log,sqrt,factorial,pi,gcd,degrees,atan2
# from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
def get_array(): return list(map(int, sys.stdin.readline().strip().split()))
def get_ints(): return map(str, sys.stdin.readline().strip().split())
def input(): return sys.stdin.readline().strip()
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')
def checker(lst):
value = lst[0]
for i in range(1,n):
if lst[i]!=value:
return False
return True
n = int(input())
string = input()
lst1,lst2 = [],[]
for i in string:
if i=='W':
lst1.append(1)
lst2.append(1)
else:
lst1.append(0)
lst2.append(0)
# if checker(lst):
# print(0)
# exit()
one = [1]*n
zero = [0]*n
ans = []
for i in range(n-1):
if lst1[i]==1:
continue
else:
lst1[i] = 1
lst1[i+1] = lst1[i+1]^1
ans.append(i+1)
# print(lst1)
if checker(lst1):
print(len(ans))
print(*ans)
exit()
ans = []
for i in range(n-1):
if lst2[i]==0:
continue
else:
lst2[i] = 0
lst2[i+1] = lst2[i+1]^1
ans.append(i+1)
if checker(lst2):
print(len(ans))
print(*ans)
exit()
print(-1)
| 1,300 | PYTHON3 |
def sol():
s = input()
return s[0].upper() + s[1:]
print(sol())
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
getline(cin, s);
int len, count = 0;
len = s.length();
sort(s.begin(), s.end());
for (int i = 0; i < len; i++) {
if (s[i] >= 97 && s[i] <= 122) {
count++;
if (s[i] == s[i + 1]) {
count--;
}
}
}
cout << count << endl;
return 0;
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9 + 2;
const int maxn = 1e5 + 10;
const int maxq = 1e3 + 10;
const int alf = 26;
const int dlm = 1e9 + 7;
const long long mod = 998244353;
string O[] = {"YES", "NO", "Yes", "No"};
long long egcd(long long a, long long b, long long &x, long long &y) {
long long d;
if (b == 0) {
x = 1;
y = 0;
return a;
}
d = egcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
long long inv(long long u, long long n) {
long long x, y, g = egcd(u, n, x, y);
if (g != 1) return -1;
return (x % n + n) % n;
}
int main() {
int n;
cin >> n;
long long ans = 1;
for (int i = n + 1; i <= (2 * n - 1); i++) {
ans *= i;
ans %= dlm;
}
long long q = 1;
for (int i = 1; i <= (n - 1); i++) {
q *= i;
q %= dlm;
}
ans = ans * inv(q, dlm);
ans %= dlm;
ans *= 2;
ans %= dlm;
ans -= n;
ans %= dlm;
cout << ans;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, rating[100000], rating1[100000], hash[10], k, i, points = 0,
poss;
cin >> n >> k;
for (i = 0; i < 10; i++) {
hash[i] = 0;
}
for (i = 0; i < n; i++) {
cin >> rating[i];
hash[rating[i] % 10] += 1;
poss += rating[i];
points += rating[i] / 10;
}
if (k >= n * 100 - poss)
cout << 10 * n;
else {
for (i = 1; i < 10; i++) hash[i] += hash[i - 1];
for (i = n - 1; i >= 0; i--) {
rating1[hash[rating[i] % 10] - 1] = rating[i];
hash[rating[i] % 10]--;
}
for (i = n - 1; k > 0 && i >= 0; i--) {
if (k >= 10 - rating1[i] % 10) {
k -= 10 - rating1[i] % 10;
points++;
rating1[i] += 10 - rating1[i] % 10;
} else
break;
}
i = n - 1;
while (k > 10) {
if (rating1[i] >= 100) {
i--;
continue;
}
if (k >= 100 - rating1[i]) {
k -= 100 - rating1[i];
points += (100 - rating1[i]) / 10;
} else {
points += k / 10;
break;
}
i--;
}
cout << points;
}
return 0;
}
| 1,400 | CPP |
n,k = map(int,input().split())
if k==1 or k==n: print(6+(n-2)*3)
else: print(8+min(k,n-k+1)+(n-3)*3) | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q, u[105], v[105], a[105], b[105], c[105], bt[1 << 13];
long long f[13][1 << 13];
bool check(int x, int y, int s) {
for (int i = 1; i <= m; i++)
if (1 & (s >> u[i])) {
if (!(1 & (s >> v[i]))) {
if (y != u[i] || x != v[i]) return false;
}
}
for (int i = 1; i <= m; i++)
if (1 & (s >> v[i])) {
if (!(1 & (s >> u[i]))) {
if (y != v[i] || x != u[i]) return false;
}
}
return true;
}
bool calc(int s) {
for (int i = 1; i <= q; i++) {
if (((s >> b[i]) & 1) && ((s >> a[i]) & 1) && !((s >> c[i]) & 1))
return false;
if (((s >> c[i]) & 1) && (!((s >> a[i]) & 1) || !((s >> b[i]) & 1)))
return false;
}
return true;
}
long long solve(int x, int s) {
if (~f[x][s]) return f[x][s];
if (0 == (1 & (s >> x))) return f[x][s] = 0;
if (s == (s & -s)) return f[x][s] = 1;
f[x][s] = 0;
int res = s ^ (1 << x);
int hav = bt[res & -res];
res ^= 1 << hav;
for (int y = 0; y <= n - 1; y++) {
if (check(x, y, 1 << hav) && calc(1 << hav))
f[x][s] += solve(y, 1 << hav) * solve(x, s ^ (1 << hav));
for (int t = res; t; t = (t - 1) & res) {
if (check(x, y, (1 << hav) | t) && calc((1 << hav) | t))
f[x][s] += solve(y, (1 << hav) | t) * solve(x, s ^ (1 << hav) ^ t);
}
}
return f[x][s];
}
int main() {
scanf("%d%d%d", &n, &m, &q);
bt[0] = ~0;
for (int i = 1; i <= (1 << n) - 1; i++) bt[i] = bt[i >> 1] + 1;
for (int i = 1; i <= m; i++) scanf("%d%d", &u[i], &v[i]), u[i]--, v[i]--;
for (int i = 1; i <= q; i++)
scanf("%d%d%d", &a[i], &b[i], &c[i]), a[i]--, b[i]--, c[i]--;
memset(f, ~0, sizeof(f));
printf("%lld\n", solve(0, (1 << n) - 1));
return 0;
}
| 2,600 | CPP |
import math
for _ in range(int(input())):
taken_input = input().split()
n = int(taken_input[0])
k = int(taken_input[1])
sets_of_not_included = math.ceil(k/(n-1))
position_in_set = k%(n-1)
if position_in_set == 0:
position_in_set = n-1
answer = ((sets_of_not_included-1)*n)+position_in_set
print(answer)
| 1,200 | PYTHON3 |
n=int(input())
if n%2==0:
for i in range(n):
C=[]
if i%2!=0:
for k in range(n//2):
C.append('BW')
print(*C,sep = '')
else:
for j in range(n//2):
C.append('WB')
print(*C,sep = '')
else:
for i in range(n):
C=[]
if i%2!=0:
for k in range((n-1)//2):
C.append('BW')
C.append('B')
print(*C,sep = '')
else:
for j in range((n-1)//2):
C.append('WB')
C.append('W')
print(*C,sep = '')
| 1,100 | PYTHON3 |
x = input()
lower = 0
for i in x :
if ord(i) >= 97 :
lower += 1
upper = len(x) - lower
if lower >= upper:
print(x.lower())
else:
print(x.upper())
| 800 | PYTHON3 |
def f(n):
if n < 3:
return 0
return n // 2 if n % 2 else n // 2 - 1
def main():
t = int(input())
for _ in range(t):
print(f(int(input())))
main() | 800 | PYTHON3 |
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
from collections import defaultdict
from itertools import permutations
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#-------------------game starts now-----------------------------------------------------
s = input()
t = input()
s_count = 0
t_count = 0
s_count_0 = 0
t_count_0 = 0
for i in s:
if i is '1':
s_count += 1
for i in t:
if i is '1':
t_count += 1
s_count_0 = len(s) - s_count
t_count_0 = len(t) - t_count
match = [0]
j = 0
i = 1
while i < len(t):
while t[j] is not t[i]:
j -= 1
if j < 0:
break
j = match[j]
if j < 0:
j = 0
match.append(0)
else:
match.append(j+1)
j += 1
i += 1
remaining_1 = s_count - t_count
remaining_0 = s_count_0 - t_count_0
if remaining_0 < 0 or remaining_1 < 0:
print(s)
exit(0)
for a in t[:match[-1]]:
if a is '1':
t_count -= 1
else:
t_count_0 -= 1
result = [t]
if t_count is not 0 and t_count_0 is not 0:
val = int(min(remaining_1/t_count, remaining_0/t_count_0))
elif t_count is 0:
val = int(remaining_0/t_count_0)
else:
val = int(remaining_1/t_count)
for _ in range(val):
result.append(t[match[-1]:])
for _ in range(remaining_0 - val * t_count_0):
result.append('0')
for _ in range(remaining_1 - val * t_count):
result.append('1')
print("".join(result))
| 1,600 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
class leaves {
public:
string tree;
string color;
};
int indian_summer() {
leaves *leaf;
int n, a = 0;
cin >> n;
leaf = new (nothrow) leaves[n];
for (int i = 0; i < n; i++) {
cin >> leaf[i].tree >> leaf[i].color;
a++;
for (int j = 0; j < i; j++)
if (leaf[j].tree == leaf[i].tree && leaf[j].color == leaf[i].color) {
a--;
break;
}
}
cout << a;
return 0;
}
int main() {
int t;
t = 1;
for (int i = 0; i < t; i++) indian_summer();
return 0;
}
| 900 | CPP |
#!/usr/bin/python3
# Copyright (C) 2016 Sayutin Dmitry.
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation; version 3
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; If not, see <http://www.gnu.org/licenses/>.
def is_leap(year):
return (year % 400 == 0 or (year % 100 != 0 and year % 4 == 0))
def main():
year = int(input())
newyear = year
delta = 0
while newyear == year or not (delta == 0 and is_leap(year) == is_leap(newyear)):
delta += (365 + int(is_leap(newyear)))
delta %= 7
newyear += 1
print(newyear)
main()
| 1,600 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using namespace rel_ops;
using ll = int64_t;
using Pii = pair<int, int>;
using ull = uint64_t;
using Vi = vector<int>;
void run();
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(10);
run();
return 0;
}
int uplg(int n) { return 32 - __builtin_clz(n); }
int uplg(ll n) { return 64 - __builtin_clzll(n); }
struct Treap {
struct Node {
int E[2] = {-1, -1}, weight{rand()};
int size{1}, par{-1};
bool flip{false};
};
vector<Node> G;
Treap(int n = 0) { init(n); }
void init(int n) {
G.clear();
G.resize(n);
}
int size(int first) { return (first >= 0 ? G[first].size : 0); }
void push(int first) {
if (first >= 0 && G[first].flip) {
G[first].flip = 0;
swap(G[first].E[0], G[first].E[1]);
for (auto& e : (G[first].E))
if (e >= 0) G[e].flip ^= 1;
}
}
void update(int first) {
if (first >= 0) {
G[first].par = -1;
int& s = G[first].size = 1;
for (auto& e : (G[first].E))
if (e >= 0) {
s += size(e);
G[e].par = first;
}
}
}
void split(int first, int& l, int& r, int i) {
push(first);
l = r = -1;
if (first < 0) return;
int key = size(G[first].E[0]);
if (i <= key) {
split(G[first].E[0], l, G[first].E[0], i);
r = first;
} else {
split(G[first].E[1], G[first].E[1], r, i - key - 1);
l = first;
}
update(first);
}
int join(int l, int r) {
push(l);
push(r);
if (l < 0 || r < 0) return max(l, r);
if (G[l].weight < G[r].weight) {
G[l].E[1] = join(G[l].E[1], r);
update(l);
return l;
}
G[r].E[0] = join(l, G[r].E[0]);
update(r);
return r;
}
int find(int first, int i) {
while (first >= 0) {
push(first);
int key = size(G[first].E[0]);
if (key == i) return first;
first = G[first].E[key < i];
if (key < i) i -= key + 1;
}
return first;
}
int reverse(int first, int l, int r) {
int a, b, c;
split(first, b, c, r);
split(b, a, b, l);
if (b >= 0) G[b].flip ^= 1;
return join(join(a, b), c);
}
int index(int first) {
int prev = -2, i = 0;
while (first != -1) {
if (G[first].E[0] != prev) i += size(G[first].E[0]) + 1;
prev = first;
first = G[first].par;
}
return i - 1;
}
};
struct Vert {
Vi E, back;
int state{0}, par{-1}, post{-1}, in{0}, out{0}, depth{0};
bool inTopo{false};
;
};
int n, m, s, t, post;
vector<Vert> G;
vector<Pii> ans;
Treap topo;
int topoRoot;
vector<Pii> suspended;
bool somethingChanged;
void dfs(int i) {
G[i].state = 1;
for (auto& e : (G[i].E))
if (e != G[i].par) {
if (G[e].state) {
if (G[e].state == 1) G[e].back.push_back(i);
} else {
G[e].par = i;
G[e].depth = G[i].depth + 1;
dfs(e);
}
}
G[i].state = 2;
}
void setEdge(int i, int j, bool rev) {
if (rev) swap(i, j);
if (G[i].inTopo && G[j].inTopo) return;
if (G[i].inTopo) {
int L, R, ind = topo.index(i);
topo.split(topoRoot, L, R, ind + 1);
L = topo.join(L, j);
topoRoot = topo.join(L, R);
G[j].inTopo = 1;
} else if (G[j].inTopo) {
int L, R, ind = topo.index(j);
topo.split(topoRoot, L, R, ind);
L = topo.join(L, i);
topoRoot = topo.join(L, R);
G[i].inTopo = 1;
} else {
assert(0);
}
}
int findUsed(int i) {
if (G[i].state > 2) return i;
return findUsed(G[i].par);
}
void direct(int i, bool reverse);
void addArc(int i, int e) {
if (G[e].state == 2) {
int used = findUsed(e);
if (i == used) {
suspended.push_back({i, e});
return;
}
bool flag = (topo.index(i) < topo.index(used));
setEdge(e, i, flag);
direct(e, flag);
}
}
void direct(int i, bool reverse) {
if (G[i].state > 2) return;
G[i].state = 3;
somethingChanged = 1;
if (G[i].par >= 0) {
setEdge(G[i].par, i, reverse);
direct(G[i].par, reverse);
}
for (auto& e : (G[i].back)) addArc(i, e);
G[i].state = 4;
}
bool solve() {
cin >> n >> m >> s >> t;
s--;
t--;
G.assign(n, {});
suspended.clear();
ans.clear();
topo.init(n);
topoRoot = t;
G[t].inTopo = 1;
somethingChanged = 0;
for (int i = (0); i < (m); i++) {
int a, b;
cin >> a >> b;
a--;
b--;
G[a].E.push_back(b);
G[b].E.push_back(a);
}
dfs(s);
if (G[t].state == 0) return false;
for (auto& v : (G)) {
sort((v.back).begin(), (v.back).end(),
[](int l, int r) { return G[l].depth > G[r].depth; });
}
for (int i = (0); i < (n); i++)
;
direct(t, false);
while (somethingChanged) {
somethingChanged = 0;
vector<Pii> vec;
vec.swap(suspended);
for (auto& p : (vec)) addArc(p.first, p.second);
}
for (int i = (0); i < (n); i++) {
for (auto& e : (G[i].E)) {
if (topo.index(i) < topo.index(e)) {
ans.push_back({i, e});
G[i].out++;
G[e].in++;
}
}
}
if (G[s].in != 0 || G[t].out != 0) return false;
for (int i = (0); i < (n); i++)
if (i != s && i != t) {
if (G[i].in == 0 || G[i].out == 0) return false;
}
return true;
}
void readTest(bool print) {
cin >> n >> m >> s >> t;
if (print) cout << n << ' ' << m << ' ' << s << ' ' << t << '\n';
for (int i = (0); i < (m); i++) {
int a, b;
cin >> a >> b;
if (print) cout << a << ' ' << b << '\n';
}
}
void run() {
int k;
cin >> k;
while (k--) {
if (solve()) {
cout << "Yes\n";
for (auto& p : (ans)) cout << p.first + 1 << ' ' << p.second + 1 << '\n';
} else {
cout << "No\n";
}
}
}
| 3,200 | CPP |
n = int(input())
prices = [int(x) for x in input().split(' ')]
a = [int(x) for x in input().split(' ')]
b = [int(x) for x in input().split(' ')]
m = int(input())
prefers = [int(x) for x in input().split(' ')]
color2shirt = {}
for i in range(n):
if a[i] not in color2shirt:
color2shirt[a[i]] = []
color2shirt[a[i]].append(i)
if b[i] not in color2shirt:
color2shirt[b[i]] = []
color2shirt[b[i]].append(i)
for c in color2shirt:
color2shirt[c].sort(key=lambda x: prices[x], reverse=True)
#print(color2shirt)
out = []
sold = set([])
for i in range(m):
while prefers[i] in color2shirt and len(color2shirt[prefers[i]]) > 0:
c = color2shirt[prefers[i]].pop()
if c in sold:
continue
sold.add(c)
out.append(prices[c])
break
else:
out.append(-1)
print(*out) | 1,400 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9 + 7;
const long long maxN = 1e6 + 5;
const long long MOD = 998244353;
int n, arr[maxN], sum1, sum2;
vector<pair<int, int> > ans;
int pref[3][maxN];
pair<int, int> getSum(int l, int r) {
return pair<int, int>(pref[1][r] - pref[1][l - 1],
pref[2][r] - pref[2][l - 1]);
}
bool isGood(int l, int r, int points) {
pair<int, int> sum1 = getSum(l, r);
pair<int, int> sum2 = getSum(l, r - 1);
int fstMax = max(sum1.first, sum1.second);
int sndMax = max(sum2.first, sum2.second);
return fstMax == points && sndMax == points - 1;
}
bool isSuitable(int l, int r, int points) {
pair<int, int> sum = getSum(l, r);
return max(sum.second, sum.first) >= points;
}
bool oneWon(int l, int r, int points) {
pair<int, int> sum = getSum(l, r);
return sum.first == points;
}
int bins(int start, int points) {
int l = start + points - 1;
int r = start + 2 * points - 2;
if (r >= n) {
if (isGood(start, n, points)) return n;
return -1;
}
while (l < r) {
int m = (l + r) / 2;
if (isSuitable(start, m, points))
r = m;
else
l = m + 1;
}
return r;
}
int check(int points) {
int fst = 1;
int cnt1 = 0;
int cnt2 = 0;
bool x;
while (fst < n + 1) {
int d = bins(fst, points);
if (d == -1) return -1;
x = oneWon(fst, d, points);
fst = d + 1;
if (x)
cnt1++;
else
cnt2++;
}
if (cnt1 == cnt2 || (cnt1 < cnt2 && x) || (cnt1 > cnt2 && !x)) return -1;
return max(cnt1, cnt2);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = (1); i <= ((n)); ++i) {
cin >> arr[i];
if (arr[i] == 1)
sum1++;
else
sum2++;
pref[1][i] = sum1;
pref[2][i] = sum2;
}
for (int points = (1); points <= ((n)); ++points) {
int d = check(points);
if (d != -1) ans.push_back(pair<int, int>(d, points));
}
sort(ans.begin(), ans.end());
cout << (int)ans.size() << "\n";
for (auto x : ans) cout << x.first << " " << x.second << "\n";
return 0;
}
| 1,900 | CPP |
n, m = map(int, input().split())
a = 500000.0
for i in range(n):
x, y = map(int, input().split())
x *= m
a = min(a, float(x) / float(y))
print("%.10f" % a)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
int n;
string s, t = "";
cin >> s;
s += '1';
n = s.length();
vector<pair<char, int>> v;
int count = 1;
for (int i = 1; i < n; i++) {
if (s[i] == s[i - 1]) {
count++;
continue;
} else {
v.push_back({s[i - 1], count});
count = 1;
}
}
int x = v[0].second;
for (int i = 0; i < 2 && i < x; i++) {
t += v[0].first;
v[0].second = min(2, v[0].second);
}
for (int i = 1; i < v.size(); i++) {
if (v[i].second == 1) {
t += v[i].first;
} else if (v[i].second >= 2 && v[i - 1].second == 2) {
t += v[i].first;
v[i].second = 1;
} else if (v[i].second >= 2 && v[i - 1].second < 2) {
t += v[i].first;
t += v[i].first;
v[i].second = 2;
}
}
cout << t << endl;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
int D[54];
int n;
const int mod = 1e9 + 7;
int dp[55][30][30][30][30];
long long int answer(int idx, int a, int b, int c, int d) {
if (a < 0 or b < 0 or c < 0 or d < 0 or a > 25 or b > 25 or c > 25 or d > 25)
return 0;
if (idx == n - 1) {
return d == 1 and c == 0 and a == 0 and b == D[idx] - 1;
}
if (dp[idx][a][b][c][d] != dp[0][0][0][0][0]) return dp[idx][a][b][c][d];
long long int ans = 0;
if (D[idx] == 2) {
ans += 1LL * answer(idx + 1, a, b + 1, c, d - 1) * d;
ans += 1LL * answer(idx + 1, a, b - 1, c, d - 1) * b * d;
ans += 1LL * answer(idx + 1, a - 1, b + 1, c, d - 1) * a * d;
ans += 1LL * answer(idx + 1, a, b + 1, c - 1, d + 1) * c;
ans += 1LL * answer(idx + 1, a, b - 1, c - 1, d + 1) * c * b;
ans += 1LL * answer(idx + 1, a - 1, b + 1, c - 1, d + 1) * c * a;
if (c == 0 and d == 0) {
ans += 1LL * answer(idx + 1, 0, 1, a, b - 1) * b;
ans += 1LL * answer(idx + 1, 0, 1, a - 1, b + 1) * a;
}
} else {
ans += 1LL * answer(idx + 1, a + 1, b, c, d - 1) * d;
ans += 1LL * answer(idx + 1, a, b, c, d - 1) * d * b;
ans += 1LL * answer(idx + 1, a - 1, b + 2, c, d - 1) * d * a;
ans += 1LL * answer(idx + 1, a, b - 2, c, d - 1) * d * (b * (b - 1)) / 2;
ans +=
1LL * answer(idx + 1, a - 2, b + 2, c, d - 1) * d * (a * (a - 1)) / 2;
ans += 1LL * answer(idx + 1, a - 1, b, c, d - 1) * d * a * b;
ans += 1LL * answer(idx + 1, a + 1, b, c - 1, d + 1) * c;
ans += 1LL * answer(idx + 1, a, b, c - 1, d + 1) * c * b;
ans += 1LL * answer(idx + 1, a - 1, b + 2, c - 1, d + 1) * c * a;
ans +=
1LL * answer(idx + 1, a, b - 2, c - 1, d + 1) * c * (b * (b - 1)) / 2;
ans += 1LL * answer(idx + 1, a - 2, b + 2, c - 1, d + 1) * c *
(a * (a - 1)) / 2;
ans += 1LL * answer(idx + 1, a - 1, b, c - 1, d + 1) * c * a * b;
if (c == 0 and d == 0) {
ans += 1LL * answer(idx + 1, 1, 0, a, b - 1) * b;
ans += 1LL * answer(idx + 1, 1, 0, a - 1, b + 1) * a;
}
}
ans %= mod;
dp[idx][a][b][c][d] = ans;
return ans;
}
int main() {
memset(dp, -1, sizeof dp);
cin >> n;
for (int i = 0; i < n; i++) scanf("%d", &D[i]);
if (D[0] == 2 and D[1] == 2)
cout << answer(2, 0, 1, 0, 1);
else if (D[0] == 3 and D[1] == 2)
cout << answer(2, 0, 1, 1, 0);
else if (D[0] == 2 and D[1] == 3)
cout << answer(2, 1, 0, 0, 1);
else
cout << answer(2, 1, 0, 1, 0);
}
| 2,600 | CPP |
n=int(input())
l=0
if (n % 10 == 0):
n+=1
l+=1
while (n>10):
if(n % 10 != 0):
l=l+1
n+=1
else:
n=n/10
else:
while (n>10):
if(n % 10 != 0):
l=l+1
n+=1
else:
n=n/10
print(l+9)
| 1,100 | PYTHON3 |
for i in range(int(input())):
num_of_rect = int(input())
nums = sorted(map(int,input().split()))
# print(num_of_rect, nums)
st = 0
end = len(nums)-1
area = nums[0]*nums[-1]
while True:
if end<=st:
print("YES")
break
if nums[st]==nums[st+1] and nums[end]==nums[end-1] and nums[st]*nums[end]==area:
end -= 2
st += 2
continue
else:
print("NO")
break
| 1,200 | PYTHON3 |
t=int(input())
while t:
n,m,k=map(int,input().split())
h=input().split()
for i in range(n):
h[i]=int(h[i])
flag=True
for j in range(n-1):
if(h[j+1]-h[j]>k):
need=h[j+1]-k-h[j]
if(m>=need):
m-=need
else:
flag=False
else:
extra=h[j]-max(h[j+1]-k,0)
m+=extra
if(flag):
print("YES")
else:
print("NO")
t-=1 | 1,200 | PYTHON3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:2000000")
#pragma comment(linker, "/HEAP:2000000")
using namespace std;
void print_width(long long x) {
std::cout << std::fixed;
std::cout << std::setprecision(x);
}
long long power(long long x, long long y, long long p = 1000000007) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
void printArr(long long a[], long long n) {
for (long long i = 0; i < n; i++) cout << a[i] << " ";
cout << '\n';
}
void printVector(std::vector<long long> v) {
for (long long i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << '\n';
}
void printVectorPair(std::vector<pair<long long, long long>> v) {
for (long long i = 0; i < v.size(); i++)
cout << v[i].first << " " << v[i].second << '\n';
;
cout << '\n';
}
void initialize(long long arr[], long long n) {
for (long long i = 0; i <= n; i++) arr[i] = i;
}
long long root(long long arr[], long long i) {
while (arr[i] != i) {
arr[i] = arr[arr[i]];
i = arr[i];
}
return i;
}
void Union(long long arr[], long long a, long long b) {
long long root_a = root(arr, a);
long long root_b = root(arr, b);
arr[root_a] = root_b;
}
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long power_wm(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
std::vector<long long> vsum(std::vector<long long> a) {
std::vector<long long> s(a.size());
s[0] = a[0];
for (long long i = 1; i <= a.size() - 1; i++) {
s[i] = s[i - 1] + a[i];
}
return s;
}
void time() {}
long long sti(string s) {
long long ans = 0;
long long p = 1;
for (long long i = s.size() - 1; i >= 0; i--) {
ans = (ans + ((long long)(s[i] - '0') * p) % 1000000007) % 1000000007;
p = (p * 10) % 1000000007;
}
return ans;
}
long long bfs(long long x, long long y, vector<vector<long long>> &g) {
std::vector<long long> vis(100001, 0);
vis[x] = 1;
queue<long long> q;
q.push(x);
std::vector<long long> level(100001, (long long)1e18);
level[x] = 0;
while (!q.empty()) {
long long p = q.front();
q.pop();
for (long long i = 0; i < g[p].size(); i++) {
long long p2 = g[p][i];
if (vis[p2] == 0) {
if (x == p and y == p2) {
continue;
} else {
q.push(p2);
vis[p2] = 1;
level[p2] = level[p] + 1;
}
}
}
}
return level[y];
}
string multiply(string num1, string num2) {
long long len1 = num1.size();
long long len2 = num2.size();
if (len1 == 0 || len2 == 0) return "0";
vector<long long> result(len1 + len2, 0);
long long i_n1 = 0;
long long i_n2 = 0;
for (long long i = len1 - 1; i >= 0; i--) {
long long carry = 0;
long long n1 = num1[i] - '0';
i_n2 = 0;
for (long long j = len2 - 1; j >= 0; j--) {
long long n2 = num2[j] - '0';
long long sum = n1 * n2 + result[i_n1 + i_n2] + carry;
carry = sum / 10;
result[i_n1 + i_n2] = sum % 10;
i_n2++;
}
if (carry > 0) result[i_n1 + i_n2] += carry;
i_n1++;
}
long long i = result.size() - 1;
while (i >= 0 && result[i] == 0) i--;
if (i == -1) return "0";
string s = "";
while (i >= 0) s += std::to_string(result[i--]);
return s;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
long long mat[n][n];
long long p = 0;
for (long long i = 0; i < n; i += 4) {
for (long long j = 0; j < n; j += 4) {
for (long long a = i; a < i + 4; a++) {
for (long long b = j; b < j + 4; b++) {
mat[a][b] = p;
p++;
}
}
}
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < n; j++) {
cout << mat[i][j] << " ";
}
cout << '\n';
}
return 0;
}
| 1,800 | CPP |
for _ in range(int(input())):
n=int(input())
khoroch=0
while(n//10>0):
temp = n//10
khoroch+=temp*10
n=temp+(n%10)
khoroch+=n
print(khoroch)
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long res = 0, ans = 0, a, mn;
int t;
scanf("%d", &t);
while (t--) {
scanf("%lld", &a);
mn = min(res, a / 2);
res -= mn;
a -= 2 * mn;
ans += mn + a / 3;
a %= 3;
res += a;
}
printf("%lld\n", ans);
return 0;
}
| 1,900 | CPP |
from collections import defaultdict as dd
import math
import sys
import heapq
input=sys.stdin.readline
def nn():
return int(input())
def li():
return list(input())
def mi():
return map(int, input().split())
def lm():
return list(map(int, input().split()))
q=nn()
def heap_place(lower, upper):
if (upper-lower)%2==1:
p = (upper-lower)//2+lower
out[p]=value
else:
p = (upper-lower)//2 - 1 + lower
out[p]=value
if p>lower:
heapq.heappush(h, (lower-p, lower, p))
if upper>p+1:
heapq.heappush(h, (p+1-upper, p+1, upper))
for _ in range(q):
n = nn()
out = [0]*n
h=[(-n,0,n)]
value=1
while h:
next = heapq.heappop(h)
heap_place(next[1],next[2])
value+=1
print(*out)
| 1,600 | PYTHON3 |
A=input()
A=A+input()
C=input()
if len(A)==len(C):
k=0
else:
k=1
for i in C:
if not C.count(i)==A.count(i):
k=1
break
if k==0:
print('YES')
else:
print('NO')
| 800 | PYTHON3 |
from sys import stdin, stdout
import heapq
import cProfile
from collections import Counter, defaultdict, deque
from functools import reduce
import math
def get_int():
return int(stdin.readline().strip())
def get_tuple():
return map(int, stdin.readline().split())
def get_list():
return list(map(int, stdin.readline().split()))
def solve():
n = get_int()
ls = get_list()
mini = min(ls)
temp = []
factors = []
copy_ls = []
for val in ls:
if val%mini==0:
factors.append(val)
copy_ls.append(0)
else:
copy_ls.append(val)
temp.append(val)
rem_ls = list(sorted(temp))
if rem_ls!=temp:
print("NO")
else:
factors.sort()
i = 0
le = len(factors)
j = 0
while i<le:
while j<n and copy_ls[j]!=0:
j += 1
copy_ls[j] = factors[i]
i += 1
if copy_ls!=list(sorted(copy_ls)):
print("NO")
else:
print("YES")
def main():
solve()
TestCases = True
if TestCases:
for i in range(get_int()):
main()
else:
main()
| 1,300 | PYTHON3 |