solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
template <class T>
void pv(T a, T b) {
for (T i = a; i != b; ++i) cout << *i << " ";
cout << endl;
}
int n;
int main() {
cin >> n;
printf("%d", n);
for (int(i) = (1); (i) < (n); (i)++) printf(" %d", i);
printf("\n");
return 0;
}
| 9 | CPP |
from math import sqrt
n = int(input())
m = l = int(sqrt(n))
while (m + 1) * l < n:
m += 1
ans = 2 * (m + l)
if n - (m * l) > 0:
ans += 2
print(ans) | 8 | PYTHON3 |
a=int(input())
for i in range(a):
count=0
b=list(map(int,input().split(" ")[:2]))
if(b[0]%b[1]==0):
print(0)
else:
print(b[1]-(b[0]%b[1])) | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
char strA[100];
int main() {
int N;
vector<string> ips;
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf(" %s", strA);
ips.push_back(strA);
}
vector<string> ret;
for (int i = 0; i < N; i++) {
int sz = 0;
int blocks = 0;
string str = ips[i];
bool used = false;
for (int j = 0; j < ips[i].size();) {
if (str[j] == ':' && str[j + 1] != ':') {
j++;
continue;
}
if (str[j] == ':' && str[j + 1] == ':') {
int bs = 0;
bool ist = false;
for (int v = j + 2; v < str.size(); v++) bs += str[v] == ':';
if (j + 2 < str.size()) blocks += bs + 1;
if (!used && blocks < 8)
printf("0000");
else if (blocks < 8)
printf(":0000");
for (int k = 1; k < 8 - blocks; k++) printf(":0000");
if (j + 2 >= str.size())
break;
else {
j += 2;
continue;
}
}
used = true;
sz = 0;
int kA = j;
for (kA = j; kA < j + 4 && kA < str.size() && str[kA] != ':'; kA++) sz++;
if (j) printf(":");
for (int v = 0; v < 4 - sz; v++) printf("0");
for (int v = j; v < j + sz && v < str.size(); v++) printf("%c", str[v]);
j = kA;
blocks++;
}
printf("\n");
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
#define M 300010
#define LL long long
#define MOD 998244353
int fac[M], inv[M];
inline int C(int n, int m) {
return 1ll * fac[n] * inv[m] % MOD * inv[n - m] % MOD;
}
int main() {
int n, A, B;
LL K;
scanf("%d%d%d%lld", &n, &A, &B, &K);
fac[0] = 1;
for(int i = 1; i <= n; ++ i) fac[i] = 1ll * fac[i - 1] * i % MOD;
inv[0] = inv[1] = 1;
for(int i = 2; i <= n; ++ i) inv[i] = 1ll * inv[MOD % i] * (MOD - MOD / i) % MOD;
for(int i = 2; i <= n; ++ i) inv[i] = 1ll * inv[i - 1] * inv[i] % MOD;
int Ans = 0;
for(int i = 0; i <= n; ++ i) {
if(K - 1ll * A * i >= 0 && (K - 1ll * A * i) % B == 0 && (K - 1ll * A * i) / B <= n) {
Ans += 1ll * C(n, i) * C(n, (K - 1ll * A * i) / B) % MOD;
if(Ans >= MOD) Ans -= MOD;
}
}
printf("%d\n", Ans);
} | 0 | CPP |
#include <iostream>
using namespace std;
int stones[51];
int main(){
while(true){
for(int i = 0;i<=50;i++)stones[i]=0;
int wanposi = 0;
int n,p;
cin >> n;
cin >> p;
if(n==0)break;
int wan = p;
while(true)
{
if(wan!=0){wan--;stones[wanposi]++;}
else{wan=stones[wanposi];stones[wanposi]=0;}
if(stones[wanposi]==p){break;}
else if(wanposi<n-1){wanposi++;}
else wanposi = 0;
}
cout << wanposi << endl;
}
return 0;
} | 0 | CPP |
n,k,x,y=[int(input())for _ in[0]*4];print(min(n,k)*x+max(0,n-k)*y) | 0 | PYTHON3 |
#include<iostream>
#include<sstream>
using namespace std;
string tmp,str;
int num,ans[2],n;
string i2s(int num){
string str;
stringstream s;
s<<num;
s>>str;
return str;
}
void dfs(string str,int cnt){
if(str.size()==1){
ans[cnt%2]=1;
return;
}
tmp="";
num=(str[0]-'0')+(str[1]-'0');
tmp+=i2s(num);
if(str.size()>2)tmp+=str.substr(2,str.size()-2);
dfs(tmp,cnt+1);
}
int main(){
cin>>n;
while(n--){
ans[0]=ans[1]=0;
string str;
cin>>str;
dfs(str,0);
if(!ans[0]) cout<<"Fabre wins."<<endl;
else cout<<"Audrey wins."<<endl;
}
return 0;
} | 0 | CPP |
n, k = map(int, input().split())
while k:
if n%10==0:
n = n//10
else:
n = n-1
k = k-1
print(n) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 505;
int n, m, a[N], x, y, z;
long double ans;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= m; i++) {
cin >> x >> y >> z;
ans = max(ans, (long double)(a[x] + a[y]) / z);
}
cout << fixed << setprecision(10) << ans;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
void FAST_IO(string filein = "", string fileout = "") {
if (fopen(filein.c_str(), "r")) {
freopen(filein.c_str(), "r", stdin);
freopen(fileout.c_str(), "w", stdout);
}
cin.tie(0), cout.tie(0)->sync_with_stdio(0);
}
void Why_Are_You_So_Orz();
signed main() {
FAST_IO("mike4235orz.inp", "mike4235orz.out");
int testcases = 1;
for (int test = 1; test <= testcases; test++) Why_Are_You_So_Orz();
return 0;
}
const int N = 3e5 + 5;
int n, m, dp[N], tr[N], cnt;
vector<pair<int, int>> q[N];
pair<int, int> st[N << 3], lz[N << 3];
void apply(int id, pair<int, int> v) {
lz[id] = max(lz[id], v);
st[id] = max(st[id], v);
}
void push(int id) { apply(id << 1, lz[id]), apply(id << 1 | 1, lz[id]); }
void update(int l, int r, pair<int, int> v, int id = 1, int tl = 1,
int tr = cnt) {
if (l > tr || tl > r) return;
if (l <= tl && tr <= r) return apply(id, v);
int tm = tl + tr >> 1;
push(id);
update(l, r, v, id << 1, tl, tm), update(l, r, v, id << 1 | 1, tm + 1, tr);
st[id] = max(st[id << 1], st[id << 1 | 1]);
}
pair<int, int> query(int l, int r, int id = 1, int tl = 1, int tr = cnt) {
if (l > tr || tl > r) return {0, 0};
if (l <= tl && tr <= r) return st[id];
int tm = tl + tr >> 1;
push(id);
return max(query(l, r, id << 1, tl, tm),
query(l, r, id << 1 | 1, tm + 1, tr));
}
int chk[N];
void Why_Are_You_So_Orz() {
cin >> n >> m;
map<int, int> mp;
for (int i = 1, v, l, r; i <= m; i++) {
cin >> v >> l >> r, mp[l], mp[r], q[v].emplace_back(l, r);
}
for (auto &vp : mp) vp.second = ++cnt;
for (int i = 1; i <= n; i++)
for (auto &v : q[i]) v.first = mp[v.first], v.second = mp[v.second];
for (int i = 1; i <= n; i++) {
pair<int, int> tmp = {0, 0};
for (auto lr : q[i]) tmp = max(tmp, query(lr.first, lr.second));
dp[i] = tmp.first + 1, tr[i] = tmp.second;
for (auto lr : q[i]) update(lr.first, lr.second, {dp[i], i});
}
int pos = max_element(dp + 1, dp + n + 1) - dp;
while (pos) {
chk[pos] = 1, pos = tr[pos];
}
vector<int> res;
for (int i = 1; i <= n; i++)
if (!chk[i]) res.push_back(i);
cout << res.size() << '\n';
for (auto v : res) cout << v << ' ';
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct point {
double x, y;
};
double distance(point a, point b) {
return sqrt(pow(a.x - b.x, 2) + pow(a.y - b.y, 2));
}
int main() {
int n, k;
cin >> n >> k;
point points[n];
for (int i = 0; i < n; i++) {
double x, y;
cin >> x >> y;
points[i].x = x;
points[i].y = y;
}
double total = 0;
for (int i = 0; i < n - 1; i++) {
total += distance(points[i], points[i + 1]);
}
double time_of_one = total / 50.0;
printf("%.9f", k * time_of_one);
return 0;
}
| 7 | CPP |
from math import ceil
num_numbers, position = map(int, input().split())
last_odd_position = ceil(num_numbers/2)
print(2*position - 1) if position <= last_odd_position else print(2*(position - last_odd_position))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, tmp = 0, res = 0, j = 0;
cin >> n;
vector<int> a(n + 1);
for (i = 0; i < n; i++) cin >> a[i];
stack<int> s;
vector<pair<int, int> > output(100000);
for (i = 0; i <= n; i++) {
while (a[i] > tmp) {
s.push(i + 1);
tmp++;
}
while (a[i] < tmp) {
output[j] = make_pair(s.top(), i);
s.pop();
j++;
tmp--;
}
}
cout << j << endl;
for (i = 0; i < j; i++)
cout << output[i].first << " " << output[i].second << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, queCnt, addCnt, subCnt;
vector<int> sign, res[2];
string s;
int main() {
getline(cin, s);
n = 0;
addCnt = 1;
subCnt = 0;
sign.push_back(1);
for (int i = 0; i < s.length(); ++i) {
if (s[i] == '?') queCnt++;
if (s[i] == '-') subCnt++, sign.push_back(0);
if (s[i] == '+') addCnt++, sign.push_back(1);
if (s[i] >= '0' && s[i] <= '9') n = 10 * n + (s[i] - '0');
}
for (int i = subCnt; i <= n * subCnt; ++i) {
int rem = n + i;
if (rem >= addCnt && rem <= n * addCnt) {
int x = rem, y = i;
cout << "Possible" << endl;
for (int j = 0; j < addCnt; ++j)
if (j == addCnt - 1)
res[0].push_back(x);
else
res[0].push_back(1), x--;
if (addCnt >= 2) {
while (res[0][addCnt - 1] > n) {
int z = addCnt - 1;
while (res[0][addCnt - 1] - z <= 0) z--;
res[0][addCnt - 1] -= z;
for (int j = 0; j <= z - 1; ++j) res[0][j]++;
}
}
for (int j = 0; j < subCnt; ++j)
if (j == subCnt - 1)
res[1].push_back(y);
else
res[1].push_back(1), y--;
if (subCnt >= 2) {
while (res[1][subCnt - 1] > n) {
int z = subCnt - 1;
while (res[1][subCnt - 1] - z <= 0) z--;
res[1][subCnt - 1] -= z;
for (int j = 0; j <= z - 1; ++j) res[1][j]++;
}
}
x = 0, y = 0;
for (int j = 0; j < sign.size(); ++j) {
if (j != 0) cout << (sign[j] == 0 ? " - " : " + ");
if (sign[j] == 0)
cout << res[1][x], x++;
else
cout << res[0][y], y++;
}
cout << " = " << n << endl;
exit(0);
}
}
cout << "Impossible" << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define mod 1000000007
#define sz(a) int32_t(a.size())
#define all(a) a.begin(), a.end()
// int prime[1000005];
// void sieve()
// {
// prime[0]=prime[1]=0;
// for(int i=2;i<1000005;i++)
// {
// prime[i]=1;
// }
// for(int i=2;i<1000005;i++)
// {
// if(prime[i]==1)
// {
// for(int j=i*i;j<1000005;j+=i)
// prime[j]=0;
// }
// }
// for(int j=2;j<1000005;j++)
// prime[j]=prime[j]+prime[j-1];
// }
// int dp[200001];
// void lcs(string s,string t,int i,int j,int n,int m,int mxd,int &ans)
// {
// if(i==n || j==m)
// return;
// if(s[i]==t[j])
// {
// ans=max(ans,mxd);
// lcs(s,t,i+1,j+1,n,m,1,ans);
// }
// lcs(s,t,i+1,j,n,m,mxd+1,ans);
// }
void solve()
{
int a,b,k;
cin>>a>>b>>k;
if(a==0)
{
if(k==0)
{
cout<<"Yes"<<endl;
for(int i=1;i<=b;i++)
cout<<"1";
cout<<endl;
for(int i=1;i<=b;i++)
cout<<"1";
cout<<endl;
}
else
cout<<"No"<<endl;
return;
}
if(b==1 )
{
if(k==0)
{
cout<<"Yes"<<endl;
cout<<"1";
for(int i=1;i<=a;i++)
cout<<"0";
cout<<endl;
cout<<"1";
for(int i=1;i<=a;i++)
cout<<"0";
cout<<endl;
}
else
{
cout<<"No"<<endl;
}
return;
}
if(k<=a+b-2)
{
cout<<"Yes"<<endl;
string str="";
for(int i=1;i<=b;i++)
{
str+="1";
cout<<"1";
}
for(int i=1;i<=a;i++)
{
str+="0";
cout<<"0";
}
cout<<endl;
if(k<=a)
{
swap(str[b-1],str[b+k-1]);
cout<<str<<endl;
return;
}
else
{
swap(str[b-1],str[b-1+a]);
k-=a;
swap(str[b-1],str[b-1-k]);
cout<<str<<endl;
return;
}
//cout<<endl;
}
else
cout<<"No"<<endl;
return;
}
int32_t main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
//sieve();
int test=1;
//cin>>test;
while(test--)
{
//dp.clear();
//memset(dp,-1,sizeof(dp));
solve();
}
} | 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, a[10111];
int main() {
while (scanf("%d%d%d", &n, &m, &k) == 3) {
for (int i = (1), _b = (n); i <= _b; i++) scanf("%d", &a[i]);
if (n % 2 == 0) {
puts("0");
continue;
}
int x = a[1];
for (int i = 1; i <= n; i += 2) x = min(x, a[i]);
int each = (n + 1) / 2;
long long minute = m / each;
long long res = min((long long)x, k * minute);
cout << res << endl;
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1e5 + 5;
const int maxx = 70;
const int nprimes = 19;
const int primes[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29,
31, 37, 41, 43, 47, 53, 59, 61, 67};
const int maxmask = 1 << nprimes;
int n, x, bitmask[maxx + 5], cnt[maxx + 5], f[2][maxx + 5];
long long dp[2][maxmask];
int power(int x, int n) {
if (n) {
long long temp = power(x, n / 2);
temp = (temp * temp) % mod;
if (n % 2) {
temp = (temp * x) % mod;
}
return temp;
}
return 1;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &x);
cnt[x]++;
}
for (int i = 1; i <= 70; i++) {
int curr = i, mask = 0, counter;
for (int j = 0; j < nprimes && curr > 1; j++) {
counter = 0;
while (curr % primes[j] == 0) {
curr /= primes[j];
counter++;
}
if (counter % 2) {
mask ^= 1 << j;
}
}
bitmask[i] = mask;
if (cnt[i]) {
f[0][i] = f[1][i] = power(2, cnt[i] - 1);
} else {
f[0][i] = 1;
f[1][i] = 0;
}
}
dp[0][0] = 1;
int curr = 1, prev = 0, newmask;
for (int i = 1; i <= 70; i++) {
for (int j = 0; j < maxmask; j++) {
dp[curr][j] = (dp[curr][j] + dp[prev][j] * f[0][i]) % mod;
newmask = j ^ bitmask[i];
dp[curr][newmask] = (dp[curr][newmask] + dp[prev][j] * f[1][i]) % mod;
}
swap(curr, prev);
for (int j = 0; j < maxmask; j++) {
dp[curr][j] = 0;
}
}
printf("%d\n", (dp[prev][0] - 1 + mod) % mod);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t;
cin >> t;
while (t--) {
long long h, n;
cin >> h >> n;
long long cnt = 0;
long long a[n];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++) {
if (a[i] - a[i + 1] == 1) {
if (i < n - 2) {
if (a[i + 2] + 2 == a[i]) {
i++;
continue;
} else {
a[i + 1] = a[i] - 2;
cnt++;
}
} else if (a[i] > 2) {
cnt++;
}
} else {
a[i] = a[i + 1] + 1;
i--;
}
}
cout << cnt << "\n";
}
}
| 9 | CPP |
n, k = map(int, input().split())
a = list(map(int, input().split()))
answ = 0
for b in range(n):
sm = 0
for i in range(n):
if (i - b) % k:
sm += a[i]
answ = max(answ, abs(sm))
print(answ) | 7 | PYTHON3 |
input();t=[*map(int,input().split())];T=sum(t)
print(*[T-t[i-1]+j for i,j in [[*map(int,input().split())] for _ in range(int(input()))]],sep='\n') | 0 | PYTHON3 |
z,zz,dgraphs=input,lambda:list(map(int,z().split())),{}
from string import *
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f
def lcd(xnum1,xnum2):return (xnum1*xnum2//gcd(xnum1,xnum2))
def prime(x):
p=ceil(x**.5)+1
for i in range(2,p):
if x%i==0:return 0
return 1
def dfs(u,visit,graph):
visit[u]=True
for i in graph[u]:
if not visit[i]:
dfs(i,visit,graph)
################################################################################
"""
led=(6,2,5,5,4,5,6,3,7,6)
vowel={'a':0,'e':0,'i':0,'o':0,'u':0}
color4=["G", "GB", "YGB", "YGBI", "OYGBI" ,"OYGBIV",'ROYGBIV' ]
"""
###########################---START-CODING---####################################
num=int(z())
for _ in range(num):
n=int(z())
l=sorted(zz())
x=l[0]
c=0
for i in l[1:]:
if i-x>1:
c=1
break
x=i
if c==1:
print('NO')
else:print('YES')
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[105];
bool can(int x) {
int sum = 0;
for(int i = 0; i < n; i++) {
sum += a[i];
sum -= x;
if(sum < 0) {
return false;
}
}
return true;
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for(int i = 0; i < n; i++) {
cin >> a[i];
}
int l = 1, r = 100;
while(r - l > 1) {
int mid = (l + r) / 2;
if(can(mid)) l = mid;
else r = mid;
}
cout << (can(l) ? l : r) << endl;
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename V>
ostream &operator<<(ostream &out, const pair<T, V> x) {
out << "{" << x.first << " : " << x.second << "}";
return out;
}
template <typename T>
ostream &operator<<(ostream &out, const set<T> x) {
for (auto &it : x) {
out << it << " ";
}
return out;
}
template <typename T>
ostream &operator<<(ostream &out, const multiset<T> x) {
for (auto &it : x) {
out << it << " ";
}
return out;
}
template <typename T, typename V>
ostream &operator<<(ostream &out, const map<T, V> x) {
for (auto &it : x) {
out << "[" << it.first << "]"
<< " = " << it.second << "\n";
}
return out;
}
template <typename T>
ostream &operator<<(ostream &out, const vector<T> x) {
for (int i = 0; i < x.size() - 1; ++i) {
out << x[i] << " ";
}
out << x.back();
return out;
}
template <typename T>
ostream &operator<<(ostream &out, const vector<vector<T> > x) {
for (int i = 0; i < x.size() - 1; ++i) {
out << "[" << i << "]"
<< " = {" << x[i] << "}\n";
}
out << "[" << x.size() - 1 << "]"
<< " = {" << x.back() << "}\n";
return out;
}
const int N = 2005;
const long long MOD = 998244353;
const long long INF = 1e9;
string s;
long long dp[N][N];
long long cnt[N];
bool can(long long id, char x) { return (s[id] == '?' || s[id] == x); }
long long bin_pow(long long x, long long k) {
long long ret = 1;
while (k) {
if (k & 1) ret *= x;
ret %= MOD;
x *= x;
x %= MOD;
k >>= 1;
}
return ret;
}
long long g(long long l, long long r) {
long long c = cnt[r];
if (l > 0) c -= cnt[l - 1];
return bin_pow(2, c);
}
long long get(long long l, long long r) {
long long sum = 0;
if (l >= r) return 0;
if (dp[l][r] >= 0) return dp[l][r];
if (can(l, '(')) {
if (can(r, ')')) sum += (get(l + 1, r - 1) + g(l + 1, r - 1)) % MOD;
}
if (s[r] != ')') sum += get(l, r - 1);
if (can(l, ')')) {
sum += get(l + 1, r);
if (can(r, '(')) sum -= (get(l + 1, r - 1) + MOD) % MOD;
}
return dp[l][r] = (sum + MOD) % MOD;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> s;
for (long long i = 0; i < s.size(); ++i) {
if (s[i] == '?') cnt[i]++;
if (i > 0) cnt[i] += cnt[i - 1];
}
for (long long i = 0; i < N; ++i)
for (long long j = 0; j < N; ++j) dp[i][j] = -1;
cout << get(0, s.size() - 1);
return 0;
}
| 10 | CPP |
n,x=[int(x) for x in input().split()]
lii=[*map(int,input().split())]
li=set(lii)
t=len(li)==len(lii)
if len(li)<n:
print(0)
quit()
for i in li:
if i&x!=i and i&x in li:
print(1)
quit()
a = set(aa & x for aa in li)
if len(a)<n:
print(2)
quit()
print(-1) | 8 | PYTHON3 |
#include<iostream>
int H, W, K;
int dp[1001][1001][3];
int solve(int x1, int y1, int x2, int y2, int type){
int res = 0;
for(int y=y1;y<=y2;y++){
res += dp[y][x2][type] - dp[y][x1-1][type];
}
return res;
}
int main(){
std::cin >> H >> W >> K;
for(int y=1;y<=H;y++){
for(int x=1;x<=W;x++){
char c;
std::cin >> c;
if(c == 'J')dp[y][x][0]++;
if(c == 'O')dp[y][x][1]++;
if(c == 'I')dp[y][x][2]++;
for(int i=0;i<3;i++){
dp[y][x][i] += dp[y][x-1][i];
}
}
}
while(K--){
int x1, y1, x2, y2;
std::cin >> y1 >> x1 >> y2 >> x2;
std::cout << solve(x1, y1, x2, y2, 0);
for(int t=1;t<3;t++){
std::cout << " " << solve(x1, y1, x2, y2, t);
}
std::cout << "\n";
}
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long N;
long ans=0;
cin >> N;
long x=10;
if(N%2==0&&N>=10){
while(x<=N){
ans+=N/x;
x*=5;
}
}
cout << ans << endl;
} | 0 | CPP |
import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
from collections import defaultdict
def gift():
for _ in range(t):
n,k = list(map(int,input().split()))
array = input()
dic = defaultdict(lambda:0)
dicLis = []
curr = 0
win = 0
score = 0
for i in range(n):
if array[i]=="W":
if win>0:
score+=2
else:
score+=1
win += 1
dicLis.append(curr)
curr=0
else:
win = 0
curr+=1
dicLis.append(curr)
for i in range(1,len(dicLis)-1):
if dicLis[i]:
dic[dicLis[i]]+=1
itemRino = sorted(list(dic.items()))
for ele in itemRino:
gap, count = ele
while count:
if k>=gap:
score += gap*2+1
else:
score += k*2
count-=1
k -= gap
#print(gap,k,score)
if k<=0:
break
if k<=0:
break
if k>0:
if len(dicLis)>1 and dicLis[-1]>0:
score += 2*(min(k,dicLis[-1]))
k-=dicLis[-1]
if k>0:
if len(dicLis)>1:
score += 2*(min(k,dicLis[0]))
k-=dicLis[0]
else:
score += 2*(min(k,dicLis[0]))-1
yield score
if __name__ == '__main__':
t= int(input())
ans = gift()
print(*ans,sep='\n')
#"{} {} {}".format(maxele,minele,minele)
| 8 | PYTHON3 |
N,Q = map(int,input().split())
qs = [tuple(map(lambda x:int(x)-1,input().split())) for i in range(Q)]
M = (N*N+1)//2
ans = []
if N%2:
for y,x in qs:
a = 1
if (x+y)%2:
a += M
a += x//2
a += N * (y//2)
if y%2:
if (x+y)%2:
a += N//2
else:
a += N//2 + 1
ans.append(a)
else:
for y,x in qs:
a = 1
if (x+y)%2:
a += M
a += x//2
a += N//2 * y
ans.append(a)
print(*ans, sep='\n')
| 8 | PYTHON3 |
#include <bits/stdc++.h>
const long long inf = 0x3f3f3f3f3f3f3f3LL;
const long long mod = (long long)1e9 + 7;
using namespace std;
template <class T>
void smin(T& a, T val) {
if (a > val) a = val;
}
template <class T>
void smax(T& a, T val) {
if (a < val) a = val;
}
const long long N = 5 * (long long)1e5 + 10;
long long n, a[N];
void solve0() {
string s, t;
cin >> s >> t;
reverse(s.begin(), s.end());
reverse(t.begin(), t.end());
long long lst = 0;
for (long long i = 0; i < (long long)(t.size()); ++i) {
if (t[i] == '1') {
lst = i;
break;
}
}
long long pos = 0;
for (long long i = lst; i < (long long)(s.size()); ++i) {
if (s[i] == '1') {
pos = i;
break;
}
}
cout << pos - lst << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
solve0();
}
return 0;
}
| 7 | CPP |
for _ in range(int(input())):
n,x = list(map(int,input().split()))
arr = list(map(int,input().split()))
e = 0
for i in arr:
if i%2==0:
e+=1
o = n-e
if x%2!=0:
f = 0
y = min(e,x)+1
for i in range(0,y,2):
val1 = i
val2 = x-i
if o>=val2:
f = 1
break
if f==1:
print("Yes")
else:
print("No")
else:
f = 0
y = min(e,x)+1
for i in range(1,y,2):
val1 = i
val2 = x-i
if o>=val2:
f = 1
break
if f==1:
print("Yes")
else:
print("NO") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e5 * 2 + 7;
int a[maxn], b[maxn], t[4 * maxn], n, W, H;
void build(int v, int l, int r) {
if (r - l == 1) {
t[v] = a[l];
return;
}
build(2 * v + 1, l, (l + r) / 2);
build(2 * v + 2, (l + r) / 2, r);
t[v] = max(t[2 * v + 1], t[2 * v + 2]);
}
int get(int v, int l, int r, int ql, int qr) {
if (ql <= l && qr >= r) return t[v];
if (ql >= r || qr <= l) return 0;
return max(get(2 * v + 1, l, (l + r) / 2, ql, qr),
get(2 * v + 2, (l + r) / 2, r, ql, qr));
}
void upd(int v, int l, int r, int pos, int x) {
if (r - l == 1) {
t[v] = x;
return;
}
if (pos < (l + r) / 2) {
upd(2 * v + 1, l, (l + r) / 2, pos, x);
} else {
upd(2 * v + 2, (l + r) / 2, r, pos, x);
}
t[v] = max(t[2 * v + 1], t[2 * v + 2]);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int ww, hh;
scanf("%d %d", &ww, &hh);
a[i] = hh;
b[i] = ww;
W += ww;
}
build(0, 0, n);
for (int i = 0; i < n; i++) {
W -= b[i];
upd(0, 0, n, i, -10000);
H = get(0, 0, n, 0, n);
printf("%d ", H * W);
W += b[i];
upd(0, 0, n, i, a[i]);
}
return 0;
}
| 8 | CPP |
#include<iostream>
#include<cmath>
using namespace std;
int main(void){
int n;
cin>> n ;
for(int i = 0 ; i < n ; i++){
int a,b; char c;
cin>>a>>c>>b;
// cout<<a<<" "<<b<<endl;
double A =a/12.0+b/60.0/12;
double B =b/60.0;
double judge =fabs(A-B);
// if(180<judge)judge = 360.0 - judge;
// cout<<judge<<endl;
if(judge>0.5){
judge = 1 - judge;
}
if(judge<30.0/360)cout<<"alert"<<endl;
else if(judge<90.0/360)cout<<"warning"<<endl;
else cout<<"safe"<<endl;
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline void pisz(int n) { printf("%d\n", n); }
template <typename T, typename TT>
ostream& operator<<(ostream& s, pair<T, TT> t) {
return s << "(" << t.first << "," << t.second << ")";
}
template <typename T>
ostream& operator<<(ostream& s, vector<T> t) {
for (int(i) = 0; (i) < (((int)((t).size()))); ++(i)) s << t[i] << " ";
return s;
}
int a[55];
int main() {
int(n), (m), (k);
scanf("%d %d %d", &(n), &(m), &(k));
if (m <= k) {
pisz(0);
return 0;
}
for (int(i) = 0; (i) < (n); ++(i)) scanf("%d", a + i);
sort(a, a + n);
reverse(a, a + n);
int s = k;
for (int(i) = (1); (i) <= (n); ++i) {
s += a[i - 1] - 1;
if (s >= m) {
pisz(i);
return 0;
}
}
pisz(-1);
}
| 7 | CPP |
import math
import bisect
import heapq
from collections import defaultdict
def egcd(a, b):
if a == 0:
return (b, 0, 1)
else:
g, x, y = egcd(b % a, a)
return (g, y - (b // a) * x, x)
def mulinv(b, n):
g, x, _ = egcd(b, n)
if g == 1:
return x % n
def isprime(n):
for d in range(2, int(math.sqrt(n))+1):
if n % d == 0:
return False
return True
def argsort(ls):
return sorted(range(len(ls)), key=ls.__getitem__)
def f(p=0):
if p == 1:
return map(int, input().split())
elif p == 2:
return list(map(int, input().split()))
elif p == 3:
return list(input())
else:
return int(input())
class DisjointSet:
_disjoint_set = list()
def __init__(self, init_arr):
self._disjoint_set = []
if init_arr:
for item in list(set(init_arr)):
self._disjoint_set.append([item])
def _find_index(self, elem):
for item in self._disjoint_set:
if elem in item:
return self._disjoint_set.index(item)
return None
def find(self, elem):
for item in self._disjoint_set:
if elem in item:
return self._disjoint_set[self._disjoint_set.index(item)]
return None
def union(self, elem1, elem2):
index_elem1 = self._find_index(elem1)
index_elem2 = self._find_index(elem2)
if index_elem1 != index_elem2 and index_elem1 is not None and index_elem2 is not None:
self._disjoint_set[index_elem2] = self._disjoint_set[index_elem2] + self._disjoint_set[index_elem1]
del self._disjoint_set[index_elem1]
return self._disjoint_set
def get(self):
return self._disjoint_set
def graph(n, m, edg=False):
edges = []
visited = [0]*n
g = [list() for _ in range(n+1)]
for i in range(m):
u, v = f(1)
g[u].append(v)
g[v].append(u)
if edg:
edges.append((u, v))
if edg:
return g, visited, edg
else:
return g, visited
def bfs(g, visited):
queue = [1]
visited[1] = 1
for u in queue:
for v in g[u]:
if visited[v] == 0:
queue.append(v)
visited[v] = 1
def dfs(u, g, visited):
print(u)
visited[u] = 1
for v in g[u]:
if visited[v] == 0:
dfs(v, g, visited)
queue = [0, 0, 0, 0, 0, 0]
n = f()
cl = f(2)
count = 0
for i in range(n):
st = True
pos = 0
if cl[i]==4:
pos = 0
elif cl[i]==8:
pos = 1
elif cl[i]==15:
pos = 2
elif cl[i]==16:
pos = 3
elif cl[i]==23:
pos = 4
elif cl[i]==42:
pos = 5
else:
st = False
if st:
if pos==0:
queue[0]+=1
else:
if queue[pos-1]!=0:
queue[pos-1]-=1
queue[pos]+=1
print(n-queue[-1]*6) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 5;
int a[maxn], b[maxn], n;
int d[maxn][maxn];
bool cmp(const int x, const int y) { return a[x] > a[y]; }
int main() {
int n, m = 0, ans;
scanf("%d", &n);
ans = n;
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
for (int i = 0; i < n; ++i) b[i] = i;
sort(b, b + n, cmp);
for (int i = 0; i < n; ++i) m += (a[i] == n);
if (m > 0) {
int fg = 0;
for (int i = m; i < n; ++i) {
if (a[b[i]] + i > n) fg = 1;
}
if (fg || m > 1) {
for (int i = 1; i < m; ++i) {
d[n][b[i]] = 1;
a[b[i]]--;
}
ans = n + 1;
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < a[b[i]]; ++j) d[(i + j + 1) % n][b[i]] = 1;
}
printf("%d\n", ans);
for (int i = 0; i < ans; ++i) {
for (int j = 0; j < n; ++j) printf("%d", d[i][j]);
puts("");
};
return 0;
}
| 11 | CPP |
import math,sys
from sys import stdin, stdout
from collections import Counter, defaultdict, deque
input = stdin.readline
I = lambda:int(input())
li = lambda:list(map(int,input().split()))
def case():
n=I()
a=li()
b=li()
m,z,o=n,n,n
f=1
for i in range(n):
if(a[i]==-1 and m==n):
m=i
if(a[i]==0 and z==n):
z=i
if(a[i]==1 and o==n):
o=i
#print(m,z,o)
for i in range(n):
if(a[i]==b[i]):
continue
elif(a[i]>b[i] and m>=i):
f=0
break
elif(a[i]<b[i] and o>=i):
f=0
break
if(f):
print("YES")
else:
print("NO")
for _ in range(int(input())):
case() | 8 | PYTHON3 |
#include <bits/stdc++.h>
int fact(int n) {
if (n <= 1)
return 1;
else
return n * fact(n - 1);
}
int main() {
int a, b, x, y, i;
scanf("%d %d", &a, &b);
int n;
if (a > b)
n = b;
else
n = a;
printf("%d\n", fact(n));
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct tree {
int tl, tr, cnt, add;
long long key[5];
tree *l, *r;
tree(){};
tree(int _tl, int _tr) : tl(_tl), tr(_tr), cnt(0), l(0), r(0), add(0) {
key[0] = key[1] = key[2] = key[3] = key[4] = 0;
if (tl != tr) {
l = new tree(tl, (tl + tr) / 2);
r = new tree((tl + tr) / 2 + 1, tr);
}
};
} * T;
typedef tree *node;
void push(node &t) {
if (t->add) {
long long safe[5];
for (int i = 0; i < 5; i++) safe[i] = t->key[i];
if (t->l) t->l->add += t->add;
if (t->r) t->r->add += t->add;
for (int i = 0; i < 5; i++) t->key[i] = safe[(i - t->add + 500000) % 5];
t->add = 0;
};
};
void add(node &t, int pos, long long value, int left_cnt) {
push(t);
if (t->tl == t->tr && t->tl == pos) {
t->cnt = 1;
t->key[left_cnt % 5] = value;
} else {
int mid = (t->tl + t->tr) / 2;
if (pos > mid)
add(t->r, pos, value, left_cnt + t->l->cnt);
else {
t->r->add++;
add(t->l, pos, value, left_cnt);
};
push(t->l);
push(t->r);
for (int i = 0; i < 5; i++) t->key[i] = t->l->key[i] + t->r->key[i];
t->cnt = t->l->cnt + t->r->cnt;
};
};
void del(node &t, int pos) {
push(t);
if (t->tl == t->tr && t->tl == pos) {
t->cnt = 0;
t->key[0] = t->key[1] = t->key[2] = t->key[3] = t->key[4] = 0;
} else {
int mid = (t->tl + t->tr) / 2;
if (pos > mid)
del(t->r, pos);
else {
t->r->add--;
del(t->l, pos);
};
push(t->l);
push(t->r);
for (int i = 0; i < 5; i++) t->key[i] = t->l->key[i] + t->r->key[i];
t->cnt = t->l->cnt + t->r->cnt;
};
};
int N, I, query[200000], val[200000];
string s;
set<int> st;
map<int, int> M;
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++) {
cin >> s;
if (s != "sum") {
if (s == "add")
query[i] = 1;
else
query[i] = 2;
scanf("%I64d", &val[i]);
st.insert(val[i]);
};
};
st.insert(0);
for (set<int>::iterator it = st.begin(); it != st.end(); it++) M[*it] = ++I;
T = new tree(1, I);
add(T, 1, 0, 0);
for (int i = 0; i < N; i++) {
if (query[i] == 0) printf("%I64d\n", T->key[3]);
if (query[i] == 1) add(T, M[val[i]], val[i], 0);
if (query[i] == 2) del(T, M[val[i]]);
};
return 0;
};
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, i;
string s;
cin >> a >> b >> c;
cin >> s;
if (s[b - 1] == s[c - 1]) {
cout << 0 << endl;
} else {
cout << 1 << endl;
}
}
| 7 | CPP |
convert = lambda x: bin(x)[2:].zfill(6)
n = list(convert(int(input())))
n[1], n[5] = n[5], n[1]
n[2], n[3] = n[3], n[2]
print(int("".join(n), 2))
| 7 | PYTHON3 |
#include<cstdio>
#include<queue>
#include<algorithm>
#include<iostream>
using namespace std;
int field[92][92] = { };
int vx[4] = { 1, -1, 0, 0 };
int vy[4] = { 0, 0, 1, -1 };
int ans=0,ANSW=0;
int dfs(int X, int Y, int n){
if (field[X][Y]==0)return n;
field[X][Y] = 0;
for (int i = 0; i < 4; i++){
ans = max(ans, dfs(X + vx[i], Y + vy[i], n + 1));
}
field[X][Y] = 1;
return ans;
}
int main(){
while (1){
ans = 0, ANSW = 0;
int l, m;
scanf("%d%d", &l, &m);
if (l == 0 && m == 0)return 0;
for (int i = 0; i < l; i++){
for (int j = 0; j < m; j++){
cin>> field[i + 1][j + 1];
}
}
for (int i = 0; i < l; i++){
for (int j = 0; j < m; j++){
if (field[i + 1][j + 1])ANSW = max(ANSW, dfs(i + 1, j + 1, 0));
}
}
printf("%d\n", ANSW);
}
} | 0 | CPP |
#include<bits/stdc++.h>
using namespace std;
const int N=2e5+50,M=4040,mod=1e9+7,L=2000;
int n,a[N],b[N],f[M][M],ans,J[N],I[N];
int C(int n,int m){return 1ll*J[n]*I[m]%mod*I[n-m]%mod;}
int main(){
scanf("%d",&n);J[0]=I[0]=I[1]=1;
for(int i=2;i<=4*L;i++)I[i]=mod-1ll*mod/i*I[mod%i]%mod;
for(int i=1;i<=4*L;i++)J[i]=1ll*J[i-1]*i%mod,I[i]=1ll*I[i-1]*I[i]%mod;
for(int i=1;i<=n;i++)scanf("%d%d",&a[i],&b[i]);
for(int i=1;i<=n;i++)f[L-a[i]][L-b[i]]++;
for(int i=0;i<=2*L;i++)for(int j=0;j<=2*L;j++){
if(i)(f[i][j]+=f[i-1][j])%=mod;
if(j)(f[i][j]+=f[i][j-1])%=mod;
}
for(int i=1;i<=n;i++)(ans+=f[L+a[i]][L+b[i]]-C(2*(a[i]+b[i]),2*a[i]))%=mod;
printf("%d\n",(1ll*ans*I[2]%mod+mod)%mod);
return 0;
} | 0 | CPP |
n=input()
n=int(n)
inp_list=[]
for i in range(n):
row=[int(i) for i in input().split()]
inp_list.append(row)
output=0
for inp in inp_list:
s=0
for i in inp:
s+=i
if s>=2:
output+=1
print(output)
| 7 | PYTHON3 |
n = int(input())
cnt = 0
for _ in range(n):
cnt += ('+' in input())
print(2 * cnt - n)
| 7 | PYTHON3 |
n, v = [int(x) for x in input().split()]
seller = []
for i in range (0, n):
items = [int(x) for x in input().split()]
items.pop(0)
minValue = min(items)
if minValue < v:
seller.append(i + 1)
print(len(seller))
for x in seller:
print(x, end= " ") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, b, mod, arr[550], dp[550][550];
long long int go(long long int line, long long int idx, long long int cnt) {
if (idx > n || cnt < 0) return 0;
if (line > m) {
if (cnt >= 0) return 1 % mod;
return 0;
}
if (dp[line][idx] != -1) return dp[line][idx];
long long int result = 0;
result = (result + go(line + 1, idx, cnt - arr[idx])) % mod;
result = (result + go(line, idx + 1, cnt)) % mod;
return dp[line][idx] = result;
}
int main() {
ios_base::sync_with_stdio(false);
long long int i, j, k;
cin >> n >> m >> b >> mod;
for (i = 1; i <= n; i++) cin >> arr[i];
dp[0][0] = 1;
for (k = 1; k <= n; k++) {
for (i = 1; i <= m; i++) {
for (j = 0; j <= b; j++) {
if (arr[k] <= j) {
dp[i][j] = (dp[i][j] + dp[i - 1][j - arr[k]]) % mod;
}
}
}
}
long long int ans = 0;
for (i = 0; i <= b; i++) {
ans = (ans + dp[m][i]) % mod;
}
cout << ans << endl;
return 0;
}
| 7 | CPP |
n = int(input())
for x in range(n):
m = int(input())
odd = False
even = False
l = list(map(int, input().split()))
s = sum(l)
if s%2==1:
print('YES')
continue
else:
for y in l:
if y%2==0:
even = True
else:
odd = True
if (even == True and odd == False) or (odd == True and even == False):
print('NO')
else:
print('YES') | 7 | PYTHON3 |
def update(a,b):
global res
# when we start search for j in lst2 both j and start are at same pos
# now if we get a match at same location then value passed for a = start, while b = j-1
# thus a > b and it hapend when lst1 = 1 2 3 4 , lst2 = 1 2 3 4, this occur when
# two ele in lst2 are adjacent in lst1 i.e. there is nothing to delete in btw them
if a > b:
return True
# getting the len in btw a and b both inclusive
l = b-a+1
apply_x = False
mx = max(lst1[a:b+1])
# checking if we can apply only x_moves , true if any of the side warrior
# is more powerful then all in btw
if a-1 >= 0 and lst1[a-1] > mx:
apply_x = True
if b+1 <= n-1 and lst1[b+1] > mx:
apply_x = True
# if still we cant apply x_moves and l<k i.e. apply only x move
# is the option left then return false
if not apply_x and l < k:
return False
# take remainder these can be delt only with x move, add cost to res
rem = l%k
res += rem*y
l -= rem
# now l is divisible by x and l >= k, thus we can apply only x or only y or a mix
if x <= y*k: # if x is cheaper than y apply x to all
res += (l//k)*x
elif apply_x: # y is cheaper and its possible to apply y to all
res += l*y
else: # y is cheaper but can be applied to all, apply y to all
res += (l-k)*y + x # except k element delete them using x moves
# return true as modification done
return True
def solve():
global res
i,j = 0,0
start = 0
# searching for elements of lst2 in lst1
while i < m:
while j<n and lst1[j] != lst2[i]:
j += 1
# it means ele in lst2 not in lst1 return -1
if j == n:
return -1
# try to update res by cost require to delete moster
# in range start to j-1 inclusive, if update successful it return true
# else false, if false then return -1, this also remove leading moster in
# first attempt
if not update(start,j-1):
return -1
# now ele at index j is saved and we advance to j+1 and i+1
j += 1
start = j
i += 1
# in the end to remove trailing moster after last element of b
if not update(start,n-1):
return -1
return res
res = 0
n,m = map(int, input().split())
x,k,y = map(int, input().split())
lst1 = list(map(int, input().split()))
lst2 = list(map(int, input().split()))
print(solve()) | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long m = 1e9 + 7, n, k, p;
long long e(long long x, long long N) {
if (!N) return 1;
if (N & 1)
return x * e(x, N - 1) % m;
else
return e(x * x % m, N / 2) % m;
}
int main() {
cin >> n >> p >> k;
if (k - 1 && (n + p) & 1)
cout << 0;
else
cout << e(e(2, n - 1), p - 1);
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> niz;
int main() {
cin >> n;
n *= 2;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
niz.push_back(a);
}
sort(niz.begin(), niz.end());
int mini = 1e9;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (i == j) continue;
int broj = 0;
int pom1 = niz[i];
int pom2 = niz[j];
if (i > j) {
niz.erase(niz.begin() + i);
niz.erase(niz.begin() + j);
} else {
niz.erase(niz.begin() + j);
niz.erase(niz.begin() + i);
}
for (int k = 1; k < niz.size(); k += 2) {
broj += abs(niz[k] - niz[k - 1]);
}
niz.push_back(pom1);
niz.push_back(pom2);
sort(niz.begin(), niz.end());
mini = min(mini, broj);
}
}
cout << mini;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<string> S(7);
S = {"SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"};
string s;
cin >> s;
for(int i=0;i<7;i++){
if(s == S.at(i)){
cout << 7 - i << endl;
}
}
} | 0 | CPP |
x1, y1 = [int(i) for i in input().split()]
x2, y2 = [int(i) for i in input().split()]
print(max(abs(x1 - x2) + 1, 2) * 2 + max(abs(y1 - y2) + 1, 2) * 2) | 20 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
inline int rnd(int l, int r) {
uniform_int_distribution<int> uid(l, r);
return uid(rng);
}
const int MOD = 1e9 + 7;
const int INF = 1e9;
const int N = 2e5 + 5;
inline long long pow_mod(long long x, long long n, long long MOD = ::MOD) {
n %= (MOD - 1);
long long res = 1;
while (n) {
if (n & 1) res = (res * x) % MOD;
x = (x * x) % MOD;
n >>= 1;
}
return res;
}
int n, m;
class FenwickTree {
int n;
vector<int> bit;
public:
FenwickTree(int n) {
this->n = n;
bit.assign(n + 1, 0);
}
FenwickTree(vector<int> &a) : FenwickTree((int)a.size()) {
for (int i = 1; i <= n; i++) update(i, a[i - 1]);
}
inline void update(int idx, int delta) {
while (idx <= n) {
bit[idx] = (bit[idx] + delta) % m;
idx += (idx & -idx);
}
}
inline void range_update(int l, int r, int delta) {
update(l, delta);
update(r + 1, -delta);
}
inline int sum(int idx) {
int res = 0;
while (idx > 0) {
res = (res + bit[idx]) % m;
idx -= (idx & -idx);
}
return res;
}
};
FenwickTree t(N);
inline void solve() {
cin >> n >> m;
long long curr = 1, prev = 0;
for (int i = 1; i <= n; i++) {
if (i ^ 1) curr = t.sum(i);
curr = (curr + prev) % m;
for (int j = 2; i * j <= n; j++)
t.range_update(i * j, min(n, i * j + j - 1), curr);
prev = (prev + curr) % m;
}
curr = (curr + m) % m;
cout << curr;
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
while (t--) solve();
}
| 10 | CPP |
(n, c) = [int(r) for r in input().split()]
ts = [int(r) for r in input().split()]
count = 1
prev = ts[0]
for t in ts[1:]:
if t - prev > c:
count = 1
else:
count += 1
prev = t
print(count)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const long long INF = 1e18;
struct UnionFind {
vector<int> par;
vector<int> rank;
vector<long long> Size;
UnionFind(int n = 1) { init(n); }
void init(int n = 1) {
par.resize(n + 1);
rank.resize(n + 1);
Size.resize(n + 1);
for (int i = 0; i <= n; ++i) par[i] = i, rank[i] = 0, Size[i] = 1;
}
int root(int x) {
if (par[x] == x) {
return x;
} else {
int r = root(par[x]);
return par[x] = r;
}
}
bool issame(int x, int y) { return root(x) == root(y); }
bool merge(int x, int y) {
x = root(x);
y = root(y);
if (x == y) return false;
if (rank[x] < rank[y]) swap(x, y);
if (rank[x] == rank[y]) ++rank[x];
par[y] = x;
Size[x] += Size[y];
return true;
}
long long size(int x) { return Size[root(x)]; }
};
long long Last[105000];
int main() {
long long N, M;
cin >> M >> N;
for (int i = 0; i < M; i++) {
Last[i] = -1;
}
vector<long long> a(M), b(N);
for (int i = 0; i < M; i++) cin >> a[i];
for (int i = 0; i < N; i++) cin >> b[i];
vector<pair<long long, pair<long long, long long> > > v;
for (int i = 0; i < M; i++) {
long long s;
cin >> s;
while (s--) {
long long d;
cin >> d;
d--;
v.push_back({a[i] + b[d], {i, d}});
}
}
sort(v.begin(), v.end(),
greater<pair<long long, pair<long long, long long> > >());
long long ans = 0;
UnionFind uni(N);
for (auto tmp : v) {
long long i = tmp.second.first;
long long j = tmp.second.second;
if (Last[i] == -1) {
Last[i] = j;
continue;
}
if (uni.merge(Last[i], j)) {
Last[i] = j;
continue;
}
ans += tmp.first;
}
cout << ans << "\n";
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> t;
int n, x, i, j, h, sol, temp;
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (i = 0; i < n; i++) {
cin >> x;
t.push_back(x);
}
cin >> h;
sort(t.begin(), t.end());
sol = 0;
for (i = 0; i < n; i++) {
temp = 1;
for (j = i + 1; j < n; j++) {
if (t[j] - t[i] <= h) temp++;
}
sol = max(sol, temp);
}
cout << sol << endl;
return 0;
}
| 8 | CPP |
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO, IOBase
def main():
for _ in range(int(input())):
n = int(input())
a = list(map(int,input().split()))
print(max(a[i]*a[i-1] for i in range(1,n)))
# Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main() | 7 | PYTHON3 |
import sys
import heapq
class Solution:
def process(self, n, x, a, b):
# print(n, x, a, b)
for i in range(len(a)):
m = 0
for j in range(len(b) - 1, -1, -1):
if a[i] + b[j] <= x:
m = 1
del b[j]
break
if not m:
break
print("No" if len(b) else "Yes")
def read_int(self, s):
return int(s.strip())
def read_int_arr(self, s):
return [int(x) for x in s.strip().split(' ')]
def parse(self, lines):
n = self.read_int(lines[0])
ind = 1
# print(n)
for _ in range(n):
N, X = self.read_int_arr(lines[ind])
ind += 1
a = self.read_int_arr(lines[ind])
ind += 1
b = self.read_int_arr(lines[ind])
ind += 2
self.process(N, X, a, b)
# a = [self.read_int_arr(lines[i + 1]) for i in range(k)]
def main():
Solution().parse(sys.stdin.readlines())
# def parse(self, lines, n):
# for i in range(n):
# print(*self.process(int(lines[i])))
# def main():
# lines = sys.stdin.readlines()
# n = int(lines[0])
# N, X =
# for i in range(1, n + 1):
# print(i, "---")
# print(lines[i])
# Solution().process(lines[i].strip())
# Solution().process(list(map(int, lines[i].split())))
# Solution().parse(lines[1:], n)
if __name__=='__main__':
main()
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100002;
int n, a[N], ki;
long long f[N];
struct data {
long long val[102][102];
void set() {
memset(val, 0, sizeof(val));
for (int i(1); i <= 100; i++) {
for (int j(1); j <= 100; j++) {
if (i == 1)
val[i][j] = a[j];
else {
if (i - j == 1) val[i][j] = 1;
}
}
}
for (int j = 1; j <= 101; j++) {
if (j == 101)
val[101][j] = 1;
else
val[101][j] = val[1][j];
}
}
};
data res;
data operator*(data a1, data a2) {
for (int i(1); i <= 101; i++) {
for (int j(1); j <= 101; j++) {
res.val[i][j] = 0;
for (int k(1); k <= 101; k++) {
res.val[i][j] =
(res.val[i][j] + a1.val[i][k] * 1ll * a2.val[k][j]) % 1000000007;
}
}
}
return res;
}
data now, e;
void nhan(long long x) {
bool ok = 0;
for (int i(0); i < (30); i++) {
if (i > 0) e = e * e;
if ((((x) >> (i)) & 1)) {
if (!ok) {
now = e;
ok = 1;
} else {
now = now * e;
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> ki;
for (int i(1); i <= n; i++) {
int x;
cin >> x;
a[x]++;
}
f[0] = 1;
for (int i = 1; i <= 1001; i++) {
for (int j(1); j <= 100; j++) {
int x = i - j;
if (x >= 0) f[i] = (f[i] + f[x] * 1ll * a[j]) % 1000000007;
}
}
if (ki <= 100) {
long long res = 0;
for (int i(0); i < (ki + 1); i++) res = (res + f[i]) % 1000000007;
cout << res;
return 0;
}
data tmp;
tmp.set();
e = tmp;
nhan(ki - 100);
long long res = 0, cur = 0;
for (int i = 100; i >= 1; i--) {
res = res + now.val[101][100 - i + 1] * 1ll * f[i];
res %= 1000000007;
cur = cur + f[i];
}
res = res + now.val[101][101] * 1ll * cur;
res %= 1000000007;
cout << (res + 1) % 1000000007;
}
| 11 | CPP |
t=int(input())
for g in range(t):
n,k=map(int,input().split())
if(k>n or (n%2!=0 and k%2==0)):
print("NO")
else:
if(n%2==0):
A=[]
p=k
k=k-1
while(k>0):
A.append(2)
k-=1
if(n-(p-1)*2)%2==0 and n-(p-1)*2>0:
print("YES")
print(*A,end=" ")
print(n-2*(p-1))
elif(n-(p-1))%2!=0 and n-(p-1)>0:
print("YES")
print("1 "*(p-1),end=" ")
print(n-(p-1))
else:
print("NO")
elif(n%2!=0):
if(n-(k-1))%2!=0 and n-(k-1)>0:
print("YES")
print("1 "*(k-1),n-(k-1))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
if (n == 1) {
cout << "Ehab";
return 0;
}
if (n % 2 == 0) {
cout << "Mahmoud";
return 0;
}
if (n % 2 != 0) {
cout << "Ehab";
}
return 0;
}
| 7 | CPP |
n = int(input())
if n==2:
print("NO")
else:
print("YES") if n%2==0 else print("NO") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long int N1 = 1000010;
const long long int N2 = 2000010;
const long long int mod1 = 1e2 + 7;
const long long int mod2 = 1e9 + 7;
int a1[N1], cnt1[N1], cnt2[N1];
pair<int, int> P[N1];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int n;
cin >> n;
;
for (int i = 1; i <= n; i++) cin >> a1[i];
;
for (int i = 1; i <= n; i++) {
if (a1[i] == 1) cnt1[i] = 1;
if (a1[i] == 2) cnt2[i] = 1;
cnt1[i] += cnt1[i - 1];
cnt2[i] += cnt2[i - 1];
}
int id = 0;
long long int mx = max(cnt1[n], cnt2[n]), s = 1;
long long int nw = mx - 1, pos = -1, f = 1;
for (int i = 1; i <= nw + 1; i++) {
long long int x = i, l = 1, r = n, t = 0;
bool ok = 0;
long long int c1 = 0, c2 = 0;
while (true) {
long long int lo = l, hi = n, mid, bs1 = -1, bs2 = -1;
while (lo <= hi) {
mid = (lo + hi) / 2LL;
if (cnt1[mid] - cnt1[l - 1] >= x) {
bs1 = mid;
hi = mid - 1;
} else
lo = mid + 1;
}
lo = l, hi = n;
while (lo <= hi) {
mid = (lo + hi) / 2LL;
if (cnt2[mid] - cnt2[l - 1] >= x) {
bs2 = mid;
hi = mid - 1;
} else
lo = mid + 1;
}
long long int mn = 1e15;
ok = 0;
if (bs1 != -1 && bs2 != -1)
mn = min(bs1, bs2), ok = 1;
else {
if (bs1 != -1)
mn = bs1, ok = 1;
else if (bs2 != -1)
mn = bs2, ok = 1;
}
if (mn == bs1)
c1++;
else if (mn == bs2)
c2++;
if (l == n && i == 1) ok = 1;
l = mn + 1;
t++;
if (l > n || !ok) break;
}
long long int cn = max(c1, c2);
if (cn == c1 && a1[n] != 1) ok = 0;
if (cn == c2 && a1[n] != 2) ok = 0;
if (ok && c1 != c2) P[++id] = make_pair(cn, i);
}
sort(P + 1, P + id + 1);
cout << id << "\n";
for (int i = 1; i <= id; i++)
cout << P[i].first << " " << P[i].second << "\n";
return 0;
}
| 8 | CPP |
n=int(input())
A=list(map(int,input().split()))
Arr=[0 for i in range(21)]
for val in A:
a=bin(val).replace("0b","")
for i in range(len(a)):
Arr[20-i]=Arr[20-i]+int(a[len(a)-1-i])
#print(Arr)
a=sum(Arr)
ans=0
while(a>0):
s=""
for i in range(21):
if (Arr[i]>0):
s=s+"1"
a=a-1
Arr[i]=Arr[i]-1
else:
s=s+"0"
v=int(s,2)
ans=ans+(v*v)
print(ans)
| 10 | PYTHON3 |
#include <iostream>
#include <set>
#include <cstdio>
#include <cstdlib>
#include <queue>
#define REP(i,n) for(int i=0; i<(int)(n); i++)
inline int getInt(){ int s; scanf("%d", &s); return s; }
using namespace std;
typedef pair<int, int> data;
int memo[1<<15];
int W;
vector<int> vk;
vector<int> w;
vector<int> wm;
vector<vector<int> > wss;
int nap(int flag){
if(flag == 0) return 0;
if(memo[flag]) return memo[flag];
int ret = 10000;
for(int i = 1; i < (1 << (int)w.size()); i++){
if(wm[i] <= W && (i | flag) == flag)
ret = min(ret, 1 + nap(flag ^ i));
}
return memo[flag] = ret;
}
int main(){
int n = getInt();
int m = getInt() - 1;
W = getInt();
vector<int> k(n);
int cnt = 0;
REP(i,n){
k[i] = getInt();
if(k[i] != 0 || i == 0){
vk.push_back(i);
wss.push_back(vector<int>());
REP(j,k[i]){
int ww = getInt();
if(i != 0){
wss[wss.size() - 1].push_back(cnt++);
w.push_back(ww);
}
}
}
}
int all = w.size();
if(all == 0){
puts("0");
return 0;
}
wm = vector<int>(1<<all);
REP(i,1<<all) REP(j,all) if(i & (1<<j))
wm[i] += w[j];
int ks = wss.size();
int ans = vk[ks - 1] - m;
int flag = 0;
for(int i = ks - 1; i > 0; i--){
REP(j,wss[i].size())
flag |= (1 << wss[i][j]);
int dist = vk[i] - vk[i - 1];
ans += dist + (dist + dist) * (nap(flag) - 1);
// printf("%d => %d (%d)\n", vk[i], vk[i - 1], ans);
}
printf("%d\n", ans);
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
string s;
int cnt, pos = -1;
int main() {
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '2') {
pos = i;
break;
} else if (s[i] == '0')
cout << '0';
}
cnt = count(s.begin(), s.end(), '1');
for (int i = 0; i < cnt; i++) cout << '1';
if (pos != -1) {
for (int i = pos; i < s.size(); i++) {
if (s[i] != '1') cout << s[i];
}
}
return 0;
}
| 8 | CPP |
#include<iostream>
using namespace std;
int main(){
int n,k,i,keep[111111],p1=0,p2=0,count=0,ans=0;
char s[111111];
cin>>n>>k>>s;
if(s[0]=='0')
count++;
keep[0]=0;
p1++;
for(i=1;i<n;i++){
if(s[i]=='0'){
if(s[i-1]=='1'){
if(count>=k){
if(i-keep[p2]>ans)
ans=i-keep[p2];
p2++;
}
count++;
}
}
else{
if(s[i-1]=='0'){
keep[p1]=i;
p1++;
}
}
}
if(i-keep[p2]>ans)
ans=i-keep[p2];
if(count<=k)
ans=n;
cout<<ans<<endl;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
char s[2020];
int main() {
int n, a, b, t;
cin >> t;
while (t--) {
cin >> n >> a >> b;
int m = 0;
int p = min(26, b);
for (int i = 1; i <= n; i++) {
s[i] = 'a' + m;
m++;
m %= p;
cout << s[i];
}
cout << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> q,sq,e[100010];
int a[100010];
bool v[100010];
void dfs(int x) {
v[x] = true;
if (q.empty() || a[x] >= q[0]) q.push_back(a[x]);
else {
q.push_back(q[0]);
q[0] = a[x];
}
for (int i = 0; i < e[x].size(); i++)
if (!v[e[x][i]]) dfs(e[x][i]);
}
int main() {
int n,m;
scanf("%d%d",&n,&m);
for (int i = 0; i < n; i++) scanf("%d",&a[i]);
while (m--) {
int x,y;
scanf("%d%d",&x,&y);
e[x].push_back(y);
e[y].push_back(x);
}
long long ans = 0, tot = 0;
for (int i = 0; i < n; i++) if (!v[i]) {
tot++;
dfs(i);
ans += q[0];
for (int i = 1; i < q.size(); i++) sq.push_back(q[i]);
q.clear();
}
if (tot < 2) {
printf("0\n");
return 0;
}
if (sq.size() < tot - 2) {
printf("Impossible\n");
return 0;
}
sort(sq.begin(),sq.end());
for (int i = 0; i < tot - 2; i++) ans += sq[i];
printf("%lld\n",ans);
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long gold[100001];
vector<int> g[100001];
unordered_map<int, long long> res;
int vis[100001];
void dfs(int x, int color) {
for (long long k = 0; k < g[x].size(); k++) {
if (vis[g[x][k]] == 0) {
res[color] = min(res[color], gold[g[x][k]]);
vis[g[x][k]] = 1;
dfs(g[x][k], color);
}
}
}
int main() {
int n, m;
cin >> n >> m;
long long x;
int color;
for (long long k = 0; k < n; k++) {
cin >> x;
gold[k + 1] = x;
}
int y;
for (long long k = 0; k < m; k++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
color = 1;
res[1] = 10000000000;
for (long long k = 1; k < n + 1; k++) {
if (vis[k] == 0) {
vis[k] = 1;
res[color] = min(res[color], gold[k]);
dfs(k, color);
color++;
res[color] = 1000000000000000;
}
}
long long sum = 0;
for (long long k = 1; k < color; k++) sum += res[k];
cout << sum;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
vector<pair<int, int>> seg(m);
vector<set<int>> was(n + 1);
for (int i = 0; i < m; ++i) {
cin >> seg[i].first >> seg[i].second;
if (seg[i].first > seg[i].second) {
swap(seg[i].first, seg[i].second);
}
was[seg[i].first].insert(seg[i].second);
}
auto check = [&](int k) {
int cnt = 0;
for (int i = 0; i < m; ++i) {
int l = seg[i].first + k, r = seg[i].second + k;
if (l > n) {
l -= n;
}
if (r > n) {
r -= n;
}
if (l > r) {
swap(l, r);
}
cnt += (was[l].find(r) != was[l].end());
}
return cnt == m;
};
for (int k = 1; k * k <= n; ++k) {
if (k == 1) {
if (check(1)) {
cout << "Yes";
return 0;
}
} else if (n % k == 0) {
if (check(k)) {
cout << "Yes";
return 0;
} else if (check(n / k)) {
cout << "Yes";
return 0;
}
}
}
cout << "No";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int prime = 999983;
const int INF = 0x7FFFFFFF;
const long long INFF = 0x7FFFFFFFFFFFFFFF;
const double pi = acos(-1.0);
const double inf = 1e18;
const double eps = 1e-6;
const long long mod = 1e9 + 7;
long long qpow(long long a, long long b) {
long long s = 1;
while (b > 0) {
if (b & 1) s = s * a % mod;
a = a * a % mod;
b >>= 1;
}
return s;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int dr[2][4] = {1, -1, 0, 0, 0, 0, -1, 1};
struct Val {
int d, id;
};
bool operator<(const Val &a, const Val &b) { return a.d > b.d; }
const int maxn = 2e5 + 10;
Val val[maxn];
int ans[maxn];
vector<pair<int, int> > v;
int main(void) {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
scanf("%d", &val[i].d);
val[i].id = i;
}
sort(val + 1, val + n + 1);
for (int i = 1; i <= n; ++i) {
ans[i] = val[i].id * 2 - 1;
if (i != 1) {
v.push_back(pair<int, int>(val[i].id * 2 - 1, val[i - 1].id * 2 - 1));
}
}
int now = n;
for (int i = 1; i <= n; ++i) {
int y = val[i].id * 2;
if (i + val[i].d - 1 <= now) {
v.push_back(pair<int, int>(y, ans[i + val[i].d - 1]));
}
if (i + val[i].d - 1 == now) ans[++now] = y;
}
for (auto &p : v) printf("%d %d\n", p.first, p.second);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 200000 + 100;
int n;
int a[maxn];
vector<int> disc;
long long bit1[maxn];
long long bitsum[maxn];
int inline lsb(int x) { return x & (-x); }
long long query(long long cc[], int x) {
long long ret = 0;
while (x) {
ret += cc[x];
x -= lsb(x);
}
return ret;
}
void add(long long cc[], int x, int b) {
while (x < disc.size()) {
cc[x] += b;
x += lsb(x);
}
}
int main() {
while (~scanf("%d", &n)) {
disc = {-inf, inf};
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
disc.push_back(a[i]);
}
sort(disc.begin(), disc.end());
disc.erase(unique(disc.begin(), disc.end()), disc.end());
long double ans = 0;
for (int i = 0; i < n; i++) {
int id = lower_bound(disc.begin(), disc.end(), a[i]) - disc.begin();
int L = id - 1, R = id;
if (disc[id - 1] == a[i] - 1) L--;
if (disc[id + 1] == a[i] + 1) R++;
ans += a[i] * (query(bit1, disc.size() - 1) - query(bit1, R) +
query(bit1, L)) -
(query(bitsum, disc.size() - 1) - query(bitsum, R) +
query(bitsum, L));
add(bit1, id, 1);
add(bitsum, id, a[i]);
}
cout << fixed << setprecision(0) << ans << '\n';
}
}
| 10 | CPP |
n=int(input())
s=list(input())
c=0
for i in range(n):
if(s[i:i+3].count('x')==3):
c=c+1
print(c) | 8 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
#define EPS (1e-10)
#define equals(a,b) (fabs((a)-(b))<EPS)
inline int sign(const double &x){
if(x>EPS) return 1;
else if(x<-EPS) return -1;
return 0;
}
/* 点 */
struct Point{
double x,y;
Point(double x=0,double y=0):x(x),y(y){}
Point operator + (Point p) { return Point(x+p.x,y+p.y); }
Point operator - (Point p) { return Point(x-p.x,y-p.y); }
Point operator * (double k) { return Point(k*x,k*y); }
Point operator / (double k) { return Point(x/k,y/k); }
//向量的大小
double abs(){ return sqrt(norm()); }
double norm() { return x*x+y*y; }
bool operator < (const Point & p) const{
return x!=p.x?x<p.x:y<p.y;
}
bool operator == (const Point & p) const {
return fabs(x-p.x)<EPS&&fabs(y-p.y)<EPS;
}
};
//两点间的距离
double getDistance(Point a,Point b){
return (a-b).abs();
}
/* 向量 */
typedef Point Vector;
//向量a和b的内积
double dot(Vector a,Vector b){
return a.x*b.x+a.y*b.y;
}
//向量a和b的外积
double cross(Vector a,Vector b){
return a.x*b.y-a.y*b.x;
}
/* 线段 */
struct Segment{
Point p1,p2;
};
/* 直线 */
typedef Segment Line;
//点到直线的距离
double getDistanceLP(Line l,Point p){
return abs(cross(l.p2-l.p1,p-l.p1)/(l.p2-l.p1).abs());
}
//点到线段的距离
double getDistanceSP(Segment s,Point p){
if(dot(s.p2-s.p1,p-s.p1)<0.0) return (p-s.p1).abs();
if(dot(s.p1-s.p2,p-s.p2)<0.0) return (p-s.p2).abs();
return getDistanceLP(s,p);
}
//判断p2与向量p1-p0的位置关系
const int COUNTER_CLOCKWISE = -1; //逆时针
const int CLOCKWISE = 1; //顺时针
const int ON_SEGMENT = 0; //在线段上
int ccw(Point p0,Point p1,Point p2){
Vector a=p1-p0;
Vector b=p2-p0;
if(cross(a,b)>EPS) return COUNTER_CLOCKWISE;
if(cross(a,b)<EPS) return CLOCKWISE;
return ON_SEGMENT;
}
//判断线段p1p2与线段p3p4是否相交
bool intersect(Point p1,Point p2,Point p3,Point p4){
return ( ccw(p1,p2,p3)*ccw(p1,p2,p4)<=0 &&
ccw(p3,p4,p1)*ccw(p3,p4,p2)<=0 );
}
bool intersect(Segment s1,Segment s2){
return intersect(s1.p1,s1.p2,s2.p1,s2.p2);
}
//线段与线段的距离
double getDistance(Segment s1,Segment s2){
if(intersect(s1,s2)) return 0.0;
return min(min(getDistanceSP(s1,s2.p1),getDistanceSP(s1,s2.p2)),
min(getDistanceSP(s2,s1.p1),getDistanceSP(s2,s1.p2)));
}
/* 直线正交
* 判断向量a，b是否正交 =》a，b的内积为0
*/
bool isOrthogonal(Vector a,Vector b){
return equals(dot(a,b),0.0);
}
bool isOrthogonal(Point a1,Point a2,Point b1,Point b2){
return isOrthogonal(a1-a2,b1-b2);
}
/* 直线平行
* 判断向量a，b是否平行 =》a，b的内积为0
*/
bool isParallel(Vector a,Vector b){
return equals(cross(a,b),0.0);
}
bool isParallel(Point a1,Point a2,Point b1,Point b2){
return isParallel(a1-a2,b1-b2);
}
struct Circle{
Point c;
double r;
Circle(Point c = Point() ,double r = 0.0 ):c(c),r(r){}
};
/* 多边形 */
typedef vector<Point> Polygon;
int main(){
int n;
scanf("%d",&n);
while(n--){
Point p1,p2,p3,p4;
scanf("%lf%lf%lf%lf%lf%lf%lf%lf",&p1.x,&p1.y,&p2.x,&p2.y,&p3.x,&p3.y,&p4.x,&p4.y);
printf("%.10f\n",getDistance(Segment{p1,p2},Segment{p3,p4}));
}
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long X[1048576 + 5], w, n, k, m, b = 1, cst = 0, c1, c2, c3;
int main() {
cin >> w >> n >> k;
m = n;
while (m > 0) {
cst += k;
b *= 10;
m /= 10;
}
m = n;
while (true) {
if (w / cst <= (b - m)) {
m += w / cst;
break;
} else {
w -= (b - m) * cst;
m = b;
cst += k;
b *= 10;
}
}
cout << m - n;
return 0;
}
| 8 | CPP |
import os
from io import BytesIO, IOBase
import sys
from collections import defaultdict, deque, Counter
from bisect import *
from math import sqrt, pi, ceil, log, inf,gcd
from itertools import permutations
from copy import deepcopy
from heapq import *
from sys import setrecursionlimit
def main():
n,a,b,k=map(int,input().split())
h=[]
ans=0
for i in map(int,input().split()):
z=i%(a+b)
if z<=a and z!=0:
ans+=1
else:
h.append(z)
if a>=b:
print(ans+min(len(h),k))
else:
h.sort(key=lambda x:x-a if x!=0 else 100000000000)
for i in h:
if i==0:
i=a+b
i=i-a
y=i//a+(i%a!=0)
if k-y<0:
break
ans+=1
k-=y
print(ans)
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main() | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n,m,i;
char s[200200],t[200200];
int main() {
scanf("%s",s);
n=strlen(s);
for (i=0; i<n; i++) if (m>0 && t[m]=='S' && s[i]=='T') m--; else t[++m]=s[i];
printf("%d\n",m);
return 0;
}
| 0 | CPP |
maxx = int(1e9)
def getVals(type = str):
return list(map(type, input().split()))
class Node:
def __init__(self, val):
self.val = val
self.left = None
self.right = None
self.height = 1
class AVL:
def getHeight(self, node):
if(node == None):
return 0
return node.height
def getBalance(self, node):
if(node == None):
return 0
return self.getHeight(node.left) - self.getHeight(node.right)
def leftRotate(self, node):
x = node.right
y = x.left
x.left = node
node.right = y
node.height = 1 + max(self.getHeight(node.left), self.getHeight(node.right))
x.height = 1 + max(self.getHeight(x.left), self.getHeight(x.right))
return x
def rightRotate(self, node):
x = node.left
y = x.right
x.right = node
node.left = y
node.height = 1 + max(self.getHeight(node.left), self.getHeight(node.right))
x.height = 1 + max(self.getHeight(x.left), self.getHeight(x.right))
return x
def rebalance(self, node, val):
balance = self.getBalance(node)
if(balance > 1):
if(val > node.left.val):
node.left = self.leftRotate(node.left)
return self.rightRotate(node)
if(balance < -1):
if(val < node.right.val):
node.right = self.rightRotate(node.right)
return self.leftRotate(node)
return node
def getMinValNode(self, node):
if node is None or node.left is None:
return node
return self.getMinValNode(node.left)
def insertNode(self, node, val):
if(node == None):
return Node(val)
if(node.val > val):
node.left = self.insertNode(node.left, val)
else:
node.right = self.insertNode(node.right, val)
node.height = 1 + max(self.getHeight(node.left), self.getHeight(node.right))
return self.rebalance(node, val)
def deleteNode(self, node, val):
if(node == None):
return node
if(node.val > val):
node.left = self.deleteNode(node.left, val)
elif(node.val < val):
node.right = self.deleteNode(node.right, val)
else:
if(node.left == None):
tempNode = node.right
node = None
return tempNode
elif(node.right == None):
tempNode = node.left
node = None
return tempNode
tempNode = self.getMinValNode(node.right)
node.val = tempNode.val
node.right = self.deleteNode(node.right, tempNode.val)
node.height = 1 + max(self.getHeight(node.left), self.getHeight(node.right))
return self.rebalance(node, val)
def preOrder(self, node):
ans = []
if(node != None):
ans += self.preOrder(node.left)
ans += [node.val]
ans += self.preOrder(node.right)
return ans
ST = [[maxx, maxx, maxx] for i in range(int(1e5))]
def buildST():
for i in range(n - 1, 0, -1):
ST[i] = min(ST[i << 1], ST[(i << 1) | 1])
def updateST(idx, val):
idx += n
ST[idx][1] = val
while(idx > 1):
ST[idx >> 1] = min(ST[idx], ST[idx ^ 1])
idx >>= 1
def queryMinST(l, r):
l += n
r += n
query = [maxx, maxx, maxx]
while(l < r):
if(l & 1):
query = min(query, ST[l])
l += 1
if(r & 1):
r -= 1
query = min(query, ST[r])
l >>= 1
r >>= 1
return query
n, m = getVals(int)
costs = getVals(int)
adjList = [None for i in range(n)]
def solve(n, m):
for i in range(n):
ST[i + n][0] = -costs[i]
ST[i + n][1] = 0
ST[i + n][2] = i
for i in range(m):
x, y = getVals(int)
x -= 1
y -= 1
adjList[x] = AVL().insertNode(adjList[x], y)
adjList[y] = AVL().insertNode(adjList[y], x)
ST[x + n][1] += costs[y]
ST[y + n][1] += costs[x]
buildST()
ans = 0
for i in range(n):
temp, val, idx= queryMinST(0, n)
ans += val
L = AVL().preOrder(adjList[idx])
ST[idx + n][0] = 0
updateST(idx, int(1e9))
for num in L:
updateST(num, ST[num + n][1] - costs[idx])
# adjList[num] = AVL().deleteNode(adjList[num], idx)
adjList[idx] = None
return ans
print(solve(n, m))
| 9 | PYTHON3 |
t=int(input())
for _ in range(t):
a,b=list(map(int,input().split()))
# print('Hello')
ans=0
for i in range(a):
l=input()
if(i==a-1):
ans+=l.count('D')
elif(l[b-1]=='R'):
ans+=1
else:
continue
print(ans)
| 8 | PYTHON3 |
def prov(a):
for i in range(1, len(a)):
if a[i] < a[i - 1]:
return 0
return len(a)
k = 0
n = int(input())
a = [int(i) for i in input().split()]
sort = []
while 1:
for i in range(len(a)):
sort.append(a[i])
if k == n - 1:
l = prov(sort)
k = 0
sort = []
if l != 0:
print(l)
exit(0)
else:
k += 1
n //= 2
| 7 | PYTHON3 |
t = int(input())
for _ in range(t):
n = int(input())
k = 4
while n % (k - 1) != 0:
k = k << 1
print(n // (k - 1)) | 7 | PYTHON3 |
t = int(input())
for g in range(t):
sumi = 0
n = int(input())
for i in range(1,n//2):
sumi += 2**i
for i in range(n//2,n):
sumi -= 2**i
sumi += 2**n
print(sumi)
| 7 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
int n,a[200010],b[200010],cnt[200010],L,R,l,r;
inline int read()
{
int x=0,w=0;char ch=0;
while(!isdigit(ch)){w|=ch=='-';ch=getchar();}
while(isdigit(ch)){x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
return w?-x:x;
}
int main()
{
r=L=n=read();
for(int i=1;i<=n;i++)cnt[a[i]=read()]++;
for(int i=1;i<=n;i++)cnt[b[n-i+1]=read()]++;
for(int i=1;i<=n;i++)if(cnt[i]>n){cout<<"No";return 0;}
cout<<"Yes\n";
l=R=1;
for(int i=1;i<=n;i++)
if(a[i]==b[i]){L=min(L,i);R=max(R,i);}
for(int i=L;i<=R;i++)
if(l<L&&b[l]!=b[i]&&b[i]!=a[l])swap(b[i],b[l++]);
else swap(b[i],b[r--]);
for(int i=1;i<=n;i++)printf("%d ",b[i]);
} | 0 | CPP |
n,inp = int(input()), [int(i) for i in input().split(" ")]
check, j = inp[:], []
check.sort()
for i in range(n):
if check[i] != inp[i]: j.append(i)
if len(j) > 2 : print("NO")
elif len(j) == 0: print("YES")
else:
inp[j[0]],inp[j[1]] = inp[j[1]],inp[j[0]]
if check == inp: print("YES")
else: print("NO") | 7 | PYTHON3 |
n=int(input())
l=[int(i) for i in input().split()]
l1=[]
l2=[]
for i in range(n-1):
x1=abs(l[i]-l[i-1])
x2=abs(l[i]-l[i+1])
if x1<=x2:
l1.append(x1)
l2.append(-1)
else:
l1.append(x2)
l2.append(1)
c1=min(l1)
c2=l1.index(c1)
c3=c2+l2[c2]
if c3<0:
print(str(c2+1)+" "+str(n-1-c3))
else:
print(str(c2+1)+" "+str(c3+1))
| 7 | PYTHON3 |
#include <cstdio>
int main(){
int H,A;
scanf("%d %d",&H,&A);
printf("%d\n",(H+A-1)/A);
return 0;
} | 0 | CPP |
n = int(input())
nxl = list(map(int, input().split()))
nyl = list(map(int, input().split()))
nxl[0] = 0
nyl[0] = 0
nxl.extend(nyl)
fin = list(set(nxl))
lhs = sum(fin)
ll = list()
for i in range(n+1):
ll.append(i)
if lhs == sum(ll):
print("I become the guy.")
else:
print("Oh, my keyboard!") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxm = 34005;
struct edge {
int to, next;
int l, r;
} e[maxm];
const int maxn = 2344;
int head[maxn], cnt;
int n, m, tot;
struct st {
int a, b, l, r;
bool operator<(st a) const { return r > a.r; }
};
int fa[maxn];
st a[maxm];
int f(int x) { return x == fa[x] ? x : fa[x] = f(fa[x]); }
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) cin >> a[i].a >> a[i].b >> a[i].l >> a[i].r;
sort(a, a + m);
int ans = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j <= n; j++) fa[j] = j;
for (int j = 0; j < m; j++)
if (a[i].l >= a[j].l) {
int x = f(a[j].a);
int y = f(a[j].b);
if (x != y) fa[x] = fa[y];
if (f(1) == f(n)) {
ans = max(ans, a[j].r - a[i].l + 1);
break;
}
}
}
if (ans == 0)
puts("Nice work, Dima!");
else
cout << ans << endl;
}
| 10 | CPP |
#n=int(input())
n,m,k=map(int,input().split())
b=list(map(int,input().split()))
d=[]
for i in range(1,n):
d.append(b[i]-b[i-1])
d.sort()
print(sum(d[:n-k])+k)
| 8 | PYTHON3 |
import sys
input = lambda: sys.stdin.readline().rstrip()
def move(frm, to, x):
mo = frm * x
A[frm-1] -= mo
A[to-1] += mo
ANS.append((frm, to, x))
# assert A[frm-1] >= 0
T = int(input())
for _ in range(T):
N = int(input())
A = [int(a) for a in input().split()]
# print("A =", A)
if sum(A) % N:
print(-1)
continue
if min(A) == max(A):
print(0)
continue
m = sum(A) // N
ANS = []
for i in range(N-1):
move(i+1, i+2, 1)
move(N, 1, 1)
# print("A =", A)
for i in range(1, N)[::-1]:
if A[i] > m:
x = (A[i] - m + i) // (i + 1)
if A[i] - (i + 1) * x < 0:
y = m - (A[i] - (i + 1) * x)
move(1, i+1, y)
move(i+1, 1, x)
else:
move(i+1, 1, x)
for i in range(1, N):
if A[i] < m:
move(1, i+1, m - A[i])
# print("A =", A)
print(len(ANS))
for a in ANS:
print(*a)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[100010];
int sz[100010], n, minsz[100010];
void HLD(int x) {
int i, mx = 0, j = -1, mn = 1e9, l = -1;
sz[x] = 1;
for (i = 0; i < g[x].size(); i++) {
HLD(g[x][i]);
sz[x] += sz[g[x][i]];
if (sz[g[x][i]] > mx) {
mx = sz[g[x][i]];
j = i;
}
if (sz[g[x][i]] < mn) {
mn = sz[g[x][i]];
l = i;
}
}
if (j != -1) swap(g[x][0], g[x][j]);
if (l != -1) minsz[x] = sz[g[x][l]];
}
multiset<int> m1, m2, m3;
int ans[100010];
int root;
void bs(multiset<int> &m, int x, int l, int r, int y, int hanel) {
if (x == root && g[x].size() == 1) return;
int mid, ma = r;
while (l <= r) {
mid = (l + r) / 2;
multiset<int>::iterator it = m.lower_bound(ma - mid + hanel);
int k;
if (it == m.end())
k = 1e9;
else
k = *it - hanel;
if (k + y <= mid) {
ans[x] = min(ans[x], mid);
r = mid - 1;
} else
l = mid + 1;
}
}
void avelacnel(int x, int xf) {
m3.erase(m3.find(sz[x]));
m1.insert(sz[x]);
int i;
if (x == xf)
i = 1;
else
i = 0;
for (; i < g[x].size(); i++) avelacnel(g[x][i], xf);
}
void jnjel(int x) {
m1.erase(m1.find(sz[x]));
m3.insert(sz[x]);
int i;
for (i = 0; i < g[x].size(); i++) jnjel(g[x][i]);
}
void dfs(int x, bool keep) {
int i;
ans[x] = n - 1;
if (g[x].empty()) {
if (keep == false) return;
m1.insert(sz[x]);
m3.erase(m3.find(sz[x]));
return;
}
m2.insert(sz[x]);
m3.erase(m3.find(sz[x]));
for (i = 1; i < g[x].size(); i++) dfs(g[x][i], false);
dfs(g[x][0], true);
if (sz[g[x][0]] >= n - sz[x]) {
int a = n - sz[x], b = n - sz[x];
if (b == 0) b = sz[g[x][0]];
for (i = 1; i < g[x].size(); i++) {
a = max(a, sz[g[x][i]]);
b = min(b, sz[g[x][i]]);
}
bs(m1, x, a, sz[g[x][0]], b, 0);
ans[x] = min(ans[x], sz[g[x][0]]);
}
m3.insert(sz[x]);
avelacnel(x, x);
m2.erase(m2.find(sz[x]));
if (n - sz[x] > sz[g[x][0]]) {
int a = sz[g[x][0]], b = sz[g[x][0]];
for (i = 1; i < g[x].size(); i++) {
b = min(b, sz[g[x][i]]);
}
bs(m2, x, a, n - sz[x], b, sz[x]);
bs(m3, x, a, n - sz[x], b, 0);
}
if (keep == false) jnjel(x);
}
int main() {
int i, x, y;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d%d", &x, &y);
if (x)
g[x].push_back(y);
else
root = y;
}
HLD(root);
for (i = 1; i <= n; i++) m3.insert(sz[i]);
dfs(root, false);
assert(m1.size() + m2.size() + m3.size() == n);
for (i = 1; i <= n; i++) printf("%d\n", ans[i]);
return 0;
}
| 13 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long MOD = 1000000007;
ifstream fin("c.in");
ofstream fout("c.out");
long N, dp[5002][5002], sum1, sum2, ans;
char c[5002];
int main() {
cin >> N;
for (int i = 1; i <= N; i++) cin >> c[i];
dp[0][0] = 1;
for (int i = 1; i <= N; i++) {
sum1 = 0;
for (int j = 0; j <= N; j++) sum1 = (sum1 + dp[i - 1][j]) % MOD;
sum2 = sum1;
if (c[i - 1] == 'f')
if (c[i] == 'f')
for (int j = 0; j <= N; j++) dp[i][j] = dp[i - 1][j - 1];
else
for (int j = 0; j <= N; j++) dp[i][j] = dp[i - 1][j];
else if (c[i] == 'f')
for (int j = 0; j <= N; j++) {
dp[i][j + 1] = sum1;
sum1 = (MOD + sum1 - dp[i - 1][j]) % MOD;
}
else
for (int j = 0; j <= N; j++) {
dp[i][j] = sum2;
sum2 = (MOD + sum2 - dp[i - 1][j]) % MOD;
}
}
for (int i = 0; i <= N; i++) ans = (ans + dp[N][i]) % MOD;
cout << ans << endl;
}
| 9 | CPP |
#!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def S(): return input().rstrip()
def LS(): return S().split()
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')
#solve
def solve(x):
a = LI()
ans = 0
tern = a[0] > 0
tmp = [a[0]]
for i in range(1, x):
if tern:
if a[i] > 0:
tmp.append(a[i])
else:
ans += max(tmp)
tmp = [a[i]]
tern = 0
else:
if a[i] < 0:
tmp.append(a[i])
else:
ans += max(tmp)
tmp = [a[i]]
tern = 1
print(ans + max(tmp))
return
#main
if __name__ == '__main__':
for _ in range(II()):
solve(II())
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t, x, y;
int s1a = 0, s2a = 0, s1b = 0, s2b = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> t >> x >> y;
if (t == 1) {
s1a += x;
s2a += x + y;
} else {
s1b += x;
s2b += x + y;
}
}
if (s1a >= s2a / 2)
cout << "LIVE" << endl;
else
cout << "DEAD" << endl;
if (s1b >= s2b / 2)
cout << "LIVE" << endl;
else
cout << "DEAD" << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n,k;
cin>>n>>k;
cout<< (n<k?0:10);
} | 0 | CPP |
n=int(input())
a=[int(x) for x in input().split()]
s=sum(a)
print("%.12f"%(s/n)) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<int, int> > v;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.push_back(make_pair(x, i + 1));
}
sort(v.begin(), v.end());
for (int i = 0; i < n / 2; i++) {
cout << v[i].second << ' ' << v[n - i - 1].second << endl;
}
cout << endl;
}
| 7 | CPP |
#include <bits/stdc++.h>
const int MAX_LEN = 1010;
using namespace std;
template <typename U, typename V>
string to_string(pair<U, V>);
string to_string(const string& e_) { return "\"" + e_ + "\""; }
string to_string(char e_) { return "\'" + string(1, e_) + "\'"; }
string to_string(bool e_) { return e_ ? "true" : "false"; }
template <typename T>
string to_string(T e_) {
string s_ = "[ ";
for (const auto& x_ : e_) s_ += to_string(x_) + " ";
return s_ + "]";
}
template <typename U, typename V>
string to_string(pair<U, V> e_) {
return "(" + to_string(e_.first) + ", " + to_string(e_.second) + ")";
}
void dbg_str() { ; }
template <typename U, typename... V>
void dbg_str(U u, V... v) {
;
dbg_str(v...);
}
const int N = 2 * 1e5 + 5;
int n, tot, ans;
int b[N];
int p[N];
bool vis[N];
void dfs(int s) {
vis[s] = true;
;
if (!vis[p[s]]) dfs(p[s]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &p[i]);
for (int i = 0; i < n; i++) {
scanf("%d", &b[i]);
tot += b[i];
}
if (tot % 2 == 0) ans++;
int c = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
c++;
dfs(i);
ans++;
}
}
if (c == 1) ans--;
printf("%d\n", ans);
}
| 7 | CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.