solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
from collections import defaultdict
n = int(input())
s = input()
lst = [[] for i in range(26)]
for i, val in enumerate(s):
lst[ord(val)-97].append(i)
for _ in range(int(input())):
t = input()
lid = []
dic = defaultdict(lambda: 0)
for i in t:
dic[i] += 1
x = lst[ord(i)-97][dic[i] - 1]
lid.append(x)
print(max(lid) + 1)
| 8 | PYTHON3 |
n=int(input())
pr=list(map(int,input().split()))
ans=0
for i in range(1,n-1):
if pr[i-1]==1 and pr[i+1]==1 and pr[i]==0:
ans+=1
pr[i+1]=0
print(ans) | 8 | PYTHON3 |
exec(int(input())*"a,b=map(int,input().split());print(a*len(f'{b+1}')-a);") | 8 | PYTHON3 |
l = list(map(int, input().split()))
if l[0] == l[1] == l[2]:
print(l[3] - l[1],l[3] - l[1] ,l[3] - l[1] )
else:
a = max(l)
l.remove(a)
print(a - l[0], a - l[1], a - l[2])
| 7 | PYTHON3 |
S = input()
print(len([True for i in range(len(S)//2) if S[i] != S[-1-i]]))
| 0 | PYTHON3 |
k,a,b=map(int,input().split());ans=0
#if both win sets (k,b%k),(a%k,k)
if a>=k and b>=k:print(a//k+b//k)
elif (a!=0 and a%k==0) or (b!=0 and b%k==0):print(a//k+b//k)
else:print(-1)
| 9 | PYTHON3 |
from math import log2
for _ in range(int(input())):
n,k = map(int,input().split())
l = list(map(int,input().split()))
s={}
for i in range(len(l)):
if l[i]/k == int(l[i]/k):
pass
elif -1*(l[i]-(((l[i]//k)+1)*k)) in s:
s[-1*(l[i]-(((l[i]//k)+1)*k))].append(l[i])
else:
s[-1*(l[i]-(((l[i]//k)+1)*k))] = []
s[-1*(l[i]-(((l[i]//k)+1)*k))].append(l[i])
# print(s)
ll,kk = 0,0
if len(s)==0:
print(0)
else:
for key,val in sorted(s.items()):
if len(val)>ll:
ll=len(val)
kk = key
elif len(val)==ll and key>kk:
kk=key
print(k*(ll-1)+kk+1)
| 10 | PYTHON3 |
#http://codeforces.com/problemset/problem/870/A
#not done
def smallest(array):
return min(array)
def getPretty1(array1,array2):
val1 = smallest(array1)
val2 = None
for item in array2:
if item == val1:
val2 = item
break
if val2 == None:
val2 = smallest(array2)
if val1 == val2:
return val1
elif val1 > val2:
return val1 + 10*val2
return val2 + 10*val1
def getPretty(array1,array2):
# Getting first pass
min1 = min(array1)
RA = None
for item in array2:
if item == min1:
RA = min1
if RA == None:
min2 = min(array2)
if min1 < min2:
RA = min1*10 + min2
else:
RA = min1 + min2*10
min1 = min(array2)
for item in array1:
if item == min1 and RA > item:
RA = item
min2 = min(array1)
if RA > min1*10 + min2:
RA = min1*10 + min2
elif RA > min1 + min2*10:
RA = min1 + min2*10
duplicates = []
for i in range(len(array1)):
for j in range(len(array2)):
if array1[i] == array2[j]:
duplicates.append(array1[i])
if duplicates != []:
if RA > min(duplicates):
return min(duplicates)
return RA
while True:
try:
junk = input()
arr1 = input()
arr2 = input()
arr1 = arr1.split(" ")
arr2 = arr2.split(" ")
for i in range(len(arr1)):
arr1[i] = int(arr1[i])
for i in range(len(arr2)):
arr2[i] = int(arr2[i])
a = (getPretty(arr1,arr2))
print(a)
except EOFError:
break
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, s;
cin >> a >> b >> s;
if (a < 0) a *= -1;
if (b < 0) b *= -1;
int n = a + b;
if (n > s)
cout << "No";
else if (n == s)
cout << "Yes";
else {
if ((s - n) % 2 == 0)
cout << "Yes";
else
cout << "No";
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long double PI = 2 * acos(0.0);
void yes() { cout << "YES\n"; }
void no() {
cout << "NO\n";
cout << -1 << "\n";
exit(0);
}
long long m(long long a) { return (a + 1000000007) % 1000000007; }
long long cel(long long x1, long long y1) {
;
if ((x1 % y1) == 0) return x1 / y1;
return x1 / y1 + 1;
}
long long power(long long a, long long b) {
if (b == 0) return 1;
long long d = power(a, b / 2);
d = m(d * d);
if (b & 1) d = m(d * a);
return d;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
stack<long long> st;
long long ans = 0;
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
while (!st.empty() && st.top() <= a) {
ans = max(ans, a ^ st.top());
st.pop();
}
if (!st.empty()) {
ans = max(ans, a ^ st.top());
}
st.push(a);
}
cout << ans;
}
| 10 | CPP |
n,d = map(int,input().split(' '))
x = input().split(' ')
x = [int(i) for i in x]
x = sorted(x)
if n <= 1:
print(0)
else:
m = 0
for i in range(0,n):
for j in range(i,n):
if x[j]-x[i]<= d:
m = max(m,j-i+1)
print(n - m) | 7 | PYTHON3 |
from sys import stdin,stdout
for _ in range(int(stdin.readline())):
# n=int(stdin.readline())
a,b,c=sorted(map(int,stdin.readline().split()))
dist=abs(a-b)+abs(a-c)+abs(b-c)-4
if dist<0:dist=0
print(dist) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int MOD = 1e9 + 7;
int fenwick[N], ct;
void upd(int node, int val) {
for (int i = node; i <= ct; i += (i & -i)) fenwick[i] += val;
}
int query(int node) {
long long int sum = 0;
for (int i = node; i >= 1; i -= (i & -i)) sum += fenwick[i];
return sum;
}
void solve() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
vector<pair<int, int> > comp;
for (int i = 0; i < a.size(); ++i) comp.push_back({a[i], i});
sort(comp.begin(), comp.end());
ct = 1;
a[comp[0].second] = ct;
for (int i = 1; i < comp.size(); ++i) {
if (comp[i].first != comp[i - 1].first) ++ct;
a[comp[i].second] = ct;
}
for (int i = 0; i <= ct; ++i) fenwick[i] = 0;
long long ans = 0;
map<int, int> mp;
mp[a[0]]++;
upd(a[0], 1);
for (int i = 1; i < n; ++i) {
int x = query(a[i] - 1);
int xx = i - x - mp[a[i]];
ans += min(x, xx);
upd(a[i], 1);
mp[a[i]]++;
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
cin >> t;
while (t--) solve();
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int Maxl = 26;
const int Maxn = 2005;
struct trie {
trie *ch[Maxl];
int cnt, en;
trie() {
for (int i = 0; i < Maxl; i++) ch[i] = nullptr;
cnt = en = 0;
}
};
int n, k;
string S[Maxn];
trie *tr;
void Insert(trie *tr, const string &s, int lvl) {
tr->cnt++;
if (lvl >= s.length()) {
tr->en++;
return;
}
int ind = s[lvl] - 'a';
if (!tr->ch[ind]) tr->ch[ind] = new trie();
Insert(tr->ch[ind], s, lvl + 1);
}
vector<int> Solve(trie *tr, int len) {
vector<int> res(tr->cnt + 1, 0);
int sz = tr->en;
for (int i = 1; i <= sz; i++) res[i] = i * (i - 1) / 2ll * len;
for (int i = 0; i < Maxl; i++)
if (tr->ch[i]) {
vector<int> dpu = Solve(tr->ch[i], len + 1);
int add = tr->ch[i]->cnt;
for (int j = sz; j >= 0; j--)
for (int k = 1; k <= add; k++)
res[j + k] = max(res[j + k], res[j] + dpu[k] + j * k * len);
sz += add;
}
return res;
}
int main() {
std::ios_base::sync_with_stdio(0);
tr = new trie();
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> S[i];
Insert(tr, S[i], 0);
}
cout << Solve(tr, 0)[k] << endl;
return 0;
}
| 12 | CPP |
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0; i<n; i++)
using namespace std;
typedef pair<int,int> P;
vector<P> v[1000];
int main(){
int n,m,a;
while(cin >> n >> m >> a,n){
a--;
rep(i,1000) v[i].clear();
int h,p,q;
rep(i,m){
cin >> h >> p >> q;
v[h-1].push_back(P(p-1,q-1));
}
rep(k,1000){
int i=999-k;
rep(j,v[i].size()){
if(v[i][j].first==a) a=v[i][j].second;
else if(v[i][j].second==a) a=v[i][j].first;
}
}
cout << a+1 << endl;
}
return 0;
}
| 0 | CPP |
n=int(input())
ans=0
while n:
e=input()
a=[int(x) for x in e.split()]
if a.count(1)>=2:
ans+=1
n-=1
print(ans)
| 7 | PYTHON3 |
num = int(input())
wins = input()
if wins.count('D') > wins.count('A'):
print("Danik")
elif wins.count('D') < wins.count('A'):
print("Anton")
else:
print("Friendship")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T sqr(T x) {
return x * x;
}
const double EPS = 1e-6;
const int INF = 0x3fffffff;
const long long LINF = INF * 1ll * INF;
const double PI = acos(-1.0);
using namespace std;
int nd[1000006 << 2];
int val[1000006];
class SegTree {
public:
SegTree(int n) { build(1, n, 1); }
void build(int l, int r, int rt) {
if (l == r)
nd[rt] = 1;
else {
int mid = (l + r) >> 1;
build(l, mid, rt << 1);
build(mid + 1, r, rt << 1 | 1);
nd[rt] = r - l + 1;
}
}
void update(int l, int r, int rt, int tot) {
if (l == r) {
nd[rt] = 0;
} else {
int mid = (l + r) >> 1;
if (nd[rt << 1] >= tot)
update(l, mid, rt << 1, tot);
else
update(mid + 1, r, rt << 1 | 1, tot - nd[rt << 1]);
nd[rt] = nd[rt << 1] + nd[rt << 1 | 1];
}
}
void solve(int l, int r, int rt) {
if (l == r) {
if (nd[rt]) cout << val[l];
} else {
int mid = (l + r) >> 1;
solve(l, mid, rt << 1);
solve(mid + 1, r, rt << 1 | 1);
}
}
};
int a[1000006];
int q[1000006];
int main(void) {
int n, m;
cin >> n >> m;
int cnt = 0;
for (int i = 0; i < m; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
cin >> q[i];
if (q[i] != -1) val[++cnt] = q[i];
}
if (cnt == 0) {
cout << "Poor stack!" << endl;
return 0;
}
SegTree seg(cnt);
int len = 0;
for (int i = 0; i < n; i++) {
if (q[i] == -1) {
int pos = upper_bound(a, a + m, len) - a;
int tmp = 0;
for (int j = 0; j < pos; j++) {
seg.update(1, cnt, 1, a[j] - tmp);
len--;
tmp++;
}
} else
len++;
}
if (len == 0)
cout << "Poor stack!";
else
seg.solve(1, cnt, 1);
cout << endl;
}
| 10 | CPP |
k=int(input())
string = 'ACL'
print(string*k) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n, m;
cin >> n >> m;
string x, y;
cin >> x >> y;
long long g = gcd(x.length(), y.length()),
l = 1ll * x.length() * y.length() / g, dist = l, c[g][26];
for (int i = 0; i < g; i++)
for (int j = 0; j < 26; j++) c[i][j] = 0;
for (int i = 0; i < x.length(); i++) c[i % g][x[i] - 'a']++;
for (int i = 0; i < y.length(); i++) dist -= c[i % g][y[i] - 'a'];
cout << dist * (x.length() * n / l) << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c, d; cin >> a >> b >> c >> d;
cout << max({b * d, b * c, a * d, a * c}) << endl;
}
| 0 | CPP |
#include "bits/stdc++.h"
using namespace std;
struct bus {
int from;
int to;
int depart;
int arrive;
};
bool operator<(const bus&l, const bus&r) {
return l.depart < r.depart;
}
struct edge {
int from;
int to;
int cost;
};
struct aa {
int now;
int time;
};
class Compare {
public:
bool operator()(const aa&l, const aa&r) {
return l.time> r.time;
}
}; //aa?????????????????ยถ
int N, M, S, G;
int dfs(const int start,const int goal, const vector<vector<edge>>&edges,vector<int>&memo,const vector<int>&node_id) {
int ans = 1e7;
priority_queue<aa,vector<aa>,Compare>que;
que.push(aa{ start,0 });
while (!que.empty()) {
aa atop(que.top());
que.pop();
for (auto e : edges[atop.now]) {
if (e.to==goal) {
return atop.time;
}
if (memo[e.to] > atop.time + e.cost) {
memo[e.to] = atop.time + e.cost;
que.push(aa{ e.to,atop.time+e.cost });
}
}
}
return -1;
}
int main() {cin >> N >> M >> S >> G;
S--; G--;
vector<vector<bus>>buss(N);
for (int i = 0; i < M; ++i) {
int u, v, t, c; cin >> u >> v >> t >>c;
buss[u-1].push_back(bus{ u - 1,v - 1,t,t+c });
}
for (int i = 0; i < N; ++i) {
sort(buss[i].begin(), buss[i].end());
}
const int start = 0;
vector<int>node_id(N);
int num = 1;
for (int i = 0; i < N; ++i) {
node_id[i] = num;
num += buss[i].size();
}
const int goal = num;
vector<vector<edge>>edges(num+1);
vector<int>memo(num, 1e8);
edges[start].push_back(edge{ start,node_id[S],buss[S][0].depart });
for (int from_stop = 0; from_stop < N; ++from_stop) {
for (int i = 0; i < buss[from_stop].size(); ++i) {
bus b(buss[from_stop][i]);
const int from_id = node_id[from_stop] +i;
if (i != buss[from_stop].size() - 1) {
edges[from_id].push_back(edge{ from_id,from_id + 1,buss[from_stop][i + 1].depart - buss[from_stop][i].depart });
}
auto it = lower_bound(buss[b.to].begin(), buss[b.to].end(), bus{ -1,-1,b.arrive,-1 });
if (b.to == G) {
edges[from_id].push_back(edge{ from_id,goal,0 });
}
else {
if (it != buss[b.to].end()) {
const int to_id = node_id[b.to] + (it - buss[b.to].begin());
const int acost = it->depart-b.arrive;
edges[from_id].push_back(edge{ from_id, to_id, acost });
}
}
}
}
int ans=dfs(0,goal, edges, memo,node_id);
cout << ans << endl;
return 0;
} | 0 | CPP |
import sys
#input=sys.stdin.readline
from collections import defaultdict as dc
from collections import Counter
from bisect import bisect_right, bisect_left
import math
from heapq import heapify, heappop, heappush
n=int(input())
s=input()
x=dc(list)
for i in range(n):
x[s[i]].append(i)
#print(x)
for _ in range(int(input())):
m=-1
t=input()
y=dc(int)
for i in t:
y[i]+=1
#print(t,y)
for i in y.keys():
#print(i,y[i],x[i][y[i]-1])
m=max(m,x[i][y[i]-1])
print(m+1)
| 8 | PYTHON3 |
import math
t=eval(input())
while(t!=0):
n=eval(input())
if(n%4==0):
print("YES")
else:
print("NO")
t=t-1 | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int sgn(long long x) {
if (x > 0) return 1;
if (x < 0) return -1;
return 0;
}
int main() {
long long x_1, x_2, y_1, y_2;
scanf("%I64d%I64d%I64d%I64d", &x_1, &y_1, &x_2, &y_2);
int n;
scanf("%d", &n);
long long a, b, c;
int ans = 0;
for (int i = 1; i <= n; i++) {
scanf("%I64d%I64d%I64d", &a, &b, &c);
if (sgn(a * x_1 + b * y_1 + c) * sgn(a * x_2 + b * y_2 + c) < 0) ans++;
}
printf("%d\n", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool cmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool cmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
int read() {
int x = 0, f = 1;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
return x * f;
}
long long n;
int q;
long long f(long long n, long long x) {
if (x & 1) return x + 1 >> 1;
long long cur = n + 1 >> 1;
if (n & 1)
if (x == 2) return cur + f(n >> 1, n >> 1);
return cur + ((n & 1) ? f(n >> 1, (x >> 1) - 1) : f(n >> 1, x >> 1));
}
int main() {
scanf("%lld%d\n", &n, &q);
while (q--) {
long long x;
scanf("%lld", &x);
printf("%lld\n", f(n, x));
}
return 0;
}
| 8 | CPP |
a=int(input())
for i in range(a):
x,y,n=map(int,input().split())
n1=n//x*x
if n1+y<=n:
print(n1+y)
else:
print((n//x-1)*x+y)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int ind[60 + 5];
int a[60 + 5];
struct DSU {
int fa[60 + 5];
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
void merge(int x, int y) { fa[find(x)] = find(y); }
void ini(int n) {
for (int i = 1; i <= n; i++) fa[i] = i;
}
} D;
vector<int> B[60 + 5];
int sta[60 + 5], to[(1 << 15) + 5], dp[(1 << 15) + 5][60 + 5];
int C[60 + 5][60 + 5];
void ini(int n) {
C[0][0] = 1;
for (int i = 1; i <= n; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % 1000000007;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
D.ini(n);
ini(n);
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
if (a[j] % a[i] == 0) {
D.merge(i, j);
ind[j]++;
}
}
}
for (int i = 1; i <= n; i++) B[D.find(i)].push_back(i);
int ans = 1;
int len = 0;
for (int r = 1; r <= n; r++) {
if ((int)B[r].size() <= 1) continue;
vector<int> S;
for (int x : B[r])
if (!ind[x]) S.push_back(x);
int cnts = S.size(), cntt = 0;
memset(to, 0, sizeof(to));
memset(dp, 0, sizeof(dp));
for (int x : B[r]) {
if (ind[x]) {
cntt++;
for (int j = 0; j < cnts; j++)
if (a[x] % a[S[j]] == 0) sta[x] |= (1 << j);
to[sta[x]]++;
}
}
for (int i = 0; i < cnts; i++) {
for (int j = 0; j < (1 << cnts); j++) {
if (!(j & (1 << i))) to[j | (1 << i)] += to[j];
}
}
dp[0][0] = 1;
for (int i = 0; i < (1 << cnts); i++) {
for (int j = 0; j < cntt; j++) {
if (j < to[i])
dp[i][j + 1] =
(dp[i][j + 1] + 1ll * dp[i][j] * (to[i] - j) % 1000000007) %
1000000007;
for (int x : B[r]) {
if (ind[x] && ((sta[x] & i) != sta[x]) &&
((sta[x] & i) != 0 || i == 0))
dp[i | sta[x]][j + 1] =
(dp[i | sta[x]][j + 1] + dp[i][j]) % 1000000007;
}
}
}
ans = 1ll * ans * dp[(1 << cnts) - 1][cntt] % 1000000007 *
C[cntt + len - 1][cntt - 1] % 1000000007;
len += cntt - 1;
}
printf("%d\n", ans);
}
| 12 | CPP |
import sys
input=sys.stdin.readline
from collections import *
from math import *
from bisect import *
t=int(input())
ref={'1':'2','2':'3','3':'4','4':'5','5':'6','6':'7','7':'8','8':'9','9':'1'}
while(t):
t-=1
n=int(input())
a=list(map(int,input().split()))
ind=dict()
for i in range(n):
if(a[i] not in ind):
ind[a[i]]=[i+1]
else:
ind[a[i]].append(i+1)
s=0
for i in ind.keys():
cc=0
for k in range(len(ind[i])//2):
cc+=1
p1=ind[i][k]
p2=ind[i][-1-k]
for j in ind.keys():
ll=bisect_right(ind[j],p1)
rr=bisect_left(ind[j],p2)
s=max(2*cc+(rr-ll),s)
print(max(s,1))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const int inf = 2e9 + 1;
const int maxn = 1e4 + 5;
int a[maxn];
int c[maxn];
int cnt[maxn << 1];
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n;
scanf("%d", &n);
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
cnt[a[i]] += 1;
}
int k = 0;
while (true) {
int pos = 0;
while (pos < n - 1 && a[pos] <= a[pos + 1]) pos += 1;
if (pos + 1 == n) break;
pos = 0;
while (cnt[pos]) pos += 1;
if (pos >= n) {
for (int i = 0; i < n; ++i) {
if (a[i] != i) {
cnt[a[i]] -= 1, cnt[pos] += 1;
a[i] = pos, c[k++] = i;
break;
}
}
} else {
cnt[a[pos]] -= 1, cnt[pos] += 1;
a[pos] = pos, c[k++] = pos;
}
}
printf("%d\n", k);
if (k == 0) puts("");
for (int i = 0; i < k; ++i)
printf("%d%c", c[i] + 1, i + 1 == k ? '\n' : ' ');
}
return 0;
}
| 10 | CPP |
a,b,c=map(int,input().split())
if c-a-b<=0:print("No");exit()
print("Yes") if 4*a*b<(c-a-b)**2 else print("No")
| 0 | PYTHON3 |
#include <bits/stdc++.h>
int n;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
printf("%d ", n + 1 + i);
}
return 0;
}
| 8 | CPP |
# -*- coding: utf-8 -*-
"""
Created on Sun Sep 27 07:59:56 2020
@author: Dark Soul
"""
[n,m]=list(map(int,input().split()))
k=m/n
if k!=int(k):
print(-1)
else:
cnt=0
flag=0
while k:
if k%2==0:
k//=2
cnt+=1
elif k%3==0:
k//=3
cnt+=1
else:
if k==1:
break
flag=1
break
if flag:
print(-1)
else:
print(cnt) | 7 | PYTHON3 |
n,k = map(int,input().split())
a = list(map(int,input().split()))
c = 0
for i in a:
if i+k<=5:
c+=1
print(c//3) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 5;
const long long linf = 1e18 + 5;
const int N = 500 + 5;
const int mod = 1e9 + 7;
int n, k, power[N];
long long dp[2][N][N];
int main() {
ios ::sync_with_stdio(0);
cin >> n >> k;
power[0] = 1;
for (int i = 1; i <= n; i++) power[i] = power[i - 1] * 2 % mod;
for (int last = 0; last <= n; last++) dp[~n & 1][last][k] = 1;
for (int x = n; x >= 1; x--)
for (int last = x - 1; last >= 0; last--)
for (int cnt = x; cnt >= 0; cnt--) {
dp[x & 1][last][cnt] = 0;
dp[x & 1][last][cnt] += dp[~x & 1][x][cnt + 1] *
(power[x - last] + mod - 1) % mod * power[last];
dp[x & 1][last][cnt] += dp[~x & 1][last][cnt] * power[last];
dp[x & 1][last][cnt] %= mod;
}
cout << dp[1][0][0] << '\n';
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
map<string, string> mp;
mp["void"] = "void";
mp["errtype"] = "errtype";
while (n--) {
string op;
cin >> op;
if (op == "typedef") {
string a, b;
cin >> a >> b;
int amp = 0;
int ast = 0;
while (!a.empty() && a.back() == '*') a.pop_back(), ast++;
while (!a.empty() && a[0] == '&') a.erase(a.begin()), amp++;
if (!mp.count(a))
mp[b] = "errtype";
else {
string z = string(amp, '&') + mp[a] + string(ast, '*');
while (!z.empty() && z[0] == '&' && z.back() == '*')
z = z.substr(1, z.size() - 2);
if (z[0] == '&' && z.back() != '*')
mp[b] = "errtype";
else if (mp[a] == "errtype")
mp[b] = "errtype";
else
mp[b] = z;
}
} else {
string a;
cin >> a;
int amp = 0;
int ast = 0;
while (!a.empty() && a.back() == '*') a.pop_back(), ast++;
while (!a.empty() && a[0] == '&') a.erase(a.begin()), amp++;
string ats = "errtype";
if (mp.count(a)) {
string z = string(amp, '&') + mp[a] + string(ast, '*');
while (!z.empty() && z[0] == '&' && z.back() == '*')
z = z.substr(1, z.size() - 2);
ats = z;
if (z[0] == '&' && z.back() != '*') ats = "errtype";
if (mp[a] == "errtype") ats = "errtype";
}
cout << ats << "\n";
}
}
}
| 10 | CPP |
n = int(input())
a = [int(x) for x in input().split()]
res = {}
for i in range(n):
sm = 0
for j in range(i, n):
sm += a[j]
if sm in res:
res[sm].append((i, j))
else:
res[sm] = [(i, j)]
best = 0
bestI = -1
for key in res:
r = -1
cnt = 0
for (a,b) in sorted(res[key]):
if a > r:
cnt += 1
r = b
elif b < r:
r = b
if cnt > best:
best = cnt
bestI = key
x = []
r = -1
for (a, b) in sorted(res[bestI]):
if a > r:
x.append(str(a+1) + " " + str(b+1))
r = b
elif b < r:
r = b
x.pop()
x.append(str(a+1) + " " + str(b+1))
print(best)
print("\n".join(x))
| 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
void solve() {
long long int a, s;
cin >> a >> s;
vector<long long int> b;
while (s) {
long long int x = a % 10;
long long int y = s % 10;
if (y >= x) {
b.push_back(y - x);
} else {
s /= 10;
y += 10 * (s % 10);
if (y > x && y <= 18 && y >= 10) {
b.push_back(y - x);
} else {
cout << -1 << '\n';
return;
}
}
s /= 10;
a /= 10;
}
if (a) {
cout << -1 << '\n';
return;
}
while (b.back() == 0) b.pop_back();
reverse((b).begin(), (b).end());
for (long long int x : b) cout << x;
cout << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int T = 1;
cin >> T;
for (long long int i = 1; i <= T; i++) {
solve();
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
double pi = 2 * acos(0.0);
const int INF = 1e9 + 7;
long long gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long int a, long long int b) { return (a / gcd(a, b)) * b; }
long long int power(long long int x, long long int y) {
long long int res = 1;
x = x;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long int nCrModp(long long int n, long long int r, long long int p) {
if (r > n - r) r = n - r;
long long int C[r + 1];
memset(C, 0, sizeof(C));
C[0] = 1;
for (long long int i = 1; i <= n; i++) {
for (int j = min(i, r); j > 0; j--) C[j] = (C[j] + C[j - 1]) % p;
}
return C[r];
}
vector<bool> prime(10000009, true);
vector<int> listof;
void sieve() {
prime[1] = false;
for (int i = 2; i <= sqrt(1000009); i++) {
if (prime[i] == true) {
for (int j = i * i; j < 10000009; j += i) {
prime[j] = false;
}
}
}
for (int i = 2; i < 10000009; i++) {
if (prime[i] == true) {
listof.push_back(i);
}
}
}
void WetPitch() {
long long int n;
vector<long long int> v(100005);
cin >> n;
for (int i = 1; i < n + 1; i++) {
cin >> v[i];
}
long long int dp[100005];
long long int ans = 1;
for (int i = 1; i <= n; i++) {
dp[i] = 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 2 * i; j <= n; j += i) {
if (v[i] < v[j]) {
dp[j] = max(dp[j], dp[i] + 1);
}
ans = max(ans, dp[j]);
}
}
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int tst;
tst = 1;
cin >> tst;
int p = 1;
while (tst--) {
WetPitch();
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
int k;
cin >> k;
string s;
cin >> s;
map<int, long long> map1;
long long count1 = 0;
for (int i = 0; i < s.length(); i++) {
map1[s[i] - '0']++;
count1 += (s[i] - '0');
}
long long answer = 0;
for (map<int, long long>::iterator it1 = map1.begin(); it1 != map1.end();
it1++) {
if (count1 < k && it1->first != 9) {
long long toAdd = (9 - it1->first) * (it1->second);
if ((count1 + toAdd) >= k) {
long long rem = k - count1;
answer += (rem / (9 - it1->first)) + (rem % (9 - it1->first) != 0);
break;
} else {
answer += (it1->second);
count1 += toAdd;
}
}
}
cout << answer << endl;
return 0;
}
| 8 | CPP |
a,b = map(int, input().split())
print(a if not a - b else 1) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int arr1[5] = {0};
int arr2[5] = {0};
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int gr;
cin >> gr;
arr1[--gr]++;
}
for (int i = 0; i < n; i++) {
int gr;
cin >> gr;
arr2[--gr]++;
}
int ans = 0;
for (int i = 0; i < 5; i++) {
if (arr1[i] == arr2[i]) continue;
if (arr1[i] > arr2[i]) {
for (int j = 0; j < 5; j++) {
if (i == j) continue;
if (arr1[j] < arr2[j]) {
int diff = min(arr1[i] - arr2[i], arr2[j] - arr1[j]);
diff /= 2;
arr1[i] -= diff;
arr2[i] += diff;
arr1[j] += diff;
arr2[j] -= diff;
ans += diff;
}
}
}
if (arr1[i] < arr2[i]) {
for (int j = 0; j < 5; j++) {
if (i == j) continue;
if (arr1[j] > arr2[j]) {
int diff = min(arr2[i] - arr1[i], arr1[j] - arr2[j]);
diff /= 2;
arr1[i] += diff;
arr2[i] -= diff;
arr1[j] -= diff;
arr2[j] += diff;
ans += diff;
}
}
}
}
for (int i = 0; i < 5; i++) {
if (arr1[i] != arr2[i]) {
cout << -1 << endl;
return 0;
}
}
cout << ans << endl;
return 0;
}
| 7 | CPP |
n = int(input())
txt = input()
result = txt[n - 1]
for i in range(n -2,-1,-1):
thesi = int(len(result)/2)
result = result[:thesi] + txt[i] + result[thesi:]
print(result) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
void solve() {
int n;
cin >> n;
stack<int> mxped;
stack<int> ovt;
mxped.push(301);
ovt.push(true);
int cspe = 0;
int ans = 0;
while (n--) {
int x;
cin >> x;
switch (x) {
case 1:
cin >> cspe;
break;
case 2:
while (ovt.top() == false) ovt.pop(), ans++;
break;
case 3:
int v;
cin >> v;
mxped.push(v);
break;
case 4:
ovt.push(true);
break;
case 5:
mxped.push(310);
break;
case 6:
ovt.push(false);
break;
}
while (mxped.top() < cspe) mxped.pop(), ans++;
}
cout << ans << endl;
}
int main() {
int t = 1;
while (t--) {
solve();
}
}
| 10 | CPP |
#include <bits/stdc++.h>
long long k;
int _, n, a[200020];
int main() {
for (scanf("%d", &_); _--;) {
scanf("%d%lld", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", a + i);
for (int i = 0; i < (k & 1) + 2; i++)
for (int i = 0, d = *std::max_element(a, a + n); i < n; i++)
a[i] = d - a[i];
for (int i = 0 * puts(""); i < n; i++) printf("%d ", a[i]);
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const long long INFL = 1e18;
const double EP = 1e-9;
const double PI = 3.141592653589793284626433832795;
const int MP = 1e9 + 7;
const int MAXN = 5e4;
const int MAXM = 5e3;
const int MAXA = 1e6;
const int LOGA = 19;
int n, m;
int a[MAXN];
pair<int, int> q[MAXM];
int f[MAXA + 1];
int d[MAXN];
int ans[MAXM];
void read() {
cin >> n >> m;
for (int i = 0; i < n; ++i) scanf("%d", a + i);
for (int i = 0; i < m; ++i) {
scanf("%d%d", &q[i].first, &q[i].second);
--q[i].first;
--q[i].second;
}
}
void solve() {
f[0] = 0;
for (int i = 1; i <= MAXA; ++i) f[i] = f[i - 1] ^ i;
for (int i = 0; i < n; ++i) {
d[i] = a[i];
for (int j = i + 1; j < n; ++j) {
d[j] = max(d[j - 1], f[a[i]] ^ f[a[j]] ^ min(a[i], a[j]));
}
for (int j = 0; j < m; ++j) {
if (q[j].first <= i && i <= q[j].second)
ans[j] = max(ans[j], d[q[j].second]);
}
}
}
void print() {
for (int i = 0; i < m; ++i) printf("%d\n", ans[i]);
}
int main() {
read();
solve();
print();
}
| 12 | CPP |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
struct fast_ios {
fast_ios() {
cin.tie(nullptr), ios::sync_with_stdio(false),
cout << fixed << setprecision(20);
};
} fast_ios_;
template <class T>
auto add = [](T a, T b) -> T { return a + b; };
template <class T>
auto f_max = [](T a, T b) -> T { return max(a, b); };
template <class T>
auto f_min = [](T a, T b) -> T { return min(a, b); };
template <class T>
using V = vector<T>;
using Vl = V<long long int>;
using VVl = V<Vl>;
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (int i = 0; i < (int)v.size(); i++)
os << v[i] << (i + 1 != v.size() ? " " : "");
return os;
}
template <typename T>
istream& operator>>(istream& is, vector<T>& v) {
for (T& in : v) is >> in;
return is;
}
template <class T>
bool chmax(T& a, const T& b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T& a, const T& b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class T>
T div_floor(T a, T b) {
if (b < 0) a *= -1, b *= -1;
return a >= 0 ? a / b : (a + 1) / b - 1;
}
template <class T>
T div_ceil(T a, T b) {
if (b < 0) a *= -1, b *= -1;
return a > 0 ? (a - 1) / b + 1 : a / b;
}
long long int gcd(long long int a, long long int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long int digit(long long int a) { return (long long int)log10(a); }
long long int e_dist(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return abs(a.first - b.first) * abs(a.first - b.first) +
abs(a.second - b.second) * abs(a.second - b.second);
}
long long int m_dist(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return abs(a.first - b.first) + abs(a.second - b.second);
}
bool check_overflow(long long int a, long long int b, long long int limit) {
if (b == 0) return false;
return a > limit / b;
}
void Worshall_Floyd(VVl& g) {
for (long long int k = (0), k_end_ = (((long long int)(g).size()));
k < k_end_; ++k)
for (long long int i = (0), i_end_ = (((long long int)(g).size()));
i < i_end_; ++i)
for (long long int j = (0), j_end_ = (((long long int)(g).size()));
j < j_end_; ++j)
chmin(g[i][j], g[i][k] + g[k][j]);
}
const long long int MOD1000000007 = 1000000007, MOD998244353 = 998244353,
INF = 1e18;
long long int dx[8] = {1, 0, -1, 0, 1, -1, 1, -1},
dy[8] = {0, 1, 0, -1, -1, -1, 1, 1};
bool YN(bool flag) {
cout << (flag ? "YES" : "NO") << '\n';
return flag;
}
bool yn(bool flag) {
cout << (flag ? "Yes" : "No") << '\n';
return flag;
}
struct Edge {
long long int from, to;
long long int cost;
Edge() {}
Edge(long long int u, long long int v, long long int c) {
cost = c;
from = u;
to = v;
}
bool operator<(const Edge& e) const { return cost < e.cost; }
};
struct WeightedEdge {
long long int to;
long long int cost;
WeightedEdge(long long int v, long long int c = 1) {
to = v;
cost = c;
}
bool operator<(const WeightedEdge& e) const { return cost < e.cost; }
};
using WeightedGraph = V<V<WeightedEdge>>;
long long int N;
int main() {
cin >> N;
cout << 1 + 3 * N * (N + 1) << '\n';
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1010;
char s[MAXN][MAXN];
int sum[MAXN][MAXN];
int n, m;
int sx, sy;
int ans;
bool check(int a, int b, int c, int d) {
return (c - a + 1) * (d - b + 1) ==
(sum[c][d] - sum[a - 1][d] - sum[c][b - 1] + sum[a - 1][b - 1]);
}
bool solve(int x, int y) {
int cover = x * y;
int nx = sx, ny = sy;
while (true) {
if (nx + x <= n && check(nx + x, ny, nx + x, ny + y - 1)) {
nx++;
cover += y;
} else if (ny + y <= m && check(nx, ny + y, nx + x - 1, ny + y)) {
ny++;
cover += x;
} else
break;
}
if (cover == sum[n][m]) {
if (ans == -1 || x * y < ans) ans = x * y;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
sum[i][j] =
sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + (s[i][j] == 'X');
bool flag = false;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++)
if (s[i][j] == 'X') {
sx = i;
sy = j;
flag = true;
break;
}
if (flag) break;
}
ans = -1;
int ty = sy;
while (ty <= m && s[sx][ty] == 'X') ty++;
ty--;
for (int i = 1; sx + i - 1 <= n; i++) {
if (check(sx, sy, sx + i - 1, ty)) {
solve(i, ty - sy + 1);
} else
break;
}
int tx = sx;
while (tx <= n && s[tx][sy] == 'X') tx++;
tx--;
for (int i = 1; sy + i - 1 <= m; i++) {
if (check(sx, sy, tx, sy + i - 1))
solve(tx - sx + 1, i);
else
break;
}
printf("%d\n", ans);
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 5e18;
long long chk(int n, int k, int c9, int d) {
++k;
int m = 0, tc9 = c9, td = d, res = 0;
for (int i = 1; i <= k; ++i) {
res += c9 * 9 + d + m;
++d;
if (d >= 10) {
d = 0;
c9 = 0;
m = 1;
}
}
if (res > n) return inf;
int rest = n - res;
long long ans = inf;
if (rest % k)
return inf;
else
rest /= k;
for (int i = 8; i >= 1; --i) {
if (rest < i) continue;
int trest = rest - i;
long long tans = 0;
vector<int> num;
num.emplace_back(i);
for (int j = 9; j >= 1; --j) {
while (trest >= j) {
trest -= j;
num.emplace_back(j);
}
}
reverse(num.begin(), num.end());
for (int &v : num) {
tans = tans * 10 + v;
}
ans = min(tans, ans);
}
if (rest == 0) ans = 0;
while (tc9 > 0) {
ans = ans * 10 + 9;
--tc9;
}
ans = ans * 10 + td;
return ans;
}
void solve(int n, int k) {
if (k == 0) {
if (n % 9) printf("%d", n % 9);
for (int i = 1; i <= n / 9; ++i) {
printf("9");
}
puts("");
return;
}
long long ans = inf;
for (int c9 = 0; c9 <= 16; ++c9) {
for (int i = 0; i <= 9; ++i) {
ans = min(ans, chk(n, k, c9, i));
}
}
if (ans == inf) ans = -1;
printf("%lld\n", ans);
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, k;
scanf("%d%d", &n, &k);
solve(n, k);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
bool check(int, int, char);
char str[10][10];
int main() {
int i, j;
bool win;
for (i = 0; i < 10; i++)
for (j = 0; j < 10; j++) {
scanf(" %c", &str[i][j]);
}
for (i = 0; i < 10; i++) {
for (j = 0; j < 10; j++) {
if (str[i][j] == 'X' || str[i][j] == '.') {
win = check(i, j, str[i][j]);
}
if (win) {
printf("YES");
break;
}
}
if (win) {
break;
}
}
if (!win) {
printf("NO");
}
return 0;
}
bool check(int x, int y, char ch) {
int i, v, h, di, dotv, doth, dotd, dir, dotdr;
if (ch == 'X') {
v = 1, h = 1, di = 1, dotv = 0, doth = 0, dotd = 0, dir = 1, dotdr = 0;
} else {
v = 0, h = 0, di = 0, dotv = 1, doth = 1, dotd = 1, dir = 0, dotdr = 1;
}
for (i = x + 1; i < (x + 5); i++) {
if (i <= 10 && str[i][y] == 'X') {
v++;
} else if (i <= 10 && str[i][y] == '.') {
dotv++;
} else {
break;
}
if (dotv > 1) {
break;
}
}
for (i = y + 1; i < (y + 5); i++) {
if (i <= 9 && str[x][i] == 'X') {
h++;
} else if (i <= 9 && str[x][i] == '.') {
doth++;
} else {
break;
}
if (doth > 1) {
break;
}
}
for (i = 1; i < 5; i++) {
if ((y + i) <= 9 && str[x + i][y + i] == 'X') {
di++;
} else if ((y + i) <= 9 && str[x + i][y + i] == '.') {
dotd++;
} else {
break;
}
if (dotd > 1) {
break;
}
}
for (i = 1; i < 5; i++) {
if ((y - i) >= 0 && str[x + i][y - i] == 'X') {
dir++;
} else if ((y - i) >= 0 && str[x + i][y - i] == '.') {
dotdr++;
} else {
break;
}
if (dotdr > 1) {
break;
}
}
return (((v == 4) && (dotv == 1)) || ((h == 4) && (doth == 1)) ||
((di == 4) && (dotd == 1)) || ((dir == 4) && (dotdr == 1)));
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
char a[200005];
int main(){
scanf("%s", a + 1);
n = strlen(a + 1);
int ans = n;
int flag = 0;
for(int i = 2; i <= n; i ++){
if(flag){
flag -= 1; continue;
}
if(a[i] == a[i - 1]) {
ans -= 1; flag = 2;
}
}
printf("%d\n", ans);
return 0;
} | 0 | CPP |
w = input()
d = {}
for i in w:
if i in d:
d[i] += 1
else:
d[i] = 1
if len(d) % 2 == 0:
print("CHAT WITH HER!")
else:
print("IGNORE HIM!")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q, w, e, i, a = 0, b = 0;
cin >> q >> w >> e;
for (i = 1; i <= e; i++) {
if (i % q == 0 && i % w == 0) {
a++;
}
}
cout << a << endl;
}
| 7 | CPP |
#include <cstdio>
#include <algorithm>
const int dx[4] = { 0, 0, 1, -1 }, dy[4] = { -1, 1, 0, 0 };
int N, M, K, a[802][802], X, Y, qx[640001], qy[640001], dis[802][802], O = 1000000000;
int main()
{
scanf("%d%d%d", &N, &M, &K);
for (int i = 1; i <= N; i++)
{
static char I[802];
scanf("%s", I + 1);
for (int j = 1; j <= M; j++)
if (I[j] != '#')
{
a[i][j] = 1;
if (I[j] == 'S')
{
X = i;
Y = j;
}
}
}
int H = 0, T = 1;
qx[1] = X;
qy[1] = Y;
dis[X][Y] = 1;
while (H < T)
{
H++;
int ux = qx[H], uy = qy[H];
for (int i = 0; i < 4; i++)
{
int vx = ux + dx[i], vy = uy + dy[i];
if (a[vx][vy] && !dis[vx][vy])
{
T++;
qx[T] = vx;
qy[T] = vy;
dis[vx][vy] = dis[ux][uy] + 1;
}
}
}
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++)
if (1 <= dis[i][j] && dis[i][j] <= K + 1)
O = std::min(O, (std::min(std::min(i - 1, N - i), std::min(j - 1, M - j)) + K - 1) / K + 1);
printf("%d\n", O);
}
| 0 | CPP |
n=int(input())
l=list(map(int,input().split()))
c1=0
for i in range(1,n):
j=i-1
if l[i]>l[j]:
while(j>=0 and l[i]>l[j]):
j=j-1
if j==-1:
c1=c1+1
elif l[i]<l[j]:
while(j>=0 and l[i]<l[j]):
j=j-1
if j==-1:
c1=c1+1
print(c1) | 7 | PYTHON3 |
k=int(input())
count=0
for i in range(k):
str1=input()
str1=list(str1.split(" "))
if(int(str1[1])-int(str1[0])>=2):
count+=1
print(count)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(long long x) {
for (int i = 2; i * i <= x; i++)
if (x % i == 0) return false;
return true;
}
int main() {
long long n, N, cnt = 0, first = 0;
vector<long long> vec;
cin >> n;
N = n;
while (n % 2 == 0) vec.push_back(2), n /= 2;
for (int i = 3; i <= sqrt(n); i += 2)
while (n % i == 0) vec.push_back(i), n /= i;
if (!vec.size() || isPrime(N)) return cout << 1 << '\n' << (long long)0, 0;
if (n != 1) vec.push_back(n);
if (vec.size() == 2) return cout << 2, 0;
return cout << 1 << '\n' << vec[0] * vec[1] << '\n', 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T sqr(T x) {
return x * x;
}
const double EPS = 1e-6;
const int INF = 0x3fffffff;
const long long LINF = INF * 1ll * INF;
const double PI = acos(-1.0);
using namespace std;
long long MOD;
vector<int> v[100005];
void init() {
for (int i = 2; i <= 100000; i++) {
if (v[i].size() == 0) {
for (int j = i; j <= 100000; j += i) v[j].push_back(i);
}
}
}
long long solve(long long m, long long x, long long y) {
if (y < 0) return 0;
long long ans = 0, sum = 0;
int sz = v[x].size();
for (int i = 1; i < (1 << sz); i++) {
long long s = 0, s1 = 0, cnt = 0;
long long f = 1;
for (int j = 0; j < sz; j++) {
if (i & (1 << j)) {
f *= v[x][j];
cnt++;
}
}
long long num = y / f;
s += num;
s %= MOD;
s1 += 1ll * (num + 1) * num / 2 % MOD * f % MOD;
s1 %= MOD;
if (cnt & 1)
ans += s, sum += s1;
else
ans -= s, sum -= s1;
ans = (ans % MOD + MOD) % MOD;
sum = (sum % MOD + MOD) % MOD;
}
ans = y - ans;
ans %= MOD;
sum = (y + 1) * y / 2 - sum;
sum %= MOD;
if (x == 0) {
if (y > 0)
ans = m;
else
ans = 0;
} else {
ans = 2 * (ans * (m + 1) % MOD - sum) % MOD;
if (x == 1) ans += m + 1;
}
ans = (ans % MOD + MOD) % MOD;
return ans;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
int main(void) {
long long n, m;
cin >> n >> m;
long long l, r;
cin >> l >> r >> MOD;
init();
long long ans = 0;
for (int i = 0; i <= n; i++) {
long long low = max(0ll, l * l - 1ll * i * i);
long long high = min(m * m, r * r - 1ll * i * i);
low = ceil(sqrt(low));
high = floor(sqrt(high));
if (low > high) continue;
ans += (n - i + 1) % MOD *
(solve(m, i, high) % MOD - solve(m, i, low - 1) % MOD) % MOD;
ans = (ans % MOD + MOD) % MOD;
}
cout << ans << endl;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, k;
cin >> n >> k;
long long f[51];
f[1] = 1;
f[0] = 1;
f[2] = 2;
for (int i = 3; i < 51; ++i) {
f[i] = f[i - 1] + f[i - 2];
}
int a[n + 1];
for (int i = 1; i < n + 1; ++i) {
if (f[n - i] < k) {
k -= f[n - i];
a[i] = i + 1;
a[i + 1] = i;
i++;
} else {
a[i] = i;
}
}
for (int i = 1; i < n + 1; ++i) {
cout << a[i] << " ";
}
cout << '\n';
;
return 0;
}
| 8 | CPP |
a=int(input())
users={}
B=[]
number=0
for x in range(a):
string=input()
if (string in users) == False:
users[string]=number+1
B.append(1)
number+=1
print('OK')
else:
print(string+str(B[users[string]-1]))
B[users[string]-1]+=1 | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int groups[100001];
int freq[100001];
memset(groups, 0, sizeof(groups));
memset(freq, 0, sizeof(freq));
for (int i = 0; i < n; i++) {
int a;
cin >> a;
freq[a]++;
groups[freq[a]]++;
}
int q;
cin >> q;
while (q--) {
char c;
cin >> c;
int a;
cin >> a;
if (c == '+') {
freq[a]++;
groups[freq[a]]++;
} else {
groups[freq[a]]--;
freq[a]--;
}
if (groups[8] > 0 || groups[4] > 1 || (groups[6] > 0 && groups[2] > 1) ||
(groups[4] > 0 && groups[2] > 2))
cout << "YES\n";
else
cout << "NO\n";
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tc = 1;
while (tc--) {
long long n;
cin >> n;
string x;
cin >> x;
pair<pair<long long, long long>, long long> p[n];
long long a[n];
for (int i = 0; i < n; i++)
cin >> p[i].first.first >> p[i].first.second, p[i].second = i,
a[i] = x[i] - '0';
sort(p, p + n);
long long c = 0, ans = 0;
string rep;
for (int tim = 0; tim <= 1e5; tim++) {
for (int i = 0; i < n; i++) {
if (p[i].first.second == tim) c++;
if (tim >= p[i].first.second &&
(tim - p[i].first.second) % p[i].first.first == 0)
a[p[i].second] = 1 - a[p[i].second];
}
long long cnt = 0;
for (int i = 0; i < n; i++)
if (a[i]) cnt++;
ans = max(ans, cnt);
if (c == n) rep = x;
}
cout << ans << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1505;
int vis[N][N];
pair<int, int> color[N][N];
char grid[N][N];
int n, m;
int movX[4] = {0, 1, 0, -1};
int movY[4] = {1, 0, -1, 0};
bool go(int x0, int y0) {
stack<pair<int, pair<pair<int, int>, pair<int, int> > > > S;
S.push(make_pair(-1, make_pair(make_pair(0, 0), make_pair(x0, y0))));
bool chi = 0;
while (!S.empty()) {
if (chi) break;
int x = S.top().second.second.first;
int y = S.top().second.second.second;
pair<int, int> p = S.top().second.first;
int d = S.top().first;
S.pop();
if (vis[x][y]) continue;
vis[x][y] = 1;
color[x][y] = p;
for (int i = int(0); i < int(4); i++)
if (i != d) {
int nxtX = x + movX[i];
int nxtY = y + movY[i];
pair<int, int> nxtP = p;
if (nxtX == -1) {
nxtP.first--;
nxtX = n - 1;
} else if (nxtX == n) {
nxtP.first++;
nxtX = 0;
} else if (nxtY == -1) {
nxtP.second--;
nxtY = m - 1;
} else if (nxtY == m) {
nxtP.second++;
nxtY = 0;
}
if (nxtX >= 0 && nxtX < n && nxtY >= 0 && nxtY < m &&
grid[nxtX][nxtY] != '#')
if (!vis[nxtX][nxtY])
S.push(
make_pair((i + 2) % 4, make_pair(nxtP, make_pair(nxtX, nxtY))));
else if (color[nxtX][nxtY] != nxtP)
chi = 1;
}
}
return chi;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
int x, y;
for (int i = int(0); i < int(n); i++)
for (int j = int(0); j < int(m); j++) {
cin >> grid[i][j];
if (grid[i][j] == 'S') {
x = i, y = j;
}
}
cout << (go(x, y) ? "Yes" : "No") << endl;
return 0;
}
| 8 | CPP |
import re;print(max(map(len,re.findall('[ATGC]*',input())))) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long ans, a, b, p = 1, c, d, e, i, j, n;
string s, s1;
map<long long, long long> m;
vector<long long> v;
int main() {
cin >> s;
n = s.size();
ans = pow(9, n - 1);
for (int i = 0; i < n; i++) {
long long o = p * pow(9, n - i - 1) * (s[i] - '1');
ans = max(ans, o);
p = p * (s[i] - '0');
}
cout << max(ans, p);
}
| 8 | CPP |
class linked_list:
def __init__(self, val):
self.val = val
self.right = None
self.left = None
def insert_right(self, node):
node.right = self.right
node.left = self
if self.right:
self.right.left = node
self.right = node
return
def insert_left(self, node):
node.left = self.left
node.right = self
if self.left:
self.left.right = node
self.left = node
def get_start(self):
node = self
while node.left:
node = node.left
return node
if __name__ == '__main__':
moves = input()
high = 1
low = 0
position = dict()
curr_node = linked_list(1)
for idx,char in enumerate(moves[:-1]):
new_node = linked_list(idx+2)
# print("Dd"+str(idx+2), curr_node.val)
if char == 'l':
curr_node.insert_left(new_node)
else:
curr_node.insert_right(new_node)
curr_node = new_node
node = curr_node.get_start()
while node:
print(node.val)
node = node.right | 7 | PYTHON3 |
n,k=map(int,input().split())
l=list(map(int,input().split()))
dp=[0 for i in range(n)]
dp[0]=l[0]
for i in range(1,n):
dp[i]=l[i]+dp[i-1]
dp.insert(0,0)
ks=[]
#print(dp)
try:
for i in range(0,n-k+1):
ks.append([dp[i+k]-dp[i],i])
except:
pass
print(min(ks)[1]+1)
| 8 | PYTHON3 |
t = list(map(int, input().split()))
digits = set(t)
minsum = sum(t)
if len(digits) == len(t):
print(minsum)
else:
for i in digits:
q = t.copy()
if q.count(i) == 2:
q.remove(i)
q.remove(i)
if sum(q) < minsum:
minsum = sum(q)
elif q.count(i) >= 3:
q.remove(i)
q.remove(i)
q.remove(i)
if sum(q) < minsum:
minsum = sum(q)
print(minsum)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, h;
while (cin >> n >> m >> h) {
int S = 0, k[m];
for (int i = 0; i < m; i++) {
cin >> k[i];
S += k[i];
}
if (n > S)
cout << "-1.0" << endl;
else {
n--;
h--;
S--;
k[h]--;
double p = 1;
for (int i = 0; i < n; i++) p *= 1.0 * (S - i - k[h]) / (S - i);
printf("%.10lf\n", 1 - p);
}
}
return 0;
}
| 8 | CPP |
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main(){
string s;
cin>>s;
if(s.size()==26){
string t=s;
if(!next_permutation(t.begin(),t.end()))cout<<-1<<endl;
else{
for(int n=0;n<s.size();n++){
if(s[n]!=t[n]){
cout<<t.substr(0,n+1)<<endl;
break;
}
}
}
}else{
for(char c='a';c<='z';c++){
if(all_of(s.begin(),s.end(),[&](char e){
return e!=c;
})){
cout<<s<<c<<endl;
break;
}
}
}
}
| 0 | CPP |
#C1
n=int(input())
A=list(map(int,input().split()))
l,r=0,n-1
if A[l]<A[r]:
tmp=A[l]
l+=1
ans='L'
else:
tmp=A[r]
r-=1
ans='R'
cnt=1
while l<=r:
left,right=A[l],A[r]
if max(left,right)<tmp:
break
cnt+=1
if left<right:
if tmp>left:
tmp=right
r-=1
ans+='R'
else:
tmp=left
l+=1
ans+='L'
else:
if tmp>right:
tmp=left
l+=1
ans+='L'
else:
tmp=right
r-=1
ans+='R'
print(cnt)
print(ans) | 9 | PYTHON3 |
t=int(input())
while(t):
s, a, b, c = map(int, input().split())
ans=s//c
print(ans+(ans//a)*b)
t=t-1 | 7 | PYTHON3 |
def main():
from sys import stdin
from heapq import heappush, heappushpop
n, k, q = map(int, input().split())
l = list(map(int, input().split()))
m, h, res = [False] * n, [], []
for a, b in map(str.split, stdin.read().splitlines()):
id = int(b) - 1
if a == "1":
m[id] = True
if k:
k -= 1
heappush(h, (l[id], id))
else:
_, id = heappushpop(h, (l[id], id))
m[id] = False
else:
res.append(("NO", "YES")[m[id]])
print('\n'.join(res))
if __name__ == '__main__':
main()
| 8 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
int main(){
string s; cin>>s;
int cnt=0;
for(int i=0;i<s.size();i++){
if(s[i]=='?') {
s[i]='D';
}
}
cout<<s<<endl;
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, ans;
long long a[100005];
long long dp1[100005][2];
long long dp2[100005][2];
int main() {
cin >> n;
for (int i = 1; i <= n - 1; i++) cin >> a[i];
for (int i = 2; i <= n; i++) {
dp1[i][0] = max(dp1[i - 1][0], dp1[i - 1][1]) +
(a[i - 1] % 2 == 1 ? a[i - 1] : a[i - 1] - 1);
if (a[i - 1] != 1)
dp1[i][1] = dp1[i - 1][1] + (a[i - 1] % 2 == 0 ? a[i - 1] : a[i - 1] - 1);
}
for (int i = n - 1; i >= 1; i--) {
dp2[i][0] =
max(dp2[i + 1][0], dp2[i + 1][1]) + (a[i] % 2 == 1 ? a[i] : a[i] - 1);
if (a[i] != 1)
dp2[i][1] = dp2[i + 1][1] + (a[i] % 2 == 0 ? a[i] : a[i] - 1);
}
for (int i = 1; i <= n; i++) {
ans = max(ans, max(dp1[i][0] + dp2[i][1], dp1[i][1] + dp2[i][0]));
}
cout << ans;
return 0;
}
| 9 | CPP |
#include<iostream>
using namespace std;
int main(){
char a,b;
cin>>a>>b;
if(a==b)cout<<"H"<<endl;
else cout<<"D"<<endl;
} | 0 | CPP |
t = int(input())
for i in range(t):
n = int(input())
lst = list(map(int,input().split()))
oldSum = sum(lst)
avg = oldSum//n
if (avg*n < oldSum):
avg+=1
print(avg) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int in[101000], n, q, k;
long long sum[101000];
bool cmp(int a, int b) { return a > b; }
int main() {
cin >> n;
for (int i = 0; i < (n); i++) cin >> in[i];
sort(in, in + n, cmp);
cin >> q;
sum[0] = 0;
for (int i = 0; i < (n); i++) sum[i + 1] = sum[i] + in[i];
long long a1 = 0;
for (int i = (1); i <= (n - 1); i++) a1 += i * 1LL * in[i];
while (q--) {
cin >> k;
if (k == 1)
cout << a1;
else {
int np = 1;
long long s = k, ans = 0;
int cnt = 1;
while (np < n) {
long long tnp = np + s;
if (tnp > n) tnp = n;
ans += cnt * (sum[tnp] - sum[np]);
np = tnp;
s *= k;
cnt++;
}
cout << ans;
}
printf("%c", ((!q) ? '\n' : ' '));
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> vec[101010];
void init() {
for (int i = 0; i < 101010; i++) vec[i].clear();
}
struct data {
int ind, val;
data() {}
data(int i, int v) {
ind = i;
val = v;
}
bool operator<(const data& dd) const { return val < dd.val; }
};
int main() {
int n, a, mini, b, c, i, j;
priority_queue<data> pq;
while (scanf("%d", &n) == 1) {
while (!pq.empty()) pq.pop();
mini = INT_MAX;
init();
for (i = 1; i <= n; i++) {
scanf("%d", &a);
pq.push(data(i, a));
mini = min(a, mini);
}
int cnt = 0;
while (pq.top().val > mini) {
data a = pq.top();
pq.pop();
data b = pq.top();
pq.pop();
a.val--;
b.val--;
a.val = max(a.val, 0);
b.val = max(b.val, 0);
mini = min(mini, a.val);
mini = min(mini, b.val);
pq.push(a);
pq.push(b);
vec[cnt].push_back(a.ind);
vec[cnt].push_back(b.ind);
data aa = pq.top();
pq.pop();
data bb = pq.top();
pq.pop();
if (bb.val == mini && aa.val > b.val && aa.ind != a.ind &&
aa.ind != b.ind) {
aa.val--;
vec[cnt].push_back(aa.ind);
}
pq.push(aa);
pq.push(bb);
sort(vec[cnt].begin(), vec[cnt].end());
cnt++;
}
printf("%d\n", pq.top().val);
printf("%d\n", cnt);
for (i = 0; i < cnt; i++) {
int cc = 0;
for (j = 1; j <= n; j++) {
if (cc < vec[i].size() && j == vec[i][cc]) {
cc++;
printf("1");
} else
printf("0");
}
printf("\n");
}
}
return 0;
}
| 7 | CPP |
N,P = map(int,input().split())
ans=1
i=2
if N==1:
print(P)
exit()
if N>=40 or P==1:
print(1)
exit()
while i<=(P**(1.001/N)):
while P%(i**N) == 0:
ans *= i
P = P//(i**N)
if i==2:
i+=1
else:
i+=2
print(ans) | 0 | PYTHON3 |
"""
Oh, Grantors of Dark Disgrace,
Do Not Wake Me Again.
"""
for _ in [0]*int(input()): print(int(input().split()[1])*2)
| 7 | PYTHON3 |
#Mamma don't raises quitter.................................................
#manan is improving, keep hustling manan bhai ;)
from collections import deque as de
import math
import sys
from math import sqrt as sq
from math import floor as fl
from math import ceil as ce
from sys import stdin, stdout
import time
sys.setrecursionlimit(10**7)
from collections import Counter as cnt
from functools import reduce
from itertools import groupby as gb
#from fractions import Fraction as fr
from bisect import bisect_left as bl, bisect_right as br
from typing import Coroutine
def factors(n):
return set(reduce(list.__add__,
([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0)))
class My_stack():
def __init__(self):
self.data = []
def my_push(self, x):
return (self.data.append(x))
def my_pop(self):
return (self.data.pop())
def __iter__(self):
return iter(self.data)
def my_peak(self):
return (self.data[-1])
def my_contains(self, x):
return (self.data.count(x))
def my_show_all(self):
return (self.data)
def isEmpty(self):
return len(self.data)==0
def len(self):
return len(self.data)
arrStack = My_stack()
class graph():
def __init__(self):
self.graphdict = {}
def add_edge(self, node, neighbor):
if node not in self.graphdict:
self.graphdict[node]=[neighbor]
else:
self.graphdict[node].append(neighbor)
def show_edge(self):
for node in self.graphdict:
for neighbors in self.graphdict:
print(node, neighbors)
def show_graph(self):
return self.graphdict
#decimal to binary
def decimalToBinary(n):
return bin(n).replace("0b", "")
#binary to decimal
def binarytodecimal(n):
return int(n,2)
def isPrime(n) :
if (n <= 1) :
return False
if (n <= 3) :
return True
if (n % 2 == 0 or n % 3 == 0) :
return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
def get_prime_factors(number):
prime_factors = []
while number % 2 == 0:
prime_factors.append(2)
number = number / 2
for i in range(3, int(math.sqrt(number)) + 1, 2):
while number % i == 0:
prime_factors.append(int(i))
number = number / i
if number > 2:
prime_factors.append(int(number))
return prime_factors
def get_frequency(list):
dic={}
for ele in list:
if ele in dic:
dic[ele] += 1
else:
dic[ele] = 1
return dic
def Log2(x):
return (math.log10(x) /
math.log10(2));
# Function to get product of digits
def getProduct(n):
product = 1
while (n != 0):
product = product * (n % 10)
n = n // 10
return product
#fucntion to find regular bracket sequence
def regularBracketsequence(str,arrStack):
for i in range(len(str)):
if str[i] =='(':
arrStack.my_push(str[i])
else:
if arrStack.isEmpty():
return False
else:
arrStack.my_pop()
if arrStack.isEmpty():
return True
else:
return False
#function to find LCM of two numbers
def lcm(x,y):
lcm = (x*y)//math.gcd(x,y)
return lcm
def isPowerOfTwo(n):
return (math.ceil(Log2(n)) == math.floor(Log2(n)));
#to check whether the given sorted sequnce is forming an AP or not....
def checkisap(list):
d=list[1]-list[0]
for i in range(2,len(list)):
temp=list[i]-list[i-1]
if temp !=d:
return False
return True
#seive of erathanos
def primes_method5(n):
out ={}
sieve = [True] * (n+1)
for p in range(2, n+1):
if (sieve[p]):
out[p]=1
for i in range(p, n+1, p):
sieve[i] = False
return out
#fucntion to get unique number to a cell in a matrix
def id(i, j, col): #one based indexing and columnwise numeration
ans= (i-1)*col
ans+=j
return ans
#function to get the sum of digits
def getSum(n):
strr = str(n)
list_of_number = list(map(int, strr.strip()))
return sum(list_of_number)
def checkperfectsquare(n):
if (ce(sq(n)) == fl(sq(n))):
return True
else:
return False
#this used for selecting r objects from n ojects
def combinatrics(n,r):
num=n
deno=n-r
pr=1
for i in range(num,deno,-1):
pr*=i
an=1
for i in range(1,r+1):
an*=i
ans=pr//an
return ans
#ceil function gives wrong answer after 10^17 so i have to create my own :)
# because i don't want to doubt on my solution of 900-1000 problem set.
def ceildiv(x,y):
return (x+y-1)//y
def di():return map(int, input().split())
def ii():return int(input())
def li():return list(map(int, input().split()))
def si():return list(map(str, input()))
def indict():
dic = {}
for index, value in enumerate(input().split()):
dic[int(value)] = int(index)
return dic
def frqdict():
# by default it is for integer input. :)
dic={}
for index, value in enumerate(input()):
if value not in dic:
dic[value] =1
else:
dic[value] +=1
return dic
#sys.stdin = open('input.txt', 'r')
#sys.stdout = open('output.txt', 'w')
#practice like your never won
#perform like you never lost
t=ii()
while t:
t-=1
n=ii()
a=sorted(li())
for i in range(1,(n//2)+1):
print( a[i], a[0])
| 8 | PYTHON3 |
# ===============================================================================================
# importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from itertools import *
import bisect
from heapq import *
from math import *
from copy import *
from collections import deque
from collections import Counter as counter # Counter(list) return a dict with {key: count}
from itertools import combinations as comb # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
from itertools import permutations as permutate
from bisect import bisect_left as bl
# If the element is already present in the list,
# the left most position where element has to be inserted is returned.
from bisect import bisect_right as br
from bisect import bisect
# If the element is already present in the list,
# the right most position where element has to be inserted is returned
# ==============================================================================================
# fast I/O region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
# ===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
def wrapped_func(*args, **kwargs):
if stack: return f(*args, **kwargs)
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
continue
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped_func
#### END ITERATE RECURSION ####
# ===============================================================================================
# some shortcuts
mod = 1000000007
def inp(): return sys.stdin.readline().rstrip("\r\n") # for fast input
def out(var): sys.stdout.write(str(var)) # for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
def zerolist(n): return [0] * n
def nextline(): out("\n") # as stdout.write always print sring.
def testcase(t):
for p in range(t):
solve()
def printlist(a):
for p in range(0, len(a)):
out(str(a[p]) + ' ')
def lcm(a, b): return (a * b) // gcd(a, b)
def power(x, y, p):
res = 1 # Initialize result
x = x % p # Update x if it is more , than or equal to p
if (x == 0):
return 0
while (y > 0):
if ((y & 1) == 1): # If y is odd, multiply, x with result
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
def ncr(n, r): return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))
def isPrime(n):
if (n <= 1): return False
if (n <= 3): return True
if (n % 2 == 0 or n % 3 == 0): return False
i = 5
while (i * i <= n):
if (n % i == 0 or n % (i + 2) == 0):
return False
i = i + 6
return True
def solve():
t=int(inp())
for _ in range(t):
n=int(inp())
s=inp()
curr=s[0]
curr_l=1
ar=[]
for i in range(1,n):
if s[i]==curr:
curr_l+=1
else:
ar.append(curr_l)
curr=s[i]
curr_l=1
if curr==s[0] and ar:
ar[0]+=curr_l
else:
ar.append(curr_l)
if len(ar)==1:
print((n+2)//3)
else:
ans=0
for i in ar:
ans+=(i//3)
print(ans)
solve()
| 10 | PYTHON3 |
n = int(input())
mas = list(map(int, input().split()))
_min = _max = mas[0]
count = 0
for i in range(1, n) :
if mas[i] > _max :
count += 1
_max = mas[i]
elif mas[i] < _min :
count += 1
_min = mas[i]
print(count)
| 7 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n;cin>>n;
vector<int> a(3*n);
int i;
for(i=0;i<3*n;i++)cin>>a.at(i);
long long ans=0;
sort(a.begin(),a.end());
reverse(a.begin(),a.end());
for(i=1;i<2*n;i+=2)ans+=a.at(i);
cout<<ans<<endl;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 250005;
int n, m, k;
vector<int> g[N];
int leaf[N], lvl[N], par[N], used[N];
int mx = 0;
void dfs(int v, int p = 0) {
used[v] = 1;
lvl[v] = lvl[p] + 1;
if (lvl[v] > lvl[mx]) {
mx = v;
}
par[v] = p;
leaf[v] = 1;
for (int i : g[v]) {
if (used[i] == 0) {
dfs(i, v);
leaf[v] = 0;
}
}
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b), g[b].push_back(a);
}
dfs(1);
if (lvl[mx] >= (n + k - 1) / k) {
cout << "PATH" << endl;
cout << lvl[mx] << endl;
for (int i = mx; i > 0; i = par[i]) {
cout << i << " ";
}
cout << endl;
return 0;
}
cout << "CYCLES" << endl;
for (int i = 1; i <= n; i++) {
if (leaf[i] == 1) {
int id = 0;
if (g[i][id] == par[i]) id++;
int x = g[i][id++];
if (g[i][id] == par[i]) id++;
int y = g[i][id];
if (lvl[x] > lvl[y]) swap(x, y);
if ((lvl[i] - lvl[x] + 1) % 3 != 0) {
cout << lvl[i] - lvl[x] + 1 << endl;
for (int nd = i; nd != par[x]; nd = par[nd]) {
cout << nd << " ";
}
} else if ((lvl[i] - lvl[y] + 1) % 3 != 0) {
cout << lvl[i] - lvl[y] + 1 << endl;
for (int nd = i; nd != par[y]; nd = par[nd]) {
cout << nd << " ";
}
} else {
cout << lvl[y] - lvl[x] + 2 << endl;
cout << i << " ";
for (int nd = y; nd != par[x]; nd = par[nd]) {
cout << nd << " ";
}
}
cout << endl;
k--;
if (k == 0) break;
}
}
return 0;
}
| 11 | CPP |
// C - Welcome to AtCoder
#include <bits/stdc++.h>
using namespace std;
int wa_count[100000];
int main(){
int n,m,p,ac=0,wa=0;
char s[3];
scanf("%d%d",&n,&m);
while(m--){
scanf("%d%s",&p,s); --p;
if(wa_count[p] < 0) continue;// ac
if(s[0] == 'W') wa_count[p]++;
else{
ac++;
wa += wa_count[p];
wa_count[p] = -1;// ac flag on
}
}
printf("%d %d\n",ac,wa);
} | 0 | CPP |
# -*- coding: utf-8 -*-
"""
@Project : ็ๅฎข็ฝ
@File : 2.py
@Time : 2018/6/10 18:23
@Author : Koushiro
B. Micro-World
time limit per test2 seconds
memory limit per test256 megabytes
inputstandard input
outputstandard output
You have a Petri dish with bacteria and you are preparing to dive into the harsh micro-world. But, unfortunately, you don't have any microscope nearby, so you can't watch them.
You know that you have
n
bacteria in the Petri dish and size of the
i
-th bacteria is
a
i
. Also you know intergalactic positive integer constant
K
.
The
i
-th bacteria can swallow the
j
-th bacteria if and only if
a
i
>
a
j
and
a
i
โค
a
j
+
K
. The
j
-th bacteria disappear, but the
i
-th bacteria doesn't change its size. The bacteria can perform multiple swallows. On each swallow operation any bacteria
i
can swallow any bacteria
j
if
a
i
>
a
j
and
a
i
โค
a
j
+
K
. The swallow operations go one after another.
For example, the sequence of bacteria sizes
a
=
[
101
,
53
,
42
,
102
,
101
,
55
,
54
]
and
K
=
1
. The one of possible sequences of swallows is:
[
101
,
53
,
42
,
102
,
101
โโโโ
,
55
,
54
]
โ
[
101
,
53
โโโ
,
42
,
102
,
55
,
54
]
โ
[
101
โโโโ
,
42
,
102
,
55
,
54
]
โ
[
42
,
102
,
55
,
54
โโโ
]
โ
[
42
,
102
,
55
]
. In total there are
3
bacteria remained in the Petri dish.
Since you don't have a microscope, you can only guess, what the minimal possible number of bacteria can remain in your Petri dish when you finally will find any microscope.
Input
The first line contains two space separated positive integers
n
and
K
(
1
โค
n
โค
2
โ
10
5
,
1
โค
K
โค
10
6
) โ number of bacteria and intergalactic constant
K
.
The second line contains
n
space separated integers
a
1
,
a
2
,
โฆ
,
a
n
(
1
โค
a
i
โค
10
6
) โ sizes of bacteria you have.
Output
Print the only integer โ minimal possible number of bacteria can remain.
Examples
inputCopy
7 1
101 53 42 102 101 55 54
outputCopy
3
inputCopy
6 5
20 15 10 15 20 25
outputCopy
1
inputCopy
7 1000000
1 1 1 1 1 1 1
outputCopy
7
Note
The first example is clarified in the problem statement.
In the second example an optimal possible sequence of swallows is:
[
20
,
15
,
10
,
15
,
20
โโโ
,
25
]
โ
[
20
,
15
,
10
,
15
โโโ
,
25
]
โ
[
20
,
15
,
10
โโโ
,
25
]
โ
[
20
,
15
โโโ
,
25
]
โ
[
20
โโโ
,
25
]
โ
[
25
]
.
In the third example no bacteria can swallow any other bacteria.
"""
if __name__ == "__main__":
n, K = map(int, input().split())
bac = list(map(int, input().split()))
bac.sort()
diff = [0 for i in range(n-1)]
count = 0
future = 0
for i in range(n-1):
if count == 0 and bac[i + 1] - bac[i] != 0:
diff[i] = bac[i + 1] - bac[i]
elif count > 0:
diff[i] = future
count -= 1
else:
j = i
tmp = bac[j]
j = j + 1
while bac[j] == tmp and j < n - 1:
j += 1
future = bac[j] - bac[i]
diff[i] = future
count = j - i - 1
swallow = 0
for i in range(n-1):
if diff[i] <= K and diff[i] != 0:
swallow += 1
print(n - swallow)
| 8 | PYTHON3 |
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <cmath>
#include <cstdlib>
#include <tuple>
using namespace std;
using ll=long long;
using R=double;
int a[100003];
int ans[100003];
int find(int x){
if(a[x] == x)return x;
else {
int tmp = find(a[x]);
a[x] = tmp;
return tmp;
}
}
void Union(int x,int y){
int x_h = find(x);
int y_h = find(y);
if(x_h != y_h)a[x_h] = y_h;
}
int main(){
int n,m;
cin>>n>>m;
for(int i=1;i<=n;i++){
cin>>ans[i];
a[i] = i;
}
int tmp1,tmp2;
for(int i=0;i<m;i++){
cin>>tmp1>>tmp2;
Union(tmp1,tmp2);
}
int cnt = 0;
for(int i=1;i<=n;i++){
if(find(i)==find(ans[i]))cnt++;
}
cout<<cnt<<endl;
return 0;
}
| 0 | CPP |
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <set>
#include <cstring>
using namespace std;
#ifdef DEBUG_MODE
#define DBG(n) n;
#else
#define DBG(n) ;
#endif
#define REP(i,n) for(ll (i) = (0);(i) < (n);++i)
#define PB push_back
#define MP make_pair
#define FI first
#define SE second
#define SHOW1d(v,n) {for(int W = 0;W < (n);W++)cerr << v[W] << ' ';cerr << endl << endl;}
#define SHOW2d(v,i,j) {for(int aaa = 0;aaa < i;aaa++){for(int bbb = 0;bbb < j;bbb++)cerr << v[aaa][bbb] << ' ';cerr << endl;}cerr << endl;}
#define ALL(v) v.begin(),v.end()
#define Decimal fixed<<setprecision(20)
#define INF 1000000000
#define LLINF 1000000000000000000LL
#define MOD 1000000007
typedef long long ll;
int main() {
ll n, m; cin >> n >> m;
ll ans = 0;
REP(i, m) {
int a; cin >> a;
if (a > m)ans++;
}
cout << ans << endl;
return 0;
}
| 0 | CPP |
import math
def factor(x):
vec=[]
if(x%2==0):
vec.append(2)
while(x%2==0):
x=x//2
i=3
while(i<=math.sqrt(x)):
if(x%i==0):
vec.append(i)
while(x%i==0):
x=x//i
i+=2
if(x>1):
vec.append(x)
return vec
mod=1000000007
def power(x,y):
res=1
x=x%mod
if(x==0):
return 0
while(y>0):
if(y%2==1):
res=(res*x)%mod
y=y>>1
x=(x*x)%mod
return res
x,n=map(int,input().split(' '))
vec=factor(x)
ans=1
for i in vec:
c=0
x=i
while(x<=n):
c+=n//x
x=x*i
ans=(ans*(power(i,c))%mod)%mod
print(ans)
| 9 | PYTHON3 |
def f(List):
l=len(List)
for i in range(l-1):
if List[i+1]<List[i]:
return i+1
else:
return l
def g(List):
l = len(List)
for i in range(l - 1):
if List[i + 1] > List[i]:
return i + 1
else:
return l
t=int(input())
for test in range(t):
n=int(input())
array = list(map(int, input().rstrip().split()))
array.reverse()
increasing=f(array)
if increasing>=n-1:
print(0)
else:
l=g(array[increasing-1:])
print(n+1-l-increasing) | 9 | PYTHON3 |
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef vector<int> VI;
typedef vector<VI> VVI;
const double PI = 3.14159265358979323846;
const double EPS = 1e-12;
const int INF = numeric_limits<int>::max() / 2;
const int NEG_INF = numeric_limits<int>::min() / 2;
const int MOD = 1e9 + 7;
using u32 = unsigned int;
using u64 = unsigned long long;
int popcount(unsigned long long a) {
a = (a & 0x5555555555555555) + (a >> 1 & 0x5555555555555555);
a = (a & 0x3333333333333333) + (a >> 2 & 0x3333333333333333);
a = (a & 0x0f0f0f0f0f0f0f0f) + (a >> 4 & 0x0f0f0f0f0f0f0f0f);
a = (a & 0x00ff00ff00ff00ff) + (a >> 8 & 0x00ff00ff00ff00ff);
a = (a & 0x0000ffff0000ffff) + (a >> 16 & 0x0000ffff0000ffff);
return (a & 0xffffffff) + (a >> 32);
}
// select : O(logN)
class fully_indexable_dictionary {
public:
static const int interval = 32;
static const int not_found = -1;
fully_indexable_dictionary(int len) : length(len) {
block_size = (length + interval - 1) / interval + 1;
blocks.resize(block_size);
}
void set(int i) {
blocks[i / interval] |= 1U << (i & (interval - 1));
}
void build() {
rank_table.assign(block_size + 1, 0);
for(int i = 1; i < block_size; ++i) {
rank_table[i] = rank_table[i - 1] + popcount(blocks[i - 1]);
}
}
// return B[pos]
bool access(int pos) const {
return blocks[pos / interval] >> (pos & 31) & 1;
}
// count 1 on B[0..pos)
int rank(int pos) const {
int block_idx = pos / interval;
u32 mask = (1U << (pos & 31)) - 1;
return rank_table[block_idx] + popcount(blocks[block_idx] & mask);
}
int rank(bool b, int pos) const {
return (b ? rank(pos) : pos - rank(pos));
}
int rank(bool b, int l, int r) const {
return rank(b, r) - rank(b, l);
}
int select(bool b, int x) const {
if(x < 0 || rank(b, length) <= x) {
return not_found;
}
int lb = 0, ub = length;
while(ub - lb > 1) {
int m = (lb + ub) / 2;
if(rank(b, m) <= x) {
lb = m;
} else {
ub = m;
}
}
return lb;
}
int select(bool b, int x, int left) const {
return select(b, x + rank(b, left));
}
private:
int length;
int block_size;
std::vector<u32> blocks;
std::vector<int> rank_table;
};
template <typename T>
class wavelet_matrix {
public:
static const int not_found = -1;
static const int max_bit_size = 64;
wavelet_matrix(std::vector<T> const& data) {
length = data.size();
max_val = *std::max_element(std::begin(data), std::end(data));
for(bit_size = 0; 1LL << bit_size <= max_val; ++bit_size);
dicts.assign(bit_size, length);
mids.assign(bit_size, 0);
std::vector<T> buf1(data), buf2(length);
for(int b = 0; b < bit_size; ++b) {
int pos = 0;
for(int i = 0; i < length; ++i) {
if((buf1[i] >> (bit_size - b - 1) & 1) == 0) {
buf2[pos++] = buf1[i];
}
}
mids[b] = pos;
for(int i = 0; i < length; ++i) {
if((buf1[i] >> (bit_size - b - 1) & 1) == 1) {
dicts[b].set(i);
buf2[pos++] = buf1[i];
}
}
dicts[b].build();
buf1.swap(buf2);
}
}
T access(int pos) const {
T res = 0;
for(int b = 0; b < bit_size; ++b) {
bool d = dicts[b].access(pos);
res = res << 1 | d;
pos = dicts[b].rank(d, pos);
if(d) {
pos += mids[b];
}
}
return res;
}
// [l..r)
int rank(T val, int l, int r) const {
if(val > max_val) {
return 0;
}
for(int b = 0; b < bit_size; ++b) {
bool d = val >> (bit_size - b - 1) & 1;
l = dicts[b].rank(d, l);
r = dicts[b].rank(d, r);
if(d) {
l += mids[b];
r += mids[b];
}
}
return r - l;
}
// [0..r)
int rank(T val, int r) const {
return rank(val, 0, r);
}
// ol -> the number of numbers strictly less than val on [l..r)
// og -> the number of numbers strictly greater than val on [l..r)
int rank_all(T val, int l, int r, int& ol, int& og) const {
if(val > max_val) {
ol = r - l;
og = 0;
return 0;
}
ol = og = 0;
for(int b = 0; b < bit_size; ++b) {
bool d = val >> (bit_size - b - 1) & 1;
int lcnt = dicts[b].rank(d, l);
int rcnt = dicts[b].rank(d, r);
(d ? ol : og) += (r - l) - (rcnt - lcnt);
l = lcnt;
r = rcnt;
if(d) {
l += mids[b];
r += mids[b];
}
}
return r - l;
}
int rank_lt(T val, int l, int r) const {
int ol, og;
rank_all(val, l, r, ol, og);
return ol;
}
// return the number of numbers in [b..u) on [l..r)
int range_freq(int l, int r, T b, T u) const {
return rank_lt(u, l, r) - rank_lt(b, l, r);
}
// find the (x + 1)th position of val
int select(T val, int x) const {
if(val > max_val) {
return not_found;
}
static int lefts[max_bit_size], rights[max_bit_size];
int l = 0, r = length;
for(int b = 0; b < bit_size; ++b) {
lefts[b] = l;
rights[b] = r;
bool d = val >> (bit_size - b - 1) & 1;
l = dicts[b].rank(d, l);
r = dicts[b].rank(d, r);
if(d) {
l += mids[b];
r += mids[b];
}
}
for(int b = bit_size - 1; b >= 0; --b) {
x = dicts[b].select(val >> (bit_size - b - 1) & 1, x, lefts[b]);
if(x == fully_indexable_dictionary::not_found || x >= rights[b]) {
return not_found;
}
x -= lefts[b];
}
return x;
}
int select(T val, int x, int left) const {
return select(val, x + rank(val, left));
}
void quantile(int l, int r, int kth, int& out_v, int& out_k) const {
if(r - l <= kth || kth < 0) {
out_v = -1;
out_k = not_found;
return;
}
T val = 0;
for(int b = 0; b < bit_size; ++b) {
int cnt = dicts[b].rank(1, l, r);
bool d = kth < cnt;
val = val << 1 | d;
if(!d) {
kth -= cnt;
}
l = dicts[b].rank(d, l);
r = dicts[b].rank(d, r);
if(d) {
l += mids[b];
r += mids[b];
}
}
out_v = val;
out_k = kth;
}
T quantile(int l, int r, int kth) const {
T tmp_v;
int tmp_k;
quantile(l, r, kth, tmp_v, tmp_k);
return tmp_v;
}
struct idx_val {
int idx;
T val;
};
idx_val quantile_idx_val(int l, int r, int k) const {
T tmp_v;
int tmp_k;
quantile(l, r, k, tmp_v, tmp_k);
return idx_val{select(tmp_v, tmp_k, l), tmp_v};
}
T max(int l, int r) const {
return quantile(l, r, 0);
}
T min(int l, int r) const {
return quantile(l, r, r - l - 1);
}
void max_dfs(int b, int l, int r, int& k, T val, std::vector<T>& res) const {
if(l >= r || k == 0) {
return;
}
if(b == bit_size) {
while(l++ < r && k > 0) {
res.push_back(val);
k--;
}
return;
}
int ll = dicts[b].rank(1, l);
int rr = dicts[b].rank(1, r);
max_dfs(b + 1, ll + mids[b], rr + mids[b], k, 1ULL << (bit_size - b - 1) | val, res);
max_dfs(b + 1, l - ll, r - rr, k, val, res);
// note: when requires min, changes to below
//max_dfs(b + 1, l - ll, r - rr, k, val, res);
//max_dfs(b + 1, ll + mids[b], rr + mids[b], k, 1ULL << (bit_size - b - 1) | val, res);
}
// top k numbers on [l..r)
std::vector<T> topk(int l, int r, int k) const {
if(r - l < k) {
k = r - l;
}
if(k < 0) {
return std::vector<T>();
}
std::vector<T> res;
max_dfs(0, l, r, k, 0, res);
return res;
}
struct freq_list_data {
T val;
int count;
freq_list_data(T v, int cnt) : val(v), count(cnt) {}
};
// O(K * logM). K := res.size()
// return {([num], [count]), ...}.
// Each [num] satisfies bottom <= [num] < up and in [l..r)
// [count] is number of occurences of [num].
void freq_list_dfs(int b, int l, int r, T val, T bottom, T up, std::vector<freq_list_data>& res) const {
if(val >= up || l >= r) {
return;
}
if(b == bit_size) {
if(bottom <= val) {
res.emplace_back(val, r - l);
}
}
T nv = val | (1ULL << (bit_size - b - 1));
T nnv = nv | ((1ULL << (bit_size - b - 1)) - 1);
if(nnv < bottom) {
return;
}
int ll = dicts[b].rank(1, l);
int rr = dicts[b].rank(1, r);
freq_list_dfs(b + 1, l - ll, r - rr, val, bottom, up, res);
freq_list_dfs(b + 1, ll + mids[b], rr + mids[b], nv, bottom, up, res);
}
std::vector<freq_list_data> freq_list(int l, int r, T bottom, T up) const {
std::vector<freq_list_data> res;
freq_list_dfs(0, l, r, 0, bottom, up, res);
return res;
}
struct rect_data {
int idx;
T val;
rect_data(int i, T v) : idx(i), val(v) {}
};
// O(K * logM). K := res.size().
// return {{[idx], [val]}...}
// Each [val] satisfies bottom <= val < up and in [l..r)
// [idx] is the index of the [val].
std::vector<rect_data> get_rect(int l, int r, T bottom, T up) const {
auto freq = freq_list(l, r, bottom, up);
std::vector<rect_data> res;
for(auto& fd : freq) {
for(int i = 0; i < fd.count; ++i) {
res.emplace_back(select(fd.val, i, l), fd.val);
}
}
return res;
}
private:
int length;
int bit_size;
T max_val;
std::vector<fully_indexable_dictionary> dicts;
std::vector<int> mids;
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll d;cin>>d;
vector<ll> x(d);
for(int i=0;i<d;i++){
cin>>x[i];
x[i]+=1e9;
}
wavelet_matrix<ll> w(x);
ll q;cin>>q;
for(int i=0;i<q;i++){
ll l,r,e;cin>>l>>r>>e;
l--;r--;
ll a=min(x[l],x[r]),b=max(x[l],x[r]);
//a+=1e9;b+=1e9;
ll ans1=w.rank_lt(a-e,l,r+1);
ll ans2=(r-l+1)-w.rank_lt(b+e+1,l,r+1);
//cout<<ans1<<" "<<ans2<<endl;
cout<<ans1+ans2<<endl;
}
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 3;
const int I = 1e4 + 4;
const int Q = 3e4 + 4;
const int K = 1e3 + 3;
const int logQ = 16;
const int mod = 1e9 + 7;
const int p = 1e7 + 19;
int n, k;
int v[N + I];
int w[N + I];
int idx;
int q;
int type[Q];
int val[Q];
int tin[N + I];
int tout[N + I];
int dp[logQ * K];
void print(int l, int r) {
int cur = 1;
int res = 0;
for (int i = l; i <= r; ++i) {
res = (res + 1LL * cur * dp[i]) % mod;
cur = (1LL * cur * p) % mod;
}
printf("%d\n", res);
}
void solve(int l, int r, int pl, int pr, int last) {
bool ok = 0;
for (int i = l; i <= r; ++i) {
if (type[i] == 3) {
ok = 1;
break;
}
}
if (!ok) {
return;
}
for (int i = 1; i <= k; ++i) {
dp[last + i] = dp[last + i - k];
}
int mid = pl + pr >> 1;
if (l == pl) {
for (int i = mid + 1; i <= pr; ++i) {
if (type[i] == 2 && tin[val[i]] < l) {
int who = val[i];
for (int j = k; j >= w[who]; --j) {
dp[j + last] =
max(dp[j + last],
((j > w[who]) ? dp[j + last - w[who]] : 0) + v[who]);
}
}
}
} else {
for (int i = pl; i <= mid; ++i) {
if (type[i] == 1 && tout[val[i]] > r) {
int who = val[i];
for (int j = k; j >= w[who]; --j) {
dp[j + last] =
max(dp[j + last],
((j > w[who]) ? dp[j + last - w[who]] : 0) + v[who]);
}
}
}
}
if (l < r) {
int mid = l + r >> 1;
solve(l, mid, l, r, last + k);
solve(mid + 1, r, l, r, last + k);
} else {
print(last + 1, last + k);
}
}
int main() {
scanf("%d %d", &n, &k);
idx = 0;
for (int i = 1; i <= n; ++i) {
++idx;
scanf("%d %d", v + idx, w + idx);
tin[idx] = 0;
tout[idx] = Q;
}
scanf("%d", &q);
for (int i = 1; i <= q; ++i) {
scanf("%d", type + i);
if (type[i] == 1) {
++idx;
scanf("%d %d", v + idx, w + idx);
val[i] = idx;
tin[idx] = i;
tout[idx] = Q;
} else if (type[i] == 2) {
scanf("%d", val + i);
tout[val[i]] = i;
}
}
for (int i = 1; i <= idx; ++i) {
if (tout[i] == Q && tin[i] == 0) {
for (int j = k; j >= w[i]; --j) {
dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
}
}
}
if (q == 1) {
print(1, k);
} else {
solve(1, 1 + q >> 1, 1, q, k);
solve((1 + q >> 1) + 1, q, 1, q, k);
}
}
| 11 | CPP |
n=int(input())
a=sorted(map(int,input().split()))
m=int(input())
b=sorted(map(int,input().split()))
print(a[-1],b[-1]) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y;
cin >> n >> x >> y;
if (x == n / 2 || x == n / 2 + 1) {
if (y == n / 2 || y == n / 2 + 1) {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vpii = vector<pii>;
using vpll = vector<pll>;
using vpdd = vector<pdd>;
template <typename T>
void ckmin(T& a, const T& b) {
a = min(a, b);
}
template <typename T>
void ckmax(T& a, const T& b) {
a = max(a, b);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
namespace __input {
template <class T1, class T2>
void re(pair<T1, T2>& p);
template <class T>
void re(vector<T>& a);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& x) {
string t;
re(t);
x = stod(t);
}
template <class Arg, class... Args>
void re(Arg& first, Args&... rest) {
re(first);
re(rest...);
}
template <class T1, class T2>
void re(pair<T1, T2>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& a) {
for (int i = 0; i < (int((a).size())); i++) re(a[i]);
}
template <class T, size_t SZ>
void re(array<T, SZ>& a) {
for (int i = 0; i < (SZ); i++) re(a[i]);
}
} // namespace __input
using namespace __input;
namespace __output {
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T, size_t SZ>
void pr(const array<T, SZ>& x);
template <class T>
void pr(const vector<T>& x);
template <class T>
void pr(const set<T>& x);
template <class T1, class T2>
void pr(const map<T1, T2>& x);
template <class T>
void pr(const T& x) {
cout << x;
}
template <class Arg, class... Args>
void pr(const Arg& first, const Args&... rest) {
pr(first);
pr(rest...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
pr("{", x.first, ", ", x.second, "}");
}
template <class T, bool pretty = true>
void prContain(const T& x) {
if (pretty) pr("{");
bool fst = 1;
for (const auto& a : x) pr(!fst ? pretty ? ", " : " " : "", a), fst = 0;
if (pretty) pr("}");
}
template <class T>
void pc(const T& x) {
prContain<T, false>(x);
pr("\n");
}
template <class T, size_t SZ>
void pr(const array<T, SZ>& x) {
prContain(x);
}
template <class T>
void pr(const vector<T>& x) {
prContain(x);
}
template <class T>
void pr(const set<T>& x) {
prContain(x);
}
template <class T1, class T2>
void pr(const map<T1, T2>& x) {
prContain(x);
}
void ps() { pr("\n"); }
template <class Arg>
void ps(const Arg& first) {
pr(first);
ps();
}
template <class Arg, class... Args>
void ps(const Arg& first, const Args&... rest) {
pr(first, " ");
ps(rest...);
}
} // namespace __output
using namespace __output;
namespace __algorithm {
template <typename T>
void dedup(vector<T>& v) {
sort((v).begin(), (v).end());
v.erase(unique((v).begin(), (v).end()), v.end());
}
template <typename T>
typename vector<T>::const_iterator find(const vector<T>& v, const T& x) {
auto it = lower_bound((v).begin(), (v).end(), x);
return it != v.end() && *it == x ? it : v.end();
}
template <typename T>
size_t index(const vector<T>& v, const T& x) {
auto it = find(v, x);
assert(it != v.end() && *it == x);
return it - v.begin();
}
template <typename T1, typename T2>
typename vector<pair<T1, T2>>::iterator lower_bound(
const vector<pair<T1, T2>>& v, const T1& x) {
return lower_bound(
(v).begin(), (v).end(), x,
[](pair<T1, T2> a, pair<T1, T2> b) { return a.first < b.first; });
}
template <typename T1, typename T2>
typename vector<pair<T1, T2>>::iterator upper_bound(
const vector<pair<T1, T2>>& v, const T1& x) {
return upper_bound(
(v).begin(), (v).end(), x,
[](pair<T1, T2> a, pair<T1, T2> b) { return a.first < b.first; });
}
} // namespace __algorithm
using namespace __algorithm;
struct __monostate {
friend istream& operator>>(istream& is,
const __attribute__((unused)) __monostate& ms) {
return is;
}
friend ostream& operator<<(ostream& os,
const __attribute__((unused)) __monostate& ms) {
return os;
}
} ms;
namespace __io {
FILE* setIn(string second) { return freopen(second.c_str(), "r", stdin); }
FILE* setOut(string second) { return freopen(second.c_str(), "w", stdout); }
void setIO(string second = "") {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << setprecision(15);
if (int((second).size())) {
setIn(second + ".in"), setOut(second + ".out");
}
}
} // namespace __io
using namespace __io;
int main() {
setIO();
int N, K;
re(N, K);
vll p;
for (int i = 0; i < (N); i++) {
ll v;
re(v);
if (p.empty() || p.back() != v) p.push_back(v);
}
int first = 0;
while (first + 1 < int((p).size()) && p[first] > p[first + 1]) first++;
p.erase(p.begin(), p.begin() + first);
N = int((p).size());
vll extrema;
for (int i = 0; i < (N); i++) {
if ((i == 0 || p[i - 1] > p[i]) && (i + 1 == N || p[i] < p[i + 1])) {
extrema.push_back(p[i]);
}
if ((i == 0 || p[i - 1] < p[i]) && (i + 1 == N || p[i] > p[i + 1])) {
extrema.push_back(p[i]);
}
}
if (int((extrema).size()) % 2) {
extrema.pop_back();
}
ll profit = 0;
vector<ll> legs;
legs.push_back(LLONG_MAX / 2);
for (int i = 0; i < (int((extrema).size()) - 1); i++) {
if (i % 2 == 0) profit += extrema[i + 1] - extrema[i];
legs.push_back(abs(extrema[i + 1] - extrema[i]));
}
legs.push_back(LLONG_MAX / 2);
int M = max(0, int((extrema).size()) / 2 - K);
while (M) {
vector<pair<ll, int>> v(int((legs).size()));
for (int i = 0; i < (int((v).size())); i++) v[i] = make_pair(legs[i], i);
if (3 * M < int((v).size())) {
nth_element(v.begin(), v.begin() + 3 * M, v.end());
}
nth_element(v.begin(), v.begin() + M, min(v.end(), v.begin() + 3 * M));
vll LEGS;
int m = 0;
bool big = false;
for (int i = 0; i < (int((legs).size())); i++) {
if (make_pair(legs[i], i) < v[M] && LEGS.back() > legs[i] &&
legs[i] <= legs[i + 1]) {
m++;
profit -= legs[i];
LEGS.back() += -legs[i] + legs[i + 1];
i++;
big = false;
} else if (3 * M < int((v).size()) && make_pair(legs[i], i) >= v[3 * M]) {
if (big) {
LEGS.back() += legs[i];
} else {
LEGS.push_back(legs[i]);
big = true;
}
} else {
LEGS.push_back(legs[i]);
big = false;
}
}
M -= m;
legs = LEGS;
}
ps(profit);
return 0;
}
| 12 | CPP |
t = int(input())
for _ in range (t):
x1,y1,x2,y2 = map(int, input().split())
print (1 + abs(x2-x1)*abs(y1-y2)) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int mod = 1e9 + 7;
struct SAM {
int n, tot, last;
int ch[N][26], dep[N], fa[N];
int root[N], ls[N * 20], rs[N * 20], cnt;
vector<int> G[N];
void init() {
tot = last = 1;
memset(ch[1], 0, sizeof(ch[1]));
}
inline int newnode(int _dep) {
dep[++tot] = _dep;
memset(ch[tot], 0, sizeof(ch[tot]));
return tot;
}
void add(int alp) {
++n;
alp -= 'a';
int u, p = newnode(dep[last] + 1);
for (u = last; u && !ch[u][alp]; u = fa[u]) ch[u][alp] = p;
if (!u)
fa[p] = 1;
else {
int v = ch[u][alp];
if (dep[v] == dep[u] + 1)
fa[p] = v;
else {
int nv = newnode(dep[u] + 1);
fa[nv] = fa[v];
fa[v] = fa[p] = nv;
memcpy(ch[nv], ch[v], sizeof(ch[v]));
for (; u && ch[u][alp] == v; u = fa[u]) ch[u][alp] = nv;
}
}
last = p;
}
int build(int l, int r, int p) {
if (l == r) return ++cnt;
int mid = l + r >> 1;
int now = ++cnt;
if (p <= mid)
ls[now] = build(l, mid, p);
else
rs[now] = build(mid + 1, r, p);
return now;
}
int merge(int x, int y) {
if (x == 0 || y == 0) return x + y;
int now = ++cnt;
ls[now] = merge(ls[x], ls[y]);
rs[now] = merge(rs[x], rs[y]);
return now;
}
void dfs(int x) {
for (int i = 0; i < G[x].size(); ++i) {
int u = G[x][i];
dfs(u);
root[x] = merge(root[x], root[u]);
}
}
void build_segtree(char* s) {
int now = 1;
int n = strlen(s + 1);
for (int i = 1; i <= n; ++i) {
now = ch[now][s[i] - 'a'];
root[now] = build(1, n, i);
}
for (int i = 1; i <= tot; ++i) G[fa[i]].push_back(i);
dfs(1);
}
string ans;
bool chk(int k, int l, int r, int p, int q) {
if (k == 0) return false;
if (l >= p && r <= q) return true;
if (l > q || r < p) return false;
int mid = l + r >> 1;
return chk(ls[k], l, mid, p, q) || chk(rs[k], mid + 1, r, p, q);
}
bool check(int l, int r, int p) { return chk(p, 1, n, l, r); }
bool solve(int now, int l, int r, char* s) {
if (l > r) return false;
if (*s == 0) {
for (int i = 0; i < 26; i++) {
if (ch[now][i] && check(l, r, root[ch[now][i]])) {
ans.push_back('a' + i);
return true;
}
}
return false;
} else {
int i = *s - 'a';
if (ch[now][i] && check(l, r, root[ch[now][i]]) &&
solve(ch[now][i], l + 1, r, s + 1)) {
ans.push_back('a' + i);
return true;
}
for (i = i + 1; i < 26; ++i) {
if (ch[now][i] && check(l, r, root[ch[now][i]])) {
ans.push_back('a' + i);
return true;
}
}
return false;
}
}
} sam;
int n, m;
char s[N];
int main() {
sam.init();
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) sam.add(s[i]);
sam.build_segtree(s);
scanf("%d", &m);
while (m--) {
int l, r;
scanf("%d %d %s", &l, &r, s + 1);
sam.ans.clear();
if (!sam.solve(1, l, r, s + 1))
printf("-1\n");
else {
reverse(sam.ans.begin(), sam.ans.end());
printf("%s\n", sam.ans.c_str());
}
}
}
| 14 | CPP |
import math
a, b = map(int, input().split())
if a < b:
print(math.factorial(a))
elif a > b:
print(math.factorial(b))
elif a == b:
print(math.factorial(a))
| 7 | PYTHON3 |
Subsets and Splits