solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 100;
int ind[N], q[N], seg[4 * N], lazy[4 * N];
int n;
void shift(int id) {
seg[2 * id] += lazy[id];
lazy[2 * id] += lazy[id];
seg[2 * id + 1] += lazy[id];
lazy[2 * id + 1] += lazy[id];
lazy[id] = 0;
}
void upd(int l, int r, int v, int s = 0, int e = n, int id = 1) {
if (r <= s || e <= l) return;
if (l <= s && e <= r) {
seg[id] += v;
lazy[id] += v;
return;
}
int mid = (s + e) / 2;
shift(id);
upd(l, r, v, s, mid, 2 * id);
upd(l, r, v, mid, e, 2 * id + 1);
seg[id] = max(seg[2 * id], seg[2 * id + 1]);
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
int d;
cin >> d;
ind[d] = i;
}
for (int i = 0; i < n; i++) cin >> q[i];
int r = n;
upd(0, ind[r] + 1, 1);
cout << r << " ";
for (int i = 0; i < n - 1; i++) {
upd(0, q[i], -1);
while (seg[1] <= 0) {
r--;
upd(0, ind[r] + 1, 1);
}
cout << r << " ";
}
cout << "\n";
}
| 11 | CPP |
#pragma region
#include <iostream>
#include <string>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <vector>
#include <map>
#include <queue>
#include <stack>
#include <set>
#include <list>
using namespace std;
typedef long long ll;
//#define rep(i, s, e) for (int(i) = (s); (i) < (e); ++(i))
#define rep(i, e) for (int(i) = 0; (i) < (e); ++(i))
#define rrep(i, s) for (int(i) = (s) - 1; (i) >= 0; --(i))
#define all(x) x.begin(),x.end()
#pragma endregion
int main()
{
int n; cin >> n;
vector<int> d(n + 1);
d[0] = 0;
for (int i = 1; i <= n; ++i)cin >> d[i];
sort(all(d));
rep(i, n + 1)if (i % 2)d[i] = 24 - d[i];
d.push_back(24);
sort(all(d));
int res = 12;
rep(i, n + 1)
{
res = min(res, d[i + 1] - d[i]);
}
cout << res << endl;
} | 0 | CPP |
n=int(input())
for i in range(0,n):
a=list(map(int,input().split()))
b=(a[0]-1)*9+a[1]
print(b)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, mod = 1e9 + 7;
string S;
long long int ans, A[N], R[N], L[N], F[N];
long long int pw(long long int a, long long int b) {
long long int r = 1;
while (b > 0) {
if (b & 1) r *= a, r %= mod;
b >>= 1;
a *= a;
a %= mod;
}
return (r + mod) % mod;
}
long long int inv(long long int x) { return (pw(x, mod - 2) + mod) % mod; }
int main() {
cin >> S;
int n = S.size();
for (int i = 1; i <= n; i++) {
if (S[i - 1] == '(')
L[i] = 1;
else
R[i] = 1;
}
for (int i = 1; i < N; i++) {
L[i] += L[i - 1];
R[i] += R[i - 1];
}
F[0] = 1;
for (int i = 1; i < N; i++) {
F[i] = F[i - 1] * i;
F[i] %= mod;
}
for (int i = 1; i <= n; i++) {
if (S[i - 1] == ')') continue;
long long int l = L[i - 1];
long long int r = R[n] - R[i];
long long int add = (F[l + r] * (inv(F[r - 1]))) % mod;
add *= inv(F[l + 1]);
add %= mod;
ans = (ans + add) % mod;
}
cout << ans << endl;
return 0;
}
| 10 | CPP |
n = int(float(input()))
d = dict(input().split() for _ in range(n))
#print(d)
l = list(d.items())
l1 = []
for i in d:
if d[i] == "rat":
d[i] = 0
elif d[i] == "child" or d[i] == "woman":
d[i] = 1
elif d[i] == "man":
d[i] = 2
else:
d[i] = 3
#print(d)
l = list(d.items())
l1 = []
for i, j in l:
if j == 0:
print(i)
for i, j in l:
if j == 1:
print(i)
for i, j in l:
if j == 2:
print(i)
for i, j in l:
if j == 3:
print(i)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long MOD;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
long long add(long long a, long long b) {
return a + b < MOD ? a + b : a + b - MOD;
}
long long sub(long long a, long long b) {
return a - b >= 0 ? a - b : a - b + MOD;
}
long long mul(long long a, long long b) { return (long long)a * b % MOD; }
long long binpow(long long a, long long n) {
long long res = 1;
while (n > 0) {
if (n & 1) {
res = mul(res, a);
}
a = mul(a, a);
n >>= 1;
}
return res;
}
long long inv(long long a) { return binpow(a, MOD - 2); }
long long divide(long long a, long long b) { return mul(a, inv(b)); }
struct hashe {
vector<long long> a, inv;
void build(string s) {
long long now = 0, pow10 = 1;
reverse(s.begin(), s.end());
for (auto to : s) {
now = add(now, mul(to - '0', pow10));
a.push_back(now);
inv.push_back(binpow(pow10, MOD - 2));
pow10 = mul(pow10, 10);
}
reverse(a.begin(), a.end());
}
long long get(long long l, long long r) {
return mul(sub(a[l], (r + 1 < a.size() ? a[r + 1] : 0)),
inv[(long long)(a.size()) - r - 1]);
}
};
bool stupid_solve(string s, string x) {
hashe hash_s, hash_x;
hash_s.build(s);
hash_x.build(x);
long long n = s.size(), m = x.size();
bool f = 0;
for (long long i = 0; i < s.size(); i++) {
for (long long j = i; j + 1 < s.size(); j++) {
for (long long k = j + 1; k < s.size(); k++) {
if (add(hash_s.get(i, j), hash_s.get(j + 1, k)) ==
hash_x.get(0, m - 1)) {
f = 1;
cout << i + 1 << ' ' << j + 1 << endl;
cout << j + 2 << ' ' << k + 1 << endl;
exit(0);
}
}
}
}
return f;
}
bool solve(string s, string x) {
hashe hash_s, hash_x;
hash_s.build(s);
hash_x.build(x);
long long n = s.size(), m = x.size();
set<long long> st;
st.insert(m);
st.insert(m - 1);
long long super_val = hash_x.get(0, m - 1);
for (auto len : st) {
if (len <= 0 || len > m) continue;
for (long long i = 0; i + len - 1 < n; i++) {
vector<long long> check;
if (len == m) {
long long l = 0, r = len;
while (r - l > 1) {
long long mid = (r + l) / 2;
if (hash_s.get(i, i + mid - 1) == hash_x.get(0, mid - 1)) {
l = mid;
} else {
r = mid;
}
}
for (long long j = -2; j <= 2; j++) check.push_back(m - l + j);
} else {
check.push_back(m);
check.push_back(m - 1);
}
for (auto t : check) {
if (t <= 0 || t > m) continue;
if (i + len + t - 1 < n) {
long long val = add(hash_s.get(i, i + len - 1),
hash_s.get(i + len, i + len + t - 1));
if (val == super_val) {
cout << i + 1 << ' ' << i + len << endl;
cout << i + len + 1 << ' ' << i + len + t << endl;
exit(0);
}
}
if (i - t >= 0) {
long long val =
add(hash_s.get(i, i + len - 1), hash_s.get(i - t, i - 1));
if (val == super_val) {
cout << i - t + 1 << ' ' << i << endl;
cout << i + 1 << ' ' << i + len << endl;
exit(0);
}
}
}
}
}
}
long long prime(long long v) {
for (long long i = 2; i * i <= v; i++) {
if (v % i == 0) return 0;
}
return 1;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
while (1) {
MOD = rnd() % (long long)(1e9) + 1e9;
if (prime(MOD)) break;
}
string s, x;
cin >> s >> x;
solve(s, x);
return 0;
}
| 13 | CPP |
n, A, B = map(int, input().split())
s = list(map(int, input().split()))
ss = sum(s)
s1 = s[0]
sl = s[1:]
sl.sort()
num = 0
while s1*A/ss < B:
ss -= sl.pop()
num += 1
print(num)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long inf = 1 << 30;
int n, m;
int seg[51][5001], a[250010], sum[51][5001], mx[51], mxl[51], mxr[51];
void init() {
int i, j, k, tot;
for (i = 1; i <= n; i++) {
mx[i] = mxl[i] = mxr[i] = -9999999;
tot = 0;
sum[i][0] = 0;
for (j = 1; j <= seg[i][0]; j++) {
tot = ((tot < 0) ? 0 : tot) + seg[i][j];
mx[i] = max(mx[i], tot);
sum[i][j] = sum[i][j - 1] + seg[i][j];
mxl[i] = max(mxl[i], sum[i][j]);
}
for (j = seg[i][0]; j >= 1; j--) {
mxr[i] = max(mxr[i], sum[i][seg[i][0]] - sum[i][j - 1]);
}
}
}
long long sol() {
int i, j;
long long tot, re;
tot = 0;
re = -inf;
for (i = 1; i <= m; i++) {
re = (re > mx[a[i]]) ? re : mx[a[i]];
if (tot < 0) {
tot = mxr[a[i]];
} else {
re = (re > (tot + mxl[a[i]])) ? re : (tot + mxl[a[i]]);
if (tot + sum[a[i]][seg[a[i]][0]] > mxr[a[i]]) {
tot += sum[a[i]][seg[a[i]][0]];
} else {
tot = mxr[a[i]];
}
}
re = (re > tot) ? re : tot;
}
return re;
}
int main() {
int i, j, k;
inf *= 1 << 29;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%d", &seg[i][0]);
for (j = 1; j <= seg[i][0]; j++) scanf("%d", &seg[i][j]);
}
for (i = 1; i <= m; i++) scanf("%d", &a[i]);
init();
long long ans = sol();
printf("%I64d\n", ans);
return 0;
}
| 10 | CPP |
#pragma GCC optimize("Ofast","unroll-loops","omit-frame-pointer","inline")
#pragma GCC option("arch=native","tune=native","no-zero-upper")
#pragma GCC target("avx2")
#include <bits/stdc++.h>
using namespace std;
#define INF 2147483647
#define infL (1LL<<60)
#define inf (1<<30)
#define inf9 (1000000000)
#define MOD 998244353//1000000007
#define EPS 1e-9
#define Gr 9.8
#define PI acos(-1)
#define REP(i,n) for(int (i)=0;(i)<(int)(n);(i)++)
#define REQ(i,n) for(int (i)=1;(i)<=(int)(n);(i)++)
#define lch (rt<<1)
#define rch (rt<<1|1)
#define readmp(n) for(int i=0,u,v;i<n;i++) {scanf("%d%d",&u,&v); mp[u].push_back(v); mp[v].push_back(u);}
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef long double ld;
typedef unsigned int uint;
typedef unsigned long long ull;
typedef ll ValType;
template<typename T> void maxtt(T& t1, T t2) {
t1=max(t1,t2);
}
template<typename T> void mintt(T& t1, T t2) {
t1=min(t1,t2);
}
#define MAX (135)
bool debug = 0;
int n,m,k;
int dx[4] = {0,1,0,-1}, dy[4] = {1,0,-1,0};
string direc="RDLU";
const ll MOD2 = (ll)MOD * (ll)MOD;
ll ln, lk, lm;
void etp(bool f = 0) {
puts(f ?"YES" : "NO");
exit(0);
}
void addmod(int &x, int y, int mod = MOD){
x+=y; if (x>=mod) x-=mod;
if(x<0) x+=mod;
assert(x>=0 && x<mod);
}
void et(int x=-1) {
printf("%d\n", x); exit(0);
}
ll fastPow(ll x, ll y, int mod=MOD) {
ll ans = 1;
while(y>0) {
if(y&1) ans = (x * ans)%mod;
x = x*x%mod;
y>>=1;
}
return ans;
}
ll gcd1(ll x, ll y) {
return y?gcd1(y,x%y):x;
}
//#include <atcoder/all>
//using mint = atcoder::modint1000000007;
string S[10];
int tr[50][26],cnt=1, ed[50*26];
void add(int id) {
int N=S[id].size();
int rt=1;
for(int i=0;i<N;i++) {
int c=S[id][i]-'a';
if (tr[rt][c]==0) tr[rt][c]=++cnt;
rt=tr[rt][c];
}
ed[rt]=id;
}
struct Matrix {
int n,m;
vector<vector<int>> a;
Matrix() { }
Matrix(int n, int m) : n(n), m(m) {
a.resize(n, vector<int>(m));
}
void init(int num) {
REP(i,n)REP(j,m)a[i][j]=num;
}
Matrix operator*(Matrix b) {
Matrix o = Matrix(n, b.m);
for(int i=0;i<n;i++) {
for(int j=0;j<b.m;j++) {
o.a[i][j]=0;
for(int k=0;k<m;k++) {
addmod(o.a[i][j], (ll)a[i][k] * b.a[k][j] % MOD);
}
}
}
return o;
}
Matrix pow(ll p) {
Matrix o = Matrix(n,m);
Matrix b = *this;
for(int i=0;i<n;i++)for(int j=0;j<m;j++) o.a[i][j] = (i==j);
while(p>0) {
if (p&1) o=o*b;
b=b*b; p>>=1;
}
return o;
}
};
map<pii,int> mp;
int mpi;
queue<pii> q;
int gid(int x, int y) {
if(x>y) swap(x,y);
if (mp.find({x,y}) == mp.end()) {
mp[{x,y}]=mpi++;
q.push({x,y});
}
return mp[{x,y}];
}
int A[200][200];
void fmain(int tid) {
scanf("%d%d", &n, &m);
REQ(i,n) cin>>S[i];
REQ(i,n) add(i);
gid(1,1);
while (!q.empty()) {
auto [x,y]=q.front();
q.pop();
int id=gid(x, y);
REP(j,26) {
int X=tr[x][j],Y=tr[y][j];
if(X==0||Y==0) continue;
A[id][gid(X, Y)]++;
if(ed[X]) A[id][gid(1, Y)]++;
if(ed[Y])A[id][gid(X, 1)]++;
if(ed[X]&&ed[Y]) {
A[id][gid(1, 1)]++;
}
}
}
Matrix mt=Matrix(mpi, mpi);
REP(i,mpi)REP(j,mpi)mt.a[i][j]=A[i][j];
Matrix B=mt.pow(m);
printf("%d\n",B.a[0][0]);
}
int main() {
// freopen("in21.txt","r",stdin);
// freopen("output.txt","w",stdout);
int t=1;
// init();
// scanf("%d", &t);
REQ(i,t) {
fmain(i);
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string x;
cin >> x;
int X = 0, Y = 0;
for (int i = 0; i < x.size(); i++) {
if (x[i] == 'L')
X--;
else if (x[i] == 'D')
Y--;
else if (x[i] == 'U')
Y++;
else
X++;
}
if (x.size() % 2 == 0)
cout << (abs(X) + abs(Y)) / 2;
else
cout << "-1";
return 0;
}
| 8 | CPP |
#pragma GCC optimize("2,Ofast,inline")
#include <bits/stdc++.h>
#define LL long long
#define P pair<int, int>
const LL N = 6e4 + 10;
const LL inf = 0x3f3f3f3f;
const LL mod = 998244353;
using namespace std;
template <typename tp>
inline void read(tp &x)
{
x = 0; char c = getchar(); bool f = 0;
for (; c < '0' || c > '9'; f |= (c == '-'), c = getchar()) ;
for (; c >= '0' && c <= '9'; x = (x << 3) + (x << 1) + c - '0', c = getchar()) ;
if (f) x = -x;
}
LL n,cost[510][510];
LL along[510][510],sum_along[510][510];
LL inverse[510][510],sum_inverse[510][510];
LL dp[510][510];
signed main()
{
read(n);
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
{
if(i==j) continue;
read(cost[i][j]);
}
for(int i=1;i<=n;i++)
for(int j=1;j<i;j++)
sum_along[j][i]=sum_along[j-1][i]+cost[j][i];
for(int i=1;i<=n;i++)
for(int j=i+1;j<=n+1;j++)
along[i][j]=along[i][j-1]+sum_along[j-1][j]-sum_along[i-1][j];
for(int i=1;i<=n;i++)
for(int j=1;j<i;j++)
sum_inverse[j][i]=sum_inverse[j-1][i]+cost[i][j];
for(int i=1;i<=n+1;i++)
for(int j=n+1;j>i;j--)
inverse[i][j]=inverse[i][j+1]+sum_inverse[i][j];
memset(dp,0x3f,sizeof(dp));
dp[0][0]=0;
for(int i=0;i<=n;i++)
for(int j=i;j<=n;j++)
if(dp[i][j]<1e18)
for(int k=j+1;k<=n+1;k++)
dp[j][k]=min(dp[j][k],dp[i][j]+along[j+1][k]+inverse[j][k+1]-inverse[i][k+1]);
LL ans=1e18;
for(int i=0;i<=n;i++)
ans=min(ans,dp[i][n+1]);
printf("%lld\n",ans);
return 0;
}
| 0 | CPP |
s = input()
ch = ord('a')
tong = 0;
for i in range(len(s)):
d = abs((ord(s[i])-ch))
if d < 13:
tong += d
else:
tong += 26-d
ch = ord(s[i])
print(tong) | 7 | PYTHON3 |
a,b=map(int,input().split())
if(a==b):
print('Equal')
exit()
import math
lcm=(a*b)//(math.gcd(a,b))
if(a<b):
da=(lcm//a)-1
ma=lcm//b
if(da>ma):
print('Dasha')
elif(da<ma):
print('Masha')
else:
print('Equal')
else:
da=(lcm//a)
ma=(lcm//b)-1
if(da>ma):
print('Dasha')
elif(da<ma):
print('Masha')
else:
print('Equal')
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool can_take_over(string &s, string &t, vector<long long> &a, long long idx) {
long long n = (long long)s.length(), m = (long long)t.length();
vector<bool> can_take(n, true);
for (long long i = 0; i <= idx; i++) {
can_take[a[i]] = false;
}
long long i_t = 0, i_s = 0;
while (i_t < m) {
while (i_s < n && (s[i_s] != t[i_t] || !can_take[i_s])) {
i_s++;
}
if (i_s == n) {
return false;
}
i_t++;
i_s++;
}
return true;
}
void test_case() {
string t, p;
cin >> t >> p;
long long n = (long long)t.length();
vector<long long> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
a[i]--;
}
if (t == p) {
cout << 0 << "\n";
return;
}
long long start = -1;
for (long long step = n; step >= 1; step /= 2) {
while (start + step < n && can_take_over(t, p, a, start + step)) {
start += step;
}
}
cout << start + 1 << "\n";
return;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long t = 1;
while (t--) {
test_case();
}
return 0;
}
| 7 | CPP |
t = int(input())
while t!=0:
n = int(input())
A = list(map(int,input().split()))
d = [2,3,5,7,11,13,17,19,23,29,31]
res = [0]*n
i = 0
while i < 11:
j = 0
while j < n:
if A[j]%d[i] == 0:
res[j] = i+1
j+=1
i += 1
x = len(set(res))
B = [1]
l = 1
k = 1
while k < n:
if res[k] not in res[:k]:
l+=1
B.append(l)
else:
B.append(B[res.index(res[k])])
k += 1
print(x)
print(*B)
t-=1 | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7, N = 2e5 + 5;
int n, k, res, s[N];
inline int Pow (int a, int b) {
int t = 1;
while (b) {
if (b & 1) t = 1ll * t * a % mod;
a = 1ll * a * a % mod, b >>= 1;
} return t;
}
inline int C (int n, int m) {
if (!m) return 1;
return 1ll * Pow (1ll * s[m] * s[n - m] % mod, mod - 2) * s[n] % mod;
}
signed main() {
scanf ("%d %d", &n, &k); s[1] = 1;
for (int i = 2; i <= n; ++i) s[i] = 1ll * s[i - 1] * i % mod;
for (int i = 1; i <= min (n - 1, k); ++i)
res = (res + 1ll * C (n, i) * C (n - 1, n - i - 1) % mod) % mod;
return printf ("%d\n", res + 1), 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define each(i,a) for (auto&& i : a)
#define FOR(i,a,b) for (ll i=(a),__last_##i=(b);i<__last_##i;i++)
#define RFOR(i,a,b) for (ll i=(b)-1,__last_##i=(a);i>=__last_##i;i--)
#define REP(i,n) FOR(i,0,n)
#define RREP(i,n) RFOR(i,0,n)
#define __GET_MACRO3(_1, _2, _3, NAME, ...) NAME
#define rep(...) __GET_MACRO3(__VA_ARGS__, FOR, REP)(__VA_ARGS__)
#define rrep(...) __GET_MACRO3(__VA_ARGS__, RFOR, RREP)(__VA_ARGS__)
#define pb push_back
#define all(a) (a).begin(),(a).end()
#define chmin(x,v) x = min(x, v)
#define chmax(x,v) x = max(x, v)
const ll linf = 1e18;
const int inf = 1e9;
const double eps = 1e-12;
const double pi = acos(-1);
template<typename T>
istream& operator>>(istream& is, vector<T>& vec) {
each(x,vec) is >> x;
return is;
}
template<typename T>
ostream& operator<<(ostream& os, const vector<T>& vec) {
rep(i,vec.size()) {
if (i) os << " ";
os << vec[i];
}
return os;
}
template<typename T>
ostream& operator<<(ostream& os, const vector< vector<T> >& vec) {
rep(i,vec.size()) {
if (i) os << endl;
os << vec[i];
}
return os;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n; string s;
while (cin >> n >> s, n || s != "0") {
ll m = linf;
vector<ll> ans;
bool rejected = false;
try {
set<vector<ll>> used;
rep(a, 7) rep(b, 7) rep(c, 7) rep(d, 7) rep(e, 7) rep(f, 7) {
if (a + b + c + d + e + f != s.size()) continue;
vector<ll> v;
if (a) v.pb(a);
if (b) v.pb(b);
if (c) v.pb(c);
if (d) v.pb(d);
if (e) v.pb(e);
if (f) v.pb(f);
if (used.count(v) > 0) continue;
used.insert(v);
ll cnt = 0;
vector<ll> vals;
bool flag = true;
rep(i, v.size()) {
string str = s.substr(cnt, v[i]);
if (str.size() > 1 && str[0] == '0') {
// flag = false;
// break;
}
vals.pb(stoll(str));
cnt += v[i];
}
if (!flag) continue;
ll sum = 0;
rep(i, vals.size()) sum += vals[i];
if (sum > n) continue;
if (n - sum == m) {
rejected = true;
}
else if (n - sum < m) {
rejected = false;
m = n - sum;
ans = vals;
}
}
if (rejected) throw string("rejected");
if (m == linf) throw string("error");
cout << n - m << " " << ans << endl;
}
catch (string err) {
cout << err << endl;
}
}
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool sortbysecdesc(const pair<int, int> &a, const pair<int, int> &b) {
return a.second > b.second;
}
bool sortinrev(const pair<int, int> &a, const pair<int, int> &b) {
return (a.first > b.first);
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
int findGCD(long long a[], long long n) {
int result = a[0];
for (int i = 1; i < n; i++) {
result = gcd(a[i], result);
if (result == 1) {
return 1;
}
}
return result;
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long n, m, k, count = 0;
cin >> n >> m >> k;
long long a[m + 1];
for (int i = 0; i < int(m + 1); i++) cin >> a[i];
for (int i = 0; i < int(m); i++) {
if (__builtin_popcount(a[i] ^ a[m]) <= k) count++;
}
cout << count << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
const int inf = 0x3f3f3f3f;
const long long mod = 1e9 + 7;
const double eps = 1e-10;
int lowbit(int x) { return x & (-x); }
long long powmod(long long x, long long k) {
long long res = 1;
for (; k; k >>= 1, x = x * x % mod)
if (k & 1) res = res * x % mod;
return res;
}
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
template <class T>
void Min(T &a, T b) {
if (a > b) a = b;
}
template <class T>
void Max(T &a, T b) {
if (a < b) a = b;
}
template <class T>
void add(T &a, T b) {
a += b;
if (a >= mod) a -= mod;
}
template <class T>
void rd(T &x) {
static char c;
x = 0;
int f = 1;
while (c = getchar(), c < 48)
if (c == '-') f = -1;
do x = (x << 1) + (x << 3) + (c ^ 48);
while (c = getchar(), c > 47);
x *= f;
}
const int N = 1e6 + 5;
const int M = 2e6 + 5;
long long la, lb, len, tot;
long long c00, c01, c10, c11;
char a[N], b[N];
int A[N], B[N];
long long fac[M], inv[M];
void gmod(long long &x) { x = (x % mod + mod) % mod; }
void prepare() {
fac[0] = inv[0] = inv[1] = 1;
for (int i = (1), __t = (M); i < __t; i++) fac[i] = fac[i - 1] * i % mod;
for (int i = (2), __t = (M); i < __t; i++)
inv[i] = inv[mod % i] * (mod - mod / i) % mod;
for (int i = (1), __t = (M); i < __t; i++) inv[i] = inv[i - 1] * inv[i] % mod;
}
long long C(long long a, long long b) {
if (a < 0 || b < 0) return 0;
if (a < b) return 0;
return fac[a] * inv[b] % mod * inv[a - b] % mod;
}
long long calc(long long b, long long a) {
if (b == 0) return 1;
return C(b + a - 1, a - 1);
}
long long solve0(long long c00, long long c01, long long c10, long long c11) {
if (c00 < 0 || c01 < 0 || c10 < 0 || c11 < 0) return 0;
if (c01 == c10)
return calc(c11, c10) * calc(c00, c01 + 1) % mod;
else if (c01 == c10 + 1)
return calc(c00, c01) * calc(c11, c10 + 1) % mod;
else
return 0;
}
long long solve1(long long c00, long long c01, long long c10, long long c11) {
if (c00 < 0 || c01 < 0 || c10 < 0 || c11 < 0) return 0;
if (c01 == c10)
return calc(c11, c01 + 1) * calc(c00, c01) % mod;
else if (c10 == c01 + 1)
return calc(c11, c10) * calc(c00, c01 + 1) % mod;
else
return 0;
}
long long calc1() {
long long res = 0, c0 = c00, c1 = c01, c2 = c10, c3 = c11;
int las = B[0];
for (int i = (1), __t = (tot); i < __t; i++) {
if (B[i] == 1) {
if (las == 0)
add(res, solve0(c00 - 1, c01, c10, c11));
else
add(res, solve0(c00, c01, c10 - 1, c11));
}
if (las == 0 && B[i] == 1) c01--;
if (las == 0 && B[i] == 0) c00--;
if (las == 1 && B[i] == 1) c11--;
if (las == 1 && B[i] == 0) c10--;
las = B[i];
}
gmod(res);
if (!c00 && !c01 && !c10 && !c11) add(res, 1ll);
gmod(res);
c00 = c0, c01 = c1, c10 = c2, c11 = c3;
return res;
}
long long calc2() {
long long res = 0;
long long c0 = c00, c1 = c01, c2 = c10, c3 = c11;
int las = A[0];
for (int i = (1), __t = (tot); i < __t; i++) {
if (A[i] == 1) {
if (las == 0)
add(res, solve0(c00 - 1, c01, c10, c11));
else
add(res, solve0(c00, c01, c10 - 1, c11));
}
if (las == 0 && A[i] == 1) c01--;
if (las == 0 && A[i] == 0) c00--;
if (las == 1 && A[i] == 1) c11--;
if (las == 1 && A[i] == 0) c10--;
las = A[i];
}
gmod(res);
c00 = c0, c01 = c1, c10 = c2, c11 = c3;
return res;
}
int main() {
prepare();
scanf("%s%s", a, b);
la = strlen(a), lb = strlen(b);
for (int i = (0), __t = (la); i < __t; i++) A[i] = a[i] - '0';
for (int i = (0), __t = (lb); i < __t; i++) B[i] = b[i] - '0';
rd(c00), rd(c01), rd(c10), rd(c11);
tot = c01 + c10 + c00 + c11 + 1;
long long ans = 0;
if (tot > lb)
return puts("0"), 0;
else if (tot < lb)
ans += solve1(c00, c01, c10, c11);
else if (tot == lb)
ans += calc1();
gmod(ans);
if (la > tot)
return puts("0"), 0;
else if (tot < la)
ans -= solve0(c00, c01, c10, c11);
else if (la == tot)
ans -= calc2();
gmod(ans);
printf("%lld\n", ans);
return 0;
}
| 16 | CPP |
a,b,c=map(int,input().split())
m=max([a,b,c])
r=a+b+c-m
print(max(0,m-r+1)) | 7 | PYTHON3 |
n,m = [int(i) for i in input().split()]
array = [int(i) for i in input().split()]
def bins(a, b):
if a == b:
return a
mid = (a+b)//2
if good(mid):
return bins(a, mid)
else:
return bins(mid+1, b)
def good(k):
q = k - m
arr = array[:]
if arr[0] + q >= 0:
arr[0] = 0
for i in range(1, n):
d = arr[i-1] - arr[i]
if d > k:
return False
if d > 0 or d <= q:
arr[i] = arr[i-1]
# if arr[i] < arr[i-1]: #d>0
# if arr[i-1] - arr[i] > k:#d>k
# return False
# else:
# arr[i] = arr[i-1]
# else:#d<=0
# if arr[i] + k - m >= arr[i-1]:#d <= k-m
# arr[i] = arr[i-1]
return True
print(bins(0, m-1)) | 7 | PYTHON3 |
def bod(n):
return int(n,2)
x=(bod(str(input())));j=0;
for i in range(50):
if(x>(pow(4,i))):
j +=1
else:
break;
print(j)
| 7 | PYTHON3 |
# from math import factorial as fac
from collections import defaultdict
# from copy import deepcopy
import sys, math
f = None
try:
f = open('q1.input', 'r')
except IOError:
f = sys.stdin
if 'xrange' in dir(__builtins__):
range = xrange
# print(f.readline())
sys.setrecursionlimit(10**2)
def print_case_iterable(case_num, iterable):
print("Case #{}: {}".format(case_num," ".join(map(str,iterable))))
def print_case_number(case_num, iterable):
print("Case #{}: {}".format(case_num,iterable))
def print_iterable(A):
print (' '.join(A))
def read_int():
return int(f.readline().strip())
def read_int_array():
return [int(x) for x in f.readline().strip().split(" ")]
def rns():
a = [x for x in f.readline().split(" ")]
return int(a[0]), a[1].strip()
def read_string():
return list(f.readline().strip())
def ri():
return int(f.readline().strip())
def ria():
return [int(x) for x in f.readline().strip().split(" ")]
def rns():
a = [x for x in f.readline().split(" ")]
return int(a[0]), a[1].strip()
def rs():
return list(f.readline().strip())
def bi(x):
return bin(x)[2:]
from collections import deque
import math
# NUMBER = 10**9 + 7
NUMBER = 998244353
def factorial(n) :
M = NUMBER
f = 1
for i in range(1, n + 1):
f = (f * i) % M # Now f never can
# exceed 10^9+7
return f
def mult(a,b):
return (a * b) % NUMBER
def minus(a , b):
return (a - b) % NUMBER
def plus(a , b):
return (a + b) % NUMBER
def egcd(a, b):
if a == 0:
return (b, 0, 1)
else:
g, y, x = egcd(b % a, a)
return (g, x - (b // a) * y, y)
def modinv(a):
m = NUMBER
g, x, y = egcd(a, m)
if g != 1:
raise Exception('modular inverse does not exist')
else:
return x % m
def choose(n,k):
if n < k:
assert false
return mult(factorial(n), modinv(mult(factorial(k),factorial(n-k))))
from collections import deque, defaultdict
import heapq
def solution(a,n):
sol = [a[0]]
if a[1] > a[0]:
up = True
else:
up = False
sol.append(a[1])
for i in range(1,n):
if a[i] > a[i-1]:
if up:
sol[-1] = a[i]
else:
sol.append(a[i])
up = True
else:
if not up:
sol[-1] = a[i]
else:
sol.append(a[i])
up = False
return str(len(sol)) + '\n' + ' '.join(map(str,sol))
def main():
T = ri()
for i in range(T):
n = ri()
# n,x = ria()
a = ria()
# b = ria()
x = solution(a,n)
if 'xrange' not in dir(__builtins__):
print(x)
else:
print >>output,str(x)# "Case #"+str(i+1)+':',
if 'xrange' in dir(__builtins__):
print(output.getvalue())
output.close()
if 'xrange' in dir(__builtins__):
import cStringIO
output = cStringIO.StringIO()
#example usage:
# for l in res:
# print >>output, str(len(l)) + ' ' + ' '.join(l)
if __name__ == '__main__':
main()
| 8 | PYTHON3 |
s=input()
ans=s[1:]
c=s[0].upper()
ans=c+ans
print(ans) | 7 | PYTHON3 |
s = input()
for i in range(0, len(s) - 7 + 1):
if len(set(s[i:i+7])) == 1:
print("YES")
break
else:
print("NO")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int ti = 0; ti < t; ++ti) {
int n, x;
cin >> n >> x;
string s;
cin >> s;
vector<int> cnt(n);
cnt[0] = (s[0] == '0' ? 1 : -1);
for (int i = 1; i < n; ++i) cnt[i] = cnt[i - 1] + (s[i] == '0' ? 1 : -1);
int total = 0;
if (cnt[n - 1] == 0) {
for (int i = 0; i < n; ++i)
if (cnt[i] == x) {
total = -1;
break;
}
} else {
if (x == 0) ++total;
int p = x / cnt[n - 1], q = x % cnt[n - 1];
for (int i = 0; i < n; ++i)
if ((cnt[i] - q) / cnt[n - 1] <= p && (cnt[i] - q) % cnt[n - 1] == 0)
++total;
}
cout << total << endl;
}
}
| 8 | CPP |
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a%b)
n, x = map(int, input().split())
print(3*(n - gcd(n, x)))
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
int rt[N], cnt, b[N], bel[N], lans, n, m;
struct node {
int fa, siz, val;
int son[2];
} tr[N];
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + (ch ^ 48);
ch = getchar();
}
return x * f;
}
inline bool which_son(int x) { return x == tr[tr[x].fa].son[1]; }
inline void pushup(int x) {
tr[x].siz = tr[tr[x].son[0]].siz + tr[tr[x].son[1]].siz + 1;
}
int newnode(int f, int x) {
tr[x].siz = 1;
tr[x].son[0] = tr[x].son[1] = 0;
tr[x].fa = f;
return x;
}
inline void rotate(int x) {
int f = tr[x].fa, ff = tr[f].fa;
bool w = which_son(x);
tr[f].son[w] = tr[x].son[w ^ 1];
tr[tr[x].son[w ^ 1]].fa = f;
tr[x].fa = ff;
tr[x].son[w ^ 1] = f;
tr[f].fa = x;
if (ff) {
tr[ff].son[tr[ff].son[1] == f] = x;
}
pushup(f);
pushup(x);
}
inline void splay(int x, int goal) {
for (int f; (f = tr[x].fa) != goal;) {
if (tr[f].fa != goal) {
rotate(which_son(x) == which_son(f) ? f : x);
}
rotate(x);
}
if (goal == 0) {
rt[bel[x]] = x;
}
}
inline void insert(int f, int p, int x) {
if (!f)
rt[bel[x]] = newnode(0, x);
else {
tr[f].son[p] = newnode(f, x);
splay(x, 0);
}
}
int find(int x, int k) {
if (!x || tr[x].siz < k) return 0;
while (x) {
if (k == tr[tr[x].son[0]].siz + 1) break;
if (k > tr[tr[x].son[0]].siz + 1)
k -= tr[tr[x].son[0]].siz + 1, x = tr[x].son[1];
else
x = tr[x].son[0];
}
return x;
}
inline int pre(int x) {
int now = tr[x].son[0];
while (tr[now].son[1]) now = tr[now].son[1];
return now;
}
inline int nxt(int x) {
int now = tr[x].son[1];
while (tr[now].son[0]) now = tr[now].son[0];
return now;
}
inline void del(int &r, int x) {
int q = pre(r), p = nxt(r);
if (!q && !p) {
r = 0;
return;
}
if (!q) {
splay(p, 0);
tr[p].son[0] = 0;
pushup(p);
return;
}
if (!p) {
splay(q, 0);
tr[q].son[1] = 0;
pushup(q);
return;
}
splay(q, 0);
splay(p, q);
tr[p].son[0] = 0;
pushup(p);
pushup(q);
}
int ans;
inline int s_ize(int x) {
x -= n;
splay(x, 0);
return tr[tr[x].son[0]].siz + 1;
}
inline void _pre(int x, int lim) {
if (!x) return;
while (x) {
if (s_ize(x) >= lim)
ans = x, x = tr[x].son[0];
else
x = tr[x].son[1];
}
}
inline void _nxt(int x, int lim) {
if (!x) return;
while (x) {
if (s_ize(x) <= lim)
ans = x, x = tr[x].son[1];
else
x = tr[x].son[0];
}
}
inline void change(int k, int k1) {
splay(k, 0);
del(rt[bel[k]], k);
splay(k1, 0);
if (tr[tr[k1].son[0]].siz == 0)
insert(k1, 0, k);
else {
int q = pre(rt[bel[k1]]);
splay(q, k1);
insert(q, 1, k);
}
}
inline void moving(int l, int r) {
if (l == r) return;
int k = find(rt[0], r), k1 = find(rt[0], l);
change(k, k1);
ans = 0;
_pre(rt[tr[k].val], l);
if (ans == k + n) return;
change(k + n, ans);
}
inline void query(int l, int r, int k) {
int t = lower_bound(b + 1, b + n + 1, k) - b;
if (!rt[t] || b[t] != k) {
printf("%d\n", lans = 0);
return;
}
k = t;
int k1, k2;
ans = 0;
_pre(rt[k], l), k1 = ans, ans = 0;
_nxt(rt[k], r), k2 = ans, ans = 0;
if (k1 == k2 && k1) {
puts("1");
lans = 1;
} else if (!k1 || !k2 || s_ize(k1) > s_ize(k2)) {
puts("0");
lans = 0;
} else {
splay(k1, 0);
splay(k2, k1);
printf("%d\n", lans = tr[tr[k2].son[0]].siz + 2);
}
}
int main() {
n = read();
for (int i = 1; i <= n; i++) tr[i].val = read(), b[i] = tr[i].val;
sort(b + 1, b + n + 1);
for (int i = 1; i <= n; i++)
tr[i].val = lower_bound(b + 1, b + n + 1, tr[i].val) - b;
for (int i = 1; i <= n; i++) bel[i] = 0, insert(rt[0], 1, i);
for (int i = 1; i <= n; i++)
bel[i + n] = tr[i].val, insert(rt[tr[i].val], 1, i + n);
m = read();
for (int i = 1, op, l, r, k; i <= m; i++) {
op = read(), l = read(), r = read();
l = (l + lans - 1) % n + 1, r = (r + lans - 1) % n + 1;
if (l > r) swap(l, r);
if (op == 1)
moving(l, r);
else
k = (read() + lans - 1) % n + 1, query(l, r, k);
}
return 0;
}
| 10 | CPP |
#include<bits/stdc++.h>
using namespace std;
int N,K;
vector<int> nex;
priority_queue<int> q;
bool cnt(){
vector<int> tmp;
for(int i=0;i<K;i++){
if( q.empty() ) return false;
int t = q.top(); q.pop();
if( t == 0 ) return false;
tmp.push_back( t-1 );
}
for(int t : tmp ) q.push( t );
return true;
}
int main(){
cin >> N >> K;
vector<string> S;
S.resize(N);
nex.resize(26);
for(string& s: S) cin >> s;
sort( S.begin(), S.end() );
for(int i=N-1;i>-1;i--)
nex[S[i][0]-'A']++;
for(int i=0;i<26;i++)
q.push( nex[i] );
int res = 0;
for(int i=0;i<N;i++){
if( cnt() ) res++;
else break;
}
cout << res << endl;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using PII = pair<int, int>;
const int mod = 998244353;
const int inf = 1 << 30;
const int maxn = 19;
int n;
ll chain[maxn][1 << maxn], suml[maxn][1 << maxn], ans[1 << maxn];
bool g[maxn][maxn];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
char s[20];
scanf("%s", s);
for (int j = 0; j < n; j++) {
g[i][j] = s[j] - '0';
}
chain[i][1 << i] = 1;
}
int ss = 1 << n;
for (int s = 0; s < ss; s++) {
for (int i = 0; i < n; i++) {
if (s >> i & 1) {
for (int j = 0; j < n; j++) {
if (i == j || !g[i][j]) continue;
if (s >> j & 1) {
chain[i][s] += chain[j][s ^ (1 << i)];
}
}
suml[__builtin_popcount(s)][s] += chain[i][s];
}
}
}
for (int len = 1; len <= n; len++) {
for (int i = 0; i < n; i++) {
for (int s = 0; s < ss; s++) {
if (s & (1 << i)) {
suml[len][s] += suml[len][s - (1 << i)];
}
}
}
}
map<vector<int>, vector<int> > pat;
for (int s = 0; s < ss / 2; s++) {
vector<int> v;
int tot = 0;
for (int i = 0; i < n - 1; i++) {
if (s >> i & 1) {
tot++;
} else {
v.push_back(tot + 1);
tot = 0;
}
}
v.push_back(tot + 1);
sort(begin(v), end(v));
pat[v].push_back(s);
}
vector<int> stk;
function<void(int, int, vector<ll>)> dfs = [&](int n, int st, vector<ll> g) {
if (n == 0) {
ll sum = 0;
for (int s = 0; s < ss; s++) {
if (__builtin_popcount(s ^ (ss - 1)) % 2 == 0) {
sum += g[s];
} else {
sum -= g[s];
}
}
for (auto s : pat[stk]) {
ans[s] = sum;
}
return;
}
for (int i = st; i <= n; i++) {
stk.push_back(i);
auto tot = g;
for (int s = 0; s < ss; s++) {
tot[s] *= suml[i][s];
}
dfs(n - i, i, tot);
stk.pop_back();
}
};
dfs(n, 1, vector<ll>(1 << n, 1));
for (int i = 0; i < (n - 1); i++) {
for (int s = 0; s < ss / 2; s++) {
if (((s >> i) & 1) == 0) {
ans[s] -= ans[s + (1 << i)];
}
}
}
for (int s = 0; s < ss / 2; s++) {
printf("%I64d ", ans[s]);
}
return 0;
}
| 12 | CPP |
import sys
import math
import itertools
import collections
def sieve(n):
if n < 2: return list()
prime = [True for _ in range(n + 1)]
p = 3
while p * p <= n:
if prime[p]:
for i in range(p * 2, n + 1, p):
prime[i] = False
p += 2
r = [2]
for p in range(3, n + 1, 2):
if prime[p]:
r.append(p)
return r
def divs(n, start=1):
r = []
for i in range(start, int(math.sqrt(n) + 1)):
if (n % i == 0):
if (n / i == i):
r.append(i)
else:
r.extend([i, n // i])
return r
def divn(n, primes):
divs_number = 1
for i in primes:
if n == 1:
return divs_number
t = 1
while n % i == 0:
t += 1
n //= i
divs_number *= t
def prime(n):
if n == 2: return True
if n % 2 == 0 or n <= 1: return False
sqr = int(math.sqrt(n)) + 1
for d in range(3, sqr, 2):
if n % d == 0: return False
return True
def convn(number, base):
newnumber = 0
while number > 0:
newnumber += number % base
number //= base
return newnumber
def cdiv(n, k): return n // k + (n % k != 0)
def ii(): return int(input())
def mi(): return map(int, input().split())
def li(): return list(map(int, input().split()))
def lcm(a, b): return abs(a * b) // math.gcd(a, b)
def wr(arr): return ' '.join(map(str, arr))
def revn(n): return str(n)[::-1]
def dd(): return collections.defaultdict(int)
def ddl(): return collections.defaultdict(list)
n, k = mi()
if n % 10 ** k == 0:
print(n)
else:
two = five = 0
while n % 5 == 0:
n //= 5
five += 1
while n % 2 == 0:
n //= 2
two += 1
print(n * 2 ** max(two, k) * 5 ** max(five, k))
| 7 | PYTHON3 |
from sys import *
input = stdin.readline
for _ in range(int(input())):
n = int(input())
a = list(map(int,input().split()))
ch = 0
for i in range(1,n):
if(a[i-1] <= a[i]):
ch = 1
break
if(ch == 1):
stdout.write("YES\n")
else:
stdout.write("NO\n") | 7 | PYTHON3 |
s=input()
lol=0
yes=False
q=[k for k in s if k.isdigit() ]
prim=[]
sec=0
primo=[]
fin=[]
kk=0
ocp=False
for i in range (len(s)):
if s[i].isupper()==True:
lol+=1
elif s[i].islower()==True:
kk+=1
while q==[]:
if len(s)==1 :
s=str(s)
if s.islower()==True:
print(s.upper())
break
elif s.isupper()==True:
print(s.lower())
break
elif len(s) >=2 :
prim.append(s[0])
for k in range (1,len(s)):
primo.append(s[k])
if s[k].isupper()==True:
sec+=1
if s[0].islower()==True and sec==len(s)-1:
for z in range (len(s)):
if s[z].islower()==True:
s2=s[z].upper()
fin.append(s2)
elif s[z].isupper()==True:
s2=s[z].lower()
fin.append(s2)
fin2="".join(map(str,fin))
print(fin2)
break
elif lol== len(s):
s=str(s)
print(s.lower())
break
yes=True
if ocp==False and yes==False or kk>0 :
print(s)
q.append(1)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int r(double ra) {
if (ra > 0.5) {
return 500;
} else if (ra > 0.25) {
return 1000;
} else if (ra > 0.125) {
return 1500;
} else if (ra > 0.0625) {
return 2000;
} else if (ra > 0.03125) {
return 2500;
} else {
return 3000;
}
}
int main() {
int n, i, j, a[124][5], yes[5], ans[5] = {0}, scorea, scoreb, rating;
cin >> n;
for (i = 0; i < n; i++) {
for (j = 0; j < 5; j++) {
cin >> a[i][j];
if (a[i][j] == -1) {
a[i][j] = 3600;
}
}
}
for (i = 0; i < 5; i++) {
if (a[0][i] > a[1][i] and a[0][i] != 3600) {
yes[i] = 1;
} else {
yes[i] = 0;
}
}
for (i = 0; i < 5; i++) {
for (j = 0; j < n; j++) {
if (a[j][i] <= 176) {
ans[i]++;
}
}
}
for (i = 0; i <= 32 * 120; i++) {
scorea = 0;
scoreb = 0;
for (j = 0; j < 5; j++) {
if (yes[j]) {
double p = ((ans[j] + i) * 1.0 / (n + i) * 1.0) * 1.0;
rating = r(p);
rating = rating / 250;
if (a[0][j] < 178) {
scorea += (rating * (250 - a[0][j]));
}
if (a[1][j] < 178) {
scoreb += (rating * (250 - a[1][j]));
}
} else {
double p = ((ans[j]) * 1.0 / (n + i) * 1.0) * 1.0;
rating = r(p);
rating = rating / 250;
if (a[0][j] < 178) {
scorea += (rating * (250 - a[0][j]));
}
if (a[1][j] < 178) {
scoreb += (rating * (250 - a[1][j]));
}
}
}
if (scorea > scoreb) {
cout << i;
return 0;
}
}
cout << "-1";
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
auto L = vector<int>(N);
auto sum = 0;
while (N--) {
cin >> L[N];
sum += L[N];
}
sort(L.begin(), L.end());
cout << (L.back() < sum - L.back() ? "Yes" : "No");
} | 0 | CPP |
print((1/int(input()))*sum([int(x) for x in input().split()])) | 8 | PYTHON3 |
def fastio():
import sys
from io import StringIO
from atexit import register
global input
sys.stdin = StringIO(sys.stdin.read())
input = lambda : sys.stdin.readline().rstrip('\r\n')
sys.stdout = StringIO()
register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
fastio()
MOD = 10**9 + 7
I = lambda:list(map(int,input().split()))
q, = I()
while q:
q -= 1
x, y = I()
if x - y >= 2:
print('YES')
else:
print('NO') | 7 | PYTHON3 |
n, m, a = map(int, input().split())
print(((m-1)//a + 1)*((n-1)//a + 1))
| 7 | PYTHON3 |
if __name__ == "__main__":
input()
while True:
try:
n, m = map(int, input().split())
std = [[0] * m for _ in range(n)]
for x in range(n):
for y in range(1, m):
std[x][y] += 1
std[x][y - 1] += 1
for x in range(1, n):
for y in range(m):
std[x][y] += 1
std[x - 1][y] += 1
now = []
for _ in range(n):
now.append(list(map(int, input().split())))
flag = True
for x in range(n):
for y in range(m):
if now[x][y] > std[x][y]:
flag = False
if flag:
print('YES')
for x in range(n):
print(*std[x])
else:
print('NO')
except EOFError:
break
pass
| 8 | PYTHON3 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#define rep(i,n) for(int i=0;i<n;++i)
#define rep1(i,n) for(int i=1;i<=n;++i)
using namespace std;
template<class T>bool chmax(T &a, const T &b) { if(a < b){ a = b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if(a > b){ a = b; return 1; } return 0; }
typedef long long ll;
ll M;
template <typename X>
struct Edge{
int from;
int to;
X cost;
int idx;
Edge() = default;
Edge(int from, int to, X cost, int idx) : from(from), to(to), cost(cost), idx(idx) {}
};
template <typename X>
struct Node{
int idx;
int par;
X depth;
vector<Edge<X>> edge;
map<int,int> to_index;
vector<X> dp;
vector<X> lsum, rsum;
int cnt;
vector<X> dp2;
vector<X> lsum2, rsum2;
int cnt2;
Node() = default;
explicit Node(int idx) : idx(idx) {
cnt = 0;
}
void Init_DP() {
dp.resize(edge.size(), -1);
dp2.resize(edge.size(), -1);
}
void Make_to_index() {
rep(i,edge.size()) {
to_index[edge[i].to] = edge[i].idx;
}
to_index[idx] = -1;
Init_DP();
}
void Make_Sum(X id) {
int n = dp.size();
lsum.resize(n+1, id);
rsum.resize(n+1, id);
rep(i,n) {
lsum[i+1] = max(lsum[i], dp[i] + 1);
}
for (int i = n; i > 0; --i) {
rsum[i-1] = max(rsum[i], dp[i-1] + 1);
}
}
bool is_full_dp() {
return cnt == dp.size();
}
void Make_Sum2(X id) {
int n = dp.size();
lsum2.resize(n+1, id);
rsum2.resize(n+1, id);
rep(i,n) {
lsum2[i+1] = lsum2[i] + dp2[i] + 2;
}
for (int i = n; i > 0; --i) {
rsum2[i-1] = rsum2[i] + dp2[i-1] + 2;
}
}
bool is_full_dp2() {
return cnt2 == dp2.size();
}
};
template <typename X>
class Tree{
private:
int n; // number of node
vector<Node<X>> node;
public:
Tree() = default;
Tree(int n) : n(n) {
rep(i,n) node.emplace_back(i);
}
Tree(int n, vector<int> a, vector<int> b) : n(n) {
rep(i,n) node.emplace_back(i);
rep(i,n-1) {
add_edge(a[i], b[i]);
add_edge(b[i], a[i]); // indirected edge
}
}
Tree(int n, vector<int> a, vector<int> b, vector<X> c) : n(n) {
rep(i,n) node.emplace_back(i);
rep(i,n-1) {
add_edge(a[i], b[i], c[i]);
add_edge(b[i], a[i], c[i]); // indirected edge
}
}
void add_edge(int from, int to, X cost = 1) {
node[from].edge.emplace_back(from, to, cost, node[from].edge.size());
}
void DFS_Init(int v, int p, int d) {
node[v].par = p;
node[v].depth = d;
for(auto next: node[v].edge) {
int w = next.to;
X cost = next.cost;
if(w == p) continue;
DFS_Init(w, v, d + cost);
}
}
void Init_Node(int root) {
DFS_Init(root, -1, 0);
rep(i,n) node[i].Make_to_index();
}
X ReRoot(int p, int v) {
int index = node[p].to_index[v];
if(index != -1) if(node[p].dp[index] >= 0) return node[p].dp[index];
if(node[v].is_full_dp()) {
if(node[v].cnt == 0) return 0;
int index2 = node[v].to_index[p];
if(index2 == -1) {
return node[v].rsum[0];
}
else {
node[p].dp[index] = max(node[v].lsum[index2], node[v].rsum[index2+1]);
node[p].cnt++;
if(node[p].is_full_dp()) {
node[p].Make_Sum(0);
}
return node[p].dp[index];
}
}
X res = 0;
for(auto next: node[v].edge) {
int w = next.to;
if(w == p) continue;
res = max(res, (ReRoot(v, w) + 1));
}
if(index == -1) return res;
node[p].dp[index] = res;
node[p].cnt++;
if(node[p].is_full_dp()) {
node[p].Make_Sum(0);
}
return res;
}
X ReRoot2(int p, int v) {
int index = node[p].to_index[v];
if(index != -1) if(node[p].dp2[index] >= 0) return node[p].dp2[index];
if(node[v].is_full_dp2()) {
if(node[v].cnt2 == 0) return 0;
int index2 = node[v].to_index[p];
if(index2 == -1) {
return node[v].rsum2[0];
}
else {
node[p].dp2[index] = node[v].lsum2[index2] + node[v].rsum2[index2+1];
node[p].cnt2++;
if(node[p].is_full_dp2()) {
node[p].Make_Sum2(0);
}
return node[p].dp2[index];
}
}
X res = 0;
for(auto next: node[v].edge) {
int w = next.to;
if(w == p) continue;
res = res + ReRoot2(v, w) + 2;
}
if(index == -1) return res;
node[p].dp2[index] = res;
node[p].cnt2++;
if(node[p].is_full_dp2()) {
node[p].Make_Sum2(0);
}
return res;
}
};
int main()
{
int n;cin >> n;
vector<int> a(n-1), b(n-1);
rep(i,n-1) {
cin >> a[i] >> b[i];
a[i]--; b[i]--;
}
Tree<int> tr(n, a, b);
tr.Init_Node(0);
// rep(i,n) cout << tr.ReRoot2(i, i) << "\n";
rep(i,n) cout << tr.ReRoot2(i, i) - tr.ReRoot(i, i) << "\n";
return 0;
}
| 0 | CPP |
import math
inp = input()
numbers = [int(s) for s in inp.strip().split(' ')]
m = numbers[0]
n = numbers[1]
if n % 2 != 0:
print(math.floor(n/2) * m + math.floor(m/2))
else:
print(math.floor(n/2) * m) | 7 | PYTHON3 |
t = int(input())
for _ in range(t):
n , x = map(int, input().split())
a = list(map(int, input().split()))
count = 0
i = 1
while(i <= x):
if i in a:
x += 1
else:
a.append(i)
i += 1
a.sort()
v = 0
i = 0
while i < len(a):
if (i+1) not in a:
break
else:
v += 1
i += 1
print(v) | 7 | PYTHON3 |
n = int(input())
a = [int(x) for x in input().split()]
b = [0] * n
s = set()
for i in range(n - 1, -1, -1):
if a[i] not in s:
s.add(a[i])
b[i] = 1
r = 0
s = set()
for i in range(n):
if b[i]:
r += len(s)
s.add(a[i])
print(r)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, size_t N>
int SIZE(const T (&t)[N]) {
return N;
}
template <typename T>
int SIZE(const T &t) {
return t.size();
}
string to_string(const string s, int x1 = 0, int x2 = 1e9) {
return '"' + ((x1 < s.size()) ? s.substr(x1, x2 - x1 + 1) : "") + '"';
}
string to_string(const char *s) { return to_string((string)s); }
string to_string(const bool b) { return (b ? "true" : "false"); }
string to_string(const char c) { return string({c}); }
template <size_t N>
string to_string(const bitset<N> &b, int x1 = 0, int x2 = 1e9) {
string t = "";
for (int __iii__ = min(x1, SIZE(b)), __jjj__ = min(x2, SIZE(b) - 1);
__iii__ <= __jjj__; ++__iii__) {
t += b[__iii__] + '0';
}
return '"' + t + '"';
}
template <typename A, typename... C>
string to_string(const A(&v), int x1 = 0, int x2 = 1e9, C... coords);
int l_v_l_v_l = 0, t_a_b_s = 0;
template <typename A, typename B>
string to_string(const pair<A, B> &p) {
l_v_l_v_l++;
string res = "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
l_v_l_v_l--;
return res;
}
template <typename A, typename... C>
string to_string(const A(&v), int x1, int x2, C... coords) {
int rnk = rank<A>::value;
string tab(t_a_b_s, ' ');
string res = "";
bool first = true;
if (l_v_l_v_l == 0) res += '\n';
res += tab + "[";
x1 = min(x1, SIZE(v)), x2 = min(x2, SIZE(v));
auto l = begin(v);
advance(l, x1);
auto r = l;
advance(r, (x2 - x1) + (x2 < SIZE(v)));
for (auto e = l; e != r; e = next(e)) {
if (!first) {
res += ", ";
}
first = false;
l_v_l_v_l++;
if (e != l) {
if (rnk > 1) {
res += '\n';
t_a_b_s = l_v_l_v_l;
};
} else {
t_a_b_s = 0;
}
res += to_string(*e, coords...);
l_v_l_v_l--;
}
res += "]";
if (l_v_l_v_l == 0) res += '\n';
return res;
}
void dbgm() { ; }
template <typename Heads, typename... Tails>
void dbgm(Heads H, Tails... T) {
cerr << to_string(H) << " | ";
dbgm(T...);
}
bool vectorpair_sort_by_sec(const pair<int, int> &a, const pair<int, int> &b) {
return a.second < b.second;
}
struct Node {
int value = -1;
};
int roundUp(double x) {
if (x > 0) {
if (x != (int)x)
return (int)x + 1;
else
return x;
} else if (x < 0) {
if (x != (int)x)
return (int)x - 1;
else
return x;
} else
return x;
}
int roundDown(double x) { return (int)x; }
bool isInt(double x) {
if (x != (int)x)
return false;
else
return true;
}
int Pow(int a, int n) {
int res = 1;
while (n) {
if (n & 1) res = (1LL * res * a) % 1000000007;
a = (1LL * a * a) % 1000000007;
n >>= 1;
}
return res;
}
void task() {
int n, k;
cin >> n >> k;
vector<pair<int, int>> p(n);
for (int i = 0; i < n; i++) {
cin >> p[i].first;
p[i].second = p[i].first % 10;
}
sort(p.begin(), p.end(), vectorpair_sort_by_sec);
int ans = 0;
for (int i = n - 1; i >= 0; i--) {
if (p[i].first % 10 == 0) {
ans += p[i].first / 10;
continue;
}
if (k >= 10 - p[i].second)
ans += (p[i].first + (10 - p[i].second)) / 10, k -= 10 - p[i].second,
p[i].first += 10 - p[i].second;
else
ans += p[i].first / 10;
}
if (k < 10)
cout << ans;
else {
for (int i = 0; i < n; i++) {
if (k < 10) break;
ans += min((100 - p[i].first) / 10, k / 10);
k -= min(100 - p[i].first, k);
}
cout << ans;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
task();
}
| 9 | CPP |
#include <bits/stdc++.h>
int s[200006], c;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
while (c && s[c - 1] == x) c--, x++;
s[c++] = x;
}
printf("%d\n", c);
for (int i = 0; i < c; i++) printf("%d ", s[i]);
puts("");
return 0;
}
| 11 | CPP |
import math
test = int(input())
for q in range(test):
n, x = map(int, input().split())
# n = int(input())
# s = input()
print(2*x) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1010;
const int MAXL = 250010;
int x[MAXN], y[MAXN];
int f[MAXL];
bool GetValue(int n, int* x, vector<int>& x1, vector<int>& x2) {
int sumx = 0;
for (int i = 0; i < n; ++i) sumx += x[i];
if (sumx & 1) return false;
sort(x, x + n);
memset(f, -1, sizeof(f));
f[0] = 0;
int sum = 0;
for (int i = 0; i < n; ++i) {
sum += x[i];
if (sum > sumx / 2) sum = sumx / 2;
for (int j = sum; j >= x[i]; --j) {
if (f[j] != -1) continue;
if (f[j - x[i]] != -1) f[j] = i;
}
}
if (f[sum] == -1) {
return false;
}
while (sum > 0) {
x1.push_back(f[sum]);
sum -= x[f[sum]];
}
sort(x1.begin(), x1.end());
int k = 0;
for (int i = 0; i < n; ++i) {
if (k < x1.size() && x1[k] == i) {
++k;
continue;
}
x2.push_back(i);
}
return true;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int times;
cin >> times;
while (times--) {
int n, m;
cin >> n;
for (int i = 0; i < n; ++i) cin >> x[i];
cin >> m;
for (int i = 0; i < m; ++i) cin >> y[i];
if (n != m) {
cout << "No" << endl;
continue;
}
vector<int> x1, x2, y1, y2;
if (!GetValue(n, x, x1, x2) || !GetValue(m, y, y1, y2)) {
cout << "No" << endl;
continue;
}
if (x1.size() > x2.size()) swap(x1, x2);
if (y1.size() < y2.size()) swap(y1, y2);
reverse(x1.begin(), x1.end());
reverse(y2.begin(), y2.end());
vector<pair<int, int>> ansx, ansy;
int tx = 0, ty = 0;
for (int i = 0; i < x1.size(); ++i) {
tx += x[x1[i]];
ansx.push_back(make_pair(tx, ty));
ty += y[y1[i]];
ansx.push_back(make_pair(tx, ty));
}
tx = 0, ty = 0;
for (int i = 0; i < y2.size(); ++i) {
ty += y[y2[i]];
ansy.push_back(make_pair(tx, ty));
tx += x[x2[i]];
ansy.push_back(make_pair(tx, ty));
}
int base = y1.size() - x1.size();
for (int i = 0; i < base; ++i) {
ty -= y[y1[i + x1.size()]];
ansy.push_back(make_pair(tx, ty));
tx += x[x2[i + y2.size()]];
ansy.push_back(make_pair(tx, ty));
}
cout << "Yes" << endl;
for (auto& [a, b] : ansx) cout << a << " " << b << endl;
for (int i = (int)ansy.size() - 2; i >= 0; --i) {
cout << ansy[i].first << " " << ansy[i].second << endl;
}
cout << "0 0" << endl;
}
return 0;
}
| 10 | CPP |
for _ in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
l.sort()
ans=float("inf")
for i in range(n-1):
ans=min(ans,l[i+1]-l[i])
print(ans) | 8 | PYTHON3 |
n=int(input())
for x in range(n):
k=int(input())
if (k<4):
print(-1)
else:
if (k==4):
print('2 4 1 3')
elif (k==5):
print('2 4 1 3 5')
else:
if (k%2==0):
for tl in range(k//2):
if (tl<k//2-2):
print(k-2*tl,end=' ')
elif (tl==k//2-2):
print(2,end=' ')
else:
print(4,end=' ')
for tq in range(k//2):
print(1+2*tq,end=' ')
else:
for tl in range(k//2):
if (tl<k//2-2):
print(k-2*tl-1,end=' ')
elif (tl==k//2-2):
print(2,end=' ')
else:
print(4,end=' ')
for tq in range(k//2+1):
print(1+2*tq,end=' ')
print()
| 13 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long T = 1, i, j;
while (T--) {
long long n;
cin >> n;
vector<long long> v(n);
for (i = 0; i < n; i++) {
cin >> v[i];
}
long long q;
cin >> q;
vector<vector<long long>> queries(q, vector<long long>(3));
for (i = 0; i < q; i++) {
long long a, b, c;
cin >> a;
if (a == 1) {
cin >> b >> c;
queries[i][0] = a;
queries[i][1] = b;
queries[i][2] = c;
} else {
cin >> b;
queries[i][0] = 2;
queries[i][1] = b;
queries[i][2] = -999999999999999999;
}
}
long long maxpayoff = -999999999999999999;
vector<bool> visited(n);
for (i = q - 1; i >= 0; i--) {
if (queries[i][0] == 1) {
long long ind = queries[i][1] - 1;
if (!visited[ind]) {
v[ind] = max(queries[i][2], maxpayoff);
visited[ind] = true;
}
} else {
maxpayoff = max(maxpayoff, queries[i][1]);
}
}
for (i = 0; i < n; i++) {
if (!visited[i]) v[i] = max(v[i], maxpayoff);
cout << v[i] << " ";
}
}
return 0;
}
| 8 | CPP |
n = int(input().strip())
li = [int(x) for x in input().split()]
se = {}
sese = set()
for i, nu in enumerate(li):
# print(nu, i)
if nu not in se:
se[nu] = i
else:
break
res = len(se)
ma = 10**10
for i, nu in enumerate(reversed(li), 1):
if nu not in sese:
sese.add(nu)
if nu not in se:
ma = min(ma, len(se))
# print(ma, i, '-')
res = max(res, ma+ i)
else:
ma = min(se[nu], ma)
# print(ma, i, '+')
res = max(res, ma+ i)
else:
break
# print()
se = {}
sese = set()
la = list(reversed(li))
for i, nu in enumerate(la):
# print(nu, i)
if nu not in se:
se[nu] = i
else:
break
# print(se)
res = max(res, len(se))
ma = 10**10
for i, nu in enumerate(reversed(la), 1):
if nu not in sese:
sese.add(nu)
if nu not in se:
ma = min(ma, len(se))
# print(ma, i, '-')
res = max(res, ma + i)
else:
ma = min(se[nu], ma)
# print(ma, i, '+')
res = max(res, ma+ i)
else:
break
print(n-res) | 8 | PYTHON3 |
k = int(input())
for i in range(k):
a = input()
if len(a) > 10:
print(a[0]+str(len(a)-2)+a[len(a)-1])
else:
print(a)
| 7 | PYTHON3 |
import sys
alpha = 'abcdefghijklmnopqrstuvwxyz'
for i in sys.stdin.readlines():
aaa = i.strip()
for j in range(1, 27):
text = aaa.translate(str.maketrans(alpha, alpha[j:] + alpha[:j]))
if 'the' in text or 'this' in text or 'that' in text:
print(text) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool ar[100005], prime[100005];
int n;
bool check(int i) {
for (int k = 0; k < (int)(i); k++) {
int c = 0;
for (int j = k; j < n; j += i) c += ar[j];
if (c == n / i) return 1;
}
return 0;
}
int main() {
for (int i = 2; i <= 1e5; i++)
if (!prime[i])
for (int j = 2 * i; j <= 1e5; j += i) prime[j] = 1;
prime[4] = 0;
prime[2] = 1;
prime[1] = 1;
cin >> n;
for (int i = 0; i < (int)(n); i++) cin >> ar[i];
for (int i = 1; i * i <= n; i++) {
if (n % i == 0) {
if (!prime[n / i] && check(i) || !prime[i] && check(n / i)) {
cout << "YES\n";
return 0;
}
}
}
cout << "NO\n";
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
const int maxn = int(1e5) + 7, mod = int(1e9) + 7;
char buf[maxn], str[maxn] = {'b'};
int len = 0, cnt[maxn], n = 0;
int main() {
scanf("%s", buf);
for (int i = 0; buf[i]; i++)
if (buf[i] <= 'b') str[++len] = buf[i];
for (int i = 1; i <= len; i++) {
if (str[i] == 'a') {
if (str[i - 1] == 'b')
cnt[++n] = 1;
else
cnt[n]++;
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) ans = (ans + (ans + 1) * cnt[i] % mod) % mod;
printf("%lld\n", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int Max = 5e5 + 1;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
t = 1;
while (t--) {
int n, m, k;
cin >> n >> m >> k;
long long arr[n + 1];
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
vector<long long> v;
unordered_map<long long, int> mp;
for (int i = 1; i <= n; i++) {
v.push_back(arr[i]);
}
sort(v.rbegin(), v.rend());
long long ans = 0;
for (int i = 0; i < m * k; i++) {
ans += v[i];
mp[v[i]]++;
}
vector<int> index;
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (mp[arr[i]]) {
cnt++;
mp[arr[i]]--;
}
if (cnt == m) {
index.push_back(i);
cnt = 0;
}
}
cout << ans << '\n';
for (int i = 0; i < k - 1; i++) {
cout << index[i] << " ";
}
}
}
| 8 | CPP |
#include <iostream>
using namespace std;
long long a, b, v, w, t;
int main() {
cin >> a >> v >> b >> w >> t;
if (v * t >= abs(b - a) + t * w)
cout << "YES\n";
else
cout << "NO\n";
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
const long long M = 21;
const long long maxn = 5e6 + 5;
const long long mod = 1e9 + 7;
const long long inf = 0x3f3f3f3f3f3f3f3f;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline long long ksm(long long x, long long y = mod - 2, long long z = mod) {
long long ret = 1;
while (y) {
if (y & 1) ret = (ret * x) % z;
x = (x * x) % z;
y >>= 1;
}
return ret;
}
long long n, m, k, p, ans, l, r;
long long a[N], h[N];
struct Node {
long long day, id;
bool operator<(const Node& o) const { return day > o.day; }
};
priority_queue<Node> Q;
long long cnt[N];
bool chk(long long x) {
while (!Q.empty()) Q.pop();
for (long long i = 1; i <= n; i++) cnt[i] = 0;
for (long long i = 1; i <= n; i++)
if (x < h[i] + a[i] * m) Q.push((Node){x / a[i], i});
for (long long i = 1; i <= m; i++)
for (long long j = 1; j <= k; j++) {
if (Q.empty()) return 1;
Node u = Q.top();
Q.pop();
if (u.day < i) return 0;
cnt[u.id]++;
if (x + cnt[u.id] * p < h[u.id] + a[u.id] * m)
Q.push((Node){(x + cnt[u.id] * p) / a[u.id], u.id});
}
return Q.empty();
}
signed main() {
n = read();
m = read();
k = read();
p = read();
for (long long i = 1; i <= n; i++) {
h[i] = read();
a[i] = read();
r = max(r, h[i] + a[i] * m);
}
while (l <= r) {
long long mid = (l + r) / 2;
if (chk(mid))
ans = mid, r = mid - 1;
else
l = mid + 1;
}
cout << ans << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const int inf = 1000000010;
const int MAXN = 300010;
struct edge {
int u, v, c, t, res;
} E[MAXN];
int n, m, k, u, v, x, y, t, a, b, N;
int comp[MAXN * 2];
bool mark[MAXN * 2];
int del[MAXN * 2];
int del2[MAXN * 2];
unordered_map<int, int> deg[MAXN];
unordered_map<int, vector<int>> GRAPH[MAXN];
vector<int> GRAPH2[MAXN];
vector<int> G[2 * MAXN];
vector<int> GR[2 * MAXN];
vector<int> topol;
void add_edge(int x, int y) {
G[x].push_back(y);
GR[y].push_back(x);
}
void add(int x, int y) {
add_edge(x ^ 1, y);
add_edge(y ^ 1, x);
}
void add2(int x, int y) {
add_edge(x ^ 1, y);
add_edge(y ^ 1, x);
del[x ^ 1]++;
del[y ^ 1]++;
del2[y]++;
del2[x]++;
}
void dfs1(int node) {
mark[node] = 1;
for (int v : G[node])
if (!mark[v]) dfs1(v);
topol.push_back(node);
}
void dfs2(int node, int id) {
comp[node] = id;
for (int v : GR[node])
if (!comp[v]) dfs2(v, id);
}
bool check(int T) {
for (int i = 0; i < 2 * MAXN; i++) {
while (del[i]) {
G[i].pop_back();
del[i]--;
}
while (del2[i]) {
GR[i].pop_back();
del2[i]--;
}
}
for (int i = 1; i <= m; i++)
if (E[i].t > T) add2(2 * i ^ 1, 2 * i ^ 1);
memset(comp, 0, sizeof(comp));
memset(mark, 0, sizeof(mark));
topol.clear();
for (int i = 2; i < 2 * MAXN; i++)
if (!mark[i]) dfs1(i);
reverse(topol.begin(), topol.end());
int id = 1;
for (int v : topol)
if (!comp[v]) dfs2(v, id++);
for (int i = 2; i < 2 * N + 2; i++)
if (comp[i] == comp[i ^ 1]) return 0;
for (int i = 1; i <= m; i++) E[i].res = (comp[2 * i] > comp[2 * i + 1]);
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> u >> v >> x >> y;
E[i] = {u, v, x, y};
deg[u][x]++;
deg[v][x]++;
GRAPH[u][x].push_back(i);
GRAPH[v][x].push_back(i);
GRAPH2[u].push_back(i);
GRAPH2[v].push_back(i);
}
for (int i = 1; i <= n; i++)
for (pair<int, int> p : deg[i])
if (p.second > 2) return cout << "No" << '\n', 0;
for (int i = 1; i <= n; i++)
for (auto it : GRAPH[i])
if (it.second.size() == 2) add(it.second[0] * 2, it.second[1] * 2);
N = m;
for (int i = 1; i <= n; i++)
if (GRAPH2[i].size() >= 2) {
k = GRAPH2[i].size();
for (int j = 0; j < k; j++) {
int a = GRAPH2[i][j];
add(2 * a ^ 1, 2 * (++N));
if (j) add(2 * (N - 1) ^ 1, 2 * N);
if (j) add(2 * a ^ 1, 2 * (N - 1) ^ 1);
}
}
int dwn = -1, up = inf;
while (up - dwn > 1) {
int mid = (dwn + up) / 2;
if (check(mid))
up = mid;
else
dwn = mid;
}
if (!check(up)) return cout << "No" << '\n', 0;
vector<int> out;
for (int i = 1; i <= m; i++)
if (E[i].res) out.push_back(i);
cout << "Yes\n" << up << ' ' << out.size() << '\n';
for (int i : out) cout << i << ' ';
cout << '\n';
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const long long linf = (long long)1e18;
template <class TAT>
inline void read(TAT &res) {
char c;
res = 0;
bool neg = false;
while (c = getchar(), c != '-' && (c < '0' || c > '9'))
;
if (c == '-') neg = true, c = getchar();
do res = (res * 10) + (c ^ 48);
while (c = getchar(), c >= '0' && c <= '9');
if (neg) res = -res;
}
template <class TAT>
inline void print(TAT first) {
if (first == 0) {
putchar('0');
return;
}
if (first < 0) {
putchar('-');
first = -first;
}
static char stk[30];
int top = 0;
while (first) stk[++top] = first % 10 ^ 48, first /= 10;
while (top) putchar(stk[top--]);
}
namespace Program {
const int N = (int)1e6;
const int M = (int)2e9;
const int V = (int)1e7;
int n, m;
int a[N + 5];
void input() {
scanf("%d %d", &n, &m);
for (int i = 0, i_END_ = n; i < i_END_; ++i) read(a[i]);
}
int b[V + 5], c[V + 5];
bool chk(int first) {
for (int i = 0, i_END_ = first; i < i_END_; ++i) b[i] = 0;
for (int i = first, i_END_ = min(first + first, V + 1); i < i_END_; ++i)
b[i] = 1;
for (int i = first + first, i_END_ = V + 1; i < i_END_; ++i)
b[i] = b[i >> 1] + b[(i >> 1) + (i & 1)];
long long cnt = 0;
for (int i = 0, i_END_ = n; i < i_END_; ++i) cnt += b[a[i]];
return cnt >= m;
}
void solve() {
int L = 1, R = V;
int ans = -1;
while (L <= R) {
int mid = L + R >> 1;
if (chk(mid))
ans = mid, L = mid + 1;
else
R = mid - 1;
}
printf("%d\n", ans);
}
void Main() {
input();
solve();
}
} // namespace Program
int main() {
srand(time(NULL));
Program::Main();
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
const long long INF = 1e18;
struct node {
int u, v, w;
node(int u = 0, int v = 0, int w = 0) : u(u), v(v), w(w) {}
} a[2 * N];
int fst[N], nxt[2 * N], tot, n, size[N];
bool vis[N];
long long ans, sum[N], ans0, mn;
void build(int x, int y, int z) {
a[tot] = node(x, y, z);
nxt[tot] = fst[x];
fst[x] = tot++;
}
void calc(int x) {
int y;
size[x] = 1;
for (int p = fst[x]; ~p; p = nxt[p]) {
if (vis[p / 2]) continue;
vis[p / 2] = 1;
y = a[p].v;
calc(y);
size[x] += size[y];
ans += (long long)a[p].w * size[y] * (n - size[y]);
}
}
void dfs1(int x) {
int y;
sum[x] = 0;
size[x] = 1;
for (int p = fst[x]; ~p; p = nxt[p]) {
if (vis[p / 2]) continue;
vis[p / 2] = 1;
y = a[p].v;
dfs1(y);
sum[x] = (long long)sum[y] + (long long)size[y] * a[p].w;
size[x] += size[y];
}
}
void dfs2(int x, int all) {
int y;
for (int p = fst[x]; ~p; p = nxt[p]) {
if (vis[p / 2]) continue;
vis[p / 2] = 1;
y = a[p].v;
sum[y] = sum[x] - (long long)size[y] * a[p].w +
(long long)(all - size[y]) * a[p].w;
mn = min(mn, sum[y]);
dfs2(y, all);
}
}
long long work(int x, int i) {
for (int j = 0; j < n - 1; j++) vis[j] = i == j ? 1 : 0;
dfs1(x);
for (int j = 0; j < n - 1; j++) vis[j] = i == j ? 1 : 0;
mn = sum[x];
dfs2(x, size[x]);
return (long long)(mn - sum[x]) * (n - size[x]);
}
int main() {
int x, y, z;
scanf("%d", &n);
tot = 0;
memset(fst, -1, sizeof(fst));
for (int i = 0; i < n - 1; i++) {
scanf("%d%d%d", &x, &y, &z);
x--;
y--;
build(x, y, z);
build(y, x, z);
}
ans = 0;
calc(0);
ans0 = ans;
long long tmp;
for (int i = 0; i < n - 1; i++) {
tmp = ans0 + work(a[i * 2].u, i) + work(a[i * 2].v, i);
ans = min(ans, tmp);
}
cout << ans << "\n";
return 0;
}
| 11 | CPP |
#include<bits/stdc++.h>
#define rep(i,n)for(int i=0;i<(n);i++)
using namespace std;
int bit[100001], n, q;
void add(int k, int x) {
while (k <= n) {
bit[k] += x;
k += k&-k;
}
}
int sum(int k) {
int res = 0;
while (k > 0) {
res += bit[k];
k -= k&-k;
}
return res;
}
int main() {
scanf("%d%d", &n, &q);
rep(i, q) {
int a; scanf("%d", &a);
if (a) {
int b; scanf("%d", &b);
printf("%d\n", sum(b));
continue;
}
int s, t, x; scanf("%d%d%d", &s, &t, &x); t++;
add(s, x); add(t, -x);
}
} | 0 | CPP |
"""
~~ Author : Bhaskar
~~ Dated : 12~06~2020
"""
import sys
from bisect import *
from math import floor, sqrt, ceil, factorial as F, gcd, pi
from itertools import chain, combinations, permutations, accumulate
from collections import Counter, defaultdict, OrderedDict, deque
INT_MAX = sys.maxsize
INT_MIN = -(sys.maxsize) - 1
mod = 1000003
ch = "abcdefghijklmnopqrstuvwxyz"
lcm = lambda a, b: (a * b) // gcd(a, b)
setbit = lambda x: bin(x)[2:].count("1")
INT = lambda type: type(sys.stdin.readline()) if type in [int, float] else type(sys.stdin.readline()).replace("\n", "")
ARRAY = lambda type: list(map(type, sys.stdin.readline().split()))
NUMS = lambda type: map(type, sys.stdin.readline().split())
def solve():
s = INT(str)
ans = 0
d = {
">" : 1000,
"<" : 1001,
"+" : 1010,
"-" : 1011,
"." : 1100,
"," : 1101,
"[" : 1110,
"]" : 1111,
}
string = ""
for i in s:
string += str(d[i])
print(int(string,2)%mod)
if __name__ == "__main__":
# try:
# sys.stdin = open("input.txt", "r")
# except:
# pass
solve()
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int n, a[4], ans[maxn], temp[4];
bool check(int pt) {
if (!a[pt]) return false;
for (int i = 0; i < 4; ++i) temp[i] = a[i];
for (int i = 1; i <= n; ++i) {
ans[i] = pt;
temp[pt]--;
if (i == n) return true;
if (pt && temp[pt - 1])
pt--;
else if (temp[pt + 1])
pt++;
else
return false;
}
return true;
}
int main() {
for (int i = 0; i < 4; ++i) {
cin >> a[i];
n += a[i];
}
for (int i = 0; i < 4; ++i)
if (check(i)) {
cout << "YES" << endl;
for (int j = 1; j <= n; ++j) cout << ans[j] << " ";
return 0;
}
cout << "NO" << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long M = 998244353;
long long fast(long long a, long long b) {
if (b == 0) return 1;
if (b == 1) return a % M;
long long c = fast(a, b / 2);
c = (c * c) % M;
if (b & 1) {
c = (c * a) % M;
}
return c;
}
int perm(int n, int k) {
if (n == 0 || k == 0) return 1;
long long q = 1;
for (int i = 1; i <= k; i++) {
q = (q * (n + 1 - i)) % M;
}
return q;
}
int binom(int n, int k) {
long long ans = perm(n, k);
ans *= fast(perm(k, k), M - 2);
return (ans % M);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
long long ans = 0;
for (int i = 1; i <= n; i++) {
int q = n / i;
if (q >= k) {
ans += binom(q - 1, k - 1);
ans %= M;
} else {
break;
}
}
cout << ans << "\n";
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.size();
int arr[n];
int start = 0, end = n - 1;
for (int i = 0; i < n; i++) {
if (s[i] == 'l') {
arr[end] = i + 1;
end--;
} else {
arr[start] = i + 1;
start++;
}
}
for (int i = 0; i < n; i++) cout << arr[i] << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, s;
vector<vector<pair<int, int> > > g;
vector<vector<int> > dist, mem;
vector<int> cc, crnum;
void comb(vector<int>& res, vector<int> const& arr) {
for (int i = (int)(res).size() - 1; i >= 0; --i) {
int resi = INT_MIN;
for (int j = 0; j < i + 1; ++j) resi = max(resi, min(res[j], arr[i - j]));
res[i] = resi;
}
}
int solvefromleaf(int u, int c) {
if (c == 0) return 0;
if (mem[u][c] != -1) return mem[u][c];
vector<int> cmb(c + 1, 0);
cmb[0] = INT_MAX;
for (int v = 0; v < n; ++v)
if (v != u && (int)(g[v]).size() == 1) {
vector<int> t(c + 1);
t[0] = INT_MAX;
for (int i = 1; i <= c; ++i) t[i] = dist[u][v] + solvefromleaf(v, c - i);
comb(cmb, t);
}
return mem[u][c] = cmb[c];
}
int solve() {
int res = INT_MAX;
for (pair<int, int> uw : g[s]) {
int u, w;
tie(u, w) = uw;
int cu = crnum[cc[u]];
vector<int> cmb(cu + 1, 0);
cmb[0] = INT_MAX;
for (int v = 0; v < n; ++v)
if (cc[v] == cc[u] && (int)(g[v]).size() == 1) {
vector<int> t(cu + 1);
t[0] = INT_MAX;
for (int i = 1; i <= cu; ++i)
t[i] = dist[s][v] + solvefromleaf(v, m - i);
comb(cmb, t);
}
res = min(res, cmb[cu]);
}
return res;
}
void dfs(int u, int p, int cn) {
cc[u] = cn;
for (pair<int, int> vw : g[u]) {
int v, w;
tie(v, w) = vw;
if (v == p) continue;
dfs(v, u, cn);
}
}
int main() {
cin >> n;
g.assign(n, vector<pair<int, int> >());
for (int i = 0; i < n - 1; ++i) {
int u, v, w;
cin >> u >> v >> w;
u--, v--;
g[u].push_back(pair<int, int>(v, w));
g[v].push_back(pair<int, int>(u, w));
}
cin >> s >> m;
s--;
vector<int> x(m);
for (int i = 0; i < m; ++i) {
cin >> x[i];
x[i]--;
}
cc.assign(n, -1);
cc[s] = 0;
int cn = 1;
for (pair<int, int> vw : g[s]) dfs(vw.first, s, cn++);
crnum.assign(cn, 0);
for (int i = 0; i < m; ++i) crnum[cc[x[i]]]++;
mem.assign(n, vector<int>(m + 1, -1));
dist.assign(n, vector<int>(n, INT_MAX / 2));
for (int i = 0; i < n; ++i) dist[i][i] = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j < (int)(g[i]).size(); ++j)
dist[i][g[i][j].first] = g[i][j].second;
for (int k = 0; k < n; ++k)
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
cout << solve() << endl;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, j, brojac;
bool ok;
pair<int, int> pocetok, kraj, par;
char niza[501][501];
queue<pair<int, int> > kju;
cin >> n >> m;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> niza[i][j];
}
}
cin >> pocetok.first >> pocetok.second;
cin >> kraj.first >> kraj.second;
pocetok.first--;
pocetok.second--;
kraj.first--;
kraj.second--;
ok = false;
if (niza[kraj.first][kraj.second] == 'X') ok = true;
i = kraj.first;
j = kraj.second;
brojac = 0;
niza[kraj.first][kraj.second] = '.';
niza[pocetok.first][pocetok.second] = '.';
if ((i > 0) && (niza[i - 1][j] == '.')) brojac++;
if ((i < n - 1) && (niza[i + 1][j] == '.')) brojac++;
if ((j > 0) && (niza[i][j - 1] == '.')) brojac++;
if ((j < m - 1) && (niza[i][j + 1] == '.')) brojac++;
if ((ok == false) && (brojac < 2)) {
cout << "NO";
return 0;
}
if ((pocetok == kraj) && (brojac == 0)) {
cout << "NO";
return 0;
}
kju.push(pocetok);
while (!kju.empty()) {
par = kju.front();
kju.pop();
i = par.first;
j = par.second;
if ((i == kraj.first) && (j == kraj.second)) {
cout << "YES";
return 0;
}
if ((i > 0) && (niza[i - 1][j] == '.')) {
par.first = i - 1;
par.second = j;
kju.push(par);
niza[i - 1][j] = 'X';
}
if ((i < n - 1) && (niza[i + 1][j] == '.')) {
par.first = i + 1;
par.second = j;
kju.push(par);
niza[i + 1][j] = 'X';
}
if ((j > 0) && (niza[i][j - 1] == '.')) {
par.first = i;
par.second = j - 1;
kju.push(par);
niza[i][j - 1] = 'X';
}
if ((j < m - 1) && (niza[i][j + 1] == '.')) {
par.first = i;
par.second = j + 1;
kju.push(par);
niza[i][j + 1] = 'X';
}
}
cout << "NO";
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using V = vector<T>;
template <typename T>
using VV = vector<V<T>>;
template <typename T>
using Mi = map<long long, T>;
template <typename T>
using MMi = map<long long, Mi<T>>;
vector<long long> tree;
void build(vector<long long> &arr, long long ind, long long l, long long r) {
if (l == r) {
tree[ind] = arr[l];
return;
}
long long mid = (l + r) / 2;
build(arr, ind * 2, l, mid);
build(arr, ind * 2 + 1, mid + 1, r);
tree[ind] = max(tree[ind * 2], tree[ind * 2 + 1]);
}
long long getMax(long long ind, long long tl, long long tr, long long l,
long long r) {
if (l > r) return 0;
if (l == tl && r == tr) return tree[ind];
long long tm = (tl + tr) / 2;
long long a = getMax(ind * 2, tl, tm, l, min(r, tm));
long long b = getMax(ind * 2 + 1, tm + 1, tr, max(l, tm + 1), r);
return max(a, b);
}
vector<bool> prim;
void er() {
long long n = 1e6;
prim = vector<bool>(n + 1, true);
prim[0] = prim[1] = false;
for (long long i = 2; i <= n; i++) {
if (prim[i]) {
for (long long j = i * i; j <= n; j += i) {
prim[j] = false;
}
}
}
}
void ds(long long ind, vector<vector<long long>> &g, vector<bool> &viz) {
viz[ind] = true;
for (long long nind : g[ind]) {
if (!viz[nind]) {
ds(nind, g, viz);
}
}
}
void bfs(long long ind, vector<vector<long long>> &g, vector<long long> &rast) {
long long len = g.size();
vector<bool> viz(len, false);
viz[ind] = true;
queue<long long> q;
q.push(ind);
while (!q.empty()) {
long long v = q.front();
q.pop();
for (long long u : g[v]) {
if (!viz[u]) {
viz[u] = true;
rast[u] = rast[v] + 1;
q.push(u);
}
}
}
}
long long ans = 0;
void dfs(long long v, vector<vector<long long>> &g, vector<bool> &viz,
vector<long long> &dost, set<long long> &list) {
viz[v] = true;
if (list.find(v) != list.end()) {
dost[v] = 2;
} else {
vector<bool> f(4, false);
for (long long u : g[v]) {
if (!viz[u]) {
dfs(u, g, viz, dost, list);
f[dost[u]] = true;
}
}
if (f[2]) {
dost[v] = 1;
ans++;
} else if (f[1]) {
dost[v] = 3;
} else {
dost[v] = 2;
}
}
}
bool comp(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return max(a.first, a.second) < max(b.first, b.second);
}
long long rast(pair<long long, long long> &a, pair<long long, long long> &b) {
return abs(a.first - b.first) + abs(a.second - b.second);
}
vector<long long> z_function(string &s) {
long long n = s.length();
vector<long long> z(n, 0);
long long l = 0, r = 0;
for (long long i = 1; i < n; i++) {
if (i <= r) {
z[i] = min(r - i + 1, z[i - l]);
}
while (i + z[i] < n && s[z[i]] == s[z[i] + i]) {
z[i]++;
}
if (i + z[i] - 1 > r) {
l = i;
r = i + z[i] - 1;
}
}
return z;
}
long long rast(pair<long long, long long> p) {
return max(0ll, p.second - p.first);
}
pair<long long, long long> ob(pair<long long, long long> a,
pair<long long, long long> b) {
pair<long long, long long> c;
c.first = max(a.first, b.first);
c.second = min(a.second, b.second);
return c;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
vector<vector<long long>> g(n);
for (int i = 0; i < n - 1; i++) {
long long a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
set<long long> list;
for (int i = 1; i < n; i++) {
if (g[i].size() == 1) {
list.insert(i);
}
}
vector<bool> viz(n, false);
vector<long long> dost(n);
dfs(0, g, viz, dost, list);
if (dost[0] == 1) {
ans--;
}
for (long long v : g[0]) {
if (dost[v] == 1) {
ans--;
}
}
cout << ans;
return 0;
}
| 11 | CPP |
t = int(input())
for _ in range(t):
n, k = [int(x) for x in input().split()]
k -= 1
while k > 0:
s = list(map(int, list(str(n))))
n2 = n + (min(s) * max(s))
k -= 1
if n2 == n:
break
n = n2
print(n)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, n1, m1, a[60][60], ans = 1 << 30, res;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
cin >> n1 >> m1;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (i + n1 <= n && j + m1 <= m) {
res = 0;
for (int i1 = i; i1 < i + n1; i1++)
for (int j1 = j; j1 < j + m1; j1++) res += a[i1][j1];
ans = min(ans, res);
}
if (i + m1 <= n && j + n1 <= m) {
res = 0;
for (int i1 = i; i1 < i + m1; i1++)
for (int j1 = j; j1 < j + n1; j1++) res += a[i1][j1];
ans = min(ans, res);
}
}
cout << ans;
return 0;
}
| 8 | CPP |
n,a,b=map(int,input().split())
if (b-a)%2==0:
print(int((b-a)//2))
else:
print(int((b-a-1)//2+min(n-b,a-1)+1)) | 0 | PYTHON3 |
cnt = [0]*9
for n in input().split():
cnt[int(n)-1]+=1
print([["Elephant","Bear"][1 in cnt],"Alien"][max(cnt)<4])
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n % 4 > 1) return puts("-1");
for (int i = 1; i < n / 2; i += 2) printf("%d %d ", n - i, i);
if (n % 4) printf("%d ", n + 1 >> 1);
for (int i = 1; i < n / 2; i += 2)
printf("%d %d ", (n - 1) / 2 + 2 + i, n - (n - 1) / 2 - i);
}
| 7 | CPP |
count = input()
a,b,c,d = map(input().split().count,['1','2','3','4'])
print(c+d + (max(a-c,0) + b*2 + 3)//4 ) | 8 | PYTHON3 |
s=input()
f=0
for i in range(len(s)):
if s[i]=='Q' or s[i]=='H' or s[i]=='9':
f=f+1
if f>0:
print("YES")
else:
print("NO") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1605;
int n, m, tot;
int a[MAXN][MAXN];
int sz[MAXN * MAXN];
int ans[MAXN * MAXN];
int cnt[MAXN * MAXN];
int fa1[MAXN * MAXN];
int fa2[MAXN * MAXN];
double v[MAXN][MAXN];
double t[MAXN][MAXN];
int getroot(int *fa, int u) {
return u == fa[u] ? u : fa[u] = getroot(fa, fa[u]);
}
void run() {
memcpy(t, v, sizeof(t));
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (a[i][j]) {
double sum = 0, cnt = 0;
for (int k = i - 4; k <= i + 4; k++)
for (int l = j - 4; l <= j + 4; l++)
if (k >= 1 && k <= n && l >= 1 && l <= m &&
(i - k) * (i - k) + (j - l) * (j - l) <= 25)
sum += t[k][l], cnt++;
v[i][j] = sum / cnt;
}
}
void merge(int *fa, int xa, int ya, int xb, int yb) {
if (!a[xa][ya] || !a[xb][yb]) return;
fa[getroot(fa, (xa - 1) * m + ya)] = getroot(fa, (xb - 1) * m + yb);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
fa1[(i - 1) * m + j] = fa2[(i - 1) * m + j] = (i - 1) * m + j;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &a[i][j]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (a[i][j]) {
v[i][j] = 1;
if (i > 1) merge(fa1, i, j, i - 1, j);
if (i < n) merge(fa1, i, j, i + 1, j);
if (j > 1) merge(fa1, i, j, i, j - 1);
if (j < m) merge(fa1, i, j, i, j + 1);
}
run();
run();
run();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (a[i][j] && v[i][j] < 0.2) {
if (i > 1 && v[i - 1][j] < 0.2) merge(fa2, i, j, i - 1, j);
if (i < n && v[i + 1][j] < 0.2) merge(fa2, i, j, i + 1, j);
if (j > 1 && v[i][j - 1] < 0.2) merge(fa2, i, j, i, j - 1);
if (j < m && v[i][j + 1] < 0.2) merge(fa2, i, j, i, j + 1);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (a[i][j] && v[i][j] < 0.2) sz[getroot(fa2, (i - 1) * m + j)]++;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (a[i][j] && v[i][j] < 0.2 &&
getroot(fa2, (i - 1) * m + j) == (i - 1) * m + j &&
sz[(i - 1) * m + j] >= 5)
cnt[getroot(fa1, (i - 1) * m + j)]++;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (a[i][j] && getroot(fa1, (i - 1) * m + j) == (i - 1) * m + j)
ans[++tot] = cnt[(i - 1) * m + j];
sort(ans + 1, ans + tot + 1);
printf("%d\n", tot);
for (int i = 1; i <= tot; i++) printf("%d ", ans[i]);
printf("\n");
return 0;
}
| 12 | CPP |
def vovel(c):
return c in ['a', 'i', 'o', 'e', 'u', 'y']
n = int(input())
s = input()[:n]
if len(s)>0:
p = s[0]
else:
print ()
exit()
res = ''
for i in range(1, len(s)):
if vovel(p) and vovel(s[i]):
continue
res +=p
p = s[i]
res += p
print (res) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int a[2001];
int b[2001];
int was[2001];
int pos[2001];
vector<pair<int, int> > ans, ans1;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
cin >> b[i];
pos[b[i]] = i;
}
int res = 0;
for (int i = 1; i <= n; i++) {
if (a[i] == b[i]) continue;
int x = 0;
for (int j = i + 1; j <= n; j++) {
if (b[i] == a[j]) x = j;
}
int last = x;
for (int j = x; j >= i; j--) {
if (pos[a[j]] >= last) {
ans.push_back(make_pair(j, last));
res += last - j;
swap(a[last], a[j]);
last = j;
}
}
}
cout << res << '\n';
cout << ans.size() << '\n';
for (auto to : ans) {
cout << to.first << ' ' << to.second << '\n';
}
return 0;
}
| 11 | CPP |
n=int(input())
b=[int(x) for x in input().split()]
b=list(set(b))
b.sort()
if(len(b)==1):
print("NO")
else:
print(b[1])
| 7 | PYTHON3 |
q=int(input())
i=0
k=0
while q>0:
n=int(input())
if n==1:
print(3)
elif n==2:
print(2)
elif n%2==0:
print(0)
else:
print(1)
q-=1
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
int a[200010], b[200010];
int main() {
int n, m;
cin >> n;
rep(i, n)cin >> a[i];
cin >> m;
rep(i, m)cin >> b[i];
rep(i, n)if (binary_search(b, b + m, a[i]))cout << a[i] << endl;
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
int w[1100000];
int main() {
int n;
while (~scanf("%d", &n)) {
int i, tem;
int nmax = 0;
memset(w, 0, sizeof(w));
for (i = 1; i <= n; i++) {
scanf("%d", &tem);
w[tem]++;
if (tem > nmax) nmax = tem;
}
for (i = 0; i <= nmax; i++) {
if (w[i] >= 2) {
w[i + 1] += w[i] / 2;
w[i] %= 2;
if (i == nmax) nmax++;
}
}
int ans = 0;
for (i = 0; i <= nmax; i++) {
if (w[i] == 1) {
ans++;
}
}
printf("%d\n", ans);
}
}
| 7 | CPP |
from math import pi
d,h,v,e=map(int,input().split())
x=(4*v)/(pi*d*d)
if x<=e :
print("NO")
else:
print("YES")
t=h/(x-e)
print(t) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const double PI = acos(-1.0);
const int MAX_N = 1005;
int n, m;
char A[MAX_N][MAX_N];
int cnt1[MAX_N][MAX_N], cnt2[MAX_N][MAX_N];
int suf[MAX_N][MAX_N], pref[MAX_N][MAX_N];
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> A[i][j];
}
}
for (int i = 0; i < n; i++) {
cnt2[i][m - 1] = 1;
for (int j = m - 2; j >= 0; j--) {
if (A[i][j] == A[i][j + 1]) {
cnt2[i][j] = cnt2[i][j + 1] + 1;
} else {
cnt2[i][j] = 1;
}
}
}
for (int j = 0; j < m; j++) {
cnt1[n - 1][j] = 1;
suf[n - 1][j] = cnt2[n - 1][j];
for (int i = n - 2; i >= 0; i--) {
if (A[i][j] == A[i + 1][j]) {
cnt1[i][j] = cnt1[i + 1][j] + 1;
suf[i][j] = min(suf[i + 1][j], cnt2[i][j]);
} else {
cnt1[i][j] = 1;
suf[i][j] = cnt2[i][j];
}
}
pref[0][j] = cnt2[0][j];
for (int i = 1; i < n; i++) {
if (A[i][j] == A[i - 1][j]) {
pref[i][j] = min(pref[i - 1][j], cnt2[i][j]);
} else {
pref[i][j] = cnt2[i][j];
}
}
}
long long res = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int i1 = i;
int i2 = i1 + cnt1[i1][j];
if (i2 == n) continue;
int i3 = i2 + cnt1[i2][j];
if (i3 == n) continue;
if (cnt1[i1][j] != cnt1[i2][j]) continue;
if (cnt1[i3][j] < cnt1[i1][j]) continue;
int m1 = suf[i1][j];
int m2 = suf[i2][j];
int m3 = pref[i3 + cnt1[i1][j] - 1][j];
res += min(m1, min(m2, m3));
}
}
cout << res;
return 0;
}
| 9 | CPP |
# 0 1 2 3 4 5
# 1 2 4 7 11 16
def f(x):
return x * (x + 1) // 2
def works(n, k, s):
rem = k - 1 - s
val = f(k - 1) - f(rem) + 1
return val >= n
def main():
n, k = map(int, input().split())
if n == 1:
print(0)
else:
if not works(n, k, k):
print(-1)
else:
lo = 0
hi = k
while lo + 1 < hi:
mid = (lo + hi) // 2
if works(n, k, mid):
hi = mid
else:
lo = mid
print(hi)
main()
| 8 | PYTHON3 |
#include<bits/stdc++.h>
#define ll long long
typedef long double ld;
#define pr pair<int,int>
#define ios ios::sync_with_stdio(false)
const int SIZE=1e6+6;
const int INF=0x3f3f3f;
using namespace std;
void getS(){
freopen(R"(C:\Users\Vicky\Desktop\ABC\in.txt)","r",stdin);
}
inline int read()
{
int x=0,f=1;
char ch=getchar();
while(ch<'0'||ch>'9')
{
if(ch=='-')
f=-1;
ch=getchar();
}
while(ch>='0' && ch<='9')
x=x*10+ch-'0',ch=getchar();
return x*f;
}
int main()
{
//getS();
ll k,n,x,t;
k=read();
while(k--){
n=read(),x=read(),t=read();
if(t>=(n-1)*x){
cout<<n*(n-1)/2<<endl;
} else{
ll cnt=t/x;
cout<<(n-cnt)*cnt+cnt*(cnt-1)/2<<endl;
}
}
}
| 7 | CPP |
k,r=map(int,input().split())
for i in range(1,10):
x=k*i
if(x%10==0):
print(i)
break
elif((x-r)%10==0):
print(i)
break | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int fx[] = {+1, -1, +0, +0};
const int fy[] = {+0, +0, +1, -1};
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
long long int binpow(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
const long long int N = 1e2 + 10;
long long int n, k;
long long int a[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t;
cin >> t;
while (t--) {
cin >> n >> k;
long long int a[n];
for (long long int i = 0; i < n; i++) {
cin >> a[i];
}
long long int sum = 1;
for (long long int i = 1; i < n; i++) {
sum += (a[i] != a[i - 1]);
}
if (k == 1) {
if (sum == 1) {
cout << 1 << endl;
} else {
cout << -1 << endl;
}
continue;
}
long long int ans = (sum + k - 3) / (k - 1);
cout << max(1LL, ans) << endl;
}
return 0;
}
| 8 | CPP |
from collections import deque
H,W=map(int,input().split())
white=0
s=[]
for y in range(H):
line=input()
white+=line.count('.')
s.append(list(line))
q = deque([(0,0,1)])
q_append=q.append
q_popleft=q.popleft
while q:
x,y,l=q_popleft()
if s[y][x]!='.':
continue
if x==W-1 and y==H-1:
print(white-l)
break
s[y][x]='*'
for d in [(1,0),(0,1),(-1,0),(0,-1)]:
nx, ny=(x+d[0],y+d[1])
if 0<=nx<W and 0<=ny<H:
q_append((nx,ny,l+1))
else:
print(-1) | 0 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
string s;
int main(){
cin>>s;
for(int i=1;i<=s.size();i++) cout<<"x";
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int power(int a, int b) {
if (b == 0) return 1;
int ret = a;
for (int i = 1; i < b; i++) {
ret *= a;
}
return ret;
}
int main() {
string s;
cin >> s;
vector<char> s1;
int c = 0;
for (int i = 0; i < s.size();) {
if (s[i] == '-' && s[i + 1] == '-') {
s1.push_back('2');
i += 2;
}
if (s[i] == '-' && s[i + 1] == '.') {
s1.push_back('1');
i += 2;
}
if (s[i] == '.') {
s1.push_back('0');
i += 1;
}
c++;
}
for (int i = 0; i < s1.size(); i++) cout << s1[i];
cout << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int s;
cin >> s;
if (s < 0) {
int a = s / 10;
int b = s / 100 * 10;
b += s % 10;
if (a > b)
cout << a;
else
cout << b;
} else
cout << s;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[1000005], b[1000005];
int n, m, t1, t2;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
for (int i = 1; i <= m; ++i) scanf("%d", b + i);
t1 = t2 = 0;
long long to1 = 0, to2 = 0;
int res = 0;
while (t1 <= n && t2 <= m) {
if (to1 <= to2)
to1 += a[++t1];
else
to2 += b[++t2];
if (to1 == to2) ++res;
if (t1 == n && t2 == m) break;
}
cout << res;
return 0;
}
| 8 | CPP |
import sys
input = lambda: sys.stdin.readline().rstrip()
for _ in range(int(input())):
a=[int(i) for i in input().split()]
a.sort()
ans=0
if a[0]>=1:
ans+=1
a[0]-=1
if a[1]>=1:
ans+=1
a[1]-=1
if a[2]>=1:
ans+=1
a[2]-=1
if a[1]>=1 and a[2]>=1:
ans+=1
a[2]-=1
a[1]-=1
if a[0]>=1 and a[2]>=1:
ans+=1
a[0]-=1
a[2]-=1
if a[0]>=1 and a[1]>=1:
ans+=1
a[0]-=1
a[1]-=1
if a[0]>=1 and a[2]>=1 and a[1]>=1:
ans+=1
a[0]-=1
a[2]-=1
a[1]-=1
print(ans)
| 7 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
const int N=1000005,P=998244353;
typedef long long ll;
int fac[N],ifac[N],n,m,ans;
int fpow(int a,int t){
static int r;
for(r=1;t;t>>=1,a=(ll)a*a%P)if(t&1)r=(ll)r*a%P;
return r;
}
int C(int n,int m){
if(n<m)return 0;
return (ll)fac[n]*ifac[m]%P*ifac[n-m]%P;
}
int main(){
scanf("%d%d",&n,&m);
if(n>m)swap(n,m);
fac[0]=1;
for(int i=1;i<=n+m;i++)fac[i]=(ll)fac[i-1]*i%P;
ifac[n+m]=fpow(fac[n+m],P-2);
for(int i=n+m;i>=1;i--)ifac[i-1]=(ll)ifac[i]*i%P;
for(int i=1;i<=n;i++)ans=(ans+(ll)C(i<<1,i)*C(n+m-(i<<1),n-i))%P;
ans=((ll)ans*fpow(C(n+m,n)*2,P-2)+m)%P;
printf("%d\n",ans);
return 0;
} | 0 | CPP |
d, h, v, e = map(int, input().split(' '))
k=4*v/(3.1415926*(d**2))
if(k>e):
print('YES\n',h/(k-e))
else:
print('NO')
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int INF = 1e9;
const long long IINF = 1e18;
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const char dir[4] = {'D', 'R', 'U', 'L'};
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (T &x : v) is >> x;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < v.size(); ++i) {
os << v[i] << (i + 1 == v.size() ? "" : " ");
}
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
cout << '(' << p.first << ',' << p.second << ')';
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &m) {
os << '{';
for (auto itr = m.begin(); itr != m.end(); ++itr) {
os << '(' << itr->first << ',' << itr->second << ')';
if (++itr != m.end()) os << ',';
--itr;
}
os << '}';
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &s) {
os << '{';
for (auto itr = s.begin(); itr != s.end(); ++itr) {
os << *itr;
if (++itr != s.end()) os << ',';
--itr;
}
os << '}';
return os;
}
void debug_out() { cerr << '\n'; }
template <class Head, class... Tail>
void debug_out(Head &&head, Tail &&...tail) {
cerr << head;
if (sizeof...(Tail) > 0) cerr << ", ";
debug_out(move(tail)...);
}
template <typename T>
T gcd(T x, T y) {
return y != 0 ? gcd(y, x % y) : x;
}
template <typename T>
T lcm(T x, T y) {
return x / gcd(x, y) * y;
}
template <class T1, class T2>
inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T1, class T2>
inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> x(n), y(n);
for (int i = 0; i < n; ++i) cin >> x[i] >> y[i];
if (n & 1) {
cout << "NO" << '\n';
return 0;
}
int m = n / 2;
vector<int> sx(m), sy(m);
for (int i = 0; i < m; ++i) {
sx[i] = x[i] + x[i + m];
sy[i] = y[i] + y[i + m];
if (i && sx[i] != sx[i - 1]) {
cout << "NO" << '\n';
return 0;
}
if (i && sy[i] != sy[i - 1]) {
cout << "NO" << '\n';
return 0;
}
}
cout << "YES" << '\n';
}
| 8 | CPP |
n=input()
if n[:1]==n[:1].upper():
print(n)
else:
print(n[:1].upper()+n[1:])
| 7 | PYTHON3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000")
using namespace std;
inline long long read() {
long long x;
cin >> x;
return x;
}
const int MAX_N = 1e5 + 5;
const int MAX_K = 1e6 + 66;
const int MAX_LOG = 19;
const long long MODULE = 1e9 + 7;
int n, logN;
vector<pair<int, int> > e[MAX_N];
int p[MAX_N][MAX_LOG], h[MAX_N], pre[MAX_N], a[MAX_N], b[MAX_N];
bool ok[MAX_N];
long long pow2[MAX_K];
inline long long mmod(long long x) {
x %= MODULE;
if (x < 0) x += MODULE;
return x;
}
void dfs(int u) {
ok[u] = 0;
for (int i = (1); i <= (logN); ++i) {
if (h[u] - (1 << i) < 1) break;
p[u][i] = p[p[u][i - 1]][i - 1];
}
for (__typeof(e[u].begin()) it = e[u].begin(); it != e[u].end(); it++) {
int v = it->first;
if (!ok[v]) continue;
pre[v] = it->second;
h[v] = h[u] + 1;
p[v][0] = u;
dfs(v);
}
}
inline int lca(int u, int v) {
if (h[u] < h[v]) swap(u, v);
if (h[u] > h[v])
for (int i = (logN); i >= (0); --i)
if (h[u] - (1 << i) >= h[v]) u = p[u][i];
if (u == v) return u;
for (int i = (logN); i >= (0); --i)
if (p[u][i] != p[v][i]) {
u = p[u][i];
v = p[v][i];
}
return p[u][0];
}
void solve(int u) {
for (__typeof(e[u].begin()) it = e[u].begin(); it != e[u].end(); it++) {
int v = it->first;
if (p[v][0] == u) {
solve(v);
a[u] += a[v];
b[u] += b[v];
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(9);
cout.setf(ios::fixed, ios::floatfield);
cin >> n;
for (int i = (1); i <= (n - 1); ++i) {
int x, y, c;
cin >> x >> y >> c;
if (c == 0) {
e[x].push_back(make_pair(y, -1));
e[y].push_back(make_pair(x, -1));
} else {
e[x].push_back(make_pair(y, 0));
e[y].push_back(make_pair(x, 1));
}
}
pow2[0] = 1;
for (int i = (1); i <= (MAX_K - 1); ++i) pow2[i] = mmod(pow2[i - 1] * 2LL);
logN = 0;
while (1 << (logN + 1) <= n) ++logN;
memset(ok, 1, sizeof(ok));
for (int u = (1); u <= (n); ++u)
for (int i = (0); i <= (logN); ++i) p[u][i] = 0;
pre[1] = -1;
h[1] = 1;
dfs(1);
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
int nQ = read(), u = 1, v, r;
while (nQ--) {
cin >> v;
r = lca(u, v);
++a[u];
--a[r];
++b[v];
--b[r];
u = v;
}
long long ans = 0;
solve(1);
for (int u = (2); u <= (n); ++u) {
if (a[u] > 0 && pre[u] == 0) ans = mmod(ans + pow2[a[u]] - 1);
if (b[u] > 0 && pre[u] == 1) ans = mmod(ans + pow2[b[u]] - 1);
}
cout << ans << '\n';
return 0;
}
| 8 | CPP |
Subsets and Splits