solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
def solve(ab,i):
return (ab - 1) // i
q = int(input())
for i in range(q):
a, b = map(int, input().split())
if a > b:
a, b = b, a
ans = a - 1
start_a = a + 1
num = int((a * b) ** 0.5)
while True:
if solve(a*b, num) == solve(a*b, num + 1):
break
else:
num += 1
ans = num - 1
ans += (solve(a*b, num) - 1)
if a == b:
ans += 1
print(ans)
| 0 | PYTHON3 |
#include <bits/stdc++.h>
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 1000000000000000000
#define MOD 1000000007
typedef long long ll;
typedef pair<ll,ll> P;
int main(){
int n,l,r;
while(cin >> n >> l >> r,n+l+r){
vector<pair<ll,ll>> v;
REP(i,n){
int tmp;cin >> tmp;
v.PB(MP(tmp,i+1));
}
ll ans = 0;
for(int i = l;i <= r;i++){
bool flag = false;
for(int j = 0;j < n;j++){
if(i % v[j].FI == 0){
flag = true;
if(v[j].SE % 2 != 0)ans++;
break;
}
}
if(!flag && n % 2 == 0)ans++;
}
cout << ans << endl;
}
return 0;
}
| 0 | CPP |
s=input()
for i in range(2**3):
t=s[0]
for j in range(3):
if i%2:t+='+'
else:t+='-'
i//=2
t+=s[j+1]
if eval(t+'==7'):
print(t+'=7')
exit() | 0 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
const int N=2e5+10;
typedef long long ll;
ll s1[N],s2[N];
int n;
int main(){
scanf("%d",&n);
for(int i=1,x,y;i<=n;i++){
scanf("%d%d",&x,&y);
s1[i]=x+y;
s2[i]=x-y;
}
sort(s1+1,s1+1+n);
sort(s2+1,s2+1+n);
printf("%lld\n",max(s1[n]-s1[1],s2[n]-s2[1]));
return 0;
} | 0 | CPP |
N = int(input())
A = [list(map(int, input().split())) for _ in range(N)]
dp = A
cnt = 0
for i in range(N):
for j in range(N):
if all(dp[i][j] < dp[i][k] + dp[k][j] for k in range(N) if k != i and k != j):
cnt += dp[i][j]
if any(dp[i][j] > dp[i][k] + dp[k][j] for k in range(N)):
print(-1)
exit()
print(cnt // 2)
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
map<int, pair<int, int> > Map;
int n, m, i, s, f, t, l, r;
bool Check(int a) { return ((l <= a) && (a <= r)); }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> s >> f;
for (i = 1; i <= m; i++) {
cin >> t >> l >> r;
Map[t] = make_pair(l, r);
}
t = 0;
while (true) {
t++;
l = Map[t].first;
r = Map[t].second;
if (s < f) {
if ((!Check(s)) && (!Check(s + 1))) {
cout << "R";
s++;
} else
cout << "X";
} else if (s > f) {
if ((!Check(s - 1)) && (!Check(s))) {
cout << "L";
s--;
} else
cout << "X";
} else
break;
}
cout << '\n';
return 0;
}
| 8 | CPP |
for s in[*open(0)][2::2]:
a=[0]*101
for x in s.split():a[int(x)]+=1
i=a.index(0);a[i]=1;print(i+a.index(1)) | 7 | PYTHON3 |
def Remove_Duplicates(arr):
res = []
count = 0
for i in arr[::-1]:
if i not in res:
res.append(i)
count += 1
print(count)
print(*res[::-1])
if __name__ == '__main__':
n = int(input())
arr = list(map(int, input().split()))
Remove_Duplicates(arr) | 7 | PYTHON3 |
#include <bits/stdc++.h>
double PI = acos(-1.0);
using namespace std;
int mod = 1000000007;
int inf = INT_MAX;
int minf = INT_MIN;
int main() {
int n;
cin >> n;
int a[n];
long long int sum = 0, cnt = 0;
vector<int> v;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
sum += a[i];
if (sum < 0) {
cout << "-1";
return 0;
}
}
if (sum != 0) {
cout << "-1";
return 0;
}
sum = 0;
set<int> s;
for (int i = 0; i < n; i++) {
cnt++;
if (a[i] > 0) {
if (!s.count(a[i]))
s.insert(a[i]);
else {
cout << "-1";
return 0;
}
}
if (a[i] < 0) {
int x = (-1) * a[i];
if (s.find(x) == s.end()) {
cout << "-1";
return 0;
}
}
sum += a[i];
if (sum == 0) {
v.push_back(cnt);
cnt = 0;
s.clear();
}
}
cout << v.size() << endl;
for (int i : v) cout << i << " ";
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s, q;
cin >> s >> q;
int curr = 0;
int n = q.length();
for (int i = 0; i < n; i++) {
if (s[curr] == q[i]) curr++;
}
cout << curr + 1;
}
| 7 | CPP |
#include <bits/stdc++.h>
const int N = 1e2 + 10;
const int inf = 0x3f3f3f3f;
const double PI = acos(-1);
const double eps = 1e-9;
using namespace std;
const long long mod = 1e9 + 7;
int ans, t, i, j, k, n, m;
int a[N];
char s[N][5];
int main() {
while (scanf("%d%d", &n, &m) != EOF) {
for (int i = 1; i <= 4; i++) {
for (int j = 1; j <= n; j++) {
s[j][i] = '.';
}
}
if (m % 2) {
s[n / 2 + 1][3] = '#';
m--;
}
{
for (int i = 2; i < 4; i++) {
if (m == 0) break;
for (int j = 2; j < n;) {
s[j][i] = '#';
m--;
if (j <= n / 2)
j = (n - j) + 1;
else
j = (n - j) + 2;
if (j == (n / 2 + 1) || m == 0) break;
}
}
if (m) {
for (int i = 2; i < 4; i++) {
s[n / 2 + 1][i] = '#';
m--;
if (m == 0) break;
}
}
printf("YES\n");
for (int i = 1; i <= 4; i++) {
for (int j = 1; j <= n; j++) {
printf("%c", s[j][i]);
}
printf("\n");
}
continue;
}
}
return 0;
}
| 8 | CPP |
S=input()
W="x"*len(S)
print(W) | 0 | PYTHON3 |
n = int(input())
print("I hate", end=" ")
for i in range(1, n):
print("that", end=" ")
if(i%2==0):
print("I hate", end=" ")
else:
print("I love", end=" ")
print("it", end=" ")
| 7 | PYTHON3 |
#include<cstdio>
#define min(a,b) (a<b?a:b)
#define abs(x) (x>0?(x):-(x))
int n,x,y,ans[2333];
int main(){
scanf("%d%d%d",&n,&x,&y);
for(int i=1;i<=n;i++)
for(int j=i+1;j<=n;j++){
int far=min(j-i,min(abs(i-x)+abs(j-y)+1,abs(i-y)+abs(j-x)+1));
ans[far]++;
}
for(int i=1;i<n;i++)printf("%d\n",ans[i]);
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxint = -1u >> 1;
const double pi = acos(-1.0);
const int maxn = 100000 + 100;
int n, tmp, tmp0;
bool islucky(int x) {
bool rst = true;
while (x > 0) {
tmp = x % 10;
if (tmp == 4 || tmp == 7) {
x /= 10;
continue;
}
rst = false;
break;
}
return rst;
}
bool can, iss;
int now;
struct node {
int v, w;
int noww;
bool operator<(const node& a) const {
if (v == a.v) return w < a.w;
return v < a.v;
}
void inp(int x) {
scanf("%d", &v);
w = x;
}
} sorted[maxn], org[maxn];
int findidx(const node& x) {
int l = 0, r = n - 1, mid;
while (l <= r) {
mid = ((l + r) >> 1);
if (sorted[mid] < x)
l = mid + 1;
else
r = mid - 1;
}
return l;
}
vector<pair<int, int> > ans;
int main() {
while (scanf("%d", &n) != EOF) {
ans.clear();
can = false;
iss = true;
now = -1;
for (int i = 0; i < n; i++) {
org[i].inp(i);
sorted[i] = org[i];
sorted[i].noww = i;
if (!can && islucky(org[i].v)) {
can = true;
now = i;
}
if (i == 0) continue;
if (iss && org[i].v < org[i - 1].v) iss = false;
}
if (!can && !iss) {
puts("-1");
continue;
}
if (iss) {
puts("0");
continue;
}
sort(sorted, sorted + n);
for (int i = 0; i < n; i++) {
tmp = sorted[i].noww;
if (i != tmp) {
if (now != i) {
tmp0 = findidx(org[i]);
sorted[tmp0].noww = now;
tmp0 = findidx(org[now]);
sorted[tmp0].noww = i;
swap(org[now], org[i]);
ans.push_back(make_pair(now + 1, i + 1));
}
now = i;
tmp0 = findidx(org[now]);
sorted[tmp0].noww = tmp;
tmp0 = findidx(org[tmp]);
sorted[tmp0].noww = now;
swap(org[now], org[tmp]);
ans.push_back(make_pair(now + 1, tmp + 1));
now = tmp;
}
}
tmp = (int)ans.size();
if (tmp > 2 * n)
while (1)
;
printf("%d\n", tmp);
for (int i = 0; i < tmp; i++)
printf("%d %d\n", ans[i].first, ans[i].second);
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int h, w, th;
string s[10];
int t[1001];
int sub(int q) {
int d = __builtin_popcount(q) + 1;
vector<int> masks(d);
int cnt = 0;
for (int i = 0; i < h; ++i) {
masks[cnt] |= 1 << i;
if ((q >> i) & 1) ++cnt;
}
int ans = d - 1;
vector<int> cur(d);
for (int j = 0; j < w; ++j) {
vector<int> del(d);
for (int k = 0; k < d; ++k) {
del[k] = __builtin_popcount(t[j] & masks[k]);
cur[k] += del[k];
}
if (*max_element(del.begin(), del.end()) > th) return 1e9;
if (*max_element(cur.begin(), cur.end()) > th) {
cur = del;
++ans;
}
}
return ans;
}
int main() {
cin >> h >> w >> th;
for (int i = 0; i < h; ++i) cin >> s[i];
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
t[j] |= (s[i][j] - '0') << i;
}
}
++w;
int mn = 1e9;
for (int q = 0; q < (1 << (h - 1)); ++q) {
mn = min(mn, sub(q));
}
cout << mn << endl;
}
| 0 | CPP |
s = bin(int(input()))[2:]
sol = []
for i, j in enumerate(s):
if j == "1":
sol.append(str(len(s) - i))
print(" ".join(sol))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
using LL = long long;
using VL = vector<LL>;
using VVL = vector<VL>;
using PLL = pair<LL, LL>;
using VS = vector<string>;
#define ALL(a) begin((a)),end((a))
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define SZ(a) int((a).size())
#define SORT(c) sort(ALL((c)))
#define RSORT(c) sort(RALL((c)))
#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define FF first
#define SS second
template<class S, class T>
istream& operator>>(istream& is, pair<S,T>& p){
return is >> p.FF >> p.SS;
}
template<class S, class T>
ostream& operator<<(ostream& os, const pair<S,T>& p){
return os << p.FF << " " << p.SS;
}
template<class T>
void maxi(T& x, T y){
if(x < y) x = y;
}
template<class T>
void mini(T& x, T y){
if(x > y) x = y;
}
const double EPS = 1e-10;
const double PI = acos(-1.0);
const LL MOD = 1e9+7;
int acc1[5010][5010];
int acc2[5010][5010];
void add(int x, int y, int d){
--acc1[x-d][y-d+1];
++acc1[x+1][y+2];
++acc2[x-d][y-d];
--acc2[x+1][y-d];
}
int get(int x, int y){
return acc1[x][y] + acc2[x][y];
}
int main(){
cin.tie(0);
ios_base::sync_with_stdio(false);
int N, M;
cin >> N >> M;
REP(i,M){
int a, b, x;
cin >> a >> b >> x;
add(a+x, b+x, x);
}
REP(x,N+1) REP(y,N+1){
acc1[x][y] += (x>=1&&y>=1? acc1[x-1][y-1]: 0) + (y>=1? acc1[x][y-1]: 0) - (x>=1&&y>=2? acc1[x-1][y-2]: 0);
acc2[x][y] += (x>=1? acc2[x-1][y]: 0) + (y>=1? acc2[x][y-1]: 0) - (x>=1&&y>=1? acc2[x-1][y-1]: 0);
}
int ans = 0;
for(int x=1;x<=N;++x){
for(int y=1;y<=x;++y){
if(get(x,y) > 0)
++ans;
}
}
cout << ans << endl;
return 0;
} | 0 | CPP |
for _ in range(int(input())):
n=int(input())
ans=0
p=-(10**10)
for i in map(int,input().split()):
if i<p:
k=len(bin(p-i))-2
ans=max(ans,k)
else:p=i
print(ans) | 9 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
inline void rd(int &x) {
int k;
int m = 0;
x = 0;
for (;;) {
k = getchar();
if (k == '-') {
m = 1;
break;
}
if ('0' <= k && k <= '9') {
x = k - '0';
break;
}
}
for (;;) {
k = getchar();
if (k < '0' || k > '9') {
break;
}
x = x * 10 + k - '0';
}
if (m) {
x = -x;
}
}
inline void rd(char &c) {
int i;
for (;;) {
i = getchar();
if (i != ' ' && i != '\n' && i != '\r' && i != '\t' && i != EOF) {
break;
}
}
c = i;
}
inline int rd(char c[]) {
int i;
int sz = 0;
for (;;) {
i = getchar();
if (i != ' ' && i != '\n' && i != '\r' && i != '\t' && i != EOF) {
break;
}
}
c[sz++] = i;
for (;;) {
i = getchar();
if (i == ' ' || i == '\n' || i == '\r' || i == '\t' || i == EOF) {
break;
}
c[sz++] = i;
}
c[sz] = '\0';
return sz;
}
inline void wt_L(char a) { putchar(a); }
inline void wt_L(int x) {
int s = 0;
int m = 0;
char f[10];
if (x < 0) {
m = 1;
x = -x;
}
while (x) {
f[s++] = x % 10;
x /= 10;
}
if (!s) {
f[s++] = 0;
}
if (m) {
putchar('-');
}
while (s--) {
putchar(f[s] + '0');
}
}
template <class S, class T>
inline S chmin(S &a, T b) {
if (a > b) {
a = b;
}
return a;
}
int N;
char S[300002];
int sz;
int lis[300002];
int main() {
int i, m;
int k;
int mn;
int y;
int f;
int cnt;
int res;
int res1;
int res2;
int ini;
rd(N);
rd(S);
k = mn = 0;
for (i = (0); i < (N); i++) {
if (S[i] == '(') {
k++;
} else {
k--;
}
chmin(mn, k);
}
if (k) {
wt_L(0);
wt_L('\n');
wt_L(1);
wt_L(' ');
wt_L(1);
wt_L('\n');
return 0;
}
k = 0;
res = res1 = res2 = 0;
for (i = (0); i < (N); i++) {
if (S[i] == '(') {
k++;
} else {
k--;
}
if (k == mn) {
res++;
lis[sz++] = i;
}
}
ini = res;
for (m = (0); m < (sz); m++) {
k = 0;
if (m == sz - 1) {
y = lis[0] + N;
} else {
y = lis[m + 1];
}
f = -1;
for (i = (lis[m] + 1); i < (y); i++) {
if (S[i % N] == '(') {
k++;
} else {
k--;
}
if (k < 2) {
f = -1;
cnt = 0;
}
if (k == 2 && f == -1) {
f = i;
}
if (k == 2) {
cnt++;
}
if (k == 2 && ini + cnt > res) {
res = ini + cnt;
res1 = f % N;
res2 = (i + 1) % N;
}
}
}
for (m = (0); m < (sz); m++) {
k = 0;
if (m == sz - 1) {
y = lis[0] + N;
} else {
y = lis[m + 1];
}
cnt = 0;
for (i = (lis[m] + 1); i < (y); i++) {
if (S[i % N] == '(') {
k++;
} else {
k--;
}
if (k == 1) {
cnt++;
}
}
if (cnt > res) {
res = cnt;
res1 = (lis[m] + 1) % N;
res2 = y % N;
}
}
wt_L(res);
wt_L('\n');
wt_L(res1 + 1);
wt_L(' ');
wt_L(res2 + 1);
wt_L('\n');
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
char m[1000][1000];
int n;
int main(void) {
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
m[i][j] = '.';
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
int j;
if (i % 2 == 0) {
j = 0;
} else {
j = 1;
}
for (; j < n; j += 2) {
ans += 1;
m[i][j] = 'C';
}
}
cout << ans << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cout << m[i][j];
}
cout << endl;
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int kN = 1e5 + 10;
int N, W, H;
int G[kN], P[kN], T[kN];
int answer[kN][2];
vector<int> same_pmt[kN * 2];
void process(vector<int> &a) {
vector<pair<int, int> > ans;
vector<pair<int, int> > hor, vert;
for (int i = 0; i < a.size(); i++) {
int u = a[i];
if (G[u] == 1) {
vert.push_back(make_pair(P[u], u));
ans.push_back(make_pair(P[u], H));
} else {
hor.push_back(make_pair(P[u], u));
ans.push_back(make_pair(W, -P[u]));
}
}
sort(ans.begin(), ans.end());
sort(hor.begin(), hor.end());
sort(vert.begin(), vert.end());
int cnt = 0;
for (int i = hor.size() - 1; i >= 0; i--) {
int id = hor[i].second;
answer[id][0] = ans[cnt].first;
answer[id][1] = ans[cnt].second;
cnt++;
}
for (int i = 0; i < vert.size(); i++) {
int id = vert[i].second;
answer[id][0] = ans[cnt].first;
answer[id][1] = ans[cnt].second;
cnt++;
}
}
int main() {
cin >> N >> W >> H;
for (int i = 1; i <= N; i++) {
cin >> G[i] >> P[i] >> T[i];
same_pmt[P[i] - T[i] + kN].push_back(i);
}
for (int i = 0; i < 2 * kN; i++)
if (same_pmt[i].size()) {
process(same_pmt[i]);
}
for (int i = 1; i <= N; i++) {
if (answer[i][1] < 0) answer[i][1] = -answer[i][1];
printf("%d %d\n", answer[i][0], answer[i][1]);
}
return 0;
}
| 10 | CPP |
def winner(n,a):
if a==[1]*n:
if n%2==0:
return 'Second'
else:
return 'First'
x = a.count(1)
if x==0:
return 'First'
for i in range(n):
if a[i]!=1:
k = i
break
if i%2!=0:
return 'Second'
else:
return 'First'
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int,input().split()))
print(winner(n,a)) | 8 | PYTHON3 |
import math
tests = int(input())
for t in range(tests):
n = int(input())
ls = list(map(int, input().split()))
ls = sorted(list(ls))[::-1]
res = [ls[0]]
curr = ls[0]
new_ls = []
removed=False
for item in ls:
if item != curr:
new_ls.append(item)
else:
if removed:
new_ls.append(item)
else:
removed=True
ls = new_ls
while len(ls)>0:
max_item = None
max_gcd = 0
new_ls = []
for item in ls:
temp = math.gcd(item, curr)
if temp > max_gcd:
max_item = item
max_gcd = temp
res.append(max_item)
removed = False
for item in ls:
if item != max_item:
new_ls.append(item)
else:
if removed:
new_ls.append(item)
else:
removed=True
ls = new_ls
curr = max_gcd
print(' '.join(list(map(str,res)))) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, m, x;
cin >> t;
while (t--) {
cin >> n;
int ar[100000], c = 1;
for (int i = 0; i < n; i++) cin >> ar[i];
sort(ar, ar + n);
for (int i = 0; i < n - 1; i++) {
if (ar[i] != ar[i + 1]) c++;
}
cout << c << endl;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using ll = long long;
using namespace std;
const ll MOD = 1000000007;
ll n, dp[4000][4000], sum[4000];
string s;
int main(){
cin >> n >> s;
rep(i,n) dp[0][i] = 1; // 先頭を選択し終えた状態
rep(i,n-1){ // 不等号ごとにDPする
// 累積和
rep(j,n-i) sum[j+1] = ( dp[i][j] + sum[j] ) % MOD;
// DP遷移
if(s[i] == '>') rep(j,n-1-i) dp[i+1][j] = sum[j+1];
else rep(j,n-1-i) dp[i+1][j] = ( sum[n-i] - sum[j+1] + MOD) % MOD;
}
cout << dp[n-1][0] << endl;
return 0;
} | 0 | CPP |
# 1097B.py
cnt = []
def sum_zero(x,i,cnt):
if x%360 == 0 and i==n:
# print(x)
cnt.append(1)
elif i==n:
return 0
else:
sum_zero(x+l[i],i+1,cnt)
sum_zero(x-l[i],i+1,cnt)
n = int(input())
l = []
for i in range(n):
a = int(input())
l.append(a)
sum_zero(0,0,cnt)
if len(cnt)>0:
print('YES')
else:
print('NO') | 8 | PYTHON3 |
#include<bits/stdc++.h>
#define L(i, j, k) for(int i = j, i##E = k; i <= i##E; i++)
#define R(i, j, k) for(int i = j, i##E = k; i >= i##E; i--)
#define ll long long
#define pii pair<int, int>
#define db double
#define x first
#define y second
#define ull unsigned long long
#define sz(a) ((int) (a).size())
#define vi vector<int>
using namespace std;
const int N = 4e5 + 7, mod = 998244353;
int ns, n, m;
int fac[N], inv[N], ifac[N];
void init(int x) {
fac[0] = ifac[0] = inv[1] = 1;
L(i, 2, x) inv[i] = (ll) inv[mod % i] * (mod - mod / i) % mod;
L(i, 1, x) fac[i] = (ll) fac[i - 1] * i % mod, ifac[i] = (ll) ifac[i - 1] * inv[i] % mod;
}
int C(int x, int y) {
return x < y || y < 0 ? 0 : (ll) fac[x] * ifac[y] % mod * ifac[x - y] % mod;
}
int main() {
cin >> n >> m, init(max(n, m) * 4);
L(z, 1, m - 1) {
int now = 0;
R(r1, n - 1, 1) {
(now += (ll) C(r1 + m - z - 1, m - z - 1) * C(n - r1 + m - z - 1, m - z) % mod) %= mod;
(ns += (ll) C(r1 + z - 1, z) * C(n - r1 + z - 1, z - 1) % mod * now % mod) %= mod;
}
}
L(p, 1, n) {
int now = 0;
L(z1, 1, m - 1) {
(now += (ll) C(n - p + z1 - 2, z1 - 2) * C(n - p + m - z1, m - z1 + 1) % mod) %= mod;
(ns += (ll) C(p + z1 - 1, z1) * C(p + m - z1 - 1, m - z1 - 1) % mod * now % mod) %= mod;
}
}
ns = (ll) ns * 2 % mod;
cout << ns << "\n";
return 0;
} | 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct wall {
long long no, x, t;
friend bool operator<(wall a, wall b) {
if (a.x != b.x) return a.x < b.x;
return a.t < b.t;
}
} w[110000 << 1];
struct Point {
long long x, y, type, no;
friend bool operator<(Point a, Point b) { return a.y - a.x < b.y - b.x; }
} p[110000 * 50];
long long tot;
long long L[110000], R[110000], T[110000];
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
q;
bool vis[110000];
long long ans[110000];
int main() {
long long n, m, i, k, now, cnt;
scanf("%I64d%I64d", &m, &n);
for (i = 1; i <= n; i++) {
scanf("%I64d%I64d%I64d", L + i, R + i, T + i);
w[i << 1].no = w[i << 1 | 1].no = i;
w[i << 1].x = L[i], w[i << 1 | 1].x = R[i];
w[i << 1].t = w[i << 1 | 1].t = T[i];
}
sort(w + 2, w + n + n + 2);
q.push(pair<long long, long long>(0x3f3f3f3f3f3f3f3fll, 0));
vis[0] = 1;
for (i = 2; i <= n + n + 1; i++) {
if (!vis[w[i].no]) {
while (!q.empty() && !vis[q.top().second]) q.pop();
if (!q.empty() && w[i].t < q.top().first) {
tot++;
p[tot].x = w[i].x;
p[tot].y = q.top().first;
p[tot].type = 1;
tot++;
p[tot].x = w[i].x;
p[tot].y = w[i].t;
p[tot].type = -1;
}
q.push(pair<long long, long long>(w[i].t, w[i].no));
vis[w[i].no] = 1;
} else {
while (!q.empty() && !vis[q.top().second]) q.pop();
if (q.top().second == w[i].no) {
q.pop();
while (!q.empty() && !vis[q.top().second]) q.pop();
tot++;
p[tot].x = w[i].x;
p[tot].y = w[i].t;
p[tot].type = 1;
tot++;
p[tot].x = w[i].x;
p[tot].y = q.top().first;
p[tot].type = -1;
}
vis[w[i].no] = 0;
}
}
for (i = 1; i <= m; i++) {
scanf("%I64d", &k);
tot++;
p[tot].type = 0;
p[tot].x = 0;
p[tot].y = k;
p[tot].no = i;
}
sort(p + 1, p + tot + 1);
for (i = 1, now = 0, cnt = 0; i <= tot; i++) {
now += cnt * (p[i].y - p[i].x - p[i - 1].y + p[i - 1].x);
cnt += p[i].type;
if (!p[i].type) ans[p[i].no] = now;
}
for (i = 1; i <= m; i++) printf("%I64d\n", ans[i]);
return 0;
}
| 10 | CPP |
s=input()
n=len(s)
if(len(s)%2):
print("-1")
exit()
a=abs(s.count('L')-s.count('R'))
b=abs(s.count('U')-s.count('D'))
print(min(a,b)+int(abs(a-b)//2)) | 8 | PYTHON3 |
#RAVENS
#TEAM_2
#ESSI-DAYI_MOHSEN-LORENZO
from math import sqrt
n,k = map(int,input().split())
p=[0]*100001
p[0]=1
p[1]=1
x=2
while x*x<100001:
if p[x] == 0:
for i in range(x+x,100001,x):
p[i]=1
x+=1
i = 2
res = 0
ans = list()
while n != 1:
if n % i == 0:
res+=1
n//=i
ans.append(i)
else:
for j in range(i+1,100001):
if p[j] ==0:
i=j
break
if res < k:
print(-1)
else:
print(*ans[:k-1],end=' ')
mul = 1
for i in range(k-1,len(ans)):
mul*=ans[i]
print(mul) | 7 | PYTHON3 |
t = int(input())
for i in range(t):
n = int(input())
a = list(map(int, input().split()))
s = 0
o = 0
sum1 = 0
for r in range(n):
if a[r] % 2 == 0:
s += 1
else:
o += 1
sum1 += a[r]
if sum1 % 2 == 1:
print('YES')
elif s != 0 and o != 0 and sum1 % 2 == 0:
print('YES')
else:
print('NO') | 7 | PYTHON3 |
#include<iostream>
using namespace std;
int main()
{
int n,t[110],m,p[110],x[110],ans = 0;
cin >> n;
for(int i=1; i<=n; i++){
cin >> t[i];
ans += t[i];
}
cin >> m;
for(int i=0; i<m; i++){
cin >> p[i] >> x[i];
cout << ans - t[p[i]] + x[i] << endl;
}
return 0;
}
| 0 | CPP |
n = int(input())
a = [list(input().split(sep = " reposted ")) for i in range(n)]
s = {"polycarp" : 1}
for i, k in a:
if k.lower() in s.keys():
s[i.lower()] = s[k.lower()] + 1
print(max(s.values())) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using cat = long long;
class IntervalTree {
struct node {
int l, r;
int son[2];
priority_queue<int> q, q_active;
int max_active, min_real;
};
vector<node> T;
vector<bool> deactivated, deleted;
void construct(int node_num) {
node n = T[node_num];
if (n.l + 1 == n.r) return;
for (int i = 0; i < 2; i++) {
if (i == 0)
n.r = (n.l + n.r) / 2;
else {
n.l = n.r;
n.r = T[node_num].r;
}
T[node_num].son[i] = T.size();
T.push_back(n);
construct(T[node_num].son[i]);
}
}
void clean(node& n) {
while (!n.q_active.empty() && deactivated[n.q_active.top()])
n.q_active.pop();
while (!n.q.empty() && deleted[n.q.top()]) n.q.pop();
n.min_real = -1;
if (n.son[0] != -1 && n.son[1] != -1)
n.min_real = min(T[n.son[0]].min_real, T[n.son[1]].min_real);
if (!n.q.empty() && n.q.top() > n.min_real) n.min_real = n.q.top();
n.max_active = n.q_active.empty() ? -1 : n.q_active.top();
if (n.son[0] != -1)
n.max_active = max(n.max_active, T[n.son[0]].max_active);
if (n.son[1] != -1)
n.max_active = max(n.max_active, T[n.son[1]].max_active);
if (n.min_real > n.max_active) n.max_active = -1;
}
public:
IntervalTree(int N, int max_val)
: T{{0,
N,
{-1, -1},
priority_queue<int>(),
priority_queue<int>(),
-1,
-1}},
deactivated(max_val, 0),
deleted(max_val, 0) {
construct(0);
}
void add(int l, int r, int val, int node_num = 0) {
node& n = T[node_num];
if (n.l >= r || l >= n.r) return;
if (n.l == l && n.r == r) {
n.q.push(val);
n.q_active.push(val);
clean(n);
return;
}
add(l, min(r, (n.l + n.r) / 2), val, n.son[0]);
add(max(l, (n.l + n.r) / 2), r, val, n.son[1]);
clean(n);
}
void remove(int l, int r, int val, int node_num = 0) {
node& n = T[node_num];
if (n.l >= r || l >= n.r) return;
if (n.l == l && n.r == r) {
deleted[val] = true;
deactivated[val] = true;
clean(n);
return;
}
remove(l, min(r, (n.l + n.r) / 2), val, n.son[0]);
remove(max(l, (n.l + n.r) / 2), r, val, n.son[1]);
clean(n);
}
void make_inactive(int l, int r, int val, int node_num = 0) {
node& n = T[node_num];
if (n.l >= r || l >= n.r) return;
if (n.l == l && n.r == r) {
deactivated[val] = true;
clean(n);
return;
}
make_inactive(l, min(r, (n.l + n.r) / 2), val, n.son[0]);
make_inactive(max(l, (n.l + n.r) / 2), r, val, n.son[1]);
clean(n);
}
int get_top() { return T[0].max_active; }
};
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(10);
int N;
cin >> N;
vector<int> x1(N), y1(N), x2(N), y2(N);
map<int, int> Mx, My;
srand(0);
for (int i = 0; i < N; i++) {
cin >> x1[i] >> y1[i] >> x2[i] >> y2[i];
Mx[x1[i]] = Mx[x2[i]] = My[y1[i]] = My[y2[i]] = 0;
}
int mx = 0, my = 0;
for (auto it = Mx.begin(); it != Mx.end(); it++) it->second = mx++;
for (auto it = My.begin(); it != My.end(); it++) it->second = my++;
vector<vector<int> > starts(mx), ends(mx);
for (int i = 0; i < N; i++) {
x1[i] = Mx[x1[i]];
x2[i] = Mx[x2[i]];
y1[i] = My[y1[i]];
y2[i] = My[y2[i]];
starts[x1[i]].push_back(i);
ends[x2[i]].push_back(i);
}
IntervalTree I(my, N);
vector<int> ans(N, 0);
for (int i = 0; i < mx; i++) {
for (auto it = starts[i].begin(); it != starts[i].end(); it++)
I.add(y1[*it], y2[*it], *it);
for (auto it = ends[i].begin(); it != ends[i].end(); it++)
I.remove(y1[*it], y2[*it], *it);
int max_active = I.get_top();
while (max_active != -1) {
ans[max_active] = 1;
I.make_inactive(y1[max_active], y2[max_active], max_active);
max_active = I.get_top();
}
}
int ans_sum = 1;
for (int i = 0; i < N; i++) ans_sum += ans[i];
cout << ans_sum << "\n";
return 0;
}
| 10 | CPP |
###
def is_ok_with_all_customers():
number_of_customers, current_temperature = tuple(map(int, input().split()))
customers_data = {}
for i in range(number_of_customers):
t, l, h = tuple(map(int, input().split()))
if t in customers_data:
customers_data[t] = (max(l, customers_data[t][0]), min(h, customers_data[t][1]))
else:
customers_data[t] = (l, h)
current_time = 0
current_temperature_range = (current_temperature, current_temperature)
for t, v in customers_data.items():
time_to_prepare = t - current_time
max_possible_temperate_for_guests = current_temperature_range[1] + time_to_prepare
min_possible_temperature_for_guests = current_temperature_range[0] - time_to_prepare
if max_possible_temperate_for_guests < v[0] or v[1] < min_possible_temperature_for_guests:
return 'NO'
current_temperature_range = (max(min_possible_temperature_for_guests, v[0]), min(max_possible_temperate_for_guests, v[1]))
#!!!
if current_temperature_range[0] > current_temperature_range[1]:
return 'NO'
#!!!
current_time = t
return 'YES'
#if __name__ == '__main__':
test_cases = int(input())
for _ in range(test_cases):
print(is_ok_with_all_customers())
| 9 | PYTHON3 |
#include <bits/stdc++.h>
int main() {
int n, k, i, s = 0;
char a[2] = {'a', 'b'}, b = 'c';
scanf("%d %d", &n, &k);
if (k > n) {
printf("-1");
} else if (n == 1 && k == 1)
printf("a");
else if (k == 1) {
printf("-1");
} else {
for (i = 0; i < (n - (k - 2)); i++) {
printf("%c", a[s]);
s = !s;
}
for (i = (n - (k - 2)); i < n; i++) {
printf("%c", b);
b++;
if (b - 'a' == 26) b = 'c';
}
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N;
string colour = "ROYGBIV";
int main() {
cin >> N;
for (int i = 0; i < N - N % 7; i++) cout << colour[i % 7];
for (int i = 0; i < N % 7; i++) cout << colour[i % 4 + 3];
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-8;
const double PI = acos(-1);
vector<string> cads;
char s[100000];
bool isAM(string s) {
int n = s.length();
if (n < 4) return false;
return s[n - 1] == 's' && s[n - 2] == 'o' && s[n - 3] == 'i' &&
s[n - 4] == 'l';
}
bool isAF(string s) {
int n = s.length();
if (n < 5) return false;
return s[n - 1] == 'a' && s[n - 2] == 'l' && s[n - 3] == 'a' &&
s[n - 4] == 'i' && s[n - 5] == 'l';
}
bool isNM(string s) {
int n = s.length();
if (n < 3) return false;
return s[n - 1] == 'r' && s[n - 2] == 't' && s[n - 3] == 'e';
}
bool isNF(string s) {
int n = s.length();
if (n < 4) return false;
return s[n - 1] == 'a' && s[n - 2] == 'r' && s[n - 3] == 't' &&
s[n - 4] == 'e';
}
bool isVM(string s) {
int n = s.length();
if (n < 6) return false;
return s[n - 1] == 's' && s[n - 2] == 'i' && s[n - 3] == 't' &&
s[n - 4] == 'i' && s[n - 5] == 'n' && s[n - 6] == 'i';
}
bool isVF(string s) {
int n = s.length();
if (n < 6) return false;
return s[n - 1] == 's' && s[n - 2] == 'e' && s[n - 3] == 't' &&
s[n - 4] == 'i' && s[n - 5] == 'n' && s[n - 6] == 'i';
}
int main() {
while (scanf("%s", s) != EOF) {
cads.push_back(string(s));
}
int m = cads.size();
int l = 0, cf = 0, cm = 0;
int a = 0;
while (l < m && (isAM(cads[l]) || isAF(cads[l]))) {
if (isAM(cads[l]))
cm++;
else
cf++;
l++;
a++;
}
int b = 0;
if (l < m && (isNM(cads[l]) || isNF(cads[l]))) {
if (isNM(cads[l]))
cm++;
else
cf++;
l++;
b++;
}
int c = 0;
while (l < m && (isVM(cads[l]) || isVF(cads[l]))) {
if (isVM(cads[l]))
cm++;
else
cf++;
l++;
c++;
}
if ((l == m && (cf == 0 || cm == 0) && b) || (a + b + c == 1 && m == 1)) {
printf("YES");
} else
printf("NO");
}
| 9 | CPP |
n = int(input())
l = list(map(int,input().split()))
m = int(input())
w = []
h = []
for i in range(m):
x,y = map(int,input().split())
w.append(x)
h.append(y)
cur = 0
for i in range(m):
cur = max(cur, l[w[i]-1])
print(cur)
cur += h[i]
| 7 | PYTHON3 |
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
from collections import deque
import threading
#sys.setrecursionlimit(300000)
#threading.stack_size(10**8)
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#-------------------game starts now-----------------------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
#-------------------------------------------------------------------------
for _ in range (int(input())):
n=input()
l=len(n)
r=(int(n[0])-1)*10+(l*(l+1))//2
print(r) | 7 | PYTHON3 |
#include <cstdio>
#include <cstdint>
#include <vector>
#include <set>
#include <utility>
#include <iostream>
#include <stdexcept>
template <class Tp>
class interval_set {
// [lb, ub) の区間の集合を表します．各区間で共通部分が出ないように
// 適宜マージしていきます．
std::set<std::pair<Tp, Tp>> ranges;
public:
void insert(Tp x) {
insert(x, x+1);
}
void erase(Tp x) {
erase(x, x+1);
}
void insert(Tp lb, Tp ub) {
if (ranges.empty()) {
ranges.emplace(lb, ub);
return;
}
auto it=ranges.upper_bound({lb, lb});
if (it != ranges.begin() && lb <= std::prev(it)->second) {
// lb 以下から始まる区間を確認する
if (ub <= std::prev(it)->second) return; // 覆われていたら終了
// 覆われていなければ lb を広げ，元の区間を一旦消去
lb = std::prev(it)->first;
ranges.erase(std::prev(it));
}
while (it != ranges.end() && it->first <= ub) {
// 被っている区間を消していく．
// ここにいい感じの制約が無いと計算量こわれる
if (ub < it->second) ub = it->second; // よしなに
it = ranges.erase(it);
}
ranges.emplace(lb, ub);
}
void erase(Tp lb, Tp ub) {
if (ranges.empty()) return;
auto it=ranges.upper_bound({lb, lb});
if (it != ranges.begin() && lb <= std::prev(it)->second) {
if (ub <= std::prev(it)->second) {
// [ ...* [ ...+ ) ...* ) みたいになっている
--it;
Tp lb0=it->first;
Tp ub0=it->second;
ranges.erase(it);
if (lb0 < lb) ranges.emplace(lb0, lb);
if (ub < ub0) ranges.emplace(ub, ub0);
return;
}
// [ ...+ ) [ ...+ )*
// [ ...+ ) <- ここを消す
Tp lb0=std::prev(it)->first;
ranges.erase(std::prev(it));
ranges.emplace(lb0, lb);
}
while (it != ranges.end() && it->first <= ub) {
if (ub < it->second) {
// 完全には覆っていない場合
Tp ub0=it->second;
ranges.erase(it);
ranges.emplace(ub, ub0);
break;
}
it = ranges.erase(it);
}
}
size_t num_ranges() const {
return ranges.size();
}
std::pair<Tp, Tp> suprange(Tp x) const {
// x を覆う区間があればそれを返します．なければ空を表す (x, x) を返します
if (ranges.empty()) return {x, x};
auto it=ranges.upper_bound({x, x});
if (it != ranges.end())
if (it->first <= x && x < it->second) return *it;
if (it == ranges.begin() || (--it)->second <= x) return {x, x};
return *it;
}
bool contains(Tp x) const {
// 空でないとき，終端が x になることはありません
return (suprange(x).second != x);
}
Tp max() const {
if (ranges.empty()) throw std::logic_error("max in empty set");
auto it=ranges.end();
return (--it)->second - 1;
}
void inspect() const {
for (auto it=ranges.begin(); it!=ranges.end(); ++it)
std::cerr << '[' << it->first << ", " << it->second << ')'
<< (std::next(it)!=ranges.end()? ' ':'\n');
}
};
int main() {
size_t n;
scanf("%zu", &n);
std::vector<int> a(n);
int max=0;
for (size_t i=0; i<n; ++i) {
scanf("%d", &a[i]);
if (max < a[i]) max = a[i];
}
interval_set<int> iset;
bool saturated=false;
for (size_t i=0; i<n; ++i) {
// iset.inspect();
if (saturated) {
puts("No");
continue;
}
int x=max-a[i];
if (!iset.contains(x)) {
iset.insert(x);
puts("Yes");
continue;
}
auto sup=iset.suprange(x);
int lb=sup.first;
int ub=sup.second;
if (ub == max) {
if (lb < x || iset.num_ranges() > 1) {
puts("No");
} else {
saturated = true;
puts("Yes");
}
continue;
}
puts("Yes");
iset.erase(x, ub);
iset.insert(ub);
}
}
| 0 | CPP |
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import random
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
import threading
from collections import defaultdict
threading.stack_size(10**8)
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
sys.setrecursionlimit(300000)
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default=2**51, func=lambda a, b: a & b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] <=key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def binary(x, length):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def countGreater(arr, n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
s=[]
n=int(input())
for i in range(n):
x,y=map(int,input().split())
if x==0:
if y>0:
s.append(90)
else:
s.append(-90)
elif y==0:
if x>0:
s.append(0)
else:
s.append(180)
else:
if x<0 and y<0:
f=Fraction(y/x)
s.append(180+math.degrees(math.atan(f)))
elif y<0:
f=Fraction(-y/x)
s.append(-math.degrees(math.atan(f)))
elif x<0:
f=Fraction(y/-x)
s.append(180-math.degrees(math.atan(f)))
else:
f = Fraction(y / x)
s.append(math.degrees(math.atan(f)))
s.sort()
m=abs(s[-1]-s[0])
for i in range (1,n):
d=360-abs(s[i]-s[i-1])
m=min(m,d)
print(m) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
int count = 1;
int maxCount = 1;
for (int i = 1; i < n; i++) {
if (a[i] > a[i - 1])
count++;
else {
count = 1;
}
maxCount = max(count, maxCount);
}
cout << maxCount << endl;
return 0;
}
| 7 | CPP |
from bisect import bisect_right as bi
b=[]
for i in range(32):
for j in range(21):
if (2**(i))*(3**(j))<3*(10**9):
b.append((2**(i))*(3**(j)))
b.sort()
l,r=list(map(int,input().split()))
print(bi(b,r)-bi(b,l-1)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 60, m = 50;
double p, a[N][N], b[N][N], f[N][N], v[N][N];
int n;
struct matrix {
double w[N][N];
void operator*=(const matrix &c) {
for (int i = 0; i <= m; ++i)
for (int j = 0; j <= m; ++j) v[i][j] = w[i][j], w[i][j] = 0;
for (int i = 0; i <= m; ++i)
for (int j = 0; j <= m; ++j)
for (int k = 0; k <= m; ++k) w[i][k] += v[i][j] * c.w[j][k];
return;
}
} Ans, trans, tmp;
int main() {
scanf("%d%lf", &n, &p), p /= 1000000000;
a[1][1] = p, a[1][2] = 1 - p;
b[1][2] = 1 - p;
for (int i = 2; i <= m; ++i) {
a[i][1] = p, a[i][2] = 1 - p;
b[i][2] = 1 - p;
for (int j = 2; j <= m; ++j) {
a[i][j] += a[i][j - 1] * a[i - 1][j - 1];
b[i][j] += b[i][j - 1] * a[i - 1][j - 1];
}
}
for (int i = m; i >= 1; --i)
for (int j = 1; j <= m; ++j)
a[i][j] *= 1 - a[i - 1][j], b[i][j] *= 1 - a[i - 1][j];
f[1][1] = 1, f[1][2] = 2;
for (int i = 2; i <= m; ++i) {
for (int j = 2; j <= m; ++j) {
double sum = 0;
for (int k = 1; k < j; ++k)
f[i][j] += f[i - 1][k] * a[i - 1][k], sum += a[i - 1][k];
f[i][j] /= sum, f[i][j] += j;
}
double sum = 0;
for (int k = 2; k <= m; ++k)
f[i][1] += f[i - 1][k] * b[i - 1][k], sum += b[i - 1][k];
f[i][1] /= sum, f[i][1] += 1;
}
double ans = 0;
if (n <= m) {
for (int i = 1; i <= m; ++i) ans += a[n][i] * f[n][i];
} else {
Ans.w[0][0] = trans.w[0][0] = 1;
for (int i = 1; i <= m; ++i) trans.w[0][i] = i;
for (int i = 2; i <= m; ++i) {
double sum = 0;
for (int j = 1; j < i; ++j) trans.w[j][i] += a[m][j], sum += a[m][j];
for (int j = 1; j <= i; ++j) trans.w[j][i] /= sum;
}
double sum = 0;
for (int i = 2; i <= m; ++i) trans.w[i][1] += b[m][i], sum += b[m][i];
for (int i = 2; i <= m; ++i) trans.w[i][1] /= sum;
for (int i = 1; i <= m; ++i) Ans.w[0][i] = f[m][i];
int k = n - m;
while (k) {
if (k & 1) Ans *= trans;
tmp = trans, trans *= tmp, k >>= 1;
}
for (int i = 1; i <= m; ++i) ans += Ans.w[0][i] * a[m][i];
}
printf("%.12lf", ans);
return 0;
}
| 13 | CPP |
a=input()
b=input()
c=len(a)
d=len(b)
while(c and d and a[c-1]==b[d-1]):
c=c-1
d=d-1
print(c+d) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long w = 1, s = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = s * 10 + ch - '0';
ch = getchar();
}
return s * w;
}
long long gcd(long long x, long long y) {
if (x < y) swap(x, y);
return x % y ? gcd(y, x % y) : y;
}
long long lcm(long long x, long long y) { return x * y / gcd(x, y); }
signed main() {
long long t = read();
while (t--) {
long long n = read();
long long cnt0 = 0, cnt1 = 0, cnt2 = 0;
for (long long i = 1; i <= n; i++) {
long long x = read();
x %= 3;
if (x == 0) cnt0++;
if (x == 1) cnt1++;
if (x == 2) cnt2++;
}
long long ans = min(cnt1, cnt2);
cnt0 += ans;
cnt1 -= ans;
cnt2 -= ans;
long long sum = cnt0 + cnt1 / 3 + cnt2 / 3;
printf("%lld\n", sum);
}
return 0;
}
| 8 | CPP |
#include <stdio.h>
#include <vector>
#include <functional>
#include <algorithm>
using namespace std;
typedef long long ll;
int main(void) {
ll i, j, k, x, y, z, t, n;
scanf("%lld%lld%lld%lld", &x, &y, &z, &k);
ll a[x];
vector<ll> v1, v2;
for(i = 0; i < x; ++i) scanf("%lld", &a[i]);
for(i = 0; i < y; ++i) {
scanf("%lld", &t);
for(j = 0; j < x; ++j) v1.push_back(t + a[j]);
}
sort(v1.begin(), v1.end(), greater<ll>());
n = k > x * y ? x * y : k;
for(i = 0; i < z; ++i) {
scanf("%lld", &t);
for(j = 0; j < n; ++j) v2.push_back(t + v1[j]);
}
sort(v2.begin(), v2.end(), greater<ll>());
for(i = 0; i < k; ++i) printf("%lld\n", v2[i]);
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-12;
const int N = 33000;
const int M = 1007;
vector<pair<int, int> > ev[N * 4];
void insert(int left, int right, int l, int r, int x, pair<int, int> v) {
if (l <= left && r >= right) {
ev[x].push_back(v);
return;
}
int mid = (left + right) >> 1;
if (l <= mid) {
insert(left, mid, l, r, x * 2, v);
}
if (r > mid) {
insert(mid + 1, right, l, r, x * 2 + 1, v);
}
}
int dp[M];
int rec[30][M];
vector<int> query[N];
int k;
const int p = 10000000 + 19;
const int q = 1000000007;
int ans[N];
void go(pair<int, int> x) {
for (int i = k; i >= x.first; --i) {
dp[i] = max(dp[i], dp[i - x.first] + x.second);
}
}
void dfs(int left, int right, int x, int level) {
for (int i = 0; i < k + 1; i++) rec[level][i] = dp[i];
for (__typeof(ev[x].begin()) it = ev[x].begin(); it != ev[x].end(); it++) {
go(*it);
}
if (left != right) {
int mid = (left + right) >> 1;
dfs(left, mid, x * 2, level + 1);
dfs(mid + 1, right, x * 2 + 1, level + 1);
} else {
for (__typeof(query[left].begin()) it = query[left].begin();
it != query[left].end(); it++) {
long long coef = 1;
int hashes = 0;
for (int i = 1; i <= k; ++i) {
hashes = (hashes + dp[i] * coef) % q;
coef = coef * p % q;
}
cout << hashes << endl;
}
}
for (int i = 0; i < k + 1; i++) dp[i] = rec[level][i];
}
int main() {
int n, q;
cin >> n >> k;
vector<pair<int, int> > g(n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &g[i].second, &g[i].first);
}
vector<int> when(n);
fill(when.begin(), when.end(), 0);
cin >> q;
for (int i = 0; i < q; i++) {
int tp;
scanf("%d", &tp);
if (tp == 1) {
int v, w;
scanf("%d%d", &v, &w);
when.push_back(i + 1);
g.push_back(make_pair(w, v));
} else if (tp == 2) {
int which;
scanf("%d", &which);
--which;
insert(0, q, when[which], i + 1, 1, g[which]);
when[which] = -1;
} else if (tp == 3) {
query[i + 1].push_back(i);
}
}
for (int i = 0; i < when.size(); i++) {
if (when[i] != -1) {
insert(0, q, when[i], q, 1, g[i]);
}
}
dfs(0, q, 1, 0);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int fi(int a) {
int b = a;
int fii = 1;
for (int i = 2; i * i <= b; i++) {
if (a % i == 0) {
a /= i;
fii *= i - 1;
}
while (a % i == 0) {
a /= i;
fii *= i;
}
}
if (a > 1) return fii * (a - 1);
return fii;
}
long long pot(long long a, long long w, long long mod) {
if (w == 0) return 1;
long long b = pot(a, w / 2, mod);
b *= b;
b %= mod;
if (w % 2 == 1) {
b *= a;
b %= mod;
}
return b;
}
int rzad(int a, int q) {
int ord = fi(q);
int res = ord;
int morda = ord;
int orda = ord;
for (int i = 1; i * i <= orda; i++) {
if (ord % i == 0) {
if (pot(a, ord / i, q) == 1) res = min(res, ord / i);
if (pot(a, i, q) == 1) res = min(res, i);
}
}
return res;
}
const int MAX_N = 1e6 + 200;
long long n, m, a, Q, P;
long long rev(long long a) { return pot(a, P - 2, P); }
long long sil[MAX_N];
long long sym[MAX_N], pref[MAX_N];
int main() {
scanf("%lld%lld%lld%lld", &n, &m, &a, &Q);
P = rzad(a, Q);
sil[0] = 1;
for (long long i = 1; i < MAX_N; ++i) sil[i] = (sil[i - 1] * i) % P;
for (long long i = 0; i <= m; ++i) {
sym[i] = sil[m] * rev(sil[m - i]);
sym[i] %= P;
sym[i] *= rev(sil[i]);
sym[i] %= P;
if (i != 0) pref[i] = pref[i - 1];
pref[i] += sym[i];
pref[i] %= P;
}
for (int j = n; j >= 1; --j) {
printf("%lld ", pot(a, pref[min(m, (long long)j - 1)], Q));
}
printf("\n");
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
const int maxn = 1e5 + 20;
const int logn = 20;
int n, q;
std::vector<int> g[maxn];
long long ans;
int size[maxn], f[maxn][logn], dep[maxn];
int fa[maxn], cnt[maxn];
long long single[maxn];
long long sqr(int x) { return 1ll * x * x; }
void dfs(int u, int fa) {
size[u] = 1;
single[u] = 0;
dep[u] = dep[fa] + 1;
f[u][0] = fa;
for (int i = 1; i < logn; i++) {
f[u][i] = f[f[u][i - 1]][i - 1];
}
single[u] += sqr(n - 1);
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == fa) continue;
dfs(v, u);
size[u] += size[v];
single[u] -= sqr(size[v]);
}
single[u] -= sqr(n - size[u]);
}
int getlca(int x, int y) {
if (dep[x] < dep[y]) std::swap(x, y);
for (int i = logn - 1; i >= 0; i--) {
if (dep[f[x][i]] >= dep[y]) x = f[x][i];
}
if (x == y) return x;
for (int i = logn - 1; i >= 0; i--) {
if (f[x][i] != f[y][i]) {
x = f[x][i];
y = f[y][i];
}
}
return f[x][0];
}
int find(int x) { return x == fa[x] ? x : (fa[x] = find(fa[x])); }
void rotate(int x, int y) {
while (x != y) {
int z = find(f[x][0]);
ans -= cnt[x] * single[x];
ans -= cnt[z] * single[z];
fa[x] = z;
cnt[z] += cnt[x];
single[z] += single[x] - sqr(n - 1) - 1 + sqr(size[x]) + sqr(n - size[x]);
ans += cnt[z] * single[z];
x = z;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1, 0);
for (int i = 1; i <= n; i++) {
fa[i] = i;
cnt[i] = 1;
ans += cnt[i] * single[i];
}
printf("%lld\n", ans);
scanf("%d", &q);
while (q--) {
int u, v, w;
scanf("%d%d", &u, &v);
u = find(u), v = find(v);
w = find(getlca(u, v));
rotate(u, w);
rotate(v, w);
printf("%lld\n", ans);
}
return 0;
}
| 13 | CPP |
import math
n,r = map(int,input().split())
a = [int(x) for x in input().split()]
ans = []
ans.append(r)
for x in range(1,len(a)):
f = 0
m = -9999999
for x_ in range(x-1,-1,-1):
if abs(a[x]-a[x_])<=2*r:
m = max(m,ans[x_]+math.sqrt((2*r)**2-(a[x]-a[x_])**2))
f = 1
if f == 0:
ans.append(r)
else:
ans.append(m)
for i in range(len(ans)):
print(ans[i],end=" ")
| 9 | PYTHON3 |
n,l,r = map(int,input().split())
minsum =0
maxsum=0
for i in range(1,l+1):
minsum+=2**(i-1)
minsum += n-l
for j in range(1,r+1):
maxsum+=2**(j-1)
maxsum+=(n-r)*(2**(r-1))
print(minsum,maxsum)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using cat = long long;
class IntervalTree {
struct node {
int l, r;
int son[2];
priority_queue<int> q, q_rm, q_active;
int max_active, min_real;
};
vector<node> T;
vector<bool> deleted;
void construct(int node_num) {
node n = T[node_num];
if (n.l + 1 == n.r) return;
for (int i = 0; i < 2; i++) {
if (i == 0)
n.r = (n.l + n.r) / 2;
else {
n.l = n.r;
n.r = T[node_num].r;
}
T[node_num].son[i] = T.size();
T.push_back(n);
construct(T[node_num].son[i]);
}
}
void clean(node& n) {
while (!n.q_active.empty() && deleted[n.q_active.top()]) {
n.q_active.pop();
}
while (!n.q_rm.empty() && n.q_rm.top() == n.q.top()) {
n.q.pop();
n.q_rm.pop();
}
n.min_real = -1;
if (n.son[0] != -1 && n.son[1] != -1)
n.min_real = min(T[n.son[0]].min_real, T[n.son[1]].min_real);
if (!n.q.empty() && n.q.top() > n.min_real) n.min_real = n.q.top();
n.max_active = n.q_active.empty() ? -1 : n.q_active.top();
if (n.son[0] != -1)
n.max_active = max(n.max_active, T[n.son[0]].max_active);
if (n.son[1] != -1)
n.max_active = max(n.max_active, T[n.son[1]].max_active);
if (n.min_real > n.max_active) n.max_active = -1;
}
public:
IntervalTree(int N, int max_val) : deleted(max_val, 0) {
node n = {0,
N,
{-1, -1},
priority_queue<int>(),
priority_queue<int>(),
priority_queue<int>(),
-1,
-1};
T.push_back(n);
construct(0);
}
void add(int l, int r, int val, int node_num = 0) {
node& n = T[node_num];
if (n.l >= r || l >= n.r) return;
if (n.l == l && n.r == r) {
n.q.push(val);
n.q_active.push(val);
clean(n);
return;
}
add(l, min(r, (n.l + n.r) / 2), val, n.son[0]);
add(max(l, (n.l + n.r) / 2), r, val, n.son[1]);
clean(n);
}
void remove(int l, int r, int val, int node_num = 0) {
node& n = T[node_num];
if (n.l >= r || l >= n.r) return;
if (n.l == l && n.r == r) {
n.q_rm.push(val);
deleted[val] = true;
clean(n);
return;
}
remove(l, min(r, (n.l + n.r) / 2), val, n.son[0]);
remove(max(l, (n.l + n.r) / 2), r, val, n.son[1]);
clean(n);
}
void make_inactive(int l, int r, int val, int node_num = 0) {
node& n = T[node_num];
if (n.l >= r || l >= n.r) return;
if (n.l == l && n.r == r) {
deleted[val] = true;
clean(n);
return;
}
make_inactive(l, min(r, (n.l + n.r) / 2), val, n.son[0]);
make_inactive(max(l, (n.l + n.r) / 2), r, val, n.son[1]);
clean(n);
}
int get_top() { return T[0].max_active; }
};
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(10);
int N;
cin >> N;
vector<int> x1(N), y1(N), x2(N), y2(N);
map<int, int> Mx, My;
srand(0);
for (int i = 0; i < N; i++) {
cin >> x1[i] >> y1[i] >> x2[i] >> y2[i];
Mx[x1[i]] = Mx[x2[i]] = My[y1[i]] = My[y2[i]] = 0;
}
int mx = 0, my = 0;
for (auto it = Mx.begin(); it != Mx.end(); it++) it->second = mx++;
for (auto it = My.begin(); it != My.end(); it++) it->second = my++;
vector<vector<int> > starts(mx), ends(mx);
for (int i = 0; i < N; i++) {
x1[i] = Mx[x1[i]];
x2[i] = Mx[x2[i]];
y1[i] = My[y1[i]];
y2[i] = My[y2[i]];
starts[x1[i]].push_back(i);
ends[x2[i]].push_back(i);
}
IntervalTree I(my, N);
vector<int> ans(N, 0);
for (int i = 0; i < mx; i++) {
for (auto it = starts[i].begin(); it != starts[i].end(); it++)
I.add(y1[*it], y2[*it], *it);
for (auto it = ends[i].begin(); it != ends[i].end(); it++)
I.remove(y1[*it], y2[*it], *it);
int max_active = I.get_top();
while (max_active != -1) {
ans[max_active] = 1;
I.make_inactive(y1[max_active], y2[max_active], max_active);
max_active = I.get_top();
}
}
int ans_sum = 1;
for (int i = 0; i < N; i++) ans_sum += ans[i];
cout << ans_sum << "\n";
return 0;
}
| 10 | CPP |
#define _CRT_SECURE_NO_WARNINGS
#define _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS
#include <stdio.h>
#include <algorithm>
#include <utility>
#include <functional>
#include <cstring>
#include <queue>
#include <stack>
#include <math.h>
#include <iterator>
#include <vector>
#include <string>
#include <set>
#include <math.h>
#include <iostream>
#include <random>
#include <map>
#include <fstream>
#include <iomanip>
#include <time.h>
#include <stdlib.h>
#include <list>
#include <typeinfo>
#include <list>
#include <set>
#include <assert.h>
#include <complex>
using namespace std;
#define LONG_INF 10000000000000
#define GOLD 1.61803398874989484820458
#define MAX_MOD 1000000007
#define MOD 998244353LL
#define seg_size 65536*4
#define REP(i,n) for(long long i = 0;i < n;++i)
long long cnt[300000] = {};
long long adding[300000] = {};
int main() {
#define int long long
int n, m;
cin >> n >> m;
vector<long long> input;
REP(i, m) {
long long tmp;
cin >> tmp;
input.push_back(tmp);
}
input.push_back(n+1);
sort(input.begin(), input.end());
REP(i, input.size()-1) {
cnt[input[i + 1] - input[i]-1]++;
}
long long tools = 0;
for (int i = 200000; i >= 0; --i) {
cnt[i] += cnt[i + 1];
adding[i] += adding[i + 1];
adding[i] += cnt[i];
}
int query;
cin >> query;
REP(test, query) {
long long geko = 0;
cin >> geko;
geko -= input[0] - 1;
if (geko < 0) {
cout << -1 << endl;
continue;
}
long long top = n-1;
long long bot = 1;
while (top - bot > 1) {
long long mid = (top + bot) / 2;
if (adding[mid] > geko) {
bot = mid;
}
else {
top = mid;
}
}
for (int i = max(1LL, (long long)bot - 3);; ++i) {
if (adding[i] <= geko) {
cout << i << endl;
break;
}
}
}
return 0;
}
| 0 | CPP |
from math import ceil
n, s =map(int, input().split())
print(ceil(s/n)) | 7 | PYTHON3 |
n=int(input())
m=0
a=[int(x) for x in input().split()]
s=input()
m=0
for x in range(n-1):
m=max(a[x],m)
if s[x]=='0' and m>x+1:
print('NO')
quit()
print('YES') | 9 | PYTHON3 |
#include<iostream>
using namespace std;
int n,a,b,c,cnt;
int main(){
cin>>n;
while(n--){
cin>>a>>b>>c;
cnt=min(a,min(b,c));
a-=cnt;
b-=cnt;
c-=cnt;
while(a>=2&&b>=1){
cnt++;
a-=2;
b--;
}
cnt+=(a/3);
cout<<cnt<<endl;
}
return 0;
} | 0 | CPP |
def main():
a = input().strip()
vowel = 'aeiou'
if a[-1] not in vowel and a[-1]!='n':
print('NO')
return
for i in range(len(a)-1):
if a[i] not in vowel:
if a[i]!='n':
if a[i+1] not in vowel:
print('NO')
return
print('YES')
return
if __name__ == '__main__':
main()
| 7 | PYTHON3 |
tc = int(input())
for i in range(tc):
[n, k] = list(map(int, input().split()))
arr = list(map(int, input().split()))
d = max(arr)
if(k%2 == 1):
for i in range(n):
arr[i] = d - arr[i]
print(*arr)
else:
for i in range(n):
arr[i] = d - arr[i]
d = max(arr)
for i in range(n):
arr[i] = d - arr[i]
print(*arr) | 8 | PYTHON3 |
from collections import defaultdict,Counter,deque
read = lambda: list(map(int,input().split()))
getinfo = lambda grid: print(list(map(print,grid)))
p = lambda x: print(x,end=" ")
inf = float('inf')
mod = 10**9+7
n = int(input())
A = input()
B = input()
res = 0
for i in range(n//2):
j = n-i-1
if Counter([A[i],B[i]]) == Counter([A[j],B[j]]) or Counter([A[i],A[j]]) == Counter([B[i],B[j]]):
continue
elif B[i] in A[j]+B[j] or B[j] in A[i]+B[i] or A[i] == B[i] or A[j] == B[j]:
res += 1
else:
res += 2
if n % 2 == 1:
index = n//2
res += A[index] != B[index]
print(res) | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int A,B;
int N;
int Apre=0;
int result;
cin >> N;
for(int i = 0; i < N; i++){
cin >> A >> B;
if(A > Apre){
result = A + B;
Apre = A;
}
}
cout << result << endl;
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << max({a*10+b+c, b*10+a+c, c*10+a+b}) << endl;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a, ax, b, bx, i, ans, h, m, x, y, z;
char c;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> a >> ax;
cin >> b >> bx;
cin >> h >> c >> m;
x = 300;
y = h * 60 + m;
z = 24 * 60 - 1;
for (i = x; i <= z; i += b) {
if (min(i + bx, y + ax) > max(i, y)) {
ans++;
}
}
cout << ans << endl;
}
| 7 | CPP |
from collections import defaultdict
t = int(input())
for _ in range(t):
n = int(input())
#n,x = map(int,input().split())
a = list(map(int,input().split()))
a = sorted(a,reverse=True)
print (*a) | 8 | PYTHON3 |
name = input()
if len(set(name)) % 2 is 0:
print ('CHAT WITH HER!')
else:
print ('IGNORE HIM!')
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long K[5050], D[5050];
int T[5050][5050];
long long n, k, ans;
long long mypow(long long a, long long b) {
if (!b) return 1;
long long ret = mypow(a, b >> 1);
ret *= ret;
ret %= mod;
return ret * (b & 1 ? a : 1) % mod;
}
int main() {
long long i, j, s;
scanf("%lld%lld", &n, &k);
if (n < k) {
T[0][0] = 1;
for (i = 1; i <= n; i++) {
T[i][0] = 1;
for (j = 1; j <= i; j++)
T[i][j] = ((long long)T[i - 1][j] + (long long)T[i - 1][j - 1]) % mod;
}
for (i = 0; i <= n; i++) {
ans = (ans + (long long)T[n][i] * mypow(i, k)) % mod;
}
printf("%lld\n", ans);
return 0;
}
T[0][0] = s = 1;
for (i = 1; i <= k; i++) {
s = s * (n - i + 1) % mod;
K[i] = (s * mypow(2, n - i)) % mod;
for (j = 0; j < i; j++) {
T[i][j] = (((long long)T[i][j] - (i - 1) * (long long)T[i - 1][j]) % mod +
mod) %
mod;
T[i][j + 1] = ((long long)T[i][j + 1] + (long long)T[i - 1][j]) % mod;
}
}
D[k] = -1;
for (i = k; i >= 0; i--) {
s = -D[i];
ans = ((ans + s * K[i]) % mod + mod) % mod;
for (j = 0; j <= i; j++)
D[j] = ((D[j] + s * (long long)T[i][j]) % mod + mod) % mod;
}
printf("%lld\n", ans);
return 0;
}
| 11 | CPP |
#include <stdio.h>
#include <math.h>
int main(){
int n,tmp;
scanf("%d",&n);
long long sum = 0;
for(int i = 0; i < n; i++){
scanf("%d",&tmp);
sum += tmp;
}
printf("%lld\n",sum/n);
return 0;
} | 0 | CPP |
n = int(input())
arr = [int(x) for x in input().split()]
max_val = max(arr)
max_len = 0
cur_len = 0
for a in arr:
if a == max_val:
cur_len += 1
max_len = max(cur_len, max_len)
else:
cur_len = 0
print(max_len)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int N, *arr, key, z = 0, max, n;
int k = 0;
cin >> N;
arr = new (nothrow) long long int[N];
for (n = 0; n < N; n++) cin >> arr[n];
key = arr[0];
for (n = 0; n < N; n++) {
if (key <= arr[n]) {
z++;
key = arr[n];
} else {
key = arr[n];
z = 1;
}
if (k == 0) {
max = z;
k++;
} else {
if (z > max) max = z;
}
}
cout << max << endl;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inft = 1000000009;
const int MAXN = 1000006;
int tt[5], T[5];
int get(int A, int B) {
;
int ret = 0;
for (int i = 0; i < (5); ++i) tt[i] = T[i];
int t = min(A, tt[4]);
A -= t;
tt[4] -= t;
ret += 4 * t;
t = min(B, tt[3]);
B -= t;
tt[3] -= t;
ret += 3 * t;
if (A == 0) {
t = min(tt[4], B);
ret += 3 * t;
B -= t;
t = min(tt[2], B);
ret += 2 * t;
B -= t;
t = min(tt[1], B);
ret += 1 * t;
B -= t;
} else if (B == 0) {
t = min(tt[3], A);
ret += 3 * t;
A -= t;
t = min(tt[2], A);
ret += 2 * t;
A -= t;
t = min(tt[1], A);
ret += 1 * t;
A -= t;
} else {
B += A;
t = min(tt[2], B);
ret += 2 * t;
B -= t;
t = min(tt[1], B);
ret += 1 * t;
B -= t;
};
return ret;
}
void solve() {
int n, N = 0;
scanf("%d", &n);
for (int i = 0; i < (n); ++i) {
int a;
scanf("%d", &a);
T[a]++;
N += a;
}
int left = -1;
for (int A = 0; 4 * A <= N; A++) {
if ((N - 4 * A) % 3 == 0 && (A + (N - 4 * A) / 3 <= n))
left = max(left, get(A, (N - 4 * A) / 3));
}
if (left == -1)
printf("%d\n", -1);
else
printf("%d\n", N - left);
}
int main() {
solve();
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, a, b, ans = 0;
cin >> n >> m >> a >> b;
if (a == 1 && b == n || m == 1)
cout << 1;
else {
if (a == b)
cout << 1;
else if (a < m && b <= m)
cout << 1;
else if (a == 1) {
if (b % m == 0)
cout << 1;
else
cout << 2;
} else if (a <= m) {
ans++;
if (b % m == 0 || b == n || b <= m * 2 || (b > m * 2 && b % m == a - 1))
ans++;
else
ans += 2;
cout << ans;
} else if (a > m) {
if (a % m != 0 && (a + (m - (a % m))) >= b)
cout << 1;
else {
if (a % m == 1) {
if (b == n || b % m == 0)
cout << 1;
else
cout << 2;
} else {
ans++;
if (b == n || b % m == 0)
ans++;
else if (a % m == 0) {
if (a + m >= b || b % m == m - 1)
ans++;
else
ans += 2;
} else if ((a + (m - (a % m))) + m >= b ||
(b > m * 2 && b % m == a % m - 1))
ans++;
else
ans += 2;
cout << ans;
}
}
}
}
return 0;
}
| 9 | CPP |
#include<iostream>
using namespace std;
long long n,m;
int main()
{
cin>>n>>m;
if (n==1 && m==1) cout<<1<<endl;
else if (n==1) cout<<m-2<<endl;
else if (m==1) cout<<n-2<<endl;
else cout<<(n-2)*(m-2)<<endl;
return 0;
} | 0 | CPP |
stra = input()
last = stra[0]
if last != '1':
print("NO")
else:
bv = True
for c in stra[1:]:
if last == '1' and ( c == '4' or c == '1' ):
last = c
elif last == '4' and c == '4':
last = '44'
elif last == '4' and c == '1':
last = '1'
elif last == '44' and c == '1':
last = '1'
else:
bv = False
break
if bv:
print("YES")
else:
print("NO") | 7 | PYTHON3 |
t=int(input())
for _ in range(t):
a,b = map(int, input().split())
res = b-a%b
if res == b: print(0)
else: print(res) | 10 | PYTHON3 |
cases = int(input())
for i in range(cases):
l1 = input().split(' ')
n = int(l1[0])
k = int(l1[1])
ans = n
for j in range(int(n**0.5),0,-1):
if n%j == 0:
if j <= k:
ans = min(ans, int(n/j))
if n/j<=k:
ans = min(ans,j)
print(ans)
| 10 | PYTHON3 |
import sys
for t in range(int(input())):
n = int(input())
if n==1:
print(-1)
else:
if (n-1)%3 == 0:
print("2"*(n-2)+"33")
else:
print("2"*(n-1)+"3")
# sys.stdout.write() | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long int n, i, c = 0, a, b;
cin >> n;
long long int arr[1005] = {0};
for (i = 0; i < n - 1; i++) {
cin >> a >> b;
arr[a]++;
arr[b]++;
}
for (i = 0; i < 1005; i++) {
if (arr[i] == 1) c++;
}
cout << c;
cout << "\n";
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
int n = str.length();
cout << ((n + 1) * 26) - n << "\n";
return 0;
}
| 7 | CPP |
for _ in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
max1=max(a)
i=0
j=1
found=0
while j<n:
if a[i]==a[j]:
i=i+1
j=j+1
else:
found=1
break
if found==0:
print(-1)
else:
for i in range(n):
if i==0:
if a[i]==max1 and (a[i+1]!=max1):
print(i+1)
break
elif i==n-1:
if a[i]==max1 and (a[i-1]!=max1):
print(i+1)
break
else:
if a[i]==max1 and (a[i-1]!=max1 or a[i+1]!=max1):
print(i+1)
break
| 9 | PYTHON3 |
a,b,c,d=map(int,input().split())
s=input()
c=a*s.count('1')+ b*s.count('2') + c*s.count('3') + d*s.count('4')
print(c) | 7 | PYTHON3 |
#include<iostream>
#include<string>
using namespace std;
int main(){
int cnt[26]={};
char ch;
while(cin>>ch){
ch=tolower(ch);
if(isalpha(ch)) cnt[ch-'a']++;
}
for(int i=0; i<=25; i++){
cout<<(char)(i+'a')<<" : "<<cnt[i]<<endl;
}
return 0;
}
| 0 | CPP |
b = int(input())
num = 1
cont = 0
while(True):
if(num * num > b): break
if(b % num == 0):
cont += 1
if( num * num != b):
cont += 1
num += 1
print(cont)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 5000 + 1;
bool isPalindrome[mx][mx];
int dp[mx][mx];
char s[21000];
int main() {
scanf("%s", s);
int q;
scanf("%d", &q);
int l = strlen(s);
for (int len = 0; len < l; ++len) {
for (int i = 0; i < l; ++i) {
if (i + len >= l) break;
if (len == 0) isPalindrome[i][len] = 1;
if (len == 1)
isPalindrome[i][len] = (s[i] == s[i + len]) ? true : false;
else if (s[i] == s[i + len] && isPalindrome[i + 1][len - 2])
isPalindrome[i][len] = 1;
}
}
for (int len = 0; len < l; ++len) {
for (int i = 0; i < l; ++i) {
if (i + len >= l) break;
if (len == 0)
dp[i][len] = 1;
else if (len == 1)
dp[i][len] = dp[i][0] + dp[i + 1][0] + isPalindrome[i][len];
else
dp[i][len] = dp[i][len - 1] + dp[i + 1][len - 1] +
isPalindrome[i][len] - dp[i + 1][len - 2];
}
}
for (int i = 0; i < q; ++i) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
printf("%d\n", dp[a][b - a]);
}
}
| 14 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long gi() {
long long res = 0, w = 1;
char ch = getchar();
while (ch != '-' && !isdigit(ch)) ch = getchar();
if (ch == '-') w = -1, ch = getchar();
while (isdigit(ch)) res = res * 10 + ch - '0', ch = getchar();
return res * w;
}
const int MAX_N = 2e6 + 5;
void Fail() {
puts("NO");
exit(0);
}
struct node {
long long w, a, b;
} a[MAX_N], b[MAX_N];
bool operator<(const node &l, const node &r) { return l.w < r.w; }
int N, L, dx[MAX_N], dy[MAX_N];
long long Floor(long long x, long long y) { return (x - (x % y + y) % y) / y; }
long long Ceil(long long x, long long y) { return (x + (y - x % y) % y) / y; }
void solve(node p[], int q[]) {
sort(&p[1], &p[N + 1]);
long long l = 0, r = L;
for (int i = 0; i < N; i++) {
long long x = p[i].b - p[i + 1].b, k = p[i].a - p[i + 1].a,
y = x + p[i + 1].w - p[i].w;
if (k > 0)
l = max(l, Ceil(x, k)), r = min(r, Floor(y, k));
else if (k < 0)
l = max(l, Ceil(y, k)), r = min(r, Floor(x, k));
else if (y < 0 || x > y)
Fail();
}
if (l > r) Fail();
long long ls = 0, lw = 0;
for (int i = 1; i <= N; i++) {
long long s = p[i].b - l * p[i].a;
if (p[i].w == lw && s != ls) Fail();
for (int j = lw; j < lw + s - ls; j++) q[j] = 1;
ls = s, lw = p[i].w;
}
}
int main() {
N = gi(), L = gi();
for (int i = 1; i <= N; i++) {
long long t = gi(), x = gi(), y = gi();
if ((x ^ y ^ t) & 1) Fail();
a[i] = (node){(int)(t % L), t / L, (x + y + t) / 2};
b[i] = (node){(int)(t % L), t / L, (x - y + t) / 2};
}
++N;
a[N] = (node){L, -1, 0};
b[N] = (node){L, -1, 0};
solve(a, dx);
solve(b, dy);
for (int i = 0; i < L; i++) putchar("LDUR"[dx[i] << 1 | dy[i]]);
putchar('\n');
return 0;
}
| 13 | CPP |
import sys, math
#sys.setrecursionlimit(10**6)
INF = float('inf')
mod = 10**9 + 7
#mod = 998244353
input = lambda: sys.stdin.readline().rstrip()
li = lambda: list(map(int, input().split()))
from itertools import groupby
def RLE(s: str) -> list:
encoded = []
for key, group in groupby(s):
encoded.append([key, len(list(group))])
return encoded
t = int(input())
output = []
for _ in range(t):
N, K, X = li()
S = list(input())
if X == 1:
cnt = S.count('a')
output.append('a' * cnt)
continue
S = RLE(S)
su = 1
lst = []
for k, n in S[::-1]:
n *= K
n += 1
if k == 'a':
continue
if n * su >= X:
su = n * su
#lst.append(su)
break
else:
su *= n
lst.append(su)
lst2 = []
X -= 1
for i in range(len(lst))[::-1]:
waru = X // lst[i]
lst2.append(waru)
X %= lst[i]
lst2.append(X)
cnt = len(lst2) - 1
ans = [''] * len(S)
for i in range(len(S))[::-1]:
k, n = S[i]
if k == 'a':
ans[i] = 'a' * n
else:
if cnt >= 0:
ans[i] = 'b' * lst2[cnt]
cnt -= 1
output.append(''.join(ans))
for a in output:
print(a) | 9 | PYTHON3 |
s,t=map(str,open(0).read().split())
print('YNeos'[s!=t[:-1]::2]) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct three {
int x, y, z;
three() {}
three(int a, int b, int c) : x(a), y(b), z(c) {}
};
const int N = 100 * 1000 + 10;
vector<int> graph[N];
vector<three> ans;
vector<int> vec[N];
int mark[N];
void DFS(int v, int p) {
mark[v] = 1;
for (int i = 0; i < (int)graph[v].size(); i++) {
int u = graph[v][i];
if (mark[u] == 0)
DFS(u, v);
else if (mark[u] == 1 && u != p)
vec[v].push_back(u);
}
int x = (int)vec[v].size();
while (x >= 2) {
ans.push_back(three(vec[v][x - 1], v, vec[v][x - 2]));
vec[v].pop_back();
vec[v].pop_back();
x -= 2;
}
if (x == 0)
vec[p].push_back(v);
else {
ans.push_back(three(p, v, vec[v][0]));
vec[v].pop_back();
}
mark[v] = 2;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
graph[a].push_back(b);
graph[b].push_back(a);
}
if (m % 2 == 1) {
cout << "No solution\n";
return 0;
}
DFS(0, -1);
for (int i = 0; i < m / 2; i++)
cout << ans[i].x + 1 << " " << ans[i].y + 1 << " " << ans[i].z + 1 << endl;
return 0;
}
| 9 | CPP |
n=int(input())
b=list(map(int, input().split(" ")))
b.sort()
suma = 0
sumb = 0
for i, stick in enumerate(b, start=1):
if i <= n/2:
suma+=stick
else:
sumb+=stick
print(suma*suma+sumb*sumb)
| 8 | PYTHON3 |
import sys
import math
input = sys.stdin.readline
q = int(input())
while q > 0:
n, x = map(int, input().split())
print(x*2)
q-=1 | 7 | PYTHON3 |
total = int(input())
for _ in range(total):
n, a, b = list(map(int, input().split()))
alp = 'abcdefghijklmnopqrstuvwxyz'
ans = (alp[:b] * ((n // b) + 1))[:n]
print(ans) | 8 | PYTHON3 |
n = input()
a =input().split()
a.reverse()
print(' '.join(a))
| 0 | PYTHON3 |
n = int(input())
a = list(map(int,input().split()))
b = {}
for i in a:
if i in b:
b[i]+=1
else:
b[i]=1
l = float("inf")
for i in b:
t=0
for j in b:
t+=((j-i)%2)*b[j]
if t<l:
l=t
print(l)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
cin >> k;
cout << "2 3 262143 131071 0 131072 262143 " << k;
}
| 10 | CPP |
import sys
input = sys.stdin.readline
I = lambda : list(map(int,input().split()))
a,b,c,d=sorted(I())
print(d-a,d-b,d-c) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[500005];
vector<int> d;
int t[500005];
int n;
int max(int a, int b) { return (a > b) ? a : b; }
int min(int a, int b) { return (a > b) ? b : a; }
void dfs(int x, int p, int dis) {
if (v[x].size() == 1) {
d.push_back(dis);
return;
}
for (int i = 0; i < v[x].size(); i++) {
if (v[x][i] != p) dfs(v[x][i], x, dis + 1);
}
}
int main() {
int i, a, b, ans = 0;
scanf("%d", &n);
for (i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
a--;
b--;
v[a].push_back(b);
v[b].push_back(a);
}
if (v[0].size()) ans = 1;
for (int i = 0; i < v[0].size(); i++) {
d.clear();
dfs(v[0][i], 0, 0);
if (d.size()) {
sort(d.begin(), d.end());
t[0] = d[0];
for (int j = 1; j < d.size(); j++) t[j] = max(t[j - 1] + 1, d[j]);
ans = max(ans, t[d.size() - 1] + 1);
}
}
cout << ans << endl;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
int map[1010][1010];
int N, M;
void oku() {
int i, a, b;
scanf(" %d %d", &N, &M);
for (i = 1; i <= M; i++) {
scanf(" %d %d", &a, &b);
map[a][b] = i;
}
}
int bak(int a, int b) {
int i, j, max = 0;
for (i = a; i <= a + 2; i++)
for (j = b; j <= b + 2; j++) {
if (!map[i][j]) return 0;
if (map[i][j] > max) max = map[i][j];
}
return max;
}
int main() {
oku();
int i, j, min = INT_MAX, tmp;
for (i = 1; i <= N - 2; i++)
for (j = 1; j <= N - 2; j++)
if (tmp = bak(i, j), tmp && tmp < min) min = tmp;
if (min == INT_MAX)
printf("-1\n");
else
printf("%d\n", min);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mx = 2e5 + 10;
const int oo = 1e9 + 10;
int p[mx];
int o[mx];
set<pair<int, int> > s;
int b[mx];
int a[mx];
bool cmp(int i, int j) { return p[i] > p[j]; }
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", p + i);
o[i] = i;
}
for (int i = 0; i < m; i++) {
int si;
scanf("%d", &si);
s.insert(make_pair(si, i));
}
sort(o, o + n, cmp);
set<pair<int, int> >::iterator it;
int c = 0, u = 0;
memset(b, -1, sizeof b);
for (int ii = 0; ii < n; ii++) {
int i = o[ii];
int from = p[i], to = p[i];
int level = 0;
while (from <= oo) {
it = s.lower_bound(make_pair(from, -1));
if (it != s.end() && it->first <= to) {
b[i] = it->second;
a[it->second] = level;
s.erase(it);
u += level;
c++;
break;
}
level++;
from = from + from - 1;
if (to == oo) break;
to = to + to;
to = min(to, oo);
}
}
printf("%d %d\n", c, u);
for (int i = 0; i < m; i++) printf("%d ", a[i]);
puts("");
for (int i = 0; i < n; i++) printf("%d ", ++b[i]);
puts("");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
void solve(int a, int b) {
int y = min(a, b);
int z = max(a, b);
int x = z - y;
int counter = 0;
counter += x / 10;
if (x % 10 != 0) {
counter++;
}
cout << counter << endl;
}
int main() {
int t;
cin >> t;
int a, b;
while (t--) {
cin >> a >> b;
solve(a, b);
}
}
| 7 | CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.