solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int d[105], h[105];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < m; i++) cin >> d[i];
vector<int> ans;
int limit = k + 1;
for (int i = 0; i < k; i++) cin >> h[i];
for (int i = 0; i < m; i++) {
vector<int> cur;
for (int j = 0; j < k; j++)
if (h[j] % d[i] == 0) cur.push_back(j);
if (cur.size() < limit) {
ans.clear(), limit = cur.size();
}
if (cur.size() == limit) ans.push_back(i);
}
cout << ans.size() << '\n';
for (int i = 0; i < ans.size(); i++)
cout << ans[i] + 1 << " \n"[i + 1 == ans.size()];
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int x, y, n;
long long int f[6];
cin >> x >> y >> n;
f[0] = x;
f[1] = y;
for (int i = 2; i < 6; i++) {
f[i] = f[i - 1] - f[i - 2];
}
long long int ans = f[(n - 1) % 6] % 1000000007;
if (ans < 0)
cout << 1000000007 + ans << endl;
else
cout << ans << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream& operator<<(ostream& cout, vector<T> V) {
cout << "[ ";
for (auto v : V) cout << v << ' ';
return cout << ']';
}
template <class L, class R>
ostream& operator<<(ostream& cout, pair<L, R> P) {
return cout << '(' << P.first << ',' << P.second << ')';
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
vector<vector<long long>> inp(n);
for (long long i = 0; i < n; ++i) {
long long tmp;
cin >> tmp;
for (long long j = 0; j < tmp; ++j) {
long long num;
cin >> num;
inp[i].push_back(num);
}
}
vector<pair<long long, long long>> nonaccent;
long long accented = 0;
for (auto vec : inp) {
long long mini = INT_MAX;
long long maxi = INT_MIN;
bool bl = 0;
for (auto it : vec) {
if (it > mini) {
bl = 1;
}
mini = min(mini, it);
maxi = max(maxi, it);
}
if (!bl) {
nonaccent.push_back({mini, maxi});
} else {
++accented;
}
}
vector<long long> maxi;
for (auto it : nonaccent) {
maxi.push_back(it.second);
}
sort(maxi.begin(), maxi.end());
long long ans = accented * n * 2 - accented * accented;
for (auto it : nonaccent) {
ans -= (upper_bound(maxi.begin(), maxi.end(), it.first) - maxi.end());
}
cout << ans << "\n";
}
| 8 | CPP |
for _ in range(int(input())):
l = list(map(int,input().split()))
count = 0
for i in l:
if i%2!=0:
count += 1
if count!=2:
if count==3:
f = 0
for i in l[:3]:
if i==0:
f = 1
break
if f==1:
print("No")
else:print("Yes")
else:print("Yes")
else:print("No") | 7 | PYTHON3 |
import math as mt
n, m, a = map(int,input().split())
print(mt.ceil(m/a)*mt.ceil(n/a))
| 7 | PYTHON3 |
n=int(input())
print("YES" if (n%4==0 or n%7==0 or n%47==0 or n%74==0 or n%447==0 or n%474==0 or n%477==0 or n%774==0 or n%747==0 or n%744==0) else "NO")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
#ifdef ONLINE_JUDGE
#define cerr if(false)cerr
#else
#define cerr if(true)cerr
#endif
#define inputarr(a,n) for(ll i=0;i<n;i++) cin>>a[i];
#define prllarr(a,n) for(ll i=0;i<n;i++) cerr<<a[i]<<" "; cerr<<endl;
#define pb push_back
#define ll long long
#define mod 998244353
#define foi ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(0);
#define in(n) scanf("%lld",&n);
#define in2(x,y) scanf("%lld %lld",&(x),&(y));
#define in3(x,y,z) scanf("%lld %lld %lld",&(x),&(y),&(z));
#define in4(x,y,z,m) scanf("%lld %lld %lld %lld",&(x),&(y),&(z),&(m));
#define out(n) printf("%lld\n",n);
#define out2(x,y) printf("%lld %lld\n",x,y);
#define test(t) ll t; in(t);while(t--)
#define set(arr,n,s) for(ll i=0;i<n;i++){arr[i]=s;}
#define fr(i,s,e) for(ll i=s;i<e;i++)
#define frr(i,s,e) for(ll i=e-1;i>=s;i--)
#define vi vector<ll>
#define see2(x,y) cerr<<x<<" "<<y<<endl;
#define see(x) cerr<<x<<endl;
#define see3(x,y,z) cerr<<x<<" "<<y<<" "<<z<<endl;
#define see4(x,y,z,m) cout<<x<<" "<<y<<" "<<z<<" "<<m<<endl;
#define invec(a,n) fr(i,0,n){ll x;in(x) a.pb(x);}
#define vii vector<pair<ll,ll> >
#define all(a) a.begin(),a.end()
#define pii pair<ll,ll>
ll power(ll x,ll y,ll p){ll res=1;x=x%p;while(y>0){if(y&1){res=(res*x)%p;} y=y>>1;x=(x*x)%p;}return res;}
ll modInverse(ll a,ll p){return power(a,p-2,p);}//used with feemat little//only for prime
// void gcd(ll a, ll b, ll& d, ll& u, ll& v) {
// if (b == 0) {
// d = a;
// u = 1;
// v = 0;
// } else {
// gcd(b, a % b, d, v, u);
// // a u + b v = b u' + (a - (a/b) * b) v'
// // = a v' + b (u' - (a/b) v').
// v -= a / b * u;
// }
// }
// ll Inverse(ll a, ll m) {
// a %= m;
// if (a < 0) a += m;
// ll d, u, v;
// gcd(a, m, d, u, v);
// assert(d == 1);
// u %= m;
// if (u < 0) u += m;
// return u;
// }
ll gcd(ll x,ll y){if(x==0 || y==0){return max(y,x);}return gcd(y%x,x);}
// ll gcdExtended(ll a,ll b,ll &x,ll &y){if(a==0){x=0;y=1;return b;}ll x1,y1;ll gcd = gcdExtended(b%a,a,x1,y1);x=y1-(b/a)*x1;y=x1;return gcd;}//o(log(b))
// ;
int main(){
test(T){
string s;
cin>>s;
ll n;
n=s.size();
if(n%2==1 || s[0]==s[n-1]){
cout<<"NO"<<endl;
continue;
}
ll first=s[0]-'a';
ll second=s[n-1]-'a';
ll cur=0;
ll here=1;
for(ll i=0;i<n;i++){
ll cc=s[i]-'a';
if(cc!=second){
cur++;
}
else cur--;
if(cur<0){
here=0;
break;
}
}
if(here && cur==0){
cout<<"YES"<<endl;
continue;
}
here=1;
cur=0;
for(ll i=0;i<n;i++){
ll cc=s[i]-'a';
if(cc!=first){
cur--;
}
else cur++;
if(cur<0){
here=0;
break;
}
}
if(here && cur==0){
cout<<"YES"<<endl;
continue;
}
cout<<"NO"<<endl;
}
}
/*error-----
convert every int to long long eg-1LL
check mod also
*/
| 7 | CPP |
x = input()
a = int(x)
if a == 2:
print("NO")
elif a%2 == 0:
print("YES")
else:
print("NO")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, a[100];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
if (a[n - 1] == 15) {
cout << "DOWN";
return 0;
}
if (a[n - 1] == 0) {
cout << "UP";
return 0;
}
if (n == 1) {
cout << "-1";
return 0;
}
if (a[n - 1] > a[n - 2]) {
cout << "UP";
return 0;
}
if (a[n - 1] < a[n - 2]) {
cout << "DOWN";
return 0;
}
}
| 7 | CPP |
import sys
from sys import stdin
ty = ["abc","acb","bac","bca","cab","cba"]
n,m = map(int,stdin.readline().split())
s = list(stdin.readline()[:-1])
dp = [[0] * (n+1) for i in range(6)]
for c in range(6):
for i in range(n):
if s[i] != ty[c][i%3]:
dp[c][i+1] = dp[c][i] + 1
else:
dp[c][i+1] = dp[c][i]
ANS = []
for loop in range(m):
l,r = map(int,stdin.readline().split())
ans = float("inf")
for c in range(6):
ans = min(ans , dp[c][r] - dp[c][l-1])
ANS.append(str(ans))
print ("\n".join(ANS))
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double Pi = acos(-1);
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
double dpow(double a, long long b) {
double ans = 1.0;
while (b) {
if (b % 2) ans = ans * a;
a = a * a;
b /= 2;
}
return ans;
}
long long quick_pow(long long x, long long y) {
long long ans = 1;
while (y) {
if (y & 1) {
ans = ans * x % mod;
}
x = x * x % mod;
y >>= 1;
}
return ans;
}
int w[maxn];
long long f[maxn];
void upd(int l, int r, int val) {
f[l] += val;
f[r + 1] -= val;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d", &w[i]);
}
for (int i = 1; i < m; i++) {
int l = w[i];
int r = w[i + 1];
if (l == r) continue;
if (l > r) swap(l, r);
upd(1, l - 1, r - l);
upd(l, l, r - 1);
upd(l + 1, r - 1, r - l - 1);
upd(r, r, l);
upd(r + 1, n, r - l);
}
for (int i = 1; i <= n; i++) {
f[i] += f[i - 1];
}
for (int i = 1; i <= n; i++) {
printf("%lld ", f[i]);
}
printf("\n");
return 0;
}
| 11 | CPP |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
int m, nmin, nmax;
while(cin >> m >> nmin >> nmax, !(m == 0 && nmin == 0 && nmax == 0)) {
vector<int> p(m);
for(int i = 0; i < m; ++i) {
cin >> p[i];
}
sort(p.begin(), p.end());
reverse(p.begin(), p.end());
int ans = 0, gap = -1;
for(int i = nmax; i >= nmin; --i) {
int g = p[i - 1] - p[i];
if(gap < g) {
ans = i;
gap = g;
}
}
cout << ans << endl;
}
} | 0 | CPP |
x = int(input())
output = 0
bills = [100,20,10,5,1]
for amount in bills:
r = x // amount
output += r
x -= r*amount
print(output) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int r[50][50], min, a, b, c;
cin >> a >> b;
for (int i = 0; i < a; i++) {
for (int j = 0; j < b; j++) {
cin >> r[i][j];
}
}
int m, n, sum = 0;
cin >> m >> n;
vector<int> vec;
for (int i = 0; i <= (a - m); i++) {
for (int j = 0; j <= (b - n); j++) {
for (int k = i; k < (i + m); k++) {
for (int l = j; l < (j + n); l++) {
sum += r[k][l];
}
}
vec.push_back(sum);
sum = 0;
}
}
for (int i = 0; i <= (a - n); i++) {
for (int j = 0; j <= (b - m); j++) {
for (int k = i; k < (i + n); k++) {
for (int l = j; l < (j + m); l++) {
sum += r[k][l];
}
}
vec.push_back(sum);
sum = 0;
}
}
cout << *min_element(vec.begin(), vec.end());
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
template <typename T>
void print(vector<T> v) {
for (T &i : v) cout << i << " ";
cout << "\n";
}
bool comp(pair<long long int, long long int> &first,
pair<long long int, long long int> &second) {
return first > second;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int arr[3][3];
for (long long int i = 0; i < 3; i++) {
for (long long int j = 0; j < 3; j++) {
cin >> arr[i][j];
}
}
for (long long int i = 0; i < 500000; i++) {
arr[1][1] = i;
long long int sum = arr[2][0] + arr[1][1] + arr[0][2];
arr[0][0] = sum - arr[0][1] - arr[0][2];
arr[2][2] = sum - arr[2][0] - arr[2][1];
if ((arr[0][0] + arr[1][1] + arr[2][2]) == sum) {
for (long long int i = 0; i < 3; i++) {
for (long long int j = 0; j < 3; j++) {
cout << arr[i][j] << " ";
}
cout << "\n";
}
break;
}
}
return 0;
}
| 8 | CPP |
#define NDEBUG
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <map>
#include <queue>
#include <set>
#include <tuple>
#include <cassert>
#include <unistd.h>
#include <cstdio>
#include <cstdlib>
using namespace std;
typedef long long ll;
struct LCNode {
typedef LCNode* NP;
typedef int D;
static const int INF = 1LL<<25;
static const int DF = 1LL<<25;
static LCNode last_d;
static NP last;
NP p, l, r;
int sz;
int v, sm, lz;
int lsm, rsm, ma, mv;
bool rev;
LCNode(D v) :p(NULL), l(last), r(last), sz(1),
v(v), sm(v), lz(DF), rev(false),
lsm(max(v, 0)), rsm(max(v, 0)), ma(max(v, 0)), mv(v) {}
LCNode() : l(NULL), r(NULL), sz(0), v(-INF), mv(-INF) {}
inline int pos() {
if (p) {
if (p->l == this) return -1;
if (p->r == this) return 1;
}
return 0;
}
void rot() {
NP qq = p->p;
int pps = p->pos();
if (p->l == this) {
p->l = r; r->p = p;
r = p; p->p = this;
} else {
p->r = l; l->p = p;
l = p; p->p = this;
}
p->update(); update();
p = qq;
if (!pps) return;
if (pps == -1) {
qq->l = this;
} else {
qq->r = this;
}
qq->update();
}
void splay() {
assert(this != last);
supush();
int ps;
while ((ps = pos())) {
int pps = p->pos();
if (!pps) {
rot();
} else if (ps == pps) {
p->rot(); rot();
} else {
rot(); rot();
}
}
}
void expose() {
assert(this != last);
NP u = this;
do {
u->splay();
} while ((u = u->p));
u = last;
u->p = this;
do {
u->p->r = u;
u->p->update();
u = u->p;
} while (u->p);
splay();
}
void push() {
int lsz = l->sz, rsz = r->sz;
if (rev) {
if (lsz) {
l->revdata();
}
if (rsz) {
r->revdata();
}
rev = false;
}
if (lz != DF) {
if (lsz) {
l->lzdata(lz);
}
if (rsz) {
r->lzdata(lz);
}
lz = DF;
}
}
void nopush() {
assert(rev == false);
assert(lz == DF);
}
void supush() {
if (pos()) {
p->supush();
}
push();
}
inline void revdata() {
assert(this != last);
swap(l, r);
swap(lsm, rsm);
rev ^= true;
}
inline void lzdata(D d) {
assert(this != last);
v = mv = d;
sm = sz*d;
lsm = rsm = ma = max(0, sm);
lz = d;
}
NP update() {
assert(this != last);
sz = 1+l->sz+r->sz;
sm = v+l->sm+r->sm;
lsm = max(l->lsm, l->sm+v+r->lsm);
rsm = max(r->rsm, r->sm+v+l->rsm);
ma = l->rsm+v+r->lsm;
ma = max(ma, l->ma);
ma = max(ma, r->ma);
// ma = max(l->ma, r->ma);
// ma = max(ma, l->rsm+v+r->lsm);
mv = v;
mv = max(mv, l->mv);
mv = max(mv, r->mv);
// mv = max(l->mv, r->mv);
// mv = max(mv, v);
return this;
}
void evert() {
expose();
revdata();
}
};
LCNode LCNode::last_d = LCNode();
LCNode::NP LCNode::last = &last_d;
const int BS = 1<<8;
char stdinb[BS], stdoutb[BS], convb[20];
int sinc = BS, soutc = 0;
char getc() {
if (sinc == BS) {
read(0, stdinb, BS);
sinc = 0;
}
sinc++;
return stdinb[sinc-1];
}
int getint() {
char c;
bool neg = false;
do {
c = getc();
} while (!isdigit(c) && c != '-');
if (c == '-') {neg = true; c = getc();}
int res = c-'0';
while (isdigit(c = getc())) {
res *= 10;
res += c-'0';
}
if (neg) res *= -1;
return res;
}
void putc(char c) {
stdoutb[soutc] = c;
soutc++;
if (soutc == BS) {
write(1, stdoutb, BS);
soutc = 0;
}
}
void flush() {
write(1, stdoutb, soutc);
soutc = 0;
}
void putint(int d) {
int c = 0;
bool neg = false;
if (d < 0) {
putc('-');
d *= -1;
}
if (!d) {
putc('0');
return;
}
while (d) {
convb[c] = d%10 + '0';
c++;
d /= 10;
}
while (c > 0) {
putc(convb[c-1]); c--;
}
}
const int MN = 201000;
LCNode tr[MN];
int main() {
int n = getint(), q = getint();
for (int i = 0; i < n; i++) {
int w = getint();
tr[i] = LCNode(w);
}
for (int i = 0; i < n-1; i++) {
int s = getint(), e = getint(); s--; e--;
tr[s].evert();
tr[e].expose();
tr[s].p = &tr[e];
}
for (int i = 0; i < q; i++) {
int t = getint(), a = getint(), b = getint(), c = getint();
a--; b--;
if (t == 1) {
tr[a].evert();
tr[b].expose();
tr[b].lzdata(c);
} else {
tr[a].evert();
tr[b].expose();
int d;
if (tr[b].mv < 0) d = tr[b].mv;
else d = tr[b].ma;
putint(d);
putc('\n');
}
}
flush();
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int (i)=(0);(i)<(long long)(n);++(i))
using ll = long long;
using P = pair<int, int>;
using namespace std;
ll dp[201010][16][2], dp2[201010][2];
int main() {
int N;
cin >> N;
vector<ll> A(N);
rep(i, N) cin >> A[i];
rep(i, N-1) rep(k, 2) dp2[i][k] = 1e18;
rep(k, 2) {
rep(j, 16) dp[N-1][j][k] = j;
for (int i=N-2; i>=0; --i) {
rep(j, 16) {
ll a = (A[i] << (2*j));
int j2 = 0;
while (a > (A[i+1]<<(2*j2))) j2++;
if (j2 <= 15) {
dp[i][j][k] = dp[i+1][j2][k] + j;
}
else {
dp[i][j][k] = dp[i+1][15][k] + j + (N-1-i) * (j2-15);
}
dp2[i][k] = min(dp2[i][k], dp[i][j][k]);
}
}
reverse(A.begin(), A.end());
}
ll ans = 1e18;
rep(i, N+1) {
ll ret = i + 2 * (dp2[i][0] + dp2[N-i][1]);
ans = min(ans, ret);
}
cout << ans << endl;
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
int min(int a, int b) {
if (a < b) return a;
return b;
}
int n, m, k;
int map[105][105];
int x[15], y[15];
int A = 1 << 29;
void dfs(int v) {
if (v == n + 1) {
int gt = 0;
for (int i = 1; i <= n; i++) y[i] = map[i][1] ^ x[i], gt += x[i];
for (int i = 2; i <= m; i++) {
int t1 = 0, t2 = 0;
for (int j = 1; j <= n; j++)
if (map[j][i] != y[j])
t1++;
else
t2++;
gt += min(t1, t2);
}
A = min(A, gt);
return;
}
x[v] = 1;
dfs(v + 1);
x[v] = 0;
dfs(v + 1);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &map[i][j]);
if (n > k) {
int ans = (1 << 29);
for (int i = 1; i <= n; i++) {
int gt = 0;
for (int j = 1; j <= n; j++)
if (i != j) {
int t1 = 0, t2 = 0;
for (int k = 1; k <= m; k++)
if (map[i][k] != map[j][k])
t1++;
else
t2++;
gt += min(t1, t2);
}
ans = min(ans, gt);
}
if (ans <= k)
printf("%d\n", ans);
else
printf("-1\n");
} else {
dfs(1);
if (A <= k)
printf("%d\n", A);
else
printf("-1\n");
}
}
| 8 | CPP |
string1 = input()
string2 = input()
string3 = input()
string4 = string1 + string2
a = len(string3)
b = len(string4)
c = 0
d = 0
if a==b:
for i in string3:
if string3.count(i) == string4.count(i):
c+=1
else:
d+=1
if c == a:
print("YES")
else:
print("NO") | 7 | PYTHON3 |
n = int(input())
cd = [int(x) for x in input().split(" ")]
min_count = 1
min = 0
for i in range(1, n):
if cd[i] < cd[min]:
min = i
min_count = 1
elif cd[i] == cd[min]:
min_count += 1
if(min_count > 1):
print("Still Rozdil")
else:
print(min + 1)
| 7 | PYTHON3 |
def solve(n: int, k: int) -> int:
assert n > k
p = n
for i in range(2,min(k+1,40000)):
if i*i > n:
break
q, r = divmod(n, i)
if r == 0:
p = min(q if q > k else i, p)
return p
if __name__ == "__main__":
tc = int(input())
while tc > 0:
n, k = map(int, input().split())
print(1 if n <= k else solve(n, k))
tc -= 1
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
set<char> st;
cin >> n;
for (int i = 0; i < n; i++) {
char c;
cin >> c;
st.insert(c);
}
if (n > 26)
cout << -1 << endl;
else
cout << n - st.size() << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 10 | CPP |
def good_numbers(n: int) -> int:
base_three_inverted = []
while n > 0:
remainder = n % 3
base_three_inverted.append(remainder)
n = n // 3
for i in range(len(base_three_inverted)):
digit = base_three_inverted[i]
if digit > 1:
for j in range(i + 1):
base_three_inverted[j] = 0
if i < len(base_three_inverted) - 1:
base_three_inverted[i + 1] += 1
else:
base_three_inverted.append(1)
acc = 0
for i in range(len(base_three_inverted)):
digit = base_three_inverted[i]
acc += digit * (3 ** i)
return acc
def test():
assert good_numbers(1) == 1
assert good_numbers(2) == 3
assert good_numbers(6) == 9
assert good_numbers(13) == 13
assert good_numbers(14) == 27
assert good_numbers(3620) == 6561
assert good_numbers(10000) == 19683
if __name__ == '__main__':
q = int(input())
for _ in range(q):
n = int(input())
print(good_numbers(n))
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long arr[5000];
bool num[1000006];
void sieve() {
int sz = sqrt(1000000);
for (int i = 2; i <= sz; i++) {
if (!num[i]) {
for (int j = i * i; j < 1000001; j += i) num[j] = true;
}
}
}
int main() {
sieve();
int t;
int n;
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
if (n == 1) {
if (!num[arr[0]])
cout << arr[0] * arr[0] << endl;
else
cout << -1 << endl;
continue;
}
long long ans = arr[0] * arr[n - 1];
for (int i = 1, j = n - 2; i <= j; i++, j--) {
if (arr[i] * arr[j] != ans) ans = -1;
}
int cnt = 0;
for (int i = 2; i <= sqrt(ans); i++) {
if (ans % i == 0) {
cnt++;
if ((ans / i) != i) cnt++;
}
}
if (cnt != n) ans = -1;
cout << ans << endl;
}
}
| 10 | CPP |
t=int(input())
for i in range(t):
n,k=map(int,input().split())
a=(k-1)//(n-1)
print(k+a) | 9 | PYTHON3 |
a = input()
s = 0
r=0
for i in a:
if i == "S":
s+=1
if i == "T" and s > 0:
s-=1
r+=1
print(len(a)-2*r) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using db = double;
using vi = vector<int>;
const int inf = 0x3f3f3f3f;
const db eps = 1e-8;
const int mod = 1e9 + 7;
ll qpow(ll a, ll b) {
ll ret = 1;
while (b) {
if (b & 1) ret = ret * a % mod;
a = a * a % mod;
b >>= 1;
}
return ret;
}
const int maxn = 1e4 + 100;
int vis[maxn];
set<int> st;
int main() {
int n;
cin >> n;
int cnt = n;
for (int i = 1; i <= n; i++) st.insert(i);
while (cnt != 1) {
int tmp1, tmp2;
if (st.size() == 1) break;
auto i = st.begin();
auto j = i;
j++;
cout << "? " << *i << " " << *j << endl;
cout.flush();
cin >> tmp1;
cout << "? " << *j << " " << *i << endl;
cout.flush();
cin >> tmp2;
if (tmp1 > tmp2) {
vis[*i] = tmp1;
st.erase(*i);
} else {
vis[*j] = tmp2;
st.erase(*j);
}
cnt--;
}
cout << "! ";
cout.flush();
for (int i = 1; i <= n; i++) {
if (vis[i] == 0) {
cout << n;
cout.flush();
} else {
cout << vis[i];
cout.flush();
}
if (i != n) {
cout << " ";
cout.flush();
}
}
cout.flush();
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e7 + 10;
const int md = 1e9 + 7;
const double EPS = 1e-15;
string a, b;
int q;
int l, r, ll, rr;
int cnt[N];
int cnta[N];
int cnt1[N];
int cnt1a[N];
int lastc[N];
int last1c[N];
int main() {
ios_base::sync_with_stdio(false);
cin >> a;
for (int i = 0; i < int(a.size()); i++) {
cnt[i + 1] = cnt[i];
if (a[i] != 'A') cnt[i + 1]++;
if (a[i] == 'A')
lastc[i + 1] = lastc[i] + 1;
else
lastc[i + 1] = 0;
}
cin >> b;
for (int i = 0; i < int(b.size()); i++) {
cnt1[i + 1] = cnt1[i];
if (b[i] != 'A') cnt1[i + 1]++;
if (b[i] == 'A')
last1c[i + 1] = last1c[i] + 1;
else
last1c[i + 1] = 0;
}
cin >> q;
for (int i = 1; i <= q; i++) {
cin >> l >> r >> ll >> rr;
int x = cnt[r] - cnt[l - 1];
int y = cnt1[rr] - cnt1[ll - 1];
int first = min(r - l + 1, lastc[r]);
int s = min(rr - ll + 1, last1c[rr]);
if (x % 2 == y % 2 && x <= y &&
(first > s || (first >= s && (x > 0 || x == y))) &&
(first % 3 == s % 3 || x < y))
cout << 1;
else
cout << 0;
}
return 0;
}
| 10 | CPP |
n, a, b = map(int, input().split())
s = input()
ab = a + b
cnt = 0
fcnt = 1
for i in range(n):
if s[i] == 'a' and ab > cnt:
cnt += 1
print('Yes')
elif s[i] == 'b' and (ab > cnt and b >= fcnt):
cnt += 1
fcnt += 1
print('Yes')
else:
print('No') | 0 | PYTHON3 |
#include <bits/stdc++.h>
char s[100];
int number;
int main() {
int i, j, n;
while (scanf("%d", &n) != EOF) {
scanf(" %s", s);
int cnt = 0;
for (i = 0; i < n; i++) {
if (s[i] == '1')
cnt++;
else {
printf("%d", cnt);
cnt = 0;
}
}
if (i == n) printf("%d\n", cnt);
}
}
| 7 | CPP |
n = int(input())
print(sum(range(n+1))) | 0 | PYTHON3 |
X, Y = map(int, input().split())
ans = 0
ans += max(0, 4 - X)
ans += max(0, 4 - Y)
if(X == 1 and Y == 1):
ans += 4
ans *= 100000
print(ans) | 0 | PYTHON3 |
#include <iostream>
#include <vector>
#include <map>
using namespace std;
const int MAX_N = 2e5 + 5, MOD = 1e9 + 7;
int length[MAX_N];
void precompute()
{
for(int i = 0; i <= 8; i++)
{
length[i] = 2;
}
length[9] = 3;
for(int i = 10; i < MAX_N; i++)
{
length[i] = (length[i - 9] + length[i - 10])%MOD;
}
}
void solve()
{
int n, no_of_operations;
cin >> n >> no_of_operations;
long long answer = 0;
while(n > 0)
{
int digit = n%10;
long long this_length = (no_of_operations < 10 - digit ? 1 : length[no_of_operations - (10 - digit)]);
//cout << "D = " << digit << " this = " << this_length << "\n";
n /= 10;
answer = (answer + this_length)%MOD;
}
cout << answer << "\n";
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
precompute();
int no_of_test_cases;
cin >> no_of_test_cases;
while(no_of_test_cases--)
solve();
return 0;
}
| 9 | CPP |
n = int(input())
*x, = map(int, input().split())
*y, = map(int, input().split())
abs_xy = [abs(i-j) for i,j in zip(x,y)]
print(sum(abs_xy))
print((sum(d**2 for d in abs_xy)) ** 0.5)
print((sum(d**3 for d in abs_xy)) ** (1/3))
print(max(abs_xy))
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
template <typename T>
void printV(T vec) {
for (int i = 0; i < (long long)vec.size(); i++)
cout << vec[i] << " " << flush;
cout << endl;
}
const int INF = 1e9 + 5;
unsigned long long gcd(unsigned long long a, unsigned long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
unsigned long long findlcm(unsigned long long arr[], unsigned long long n) {
long long ans = arr[0];
for (unsigned long long i = 1; i < n; i++)
ans = (((arr[i] * ans)) / (gcd(arr[i], ans)));
return ans;
}
int main() {
stringstream ss;
cout << setprecision(16);
ios::sync_with_stdio(0);
cin.tie(0);
long long testCase;
cin >> testCase;
for (long long tt = 0; tt < testCase; tt++) {
long long n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
bool truth = false;
if (((a - b) * n >= c - d and (a - b) * n <= c + d) or
((a + b) * n <= c + d and (a + b) * n >= c - d))
truth = true;
if ((((a - b) * n) <= c - d and (a + b) * n >= c - d) or
((a - b) * n <= c + d and (a + b) * n >= c + d))
truth = true;
if (((a - b) * n <= c - d and (a + b) * n >= c + d)) truth = true;
if (truth) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
| 7 | CPP |
#include<bits/stdc++.h>
using namespace std;
int main(){
int T;
cin>>T;
while(T--){
string s;
cin>>s;
int len = s.length();
int vis1=0;
int vis2=0;
for(int i=0;i<len-1;i++){
if(s[i]=='1'&&s[i+1]=='1'){
vis1=1;
}
if(vis1==1&&s[i]=='0'&&s[i+1]=='0'){
vis2=1;
}
}
if(vis2) cout<<"NO"<<endl;
else cout<<"YES"<<endl;
}
return 0;
} | 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
while (T--) {
int n, m;
cin >> n >> m;
int ans = min(2, n - 1) * m;
cout << ans;
cout << "\n";
}
return 0;
}
| 7 | CPP |
#include <iostream>
using namespace std;
int main()
{
long long q,h,s,d,n,ans=0;
scanf("%lld%lld%lld%lld%lld",&q,&h,&s,&d,&n);
ans=n/2*min(min(d,s*2),min(h*4,q*8)),n%=2;
if(n) ans+=min(q*4,min(h*2,s));
printf("%lld\n",ans);
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,n) for(int i = 0; i < (n); i++)
#define sz(c) ((int)c.size())
#define ten(n) ((int)1e##n)
using ll = long long;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
template<typename ...> static inline int getchar_unlocked(void) { return getchar(); }
template<typename ...> static inline void putchar_unlocked(int c) { putchar(c); }
#define mygc(c) (c)=getchar_unlocked()
#define mypc(c) putchar_unlocked(c)
void reader(int& x) { int k, m = 0; x = 0; for (;;) { mygc(k); if (k == '-') { m = 1; break; }if ('0' <= k&&k <= '9') { x = k - '0'; break; } }for (;;) { mygc(k); if (k<'0' || k>'9')break; x = x * 10 + k - '0'; }if (m) x = -x; }
void reader(ll& x) { int k, m = 0; x = 0; for (;;) { mygc(k); if (k == '-') { m = 1; break; }if ('0' <= k&&k <= '9') { x = k - '0'; break; } }for (;;) { mygc(k); if (k<'0' || k>'9')break; x = x * 10 + k - '0'; }if (m) x = -x; }
int reader(char c[]) { int i, s = 0; for (;;) { mygc(i); if (i != ' '&&i != '\n'&&i != '\r'&&i != '\t'&&i != EOF) break; }c[s++] = i; for (;;) { mygc(i); if (i == ' ' || i == '\n' || i == '\r' || i == '\t' || i == EOF) break; c[s++] = i; }c[s] = '\0'; return s; }
int reader(string& c) { int i; for (;;) { mygc(i); if (i != ' '&&i != '\n'&&i != '\r'&&i != '\t'&&i != EOF) break; }c.push_back(i); for (;;) { mygc(i); if (i == ' ' || i == '\n' || i == '\r' || i == '\t' || i == EOF) break; c.push_back(i); }; return sz(c); }
template <class T, class S> void reader(T& x, S& y) { reader(x); reader(y); }
template <class T, class S, class U> void reader(T& x, S& y, U& z) { reader(x); reader(y); reader(z); }
template <class T, class S, class U, class V> void reader(T& x, S& y, U& z, V & w) { reader(x); reader(y); reader(z); reader(w); }
void writer(int x, char c) { int s = 0, m = 0; char f[10]; if (x<0)m = 1, x = -x; while (x)f[s++] = x % 10, x /= 10; if (!s)f[s++] = 0; if (m)mypc('-'); while (s--)mypc(f[s] + '0'); mypc(c); }
void writer(ll x, char c) { int s = 0, m = 0; char f[20]; if (x<0)m = 1, x = -x; while (x)f[s++] = x % 10, x /= 10; if (!s)f[s++] = 0; if (m)mypc('-'); while (s--)mypc(f[s] + '0'); mypc(c); }
void writer(const char c[]) { int i; for (i = 0; c[i] != '\0'; i++)mypc(c[i]); }
void writer(const string& x, char c) { int i; for (i = 0; x[i] != '\0'; i++)mypc(x[i]); mypc(c); }
void writer(const char x[], char c) { int i; for (i = 0; x[i] != '\0'; i++)mypc(x[i]); mypc(c); }
template<class T> void writerLn(T x) { writer(x, '\n'); }
template<class T, class S> void writerLn(T x, S y) { writer(x, ' '); writer(y, '\n'); }
template<class T, class S, class U> void writerLn(T x, S y, U z) { writer(x, ' '); writer(y, ' '); writer(z, '\n'); }
template<class T> void writerArr(T x[], int n) { if (!n) { mypc('\n'); return; }FOR(i, n - 1)writer(x[i], ' '); writer(x[n - 1], '\n'); }
template<class T> void writerArr(vector<T>& x) { writerArr(x.data(), (int)x.size()); }
template<class T> void chmin(T& a, const T& b) { if (a > b) a = b; }
template<class T> void chmax(T& a, const T& b) { if (a < b) a = b; }
template<class T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template<class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
ll mod_pow(ll a, ll n, ll mod) {
ll ret = 1;
ll p = a % mod;
while (n) {
if (n & 1) ret = ret * p % mod;
p = p * p % mod;
n >>= 1;
}
return ret;
}
template<class T> T extgcd(T a, T b, T& x, T& y) { for (T u = y = 1, v = x = 0; a;) { T q = b / a; swap(x -= q * u, u); swap(y -= q * v, v); swap(b -= q * a, a); } return b; }
template<class T> T mod_inv(T a, T m) { T x, y; extgcd(a, m, x, y); return (m + x % m) % m; }
class UnionFind {
private:
int n;
vector<int> a;
public:
UnionFind(int n) : n(n), a(n, -1) {}
int find(int x) { return a[x] < 0 ? x : (a[x] = find(a[x])); }
bool same(int x, int y) { return find(x) == find(y); }
bool same(Pii& p) { return same(p.first, p.second); }
bool unite(int x, int y) {
x = find(x), y = find(y);
if (x == y) return false;
if (a[x] > a[y]) swap(x, y);
a[x] += a[y];
a[y] = x;
n--;
return true;
}
bool unite(Pii& p) { return unite(p.first, p.second); }
int size() const { return n; }
int size(int x) { return -a[find(x)]; }
};
int main() {
int n, m, k; reader(n, m, k);
vector<int> c(n); FOR(i, n) reader(c[i]);
vector<tuple<int, int, int>> vp;
FOR(i, m) {
int a, b, w; reader(a, b, w);
a--; b--;
vp.emplace_back(w, a, b);
}
UnionFind uf(n + k);
int free = 0;
FOR(i, n) {
c[i]--;
if (c[i] == -1) {
free++;
} else {
uf.unite(i, n + c[i]);
}
}
ll ans = 0;
sort(vp.begin(), vp.end());
for (auto& wab : vp) {
if (uf.size() <= free + 1) {
break;
}
int w, a, b; tie(w, a, b) = wab;
if (uf.unite(a, b)) {
ans += w;
}
}
if (uf.size() > free + 1) {
ans = -1;
}
writerLn(ans);
return 0;
}
| 0 | CPP |
N = int(input())
dp = [0] * (1 << N)
dp[0] = 1
MOD = 10 ** 9 + 7
now = {0}
for _ in range(N):
mat = [1<<i for i, v in enumerate(input().split()) if v == '1']
nxt = set()
for k in now:
p = dp[k] % MOD
for m in mat:
if k & m: # 1101 & 0100 3番目の人はすでにペアになっているためはじく
continue
dp[k | m] += p # 1001 | 0010 = 1011
nxt.add(k | m)
now = nxt
print(dp[-1] % MOD) #dp[11...11]が答えになる | 0 | PYTHON3 |
N, K = map(int,input().split())
li_h = list(map(int, input().split()))
print(sum(i>=K for i in li_h)) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3fffffff;
const int SINF = 0x7fffffff;
const long long LINF = 0x3fffffffffffffff;
const long long SLINF = 0x7fffffffffffffff;
const int MAXN = 100007;
const int MAXS = 400007;
const int MAXL = 31;
const int MOD = 998244353;
const int RT = 3;
struct eT {
void setd(int _u, int _v, int _l) { u = _u, v = _v, last = _l; }
int u, v, last;
} edge[MAXN * 2];
int n, K;
int ans;
int ke, la[MAXN];
int sz[MAXN];
int dp[MAXN], cv[MAXN];
int na[MAXN], tmp[MAXN * 2], cd[MAXN];
int frac[MAXN], rf[MAXN];
int ca[MAXS], cb[MAXS], cans[MAXS], rt[MAXS];
map<int, int> mp;
void init();
void input();
void work();
int dfs(int now, int fa);
int getval(int a[], int n, int x);
void polydiv(int a[], int n, int x, int ans[]);
void fft(int ar[], int tn);
void mul(int a[], int n, int b[], int m, int ans[]);
void muldivi(int a[], int l, int r, int ans[]);
int add(int x, int y) {
x += y;
if (x >= MOD) x -= MOD;
return x;
}
void addv(int &x, int y) {
x += y;
if (x >= MOD) x -= MOD;
}
int dec(int x, int y) {
x -= y;
if (x < 0) x += MOD;
return x;
}
void decv(int &x, int y) {
x -= y;
if (x < 0) x += MOD;
}
int qpow(int a, int b) {
long long base = a, ans = 1;
while (b) {
if (b & 1) (ans *= base) %= MOD;
(base *= base) %= MOD;
b >>= 1;
}
return static_cast<int>(ans);
}
int main() {
init();
input();
work();
}
void init() {
ios::sync_with_stdio(false);
frac[0] = 1;
for (int i = 1; i < MAXN; ++i)
frac[i] = frac[i - 1] * static_cast<long long>(i) % MOD;
rf[MAXN - 1] = qpow(frac[MAXN - 1], MOD - 2);
for (int i = MAXN - 2; i >= 0; --i)
rf[i] = rf[i + 1] * static_cast<long long>(i + 1) % MOD;
}
void input() {
scanf("%d%d", &n, &K);
int u, v;
memset(la, -1, sizeof(la));
for (int i = 1; i < n; ++i) {
scanf("%d%d", &u, &v);
edge[ke].setd(u, v, la[u]);
la[u] = ke++;
edge[ke].setd(v, u, la[v]);
la[v] = ke++;
}
}
void work() {
if (K == 1) {
printf("%d\n", (static_cast<long long>(n) * (n - 1) >> 1) % MOD);
return;
}
dfs(1, -1);
cout << ans << endl;
}
int dfs(int now, int fa) {
sz[now] = 1;
for (int i = la[now]; ~i; i = edge[i].last)
if (edge[i].v ^ fa) sz[now] += dfs(edge[i].v, now);
int pv = 0;
for (int i = la[now]; ~i; i = edge[i].last) {
if (edge[i].v ^ fa) {
addv(ans, static_cast<long long>(pv) * dp[edge[i].v] % MOD);
addv(pv, dp[edge[i].v]);
}
}
dp[now] = pv;
int nd = 0;
for (int i = la[now]; ~i; i = edge[i].last)
if (edge[i].v ^ fa) na[++nd] = sz[edge[i].v];
na[++nd] = n - sz[now];
muldivi(na, 1, nd, tmp);
for (int i = 0; i <= nd; ++i) na[i] = tmp[i];
mp.clear();
for (int i = la[now]; ~i; i = edge[i].last) {
if (edge[i].v ^ fa) {
addv(ans, static_cast<long long>(dp[edge[i].v]) *
getval(na, nd, sz[edge[i].v]) % MOD);
}
}
addv(dp[now], getval(na, nd, n - sz[now]));
return sz[now];
}
int getval(int a[], int n, int x) {
map<int, int>::iterator it;
if ((it = mp.find(x)) != mp.end())
return it->second;
else {
polydiv(a, n, x, cd);
int ub = (((n - 1) < (K)) ? (n - 1) : (K)), ans = 0;
for (int i = 0; i <= ub; ++i)
addv(ans, static_cast<long long>(cd[i]) * rf[K - i] % MOD);
ans = static_cast<long long>(ans) * frac[K] % MOD;
mp[x] = ans;
return ans;
}
}
void polydiv(int a[], int n, int x, int ans[]) {
for (int i = 0; i <= n; ++i) ans[i] = a[i];
for (int i = 0; i < n; ++i)
decv(ans[i + 1], static_cast<long long>(ans[i]) * x % MOD);
}
void fft(int ar[], int tn) {
for (int i = 0, j = 0; i < tn; ++i) {
if (i > j) swap(ar[i], ar[j]);
for (int bt = tn >> 1; bt && (!((j ^= bt) & bt)); bt >>= 1)
;
}
int m, x, y;
for (int i = 2; i <= tn; i <<= 1) {
m = i >> 1;
for (int j = 0; j < tn; j += i) {
for (int k = 0; k < m; ++k) {
x = ar[j + k],
y = static_cast<long long>(ar[j + k + m]) * rt[tn / i * k] % MOD;
ar[j + k] = add(x, y);
ar[j + k + m] = dec(x, y);
}
}
}
}
void mul(int a[], int n, int b[], int m, int ans[]) {
int nm = n + m;
int tn = 1;
while (tn <= nm) tn <<= 1;
for (int i = 0; i <= n; ++i) ca[i] = a[i];
for (int i = n + 1; i < tn; ++i) ca[i] = 0;
for (int i = 0; i <= m; ++i) cb[i] = b[i];
for (int i = m + 1; i < tn; ++i) cb[i] = 0;
int nrt = qpow(RT, (MOD - 1) / tn);
rt[0] = 1;
for (int i = 1; i < tn; ++i)
rt[i] = static_cast<long long>(rt[i - 1]) * nrt % MOD;
fft(ca, tn);
fft(cb, tn);
for (int i = 0; i < tn; ++i)
cans[i] = static_cast<long long>(ca[i]) * cb[i] % MOD;
reverse(rt + 1, rt + tn);
fft(cans, tn);
int rn = qpow(tn, MOD - 2);
for (int i = 0; i <= nm; ++i)
ans[i] = static_cast<long long>(cans[i]) * rn % MOD;
}
void muldivi(int a[], int l, int r, int ans[]) {
if (l == r) {
ans[0] = 1;
ans[1] = a[l];
return;
}
int mid = (l + r) >> 1;
muldivi(a, l, mid, ans);
muldivi(a, mid + 1, r, ans + ((mid - l + 1) << 1));
mul(ans, mid - l + 1, ans + ((mid - l + 1) << 1), r - mid, ans);
}
| 14 | CPP |
#include <bits/stdc++.h>
using namespace std;
char mp[5500][5500];
int sum[5500][5500];
const int INF = 0x3f3f3f3f;
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%s", mp[i] + 1);
for (int i = 1; i <= n; ++i) {
int tot = 0;
for (int j = 1; j <= m; ++j) {
if (mp[i][j] == '1') ++tot;
sum[i][j] = tot;
}
}
int mm = max(n, m), ans = INF;
for (int k = mm; k > 1; --k) {
bool fi = true;
int i, j, tj = k, ti = k, t0 = 0, t1 = 0, tans = 0;
for (i = 1; i <= ti; ++i) {
if (i > n || tj > m) {
if (i > n) fi = false;
if (i > n)
t0 += k;
else {
t1 += sum[i][m] - sum[i][tj - k];
t0 += k - (sum[i][m] - sum[i][tj - k]);
}
} else {
if (i == n) fi = false;
t1 += sum[i][tj] - sum[i][tj - k];
t0 += k - (sum[i][tj] - sum[i][tj - k]);
}
if (i == ti) {
tans += min(t0, t1);
t0 = 0, t1 = 0;
}
if (i == ti && tj < m) {
tj += k;
i = ti - k;
} else if (i == ti && fi && tj >= m) {
ti += k;
tj = k;
}
}
ans = min(ans, tans);
}
printf("%d\n", ans);
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main(){
int a,b,x;
cin>>a>>b;
x=(a+b)/2;
if((a+b)%2==0){cout<<x;}
else{cout<<"IMPOSSIBLE";}
return 0;
} | 0 | CPP |
d = int(input())%10
if d==3:
print("bon")
elif d in [0,1,6,8]:
print("pon")
else:
print("hon") | 0 | PYTHON3 |
# -*- coding: utf-8 -*-
"""
Created on Sun Sep 8 13:42:27 2019
@author: avina
"""
from collections import defaultdict
n = int(input())
l = list(map(int, input().split()))
d = defaultdict(list)
for i in range(n):
d[l[i]].append(i+1)
k = 0
for i in d:
if len(d[i]) == 1 and d[i][0] == i:
k+=1
s = len(set(l))
print((k+s)//2) | 9 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin >> s;
long k;
cin >> k;
int i = 0;
int n = s.length();
while(k>0 && i<n){
int tmp = (26-(int)(s[i]-'a'))%26;
if(tmp<=k){
k-=tmp;
s[i] = 'a';
}
i++;
}
if(k>0)s[n-1]=(char)((int)(s[n-1])+k%26);
cout << s << endl;
}
| 0 | CPP |
l=[]
n=int(input())
for i in range(n):
l.append([])
l[i]=list(map(int,input().split()))
v=0
for i in range(n):
for j in range(n):
if l[i][0]==l[j][1]:
v=v+1
print(v)
| 7 | PYTHON3 |
from collections import deque
n, k = map(int, input().split())
s = input()
queue = deque([s])
visited = set()
cost = 0
num_of_words = 1
while queue and num_of_words < k:
new = queue.popleft()
for i in range(len(new)):
neigh = new[0:i] + new[i + 1:]
if neigh not in visited :
cost += n - len(new) + 1
num_of_words += 1
visited.add(neigh)
queue.append(neigh)
if num_of_words >= k:
break
#print(queue)
if num_of_words < k:
print(-1)
else:
print(cost) | 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100005];
long long z[100005];
long long ans[100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n, greater<int>());
for (int i = 0; i < n; i++) z[i + 1] = z[i] + a[i];
for (int k = 1; k <= 100000; k++) {
long long sz = 1, cost = 0;
long long reach = 0, step = 0;
while (reach < n) {
long long f = z[min<long long>(n, reach + sz)] - z[reach];
cost += step * f;
step++;
reach += sz;
sz *= k;
}
ans[k] = cost;
}
int q;
cin >> q;
while (q--) {
int x;
cin >> x;
cout << ans[x] << ' ';
}
cout << '\n';
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long INF = 1e18;
long long MOD = 1e9 + 7;
long long solve() {
int n;
cin >> n;
set<long long> buy, sell, unknown;
long long ans = 1;
for (int i = 0; i < n; i++) {
string s;
long long a;
cin >> s >> a;
if (s == "ADD") {
if (sell.count(a)) return 0;
if (buy.count(a)) return 0;
if (unknown.count(a)) return 0;
if (buy.size() > 0 && (*buy.rbegin()) >= a) {
buy.insert(a);
} else if (sell.size() > 0 && (*sell.begin()) <= a) {
sell.insert(a);
} else {
unknown.insert(a);
}
} else {
if (!(sell.count(a) || buy.count(a) || unknown.count(a))) return 0;
if (buy.size() > 0 && (*buy.rbegin()) > a) {
return 0;
} else if (sell.size() > 0 && (*sell.begin()) < a) {
return 0;
}
if (buy.size() > 0 && (*buy.rbegin()) == a) {
buy.erase(buy.find(a));
} else if (sell.size() > 0 && (*sell.begin()) == a) {
sell.erase(sell.find(a));
} else {
ans = (ans * 2) % MOD;
unknown.erase(unknown.find(a));
}
for (auto x : unknown)
if (x < a)
buy.insert(x);
else
sell.insert(x);
unknown.clear();
}
}
ans = (ans * (1 + (long long)unknown.size())) % MOD;
return ans;
}
int main() {
cout << solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
inline int pow_(long long a, int n, int p = mod) {
int r = 1;
while (n) {
if (n & 1) r = r * a % p;
n >>= 1;
a = a * a % p;
}
return r;
}
inline int inv_(int a) { return pow_(a, mod - 2, mod); }
inline int add(int a, int b) {
a += b;
if (a >= mod) a -= mod;
return a;
}
inline void adds(int& a, int b) {
a += b;
if (a >= mod) a -= mod;
}
inline int mul(int a, int b) { return a * 1ll * b % mod; }
inline void muls(int& a, int b) { a = a * 1ll * b % mod; }
inline int sub(int a, int b) {
a -= b;
if (a < 0) a += mod;
return a;
}
inline int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int p[] = {
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37,
41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89,
97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151,
157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223,
227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281,
283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359,
367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433,
439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503,
509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593,
599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659,
661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743,
751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827,
829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911,
919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997,
1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069,
1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163,
1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249,
1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321,
1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439,
1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511,
1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601,
1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693,
1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783,
1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877,
1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987,
1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069,
2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 2141, 2143,
2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267,
2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347,
2351, 2357, 2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423,
2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543,
2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633, 2647, 2657,
2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693, 2699, 2707, 2711, 2713,
2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801,
2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903,
2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, 3001, 3011,
3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079, 3083, 3089, 3109, 3119,
3121, 3137, 3163, 3167, 3169, 3181, 3187, 3191, 3203, 3209, 3217, 3221,
3229, 3251, 3253, 3257, 3259, 3271, 3299, 3301, 3307, 3313, 3319, 3323,
3329, 3331, 3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391, 3407, 3413,
3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, 3517, 3527,
3529, 3533, 3539, 3541, 3547, 3557, 3559, 3571, 3581, 3583, 3593, 3607,
3613, 3617, 3623, 3631, 3637, 3643, 3659, 3671, 3673, 3677, 3691, 3697,
3701, 3709, 3719, 3727, 3733, 3739, 3761, 3767, 3769, 3779, 3793, 3797,
3803, 3821, 3823, 3833, 3847, 3851, 3853, 3863, 3877};
int cnt[15000001];
int main() {
int n;
cin >> n;
vector<int> v(n);
int g = 0;
for (int i = 0; i < (n); ++i) {
scanf("%d", &v[i]);
g = gcd(g, v[i]);
}
for (int i = 0; i < (n); ++i) {
v[i] /= g;
for (int j = 0; p[j] * p[j] <= v[i]; ++j)
if (v[i] % p[j] == 0) {
cnt[p[j]] += 1;
while (v[i] % p[j] == 0) v[i] /= p[j];
}
if (v[i] > 1) cnt[v[i]] += 1;
}
int mx = max_element(cnt + 2, cnt + 15000001) - cnt;
if (cnt[mx] == 0)
puts("-1");
else
printf("%d\n", n - cnt[mx]);
return 0;
}
| 7 | CPP |
n,sx,sy = map(int,input().split())
d = {}
count = 0
for i in range(n) :
fx,fy = map(int,input().split())
up = fy - sy
down = fx - sx
if down == 0 :
if 10000 not in d.keys() :
d[10000] = 1
count +=1
else :
t = up/down
if t not in d.keys() :
d[t] = 1
count +=1
print(count) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, x, y, sum, cnt, ans, a[1000];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
x = max(x, a[i]);
}
cout << (x ^ a[n - 1]) << endl;
return 0;
}
| 9 | CPP |
def solve(i, j, k):
if (i < 0 and j < 0) or (j < 0 and k < 0) or (i < 0 and k < 0):
return 0
if dp[i][j][k] != -1:
return dp[i][j][k]
ans = 0
if i >= 0 and j >= 0:
ans = max(ans, rs[i] * gs[j] + solve(i - 1, j - 1, k))
if i >= 0 and k >= 0:
ans = max(ans, rs[i] * bs[k] + solve(i - 1, j, k - 1))
if j >= 0 and k >= 0:
ans = max(ans, bs[k] * gs[j] + solve(i, j - 1, k - 1))
dp[i][j][k] = ans
return ans
a, b, c = map(int, input().split())
rs = sorted(list(map(int, input().split())))
gs = sorted(list(map(int, input().split())))
bs = sorted(list(map(int, input().split())))
dp = [[[-1 for x in range(c + 1)] for y in range(b + 1)] for z in range(a + 1)]
print(solve(a - 1, b - 1, c - 1))
| 10 | PYTHON3 |
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().strip().split()))
left = [0 for _ in range(len(a))]
right = [0 for _ in range(len(a))]
for i in range(len(a)):
if a[i] >= i:
left[i] = 1
else:
break
for i in range(len(a) - 1, -1, -1):
if a[i] >= len(a) - i - 1:
right[i] = 1
else:
break
good = False
for i in range(len(a)):
if left[i] == right[i] and left[i] == 1:
print("Yes")
good = True
break
if not good:
print("No") | 8 | PYTHON3 |
#include <bits/stdc++.h>
int main() {
int n, i, sum1, sum2, sum3;
scanf("%d", &n);
sum1 = 0;
for (i = 0; i < n; i++) {
int a;
scanf("%d", &a);
sum1 ^= a;
}
sum2 = 0;
for (i = 0; i < n - 1; i++) {
int b;
scanf("%d", &b);
sum2 ^= b;
}
sum3 = 0;
for (i = 0; i < n - 2; i++) {
int c;
scanf("%d", &c);
sum3 ^= c;
}
printf("%d\n%d\n", sum1 ^ sum2, sum2 ^ sum3);
return 0;
}
| 8 | CPP |
n=int(input())
arr=list(map(int,input().split()))
arr2=arr.copy()
arr.sort()
arr.reverse()
count=0
c=[]
for i in range(n):
count=i*arr[i]+1+count
print(count)
for i in arr:
c.append(arr2.index(i))
arr2[arr2.index(i)]=0
for i in range(n):
print(c[i]+1,end=' ') | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long GCD(long long x, long long y) {
if (y == 0) return x;
return GCD(y, x % y);
}
long long LCM(long long x, long long y) { return (x * y) / (GCD(x, y)); }
long long LOGK(long long x, long long k) {
if (x >= k) return 1 + LOGK(x / k, k);
return 0;
}
long long MPOW(long long a, long long b, long long m) {
if (b == 0) return 1;
long long x = MPOW(a, b / 2, m);
x = (x * x) % m;
if (b % 2 == 1) x = (x * a) % m;
return x;
}
long long MINV(long long a, long long m) { return MPOW(a, m - 2, m); }
class pnc {
long long FACT_MAX, MODU;
vector<long long> fact;
public:
pnc(long long n, long long m) {
FACT_MAX = n;
fact.resize(FACT_MAX);
MODU = m;
MFACT_INIT(MODU);
}
void MFACT_INIT(long long m) {
fact[0] = 1;
for (long long i = 1; i < FACT_MAX; ++i) fact[i] = (i * fact[i - 1]) % MODU;
}
long long MFACT(long long n) { return fact[n]; }
long long PERM(long long n, long long r) {
return (fact[n] * ::MINV(fact[n - r], MODU)) % MODU;
}
long long COMB(long long n, long long r) {
return (PERM(n, r) * ::MINV(fact[r], MODU)) % MODU;
}
};
long long m, n, k, t;
vector<long long> l, r, d;
vector<long long> soldiers;
long long can(long long x) {
long long mn = soldiers[x];
vector<pair<long long, long long> > seg;
for (long long i = 0; i < k; i++) {
if (d[i] > mn) {
seg.push_back({l[i], r[i]});
}
}
sort(seg.begin(), seg.end());
long long reqtime = 0;
long long curr = 0;
if (seg.size() == 0) {
reqtime = n + 1;
} else {
for (auto i : seg) {
if (curr < i.first) {
reqtime += 2 * (i.second - i.first);
reqtime += 2;
curr = i.second;
} else {
if (curr < i.second) {
reqtime += 2 * (i.second - curr);
curr = i.second;
}
}
}
reqtime += n + 1;
}
return (reqtime <= t);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long test = 1;
while (test--) {
cin >> m >> n >> k >> t;
for (long long i = 0; i < m; i++) {
long long z;
cin >> z;
soldiers.push_back(z);
}
l.resize(k);
r.resize(k);
d.resize(k);
sort(soldiers.begin(), soldiers.end());
for (long long i = 0; i < k; i++) {
cin >> l[i] >> r[i] >> d[i];
}
long long left = 0, right = m;
while (left < right) {
long long mid = (left + right) / 2;
if (can(mid))
right = mid;
else
left = mid + 1;
}
cout << m - left;
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n;
vector<pair<int, long long>> v;
for (int i = 0; i < n; ++i) {
cin >> m;
int a, max = 0;
for (int j = 0; j < m; ++j) {
cin >> a;
if (max < a) {
max = a;
}
}
v.push_back(make_pair(max, m));
}
long long k = 0;
sort(v.begin(), v.end());
for (int i = 0; i < n - 1; ++i) {
k += (v[i + 1].first - v[i].first) * v[i].second;
v[i + 1].second += v[i].second;
}
cout << k;
return 0;
}
| 7 | CPP |
w,l = map(int, input().split())
print(w*l//2)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a;
while (cin >> n >> m >> a) {
long long row, column;
row = n / a + (n % a == 0 ? 0 : 1);
column = m / a + (m % a == 0 ? 0 : 1);
cout << row * column << endl;
}
return 0;
}
| 7 | CPP |
n = int(input())
x = [int(i) for i in input().split()]
t = [0] * 3
k = 0
for i in range(n):
for j in range(3):
if x[i] == (j + 1):
t[j] += 1
print(min(min(t[1], t[0]), t[2]))
i2 = 0
j = 0
z = [[0] * 3 for i in range(min(min(t[1], t[0]), t[2]))]
for j in range(3):
while k < min(min(t[1], t[0]), t[2]):
if x[i2] == (j + 1):
z[k][j] = i2
k += 1
i2 += 1
i2 = 0
k = 0
for i in range(min(min(t[1], t[0]), t[2])):
print(z[i][0] + 1, z[i][1] + 1, z[i][2] + 1) | 7 | PYTHON3 |
#include<iostream>
#include<queue>
#include<stack>
#include<algorithm>
#include<vector>
#include<cmath>
#include<deque>
#include<memory.h>
#include<set>
#include<map>
#include<unordered_map>
#include<unordered_set>
#include<cstdio>
#include<cstring>
#include<string.h>
#include<algorithm>
#include<string>
#include<fstream>
#include<math.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define Design ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
#define db double
#define fi first
#define sc second
#define pii pair<int,int>
#define pll pair<ll,ll>
#define pb push_back
#define vi vector<int>
#define vl vector<ll>
#define minf 0x3f3f3f3f3f3f3f3f
ll GCD(ll a, ll b) { return b ? GCD(b, a % b) : a; }
ll LCM(ll a, ll b) { return a * b / GCD(a, b); }
ll lb(ll x) { return x & (-x); }
const ll N = 2e5 + 7;
const ll inf = 1e18 + 1;
const ll mod2 = 998244353;
const ll mod1 = 1e9 + 7;
const int P1 = 13331;
const int P2 = 131;
const double eps = 1e-6;
const db dbinf = 1e13 + 7;
const ll mod3 = 1e6 + 3;
const db pi=acos(-1);
int t,n;
ll a[N];
int main() {
cin>>t;
while(t--){
cin>>n;
for(int i=1;i<=n*2;i++)a[i]=-inf;
int x;
for(int i=1;i<=n;i++)cin>>x,a[x]=i;
ll ans=0;
for(int v=3;v<=2*n;v++){
for(int q=1;q*q<=v;q++){
if(v%q>=1)continue;
int w=v/q;
if(w==q)continue;
if(a[q]+a[w]==v){
ans++;
//cout<<v<<" "<<q<<" "<<w<<"\n";
}
}
}
cout<<ans<<"\n";
}
return 0;
} | 8 | CPP |
def main():
x = int(input())
if x % 2 == 1 or x == 2:
print("NO")
else:
print("YES")
if __name__ == '__main__':
main() | 7 | PYTHON3 |
# cook your dish here
t = int(input())
for i in range(t):
x = str(input())
x = x.rstrip('0')
x = x.lstrip('0')
if (x.count('1') == 0):
print(0)
else:
print (x.count('0')) | 7 | PYTHON3 |
L = input().split()
n = int(L[0])
k = int(L[1])
height = input().split()
for i in range(n):
height[i] = int(height[i])
# end of input
m = sum(height[i] for i in range(k))
s = m
i = 0
j = i
while i < n - k and m != k:
s = s - height[i] + height[i + k]
i += 1
if m > s:
m = s
j = i
print(j + 1)
| 8 | PYTHON3 |
a=int(input())
S=0
for i in range(a):
b,c=map(int,input().split())
S+=max(((c-b)>1,0))
print(S)
| 7 | PYTHON3 |
for t in range(int(input())):
n, k = map(int, input().split())
print(0 if k%n==0 else 2)
a = [[0]*n for i in range(n)]
c, r = 0, n-1;
while k > 0:
i, j = 0, c;
while k > 0 and j < n:
a[i][j] = 1
i, j, k = i+1, j+1, k-1
c = c + 1
i, j = r, 0;
while k > 0 and i < n:
a[i][j] = 1
i, j, k = i+1, j+1, k-1
r -= 1
# print(val)
for i in a:
print(''.join(str(x) for x in i)) | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MXN = 2e5 + 5;
int n, m, k;
set<pair<long long, int>> t[MXN];
set<int> where_taxi;
set<pair<long long, pair<int, int>>> event_free;
long long acttime = 0;
void add(pair<long long, pair<int, int>> x) {
int where = x.second.first;
int who = x.second.second;
long long time = x.first;
acttime = max(acttime, time);
where_taxi.insert(where);
t[where].insert(make_pair(time, who));
}
void go(int where, long long time, int a, int b) {
int taxi = t[where].begin()->second;
t[where].erase(t[where].begin());
if (t[where].size() == 0) where_taxi.erase(where);
printf("%d %lld\n", taxi, max((where - a), -(where - a)) + acttime - time);
event_free.insert(make_pair(
acttime + max((where - a), -(where - a)) + max((a - b), -(a - b)),
make_pair(b, taxi)));
}
int main() {
scanf("%d%d%d", &n, &k, &m);
for (int i = 1; i <= (k); i++) {
int a;
a = rand() % n + 1;
scanf("%d", &a);
event_free.insert(make_pair(0, make_pair(a, i)));
}
for (int i = 0; i < (m); i++) {
long long tt;
int a, b;
tt = 100000000LL * i + 3;
a = rand() % n + 1;
b = rand() % n + 1;
scanf("%lld%d%d", &tt, &a, &b);
acttime = max(acttime, tt);
while (event_free.size() &&
(event_free.begin()->first <= acttime || where_taxi.size() == 0)) {
add(*event_free.begin());
event_free.erase(event_free.begin());
}
if (where_taxi.size() == 1) {
go(*where_taxi.begin(), tt, a, b);
} else {
auto x = where_taxi.upper_bound(a);
if (x == where_taxi.end()) x--;
if (x == where_taxi.begin()) {
go(*x, tt, a, b);
continue;
}
auto x2 = x;
x2--;
int p = *x;
int l = *x2;
if ((max((a - l), -(a - l)) < max((a - p), -(a - p))) ||
((max((a - l), -(a - l)) == max((a - p), -(a - p)) &&
(*(t[l].begin()) < *(t[p].begin())))))
go(l, tt, a, b);
else
go(p, tt, a, b);
}
}
}
| 19 | CPP |
n = int(input())
a = list(map(int, input().split()))
ret, s = 0, sum(a)
if s % 3 == 0:
p1 = s // 3
p2 = s - p1
s = c = 0
for i in range(n - 1):
s += a[i]
if s == p2:
ret += c
if s == p1:
c += 1
print(ret)
| 9 | PYTHON3 |
#include<iostream>
#include<algorithm>
#include<vector>
#include<set>
#include<cstdio>
#include<map>
using namespace std;
map<string,int>a;
int main()
{
int n,choose,temp,l,r;
string color;
scanf("%d", &n);
while (n--)
{
scanf("%d ", &choose);
switch (choose)
{
case 0:
cin >> color >> temp;
//scanf("%s%d", color, &temp);
a[color] = temp;
break;
case 1:
cin >> color;
if (a.find(color) != a.end())printf("%d\n", a[color]);
else printf("0\n");
break;
case 2:
cin >> color;
a.erase(color);
break;
case 3:
string p, q;
cin >> p >> q;
map<string, int>::iterator begin, end;
begin = a.lower_bound(p);
end = a.upper_bound(q);
for (; begin != end; begin++)
{
cout << (*begin).first <<" "<<(*begin).second<< endl;
}
}
}
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500005;
int n;
long long Read() {
long long x = 0, f = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x * 10) + (c ^ 48);
c = getchar();
}
return x * f;
}
template <typename T>
void Put1(T x) {
if (x > 9) Put1(x / 10);
putchar(x % 10 ^ 48);
}
template <typename T>
void Put(T x, char c = -1) {
if (x < 0) putchar('-'), x = -x;
Put1(x);
if (c >= 0) putchar(c);
}
template <typename T>
T Max(T x, T y) {
return x > y ? x : y;
}
template <typename T>
T Min(T x, T y) {
return x < y ? x : y;
}
template <typename T>
T Abs(T x) {
return x < 0 ? -x : x;
}
int head[2][MAXN], tot[2];
struct edge {
int v, nxt;
} e[2][MAXN << 1];
void Add_Edge(int opt, int x, int y) {
e[opt][++tot[opt]].v = y;
e[opt][tot[opt]].nxt = head[opt][x];
head[opt][x] = tot[opt];
}
void Add_Double_Edge(int opt, int x, int y) {
Add_Edge(opt, x, y);
Add_Edge(opt, y, x);
}
int f[2][MAXN], Fa[MAXN];
int findSet(int x) {
if (Fa[x] != x) Fa[x] = findSet(Fa[x]);
return Fa[x];
}
void dfs(int opt, int x, int fa) {
for (int i = head[opt][x]; i; i = e[opt][i].nxt) {
int v = e[opt][i].v;
if (v == fa) continue;
f[opt][v] = x;
dfs(opt, v, x);
}
}
int anstot;
struct Answer {
int u1, v1, u2, v2;
Answer() {}
Answer(int u11, int v11, int u21, int v21) {
u1 = u11;
v1 = v11;
u2 = u21;
v2 = v21;
}
} ans[MAXN];
void solve(int x) {
for (int i = head[0][x]; i; i = e[0][i].nxt) {
int v = e[0][i].v;
if (v == f[0][x]) continue;
solve(v);
if (f[1][v] != x && f[1][x] != v)
ans[++anstot] = Answer(x, v, findSet(v), f[1][findSet(v)]);
}
}
int main() {
n = Read();
for (int i = 1; i < n; ++i) Add_Double_Edge(0, Read(), Read());
for (int i = 1; i < n; ++i) Add_Double_Edge(1, Read(), Read());
dfs(0, 1, 0);
dfs(1, 1, 0);
for (int i = 2; i <= n; ++i) {
if (f[1][i] == f[0][i] || i == f[0][f[1][i]])
Fa[i] = f[1][i];
else
Fa[i] = i;
}
solve(1);
Put(anstot, '\n');
for (int i = 1; i <= anstot; ++i)
Put(ans[i].u1, ' '), Put(ans[i].v1, ' '), Put(ans[i].u2, ' '),
Put(ans[i].v2, '\n');
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
struct Widget {
std::string name;
long long width, height;
Widget(const std::string& name, long long width, long long height)
: name(name), width(width), height(height) {}
~Widget() {}
virtual void calculateSize() {}
};
struct Box : public Widget {
int spacing, border;
std::vector<Widget*> children;
Box(const std::string& name) : Widget(name, 0, 0), spacing(0), border(0) {}
};
struct HBox : public Box {
HBox(const std::string& name) : Box(name) {}
virtual void calculateSize() {
if (children.empty()) {
width = 0;
height = 0;
return;
}
if (width == 0 && height == 0) {
for (std::vector<Widget*>::iterator i = children.begin();
i != children.end(); ++i) {
(*i)->calculateSize();
width += (*i)->width;
height = std::max(height, (*i)->height);
}
width += (children.size() - 1) * spacing + 2 * border;
height += 2 * border;
}
}
};
struct VBox : public Box {
VBox(const std::string& name) : Box(name) {}
virtual void calculateSize() {
if (children.empty()) {
width = 0;
height = 0;
return;
}
if (width == 0 && height == 0) {
for (std::vector<Widget*>::iterator i = children.begin();
i != children.end(); ++i) {
(*i)->calculateSize();
width = std::max(width, (*i)->width);
height += (*i)->height;
}
height += (children.size() - 1) * spacing + 2 * border;
width += 2 * border;
}
}
};
int main() {
int n;
std::cin >> n;
std::map<std::string, Widget*> map;
for (int i = 0; i < n; ++i) {
std::string s;
std::cin >> s;
if (s == "Widget") {
std::cin >> s;
std::string::size_type lparen = s.find("(");
std::string name = s.substr(0, lparen);
std::string::size_type comma = s.find(",", lparen + 1);
std::string::size_type rparen = s.find(")", comma + 1);
int width =
strtol(s.substr(lparen + 1, comma - lparen - 1).c_str(), 0, 10);
int height =
strtol(s.substr(comma + 1, rparen - comma - 1).c_str(), 0, 10);
map[name] = new Widget(name, width, height);
} else if (s == "VBox") {
std::cin >> s;
map[s] = new VBox(s);
} else if (s == "HBox") {
std::cin >> s;
map[s] = new HBox(s);
} else {
std::string::size_type dot = s.find(".");
std::string::size_type lparen = s.find("(", dot + 1);
std::string::size_type rparen = s.find(")", lparen + 1);
std::string name = s.substr(0, dot);
std::string method = s.substr(dot + 1, lparen - dot - 1);
if (method == "pack") {
std::string child = s.substr(lparen + 1, rparen - lparen - 1);
static_cast<Box*>(map[name])->children.push_back(map[child]);
} else if (method == "set_border") {
int border =
strtol(s.substr(lparen + 1, rparen - lparen - 1).c_str(), 0, 10);
static_cast<Box*>(map[name])->border = border;
} else if (method == "set_spacing") {
int spacing =
strtol(s.substr(lparen + 1, rparen - lparen - 1).c_str(), 0, 10);
static_cast<Box*>(map[name])->spacing = spacing;
}
}
}
for (std::map<std::string, Widget*>::iterator i = map.begin(); i != map.end();
++i) {
Widget* widget = (*i).second;
widget->calculateSize();
std::cout << widget->name << " " << widget->width << " " << widget->height
<< std::endl;
}
}
| 10 | CPP |
def solve():
return sum([1 if x <= h else 2 for x in a])
n, h = map(int, input().strip().split())
a = list(map(int, input().strip().split()))
print(solve()) | 7 | PYTHON3 |
import math
a,b=map(str,input().split())
if a==b:
print(math.gcd(int(a),int(b)))
else:
print(1) | 7 | PYTHON3 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = numeric_limits<int>::max();
struct edge {
int from, to, cost;
};
struct Graph {
vector<edge> es;
vector<int> d;
Graph(int n) {
d.assign(n, INF);
}
};
int main()
{
int nv, ne, r;
cin >> nv >> ne >> r;
Graph g(nv);
rep(i, ne) {
int s, t, d;
cin >> s >> t >> d;
g.es.push_back({s, t, d});
}
g.d[r] = 0;
rep(i, nv) {
for (auto& e : g.es) {
if (g.d[e.from] != INF && g.d[e.to] > g.d[e.from] + e.cost) {
if (i == nv - 1) {
cout << "NEGATIVE CYCLE" << endl;
return 0;
}
g.d[e.to] = g.d[e.from] + e.cost;
}
}
}
for (auto d : g.d) {
if (d == INF) {
cout << "INF" << endl;
} else {
cout << d << endl;
}
}
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000007;
const long long LLINF = 1000000000000000007LL;
const double EPS = 1e-9;
const int sz = 200100;
int n;
map<pair<int, int>, vector<pair<int, int>>> mp;
vector<vector<int>> vec;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) {
int a, b, c;
cin >> a >> b >> c;
mp[{a, b}].push_back({c, i});
if (mp[{b, a}].empty() || mp[{b, a}].back().second != i)
mp[{b, a}].push_back({c, i});
if (mp[{c, b}].empty() || mp[{c, b}].back().second != i)
mp[{c, b}].push_back({a, i});
if (mp[{b, c}].empty() || mp[{b, c}].back().second != i)
mp[{b, c}].push_back({a, i});
if (mp[{a, c}].empty() || mp[{a, c}].back().second != i)
mp[{a, c}].push_back({b, i});
if (mp[{c, a}].empty() || mp[{c, a}].back().second != i)
mp[{c, a}].push_back({b, i});
vec.push_back({a, b, c});
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 3; ++j) {
for (int k = 0; k < j; ++k) {
sort(mp[{vec[i][j], vec[i][k]}].rbegin(),
mp[{vec[i][j], vec[i][k]}].rend());
sort(mp[{vec[i][k], vec[i][j]}].rbegin(),
mp[{vec[i][k], vec[i][j]}].rend());
while (mp[{vec[i][j], vec[i][k]}].size() >= 3)
mp[{vec[i][j], vec[i][k]}].pop_back();
while (mp[{vec[i][k], vec[i][j]}].size() >= 3)
mp[{vec[i][k], vec[i][j]}].pop_back();
}
}
}
int res = 0;
vector<int> ans;
vector<pair<int, int>> buf;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 3; ++j) {
for (int k = 0; k < j; ++k) {
buf = mp[{vec[i][j], vec[i][k]}];
int r;
if (buf.size() == 1) {
r = buf[0].first;
if (min(min(vec[i][j], vec[i][k]), r) > res) {
res = min(min(vec[i][j], vec[i][k]), r);
ans = {buf[0].second};
}
} else {
r = buf[0].first + buf[1].first;
if (min(min(vec[i][j], vec[i][k]), r) > res) {
res = min(min(vec[i][j], vec[i][k]), r);
ans = {buf[0].second, buf[1].second};
}
}
}
}
}
cout << ans.size() << '\n';
for (int el : ans) cout << el + 1 << ' ';
}
| 10 | CPP |
def INT(): return int(input())
def FLOAT(): return float(input())
MOD = 10**9+7
n = INT()
memo = [{} for _ in range(n+1)]
def ok(last4):
for i in range(4):
t = list(last4)
if i>=1:
t[i-1],t[i] = t[i],t[i-1]
if "".join(t).count("AGC")>=1:
return False
return True
def dfs(cur,last3):
if last3 in memo[cur]:
return memo[cur][last3]
if cur==n:
return 1
ret = 0
for c in "ACGT":
if ok(last3+c):
ret = (ret + dfs(cur+1,last3[1:]+c))%MOD
memo[cur][last3] = ret
return ret
print(dfs(0,'TTT')) | 0 | PYTHON3 |
#import<cstdio>
int main(){for(int a,b;~scanf("%d%d",&a,&b);printf("%d\n",a+b));} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, p = 1000000007;
long long c[60][60];
long long f[60][120];
int main() {
scanf("%d", &n);
for (int i = 0; i <= n; i++) {
c[i][0] = 1;
for (int j = 1; j <= i; j++) {
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % p;
}
}
f[1][n] = f[1][n - 1] = 1;
for (int i = 1; i <= n; i++) {
for (int j = -i; j <= i; j++) {
if (f[i][j + n] == 0) {
continue;
}
for (int a = 0; a < n; a++) {
for (int b = 0; b < n; b++) {
if (a + b > 0 && i + a + b <= n && (j + a - b) % 2 == 0 && abs(j) <= a + b) {
long long &t = f[i + a + b][(j + a - b) / 2 + n];
t = (t + f[i][j + n] * c[i + a + b][a + b] % p * c[a + b][b]) % p;
}
}
}
}
}
printf("%lld\n", f[n][n]);
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const long double PI = 3.14159265358979323846;
const long double eps = 1e-5;
const int INF = numeric_limits<int>::max();
const long long LINF = numeric_limits<long long>::max();
const long long mod = 1000 * 1000 * 1000 + 7;
bool clockwise(pair<long long, long long> a, pair<long long, long long> b,
pair<long long, long long> c) {
return (b.first - a.first) * (c.second - a.second) -
(b.second - a.second) * (c.first - a.first) <
0;
}
bool counterClockwise(pair<long long, long long> a,
pair<long long, long long> b,
pair<long long, long long> c) {
return (b.first - a.first) * (c.second - a.second) -
(b.second - a.second) * (c.first - a.first) >
0;
}
vector<pair<int, int> > convexHull(vector<pair<int, int> > a) {
if (a.size() < 3) return a;
sort(a.begin(), a.end());
pair<int, int> p1 = a[0], p2 = a.back();
vector<pair<int, int> > up, down;
up.push_back(p1);
down.push_back(p1);
for (int i = 1; i < a.size(); ++i) {
if ((i == a.size() - 1) || clockwise(p1, a[i], p2)) {
while ((up.size() >= 2) &&
(!clockwise(up[up.size() - 2], up[up.size() - 1], a[i])))
up.pop_back();
up.push_back(a[i]);
}
if ((i == a.size() - 1) || (counterClockwise(p1, a[i], p2))) {
while ((down.size() >= 2) &&
(!counterClockwise(down[down.size() - 2], down[down.size() - 1],
a[i])))
down.pop_back();
down.push_back(a[i]);
}
}
a.clear();
for (int i = 0; i < up.size(); ++i) a.push_back(up[i]);
for (int i = down.size() - 2; i > 0; --i) a.push_back(down[i]);
return a;
}
vector<int> z_function(const string& s) {
int n = s.size();
vector<int> z(n);
for (int i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r) z[i] = min(r - i + 1, z[i - l]);
while ((i + z[i] < n) && (s[z[i]] == s[i + z[i]])) ++z[i];
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
return z;
}
long long norm2(const pair<int, int>& p) {
return (long long)(p.first) * (p.first) + (long long)(p.second) * p.second;
}
long long gcd(long long x, long long y) {
if (y == 0) return x;
return gcd(y, x % y);
}
string get(vector<pair<int, int> >& a) {
int n = a.size();
vector<pair<int, int> > v(n);
a.push_back(a[0]);
for (int i = 0; i < n; ++i) {
v[i].first = a[i + 1].first - a[i].first;
v[i].second = a[i + 1].second - a[i].second;
}
string s = "";
v.push_back(v[0]);
for (int i = 0; i < n; ++i) {
s += to_string((norm2(v[i]))) + '!';
long long y = (long long)v[i].first * v[i + 1].first +
(long long)(v[i].second) * v[i + 1].second;
s += to_string(y) + '$';
}
return s;
}
void solve() {
int n, m;
cin >> n >> m;
vector<pair<int, int> > a(n), b(m);
for (int i = 0; i < n; ++i) {
cin >> a[i].first >> a[i].second;
}
for (int i = 0; i < m; ++i) {
cin >> b[i].first >> b[i].second;
}
a = convexHull(a), b = convexHull(b);
if (a.size() != b.size()) {
cout << "NO\n";
return;
}
string s1 = get(a), s2 = get(b);
int sz = s1.size();
if (s2.size() != sz) {
cout << "NO\n";
return;
}
string s = s1 + "#" + s2 + s2;
vector<int> res = z_function(s);
for (int i = 1; i < res.size(); ++i) {
if (res[i] >= sz) {
cout << "YES\n";
return;
}
}
cout << "NO\n";
}
int main() {
ios_base::sync_with_stdio(0);
solve();
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
long long sqr(long long n) { return n * n; }
long long binpow(long long a, long long n) {
if (n == 0) return 1;
if (n % 2 != 0)
return binpow(a, n - 1) * a;
else {
long long b = binpow(a, n / 2);
return b * b;
}
}
long long gcd(long long a, long long b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
void solve() {
int n;
cin >> n;
vector<int> a(n + 2);
for (int i = 1; i <= n; i++) cin >> a[i];
a[n + 1] = 1001;
a[0] = 0;
int ans = 0, k = 0;
for (int i = 0; i <= n + 1; i++) {
for (int j = i + 1; j <= n + 1; j++) {
if (a[i] - i == a[j] - j)
k++;
else {
ans = max(ans, k - 1);
k = 0;
}
}
ans = max(ans, k - 1);
k = 0;
}
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 7 | CPP |
for _ in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
X=a[0]
x=a[0]
a.pop(0)
y=0
Y=0
moves=1
while len(a)!=0:
while Y<=X :
if len(a)==0:
break
Y+=a[-1]
a.pop(-1)
moves+=1
y+=Y
if len(a)==0:
break
X=0
while X<=Y:
if len(a)==0:
break
X+=a[0]
a.pop(0)
moves+=1
x+=X
Y=0
print(moves,x,y) | 10 | PYTHON3 |
import sys
t=int(input())
while t:
n=int(input())
s=input()
#m=list(map(int,input().split()))
d={}
mini=200
for i in range(n):
if d.get(ord(s[i]),-1)==-1:
d[ord(s[i])]=[]
d[ord(s[i])].append(i)
if ord(s[i])<mini:
mini=ord(s[i])
l_s={}
d[mini].sort()
ld=[]
ch=0
for i in range(len(d[mini])):
s1=''
cnt=0
s1+=s[d[mini][i]:]
cnt=n-d[mini][i]
if cnt%2==0:
s1+=s[:d[mini][i]]
else:
if d[mini][i]-1>=0:
s1+=s[d[mini][i]-1::-1]
#print(11,s1)
if l_s.get(s1,-1)==-1:
l_s[s1]=d[mini][i]
ld.append(s1)
#print(l_s)
ld.sort()
print(ld[0])
print(l_s[ld[0]]+1)
t-=1 | 8 | PYTHON3 |
#Q_B
S = input()
w = int(input())
l = [S[i] for i in range(0, len(S), w)]
print(''.join(l)) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300300;
vector<pair<int, int> > segs[N];
struct node {
int l, r, mid;
pair<int, int> mx;
node *L, *R;
bool prop;
node(int ll, int rr) {
l = ll, r = rr;
mid = (l + r) / 2;
mx = {0, -1};
prop = 0;
if (l == r) return;
L = new node(l, mid);
R = new node(mid + 1, r);
}
pair<int, int> query(int x, int y) {
propagate_max();
if (x == l && y == r) return mx;
if (y <= mid) return L->query(x, y);
if (x > mid) return R->query(x, y);
return max(L->query(x, mid), R->query(mid + 1, y));
}
void propagate_max() {
if (prop) {
if (l != r) {
L->mx = R->mx = mx;
L->prop = R->prop = true;
}
prop = 0;
}
}
void set_max(int x, int y, int n_mx, int n_nx) {
propagate_max();
if (x == l && y == r) {
mx = {n_mx, n_nx};
prop = true;
return;
}
if (y <= mid)
L->set_max(x, y, n_mx, n_nx);
else if (x > mid)
R->set_max(x, y, n_mx, n_nx);
else {
L->set_max(x, mid, n_mx, n_nx);
R->set_max(mid + 1, y, n_mx, n_nx);
}
mx = max(L->mx, R->mx);
}
};
int main() {
int n, m;
scanf("%d %d", &n, &m);
vector<int> zip;
for (int i = 0; i < m; ++i) {
int row, l, r;
scanf("%d %d %d", &row, &l, &r);
--row;
segs[row].push_back({l, r});
zip.push_back(l);
zip.push_back(r);
}
sort(zip.begin(), zip.end());
zip.resize(unique(zip.begin(), zip.end()) - zip.begin());
m = (int)zip.size();
vector<pair<int, int> > ans(n);
int best = n - 1;
node st(0, m - 1);
for (int i = n - 1; i >= 0; --i) {
ans[i] = {0, -1};
for (auto sg : segs[i]) {
int idx_l = lower_bound(zip.begin(), zip.end(), sg.first) - zip.begin();
int idx_r = lower_bound(zip.begin(), zip.end(), sg.second) - zip.begin();
auto cand = st.query(idx_l, idx_r);
ans[i] = max(ans[i], cand);
}
++ans[i].first;
if (ans[i] > ans[best]) best = i;
for (auto sg : segs[i]) {
int idx_l = lower_bound(zip.begin(), zip.end(), sg.first) - zip.begin();
int idx_r = lower_bound(zip.begin(), zip.end(), sg.second) - zip.begin();
st.set_max(idx_l, idx_r, ans[i].first, i);
}
}
vector<bool> good(n);
while (best != -1) {
good[best] = 1;
best = ans[best].second;
}
vector<int> bad;
for (int i = 0; i < n; ++i)
if (!good[i]) bad.push_back(i);
int sz = (int)bad.size();
printf("%d\n", sz);
for (int i = 0; i < sz; ++i) printf("%d%c", ++bad[i], " \n"[i == sz - 1]);
return 0;
}
| 10 | CPP |
#By hassan alkanash
n=int(input())
sum=1
x="I hate that"
y="I love that"
for i in range(n):
if i==n-1:
if (sum % 2 == 1):
print(x[:-4]+"it", end=" ")
break
else:
print(y[:-4]+"it", end=" ")
break
if(sum%2==1):
print(x,end=" ")
else:
print(y,end=" ")
sum+=1
#I hate that I love that I hate that I love it
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long arr[101][101];
int main() {
long long n, i, l, r, f, h, v, j;
cin >> n;
for (i = 0; i < n; i++) {
cin >> l >> r;
arr[l][r] = 1;
}
h = v = 0;
for (i = 0; i <= 100; i++) {
f = 0;
for (j = 0; j <= 100; j++) {
if (arr[i][j]) f = 1;
}
if (f) h++;
}
for (j = 0; j <= 100; j++) {
f = 0;
for (i = 0; i <= 100; i++) {
if (arr[i][j]) f = 1;
}
if (f) v++;
}
cout << min(h, v) << '\n';
return 0;
}
| 7 | CPP |
import math
def LCM(a, b):
return (a * b)//math.gcd(a, b)
n = int(input())
arr = list(map(int, input().split()))
suffix_arr = [1] * n
suffix_arr[-1] = arr[n-1]
for i in range(n-2, -1, -1):
suffix_arr[i] = math.gcd(arr[i], suffix_arr[i+1])
ans = LCM(arr[0], suffix_arr[1])
for i in range(1, n-1):
ans = math.gcd(ans, LCM(arr[i], suffix_arr[i+1]))
print(ans)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 400002, LG = 19;
int n = 1, q, ans, nxt[N][LG], mx[N][LG], w[N];
long long sum[N][LG];
int getParent(long long p, long long q) {
for (int j = LG - 1; j >= 0; --j)
if (nxt[p][j] and mx[p][j] < q) p = nxt[p][j];
return nxt[p][0];
}
void add(long long p, long long q) {
int x = w[p] >= q ? p : getParent(p, q);
nxt[++n][0] = x;
sum[n][0] = mx[n][0] = w[x];
w[n] = q;
for (int j = 1; j <= LG - 1; ++j)
if (nxt[n][j - 1]) {
nxt[n][j] = nxt[nxt[n][j - 1]][j - 1];
sum[n][j] = sum[n][j - 1] + sum[nxt[n][j - 1]][j - 1];
mx[n][j] = max(mx[n][j - 1], mx[nxt[n][j - 1]][j - 1]);
} else
break;
}
int query(long long p, long long q) {
int ret = w[p] <= q;
q -= w[p];
for (int j = LG - 1; j >= 0; --j)
if (nxt[p][j] and q >= sum[p][j]) {
ret += 1 << j;
q -= sum[p][j];
p = nxt[p][j];
}
return ret;
}
int main() {
scanf("%d", &q);
while (q--) {
long long t, p, q;
scanf("%I64d %I64d %I64d", &t, &p, &q);
p ^= ans;
q ^= ans;
if (t == 1)
add(p, q);
else
printf("%d\n", ans = query(p, q));
}
}
| 10 | CPP |
#include <bits/stdc++.h>
template <typename T>
void MACRO_VAR_Scan(T& t) {
std::cin >> t;
}
template <typename First, typename... Rest>
void MACRO_VAR_Scan(First& first, Rest&... rest) {
std::cin >> first;
MACRO_VAR_Scan(rest...);
}
template <typename T>
void MACRO_VEC_ROW_Init(int n, T& t) {
t.resize(n);
}
template <typename First, typename... Rest>
void MACRO_VEC_ROW_Init(int n, First& first, Rest&... rest) {
first.resize(n);
MACRO_VEC_ROW_Init(n, rest...);
}
template <typename T>
void MACRO_VEC_ROW_Scan(int p, T& t) {
std::cin >> t[p];
}
template <typename First, typename... Rest>
void MACRO_VEC_ROW_Scan(int p, First& first, Rest&... rest) {
std::cin >> first[p];
MACRO_VEC_ROW_Scan(p, rest...);
}
template <typename T>
void MACRO_OUT(const T t) {
std::cout << t;
}
template <typename First, typename... Rest>
void MACRO_OUT(const First first, const Rest... rest) {
std::cout << first << " ";
MACRO_OUT(rest...);
}
template <class T>
inline T CHMAX(T& a, const T b) {
return a = (a < b) ? b : a;
}
template <class T>
inline T CHMIN(T& a, const T b) {
return a = (a > b) ? b : a;
}
template <class T>
using V = std::vector<T>;
template <class T>
using VV = V<V<T>>;
template <typename S, typename T>
std::ostream& operator<<(std::ostream& os, std::pair<S, T> p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using PAIR = std::pair<ll, ll>;
using PAIRLL = std::pair<ll, ll>;
constexpr ll INFINT = (1 << 30) - 1;
constexpr ll INFINT_LIM = (1LL << 31) - 1;
constexpr ll INFLL = 1LL << 60;
constexpr ll INFLL_LIM = (1LL << 62) - 1 + (1LL << 62);
constexpr double EPS = 1e-10;
constexpr ll MOD = 998244353;
constexpr double PI = 3.141592653589793238462643383279;
template <class T, size_t N>
void FILL(T (&a)[N], const T& val) {
for (auto& x : a) x = val;
}
template <class ARY, size_t N, size_t M, class T>
void FILL(ARY (&a)[N][M], const T& val) {
for (auto& b : a) FILL(b, val);
}
template <class T>
void FILL(std::vector<T>& a, const T& val) {
for (auto& x : a) x = val;
}
template <class ARY, class T>
void FILL(std::vector<std::vector<ARY>>& a, const T& val) {
for (auto& b : a) FILL(b, val);
}
ll dp[10006][3][2];
ll rec(ll n, ll ng, ll from) {
if (n == 0) return 1ll;
if (n == 1) return ng != from;
ll& res = dp[n][ng][from];
if (res != -1) return res;
res = 0;
ll X = 2;
while ((X - 1) <= n) X *= 2;
X /= 2;
--X;
ll rest = n - X;
ll l = X / 2 + std::min((X + 1) / 2, rest);
ll r = n - l - 1;
ll end = l;
while (r <= end) {
ll rp = from;
if (l % 2 == 1) rp = 1 - from;
if (ng != rp) (res += rec(l, rp, from) * rec(r, 1 - rp, 1 - rp)) %= MOD;
--l;
++r;
}
return res;
}
signed main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
;
ll n;
MACRO_VAR_Scan(n);
;
if (n == 3) {
MACRO_OUT(0);
std::cout << "\n";
;
return 0;
}
ll sum = 0;
ll X = 0;
while (sum < n) {
sum += 1 << X;
++X;
}
--X;
sum -= 1 << X;
V<ll> a({0, 0, 0, 1});
while (a.size() <= X) {
ll sz = a.size();
a.emplace_back(a[sz - 1] + 2 * a[sz - 2] + 3);
}
MACRO_OUT(n == sum + 1 + a[X] || n == sum + 1 + a[X] + 1);
std::cout << "\n";
;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int f[100005], Q[100005], S[100005], sum[100005], g[100005], a[100005],
b[100005];
int n, m, i, x, y, k, mod, h, t, ans;
int get(int u) { return f[u] == u ? u : f[u] = get(f[u]); }
int check(int x) {
for (; x; x /= 10)
if (x % 10 != 4 && x % 10 != 7) return 0;
return 1;
}
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) f[i] = i;
for (i = 1; i <= m; i++) scanf("%d%d", &x, &y), f[get(x)] = get(y);
for (i = 1; i <= n; i++) sum[get(i)]++;
for (i = 1; i <= n; i++)
if (f[i] == i) S[++*S] = sum[i];
sort(S + 1, S + *S + 1);
k = 1;
m = 0;
for (i = 2; i <= (*S) + 1; i++)
if (S[i] != S[i - 1]) a[++m] = S[i - 1], b[m] = i - k, k = i;
f[0] = 0;
for (i = 1; i <= n; i++) f[i] = 1e9;
for (i = 1; i <= m; i++) {
for (k = 0; k <= n; k++) g[k] = f[k];
for (mod = 0; mod < a[i]; mod++) {
h = t = 1;
Q[1] = mod;
for (k = mod + a[i]; k <= n; k += a[i]) {
for (; h <= t && (k - Q[h]) / a[i] > b[i]; h++)
;
if (h <= t) f[k] = min(f[k], g[Q[h]] + (k - Q[h]) / a[i]);
for (; h <= t && g[k] <= g[Q[t]] + (k - Q[t]) / a[i]; t--)
;
Q[++t] = k;
}
}
}
ans = 1e9;
for (i = 1; i <= n; i++)
if (check(i)) ans = min(ans, f[i]);
printf("%d\n", ans == 1e9 ? -1 : ans - 1);
}
| 11 | CPP |
x = input().split()
n,m,a = list(map(int,x))
w = n//a
h = m//a
if n % a > 0 :
w = w + 1
if m % a > 0 :
h += 1
ans = w*h
print(ans)
| 7 | PYTHON3 |
INT_MAX=10**19+7
MOD=10**12+7
def INPUT():return list(int(i) for i in input().split())
def LIST_1D_ARRAY(n):return [0 for _ in range(n)]
def LIST_2D_ARRAY(m,n):return [[0 for _ in range(n)]for _ in range(m)]
#=======================================================================
import bisect
z=1000000
dpheight=[0]*(z)
for i in range(1,z):
dpheight[i]=((3*i+1)*i)//2
#print(dpheight[0:100])
for _ in range(int(input())):
cards=int(input())
ans=0
while(cards>1):
h=bisect.bisect_left(dpheight,cards,0,z)-1
if dpheight[h+1]==cards:
h+=1
#print(h)
cards-=dpheight[h]
ans+=1
print(ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long i, k, n, a[200009], b[200009], c[200009];
int main() {
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n; i++) {
if (a[i] == 0) k = i;
if (k) b[i] = k;
}
k = 0;
for (i = n; i >= 1; i--) {
if (a[i] == 0) k = i;
if (k) c[i] = k;
}
for (i = 1; i <= n; i++) {
k = 1000009;
if (b[i]) k = i - b[i];
if (c[i]) k = min(k, c[i] - i);
cout << k << ' ';
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
int odd = 0, even = 0;
for (int i = 0; i < n; ++i) {
int temp;
cin >> temp;
if (temp & 1)
++odd;
else
++even;
}
if (x % 2 == 0) {
if (even == 0) {
cout << "No\n";
continue;
}
--even;
--x;
}
x -= 2 * min((x - 1) / 2, even / 2);
if (odd >= x)
cout << "Yes\n";
else
cout << "No\n";
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n, m;
while(cin >> n >> m, n || m){
long long ans = 0;
string N[100], B[1000];
int M[100], cnt[100] = {0};
for(int i = 0; i < n; i++){
cin >> N[i] >> M[i];
for(int j = 0; j < 8; j++){
if(N[i][j] == '*') cnt[i]++;
}
}
for(int i = 0; i < m; i++) cin >> B[i];
for(int i = 0; i < n; i++){
for(int j = 0; j < m; j++){
if(N[i].substr(cnt[i], N[i].size() - cnt[i]) == B[j].substr(cnt[i], N[i].size() - cnt[i])) ans += M[i];
}
}
cout << ans << endl;
}
return 0;
} | 0 | CPP |
a,b,c=map(int,input().split())
if (a+c>=b and b+c>=a) and c!=0:
print("?")
elif a>b and a>c:
print("+")
elif b>a and b>c:
print('-')
else:
print(0) | 7 | PYTHON3 |
Subsets and Splits