solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
# stdin = open('testdata.txt')
# def input():
# return stdin.readline().strip()
n = int(input())
a = [""]*n
ans = 0
sm=0
for i in range(n):
g,h = [int(x) for x in input().split()]
a[i] = [h,g]
sm+=g
a.sort()
for i in range(n-1,-1,-1):
x = a[i]
k = min(x[0],sm)
ans += min(sm - ans - k,x[1])
print(sm*2-ans)
| 10 | PYTHON3 |
t = int(input())
for _ in range(t):
n = int(input())
a = input()
b = input()
c = 0
va = []
vb = []
if a == b:
print(0)
else:
for i in range(1, n):
if a[i] != a[i - 1]:
c += 1
va.append(str(i))
if a[n - 1] != b[n - 1]:
c += 1
va.append(str(n))
for i in range(1, n):
if b[i] != b[i - 1]:
c += 1
vb.append(str(i))
print(' '.join([str(len(va) + len(vb))] + va + vb[::-1])) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int f = 1, k = 0, g;
string s, ins;
cin >> s >> ins;
for (long long int i = 0; i < s.length(); i++) {
g = 0;
for (int j = k; j < ins.length(); j++) {
if (ins[j] == s[i]) {
g = 1;
k = j + 1;
f = i + 2;
break;
}
}
if (g == 0) break;
if (k == ins.length()) break;
}
cout << f << "\n";
}
| 7 | CPP |
#elephant
n = int(input())
if n >5:
a = n//5
if n%5==0:
print(a)
else:
print(a+1)
else :
print('1')
| 7 | PYTHON3 |
for i in range(int(input())):
c=0
n=int(input())
ans=1
while(n>1):
c+=1
if(n%2==0): n=n//2
elif(n%3==0): n= (2*n)//3
elif n%5==0 : n= (4*n)//5
else:
ans=0
break
if(ans==0): print(-1)
else: print(c) | 7 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
using LL=long long;
int main(){
int N,Q;cin>>N>>Q;
vector<LL>A(N);
for(int i=0;i<N;i++)scanf("%lld",&A[i]);
if(N%2!=0){
A.insert(A.begin(),0);
N+=1;
}
A.push_back(100000000000L);
vector<LL>s(N),k(N);
s[0]=A[0];
for(int i=1;i<N;i++)s[i]=s[i-1]+A[i];
k[0]=A[0];
for(int i=1;i<N;i++)k[i]=k[i-1]+ (i%2==0?A[i]:0);
vector<LL>d(N/2);
for(int i=0;i<N/2;i++){
d[i]=(A[N-(N/2-i)]+A[i*2+1])/2;
}
for(int i=0;i<Q;i++){
LL X;scanf("%lld",&X);
vector<LL>::iterator it=lower_bound(d.begin(),d.end(),X);
int o=(it-d.begin());
printf("%lld\n",s[N-1]-((s[N-(N/2-o)-1]-(o*2-1<0?0:s[o*2-1])) + (o*2-1<0?0:k[o*2-1])));
}
}
| 0 | CPP |
limonKati=int(int(input())/1)
elmaKati=int(int(input())/2)
armutKati=int(int(input())/4)
print(min(limonKati,elmaKati,armutKati)*7)
| 7 | PYTHON3 |
n=int(input())
a=sorted(list(map(int,input().split())),reverse=True)
s=sum(a)
curs=0
c=0
for coin in a:
curs+=coin
s-=coin
c+=1
if curs>s:
print(c)
break
| 7 | PYTHON3 |
#include <iostream>
#define MOD 1000000007
typedef long long LL;
using namespace std;
LL calc(LL x, LL n){
LL ans = 1;
while(n > 0){
if(n & 1){
ans = ans * x % MOD;
}
x = x * x % MOD;
n >>= 1;
}
return ans;
}
int main(){
LL x,n;
cin >> x >> n;
cout << calc(x,n) << endl;
}
| 0 | CPP |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
#include <cmath>
using namespace std;
#define mp make_pair
#define pb push_back
#define ll long long
const int maxN = 100011;
int n, i, j, x, y, bg, pos;
vector<int> list[maxN];
bool leaf[maxN];
int gr[maxN], gr_leaf[maxN];
vector<int> ord, ord2;
vector<int> ans;
void dfs(int node, int root) {
ord.pb(node);
for (auto to : list[node])
if (!leaf[to])
if (to != root)
dfs(to, node);
}
int main()
{
// freopen("test.in","r",stdin);
scanf("%d", &n);
for (i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
list[x].pb(y);
list[y].pb(x);
gr[x]++; gr[y]++;
}
if (n == 2) {
printf("1 2");
return 0;
}
for (i = 1; i <= n; i++) {
if (gr[i] > 1) continue;
leaf[i] = true;
gr_leaf[list[i][0]]++;
}
for (i = 1; i <= n; i++) {
if (gr[i] - gr_leaf[i] > 2) {
printf("-1");
return 0;
}
}
for (bg = 1; leaf[bg] || gr[bg] - gr_leaf[bg] == 2; bg++);
dfs(bg, 0);
ord2 = ord;
reverse(ord2.begin(), ord2.end());
for (i = 0; i < ord.size(); i++) {
if (gr_leaf[ord[i]] < gr_leaf[ord2[i]]) break;
if (gr_leaf[ord[i]] > gr_leaf[ord2[i]]) {
swap(ord, ord2);
break;
}
}
gr_leaf[ord[0]]--;
gr_leaf[ord.back()]--;
pos = 2;
ans = {1};
for (auto e : ord) {
for (i = 1; i <= gr_leaf[e]; i++) ans.pb(pos + i);
ans.pb(pos);
pos += gr_leaf[e] + 1;
}
ans.pb(n);
for (auto e : ans) printf("%d ", e);
return 0;
}
| 0 | CPP |
n, k = map(int, input().split())
c = list(map(int, input().split()))
dem = [0]*k
for i in c:
j = i%k
dem[j] += 1
total = dem[0]//2
for i in range(1, (k//2)+1):
total += min(dem[i], dem[k-i])
if k%2 == 0:
if dem[k//2]%2==0:
total -= dem[k//2]/2
else:
total -= dem[k//2]//2 + 1
print(int(total*2))
| 8 | PYTHON3 |
s1=str(input()).lower()
s2=str(input()).lower()
if s1==s2:
print(0)
else:
for i in range(len(s1)):
if ord(s1[i])>ord(s2[i]):
print(1)
break
elif ord(s1[i])<ord(s2[i]):
print(-1)
break
else:
continue | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long a[123456], f[123456], ans, tmp;
void init() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%I64d", &tmp);
a[tmp]++;
}
}
void solve() {
f[1] = a[1];
ans = f[1];
for (int i = 2; i < 123456; i++) {
f[i] = max(f[i - 1], f[i - 2] + a[i] * i);
ans = max(f[i], ans);
}
printf("%I64d\n", ans);
}
int main() {
init();
solve();
}
| 9 | CPP |
n=int(input())
s=list(map(int,input().split()))
dp=[0,0]
for i in range(3):
if s[i]%2==0:
dp[1]+=1
else:
dp[0]+=1
if dp[0]<dp[1]:
for i in range(n):
if s[i]%2!=0:
print(i+1)
break
else:
for i in range(n):
if s[i]%2==0:
print(i+1)
break
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, b, mini = 1000000000;
cin >> n >> b;
int ar[b + 1];
int index[1001] = {0};
for (int i = 0; i < b; i++) {
cin >> ar[i];
index[ar[i]] = index[ar[i]] + 1;
}
for (int i = 1; i <= n; i++) {
if (index[i] == 0) {
cout << 0;
exit(0);
}
if ((index[i] < mini)) mini = index[i];
}
cout << mini;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int house[100005][2], dp[100005], n;
long long int fun(int i, int a, int b) {
if (i > n)
return 0;
else {
if (dp[i] != 0) return dp[i];
long long int ans1 = 0, ans2 = 0, ans = 0;
ans1 = fabs(house[i][0] - a) + fabs(house[i][1] - b);
ans2 = fabs(house[i][1] - a) + fabs(house[i][0] - b);
ans += min(fun(i + 1, house[i][0], house[i][1]) + ans1,
ans2 + fun(i + 1, house[i][1], house[i][0]));
return dp[i] = ans;
}
}
int main() {
int i, j, a, b;
cin >> n;
for (i = 1; i <= 2 * n; i += 2) {
cin >> a;
cin >> b;
if (house[a][0] == 0)
house[a][0] = i;
else
house[a][1] = i;
if (house[b][0] == 0)
house[b][0] = i + 1;
else
house[b][1] = i + 1;
}
for (i = 1; i <= n; i++) {
}
cout << fun(1, 1, 1);
return 0;
}
| 8 | CPP |
if __name__== "__main__":
inp=(input()).split(" ")
n=int(inp[0])
a=int(inp[1])
b=int(inp[2])
s=0
i=a+1
while i<=n:
if (b>=(n-i)):
s=s+1
i=i+1
print(s) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
int n, m;
int a[maxn][10];
int mask[maxn];
int valid[1024];
pair<int, int> ans;
void print(int x) {
for (int i = 7; i >= 0; i--) cout << ((x >> i) & 1);
puts("");
}
bool check(int x) {
memset(valid, -1, sizeof(valid));
memset(mask, 0, sizeof(mask));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (a[i][j] >= x) mask[i] |= (1 << j);
valid[mask[i]] = i;
}
for (int i = 0; i < (1 << m); i++) {
if (valid[i] == -1) continue;
for (int j = 0; j < (1 << m); j++)
if (((i | j) == ((1 << m) - 1)) && valid[j] != -1) {
ans = make_pair(valid[i], valid[j]);
return true;
}
}
return false;
}
int main() {
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 l = 0, r = 1e9;
while (l < r) {
int mid = l + r + 1 >> 1;
if (check(mid))
l = mid;
else
r = mid - 1;
}
check(l);
printf("%d %d", ans.first + 1, ans.second + 1);
return 0;
}
| 10 | CPP |
#include<iostream>
using namespace std;
int main(){
int n, max,min, tmp, sum=0;
while(1){
cin >> n;
if(n==0)break;
max=0; min=500;
for(int i=0;i<n;i++){
for(int j=0;j<5;j++){
cin >> tmp;
sum+=tmp;
}
if(max<sum) max=sum;
if(min>sum) min=sum;
sum=0;
}
cout << max << " " << min << endl;
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n, a[5003], ans[5003] = {};
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
int t[5003] = {}, max = 0, maxi = 5003;
for (int j = i; j < n; j++) {
t[a[j]]++;
if (t[a[j]] > max) {
maxi = a[j];
max = t[a[j]];
} else if (t[a[j]] == max && a[j] < maxi) {
maxi = a[j];
max = t[a[j]];
}
ans[maxi]++;
}
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
}
| 7 | CPP |
n=int(input())
a=list(map(int,input().split()))
mod=10**9+7
c=[0]*60
for aa in a:
for i in range(60):
if aa&(1<<i):c[i]+=1
ans=0
for i,cc in enumerate(c):
ans+=cc*(n-cc)*2**i
ans%=mod
print(ans)
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
string substring(string &s, int len) {
string ret = "";
for (int i = 0; i < len; i++) {
ret += s[i];
}
string new_s = "";
for (int i = len; i < s.size(); i++) {
new_s += s[i];
}
s = new_s;
return ret;
}
int main() {
string s;
cin >> s;
int len = s.size();
int rows = (len - 1) / 20 + 1;
int row[5];
int len_in_row = len / rows;
for (int i = 0; i < rows; i++) {
row[i] = len_in_row;
}
int left_chars = len - rows * len_in_row;
if (left_chars > 0) len_in_row++;
int it = 0;
while ((left_chars--) > 0) {
row[it++]++;
}
cout << rows << ' ' << len_in_row << '\n';
for (int i = 0; i < rows; i++) {
cout << substring(s, row[i]);
if (row[i] != len_in_row) cout << '*';
cout << '\n';
}
return 0;
}
| 8 | CPP |
n = input()
letters = input()
count0 = 0
count1 = 0
for letter in letters:
if(letter == 'z'):
count0 = count0 + 1
else:
if(letter == 'n'):
count1 = count1 + 1
if(count1 > 0):
print(1, end='')
for i in range(1, count1):
print(" 1", end='')
if(count0 > 0):
print(" 0", end='')
for i in range(1, count0):
print(" 0", end = '')
print()
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
const double eps = 1e-9;
int n, b[maxn], c[maxn], stak[maxn], top, ans[maxn], cnt;
pair<int, int> p[maxn];
vector<int> G[maxn];
struct node {
double fir, sec;
node() {}
node(double x, double y) {
fir = x;
sec = y;
}
} a[maxn];
node operator-(node x, node y) { return node(x.fir - y.fir, x.sec - y.sec); }
double slop(node x) { return x.sec / x.fir; }
bool cmp(int x, int y) { return a[x].fir < a[y].fir; }
bool cmp1(int x, int y) {
return p[x].first != p[y].first ? p[x].first < p[y].first
: p[x].second < p[y].second;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &p[i].first, &p[i].second);
b[i] = i;
}
sort(b + 1, b + n + 1, cmp1);
int m = 0;
for (int l = 1, r; l <= n; l = r + 1) {
r = l;
while (r < n && p[b[l]] == p[b[r + 1]]) ++r;
if (r < n && p[b[r]].first == p[b[r + 1]].first) continue;
++m;
c[m] = m;
a[m] = node(1.0 / p[b[l]].first, 1.0 / p[b[l]].second);
for (int j = l; j <= r; ++j) G[m].push_back(b[j]);
}
sort(c + 1, c + m + 1, cmp);
for (int i = 1; i <= m; ++i) {
while (top > 1 && slop(a[stak[top]] - a[stak[top - 1]]) >
slop(a[c[i]] - a[stak[top - 1]]))
--top;
stak[++top] = c[i];
}
for (int i = 0; i < G[stak[1]].size(); ++i) ans[++cnt] = G[stak[1]][i];
for (int i = 2; i <= top; ++i) {
node u = a[stak[i]] - a[stak[i - 1]];
if (slop(u) < 0) {
for (int j = 0; j < G[stak[i]].size(); ++j) ans[++cnt] = G[stak[i]][j];
} else {
break;
}
}
sort(ans + 1, ans + cnt + 1);
for (int i = 1; i <= cnt; ++i) printf("%d ", ans[i]);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<pair<int, int> > v;
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
if (v.size() == 0)
v.push_back(make_pair(x, y));
else {
while (v.size() > 0) {
int len = v.size();
pair<int, int> temp = v[len - 1];
if (temp.second <= y) {
v.pop_back();
} else
break;
}
v.push_back(make_pair(x, y));
}
}
vector<int> f;
int t = v[0].second;
for (int i = 0; i < t; i++) {
f.push_back(a[i]);
}
v.push_back(make_pair(0, 0));
sort(f.begin(), f.end());
int L = 0, R = f.size() - 1;
int len1 = v.size();
int idx = v[0].second - 1;
for (int i = 0; i < len1 - 1; i++) {
int dis = v[i].second - v[i + 1].second;
if (v[i].first == 1) {
while (dis > 0) {
a[idx] = f[R];
idx--;
R--;
dis--;
}
} else {
while (dis > 0) {
a[idx] = f[L];
idx--;
L++;
dis--;
}
}
}
for (int i = 0; i < n; i++) cout << a[i] << " ";
}
| 9 | CPP |
// B - Varied
#include <bits/stdc++.h>
using namespace std;
int main(){
string s; cin>>s;
sort(s.begin(), s.end());
for(int i=1; i<s.size(); ++i){
if(s[i]==s[i-1]){
puts("no");
return 0;
}
}
puts("yes");
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int a[N], p[N], n, cnt, ans;
struct Node {
int v, l, r;
} o[N * 20];
int root[N], sz;
void add(int &rt, int l, int r, int x) {
o[++sz] = o[rt];
rt = sz;
++o[rt].v;
if (l == r) return;
int m = l + r >> 1;
if (x <= m)
add(o[rt].l, l, m, x);
else
add(o[rt].r, m + 1, r, x);
}
int ask(int rt1, int rt2, int l, int r, int x, int y) {
if (x <= l && r <= y) return o[rt1].v - o[rt2].v;
int m = (l + r) >> 1, ret = 0;
if (x <= m) ret += ask(o[rt1].l, o[rt2].l, l, m, x, y);
if (y > m) ret += ask(o[rt1].r, o[rt2].r, m + 1, r, x, y);
return ret;
}
const int BufferSize = 1 << 16;
char buffer[BufferSize], *head, *tail;
inline char Getchar() {
if (head == tail) {
int l = fread(buffer, 1, BufferSize, stdin);
tail = (head = buffer) + l;
}
return *head++;
}
inline int read() {
int x = 0, f = 1;
char c = Getchar();
for (; !isdigit(c); c = Getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = Getchar()) x = x * 10 + c - '0';
return x * f;
}
int main() {
n = read();
for (int i = 1; i <= n; ++i) a[i] = read(), p[i] = a[i];
sort(p + 1, p + 1 + n);
cnt = unique(p + 1, p + 1 + n) - p - 1;
root[0] = sz;
for (int i = 1; i <= n; ++i) {
a[i] = lower_bound(p + 1, p + 1 + cnt, a[i]) - p;
add(root[i] = root[i - 1], 1, cnt, a[i]);
}
for (int k = 1; k < n; ++k) {
ans = 0;
for (int i = 1; i <= n; ++i) {
int l = k * (i - 1) + 2, r = k * i + 1;
if (l > n) break;
r = min(n, r);
if (a[i] - 1 >= 1) {
ans += ask(root[r], root[l - 1], 1, cnt, 1, a[i] - 1);
}
}
if (k > 1) printf(" ");
printf("%d", ans);
}
printf("\n");
return 0;
}
| 12 | CPP |
#include <iostream>
using namespace std;
int main() {
int DP[34]={0};
int x;
DP[0]=1;
for(int i=0;i<=29;i++){
for(int j=1;j<=3;j++)
DP[i+j]+=DP[i];
}
while(true){
cin >> x;
if(x==0)
break;
cout << (DP[x]+3649)/3650 << endl;
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> P;
int n, q;
int fish[1000001];
int main() {
cin >> n >> q;
priority_queue<P> pq;
for(int i = 0; i < q; i++) {
int a, v;
cin >> a >> v;
fish[a] += v;
pq.push(P(fish[a], a * (-1)));
while(!pq.empty()) {
P p = pq.top();
p.second *= -1;
if(p.first == fish[p.second]) {
cout << p.second << ' ' << p.first << endl;
break;
}
pq.pop();
}
}
return 0;
} | 0 | CPP |
N = int(input())
A = list(map(int,input().split()))
A.sort()
min_ptn = A[1]
for i in range(min_ptn,0,-1):
count = 0
for a in A:
if a%i!=0:
count+=1
if count>1:
break
if count<2:
print(i)
break | 0 | PYTHON3 |
#include <bits/stdc++.h>
const int N = 200054, M = 1000054;
int V, E, si, ti, Es;
int to[M], first[N], next[M];
int cnt = 0, id[N], low[N];
int top = 0, stack[N];
int bcc_cnt, p[M], deg[M], size[M];
int fc[M], nc[M];
inline void down(int &x, const int y) { x > y ? x = y : 0; }
inline void addedge(int u, int v) {
to[++Es] = v, next[Es] = first[u], first[u] = Es;
to[++Es] = u, next[Es] = first[v], first[v] = Es;
}
inline void link(int x, int y) {
p[x] = y, ++deg[x], ++deg[y], nc[x] = fc[y], fc[y] = x;
}
void dfs(int x, int px) {
int i, y, z;
id[x] = low[x] = ++cnt, stack[top++] = x;
for (i = first[x]; i; i = next[i])
if (!id[y = to[i]]) {
dfs(y, i), down(low[x], low[y]);
if (id[x] <= low[y])
for (link(++bcc_cnt + V, x), z = 0; z != y;)
link(z = stack[--top], bcc_cnt + V);
} else if (px - 1 ^ i - 1 ^ 1)
down(low[x], id[y]);
}
void dfss(int x) {
int y;
size[x] = (x <= V);
for (y = fc[x]; y; y = nc[y]) dfss(y), size[x] += size[y];
}
void work() {
int i, u, v, a, b;
scanf("%d%d%d%d", &V, &E, &si, &ti), Es = cnt = top = bcc_cnt = 0;
memset(first, 0, (V + 1) << 2);
memset(id, 0, (V + 1) << 2);
for (i = 0; i < E; ++i) scanf("%d%d", &u, &v), addedge(u, v);
dfs(si, 0);
if (deg[si] < 2 || deg[ti] < 2)
puts("0");
else {
dfss(si), a = size[ti] - 1;
assert(size[si] == V);
for (u = ti; p[u] != si; u = p[u])
;
b = size[si] - size[u] - 1;
printf("%lld\n", (long long)a * b);
}
memset(p, 0, (V + bcc_cnt + 1) << 2);
memset(deg, 0, (V + bcc_cnt + 1) << 2);
memset(fc, 0, (V + bcc_cnt + 1) << 2);
}
int main() {
int T;
for (scanf("%d", &T); T; --T) work();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5, INF = ~0U >> 1;
int n, k, l, a[MAXN];
int main() {
scanf("%d%d%d", &n, &k, &l);
for (int i = 0; i < n * k; i++) scanf("%d", &a[i]);
sort(a, a + n * k);
int id = (upper_bound(a, a + n * k, a[0] + l) - a) - 1;
if (id + 1 < n) {
puts("0");
return 0;
}
long long sum = 0;
int num;
if (k == 1)
num = n;
else if ((id + 1 - n) % (k - 1))
num = (id + 1 - n) / (k - 1) + 1;
else
num = (id + 1 - n) / (k - 1);
for (int i = 0; i < num * k; i += k) sum += a[i];
int last = id;
for (int i = 0; i < (n - num); i++) sum += a[last--];
printf("%lld\n", sum);
return 0;
}
| 9 | CPP |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
const ll MAX = 10000000;
ll fac[MAX], finv[MAX], inv[MAX];
//テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i%MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
//二項計数計算
ll COM(ll n, ll k) {
if (n < k) return 0;
if (n < 0 || k < 0)return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main(){
COMinit();
int n,m;
cin>>n>>m;
map<int,int>res;
for(int i=2; i*i<=m; i++){
while(m%i==0){
res[i]++;
m/=i;
}
}
if(m!=1)res[m]++;
ll ans=1;
for(auto p:res){
ans *=COM(n+p.second-1,p.second);
ans%=MOD;
}
cout<<ans<<endl;
}
| 0 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimization("unroll-loops")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4")
using namespace std;
const int BASE = 1000000, D = 10;
char what[BASE + 2];
pair<int, int> nxt[D][BASE + 2];
pair<long long, int> to[D][D];
inline long long Calc(long long x) {
long long suff = x / BASE, pref = x % BASE;
long long ans = suff;
while (suff > 0) {
ans += nxt[what[suff]][pref].first;
pref = nxt[what[suff]][pref].second;
pref += BASE - max(what[suff], what[pref]);
--suff;
}
return ans + nxt[0][pref].first;
}
inline long long Process(long long x) {
long long suff = x / (1LL * BASE * BASE), psuff = x / BASE % BASE,
pref = x % BASE;
if (suff == 0) {
return Calc(x);
}
long long ans = 0;
while (psuff >= 0) {
char r = what[psuff] < what[suff] ? what[suff] : what[psuff];
ans += nxt[r][pref].first + 1;
pref = nxt[r][pref].second;
pref += BASE - (r < what[pref] ? what[pref] : r);
--psuff;
}
--suff;
while (suff > 0) {
ans += to[what[suff]][BASE - pref].first;
pref = to[what[suff]][BASE - pref].second;
--suff;
}
return ans + Calc(1LL * (BASE - 1) * BASE + pref);
}
int main() {
for (int i = 1; i <= BASE; ++i) {
what[i] = i % D > what[i / D] ? i % D : what[i / D];
for (int d = 0; d < D; ++d) {
char r = what[i] < d ? d : what[i];
if (i >= r) {
nxt[d][i] = make_pair(nxt[d][i - r].first + 1, nxt[d][i - r].second);
} else {
nxt[d][i] = make_pair(0, i);
}
}
}
for (char d = 1; d < D; ++d) {
for (int l = 0; l < D; ++l) {
int suff = BASE - 1, pref = BASE - l;
to[d][l].first = BASE;
while (suff >= 0) {
char r = (d < what[suff] ? what[suff] : d);
to[d][l].first += nxt[r][pref].first;
pref = nxt[r][pref].second;
pref += BASE - (r < what[pref] ? what[pref] : r);
--suff;
}
to[d][l].second = pref;
}
}
long long n;
cin >> n;
cout << Process(n) << '\n';
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 5;
int a[maxn][maxn];
int main() {
int n, sum = 0;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j];
if (i == j)
sum += a[i][j];
else if (i + j == n - 1)
sum += a[i][j];
else if (i == n / 2)
sum += a[i][j];
else if (j == n / 2)
sum += a[i][j];
}
}
cout << sum << endl;
}
| 7 | CPP |
s0 = input()
s1 = sum(int(x) for x in s0)
a = 0
result = 0
for i in range(1001):
a = int(s0) + i
result = sum(int(x) for x in str(a))
if result % 4 == 0:
print (int(s0) + i)
break
| 7 | PYTHON3 |
nums = input().split('+')
num = sorted(nums)
s = "+"
s = s.join(num)
print(s) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void splitstr(const string &s, vector<T> &out) {
istringstream in(s);
out.clear();
copy(istream_iterator<T>(in), istream_iterator<T>(), back_inserter(out));
}
template <class T>
T readValue(string s) {
T result;
istringstream sin(s);
sin >> result;
return result;
}
template <class T>
void initArray(T *arr, int size, T value) {
for (int i = 0; i < size; i++) arr[i] = value;
}
template <class T>
inline T gcd(T a, T b) {
return (!a) ? b : gcd(b % a, a);
}
template <class T>
inline T mod(T a, T p) {
a %= p;
return (a < 0) ? a + p : a;
}
template <class T>
inline int num_bits(T n) {
return (!n) ? 0 : 1 + numbits(n & (n - 1));
}
template <class T>
inline T inverse(T a, T m) {
a = mod<T>(a, m);
return (a == 1) ? 1 : mod((1 - m * inverse(m % a, a)) / a, m);
}
template <class T>
inline bool is_prime(T a) {
T lim = (T)sqrt((double)a);
for (T i = 2; i <= T(lim + 1E-9); i++)
if (a % i == 0) return false;
return true;
}
template <class T>
inline T power(T a, T p, T mod) {
if (!p) return 1;
T temp = power(a, p >> 1, mod);
temp = (temp * temp) % mod;
if (p & 1) temp = (temp * a) % mod;
return temp;
}
void get_primes(int start, int end, vector<int> &vi) {
int *p = new int[end + 1];
initArray<int>(p, end + 1, 0);
p[1] = 1;
for (int i = 2; i <= end; i++) {
if (!p[i]) {
if (i >= start) vi.push_back(i);
for (int j = 2 * i; j <= end; j += i) p[j] = 1;
}
}
delete[] p;
}
bool dfs(int current, int final, int total, int *visited, int **edges,
bool flow) {
if (current == final) return true;
if (visited[current]) return false;
visited[current] = true;
for (int i = 0; i < total; i++)
if (edges[current][i] && dfs(i, final, total, visited, edges, flow)) {
if (flow) {
edges[current][i]--;
edges[i][current]++;
}
return true;
}
return false;
}
int flow(int in, int out, int total, int **edges) {
int result = 0;
int *visited = new int[total];
while (initArray<int>(visited, total, 0),
dfs(in, out, total, visited, edges, true))
result++;
delete[] visited;
return result;
}
void create_set(int x, int *P, int *rank) {
P[x] = x;
rank[x] = 0;
}
int find_set(int x, int *P) {
if (x != P[x]) P[x] = find_set(P[x], P);
return P[x];
}
bool merge_sets(int x, int y, int *P, int *rank) {
int Px = find_set(x, P);
int Py = find_set(y, P);
if (Px == Py) return false;
if (rank[Px] > rank[Py])
P[Py] = Px;
else
P[Px] = Py;
if (rank[Px] == rank[Py]) rank[Py]++;
return true;
}
template <typename T>
int read_cum_freq(int index, T *tree) {
int sum = 0;
while (index) {
sum += tree[index];
index -= (index & -index);
}
return sum;
}
template <typename T>
void upd_freq(int index, int mxIndex, int value, T *tree) {
while (index <= mxIndex) {
tree[index] += value;
index += (index & -index);
}
}
template <typename T>
int read_freq(int index, T *tree) {
return read_cum_freq(index, tree) - read_cum_freq(index - 1, tree);
}
void build_failure_function(const string &str, int *temp_arr) {
temp_arr[0] = temp_arr[1] = 0;
for (int i = 2; i <= ((int)(str).size()); i++) {
temp_arr[i] = -1;
for (int ind = temp_arr[i - 1]; temp_arr[i] == -1; ind = temp_arr[ind]) {
if (str[ind] == str[i - 1]) {
temp_arr[i] = ind + 1;
} else if (ind == 0) {
temp_arr[i] = 0;
}
}
}
}
void KMP(const string &text, const string &pattern, int *res) {
int *temp_arr = new int[((int)(pattern).size()) + 1];
build_failure_function(pattern, temp_arr);
int i = 0;
int ind = 0;
while (i < ((int)(text).size())) {
if (text[i] == pattern[ind]) {
res[i] = ++ind;
if (res[i] == ((int)(pattern).size())) {
ind = temp_arr[ind];
}
i++;
} else if (ind == 0) {
res[i++] = 0;
} else {
ind = temp_arr[ind];
}
}
delete[] temp_arr;
}
void setup(int value, string name) {
string name_in = name + ".in";
string name_out = name + ".out";
freopen(name_in.c_str(), "r", stdin);
if (value) {
freopen(name_out.c_str(), "w", stdout);
}
}
struct no_road {
int a, b, c;
no_road() {}
no_road(int x, int y, int z) {
a = x;
b = y;
c = z;
}
bool operator<(const no_road &r) const {
if (a != r.a) return a < r.a;
if (b != r.b) return b < r.b;
return c < r.c;
}
};
struct state {
int dist;
int prev;
int cur;
state(int d, int p, int c) {
dist = d;
prev = p;
cur = c;
}
bool operator<(const state &s) const { return dist < s.dist; }
bool operator>(const state &s) const { return s.dist < dist; }
};
map<int, vector<int> > mp;
set<no_road> st;
int dp[3001][3001];
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
mp[a].push_back(b);
mp[b].push_back(a);
}
for (map<int, vector<int> >::iterator it = mp.begin(); it != mp.end(); it++)
sort(it->second.begin(), it->second.end());
for (int i = 0; i < k; i++) {
no_road r;
scanf("%d%d%d", &r.a, &r.b, &r.c);
st.insert(r);
}
memset(dp, 1, sizeof(dp));
priority_queue<state, vector<state>, greater<state> > p_q;
p_q.push(state(0, 1, 1));
dp[1][1] = 0;
while (!p_q.empty()) {
int dist = p_q.top().dist;
int prev = p_q.top().prev;
int cur = p_q.top().cur;
p_q.pop();
if (dp[prev][cur] < dist) continue;
dp[prev][cur] = dist;
if (cur == n) {
vector<int> res(1, cur);
while (prev != 1) {
res.push_back(prev);
vector<int> &vi = mp[prev];
for (int i = 0; i < vi.size(); i++)
if (dp[vi[i]][prev] == dist - 1 &&
!st.count(no_road(vi[i], prev, cur))) {
dist--;
cur = prev;
prev = vi[i];
break;
}
}
printf("%d\n", ((int)(res).size()));
res.push_back(1);
reverse(res.begin(), res.end());
for (int i = 0; i < res.size(); i++) printf("%d ", res[i]);
return 0;
}
vector<int> &vi = mp[cur];
for (int i = 0; i < vi.size(); i++)
if (!st.count(no_road(prev, cur, vi[i]))) {
if (dp[cur][vi[i]] > dist + 1) {
dp[cur][vi[i]] = dist + 1;
p_q.push(state(dist + 1, cur, vi[i]));
}
}
}
std::cout << -1 << std::endl;
return 0;
}
| 11 | CPP |
#include<stdio.h>
#include<algorithm>
int main()
{
int N,M,T[100],L[100],i,j,s,e;
while(scanf("%d",&N),N)
{
for(i=0;i<N;++i)
{
scanf("%d%d",&M,L+i);
for(T[i]=0;M--;)
for(scanf("%d%d",&s,&e);s-e;++s)
T[i]|=1<<(s-6);
}
int dp[1<<16]={};
for(i=0;i<(1<<16);++i)
{
for(j=0;j<N;++j)
{
if(i&T[j])continue;
int&r=dp[i|T[j]];
r=std::max(r,dp[i]+L[j]);
}
}
printf("%d\n",*std::max_element(dp,dp+(1<<16)));
}
return 0;
} | 0 | CPP |
t = int(input())
for i in range(t):
n = int(input())
x = list(map(int, input()))
a = [0] * len(x)
b = [0] * len(x)
k = 0
for i in range(len(x)):
if x[i] == 1 and k == 0:
a[i] = 1
k = 1
elif x[i] == 1 and k == 1:
b[i] = 1
elif x[i] == 2 and k == 0:
a[i] = 1
b[i] = 1
elif x[i] == 2 and k == 1:
a[i] = 0
b[i] = 2
print(*a, sep='')
print(*b, sep='') | 9 | PYTHON3 |
#include <bits/stdc++.h>
int main() {
int c1, c2, c3, c4, c5;
scanf("%d %d %d %d %d", &c1, &c2, &c3, &c4, &c5);
int sum = c1 + c2 + c3 + c4 + c5;
if (sum % 5 == 0 && sum > 0)
printf("%d\n", sum / 5);
else
printf("-1");
}
| 7 | CPP |
import sys
r=sys.stdin.readline
for _ in range(int(r())):
n,k=map(int,r().split())
a=list(map(int,r().split()))
a.sort()
print(sum(a[-(k+1):])) | 8 | PYTHON3 |
import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
n=int(input())
w=list(map(int,input().split()))
ans=max(w)
graph=[]
for i in range(n):
graph.append([])
for i in range(n-1):
u,v,c=map(int,input().split())
graph[u-1].append((v-1,c))
graph[v-1].append((u-1,c))
children=[]
parents=[-1]*n
for i in range(n):
children.append([])
stack=[(0,-1)]
while stack:
curr,parent=stack.pop()
for i,j in graph[curr]:
if i!=parent:
children[curr].append((i,j))
parents[i]=curr
stack.append((i,curr))
donechildren=[0]*n
value=[0]*n
stack=[]
for i in range(n):
if not children[i]:
stack.append(i)
while stack:
curr=stack.pop()
k=[]
for child,cost in children[curr]:
k.append(value[child]-cost)
k.sort()
if len(children[curr])>=2:
ans=max(ans,k[-1]+k[-2]+w[curr])
if children[curr]:
value[curr]=max(w[curr],w[curr]+k[-1])
else:
value[curr]=w[curr]
ans=max(ans,value[curr])
if curr==0:
break
parent=parents[curr]
donechildren[parent]+=1
if donechildren[parent]==len(children[parent]):
stack.append(parent)
print(ans) | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return ((a * b) / gcd(a, b)); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long n, m;
cin >> n >> m;
map<string, long long> mapp;
for (long long i = 0; i < n; i++) {
string s;
cin >> s;
mapp[s]++;
}
for (long long i = 0; i < m; i++) {
set<string> combinations;
vector<long long> pos;
long long noOfBlanks = 0;
string s;
cin >> s;
for (long long j = 0; j < s.length(); j++) {
if (s[j] == '?') {
++noOfBlanks;
pos.push_back(j);
}
}
if (noOfBlanks == 0) {
combinations.insert(s);
} else if (noOfBlanks == 1) {
for (long long k = 0; k < 6; k++) {
string extra;
string now = "";
if (k == 0) {
extra = 'a';
} else if (k == 1) {
extra = 'b';
} else if (k == 2) {
extra = 'c';
} else if (k == 3) {
extra = 'd';
} else if (k == 4) {
extra = 'e';
} else {
extra = "";
}
now = s.substr(0, pos[0]);
now += extra;
now += s.substr(pos[0] + 1, n - pos[0] - 1);
combinations.insert(now);
}
} else if (noOfBlanks == 2) {
for (long long k = 0; k < 6; k++) {
string extra;
string now = "";
if (k == 0) {
extra = 'a';
} else if (k == 1) {
extra = 'b';
} else if (k == 2) {
extra = 'c';
} else if (k == 3) {
extra = 'd';
} else if (k == 4) {
extra = 'e';
} else {
extra = "";
}
now = s.substr(0, pos[0]);
now += extra;
now += s.substr(pos[0] + 1, pos[1] - pos[0] - 1);
for (long long l = 0; l < 6; l++) {
string extra1 = "";
if (l == 0) {
extra1 = 'a';
} else if (l == 1) {
extra1 = 'b';
} else if (l == 2) {
extra1 = 'c';
} else if (l == 3) {
extra1 = 'd';
} else if (l == 4) {
extra1 = 'e';
} else {
extra1 = "";
}
now += extra1;
now += s.substr(pos[1] + 1, n - pos[1] - 1);
combinations.insert(now);
if (l < 5) {
now = s.substr(0, pos[0]);
now += extra;
now += s.substr(pos[0] + 1, pos[1] - pos[0] - 1);
}
}
}
} else {
for (long long k = 0; k < 6; k++) {
string extra;
string now = "";
if (k == 0) {
extra = 'a';
} else if (k == 1) {
extra = 'b';
} else if (k == 2) {
extra = 'c';
} else if (k == 3) {
extra = 'd';
} else if (k == 4) {
extra = 'e';
} else {
extra = "";
}
now = s.substr(0, pos[0]);
now += extra;
now += s.substr(pos[0] + 1, pos[1] - pos[0] - 1);
for (long long l = 0; l < 6; l++) {
string extra1 = "";
if (l == 0) {
extra1 = 'a';
} else if (l == 1) {
extra1 = 'b';
} else if (l == 2) {
extra1 = 'c';
} else if (l == 3) {
extra1 = 'd';
} else if (l == 4) {
extra1 = 'e';
} else {
extra1 = "";
}
now += extra1;
now += s.substr(pos[1] + 1, pos[2] - pos[1] - 1);
for (long long o = 0; o < 6; o++) {
string extra2 = "";
if (o == 0) {
extra2 = 'a';
} else if (o == 1) {
extra2 = 'b';
} else if (o == 2) {
extra2 = 'c';
} else if (o == 3) {
extra2 = 'd';
} else if (o == 4) {
extra2 = 'e';
} else {
extra2 = "";
}
now += extra2;
now += s.substr(pos[2] + 1, n - pos[2] - 1);
combinations.insert(now);
if (o < 5) {
now = s.substr(0, pos[0]);
now += extra;
now += s.substr(pos[0] + 1, pos[1] - pos[0] - 1);
now += extra1;
now += s.substr(pos[1] + 1, pos[2] - pos[1] - 1);
}
}
combinations.insert(now);
now = s.substr(0, pos[0]);
now += extra;
now += s.substr(pos[0] + 1, pos[1] - pos[0] - 1);
}
}
}
long long counter = 0;
set<string>::iterator it;
for (it = combinations.begin(); it != combinations.end(); it++) {
if (mapp[*it] >= 1) {
counter += (mapp[*it]);
}
}
cout << counter << '\n';
}
return 0;
}
| 13 | CPP |
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<stack>
#include<list>
#include<set>
#include<string>
#include <iomanip>
using namespace std;
typedef long long ll;
int Tmax, V, E, u, v, d, Nnew, new_id, dst, order[11111], check[444], par[444], sum = 0;
vector<vector<pair<int, int>>> li(444);
queue<pair<int, int>> route;
queue<int> store;
queue<int> car;
void dfs(int now, int distance) {
route.push(make_pair(now, distance));
sum += distance * 2;
for (auto &e : li[now]) {
if (par[e.first] == now) {
dfs(e.first, e.second);
route.push(make_pair(now, e.second));
}
}
}
int main() {
cin >> V >> E;
for (int i = 0; i < E; i++) {
cin >> u >> v >> d;
li[u].push_back(make_pair(v, d));
li[v].push_back(make_pair(u, d));
}
cin >> Tmax;
for (int i = 0; i < Tmax; i++) {
cin >> Nnew;
if (Nnew)
cin >> new_id >> order[i];
else
order[i] = -1;
}
for (int i = 1; i <= V; i++)
check[i] = 0;
priority_queue<pair<pair<int, int>, int>, vector<pair<pair<int, int>, int>>, greater<pair<pair<int, int>, int >>> que;
que.push(make_pair(make_pair(0, 1), -1));
while (!que.empty()) {
int now = que.top().first.second, npar = que.top().second;
que.pop();
if (!check[now]) {
check[now]++;
par[now] = npar;
for (auto &e : li[now]) {
int next = e.first, dnext = e.second;
if (!check[next])
que.push(make_pair(make_pair(dnext, next), now));
}
}
}
dfs(1, 0);
route.pop();
int count = 0, ndst=1, check_store = 1;
for (int i=0; i < Tmax; i++) {
if (order[i] > 0)
store.push(order[i]);
if (ndst == 1 && !count)
check_store = 1;
if (check_store) {
while (!store.empty()) {
car.push(store.front());
store.pop();
}
}
if (check_store&&car.size() < 1)
cout << "-1" << endl;
else {
check_store = 0;
if (!count) {
queue<int> keep;
while (!car.empty()) {
if (car.front() != ndst)
keep.push(car.front());
car.pop();
}
while (!keep.empty()) {
car.push(keep.front());
keep.pop();
}
int nowp = ndst;
ndst = route.front().first;
count = route.front().second;
route.pop();
route.push(make_pair(ndst, count));
if (car.empty()) {
while (ndst != par[nowp]) {
ndst = route.front().first;
count = route.front().second;
route.pop();
route.push(make_pair(ndst, count));
}
}
}
cout << ndst << endl;
count--;
}
}
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 10;
struct node {
long long mx;
long long i;
long long sum;
node() {
mx = 0;
i = -1;
sum = 0;
}
};
node t[4 * maxn];
long long a[maxn];
void upd(long long v, long long vl, long long vr) {
if (t[vl].mx > t[vr].mx) {
t[v].i = t[vl].i;
t[v].mx = t[vl].mx;
} else {
t[v].i = t[vr].i;
t[v].mx = t[vr].mx;
}
t[v].sum = t[vl].sum + t[vr].sum;
}
void build_tree(long long v, long long l, long long r) {
if (l + 1 == r) {
t[v].mx = a[l];
t[v].i = l;
t[v].sum = a[l];
return;
}
long long m = (l + r) / 2;
long long vl = 2 * v, vr = vl + 1;
build_tree(vl, l, m);
build_tree(vr, m, r);
upd(v, vl, vr);
}
long long st, ed, dt, res, id, sum;
void get_segm(long long v, long long l, long long r) {
if (l >= ed || r <= st) return;
if (st <= l && r <= ed) {
if (res < t[v].mx) {
res = t[v].mx;
id = t[v].i;
}
sum += t[v].sum;
return;
}
long long m = (l + r) / 2;
long long vl = 2 * v, vr = vl + 1;
get_segm(vl, l, m);
get_segm(vr, m, r);
}
void update(long long v, long long l, long long r) {
if (l >= ed || r <= st) return;
if (l + 1 == r) {
t[v].mx = dt;
t[v].sum = dt;
return;
}
long long m = (l + r) / 2;
long long vl = 2 * v, vr = vl + 1;
update(vl, l, m);
update(vr, m, r);
upd(v, vl, vr);
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
long long n, m;
cin >> n >> m;
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
build_tree(1, 0, n);
for (long long i = 0; i < m; i++) {
long long t;
cin >> t;
if (t == 1) {
long long l, r;
cin >> l >> r;
st = l - 1;
ed = r;
sum = 0;
get_segm(1, 0, n);
cout << sum << "\n";
} else if (t == 2) {
long long l, r, x;
cin >> l >> r >> x;
do {
st = l - 1;
ed = r;
res = 0;
get_segm(1, 0, n);
if (res >= x) {
st = id;
ed = id + 1;
dt = res % x;
update(1, 0, n);
}
} while (res >= x);
} else {
long long k, x;
cin >> k >> x;
st = k - 1;
ed = k;
dt = x;
update(1, 0, n);
}
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<pair<int, int> > niz[5005];
int tip[5005];
int obidjen[5005];
bool ima;
void dfs(int t, int o) {
obidjen[t] = 1;
for (auto x : niz[t]) {
if (obidjen[x.first] == 1) {
tip[x.second] = 2;
ima = true;
} else
tip[x.second] = 1;
if (!obidjen[x.first]) dfs(x.first, t);
}
obidjen[t] = 2;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
int t1, t2;
scanf("%d %d", &t1, &t2);
niz[t1].push_back(make_pair(t2, i));
}
for (int i = 1; i <= n; i++)
if (!obidjen[i]) dfs(i, 0);
if (ima)
printf("2\n");
else
printf("1\n");
for (int i = 1; i <= m; i++) printf("%d ", tip[i]);
return 0;
}
| 10 | CPP |
n=int(input())
a=list(map(int,input().split()))
b=[i for i in range(1,n+1,1)];c=[]
for i,j in zip(a,b):
c.append([i-j,i])
c=sorted(c)
s=c[0][0];d=0;e=[]
for i in range(n):
if s!=c[i][0]:
s=c[i][0]
e.append(d)
d=0
d+=c[i][1]
e.append(d)
print(max(e))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target(sse, sse1, sse2, tune = native, popcnt)
using namespace std;
const long long inf = 1e17 + 47, MAXN = 5e5 + 47, mod = 1e9 + 7, N = 201;
mt19937 rnd(time(0));
struct node {
long long l, r, dw, mn;
node() {
l = r = -1;
dw = 0;
mn = inf;
}
};
vector<node> t(4 * MAXN);
void build(long long i, long long l, long long r) {
t[i].l = l, t[i].r = r;
if (l == r) {
return;
}
long long mid = (l + r) / 2;
build(i * 2, l, mid);
build(i * 2 + 1, mid + 1, r);
}
void push(long long i) {
if (t[i].l != t[i].r) {
t[i * 2].dw += t[i].dw;
t[i * 2 + 1].dw += t[i].dw;
}
t[i].mn += t[i].dw;
t[i].dw = 0;
}
void update(long long i, long long l, long long r, long long add) {
push(i);
if (t[i].l > r || t[i].r < l) return;
if (l <= t[i].l && t[i].r <= r) {
t[i].dw += add;
push(i);
return;
}
update(i * 2, l, r, add);
update(i * 2 + 1, l, r, add);
}
long long get(long long i, long long pos) {
push(i);
if (t[i].l > pos || pos > t[i].r) return inf;
if (t[i].l == pos && t[i].r == pos) return t[i].mn;
return min(get(i * 2, pos), get(i * 2 + 1, pos));
}
void eshkere(long long i, long long pos, long long a) {
push(i);
if (t[i].l > pos || pos > t[i].r) return;
if (t[i].l == pos && t[i].r == pos) {
t[i].mn = min(t[i].mn, a);
return;
}
eshkere(i * 2, pos, a);
eshkere(i * 2 + 1, pos, a);
}
void print(long long i) {
push(i);
if (t[i].l == t[i].r)
cout << t[i].mn << " ";
else
print(i * 2), print(i * 2 + 1);
}
long long n, m;
vector<long long> a, p, b;
unordered_map<long long, long long> ind;
void solve() {
cin >> n;
a.resize(n), p.resize(n);
for (long long i = 0; i < n; ++i) cin >> a[i];
for (long long i = 0; i < n; ++i) cin >> p[i];
cin >> m;
b.resize(m);
for (long long i = 0; i < m; ++i) {
cin >> b[i];
ind[b[i]] = i;
}
vector<long long> temp(m + 1, inf);
temp[0] = 0;
long long UK = 0;
build(1, 0, m);
eshkere(1, 0, 0);
for (long long i = 0; i < n; ++i) {
long long t = inf;
if (ind.find(a[i]) != ind.end()) {
t = get(1, ind[a[i]]);
}
if (p[i] < 0) {
update(1, 0, UK, p[i]);
} else {
long long ind =
(long long)(lower_bound(b.begin(), b.end(), a[i]) - b.begin());
ind = min(ind, UK);
update(1, 0, ind, p[i]);
}
if (ind.find(a[i]) != ind.end()) {
if (UK >= ind[a[i]]) {
eshkere(1, ind[a[i]] + 1, t);
UK = max(UK, ind[a[i]] + 1);
}
}
}
long long t = get(1, m);
if (t == inf)
cout << "NO" << endl;
else
cout << "YES" << endl << t << endl;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie();
long long t = 1;
while (t--) {
solve();
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 16;
char e[N][N];
int n, ct[N][64], ctt[N][128];
bool vis[N];
long long ans[1 << 14 | 1];
void dfs(int u, int k) {
if (u < k) return;
if (k == 0) {
static int p[N];
int t = 0;
for (int i = 1; i <= n; ++i)
if (vis[i]) p[++t] = i;
do {
int S = 0;
for (int i = 1; i < t; ++i) S = S << 1 | (e[p[i]][p[i + 1]]);
++ct[p[t]][S];
} while (next_permutation(p + 1, p + t + 1));
t = 0;
for (int i = 1; i <= n; ++i)
if (!vis[i]) p[++t] = i;
do {
int S = 0;
for (int i = 1; i < t; ++i) S = S << 1 | (e[p[i]][p[i + 1]]);
for (int i = 1; i <= n; ++i)
if (vis[i]) {
int T = S | (e[i][p[1]]) << (t - 1);
++ctt[i][T];
}
} while (next_permutation(p + 1, p + t + 1));
for (int i = 1; i <= n; ++i)
if (vis[i]) {
for (int j = 0; j < 64; ++j)
if (int x = ct[i][j])
for (int k = 0; k < 128; ++k)
ans[j << t | k] += (long long)x * ctt[i][k];
memset(ct[i], 0, sizeof *ct);
memset(ctt[i], 0, sizeof *ctt);
}
return;
}
dfs(u - 1, k);
vis[u] = 1;
dfs(u - 1, k - 1);
vis[u] = 0;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> (e[i] + 1);
for (int j = 1; j <= n; ++j) e[i][j] -= '0';
}
if (n < 10) {
int p[N];
for (int i = 1; i <= n; ++i) p[i] = i;
do {
int S = 0;
for (int i = 1; i < n; ++i) S = S << 1 | (e[p[i]][p[i + 1]]);
++ans[S];
} while (next_permutation(p + 1, p + n + 1));
for (int i = 0; i < 1 << (n - 1); ++i) cout << ans[i] << ' ';
} else {
dfs(n, 7);
for (int i = 0; i < 1 << (n - 1); ++i) cout << ans[i] << ' ';
}
return 0;
}
| 12 | CPP |
nr=[0,0]
last="00"
x=alt=0
n=int(input())
a=[input()]
for i in range (n-1):
a.append(input())
a.sort()
a.append("00")
for s in a:
alt^=1
if s[0]==last[0]:
nr[alt]+=1
else:
x+=(nr[0]*(nr[0]-1)/2+nr[1]*(nr[1]-1)/2)
last=s
nr=[0,0]
nr[alt]+=1
print(int(x))
| 7 | PYTHON3 |
#import math
s1 = input()
s1 = s1.lower()
s2 = input()
s2 = s2.lower()
li1 = [ord(x) for x in s1]
li2 = [ord(x) for x in s2]
lis1=0
lis2 =0
c=0
for i in range(len(li1)):
lis1 += li1[i]
for i in range(len(li1)):
lis2 += li2[i]
#else:
for i in range(len(li1)):
if li1[i]>li2[i]:
print(1)
break
elif li1[i]<li2[i]:
print(-1)
break
else:
c +=1
if (c==len(li2)):
print(0)
# for i in range(len(li1)):
# lis1 += li1[i]
#
# for i in range(len(li1)):
# lis2 += li2[i]
#
#
# if (lis1>lis2):
# print(1)
# elif(lis1<lis2):
# print(-1)
# else:
# print(0)
| 7 | PYTHON3 |
from sys import stdin
for _ in range(int(input())):
n = int(stdin.readline().rstrip())
l = list(map(int, stdin.readline().rstrip().split(" ")))
if l == sorted(l):
print(0)
else:
cs = ce = 0
for i in range(0, n):
if l[i]!=i+1:
break
cs+=1
for i in range(n-1,-1,-1):
if l[i]!=i+1:
break
ce +=1
pos_al_sorted = False
for i in range(cs, n - ce):
if l[i]==i+1:
pos_al_sorted=True
break
if pos_al_sorted:
print(2)
else:
print(1) | 9 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
using namespace std;
long long int dp[100005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int a, b, i, ans = 0, j;
cin >> a;
for (i = 0; i < a; i++) {
cin >> b;
dp[b] = 1;
for (j = 2; j * j <= b; j++)
if (b % j == 0) dp[b] = max(dp[b], max(dp[j], dp[b / j]) + 1);
for (j = 2; j * j <= b; j++)
if (b % j == 0) dp[j] = dp[b / j] = dp[b];
ans = max(dp[b], ans);
}
cout << ans << endl;
}
| 10 | CPP |
a=int(input())
l=[]
for i in range(1,a+1):
s=str(input())
l.append(s)
b=0
for i in l:
if i=="++X" or i=="X++":
b=b+1
if i=="--X" or i=="X--":
b=b-1
print(b) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4;
bool vis[N];
pair<int, pair<int, int> > P[N];
pair<int, int> ans[N], siz[N], s[N];
int main() {
int n, k, sum = 0, C = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int c, p;
scanf("%d%d", &c, &p);
P[i] = make_pair(p, make_pair(c, i + 1));
}
sort(P, P + n);
scanf("%d", &k);
for (int i = 0; i < k; i++) {
int x;
scanf("%d", &x);
s[i] = {x, i + 1};
}
sort(s, s + k);
int l = 0;
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < k; j++) {
if (P[i].second.first <= s[j].first && vis[s[j].second] == 0) {
vis[s[j].second] = 1;
C++;
sum += P[i].first;
ans[l] = {P[i].second.second, s[j].second};
l++;
break;
}
}
}
cout << C << " " << sum << endl;
for (int i = 0; i < C; i++) {
cout << ans[i].first << " " << ans[i].second << endl;
}
return 0;
}
| 9 | CPP |
# cf 758 A 700
n = input()
A = list(map(int, input().split()))
m = max(A)
s_ = 0
for a in A:
s_ += (m - a)
print(s_)
| 7 | PYTHON3 |
from sys import stdin
t = int(stdin.readline())
for _ in range(t):
n = int(stdin.readline())
a = []
s = []
for i in range(n):
m = int(stdin.readline())
if m == 1:
s.append(1)
a.append('1')
else:
while s[-1] != m-1:
s.pop()
a.pop()
s[-1] += 1
a[-1] = str(m)
print(".".join(a))
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n;
string st;
long long arr[10005];
int main() {
int n;
cin >> n;
if (n % 2 == 1)
cout << (n - 1) / 2 << endl;
else {
long long x = 1;
while (2 * x <= n) x *= 2;
cout << (n - x) / 2 << endl;
}
return 0;
}
| 7 | CPP |
n = int(input())
s = input()
ans = []
count = s.count('n')
for _ in range(count):
ans.append(1)
count = s.count('z')
for _ in range(count):
ans.append(0)
for i in ans:
print(i, end=' ')
print() | 7 | PYTHON3 |
def solve():
N = int(input())
L = list(map(int, input().split()))
print(len(set(L)))
T = int(input())
for _ in range(T):
solve()
| 7 | PYTHON3 |
n, s = map(int, input().split(' '))
a = list(map(int, input().split(' ')))
b = list(map(int, input().split(' ')))
import copy
def solution(n, s, a, b):
answer = []
if a[0] == 0:
return 'NO'
answer = copy.deepcopy(a)
max_index = 0
for i in range(len(a)):
if a[i] == 1 and b[i] == 1:
max_index = i
for i in range(max_index):
if b[i] == 1:
answer[i] = 1
return "YES" if answer[s - 1] == 1 else 'NO'
print(solution(n, s, a, b)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, m, a[1005], ans, min, min2;
a[1004] = 100000;
cin >> t;
for (int i = 0; i < t; i++) {
scanf("%d%d", &m, &n);
ans = 0;
min = 1004;
min2 = 1004;
for (int j = 0; j < m; j++) {
scanf("%d", &a[j]);
ans += a[j];
if (a[j] < a[min])
min = j;
else if (a[j] < min2)
min2 = j;
}
if (n < m || m <= 2) {
cout << "-1" << endl;
continue;
}
ans *= 2;
ans += (n - m) * (a[min] + a[min2]);
cout << ans << endl;
for (int i = 1; i < m; i++) {
printf("%d %d\n", i, i + 1);
}
printf("%d %d\n", m, 1);
for (int i = 0; i < n - m; i++) {
printf("%d %d\n", min + 1, min2 + 1);
}
}
return 0;
}
| 8 | CPP |
from itertools import product
n = input()
print(['YES', 'NO'][all(int(n) % int(''.join(t)) for i in [1,2,3][:len(n)] for t in product('47', repeat=i))])
| 7 | PYTHON3 |
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <map>
#include <bitset>
#include <climits>
using namespace std;
const long long INF = LLONG_MAX / 4;
int main(){
int n, m, w, t;
cin >> n >> m >> w >> t;
map<string, int> name;
vector<int> v(m), sell(m); // ツ重ツつウツ、ツ氾個板可ソツ格
for(int i=0; i<m; ++i){
string s;
cin >> s >> v[i] >> sell[i];
name[s] = i;
}
vector<int> x(n), y(n);
vector<vector<long long> > buy(n, vector<long long>(m, INF)); // ツ仕ツ禿シツづェツ値
for(int i=0; i<n; ++i){
int l;
cin >> l >> x[i] >> y[i];
for(int j=0; j<l; ++j){
string s;
int a;
cin >> s >> a;
buy[i][name[s]] = a;
}
}
vector<int> order(n);
for(int i=0; i<n; ++i)
order[i] = i;
vector<long long> minTime(1<<n, INF);
vector<vector<long long> > minBuy(1<<n, vector<long long>(m, INF));
do{
bitset<7> bs;
long long len = 0;
int y0 = 0;
int x0 = 0;
for(int j=0; j<n; ++j){
int curr = order[j];
bs[curr] = true;
for(int k=0; k<m; ++k)
minBuy[bs.to_ulong()][k] = min(minBuy[bs.to_ulong()][k], buy[curr][k]);
len += abs(y0 - y[curr]) + abs(x0 - x[curr]);
minTime[bs.to_ulong()] = min(minTime[bs.to_ulong()], len + abs(y[curr]) + abs(x[curr]));
y0 = y[curr];
x0 = x[curr];
}
}while(next_permutation(order.begin(), order.end()));
vector<long long> maxMoney(1<<n, 0); // ツ嘉アツづゥツ店ツづ可妥篠つオツづづ個催妥・ツ猟伉益
for(int i=0; i<(1<<n); ++i){
vector<long long> maxMoneyTmp(w+1, 0); // ツ重ツづ敖づ可妥篠つオツづづ個催妥・ツ猟伉益
for(int j=1; j<=w; ++j){
maxMoneyTmp[j] = maxMoneyTmp[j-1];
for(int k=0; k<m; ++k){
if(j - v[k] >= 0)
maxMoneyTmp[j] = max(maxMoneyTmp[j], maxMoneyTmp[j-v[k]] + sell[k] - minBuy[i][k]);
}
}
maxMoney[i] = maxMoneyTmp[w];
}
vector<long long> ret(t+1, 0); // ツ篠楪甘板づ可妥篠つオツづづ個催妥・ツ猟伉益
for(int i=1; i<=t; ++i){
ret[i] = ret[i-1];
for(int j=0; j<(1<<n); ++j){
if(i - minTime[j] >= 0)
ret[i] = max(ret[i], ret[i-minTime[j]] + maxMoney[j]);
}
}
cout << ret[t] << endl;
return 0;
} | 0 | CPP |
import sys
# sys.setrecursionlimit(10**6)
from sys import stdin, stdout
import bisect #c++ upperbound
from itertools import groupby
import math
import heapq
def modinv(n,p):
return pow(n,p-2,p)
def cin():
return map(int,sin().split())
def ain(): #takes array as input
return list(map(int,sin().split()))
def sin():
return input()
def inin():
return int(input())
import math
def Divisors(n) :
l = []
for i in range(1, int(math.sqrt(n) + 1)) :
if (n % i == 0) :
if (n // i == i) :
l.append(i)
else :
l.append(i)
l.append(n//i)
return l
def most_frequent(list):
return max(set(list), key = list.count)
#Implement heapq
#grades = [110, 25, 38, 49, 20, 95, 33, 87, 80, 90]
#print(heapq.nlargest(3, grades)) #top 3 largest
#print(heapq.nsmallest(4, grades))
#Always make a variable of predefined function for ex- fn=len
"""*******************************************************"""
def main():
#Write Your Code Here
n=ain()
c=n[0]
v0=n[1]
v1=n[2]
a=n[3]
l=n[4]
res=c
count=1
for i in range(c):
res=res-v0
if res<=0:
print(count)
break
else:
if count==1 and res<=0:
print(count)
break
else:
if count!=0:
v0=min(v0+a,v1)
res=res+l
if res<=0:
print(count)
break
count=count+1
######## Python 2 and 3 footer by Pajenegod and c1729
# Note because cf runs old PyPy3 version which doesn't have the sped up
# unicode strings, PyPy3 strings will many times be slower than pypy2.
# There is a way to get around this by using binary strings in PyPy3
# but its syntax is different which makes it kind of a mess to use.
# So on cf, use PyPy2 for best string performance.
py2 = round(0.5)
if py2:
from future_builtins import ascii, filter, hex, map, oct, zip
range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192
class FastIO(BytesIO):
newlines = 0
def __init__(self, file):
self._file = file
self._fd = file.fileno()
self.writable = "x" in file.mode or "w" in file.mode
self.write = super(FastIO, self).write if self.writable else None
def _fill(self):
s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.seek((self.tell(), self.seek(0,2), super(FastIO, self).write(s))[0])
return s
def read(self):
while self._fill(): pass
return super(FastIO,self).read()
def readline(self):
while self.newlines == 0:
s = self._fill(); self.newlines = s.count(b"\n") + (not s)
self.newlines -= 1
return super(FastIO, self).readline()
def flush(self):
if self.writable:
os.write(self._fd, self.getvalue())
self.truncate(0), self.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
if py2:
self.write = self.buffer.write
self.read = self.buffer.read
self.readline = self.buffer.readline
else:
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')
# Cout implemented in Python
import sys
class ostream:
def __lshift__(self,a):
sys.stdout.write(str(a))
return self
cout = ostream()
endl = '\n'
# Read all remaining integers in stdin, type is given by optional argument, this is fast
def readnumbers(zero = 0):
conv = ord if py2 else lambda x:x
A = []; numb = zero; sign = 1; i = 0; s = sys.stdin.buffer.read()
try:
while True:
if s[i] >= b'0' [0]:
numb = 10 * numb + conv(s[i]) - 48
elif s[i] == b'-' [0]: sign = -1
elif s[i] != b'\r' [0]:
A.append(sign*numb)
numb = zero; sign = 1
i += 1
except:pass
if s and s[-1] >= b'0' [0]:
A.append(sign*numb)
return A
if __name__== "__main__":
main()
| 7 | PYTHON3 |
n,m=map(int,input().split())
M=[]
for _ in range(m):
M.append(list(map(int,input().split())))
#print(M)
v=[0]*n
for i in M:
pos=i.index(max(i))
v[pos]+=1
print(v.index(max(v))+1) | 7 | PYTHON3 |
import fractions
X = int(input())
ans = [float("inf"),float("inf")]
for i in range(10 ** 6):
i += 1
if X % i == 0:
j = X // i
if fractions.gcd(i,j) == 1:
if max(ans) > max(i,j):
ans = [i,j]
if ans[0] == float("inf"):
print (1,X)
else:
print (ans[0],ans[1])
| 9 | PYTHON3 |
import sys,bisect as bs,collections as cl
sys.setrecursionlimit(100000)
mod = 10**9+7
Max = sys.maxsize
def l(): #intのlist
return list(map(int,input().split()))
def m(): #複数文字
return map(int,input().split())
def onem(): #Nとかの取得
return int(input())
def s(x): #圧縮
a = []
aa = x[0]
su = 1
for i in range(len(x)-1):
if aa != x[i+1]:
a.append([aa,su])
aa = x[i+1]
su = 1
else:
su += 1
a.append([aa,su])
return a
def jo(x): #listをスペースごとに分ける
return " ".join(map(str,x))
def max2(x): #他のときもどうように作成可能
return max(map(max,x))
def In(x,a): #aがリスト(sorted)
k = bs.bisect_left(a,x)
if k != len(a) and a[k] == x:
return True
else:
return False
n = onem()
p = [0] + l() + [n+1]
ans = 0
a = [0 for i in range(n+2)]
for i in range(n+2):
a[p[i]] = i
l = [set() for i in range(n+2)]
r = [set() for i in range(n+2)]
for i in range(n+2):
l[i].add(max(0,i-1))
l[i].add(max(0,i-2))
r[i].add(min(n+1,i+1))
r[i].add(min(n+1,i+2))
for i in range(n+1):
m = a[i]
x2,x1,y1,y2 = min(l[m]),max(l[m]),min(r[m]),max(r[m])
hoge= i*(abs((m-x1)*(y2-y1)) + abs((y1-m)*(x1-x2)))
ans += hoge
r[x1].clear()
r[x1].add(y1)
r[x1].add(y2)
l[y1].clear()
l[y1].add(x1)
l[y1].add(x2)
r[x2].clear()
r[x2].add(x1)
r[x2].add(y1)
l[y2].clear()
l[y2].add(y1)
l[y2].add(x1)
print(ans)
| 0 | PYTHON3 |
def step(a, b):
if a > n - 3 or b == 0 or b == n - 1 or l[a + 1][b] == '#' or l[a + 2][b] == '#' or l[a + 1][b - 1] == '#' or l[a + 1][b + 1] == '#':
return False
else:
l[a] = l[a][:b] + '#' + l[a][b + 1:]
l[a + 1] = l[a + 1][:b - 1] + '###' + l[a + 1][b + 2:]
l[a + 2] = l[a + 2][:b] + '#' + l[a + 2][b + 1:]
return True
n = int(input())
l = [input() for i in range(n)]
ans = 'YES'
for i in range(n):
for j in range(n):
if l[i][j] == '.' and not step(i, j):
ans = 'NO'
print(ans) | 8 | PYTHON3 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 998244353
dd = [(0,-1),(1,0),(0,1),(-1,0)]
ddn = [(0,-1),(1,-1),(1,0),(1,1),(0,1),(-1,-1),(-1,0),(-1,1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
rr = []
ii = [2**i for i in range(6)]
while True:
n = I()
if n == 0:
break
a = [S() for _ in range(n)]
d = 0
s = [[]]
for c in a:
l = len(c)
while l <= d:
if s[-1][0] == '+':
k = 0
for kc in s[-1][1:]:
k += kc
else:
k = 1
for kc in s[-1][1:]:
k *= kc
s = s[:-1]
s[-1].append(k)
d -= 1
t = c[-1]
if t == '+' or t == '*':
d += 1
s.append([t])
else:
s[-1].append(int(t))
while len(s) > 1:
if s[-1][0] == '+':
k = 0
for kc in s[-1][1:]:
k += kc
else:
k = 1
for kc in s[-1][1:]:
k *= kc
s = s[:-1]
s[-1].append(k)
rr.append(s[0][0])
return '\n'.join(map(str, rr))
print(main())
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
const int mod = 1e9 + 7;
int c[maxn], last[maxn];
void add(int pos, int val) {
while (pos < maxn) {
c[pos] += val;
c[pos] %= mod;
pos += pos & (-pos);
}
}
int getsum(int pos) {
int ret = 0;
while (pos > 0) {
ret = (ret + c[pos]) % mod;
pos -= pos & (-pos);
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, ans = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
int temp = (a + 1LL * a * getsum(a) % mod) % mod;
temp = (temp - last[a] + mod) % mod;
last[a] = (last[a] + temp) % mod;
ans = (ans + temp) % mod;
add(a, temp);
}
cout << ans << endl;
return 0;
}
| 11 | CPP |
n=int(input())
it=list(map(int,input().split()))
a=[i for i in it if i<=-1]
b=[i for i in it if i>=1]
c=n-len(a)-len(b)
if len(a)%2==0:
print(sum([-1-i for i in a])+sum([i-1 for i in b])+1*c)
if len(a)%2==1:
if c!=0:
print(sum([-1-i for i in a])+sum([i-1 for i in b])+1*c)
else:
aa=sum([-1-i for i in a])
bb=-1-max(a)
cc=sum([i-1 for i in b])
d=1-max(a)
print(aa-bb+cc+d)
| 8 | PYTHON3 |
#if(a>1): b=1
#else: b=2
#can be written as b=1 if a>1 else 2
n = int(input())
a = [ int(x[-1])%2 for x in input().split()]
i=0
series = a[0]
series_len=0
res=[]
prev=''
while(i<=n):
if(i<n and a[i]==series): #for length of sereis
series_len+=1
else: #working on previous block
if(series_len%2!=0): #checks if True of False
#current= 'F0' if sereis==0 else 'F1' #checks if F0 or F1
if(prev==series): #checks if previous was same as current
res.pop(-1)
prev= res[-1] if len(res)>=1 else '' #checks if result is empty or not
else:
res.append(series)
prev=series
if(i<n):series= a[i]
series_len=1
i+=1
print('Yes') if len(res)<=1 else print('No')
#True means continuous even no of columns of either 1 or 0
#True signifies the set of columns can be made to even length or odd
#F0 means false if column set has length even
| 10 | PYTHON3 |
n,m = (int(i) for i in input().split())
l = False
for i in range(n):
s = input()
k = s[0]
for j in range(len(s)):
if s[j]!=k:
print("NO")
exit(0)
if l==False:
l = False
elif (s[j] == s1[j]):
print("NO")
exit(0)
l = True
s1 = s
print("YES")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int y;
char id;
} x[26];
bool cmp(node a, node b) {
if (a.y == b.y)
return a.id < b.id;
else
return a.y > b.y;
}
bool isPrime(int a) {
for (int i = 2; i < a; i++)
if (a % i == 0) return false;
return true;
}
int main() {
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
x[s[i] - 'a'].y++;
x[s[i] - 'a'].id = s[i];
}
sort(x, x + 26, cmp);
char a[1005];
fill(a, a + s.size() + 1, '$');
int k = 0;
for (int i = 2; i < s.size() + 1; i++) {
if (isPrime(i)) {
if (x[k].y == 0) k++;
a[i] = x[k].id;
x[k].y--;
for (int j = i + i; j < s.size() + 1; j += i) {
if ((a[j] != '$' && a[j] != a[i]) || (a[j] == '$' && x[k].y == 0)) {
cout << "NO" << endl;
return 0;
} else if (a[j] == '$' && x[k].y != 0) {
a[j] = x[k].id;
x[k].y--;
}
}
}
}
if (x[k].y == 0) k++;
a[1] = x[k].id;
cout << "YES" << endl;
for (int i = 1; i < s.size() + 1; i++) cout << a[i];
cout << endl;
return 0;
}
| 7 | CPP |
n=int(input())
a=list(map(int,input().split()))
b=[0]*(n+1)
c=0
m=0
for x in a:
b[x]=(b[x]+1)%2
c+=(-1,1)[b[x]]
m=max(m,c)
print(m)
| 7 | PYTHON3 |
n,a = map(int,input().split())
x = list(map(int,input().split()))
x = [t-a for t in x]
p = [0]*5010
p[0] = 1
q = [0]*5010
for t in x:
for i in range(5010):
q[i] = p[i] + p[(i-t)%5010]
for i in range(5010):
p[i] = q[i]
print(p[0]-1) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
string to_string(string s) { return '"' + s + '"'; }
string to_string(char s) { return string(1, s); }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A>
string to_string(A);
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool f = 1;
string r = "{";
for (const auto& x : v) {
if (!f) r += ", ";
f = 0;
r += to_string(x);
}
return r + "}";
}
void debug_out() { cout << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cout << " " << to_string(H);
debug_out(T...);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> a(n);
map<int, set<int>> mp;
for (auto i = (0); i <= (n - 1); ++i) {
cin >> a[i];
if (!mp.count(a[i])) mp[a[i]].insert(n + a[i]);
mp[a[i]].insert(i);
}
int ans = 0;
set<int> s;
map<int, int> pos;
for (auto i = (0); i <= (n - 1); ++i) {
if (s.count(a[i])) {
} else if (int(s.size()) < k) {
s.insert(a[i]);
++ans;
} else {
++ans;
auto it = *pos.rbegin();
s.erase(it.second);
pos.erase(it.first);
s.insert(a[i]);
}
mp[a[i]].erase(i);
pos[*mp[a[i]].upper_bound(i)] = a[i];
}
cout << ans;
return 0;
}
| 7 | CPP |
#_________________ Mukul Mohan Varshney _______________#
#Template
import sys
import os
import math
import copy
from math import gcd
from bisect import bisect
from io import BytesIO, IOBase
from math import sqrt,floor,factorial,gcd,log,ceil
from collections import deque,Counter,defaultdict
from itertools import permutations, combinations
import itertools
#define function
def Int(): return int(sys.stdin.readline())
def Mint(): return map(int,sys.stdin.readline().split())
def Lstr(): return list(sys.stdin.readline().strip())
def Str(): return sys.stdin.readline().strip()
def Mstr(): return map(str,sys.stdin.readline().strip().split())
def List(): return list(map(int,sys.stdin.readline().split()))
def Hash(): return dict()
def Mod(): return 1000000007
def Ncr(n,r,p): return ((fact[n])*((ifact[r]*ifact[n-r])%p))%p
def Most_frequent(list): return max(set(list), key = list.count)
def Mat2x2(n): return [List() for _ in range(n)]
def Lcm(x,y): return (x*y)//gcd(x,y)
def dtob(n): return bin(n).replace("0b","")
def btod(n): return int(n,2)
# Driver Code
def solution():
for j in range(Int()):
n=Int()
v=ceil(n/4)
ans='9'*(n-v)+'8'*(v)
print(ans)
#Call the solve function
if __name__ == "__main__":
solution()
| 8 | PYTHON3 |
x=int(input())
count=0
while x:
x &= (x-1)
count += 1
print(count)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
struct DSU {
int par[N];
DSU() {
for (int i = 0; i < N; i++) par[i] = i;
}
int find(int u) {
if (par[u] == u) return u;
return par[u] = find(par[u]);
}
void merge(int u, int v) { par[find(v)] = find(u); }
};
vector<int> rowvals[N];
vector<int> colvals[N];
bool rowhas[N], colhas[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, q;
cin >> n >> m >> q;
vector<pair<int, int> > st;
set<pair<int, int> > st2;
for (int i = 0; i < q; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
st.push_back(pair<int, int>(x, y));
rowvals[x].push_back(y);
colvals[y].push_back(x);
}
DSU rows, cols;
for (int i = 0; i < n; i++) {
if (rowvals[i].empty()) continue;
for (auto u : rowvals[i]) cols.merge(u, rowvals[i][0]);
}
for (int i = 0; i < m; i++) {
if (colvals[i].empty()) continue;
for (auto u : colvals[i]) rows.merge(u, colvals[i][0]);
}
for (auto pr : st) {
int x = rows.find(pr.first);
int y = cols.find(pr.second);
rowhas[x] = 1;
colhas[y] = 1;
}
int nn = 0, mm = 0, kn = 0, km = 0;
for (int i = 0; i < n; i++)
if (rows.par[i] == i) {
nn++;
if (rowhas[i]) kn++;
}
for (int i = 0; i < m; i++)
if (cols.par[i] == i) {
++mm;
if (colhas[i]) km++;
}
assert(kn == km);
cout << (mm + nn) - (kn + 1) << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
#define int long long
using namespace std;
signed main(){
ios_base::sync_with_stdio(false);
cin.tie(0);
int n; cin >> n;
vector<string> a(n);
map<int, set<string>> srt;
int gop = 53, mod = 2654435761;
for(int i = 0; i < n; ++i){
cin >> a[i];
vector<int> cnt(26);
for(auto&j:a[i]){
++cnt[j - 'a'];
}
int val = 7;
for(int j = 0; j < (int)cnt.size(); ++j){
val += cnt[j]; val %= mod;
val *= gop; val %= mod;
}
srt[val].insert(a[i]);
}
a.clear();
for(auto&i:srt){
for(auto&j:i.second){
a.push_back(j);
}
}
int ans = 0;
vector<int> gr;
for(int rep = 0; rep < 2; ++rep){
reverse(a.begin(), a.end());
vector<vector<int>> ha(n, vector<int>((int)a[0].size() + 1));
for(int i = 0; i < n; ++i){
int val = 7;
for(int j = (int)a[0].size() - 1; j >= 0; --j){
val += (a[i][j] - '0'); val %= mod;
val *= gop; val %= mod;
ha[i][j] = val;
}
}
vector<vector<int>> haf(n, vector<int>((int)a[0].size() + 1));
for(int i = 0; i < n; ++i){
int val = 7;
for(int j = 0; j < (int)a[0].size(); ++j){
val += (a[i][j] - '0'); val %= mod;
val *= gop; val %= mod;
haf[i][j] = val;
}
}
vector<map<int, int>> mp((int)a[0].size() + 1);
int last = -1;
vector<vector<pair<int, int>>> minu(n), plu(n);
for(int i = 0; i < n;){
vector<int> cnt(26);
for(auto&j:a[i]){
++cnt[j - 'a'];
}
int j = i + 1;
while(j < n){
vector<int> cnt2(26);
for(auto&k:a[j]){
++cnt2[k - 'a'];
}
if(cnt != cnt2){
break;
}
++j;
}
for(int k = i; k < j; ++k){
int y = (int)a[k].size() - 1;
for(int x = (int)a[k].size() - 1; x >= 0; --x){
if(x < (int)a[k].size() - 1 && a[k][x] > a[k][x + 1]){
y = x;
}
int l = last + 1, r = k, mid;
while(l < r){
mid = (l + r) >> 1;
if(!x || haf[mid][x - 1] == haf[k][x - 1]){
r = mid;
}
else{
l = mid + 1;
}
}
if(haf[l][x] != haf[k][x]){
if(l > last + 1) minu[l - 1].push_back({y + 1, ha[k][y + 1]});
for(int bit = 20; bit >= 0; --bit){
if(l + (1 << bit) <= k && haf[l + (1 << bit)][x] != haf[k][x]){
l += (1 << bit);
}
}
plu[l].push_back({y + 1, ha[k][y + 1]});
}
}
for(int x = 0; x <= (int)a[k].size(); ++x){
++mp[x][ha[k][x]];
}
}
if(rep) gr.push_back(j - i);
i = j; last = j - 1;
for(int r = 0; r <= (int)a[0].size(); ++r) mp[r].clear();
}
for(int i = 0; i < n; ){
vector<int> cnt(26);
for(auto&j:a[i]){
++cnt[j - 'a'];
}
int j = i + 1;
while(j < n){
vector<int> cnt2(26);
for(auto&k:a[j]){
++cnt2[k - 'a'];
}
if(cnt != cnt2){
break;
}
++j;
}
for(int k = i; k < j; ++k){
for(int x = 0; x <= (int)a[k].size(); ++x){
++mp[x][ha[k][x]];
}
for(auto&r:minu[k]){
ans -= mp[r.first][r.second];
}
for(auto&r:plu[k]){
ans += mp[r.first][r.second];
}
}
i = j;
for(int r = 0; r <= (int)a[0].size(); ++r) mp[r].clear();
}
}
int ans3 = 0;
for(auto&i:gr){
ans3 += i * (i - 1) / 2;
}
ans += (ans3 - ans) * 2;
int ans2 = 0;
for(auto&i:gr){
ans2 += 1337 * i * (n - i);
}
ans += ans2 / 2;
cout << ans << '\n';
return 0;
} | 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (typename vector<T>::const_iterator vi = v.begin(); vi != v.end(); ++vi) {
if (vi != v.begin()) os << ", ";
os << *vi;
}
os << "}";
return os;
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
os << '(' << p.first << ", " << p.second << ')';
return os;
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
const int MAX = 1005;
const int SG_MAX = 3;
int N, X, Y, Z;
vector<int> SG[3];
int period[3];
int get_SG(int a, long long n) {
if (n <= MAX) return SG[a][n];
n = MAX - period[a] + (n - MAX) % period[a];
return SG[a][n];
}
int compute_period(vector<int> SG) {
for (int p = 1;; p++) {
bool works = true;
for (int i = MAX / 2; i + p <= MAX; i++)
if (SG[i] != SG[i + p]) {
works = false;
break;
}
if (works) return p;
}
}
void precompute() {
for (int a = 0; a < 3; a++) SG[a].assign(MAX + 1, 0);
for (int n = 1; n <= MAX; n++)
for (int a = 0; a < 3; a++) {
vector<bool> seen(SG_MAX + 1, false);
seen[SG[0][max(n - X, 0)]] = true;
if (a != 1) seen[SG[1][max(n - Y, 0)]] = true;
if (a != 2) seen[SG[2][max(n - Z, 0)]] = true;
SG[a][n] = 0;
while (seen[SG[a][n]]) SG[a][n]++;
}
for (int a = 0; a < 3; a++) period[a] = compute_period(SG[a]);
}
vector<long long> A;
void run_case() {
cin >> N >> X >> Y >> Z;
precompute();
A.resize(N);
for (long long &a : A) cin >> a;
int overall_SG = 0;
for (long long &a : A) overall_SG ^= get_SG(0, a);
int total = 0;
for (long long &a : A) {
overall_SG ^= get_SG(0, a);
total += (overall_SG ^ get_SG(0, max(a - X, 0LL))) == 0;
total += (overall_SG ^ get_SG(1, max(a - Y, 0LL))) == 0;
total += (overall_SG ^ get_SG(2, max(a - Z, 0LL))) == 0;
overall_SG ^= get_SG(0, a);
}
cout << total << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int tests;
cin >> tests;
while (tests-- > 0) run_case();
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin>>t;
while(t--){
int n;
cin>>n;
vector<int> a(n,0);
for(auto &i: a) cin>>i;
int sum = accumulate(a.begin(),a.end(),0LL);
if(sum%n != 0) cout<<-1<<endl;
else{
int cnt = 0;
for(int i=0;i<n;i++) if(a[i] > sum/n) cnt++;
cout<<cnt<<endl;
}
}
} | 8 | CPP |
z=input
for i in range(int(z())):
a,b,c=sorted(list(map(int,z().split())))
t=a+b+c
print(min(a+b,t//2))
| 7 | PYTHON3 |
n = int(input())
a = 'that I love '
b = 'that I hate '
out = 'I hate '
if n % 2 ==1:
for x in range(int((n-1)/2)):
out += a
out += b
else:
for x in range(int(n/2-1)):
out += a
out += b
out += a
out += 'it'
print(out)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int prime[10000011 / 10], lp = 0, phi[10000011], small[10000011],
sum[2][10000011], sonofbitch[2][10000011];
bool notprime[10000011];
void pre(int n) {
phi[1] = 1;
sum[0][1] = sum[1][1] = 0;
for (int i = 2; i <= n; i++) {
sum[0][i] = sum[0][i - 1] + (!notprime[i] && i * 2 <= n);
sum[1][i] = sum[1][i - 1] + (!notprime[i]);
if (!notprime[i]) {
prime[++lp] = i;
phi[i] = i - 1;
sonofbitch[0][i] = (i * 2 <= n);
sonofbitch[1][i] = 1;
small[i] = i;
}
for (int j = 1; j <= lp && 1ll * i * prime[j] <= n; j++) {
notprime[i * prime[j]] = 1;
small[i * prime[j]] = prime[j];
if (i % prime[j]) {
phi[i * prime[j]] = phi[i] * (prime[j] - 1);
sonofbitch[0][i * prime[j]] = sonofbitch[0][i] + (prime[j] * 2 <= n);
sonofbitch[1][i * prime[j]] = sonofbitch[1][i] + 1;
} else {
phi[i * prime[j]] = phi[i] * prime[j];
sonofbitch[0][i * prime[j]] = sonofbitch[0][i];
sonofbitch[1][i * prime[j]] = sonofbitch[1][i];
break;
}
}
}
}
int main() {
scanf("%d", &n);
pre(n);
long long tot1 = 0, tot2 = 0, tot3 = 0, m = n - (sum[1][n] - sum[0][n]) - 1,
tot = m * 1ll * (m - 1) / 2;
for (int i = 2; i <= n; i++) tot1 += i - 1 - phi[i];
for (int i = 2; i <= n; i++)
if (notprime[i])
tot2 += phi[i] - sum[1][i] + sonofbitch[1][i] - 1 + sum[0][n / small[i]] -
sonofbitch[0][i];
else if (i * 2 <= n)
tot2 += sum[0][min(i - 1, n / i)];
tot3 = tot - tot1 - tot2;
printf("%lld\n", tot1 + tot2 * 2 + tot3 * 3);
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int step[2005];
bool vis[2005];
queue<int> que;
set<int> vec;
int solve() {
while (que.size()) {
int val = que.front();
que.pop();
if (val == 0) return step[val + 1000];
for (set<int>::iterator it = vec.begin(); it != vec.end(); it++) {
int o = *it;
int fval = val + o;
if (fval >= -1000 && fval <= 1000) {
if (step[val + 1000] + 1 < step[fval + 1000] ||
step[fval + 1000] == 0) {
que.push(fval);
step[fval + 1000] = step[val + 1000] + 1;
}
}
}
}
return -1;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < k; i++) {
int x;
scanf("%d", &x);
x -= n;
vec.insert(x);
if (!vis[x + 1000]) {
que.push(x);
vis[x + 1000] = 1;
}
step[x + 1000] = 1;
}
printf("%d\n", solve());
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
pair<int, int> arr[3001];
long long dp[3001][3001];
long long getAns(int pos, int pre) {
if (pos > n) return 0;
if (dp[pos][pre] != 1000000000000000) return dp[pos][pre];
long long x = arr[pos].second + getAns(pos + 1, pos);
long long y = abs(arr[pre].first - arr[pos].first) + getAns(pos + 1, pre);
return dp[pos][pre] = min(x, y);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> arr[i].first >> arr[i].second;
}
sort(arr + 1, arr + n + 1);
for (int i = 0; i <= 3000; i++) {
for (int j = 0; j <= 3000; j++) {
dp[i][j] = 1000000000000000;
}
}
long long ans = getAns(2, 1) + arr[1].second;
cout << ans;
}
| 11 | CPP |
import sys
import math
import bisect
def solve(n):
A = []
for i in range(2 * n + 1):
A.append([-1] * (2 * n + 1))
m = len(A)
for i in range(m):
for j in range(m):
delta = abs(i - n) + abs(j - n)
if delta <= n:
A[i][j] = n - delta
'''
for i in range(len(A)):
print('A[%d]: %s' % (i, str(A[i])))
'''
B = []
for i in range(m):
row = []
for j in range(m):
if A[i][j] < 0:
row.append(' ')
else:
row.append(chr(ord('0') + A[i][j]))
B.append(row)
'''
for i in range(m):
print('B[%d]: %s' % (i, str(B[i])))
'''
for i in range(m):
while len(B[i]) > 0 and B[i][-1] == ' ':
B[i].pop();
#print('B[%d] len: %d' % (i, len(B[i])))
'''
for i in range(m):
print('B[%d]: %s' % (i, str(B[i])))
'''
ans = []
for i in range(m):
ans.append(' '.join(B[i]))
return ans
def main():
n = int(input())
ans = solve(n)
for s in ans:
print(s)
if __name__ == "__main__":
main()
| 8 | PYTHON3 |
def main():
n = int(input())
day_one = 0
s = input().split()
for x in s:
day_one += int(x)
day_two = 0
s = input().split()
for y in s:
day_two += int(y)
if day_one < day_two:
print("No")
else:
print("Yes")
main()
| 7 | PYTHON3 |
x=list(input().split())
k,m,n = map(int, x )
x =(k*n*(n+1))/2 - m
if (x>0):
print("%d" %x)
else:
print(0) | 7 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimize "-O3"
#pragma GCC target("avx,avx2,fma")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
using namespace std;
int n;
int q;
vector<long long int> v;
vector<long long int> w;
long long int bit[300002];
void add(int i, long long int x) {
i++;
while (i < 300002) {
bit[i] += x;
i += i & -i;
}
}
long long int sum(int i) {
i++;
long long int r = 0;
while (i) {
r += bit[i];
i -= i & -i;
}
return r;
}
long long int rng(int l, int r) {
long long int sm = sum(r);
if (l) sm -= sum(l - 1);
return sm;
}
long long int pf[300002];
void pf_add(int i, long long int x) {
x %= 1000000007;
x += 1000000007;
x %= 1000000007;
i++;
while (i < 300002) {
pf[i] += x;
if (pf[i] >= 1000000007) pf[i] %= 1000000007;
i += i & -i;
}
}
long long int pf_sum(int i) {
i++;
long long int r = 0;
while (i) {
r += pf[i];
if (r >= 1000000007) r %= 1000000007;
i -= i & -i;
}
return r;
}
long long int sf[300002];
void sf_add(int i, long long int x) {
i++;
x %= 1000000007;
x += 1000000007;
x %= 1000000007;
while (i < 300002) {
sf[i] += x;
if (sf[i] >= 1000000007) sf[i] %= 1000000007;
i += i & -i;
}
}
long long int sf_sum(int i) {
i++;
long long int r = 0;
while (i) {
r += sf[i];
if (r >= 1000000007) r %= 1000000007;
i -= i & -i;
}
return r;
}
int main() {
cin >> n >> q;
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
v.push_back(a);
}
int rngg = n;
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
w.push_back(a);
add(i, a);
pf_add(i, -(v[i] + rngg) * a);
sf_add(i, (v[i] - i) * a);
rngg--;
}
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
x *= -1;
x--;
add(x, -w[x]);
pf_add(x, (v[x] + (n - x)) * w[x]);
sf_add(x, -(v[x] - x) * w[x]);
w[x] = y;
add(x, w[x]);
pf_add(x, -(v[x] + (n - x)) * w[x]);
sf_add(x, (v[x] - x) * w[x]);
} else {
int l = x;
int r = y;
l--;
r--;
int mint = l;
int maxt = r;
long long int ALL = (rng(l, r) + 1LL) / 2LL;
while (mint + 1 < maxt) {
int mid = (mint + maxt) / 2;
if (rng(l, mid) >= ALL) {
maxt = mid;
} else {
mint = mid;
}
}
if (rng(l, mint) >= ALL) {
maxt = mint;
} else {
mint = maxt;
}
long long int act = n - mint;
long long int cs1 =
((((sum(mint) - sum(l - 1)) % 1000000007 + 1000000007) % 1000000007) *
(v[mint] + act) % 1000000007) +
((((pf_sum(mint) - pf_sum(l - 1)) % 1000000007) + 1000000007) %
1000000007);
act = mint;
cs1 %= 1000000007;
long long int cs2 =
((sf_sum(r) - sf_sum(mint - 1) % 1000000007 + 1000000007) %
1000000007) -
((((sum(r) - sum(mint - 1)) % 1000000007 + 1000000007) % 1000000007) *
(v[mint] - act) % 1000000007);
cs2 %= 1000000007;
cs1 += cs2;
cs1 %= 1000000007;
cs1 += 1000000007;
cs1 %= 1000000007;
printf("%lld\n", cs1);
}
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, a[97];
int main() {
int i;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
}
if (a[n - 1] == 0)
cout << "UP";
else if (a[n - 1] == 15)
cout << "DOWN";
else if (n == 1)
cout << "-1";
else if (a[n - 1] - a[n - 2] == 1)
cout << "UP";
else
cout << "DOWN";
return 0;
}
| 7 | CPP |
from collections import deque
t=int(input())
while t > 0:
n=int(input())
t-=1
stack=deque()
count=0
s=input()
for x in s:
if x =="(":
stack.append(x)
elif x==")" and stack:
if stack[-1]=="(":
stack.pop()
else:
count+=1
else:
count+=1
print(count) | 9 | PYTHON3 |
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<sstream>
#include<utility>
#include<map>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
typedef long long ll;
//typedef pair<int,int>P;
int N,M,P,r1,r2;
vector<int>B,a1,a2;
int ch(vector<int> o,vector<int> s)
{
int c=0,r=0;
for(int i=0;i<o.size();i++)
if(o[i]!=s[i])c++;
if(c%2)return 1000000000;
for(int i=0;i<o.size();i++)
{
if(o[i]!=s[i])
{
for(int j=i+1;j<o.size();j++)
{
if(o[j]!=s[j]&&o[i]!=o[j])
{
r+=j-i;
swap(o[i],o[j]);
break;
}
}
}
if(o[i]!=s[i])return 1000000000;
}
return r;
}
int main()
{
scanf("%d%d",&N,&M);
for(int i=0;i<N;i++)
{
int t;
scanf("%d",&t);
B.push_back(t);
}
for(int i=0;i<M;i++)
{
scanf("%d",&P);
for(int j=0;j<P;j++)
{
a1.push_back(i%2);
a2.push_back((i+1)%2);
}
}
printf("%d\n",min(ch(B,a1),ch(B,a2)));
} | 0 | CPP |
n = int(input())
arr = list(map(int,input().split()))
h = 1
if arr[n-1]-1<500000:
print(arr[n-1]-1)
elif arr[0]>500000:
print(1000000-arr[0])
else:
for i in range(n):
if arr[i]>500000:
h = i
break
if arr[h-1]>1000000-arr[h]:
print(arr[h-1]-1)
else:
print(1000000-arr[h])
| 8 | PYTHON3 |
#include <bits/stdc++.h>
void read(int &x) {
int t = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while ('0' <= c && c <= '9') {
t = t * 10 + c - '0';
c = getchar();
}
x = t;
return;
}
int cnt[2][2], n, m, x;
int main() {
read(n);
read(m);
for (int i = 1; i <= n; i++) read(x), cnt[0][x & 1]++;
for (int i = 1; i <= m; i++) read(x), cnt[1][x & 1]++;
printf("%d\n",
std::min(cnt[0][0], cnt[1][1]) + std::min(cnt[0][1], cnt[1][0]));
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 150000 + 1;
struct data {
double sum, pref, suff, ans;
};
int x[MAXN];
double w[MAXN];
data t[4 * MAXN];
data MAKE(double val) {
data res;
res.sum = val;
res.pref = res.suff = res.ans = max(0.0, val);
return res;
}
data COMBINE(data a, data b) {
data res;
res.sum = a.sum + b.sum;
res.pref = max(a.pref, a.sum + b.pref);
res.suff = max(b.suff, b.sum + a.suff);
res.ans = max(max(a.ans, b.ans), a.suff + b.pref);
return res;
}
void BUILD(int v, int tl, int tr) {
if (tl == tr)
t[v] = MAKE(w[tl]);
else {
int tm = (tl + tr) >> 1;
BUILD(v << 1, tl, tm);
BUILD((v << 1) + 1, tm + 1, tr);
t[v] = COMBINE(t[v << 1], t[(v << 1) + 1]);
}
}
data QUERY(int v, int tl, int tr, int l, int r) {
if (l == tl && r == tr) return t[v];
int tm = (tl + tr) / 2;
if (r <= tm) return QUERY(v << 1, tl, tm, l, r);
if (l > tm) return QUERY((v << 1) + 1, tm + 1, tr, l, r);
return COMBINE(QUERY(v << 1, tl, tm, l, tm),
QUERY((v << 1) + 1, tm + 1, tr, tm + 1, r));
}
int main() {
int n, m, c;
scanf("%d%d%d", &n, &m, &c);
for (int i = 0; i < n; ++i) scanf("%d", &x[i]);
for (int i = 0; i + 1 < n; ++i) {
double v;
scanf("%lf", &v);
w[i] = (x[i + 1] - x[i]) / 2.0 - c * v / 100;
}
BUILD(1, 0, n - 2);
double ans = 0;
for (int i = 0; i < m; ++i) {
int l, r;
scanf("%d%d", &l, &r);
ans += QUERY(1, 0, n - 2, l - 1, r - 2).ans;
}
printf("%.10lf", ans);
return 0;
}
| 11 | CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.