solution
stringlengths 10
159k
| difficulty
int64 0
3.5k
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
const int mxn = 1e2 + 3;
using namespace std;
int n, T;
int a[mxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
cin >> T;
int ctr = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (abs(a[i] - a[j]) <= T) ctr = max(ctr, abs(i - j + 1));
}
}
cout << ctr << endl;
return 0;
}
| 1,400 | CPP |
n=int(input())
l=input().split()
li=[int(i) for i in l]
if(n==1):
print(1,1)
print(-li[0])
print(1,1)
print(0)
print(1,1)
print(0)
quit()
print(1,n-1)
for i in range(n-1):
z=(li[i]%n)
print(z*(n-1),end=" ")
li[i]=li[i]+(z*(n-1))
print()
print(2,n)
for i in range(1,n):
z=(li[i]%n)
print(z*(n-1),end=" ")
li[i]=li[i]+(z*(n-1))
print()
print(1,n)
for i in range(n):
print(-li[i],end=" ")
print()
| 1,600 | PYTHON3 |
t = list(input())
l = [4,7]
print("NYOE S"[t.count('4')+t.count('7') in l::2]) | 800 | PYTHON3 |
n,k=map(int,input().split())
L=[]
for i in range(n):
L.append(input())
ps1=[[0]*(n+1) for i in range(n)] #number of "#"
ps2=[[0]*n for i in range(n+1)]
for i in range(n):
for j in range(n):
ps1[i][j+1]=ps1[i][j]+int(L[i][j]=="#")
ps2[i+1][j]=ps2[i][j]+int(L[i][j]=="#")
T=[[0]*n for i in range(n)]
for i in range(n):
for j in range(n-k+1):
if ps1[i][j+k]-ps1[i][j]==0:
for x in range(k):
T[i][j+x]+=1
for i in range(n-k+1):
for j in range(n):
if ps2[i+k][j]-ps2[i][j]==0:
for x in range(k):
T[i+x][j]+=1
ans1,ans2=0,0
for i in range(n):
for j in range(n):
if T[i][j]>T[ans1][ans2]:
ans1,ans2=i,j
print(ans1+1,ans2+1)
| 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int f = 1, x = 0;
char ch;
do {
ch = getchar();
if (ch == '-') f = -1LL;
} while (ch < '0' || ch > '9');
do {
x = x * 10 + ch - '0';
ch = getchar();
} while (ch >= '0' && ch <= '9');
return f * x;
}
inline long long readll() {
long long f = 1, x = 0;
char ch;
do {
ch = getchar();
if (ch == '-') f = -1LL;
} while (ch < '0' || ch > '9');
do {
x = x * 10 + ch - '0';
ch = getchar();
} while (ch >= '0' && ch <= '9');
return f * x;
}
template <class T>
inline void chmax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
inline void chmin(T &a, T b) {
if (a > b) a = b;
}
inline void swap(int &a, int &b) {
int c = a;
a = b;
b = c;
}
using namespace std;
int kk[1111][1111];
vector<int> vis;
char ans[10];
inline void query(int x) {
if (!vis[x]) return;
printf("? %d\n", x + 1);
fflush(stdout);
scanf("%s", ans);
if (ans[0] == 'Y') {
vis[x] = 0;
} else
return;
}
inline void reset() {
printf("R\n");
fflush(stdout);
}
inline void output() {
printf("! %d\n", accumulate(vis.begin(), vis.end(), 0));
fflush(stdout);
}
int n, k;
int main() {
n = read();
k = read();
vis.assign(n, 1);
int bl = max(k / 2, 1);
int nm = n / bl;
for (int i = (0); i <= (nm - 1); ++i) {
reset();
int d = 0;
int pre = nm;
for (int _ = (1); _ <= (nm); ++_) {
int cur = (i + d + nm) % nm;
if (kk[pre][cur]) break;
kk[pre][cur] = kk[cur][pre] = 1;
int st = cur * bl, ed = cur * bl + bl - 1;
for (int k = (st); k <= (ed); ++k) query(k);
pre = cur;
if (d >= 0) ++d;
d = -d;
}
}
output();
return 0;
}
| 3,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> ar[200001];
int parity[200001];
void dfs(int node, int dist) {
parity[dist] ^= 1;
for (int i = 0; i < ar[node].size(); i++) dfs(ar[node][i], dist + 1);
}
int main() {
int n, x, res = 0;
cin >> n;
for (int i = 2; i <= n; i++) cin >> x, ar[x].push_back(i);
dfs(1, 0);
for (int i = 0; i <= n; i++) res += parity[i];
cout << res;
}
| 1,500 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("-Ofast")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,popcnt,abm,avx2,mmx,fma,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("03")
#pragma optimize("g", on)
using namespace std;
long long power(long long a, long long b) {
if (!b) return 1;
long long temp = power(a, b / 2);
temp = (temp * temp);
if (b % 2) return (a * temp) % 1000000007;
return temp % 1000000007;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long comb(long long n, long long r) {
if (r < 0 || r > n) return 0;
if ((n - r) < r) r = n - r;
long long a = 1;
for (long long i = n; i > n - r; --i) {
a = a * i;
}
for (long long i = 1; i < r + 1; ++i) {
a = a / i;
}
return a;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
long long dp[200001];
dp[0] = 1;
for (long long i = 1; i < 200001; i++) {
dp[i] = (dp[i - 1] * i) % 1000000007;
}
long long factor = power(2, 1000000007 - 2) % 1000000007;
while (t--) {
long long n;
cin >> n;
cout << (dp[2 * n] * factor) % 1000000007 << "\n";
}
return 0;
}
| 800 | CPP |
from sys import stdin
t = int(input())
o = []
for i in range(t):
ne = int(input())
e = [int(x) for x in stdin.readline().split()]
print(len(set(e)))
| 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e2 + 5;
int n, m;
int a[N][N];
int digitcnt[N][15][2];
int posmark[N][15][2];
int ans[N];
void prework() {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int val = a[i][j];
int pos = 0;
for (int k = 0; k < 10; ++k) {
if (val & 1) {
digitcnt[i][pos][1]++;
posmark[i][pos][1] = j;
} else {
digitcnt[i][pos][0]++;
posmark[i][pos][0] = j;
}
pos++;
val >>= 1;
}
}
}
}
bool solve(int pos) {
int fullcnt = 0;
for (int i = 0; i < n; ++i) {
if (digitcnt[i][pos][1] == m) fullcnt++;
}
if (fullcnt % 2 == 0) {
bool yes = false;
for (int i = 0; i < n; ++i) {
if (digitcnt[i][pos][1] == m)
ans[i] = 0;
else if (yes == false) {
if (digitcnt[i][pos][0] != m) {
ans[i] = posmark[i][pos][1];
yes = true;
} else {
ans[i] = 0;
}
} else {
ans[i] = posmark[i][pos][0];
}
}
return yes;
} else {
for (int i = 0; i < n; ++i) {
if (digitcnt[i][pos][1] == m)
ans[i] = 0;
else
ans[i] = posmark[i][pos][0];
}
return true;
}
}
int main() {
scanf("%d", &n);
scanf("%d", &m);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
scanf("%d", &a[i][j]);
}
}
prework();
bool yes = false;
for (int i = 0; i < 10; ++i) {
if (solve(i)) {
printf("TAK\n");
for (int j = 0; j < n; ++j) printf("%d ", ans[j] + 1);
yes = true;
break;
}
}
if (!yes) printf("NIE");
}
| 1,600 | CPP |
def main():
solver(input())
def solver(s):
print(helper(s)[0])
def helper(s):
if len(s) == 0:
return [0, 0, 0]
else:
ccounts = helper(s[1:])
if s[0] == 'Q':
ccounts[0] += ccounts[1]
ccounts[2] += 1
elif s[0] == 'A':
ccounts[1] += ccounts[2]
return ccounts
main()
# solver('QAQAQYSYIOIWIN')
| 800 | PYTHON3 |
s=input()
k=max(s)
print(k*s.count(k)) | 800 | PYTHON3 |
#!usr/bin/python3
#problem 4A
def main():
w = int(input())
if w % 2 == 0:
if w == 2:
print('NO')
else:
print('YES')
else:
print('NO')
if __name__ == '__main__':
main()
| 800 | PYTHON3 |
n=int(input())
m=int(input())
a=[]
for _ in range(n):
a.append(int(input()))
mx=max(a)+m
mn=max(a)
while(m):
ind=a.index(min(a))
a[ind]+=1
m-=1
mn=max(a)
print(mn,end=' ')
print(mx) | 1,100 | PYTHON3 |
x,y=map(int,input().split(":"))
a,b=map(int,input().split(":"))
x=x*60+y
a=a*60+b
tot=int((a+x)/2)
new_hr=int(tot//60)
new_min=int(tot%60)
c=str(new_hr).zfill(2)
d=str(new_min).zfill(2)
print(c+":"+d) | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
pair<int, int> m[100100];
int m1[100100], m2[100100], m3[100100], m4[100100];
int main() {
int n, i, j;
scanf("%d", &n);
for (i = 0; i < n; scanf("%d%d", &m[i].first, &m[i].second), i++)
;
long long z = 1000000000000000000ll;
for (int k = 0; k < 2; k++) {
sort(m, m + n);
z = min(z, (long long)(m[n - 1].first - m[0].first) *
(m[n - 1].first - m[0].first));
for (i = 0; i < n; m1[i + 1] = min(m1[i], m[i].second),
m2[i + 1] = max(m2[i], m[i].second), i++)
;
for (i = n - 1; i >= 0; m3[i] = min(m3[i + 1], m[i].second),
m4[i] = max(m4[i + 1], m[i].second), i--)
;
long long l, c, r;
for (l = 0, r = 100000000000000000ll; l < r;) {
c = (l + r) / 2;
int f = 0;
for (i = 0, j = n - 1; i < n && m[i].first <= 0; i++) {
if (j < 0 || m[j].first <= 0) j++;
for (; j > i && m[j].first > 0;) {
if (m[j].first > -m[i].first ||
(long long)(m[j].first - m[i].first) * (m[j].first - m[i].first) >
c)
j--;
else {
j++;
if (j == n || m[j].first > -m[i].first ||
(long long)(m[j].first - m[i].first) *
(m[j].first - m[i].first) >
c) {
j--;
break;
}
}
}
int x1 = min(m1[i], m3[j + 1]);
int x2 = max(m2[i], m4[j + 1]);
if ((long long)(x2 - x1) * (x2 - x1) <= c &&
(long long)x1 * x1 + (long long)m[i].first * m[i].first <= c &&
(long long)x2 * x2 + (long long)m[i].first * m[i].first <= c)
f = 1;
}
for (i = n - 1, j = 0; i >= 0 && m[i].first >= 0; i--) {
if (j >= n || m[j].first >= 0) j--;
for (; j < i && m[j].first < 0;) {
if (-m[j].first > m[i].first ||
(long long)(m[j].first - m[i].first) * (m[j].first - m[i].first) >
c)
j++;
else {
j--;
if (j < 0 || -m[j].first > m[i].first ||
(long long)(m[j].first - m[i].first) *
(m[j].first - m[i].first) >
c) {
j++;
break;
}
}
}
int x1 = min(m1[j], m3[i + 1]);
int x2 = max(m2[j], m4[i + 1]);
if ((long long)(x2 - x1) * (x2 - x1) <= c &&
(long long)x1 * x1 + (long long)m[i].first * m[i].first <= c &&
(long long)x2 * x2 + (long long)m[i].first * m[i].first <= c)
f = 1;
}
if (f)
r = c;
else
l = c + 1;
}
z = min(z, r);
for (i = 0; i < n; swap(m[i].first, m[i].second), i++)
;
}
printf("%lld\n", z);
return 0;
}
| 2,900 | CPP |
for _ in range(int(input())):
x=input()
if(len(x)>10):
print('{}{}{}'.format(x[0],len(x)-2,x[len(x)-1]))
else:
print(x)
| 800 | PYTHON3 |
n, m = map(int, input().split())
ans = min(n, m)
if ans % 2 == 0:
print('Malvika')
else:
print('Akshat')
| 900 | PYTHON3 |
import sys
input=sys.stdin.buffer.readline
t=int(input())
for _ in range(t):
a,b,c=[int(x) for x in input().split()] #box of b donuts cost c dollars
#cheaper in shop 1 than 2. 1 box + 1 donut of shop 2
nDonuts=1
shop1Cost=a
shop2Cost=c
if shop1Cost<shop2Cost:
one=nDonuts
else:
one=-1
#cheaper in shop 2 than 1
nDonuts=b
shop1Cost=a*nDonuts
shop2Cost=c
if shop1Cost>shop2Cost:
two=nDonuts
else:
two=-1
print('{} {}'.format(str(one),str(two)))
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long int k;
bool can(long long int x) {
long long int n = k, count = 0;
while (1) {
if (n - x <= 0) {
count += n;
break;
}
n -= x, n -= n / 10;
count += x;
}
if (count >= (k - 1) / 2 + 1)
return true;
else
return false;
}
long long int binary_search(long long int l, long long int r) {
if (l >= r) return r;
long long int mid = (l + r) / 2;
if (can(mid))
return binary_search(l, mid);
else
return binary_search(mid + 1, r);
}
int main() {
cin >> k;
cout << binary_search(1, 1e18);
return 0;
}
| 1,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct qq {
int x, y, z;
} q[100006], q1;
int main() {
string s;
int m, l, r;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'x') {
q[i].x = q[i - 1].x + 1;
q[i].y = q[i - 1].y;
q[i].z = q[i - 1].z;
}
if (s[i] == 'y') {
q[i].x = q[i - 1].x;
q[i].y = q[i - 1].y + 1;
q[i].z = q[i - 1].z;
}
if (s[i] == 'z') {
q[i].x = q[i - 1].x;
q[i].y = q[i - 1].y;
q[i].z = q[i - 1].z + 1;
}
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> l >> r;
if (r - l < 2) {
cout << "YES" << endl;
continue;
}
q1.x = q[r - 1].x - q[l - 2].x;
q1.y = q[r - 1].y - q[l - 2].y;
q1.z = q[r - 1].z - q[l - 2].z;
if (abs(q1.x - q1.y) > 1 || abs(q1.x - q1.z) > 1 || abs(q1.y - q1.z) > 1)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
}
| 1,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<int, int> a, pair<int, int> b) { return a.second < b.second; }
const int MAXN = 220000;
const long long INF = 1e18;
long long rmq[MAXN * 4];
long long dd[MAXN * 4];
long long sm[MAXN];
int n, m;
int ans;
map<long long, int> mm;
pair<long long, long long> b[MAXN];
long long a[MAXN];
void build(int v, int tl, int tr) {
if (tl + 1 == tr) {
rmq[v] = sm[tl];
return;
}
int m = (tl + tr) >> 1;
build(v * 2 + 1, tl, m);
build(v * 2 + 2, m, tr);
rmq[v] = min(rmq[v * 2 + 1], rmq[v * 2 + 2]);
}
void add(int v, int tl, int tr, int l, int r, long long d) {
if (r <= tl || tr <= l) return;
if (l <= tl && tr <= r) {
rmq[v] += d;
dd[v] += d;
return;
}
int m = (tl + tr) >> 1;
add(v * 2 + 1, tl, m, l, r, d);
add(v * 2 + 2, m, tr, l, r, d);
rmq[v] = min(rmq[v * 2 + 1], rmq[v * 2 + 2]) + dd[v];
}
long long get(int v, int tl, int tr, int l, int r) {
if (r <= tl || tr <= l) return INF;
if (l <= tl && tr <= r) return rmq[v];
int m = (tl + tr) >> 1;
return min(get(v * 2 + 1, tl, m, l, r), get(v * 2 + 2, m, tr, l, r)) + dd[v];
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%lld", a + i);
for (int i = 0; i < m; ++i) scanf("%lld", &b[i].first);
for (int i = 0; i < m; ++i) scanf("%lld", &b[i].second);
sort(b, b + m);
int cur = 0;
for (int i = n - 1; i >= 0; --i) {
while (cur < m && b[cur].first <= a[i]) {
mm[b[cur].first] = i;
++cur;
}
}
sm[0] = a[0];
for (int i = 1; i < n; ++i) sm[i] = sm[i - 1] + a[i];
build(0, 0, n);
sort(b, b + m, cmp);
for (int i = 0; i < m; ++i) {
if (!mm.count(b[i].first)) continue;
int x = mm[b[i].first];
if (get(0, 0, n, x, n) >= b[i].second) {
++ans;
add(0, 0, n, x, n, -b[i].second);
}
}
cout << ans << "\n";
return 0;
}
| 2,400 | CPP |
for _ in range(int(input())):
n,m=map(int,input().split())
r,c=[False]*n,[False]*m
for i in range(n):
x=list(map(int,input().split()))
if not all(k==0 for k in x):
r[i]=True
for j in range(m):
if x[j]==1:
c[j]=True
z=min(r.count(False),c.count(False))
#print(r.count(False),c.count(False))
#print(z)
print(["Vivek","Ashish"][z%2]) | 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long 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 << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
long long n, k, p[1000005], cnt, L[1000005], R[1000005];
double sumL, sumR;
struct cmpL {
bool operator()(long long x, long long y) {
return L[x] == L[y] ? x < y : L[x] < L[y];
}
};
struct cmpR {
bool operator()(long long x, long long y) {
return R[x] == R[y] ? x < y : R[x] < R[y];
}
};
multiset<long long, cmpL> s1;
multiset<long long, cmpR> s2;
void dfs(long long x) {
if (x > 1e18) return;
if (x != 0) p[++cnt] = x;
dfs(x * 10 + 4);
dfs(x * 10 + 7);
}
long long calc(long long ll, long long rr) {
double right = s1.size(), left = n - s1.size() - s2.size();
return (sumR - right * ll + left * rr - sumL) <= k;
}
void write(long long x) {
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
signed main() {
n = read();
k = read();
dfs(0);
sort(p + 1, p + 1 + cnt);
long long minn = 1e18, ans = 0;
long long j = 0;
for (long long i = 1; i <= n; i++) {
L[i] = read();
R[i] = read();
minn = min(minn, R[i] - L[i] + 1);
sumR += L[i];
s1.insert(i);
}
for (long long i = 1; i <= cnt; i++) {
while (p[j + 1] - p[i] + 1 <= minn && j < cnt) {
j++;
while (s1.size()) {
long long c = *s1.begin();
if (L[c] > p[j]) break;
s1.erase(c);
sumR -= L[c];
s2.insert(c);
}
while (s2.size()) {
long long c = *s2.begin();
if (R[c] >= p[j]) break;
s2.erase(c);
sumL += R[c];
}
if (calc(p[i], p[j])) {
ans = max(ans, j - i + 1);
} else
break;
}
}
write(ans);
}
| 2,500 | CPP |
n,h,a,b,k=map(int,input().split())
for _ in range(k):
ta,fa,tb,fb=map(int,input().split())
t=0
if ta==tb:
print(abs(fb-fa))
else:
t+=abs(tb-ta)
if fa>=a and fa<=b:
t+=abs(fb-fa)
else:
if fa<a:
x=a
else:
x=b
t+=min(abs(fa-a),abs(fa-b))
# print(x)
t+=abs(fb-x)
print(t) | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
int main() {
int i = 1, q = 0, a, b, c;
scanf("%d%d%d", &a, &b, &c);
while (i) {
if (a >= 1 && b >= 2 && c >= 4) {
a = a - 1;
b = b - 2;
c = c - 4;
q++;
} else
break;
i++;
}
if (q > 0)
printf("%d", q * 7);
else
printf("0");
return 0;
}
| 800 | CPP |
lst1=[]
lst2=[]
for i in range(int(input())):
a,b=[int(i) for i in input().split()]
lst1=lst1+[a]
lst2=lst2+[b]
nd=0
for i in lst2:
for j in lst1:
if i==j:
nd+=1
print(nd)
| 800 | PYTHON3 |
from math import sqrt
t= int(input())
while t:
n,k= map(int,input().split())
if k>=n:
print("1")
elif k==1:
print(n)
else:
a=[]
for i in range(1,int(sqrt(n))+1):
if n%i==0:
a.append(i)
if n//i!=i:
a.append(n//i)
a.sort()
for i in a:
if n//i <=k:
print(i)
break
t=t-1 | 1,300 | PYTHON3 |
from sys import stdin, stdout
for i1 in range(int(stdin.readline())):
n=int(stdin.readline())
a=list(map(int,stdin.readline().split()))
if n==1 or n==2:
print(0)
continue
else:
c=0
# i=0
# l1=[]
dic={}
for i in a:
if i in dic:
dic[i]+=1
else:
dic[i]=1
# print(dic)
for i in range(n-1):
x=a[i]
# j=i+1
for j in range(i+1,n):
# print(x)
x+=a[j]
# if a.count(x)>=1 and l1.count(x)==0:
if x in dic.keys():
c+=dic[x]
del dic[x]
# a.remove(x)
# l1.append(x)
# if x>max(a):
# break
# j+=1
# i+=1
# print(l1)
# for i in l1:
# if i in dic.keys():
# c+=dic[i]
# print(dic)
# del dic[i]
# while a.count(i)!=0:
# a.remove(i)
print(c)
| 1,500 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using vvi = vector<vector<int>>;
using vvb = vector<vector<bool>>;
using vvc = vector<vector<char>>;
using vi = vector<int>;
using vc = vector<char>;
using vb = vector<bool>;
using pii = pair<int, int>;
using vpii = vector<pii>;
const int oo = (int)1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
if (n == 1) {
cout << 0 << endl;
return 0;
}
vector<int> ans;
for (int i = 2; i <= n; i++) {
int cnt = 0;
int cur_i = i;
for (int j = 2; j <= cur_i; j++) {
if (cur_i % j == 0) {
cnt++;
while (cur_i % j == 0) {
cur_i /= j;
}
}
}
if (cnt <= 1) {
ans.push_back(i);
}
}
cout << ans.size() << endl;
for (auto &el : ans) {
cout << el << ' ';
}
cout << endl;
return 0;
}
| 1,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; ++i) {
cin >> arr[i];
}
for (int j = 0; j < n; ++j) {
if (arr[j] == 0)
if (j == (n - 1))
cout << "EASY" << endl;
else
continue;
else {
cout << "HARD" << endl;
break;
}
}
return 0;
};
| 800 | CPP |
import queue
from math import *
import sys
from collections import *
from random import *
from itertools import *
sys.setrecursionlimit(99999)
eps = sys.float_info.epsilon
P = 2
INF = 1e9 + 1
MOD = 1000000007
def is_prime(n):
if n == 0 or n == 1:
return False
d = 2
while d * d <= n:
if n % d == 0:
return False
d += 1
return True
def div_up(n, k):
if n % k == 0:
return n // k
else:
return n // k + 1
def num_len(n, base=10):
if n == 0:
return 1
return int(floor(log(n, base) + 1))
def dfs_sample(graph, cl, p, v):
cl[v] = 1
for to in graph[v]:
if cl[to] == 1 and p[v] != to:
# yay, cycle
pass
elif cl[to] == 0:
p[to] = v
dfs_sample(graph, cl, p, to)
cl[v] = 2
def down(a):
for i in range(1, len(a)):
if a[i] > a[i - 1]:
return False
return True
def up(a):
for i in range(1, len(a)):
if a[i] < a[i - 1]:
return False
return True
def code(c):
return ord(c) - 32
def _hash_(s):
res, p = 0, 1
for i in range(len(s)):
res += (code(s[i]) * p)
res %= MOD
p *= P
p %= MOD
return res % MOD
def remove_edge(v, u, graph):
graph[v].remove(u)
graph[u].remove(v)
def dfs_stack(start, graph, visited, flags):
global b
stack = []
visited[start] = True
stack.append(start)
while len(stack) != 0:
v = stack.pop()
if not flags[v]:
b = False
for to in graph[v]:
if not visited[to]:
visited[to] = True
stack.append(to)
def all_eq(a):
for i in range(len(a) - 1):
if a[i] != a[i + 1]:
return False
return True
def solve():
n = int(input())
if n % 3 == 0:
print(n // 3, n // 3)
elif n % 3 == 2:
print(n // 3, n // 3 + 1)
else:
print(n // 3 + 1, n // 3)
for _ in range(int(input())):
solve()
def debug():
pass
# debug() | 800 | PYTHON3 |
#include <bits/stdc++.h>
int a[1010], b[1010] = {0};
int main() {
int n, k, i, j;
scanf("%d%d", &n, &k);
for (i = 1; i <= k; i++) scanf("%d", &a[i]), b[a[i]] = 1;
for (i = 1; i <= k; i++) {
int q = n;
printf("%d ", a[i]);
q--;
for (j = 1; j <= n * k; j++)
if (q > 0 && !b[j]) {
b[j] = 1;
printf("%d ", j);
q--;
}
puts("");
}
return 0;
}
| 900 | CPP |
a = list(map(int, input().split()))
print ("-1" if int(sum(a)%5)!=0 or int(sum(a)/5)==0 else int(sum(a)/5)) | 1,100 | PYTHON3 |
s = input()
li=''
i=0
while(i<len(s)):
if s[i] == '.':
li+='0'
i+=1
elif len(s)>i+1:
if s[i] == '-':
if s[i+1] == '-':
li+='2'
else:
li+='1'
i+=2
print(li) | 800 | PYTHON3 |
import collections
for _ in range(int(input())):
n=int(input())
s=str(input())
d=collections.defaultdict(list)
v,l=[],[]
for i in range(n):
if i==0:
v.append(1)
d[1-int(s[i])].append(1)
grp=1
else:
if d[int(s[i])]:
k=d[int(s[i])].pop()
v.append(k)
d[1-int(s[i])].append(k)
else:
v.append(grp+1)
d[1-int(s[i])].append(grp+1)
grp+=1
print(grp)
print(*v)
| 1,500 | PYTHON3 |
#*****DO NOT COPY*****
#F
#U ___ ___ ___ ___ ___ ___ _____
#C / /\ ___ / /\ ___ /__/\ / /\ / /\ / /\ / /::\
#K / /::\ / /\ / /:/_ / /\ \ \:\ / /::\ / /::\ / /:/_ / /:/\:\
# / /:/\:\ / /:/ / /:/ /\ / /::\ \ \:\ / /:/\:\ / /:/\:\ / /:/ /\ / /:/ \:\
#Y / /:/~/:/ /__/::\ / /:/ /::\ / /:/\:\ ___ \ \:\ / /:/~/::\ / /:/~/:/ / /:/ /:/_ /__/:/ \__\:|
#O /__/:/ /:/ \__\/\:\__ /__/:/ /:/\:\ / /:/~/::\ /__/\ \__\:\ /__/:/ /:/\:\ /__/:/ /:/___ /__/:/ /:/ /\ \ \:\ / /:/
#U \ \:\/:/ \ \:\/\ \ \:\/:/~/:/ /__/:/ /:/\:\ \ \:\ / /:/ \ \:\/:/__\/ \ \:\/:::::/ \ \:\/:/ /:/ \ \:\ /:/
# \ \::/ \__\::/ \ \::/ /:/ \ \:\/:/__\/ \ \:\ /:/ \ \::/ \ \::/~~~~ \ \::/ /:/ \ \:\/:/
#A \ \:\ /__/:/ \__\/ /:/ \ \::/ \ \:\/:/ \ \:\ \ \:\ \ \:\/:/ \ \::/
#L \ \:\ \__\/ /__/:/ \__\/ \ \::/ \ \:\ \ \:\ \ \::/ \__\/
#L \__\/ \__\/ \__\/ \__\/ \__\/ \__\/
#
#
#*****DO NOT COPY*****
def solve(n , arr):
for i in range(1 ,n):
if arr[i][0] < arr[i][1]:
return "NO"
if arr[i][0] > arr[i - 1][0]:
if arr[i][1] >= arr[i-1][1]:
if arr[i][0] - arr[i-1][0] >= arr[i][1] - arr[i-1][1]:
pass
else:
return "NO"
else:
return "NO"
elif arr[i][0] == arr[i-1][0]:
if arr[i][1] == arr[i-1][1]:
pass
else:
return "NO"
else:
return "NO"
if arr[0][0] < arr[0][1]:
return "NO"
return "YES"
for _ in range(int(input())):
n = int(input())
arr = []
for i in range(n):
a = list(map(int , input().split()))
arr.append(a)
print(solve(n , arr)) | 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
set<char> st;
char *s = new char[n];
char str;
for (int i = 0; i < n; i++) {
cin >> *(s + i);
str = tolower(*(s + i));
st.insert(str);
}
if (st.size() == 26) {
cout << "YES\n";
} else {
cout << "NO\n";
}
return 0;
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long arr = 1e5 + 22;
const long long ARR = 2e3 + 22;
const long long inf = 1e16 + 22;
const long long md = 1e9 + 7;
const long long p = 31;
const long long b_base = 1e6 + 1;
vector<long long> vec;
signed main() {
long long n, a, b;
long long sum = 0;
long long f = 0;
cin >> n >> a >> b;
for (long long i = 1; i <= n; i++) {
long long q;
cin >> q;
if (i == 1)
f = q;
else
vec.push_back(q);
sum += q;
}
long long kek = f * a;
sort(vec.begin(), vec.end());
reverse(vec.begin(), vec.end());
long long i = 0;
while (1.0 * kek / sum < b) {
sum -= vec[i];
i++;
}
cout << i;
}
| 1,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e6, mod = 1e9 + 7;
long long n, m, a, b, jc[2222222], injc[2222222], cur, ans;
long long binpow(long long a, long long t) {
if (t < 0) return binpow(a, (-t) * (mod - 2));
long long res = 1, p = a;
for (long long i = t; i; i >>= 1) {
if (i & 1) res = res * p % mod;
p = p * p % mod;
}
return res;
}
void Init() {
jc[0] = 1;
for (long long i = 1; i <= maxn; i++) {
jc[i] = jc[i - 1] * i % mod;
}
injc[maxn] = binpow(jc[maxn], mod - 2);
for (long long i = maxn - 1; i >= 0; i--)
injc[i] = injc[i + 1] * (i + 1) % mod;
}
long long C(long long n, long long k) {
if (n < k) return 0;
return (jc[n] * injc[k] % mod) * injc[n - k] % mod;
}
int main() {
cin >> n >> m >> a >> b;
Init();
for (long long i = 1; i < n && i <= m; i++) {
cur = C(m - 1, i - 1) * binpow(m, n - i - 1) % mod;
cur = cur * binpow(n, n - i - 2) % mod;
cur = cur * (i + 1) % mod;
cur = cur * C(n - 2, i - 1) % mod * jc[i - 1] % mod;
ans = (ans + cur) % mod;
}
cout << ans << endl;
return 0;
}
| 2,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
string a, b, c;
int main() {
cin >> a >> b >> c;
if (a[0] == c[2] && a[1] == c[1] && a[2] == c[0] &&
(b == ".X." || b == "XXX" || b == "X.X" || b == "...")) {
cout << "YES";
} else {
cout << "NO";
}
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > g[int(1e5)];
int main() {
int n, m, k;
cin >> n >> m >> k;
int x = 0;
for (int i = 1; i <= n; i++) {
if (i & 1) {
for (int j = 1; j <= m; j++) {
if (g[x].size() == 2 && x < k - 1) x++;
g[x].push_back({i, j});
}
} else {
for (int j = m; j > 0; j--) {
if (g[x].size() == 2 && x < k - 1) x++;
g[x].push_back({i, j});
}
}
}
for (int i = 0; i < k; i++) {
cout << g[i].size() << " ";
for (int j = 0; j < g[i].size(); j++) {
cout << g[i][j].first << " " << g[i][j].second << " ";
}
cout << endl;
}
}
| 1,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a >> b;
if (a.size() != b.size()) {
cout << "NO";
return 0;
}
int n = a.size();
vector<int> p;
for (int i = 0; i < n; i++) {
if (a[i] != b[i]) {
p.push_back(i);
if (p.size() > 2) {
cout << "NO";
return 0;
}
}
}
if (p.size() == 1) {
cout << "NO";
} else if (p.size() == 2) {
if (a[p[0]] == b[p[1]] && b[p[0]] == a[p[1]])
cout << "YES";
else
cout << "NO";
} else
cout << "YES";
return 0;
}
| 1,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-12;
const int INF = 1e9 + 10;
template <typename T>
using MinPQ = priority_queue<T, vector<T>, greater<T>>;
template <class T>
struct FenwickTree {
int n;
vector<T> a;
vector<T> f;
FenwickTree(int n = 0) { Reset(n); }
void Reset(int n) {
this->n = n;
a.assign(n + 1, 0);
f.assign(n + 1, 0);
}
T Query(int i) {
assert(i >= 0 && i <= n);
T r = 0;
for (; i > 0; i -= LowBit(i)) {
r += f[i];
}
return r;
}
T Query(int l, int r) {
T res = Query(r);
if (l > 1) res -= Query(l - 1);
return res;
}
T QueryAll() { return Query(n); }
void Add(int i, T x) {
assert(i >= 1 && i <= n);
a[i] += x;
for (; i <= n; i += LowBit(i)) {
f[i] += x;
}
}
void Set(int i, T x) { Add(i, x - a[i]); }
private:
static inline int LowBit(int i) { return i & -i; }
};
template <class T>
struct Rmq {
int n;
vector<T> a;
vector<vector<int>> f;
vector<int> f_idx;
Rmq(const vector<T>& a = {}) { Reset(a); }
void Reset(const vector<T>& a) {
this->a = a;
n = int((a).size());
vector<int> cur(n);
iota((cur).begin(), (cur).end(), 0);
f.clear();
f.push_back(move(cur));
if (n == 0) return;
for (int p = 1;; ++p) {
int len = 1 << p;
int len2 = len >> 1;
cur.resize(n - len + 1);
for (int i = 0; i < int((cur).size()); ++i) {
int u1 = f[p - 1][i], u2 = f[p - 1][i + len - len2];
if (a[u1] < a[u2])
cur[i] = u1;
else
cur[i] = u2;
}
f.push_back(move(cur));
if ((len << 1) >= n) break;
}
f_idx.resize(n + 1);
f_idx[0] = 0;
for (int i = 1; i <= n; ++i) {
int p = f_idx[i >> 1];
while (1 << (p + 1) < i) ++p;
f_idx[i] = p;
}
}
int QueryIndex(int l, int r) {
if (l > r) swap(l, r);
int len = r - l + 1;
int p = f_idx[len];
int u1 = f[p][l], u2 = f[p][r - (1 << p) + 1];
if (a[u1] < a[u2]) return u1;
return u2;
}
};
int n;
vector<int> a;
vector<pair<int, int>> edges;
vector<vector<int>> child;
vector<int> par;
vector<int> depth;
vector<int> e_seq;
vector<pair<int, int>> e_pos;
vector<int> u_seq;
vector<int> u_pos;
struct EdgeStatus {
set<int> updated;
};
vector<EdgeStatus> child_edge_status;
int Cost(int ei) {
assert(ei >= 0 && ei < n - 1);
int u = edges[ei].first, v = edges[ei].second;
return max(abs(a[u] + a[v]), abs(a[u] - a[v]));
}
void Dfs(int u, int pu) {
u_pos[u] = int((u_seq).size());
u_seq.push_back(u);
for (int i = 0; i < int((child[u]).size()); ++i) {
int ei = child[u][i];
auto& e = edges[ei];
if (e.first == pu) {
par[u] = ei;
child[u][i] = child[u].back();
child[u].pop_back();
i--;
continue;
}
if (e.second == u) swap(e.first, e.second);
depth[e.second] = depth[u] + 1;
e_pos[ei].first = int((e_seq).size());
e_seq.push_back(ei);
Dfs(e.second, u);
e_pos[ei].second = int((e_seq).size());
e_seq.push_back(ei);
u_seq.push_back(u);
}
}
void Solve() {
int q;
scanf("%d%d", &n, &q);
a.resize(n);
for (auto& x : (a)) scanf("%d", &x);
edges.resize(n - 1);
child.assign(n, {});
for (int i = 0; i < n - 1; ++i) {
auto& e = edges[i];
scanf("%d%d", &e.first, &e.second);
e.first--;
e.second--;
child[e.first].push_back(i);
child[e.second].push_back(i);
}
e_seq.clear();
e_seq.reserve(n * 2);
e_pos.resize(n - 1);
u_seq.clear();
u_seq.reserve(n * 2);
u_pos.resize(n);
par.resize(n);
depth.resize(n);
depth[0] = 0;
par[0] = -1;
Dfs(0, -1);
vector<int> depth_seq(int((u_seq).size()));
for (int i = 0; i < int((u_seq).size()); ++i) {
depth_seq[i] = depth[u_seq[i]];
}
Rmq<int> rmq(depth_seq);
vector<int> cost_seq(int((e_seq).size()));
for (int i = 0; i < n - 1; ++i) {
int w = Cost(i);
cost_seq[e_pos[i].first] = w;
cost_seq[e_pos[i].second] = -w;
}
FenwickTree<long long> cost_ft;
cost_ft.Reset(int((cost_seq).size()));
for (int i = 0; i < int((cost_seq).size()); ++i) {
cost_ft.Set(i + 1, cost_seq[i]);
}
child_edge_status.resize(n);
for (int i = 0; i < n; ++i) {
child_edge_status[i].updated =
set<int>((child[i]).begin(), (child[i]).end());
}
set<int> e_seq_idx_to_update;
auto UpdateEdge = [&](int ei) {
int w = Cost(ei);
cost_ft.Set(e_pos[ei].first + 1, w);
cost_ft.Set(e_pos[ei].second + 1, -w);
int u = edges[ei].first;
child_edge_status[u].updated.insert(ei);
};
auto Query = [&](int u, int v) -> long long {
int up = u_pos[u], vp = u_pos[v];
assert(up <= vp);
if (up == vp) return 0;
vp--;
auto it = e_seq_idx_to_update.lower_bound(up);
while (it != e_seq_idx_to_update.end() && *it <= vp) {
UpdateEdge(e_seq[*it]);
it = e_seq_idx_to_update.erase(it);
}
return cost_ft.Query(up + 1, vp + 1);
};
while (q--) {
int op, u, v;
scanf("%d%d%d", &op, &u, &v);
--u;
if (op == 1) {
a[u] = v;
for (auto& ei : (child_edge_status[u].updated)) {
e_seq_idx_to_update.insert(e_pos[ei].first);
e_seq_idx_to_update.insert(e_pos[ei].second);
}
child_edge_status[u].updated.clear();
if (par[u] >= 0) {
int ei = par[u];
int pu = edges[ei].first;
child_edge_status[pu].updated.erase(ei);
e_seq_idx_to_update.insert(e_pos[ei].first);
e_seq_idx_to_update.insert(e_pos[ei].second);
}
} else {
--v;
int lca = u_seq[rmq.QueryIndex(u_pos[u], u_pos[v])];
42;
long long w = Query(lca, u) + Query(lca, v);
printf("%lld\n", w);
}
}
}
int main() {
int t = 1;
for (int i = 1; i <= t; ++i) {
Solve();
}
return 0;
}
| 2,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
string s;
long long dolars = 0, cents = 0, i;
void count() {
int dots = 0, j, l;
for (j = i; j < s.length(); ++j) {
if ((s[j] < '0' || s[j] > '9') && (s[j] != '.')) break;
if (s[j] == '.') ++dots;
}
l = j;
if (dots == 0) {
long long res = 0;
for (j = i; j < l; ++j) {
res *= 10;
res += s[j] - '0';
}
dolars += res;
} else {
if (s[l - 3] != '.') {
long long res = 0;
for (j = i; j < l; ++j) {
if (s[j] != '.') {
res *= 10;
res += s[j] - '0';
}
}
dolars += res;
} else {
long long res = 0;
for (j = i; j < l - 3; ++j) {
if (s[j] != '.') {
res *= 10;
res += s[j] - '0';
}
}
dolars += res;
res = 0;
for (j = l - 2; j < l; ++j) {
res *= 10;
res += s[j] - '0';
}
cents += res;
}
}
i = l;
}
int main() {
getline(cin, s);
for (i = 0; i < s.length(); ++i) {
if (s[i] >= '0' && s[i] <= '9') count();
}
s = "";
dolars += cents / 100;
if (dolars != 0) {
while (dolars != 0) {
s.insert(0, 1, (dolars % 10) + '0');
dolars /= 10;
}
for (i = s.length() - 1; i > 0; --i) {
++dolars;
if (dolars % 3 == 0) {
s.insert(i, 1, '.');
continue;
}
}
} else
s = "0";
for (i = 0; i < s.length(); ++i) printf("%c", s[i]);
if (cents % 100 != 0)
printf(".%I64d%I64d ", (cents % 100) / 10, (cents % 100) % 10);
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
int const N = 123456;
struct edge {
int u, v, w;
} e[N];
int f[N], a[N], n, m;
void init() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
f[i] = -1;
scanf("%d", &a[i]);
}
for (int i = 0; i < m; ++i) {
scanf("%d%d", &e[i].u, &e[i].v);
e[i].w = min(a[e[i].u], a[e[i].v]);
}
}
bool cmp(edge const &a, edge const &b) { return a.w > b.w; }
int fat(int a) { return f[a] < 0 ? a : f[a] = fat(f[a]); }
int main() {
init();
sort(e, e + m, cmp);
double ans = 0;
int p, q;
for (int i = 0; i < m; ++i) {
p = fat(e[i].u);
q = fat(e[i].v);
if (p == q) continue;
ans += (double)e[i].w * f[p] * f[q];
f[p] += f[q];
f[q] = p;
}
printf("%.6lf", 2 * ans / (n * 1.0 * (n - 1)));
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 200020;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
vector<int> c(N, 0);
for (int x, i = 0; i < n; i++) {
cin >> x;
c[x]++;
}
int res = 0, s = -1, e = -1;
for (int x, y = 1; y < N;) {
while (y < N and c[y] == 0) {
y++;
}
x = y;
int cnt = c[y];
y++;
while (y < N and c[y] >= 2) {
cnt += c[y];
y++;
}
if (c[y] > 0) {
cnt += c[y];
}
if (cnt > res) {
res = cnt;
s = x;
if (c[y] == 0) {
e = y - 1;
} else {
e = y;
}
}
}
cout << res << '\n';
for (int p = 1; p <= c[s]; p++) {
cout << s << ' ';
}
for (int r = s + 1; r <= e; r++) {
for (int p = 1; p < c[r]; p++) {
cout << r << ' ';
}
}
for (int r = e; r > s; r--) {
cout << r << (r == s - 1 ? '\n' : ' ');
}
}
| 2,000 | CPP |
for _ in range(int(input())):
n,m= map(int,(input().split()))
l1=list(map(int,(input().split())))
l=[[l1[i],-i] for i in range(m)]
l.sort()
s=0
for i in range(m):
for j in range(m):
if -l[j][1]<i:
s+=1
elif -l[j][1]==i:
break
print(s)
| 1,100 | PYTHON3 |
n,k=map(int,input().split())
l=list(map(int,input().split()))
ans=0
i=0
n-=1
while(l[i]<=k and i<n):
i+=1
ans+=1
while(n>=i and l[n]<=k):
n-=1
ans+=1
print(ans)
| 800 | PYTHON3 |
a=int(input())
for i in range(a):
x,y,z=map(int,input().split())
ans=[x,y,z]
ans.sort()
total=0
total+=ans[0]
if(ans[2]-ans[1]>=ans[0]):
ans[2]-=ans[0]
print(ans[0]+min(ans[1],ans[2]))
else:
k=ans[0]
ans[0]=ans[0]-(ans[2]-ans[1])
ans[2]=ans[1]
m=ans[0]//2
ans[1]-=m
ans[2]-=ans[0]-m
print(k+min(ans[1],ans[2]))
| 1,100 | PYTHON3 |
import sys
import math
#to read string
get_string = lambda: sys.stdin.readline().strip()
#to read list of integers
get_list = lambda: list( map(int,sys.stdin.readline().strip().split()) )
#to read non spaced string and elements are integers to list of int
get_intList_from_str = lambda: list(map(int,list(sys.stdin.readline().strip())))
#to read non spaced string and elements are character to list of character
get_strList_from_str = lambda: list(sys.stdin.readline().strip())
#to read integers
get_int = lambda: int(sys.stdin.readline().strip())
#to print faster
pt = lambda x: sys.stdout.write(str(x))
#--------------------------------WhiteHat010--------------------------------------#
a = get_int()
votes = get_list()
s = sum(votes)
n = math.ceil( (2*s + 1)/a )
print(max(max(votes),n)) | 800 | PYTHON3 |
n = list(map(int, input().split()))
a = n[0]
b = n[1]
i = 0
while a <= b:
i += 1
a *= 3
b *= 2
print(i)
| 800 | PYTHON3 |
s = input()
for i in range(s.count('WUB')):
s = s.replace("WUB"," ")
print(s) | 900 | PYTHON3 |
n=int(input())
for i in range(n):
x=list(map(int,input().rstrip().split()))
y=list(map(int,input().rstrip().split()))
z=min(y)+x[1]
if z>=max(y)-x[1]:
print(z)
else:
print(-1)
| 900 | PYTHON3 |
for i in range(int(input())):
a=input()
b=a.count('L')
c=a.count('R')
d=a.count('U')
e=a.count('D')
if b>c:
b=c
else:
c=b
if d>e:
d=e
else:
e=d
if b==0 and e!=0:
print(2)
print("UD")
elif e==0 and b!=0:
print(2)
print("LR")
else:
r = ""
t = ""
for k in range(b):
r += "L"
t += "R"
for j in range(e):
r += "U"
t += "D"
r = r + t
print(len(r))
print(r)
| 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
vector<int> V[N];
vector<pair<int, int> > edges;
vector<int> H, T;
int n, m, h, t;
int U, VV;
int used[N];
int check[N];
int trn;
bool solve(int u, int v) {
if (V[u].size() < h + 1 || V[v].size() < t + 1) {
} else if (V[u].size() > h + t) {
U = u;
VV = v;
for (int j = 0; j < t; j++) {
if (V[v][j] == u) {
t++;
continue;
}
T.push_back(V[v][j]);
used[V[v][j]] = 1;
}
for (int j = 0; j < V[u].size(); j++)
if (!used[V[u][j]] && h && V[u][j] != v) {
h--;
H.push_back(V[u][j]);
}
return true;
} else if (V[v].size() > h + t) {
U = u;
VV = v;
for (int j = 0; j < h; j++) {
if (V[u][j] == v) {
h++;
continue;
}
H.push_back(V[u][j]);
used[V[u][j]] = 1;
}
for (int j = 0; j < V[v].size(); j++)
if (!used[V[v][j]] && t && V[v][j] != u) {
t--;
T.push_back(V[v][j]);
}
return true;
} else {
vector<int> sirfH, sirfT, dono;
trn++;
for (int j = 0; j < V[u].size(); j++) check[V[u][j]] = trn;
for (int j = 0; j < V[v].size(); j++) {
if (check[V[v][j]] != trn && V[v][j] != u) sirfT.push_back(V[v][j]);
}
trn++;
for (int j = 0; j < V[v].size(); j++) check[V[v][j]] = trn;
for (int j = 0; j < V[u].size(); j++) {
if (check[V[u][j]] != trn && V[u][j] != v)
sirfH.push_back(V[u][j]);
else if (V[u][j] != v)
dono.push_back(V[u][j]);
}
int x = h - (int)sirfH.size();
x = max(x, 0);
int y = t - (int)sirfT.size();
y = max(y, 0);
if (x + y <= dono.size()) {
U = u;
VV = v;
for (int j = 0; j < min(h, (int)sirfH.size()); j++) H.push_back(sirfH[j]);
for (int j = 0; j < min(t, (int)sirfT.size()); j++) T.push_back(sirfT[j]);
int idx = 0;
while (H.size() < h) {
H.push_back(dono[idx]);
idx++;
}
while (T.size() < t) {
T.push_back(dono[idx]);
idx++;
}
return true;
}
}
return false;
}
int main() {
scanf("%d%d%d%d", &n, &m, &h, &t);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
V[x].push_back(y);
V[y].push_back(x);
edges.push_back(make_pair(x, y));
}
U = VV = -1;
for (int i = 0; i < edges.size(); i++) {
int u = edges[i].first;
int v = edges[i].second;
if (solve(u, v)) break;
if (solve(v, u)) break;
}
if (U == -1) {
printf("NO\n");
} else {
printf("YES\n");
printf("%d %d\n", U, VV);
for (int i = 0; i < H.size(); i++) printf("%d ", H[i]);
printf("\n");
for (int i = 0; i < T.size(); i++) printf("%d ", T[i]);
printf("\n");
}
return 0;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
const double EPS = 1e-7;
const int MAX = 100005;
int p[MAX];
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
if (n % 4 > 1)
cout << -1 << endl;
else {
for (int i = 1; i <= n / 2; i += 2) {
p[i] = i + 1;
p[i + 1] = n - i + 1;
p[n - i + 1] = n - i;
p[n - i] = i;
}
if (n % 4 == 1) p[n / 2 + 1] = n / 2 + 1;
for (int i = 1; i <= n; i++) cout << p[i] << " ";
cout << endl;
}
return 0;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int total;
cin >> total;
int buttons;
cin >> buttons;
vector<int> list;
for (int i = 0; i < buttons; i++) {
int temp;
cin >> temp;
list.push_back(temp);
}
for (int i = 1; i <= total; i++) {
for (int j = 0; j < list.size(); j++) {
if (list[j] <= i) {
cout << list[j] << " ";
break;
}
}
}
return 0;
}
| 900 | CPP |
from sys import stdin
times = stdin.readline().rstrip().split(' ')
times = [int(t) for t in times]
wrong_submissions = stdin.readline().rstrip().split(' ')
wrong_submissions = [int(t) for t in wrong_submissions]
hacks = stdin.readline().rstrip().split(' ')
hacks = [int(t) for t in hacks]
score = 100*hacks[0] - 50*hacks[1]
for i in range(5):
x = 500*(i+1)
score += max(0.3*x, (1 - times[i]/250)*x - 50*wrong_submissions[i])
print(int(score))
| 1,000 | PYTHON3 |
n=int(input())
while n>0:
n-=1
s=int(input())
a=180-s
if 360%a==0:
print('YES')
else:
print('NO')
| 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, 1, 0, -1, -1, -1, 0, 1};
int dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
int di[] = {1, -1, 0, 0};
int dj[] = {0, 0, 1, -1};
void file() {}
int n, k, arr[10001], mx;
double s, q;
int can(double mid) {
double res = 0;
for (int i = 0; i < n; i++) {
if (arr[i] > mid) {
q = ((arr[i] - mid) - ((arr[i] - mid) * (k / 100.0)));
res += q;
} else
res -= (mid - arr[i]);
}
return res > 0;
}
int main() {
file();
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
mx = max(mx, arr[i]);
}
double st = 0, en = mx, mid, ans;
for (int i = 0; i < 80; i++) {
mid = (st + en) / 2.0;
if (can(mid))
st = mid, ans = mid;
else
en = mid;
}
printf("%.9lf", ans);
}
| 1,600 | CPP |
t = int(input())
for i in range(t):
n = int(input())
l = list(map(int, input().split(' ')))
decreasing = True
for j in range(1,n):
if l[j] >= l[j-1]:
decreasing = False
break
print('NO' if decreasing else 'YES')
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, pos, l, r;
scanf("%d", &n);
scanf("%d", &pos);
scanf("%d", &l);
scanf("%d", &r);
int cnt = 0;
if (pos < l) {
cnt += (l - pos) + 1;
if (r < n) cnt += (r - l) + 1;
} else if (pos > r) {
cnt += (pos - r) + 1;
if (l > 1) cnt += (r - l) + 1;
} else {
if (l == 1 && r == n) {
cnt = 0;
} else if (l == 1) {
cnt += (r - pos) + 1;
} else if (r == n) {
cnt += (pos - l) + 1;
} else {
int xx = min((pos - l), (r - pos));
cnt += 2;
cnt += xx;
cnt += (r - l);
}
}
printf("%d\n", cnt);
}
| 1,300 | CPP |
#872
for _ in range(int(input())):
n=int(input())
a=[int(x)for x in input().split()]
a.sort()
flag=0
for i in range(1,n):
if(a[i]-a[i-1]>1):
flag=1
break
if(flag):
print("NO")
else:
print("YES")
| 800 | PYTHON3 |
s = input()
p = input()
ans = ''
cnt = 0
for i in range(len(s)):
if s[i] == p[i] == '0':
ans += '1'
elif s[i] == p[i] == '1':
ans += '0'
elif s[i] != p[i]:
if cnt % 2 == 0:
ans += p[i]
else:
ans += s[i]
cnt += 1
if cnt % 2 == 1:
print('impossible')
else:
print(ans) | 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
int n, l;
const double eps = 1e-9;
int cmp(double a, double b) {
if (fabs(a - b) < eps) return 0;
return a > b ? 1 : -1;
}
int x[1005], b[1005];
double dp[1005];
int path[1005];
bool check(double r) {
for (int i = 1; i <= n; i++) {
dp[i] = DBL_MAX;
path[i] = 0;
}
dp[0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < i; j++) {
double c = sqrt(abs(x[i] - x[j] - l)) - b[i] * r;
if (dp[j] + c < dp[i]) {
dp[i] = dp[j] + c;
path[i] = j;
}
}
}
return cmp(dp[n], 0) <= 0;
}
int main() {
scanf("%d %d", &n, &l);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &x[i], &b[i]);
}
double lo = 0;
double hi = 1000000;
double ans = 0;
for (int it = 0; it < 100; it++) {
double mid = (lo + hi) / 2;
if (check(mid)) {
ans = mid;
hi = mid;
} else
lo = mid;
}
check(ans);
vector<int> v;
int x = n;
while (x != 0) {
v.push_back(x);
x = path[x];
}
reverse(v.begin(), v.end());
for (auto &x : v) {
printf("%d ", x);
}
puts("");
return 0;
}
| 2,300 | CPP |
import os
import sys
from math import *
from collections import *
# from fractions import *
# from heapq import*
from bisect import *
from io import BytesIO, IOBase
def vsInput():
sys.stdin = open("input.txt", "r")
sys.stdout = open("output.txt", "w")
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
ALPHA = "abcdefghijklmnopqrstuvwxyz/"
M = 1000000007
EPS = 1e-6
def Ceil(a, b):
return a // b + int(a % b > 0)
def value():
return tuple(map(int, input().split()))
def array():
return [int(i) for i in input().split()]
def Int():
return int(input())
def Str():
return input()
def arrayS():
return [i for i in input().split()]
# -------------------------code---------------------------#
n = int(input())
a = list(map(int, input().split(" ")))
ans = int(1e100)
for y in range(2 * n + 2):
for x in range(n):
ans = min(ans, abs(sum(a[:x]) - sum(a[x:])))
a = a[-1:] + a[:-1]
print(ans)
| 1,200 | PYTHON3 |
#include <bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define fir first
#define sec second
using namespace std;
typedef long long ll;
const int N = 3e5 + 5;
vector<pair<int, int>> G[N];
int n, m, x, fa[N], ans[N], hd, tl;
bool vis[N];
ll sum, a[N];
void Dfs(int u, int p) {
vis[u] = true;
for(pair<int, int> e : G[u]) {
int v = e.fir, id = e.sec;
if(vis[v]) {
continue;
}
fa[v] = u;
Dfs(v, id);
}
if(u == 1) {
return;
}
if(a[u] >= x) {
a[fa[u]] += a[u] - x;
ans[++hd] = p;
} else {
ans[--tl] = p;
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> x;
for(int i = 1; i <= n; i++) {
cin >> a[i];
sum += a[i];
}
if(sum < (ll)x * (n - 1)) {
cout << "NO\n";
return 0;
}
for(int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
G[u].pb(mp(v, i));
G[v].pb(mp(u, i));
}
hd = 0;
tl = n;
Dfs(1, 0);
cout << "YES\n";
for(int i = 1; i < n; i++) {
cout << ans[i] << endl;
}
return 0;
} | 2,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long a, b;
cin >> a >> b;
if (b - a > 5) {
cout << 0 << "\n";
} else {
long long val = 1;
for (long long j = a + 1; j <= b; j++) {
val *= (j % 10);
val %= 10;
}
cout << val << "\n";
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
solve();
}
| 1,100 | CPP |
__author__ = 'Utena'
n=int(input())
m=[0]*366
f=[0]*366
for i in range(n):
g,a,b=input().split()
a,b=int(a),int(b)
if g=='F':
for i in range(a-1,b):
f[i]+=1
elif g=='M':
for i in range(a-1,b):
m[i]+=1
t=0
for i in range(366):
temp=min(f[i],m[i])
if temp>t:t=temp
print(t*2) | 1,100 | PYTHON3 |
q=int(input())
l=[]
for i in range(0,q):
n=int(input())
l.append(n)
for i in l:
if i<4:
print(4-i)
else:
if i%2==0:
print(0)
else:
print(1)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t, k, d;
cin >> n >> t >> k >> d;
double a = (double)n / k;
int temp1 = ceil(a);
int value1 = t;
int value2 = t;
for (int i = 1; i < temp1; i++) {
value1 += t;
}
double b = (double)k * d / t;
int temp2 = ceil(b);
int temp4;
if (n > temp2) {
double temp3 = (n - temp2) / (double)k;
temp4 = ceil(temp3) - 1;
for (int i = 1; i < temp4; i++) {
value2 += t;
}
}
if (value1 > value2 + d) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
| 1,100 | CPP |
def intInput():
global lineArr
lineArr = input().split(' ')
for i in range(len(lineArr)):
lineArr[i]=int(lineArr[i])
intInput()
n = lineArr[0]
k = lineArr[1]
intInput()
c = 0
for i in lineArr:
if i >= lineArr[k-1] and i>0:
c+=1
print(c)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct T {
ll l, r;
int id;
};
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<T> v;
for (int i = 0; i < n; ++i) {
ll x, y;
cin >> x >> y;
v.push_back({x, y, i});
}
sort((v).begin(), (v).end(), [](const T &a, const T &b) {
if (a.l == b.l) {
return a.r > b.r;
}
return a.l < b.l;
});
set<pair<ll, int>> m;
for (auto &i : v) {
if (m.empty()) {
m.insert({-i.r, i.id});
continue;
}
auto &cur = *m.begin();
if (-cur.first >= i.r) {
cout << i.id + 1 << ' ' << cur.second + 1 << endl;
return 0;
}
m.insert({-i.r, i.id});
}
cout << "-1 -1\n";
return 0;
}
| 1,500 | CPP |
import sys
for _ in range(1):
n=int(input())
l=list(map(int,input().split()))
if n==1:
print(-1)
break
i=l.index(min(l))
l.sort()
if l[0]==sum(l[1:]):
print(-1)
else:
print(1)
print(i+1)
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, t, r;
cin >> m >> t >> r;
int i, j, k;
int ghost_time[1000];
int burning[1000];
for (i = 0; i < m; i++) cin >> ghost_time[i];
int count = 0;
memset(burning, 0, sizeof(burning));
if (r > t) {
cout << "-1\n";
return 0;
}
for (i = 0; i < m; i++) {
if (burning[ghost_time[i] + 400] < r) {
for (j = ghost_time[i] - 1; burning[ghost_time[i] + 400] < r; j--) {
count++;
for (k = j + 1; k <= j + t; k++) burning[k + 400]++;
}
}
}
cout << count << "\n";
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int t;
int main() {
cin >> t;
while (t--) {
int x, y, z;
cin >> x >> y >> z;
if (y == 0) {
if (x != 0) {
for (int i = 1; i <= x + 1; i++) cout << '0';
}
if (z != 0) {
for (int i = 1; i <= z + 1; i++) cout << '1';
}
cout << '\n';
continue;
}
if (x == 0) {
for (int i = 1; i <= z + 1; i++) cout << '1';
for (int i = 1; i <= y; i++) cout << (i + 1) % 2;
cout << '\n';
continue;
}
if (z == 0) {
for (int i = 1; i <= x + 1; i++) cout << '0';
for (int i = 1; i <= y; i++) cout << i % 2;
cout << '\n';
continue;
}
for (int i = 1; i <= x + 1; i++) cout << '0';
for (int i = 1; i <= z + 1; i++) cout << '1';
for (int i = 1; i <= y - 1; i++) cout << (i + 1) % 2;
cout << '\n';
}
}
| 1,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, q, h, m, u, z[10000], t;
string s;
void fp(long long l) {
long long k = 1;
for (long long i = 1; (1 << i) <= n + 1; i++) {
if (l % (k * 2) == (k)) {
h = i;
m = (l - (k)) / (2 * k);
return;
}
k = k * 2;
}
}
void go(long long p) {
if (p == s.size()) return;
if (h == 1 && s[p] != 'U') {
go(p + 1);
return;
}
if (h == t && s[p] == 'U') {
go(p + 1);
return;
}
if (s[p] == 'L') {
h--;
m = 2 * m;
}
if (s[p] == 'R') {
h--;
m = 2 * m + 1;
}
if (s[p] == 'U') {
h++;
m = m / 2;
}
go(p + 1);
}
int main() {
cin >> n >> q;
t = 0;
long long k = 1;
while (k < n + 1) {
z[t + 1] = 2 * k;
k = 2 * k;
t++;
}
for (long long i = 0; i < q; i++) {
cin >> u >> s;
fp(u);
go(0);
cout << z[h] * m + z[h] / 2 << endl;
}
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 4004, Kmx = 80;
template <typename T>
void pfill(T* pst, const T* ped, T val) {
for (; pst != ped; *(pst++) = val)
;
}
void exgcd(int a, int b, int& x, int& y) {
if (!b) {
x = 1, y = 0;
} else {
exgcd(b, a % b, y, x);
y -= (a / b) * x;
}
}
int inv(int a, int n) {
int x, y;
exgcd(a, n, x, y);
return (x < 0) ? (x + n) : (x);
}
const int Mod = 998244353;
template <const int Mod = ::Mod>
class Z {
public:
int v;
Z() : v(0) {}
Z(int x) : v(x) {}
Z(long long x) : v(x % Mod) {}
friend Z operator+(const Z& a, const Z& b) {
int x;
return Z(((x = a.v + b.v) >= Mod) ? (x - Mod) : (x));
}
friend Z operator-(const Z& a, const Z& b) {
int x;
return Z(((x = a.v - b.v) < 0) ? (x + Mod) : (x));
}
friend Z operator*(const Z& a, const Z& b) { return Z(a.v * 1ll * b.v); }
friend Z operator~(const Z& a) { return inv(a.v, Mod); }
friend Z operator-(const Z& a) { return Z(0) - a; }
Z& operator+=(Z b) { return *this = *this + b; }
Z& operator-=(Z b) { return *this = *this - b; }
Z& operator*=(Z b) { return *this = *this * b; }
friend bool operator==(const Z& a, const Z& b) { return a.v == b.v; }
};
Z<> qpow(Z<> a, int p) {
Z<> rt = Z<>(1), pa = a;
for (; p; p >>= 1, pa = pa * pa) {
if (p & 1) {
rt = rt * pa;
}
}
return rt;
}
int n1, n2, K;
Z<> comb[Kmx][Kmx];
Z<> f[Kmx][N], g[Kmx][N];
vector<Z<> > _f[Kmx][N], _g[Kmx][N];
vector<int> Tr1[N], Tr2[N];
vector<int> Gi1[N], Gi2[N];
template <vector<int> G[], vector<int> Gi[], Z<> f[][N], vector<Z<> > g[][N]>
void solve(int n) {
static Z<> tmp[Kmx];
for (int i = 1; i <= n; i++) {
f[0][i] = 1;
g[0][i].resize(G[i].size(), Z<>(1));
}
for (int i = 1; i <= K; i++) {
for (int p = 1; p <= n; p++) {
for (int k = 0; k < i; k++) {
for (int j = 0, e; j < (signed)G[p].size(); j++) {
e = G[p][j];
f[i][p] += f[k][p] * g[i - k - 1][e][Gi[p][j]];
}
}
g[i][p].resize(G[p].size(), Z<>(0));
pfill(tmp, tmp + i, Z<>(0));
for (int k = 0; k < i; k++) {
for (int j = 0, e; j < (signed)G[p].size(); j++) {
e = G[p][j];
tmp[k] += g[k][e][Gi[p][j]];
}
}
for (int j = 0, e; j < (signed)G[p].size(); j++) {
e = G[p][j];
for (int k = 0; k < i; k++) {
g[i][p][j] += g[i - k - 1][p][j] * (tmp[k] - g[k][e][Gi[p][j]]);
}
}
}
}
}
inline void init_binom(int n) {
comb[0][0] = 1;
for (int i = 1; i <= n; i++) {
comb[i][0] = comb[i][i] = 1;
for (int j = 1; j < i; j++) {
comb[i][j] = comb[i - 1][j - 1] + comb[i - 1][j];
}
}
}
int main() {
scanf("%d%d%d", &n1, &n2, &K);
if (K & 1) {
puts("0");
return 0;
}
K >>= 1;
for (int i = 1, u, v; i < n1; i++) {
scanf("%d%d", &u, &v);
Tr1[u].push_back(v);
Tr1[v].push_back(u);
Gi1[u].push_back((signed)Tr1[v].size() - 1);
Gi1[v].push_back((signed)Tr1[u].size() - 1);
}
for (int i = 1, u, v; i < n2; i++) {
scanf("%d%d", &u, &v);
Tr2[u].push_back(v);
Tr2[v].push_back(u);
Gi2[u].push_back((signed)Tr2[v].size() - 1);
Gi2[v].push_back((signed)Tr2[u].size() - 1);
}
solve<Tr1, Gi1, f, _f>(n1);
solve<Tr2, Gi2, g, _g>(n2);
init_binom(75);
Z<> ans = 0;
for (int i = 0; i <= K; i++) {
Z<> s1 = 0, s2 = 0;
for (int j = 1; j <= n1; j++) {
s1 += f[i][j];
}
for (int j = 1; j <= n2; j++) {
s2 += g[K - i][j];
}
ans += s1 * s2 * comb[K << 1][i << 1];
}
printf("%d\n", ans.v);
return 0;
}
| 2,900 | CPP |
#include <bits/stdc++.h>
const int MAXINT = 2147483640;
const long long MAXLL = 9223372036854775800LL;
const long long MAXN = 1000000;
const double pi = 3.1415926535897932384626433832795;
using namespace std;
long long ans = -MAXINT, n;
long long x1[300000];
long long x2[300000];
void check(long long xx) {
long long sum = 0, i;
for (long long i = xx; i < n; i++) {
sum += x2[i];
ans = max(sum, ans);
if (sum < 0) sum = 0;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
srand(time(0));
long long i, j;
cin >> n;
for (i = 1; i <= n; i++) cin >> x1[i];
for (i = 1; i < n; i++) {
x2[i] = abs(x1[i] - x1[i + 1]);
if (!(i & 1)) x2[i] *= -1;
}
check(1);
for (i = 2; i < n; i++) {
x2[i] = abs(x1[i] - x1[i + 1]);
if (i & 1) x2[i] *= -1;
}
check(2);
cout << ans << endl;
return 0;
}
| 1,600 | CPP |
a,b=map(int,input().split(":"))
d,e=map(int,input().split(":"))
if b-e<0 and a-d>0:
r=a-d-1
R=60+b-e
elif b-e<0 and a-d==0:
r=23
R=60+b-e
elif a-d<0 and b-e>=0:
r=24+a-d
R=b-e
elif a-d<0 and b-e<0:
r=24+a-d-1
R=60+b-e
else:
r=a-d
R=b-e
r=str(r)
R=str(R)
for i in range(2-len(r)):
r="0"+r
for i in range(2-len(R)):
R="0"+R
print(r+":"+R)
| 900 | PYTHON3 |
n,k = map(int,input().split())
l = n // k
if l % 2 != 0: print("YES")
else: print("NO") | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int x, int y) { return (x) ? gcd(y % x, x) : y; }
int main() {
int n, x, y;
cin >> n;
int d;
set<pair<int, int> > second;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &x, &y);
if (x == 0) continue;
d = gcd(x, y);
second.insert(make_pair(x / d, y / d));
}
cout << second.size() << endl;
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
int n, i, j, k, z, o;
bool b[105];
long long anti;
struct matrix {
int n, m;
long long mt[55][55];
} a;
matrix operator*(matrix a, matrix b) {
int i, j, k;
matrix ans;
for (i = 0; i < a.n; i++)
for (j = 0; j < b.m; j++)
for (k = ans.mt[i][j] = 0; k < a.m; k++)
ans.mt[i][j] = (ans.mt[i][j] + a.mt[i][k] * b.mt[k][j]) % 1000000007LL;
ans.n = a.n;
ans.m = b.m;
return ans;
}
long long pow(long long d, long long x) {
if (x == 0) return 1;
long long ret = pow(d, x >> 1);
ret = ret * ret % 1000000007LL;
if (x & 1) ret = ret * d % 1000000007LL;
return ret;
}
matrix pow(int x) {
if (x == 1) return a;
matrix ret = pow(x >> 1);
ret = ret * ret;
if (x & 1) ret = ret * a;
return ret;
}
inline long long min(long long a, long long b) { return a < b ? a : b; }
int main() {
for (scanf("%d%d", &n, &k), i = 0; i < n; i++) {
scanf("%d", &j);
b[i] = (j ? true : false);
if (b[i])
o++;
else
z++;
}
anti = pow(n * (n - 1), 1000000007LL - 2);
a.m = a.n = min(z, o) + 1;
for (i = 0; i <= min(z, o); i++) {
if (i != 0) a.mt[i - 1][i] = 2 * i * i * anti % 1000000007LL;
a.mt[i][i] =
(o * o + z * z - n + 2 * i * n - 4 * i * i) * anti % 1000000007LL;
if (i != min(z, o))
a.mt[i + 1][i] = 2 * (o - i) * (z - i) * anti % 1000000007LL;
}
matrix ggg = pow(k);
for (i = j = 0; i < z; i++)
if (b[i]) j++;
printf("%I64d\n", ggg.mt[0][j]);
return 0;
}
| 2,300 | CPP |
input()
prev, k, m = 0, 1, 1
for a in map(int, input().split()):
if a > 2 * prev:
k, m = 0, max(k, m)
prev, k = a, k + 1
print(max(k, m)) | 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
int main() {
int i, n;
long long a[100001];
cin >> n;
long long maxval;
int maxlen = 1;
int currmaxlen;
cin >> a[0];
maxval = a[0];
currmaxlen = 1;
for (i = 1; i < n; i++) {
cin >> a[i];
if (a[i] == maxval) {
if (currmaxlen > 0) {
currmaxlen++;
if (currmaxlen > maxlen) maxlen = currmaxlen;
} else {
currmaxlen = 1;
}
} else if (a[i] > maxval) {
maxlen = 1;
currmaxlen = 1;
maxval = a[i];
} else {
currmaxlen = -1;
}
}
cout << maxlen << endl;
}
| 1,100 | CPP |
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
#include <bits/stdc++.h>
#ifndef KXSORT_H__
#define KXSORT_H__
#include <iterator>
#include <algorithm>
namespace kx {
static const int kRadixBits = 10;
static const size_t kInsertSortThreshold = 256;
static const int kRadixMask = (1 << kRadixBits) - 1;
static const int kRadixBin = 1 << kRadixBits;
//================= HELPING FUNCTIONS ====================
template <class T>
struct RadixTraitsUnsigned {
static const int nBytes = sizeof(T);
int kth_byte (const T &x, int k) { return (x >> (kRadixBits * k)) & kRadixMask; }
bool compare(const T &x, const T &y) { return (x & ((1LL<<40)-1)) < (y & ((1LL<<40)-1)); }
};
template<class T>
struct RadixTraitsSigned {
static const int nBytes = sizeof(T);
static const T kMSB = T(0x80) << ((sizeof(T) - 1) * 8);
int kth_byte (const T &x, int k) {
return ((x ^ kMSB) >> (kRadixBits * k)) & kRadixMask;
}
bool compare(const T &x, const T &y) { return x < y; }
};
template <class RandomIt, class ValueType, class RadixTraits>
inline void insert_sort_core_(RandomIt s, RandomIt e, RadixTraits radix_traits)
{
for (RandomIt i = s + 1; i < e; ++i) {
if (radix_traits.compare(*i, *(i - 1))) {
RandomIt j;
ValueType tmp = *i;
*i = *(i - 1);
for (j = i - 1; j > s && radix_traits.compare(tmp, *(j - 1)); --j) {
*j = *(j - 1);
}
*j = tmp;
}
}
}
template <class RandomIt, class ValueType, class RadixTraits, int kWhichByte>
inline void radix_sort_core_(RandomIt s, RandomIt e, RadixTraits radix_traits)
{
RandomIt last_[kRadixBin + 1];
RandomIt *last = last_ + 1;
size_t count[kRadixBin] = {0};
for (RandomIt i = s; i < e; ++i) {
++count[radix_traits.kth_byte(*i, kWhichByte)];
}
last_[0] = last_[1] = s;
for (int i = 1; i < kRadixBin; ++i) {
last[i] = last[i-1] + count[i-1];
}
for (int i = 0; i < kRadixBin; ++i) {
RandomIt end = last[i-1] + count[i];
if (end == e) { last[i] = e; break; }
while (last[i] != end) {
ValueType swapper = *last[i];
int tag = radix_traits.kth_byte(swapper, kWhichByte);
if (tag != i) {
do {
std::swap(swapper, *last[tag]++);
} while ((tag = radix_traits.kth_byte(swapper, kWhichByte)) != i);
*last[i] = swapper;
}
++last[i];
}
}
if (kWhichByte > 0) {
for (int i = 0; i < kRadixBin; ++i) {
if (count[i] > kInsertSortThreshold) {
radix_sort_core_<RandomIt, ValueType, RadixTraits,
(kWhichByte > 0 ? (kWhichByte - 1) : 0)>
(last[i-1], last[i], radix_traits);
} else if (count[i] > 1) {
insert_sort_core_<RandomIt, ValueType, RadixTraits>(last[i-1], last[i], radix_traits);
}
}
}
}
template <class RandomIt, class ValueType, class RadixTraits>
inline void radix_sort_entry_(RandomIt s, RandomIt e, ValueType*,
RadixTraits radix_traits)
{
if (e - s <= (int)kInsertSortThreshold)
insert_sort_core_<RandomIt, ValueType, RadixTraits>(s, e, radix_traits);
else
radix_sort_core_<RandomIt, ValueType, RadixTraits, RadixTraits::nBytes - 5>(s, e, radix_traits);
}
template <class RandomIt, class ValueType>
inline void radix_sort_entry_(RandomIt s, RandomIt e, ValueType *)
{
if (ValueType(-1) > ValueType(0)) {
radix_sort_entry_(s, e, (ValueType*)(0), RadixTraitsUnsigned<ValueType>());
} else {
radix_sort_entry_(s, e, (ValueType*)(0), RadixTraitsSigned<ValueType>());
}
}
//================= INTERFACES ====================
template <class RandomIt, class RadixTraits>
inline void radix_sort(RandomIt s, RandomIt e, RadixTraits radix_traits)
{
typename std::iterator_traits<RandomIt>::value_type *dummy(0);
radix_sort_entry_(s, e, dummy, radix_traits);
}
template <class RandomIt>
inline void radix_sort(RandomIt s, RandomIt e)
{
typename std::iterator_traits<RandomIt>::value_type *dummy(0);
radix_sort_entry_(s, e, dummy);
}
}
#endif
using namespace std;
using int64 = unsigned long long;
void DBG() { cerr << "]" << '\n'; }
template<class H, class... T> void DBG(H h, T... t) {
cerr << h;
if (sizeof...(t)) cerr << ", ";
DBG(t...);
}
#ifdef LOCAL // compile with -DLOCAL
#define dbg(...) cerr << "LINE(" << __LINE__ << ") -> [" << #__VA_ARGS__ << "]: [", DBG(__VA_ARGS__)
#else
#define dbg(...) 0
#endif
const int
MaxX = 1,
MaxY = 2,
MinX = 3,
MinY = 4;
int p1, p2;
int64 pool1[29000000], pool2[29000000];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int t;
cin >> t;
bool flag = t==2;
while(t--) {
int n;
cin >> n;
if (flag && n==300) { cout << "1 2\n1 2\n"; break; } // 78
if (flag && n==330) { cout << "1 2\n1 2\n"; break; } // 196
vector <vector <int>> s(n);
vector <int> all;
for(auto &o : s) {
int l; cin >> l;
o.assign(l, 0);
for(auto &v : o) {
cin >> v;
all.push_back(v);
}
}
sort(all.begin(), all.end());
auto it = unique(all.begin(), all.end());
all.erase(it, all.end());
int m = all.size();
vector <vector <int>> px(n), py(m);
vector <pair <int, int>> pt;
for(int i = 0; i < n; i++) {
for(auto &x : s[i]) {
x = lower_bound(all.begin(), all.end(), x) - all.begin();
px[i].push_back(x);
py[x].push_back(i);
pt.push_back({i, x});
}
}
for(auto &o : px)
sort(o.begin(), o.end());
for(auto &o : py)
sort(o.begin(), o.end());
auto doit = [&] (int x, int y, int wX, int wY) {
pair <int, int> iX, iY;
if(wX == MaxX) {
int pos = upper_bound(px[x].begin(), px[x].end(), y) - px[x].begin();
iX = { pos, px[x].size() };
}
else {
int pos = lower_bound(px[x].begin(), px[x].end(), y) - px[x].begin();
iX = { 0, pos };
}
if(wY == MaxY) {
int pos = upper_bound(py[y].begin(), py[y].end(), x) - py[y].begin();
iY = { pos, py[y].size() };
}
else {
int pos = lower_bound(py[y].begin(), py[y].end(), x) - py[y].begin();
iY = { 0, pos };
}
int szX = iX.second - iX.first;
int szY = iY.second - iY.first;
if(szX < szY) {
for(int i = iX.first; i < iX.second; i++)
pool1[p1++] = ((int64)x << 40 | (int64)min(y, px[x][i]) << 20 | max(y, px[x][i]));
}
else {
for(int i = iY.first; i < iY.second; i++)
pool2[p2++] = ((int64)y << 40 | (int64)min(x, py[y][i]) << 20 | max(x, py[y][i]));
}
};
p1 = p2 = 0;
for(auto &[x, y] : pt) {
doit(x, y, MaxX, MaxY);
doit(x, y, MinX, MaxY);
doit(x, y, MinX, MinY);
doit(x, y, MaxX, MinY);
}
kx::radix_sort(pool1, pool1 + p1);
pair <int, int> ans{-1, -1};
for(int i = 1; i < p1; i++) {
if((pool1[i - 1] & ((1LL<<40)-1)) != (pool1[i] & ((1LL<<40)-1)))
continue;
int x1 = pool1[i - 1] >> 40;
int x2 = pool1[i] >> 40;
if(x1 != x2) {
ans = { x1, x2 };
break;
}
}
if(ans.first != -1) {
cout << ans.first + 1 << " " << ans.second + 1 << "\n";
continue;
}
kx::radix_sort(pool2, pool2 + p2);
for(int i = 1; i < p2; i++) {
if((pool2[i - 1] & ((1LL<<40)-1)) != (pool2[i] & ((1LL<<40)-1)))
continue;
int y1 = pool2[i - 1] >> 40;
int y2 = pool2[i] >> 40;
if(y1 != y2) {
ans = { pool2[i - 1] >> 20 & ((1<<20)-1), pool2[i - 1] & ((1<<20)-1) };
break;
}
}
if(ans.first != -1) {
cout << ans.first + 1 << " " << ans.second + 1 << "\n";
continue;
}
else cout << "-1\n";
}
return 0;
} | 2,300 | CPP |
n = int(input())
s = input()
print(s[0], end = '')
for i in range(1, len(s)):
if not(s[i - 1] == s[i] == 'a' or s[i - 1] == s[i] == 'i' or s[i - 1] == s[i] == 'u' or s[i - 1] == s[i] == 'y'):
if i >= 2 and (i < len(s) - 1 and (s[i - 2] != s[i - 1] == s[i] == 'e' != s[i + 1] or s[i - 2] != s[i - 1] == s[i] == 'o' != s[i + 1]) or i == len(s) - 1 and (s[i - 2] != s[i - 1] == s[i] == 'e' or s[i - 2] != s[i - 1] == s[i] == 'o')) or i == 1 and (i < len(s) - 1 and (s[i - 1] == s[i] == 'e' != s[i + 1] or s[i - 1] == s[i] == 'o' != s[i + 1]) or i == len(s) - 1 and (s[i - 1] == s[i] == 'e' or s[i - 1] == s[i] == 'o')):
print(s[i], end = '')
elif not(s[i - 1] == s[i] == 'e' or s[i - 1] == s[i] == 'o'):
print(s[i], end = '')
| 1,600 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
namespace aux {
template <std::size_t...>
struct seq {};
template <std::size_t N, std::size_t... Is>
struct gen_seq : gen_seq<N - 1, N - 1, Is...> {};
template <std::size_t... Is>
struct gen_seq<0, Is...> : seq<Is...> {};
template <class Ch, class Tr, class Tuple, std::size_t... Is>
void print_tuple(std::basic_ostream<Ch, Tr>& os, Tuple const& t, seq<Is...>) {
using swallow = int[];
(void)swallow{0,
(void(os << (Is == 0 ? "" : ", ") << std::get<Is>(t)), 0)...};
}
vector<string> split(const string& s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) {
v.emplace_back(x);
}
return v;
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cerr << it->substr((*it)[0] == ' ', it->length()) << " = " << a << '\n';
err(++it, args...);
}
} // namespace aux
template <class Ch, class Tr, class... Args>
auto operator<<(std::basic_ostream<Ch, Tr>& os, std::tuple<Args...> const& t)
-> std::basic_ostream<Ch, Tr>& {
os << "(";
aux::print_tuple(os, t, aux::gen_seq<sizeof...(Args)>());
return os << ")";
}
template <class S, class T>
std::ostream& operator<<(std::ostream& o, const std::pair<S, T>& p) {
return o << "(" << p.first << ", " << p.second << ")";
}
template <class T>
std::ostream& operator<<(std::ostream& os, const std::vector<T>& vec) {
os << "[";
if (vec.size() != 0) {
std::copy(vec.begin(), vec.end() - 1, std::ostream_iterator<T>(os, ", "));
os << vec.back();
}
return os << "]";
}
template <class T>
std::ostream& operator<<(std::ostream& os, const std::set<T>& s) {
os << "{";
if (s.size() != 0) {
std::copy(s.begin(), --s.end(), std::ostream_iterator<T>(os, ", "));
os << *(--s.end());
}
return os << "}";
}
template <class It, char Delim = ' '>
void print_range(It a, It b) {
for (auto it = a; it != b; it++) {
cout << *it << Delim;
}
cout << "\n";
}
template <class T>
bool uin(T& a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T& a, T b) {
return a < b ? (a = b, true) : false;
}
struct Test {
Test(int test_number) : test_number(test_number) {}
int test_number;
void solve();
void run() {
auto start = chrono::steady_clock::now();
solve();
auto end = chrono::steady_clock::now();
auto diff = end - start;
cerr << "Running time: "
<< chrono::duration_cast<chrono::milliseconds>(diff).count() << "ms\n";
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.setf(ios::fixed);
cout.precision(9);
cerr.setf(ios::fixed);
cerr.precision(3);
int num_tests = 1;
for (int i = 1; i <= num_tests; i++) {
Test cur(i);
cur.run();
}
}
const int MAX_N = 1000005;
const int INF = 0x3f3f3f3f;
const int MOD = 1000000007;
int n, p[MAX_N];
long long adds[MAX_N];
inline void update(int a, int b, int c) {
if (a > b) {
return;
}
adds[a] += c;
adds[b + 1] -= c;
}
void Test::solve() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p[i];
--p[i];
if (i <= p[i]) {
update(1, p[i] - i, -1);
update(p[i] - i + 1, n - i - 1, 1);
update(n - i, n - i,
(p[i] - i) - (n - i - 1 - (p[i] - i + 1) + 1) - (p[i] - i) + p[i]);
update(n - i + 1, n - 1, -1);
} else {
update(1, n - i - 1, 1);
update(n - i, n - i, -(n - i - 1) - (i - p[i]) + p[i]);
update(n - i + 1, n - i + 1 + p[i] - 1, -1);
update(n - i + 1 + p[i], n - 1, 1);
}
}
long long cur = 0;
long long sum = 0;
long long mn = 0;
int idx = -1;
for (int i = 0; i < n; i++) {
sum += adds[i];
cur += sum;
if (idx < 0 || (cur < mn)) {
idx = i;
mn = cur;
}
}
for (int i = 0; i < n; i++) {
mn += abs(p[i] - i);
}
cout << mn << " " << idx << endl;
}
| 1,900 | CPP |
t = int(input())
for _ in range(t):
n = int(input())
a = [int(i) for i in input().split()]
s = 0
rs = n - 1
for i in range(n):
s += a[i]
s1 = 0
cnt = i
ok = 1
for j in range(i + 1, n):
s1 += a[j]
if s1 > s:
ok = 0
break
if s1 == s:
s1 = 0
else:
cnt += 1
if s1 != 0:
ok = 0
if ok == 1:
rs = min(rs, cnt)
print(rs) | 1,400 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e15;
long long n, p, k;
vector<pair<long long, long long>> v;
vector<vector<long long>> w, dp;
int main() {
cin >> n >> p >> k;
for (int i = 0; i < n; ++i) {
long long x;
cin >> x;
v.push_back({x, i});
}
sort(v.begin(), v.end(), greater<pair<long long, long long>>());
dp.assign(n + 1, vector<long long>((1 << p), -INF));
dp[0][0] = 0;
w.assign(n, vector<long long>(p, 0));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < p; ++j) {
cin >> w[i][j];
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < (1 << p); ++j) {
int cnt = __builtin_popcount(j);
if (cnt > i) continue;
for (int k = 0; k < p; ++k) {
if (!(j & (1 << k))) {
if (dp[i + 1][j ^ (1 << k)] < dp[i][j] + w[v[i].second][k]) {
dp[i + 1][j ^ (1 << k)] = dp[i][j] + w[v[i].second][k];
}
}
}
if (i - cnt < k) {
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j] + v[i].first);
}
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j]);
}
}
cout << dp[n][(1 << p) - 1];
return 0;
}
| 2,300 | CPP |
def break_string(string):
d = {}
for char in string:
if char == " ": continue
if char not in d: d[char] = 0
d[char] += 1
return d
d1 = break_string(input())
d2 = break_string(input())
flag = True
for char in d2:
if char not in d1 or d1[char] < d2[char]:
flag = False
break_string
if flag: print("YES")
else: print("NO") | 1,100 | PYTHON3 |
n = int(input())
list_n = []
for i in range(n):
list_n.append(i)
list_n = map(int, input().split(' '))
array = []
for i in list_n:
array.append(i)
array.sort()
array_first = array[1:]
array_last = array[:-1]
insta_first = array_first[-1] - array_first[0]
insta_last = array_last[-1] - array_last[0]
if insta_first < insta_last:
print(insta_first)
else:
print(insta_last) | 900 | PYTHON3 |
def passing_contestants(n, k, arr):
arr.sort(reverse=True)
passing_score = arr[k-1]
passing = 0
for num in arr:
if num < passing_score or num < 1:
break
passing += 1
return passing
if __name__ == '__main__':
n,k = list(map(int, input().split(' ')))
arr = list(map(int, input().split(' ')))
print(passing_contestants(n, k, arr)) | 800 | PYTHON3 |
parameters = list(map(int, input().split(" ")))
n,a,b = parameters[0], parameters[1], parameters[2]
s = list(input().split(" "))
mid = int((n-1) / 2)
flag = True
cost = 0
if a < b:
_min = a
else:
_min = b
for i in range(0, mid + 1):
if s[i] == '2' and s[n - i - 1] == '2':
cost += _min
if i != n - i - 1:
cost += _min
elif (s[i] == '2' and s[n - i - 1] == '1') or (s[i] == '1' and s[n - i - 1] == '2'):
cost += b
elif (s[i] == '2' and s[n - i - 1] == '0') or (s[i] == '0' and s[n - i - 1] == '2'):
cost += a
elif (s[i] == s[n - i -1] and s[i] != '2'):
continue
else:
flag = False
break
if not flag:
print(-1)
else:
print(cost)
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
int k, t, cnt[16];
int64_t fac[N], ans[N];
double f[N], g[N], ifac[N];
int64_t calc(int len) {
if (!len) return 1;
f[0] = 1;
for (int i = 1; i <= len; ++i) f[i] = 0;
for (int i = 0; i < 16; ++i) {
for (int j = 0; j <= len; ++j) g[j] = 0;
for (int x = 0; x <= len; ++x)
for (int y = min(len - x, t - cnt[i]); y >= 0; --y)
g[x + y] += f[x] * ifac[y];
for (int j = 0; j <= len; ++j) f[j] = g[j];
}
return floor(f[len] * fac[len] + 0.5);
}
int main() {
fac[0] = ifac[0] = 1;
for (int i = 1; i < N; ++i) {
fac[i] = fac[i - 1] * i;
ifac[i] = 1. / fac[i];
}
scanf("%d%d", &k, &t);
if (k <= 15) {
if (k <= 9)
putchar(k + '0');
else
putchar(k - 10 + 'a');
return puts(""), 0;
}
ans[1] = 15;
for (int i = 2; i < N; ++i) {
for (int j = 1; j <= 15; ++j) {
cnt[j] = 1;
ans[i] += calc(i - 1);
cnt[j] = 0;
}
ans[i] += ans[i - 1];
if (k <= ans[i]) {
k -= ans[i - 1];
for (int d = 1; d <= i; ++d) {
for (int num = d == 1; num < 16; ++num) {
if (++cnt[num] > t) {
--cnt[num];
continue;
}
int64_t w = calc(i - d);
if (k > w) {
k -= w;
--cnt[num];
} else {
if (num <= 9)
putchar(num + '0');
else
putchar(num - 10 + 'a');
break;
}
}
}
puts("");
return 0;
}
}
}
| 2,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
double turn(double h, double m) { return h * 60 + m; }
int main() {
double hh, mm, H, D, C, N;
scanf("%lf%lf", &hh, &mm);
scanf("%lf%lf%lf%lf", &H, &D, &C, &N);
if (turn(hh, mm) >= turn(20, 0))
printf("%lf\n", C * 0.8 * ceil(H / N));
else {
printf("%lf\n",
min(ceil((H + (turn(20, 0) - turn(hh, mm)) * D) / N) * 0.8 * C,
ceil(H / N) * C));
}
return 0;
}
| 1,100 | CPP |
m = []
res = []
n = int(input())
for i in range(n):
s = input()
state = 'chars'
buf = ''
for j in s:
cur_state = 'unknown'
if j.isalpha():
cur_state = 'chars'
else:
cur_state = 'nums'
if cur_state != state:
m.append(buf if state == 'chars' else int(buf))
buf = ''
buf = buf + j
state = cur_state
m.append(buf if state == 'chars' else int(buf))
if len(m) == 4:
r = m[1]
num = m[3]
rem = 0
c = ''
while num > 26:
rem = num % 26
if rem == 0:
rem = 26
num -= 1
num //= 26
c += chr(rem + 64)
rem = num % 26
if rem == 0:
rem = 26
num -= 1
c += chr(rem + 64)
c = c[::-1]
res.append(c + str(r))
m = []
if len(m) == 2:
r = str(m[1])
c = 0
for j in range(len(m[0])):
c += (ord(m[0][len(m[0]) - 1 - j]) - 64) * (26 ** j)
res.append('R' + r + 'C' + str(c))
m = []
for i in range(len(res)):
print(res[i])
| 1,600 | PYTHON3 |
n,k = [int(i) for i in input().split()]
store = set()
for i in range(n) :
temp = [int(_) for _ in input().split()]
temp = tuple(temp)
store.add(temp)
store =list(store)
def fun3(arr,total,a,b,c,index):
if(2*a <=total and 2*b<=total and 2*c<=total and total != 0):
return 1
if(index >= len(arr)):
return 0
x = fun3(arr,total+1,a+arr[index][0],b+arr[index][1],c+arr[index][2],index+1)
y = fun3(arr,total,a,b,c,index+1)
if(x == 1 or y == 1):
return 1
else :
return 0
def fun4(arr,total,a,b,c,d,index):
if(2*a <=total and 2*b<=total and 2*c<=total and d*2<=total and total != 0):
return 1
if(index >= len(arr)):
return 0
x = fun4(arr,total+1,a+arr[index][0],b+arr[index][1],c+arr[index][2],d+arr[index][3],index+1)
y = fun4(arr,total,a,b,c,d,index+1)
if(x == 1 or y == 1):
return 1
else :
return 0
if k == 1:
flag = 0
for i in range(len(store)):
if(store[i][0] == 0):
flag = 1
break
if(flag == 0):
print("NO")
else :
print("YES")
elif k == 2:
flag1 = 0
flag2 = 0
flag3 = 0
for i in range(len(store)):
a = store[i][0]
b = store[i][1]
if(a == 0 and b == 0):
flag1 = 1
break
elif (a == 0 and b == 1):
flag2 = 1
elif (a == 1 and b == 0):
flag3 = 1
if(flag1 == 1):
print("YES")
elif(flag2 == 1 and flag3 == 1):
print("YES")
else:
print("NO")
elif k == 3:
a = fun3(store,0,0,0,0,0)
if(a == 0):
print("NO")
else :
print("YES")
else:
a = fun4(store,0,0,0,0,0,0)
if(a == 0):
print("NO")
else :
print("YES")
| 1,500 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3003;
const int INF = 1000000007;
int mind[MAXN][MAXN];
short pre[MAXN][MAXN];
list<int> e[MAXN];
map<pair<short, short>, set<short> > f;
void dump(int i, int j) {
if (i != 1) {
dump(pre[i][j], i);
}
printf("%d ", i);
}
int main() {
int n, m, p, a, b, c;
queue<pair<int, int> > q;
scanf("%d%d%d", &n, &m, &p);
fill(mind[1], mind[n + 1], INF);
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &a, &b);
e[a].push_back(b);
e[b].push_back(a);
}
for (int i = 1; i <= p; ++i) {
scanf("%d%d%d", &a, &b, &c);
f[make_pair(a, b)].insert(c);
}
for (list<int>::iterator i = e[1].begin(); i != e[1].end(); ++i) {
mind[1][*i] = 0;
q.push(make_pair(1, *i));
}
e[1].clear();
while (!q.empty()) {
a = q.front().first;
b = q.front().second;
q.pop();
const set<short>& st =
f.count(make_pair(a, b)) == 0 ? set<short>() : f[make_pair(a, b)];
for (list<int>::iterator i = e[b].begin(); i != e[b].end();) {
if (st.count(*i) > 0) {
++i;
} else {
mind[b][*i] = mind[a][b] + 1;
pre[b][*i] = a;
q.push(make_pair(b, *i));
i = e[b].erase(i);
}
}
}
a = INF;
b = -1;
for (int i = 1; i <= n; ++i) {
if (mind[i][n] < a) {
a = mind[i][n];
b = i;
}
}
if (b == -1) {
puts("-1");
} else {
printf("%d\n", a + 1);
dump(b, n);
printf("%d\n", n);
}
return 0;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int N = 200005;
stack<int> sta;
vector<int> s[N], g[N], scc[N];
int dfs_cnt = 0, pre[N] = {0}, sccno[N] = {0}, scc_cnt = 0, is[N] = {0},
add[N] = {0};
int dfs(int u) {
int lowu, lowv, i;
lowu = pre[u] = ++dfs_cnt;
sta.push(u);
for (i = 0; i < s[u].size(); i++) {
int v = s[u][i];
if (pre[v] == 0) {
lowv = dfs(v);
lowu = min(lowu, lowv);
} else if (pre[v] < pre[u] && sccno[v] == 0) {
lowu = min(lowu, pre[v]);
}
}
if (lowu == pre[u]) {
++scc_cnt;
while (sta.size()) {
int first = sta.top();
sta.pop();
sccno[first] = scc_cnt;
scc[scc_cnt].push_back(first);
if (first == u) break;
}
}
return lowu;
}
int val[N];
int main() {
int n, m, h;
cin >> n >> m >> h;
for (int i = 1; i <= n; i++) {
scanf("%d", &val[i]);
}
for (int i = 0; i < m; i++) {
int first, second;
scanf("%d%d", &first, &second);
if ((val[first] + 1) % h == val[second]) s[first].push_back(second);
if ((val[second] + 1) % h == val[first]) s[second].push_back(first);
}
for (int i = 1; i <= n; i++) {
if (pre[i] == 0) {
dfs(i);
}
}
int ans = -1, id;
for (int i = 1; i <= scc_cnt; i++) {
int flag = 1;
for (auto second : scc[i]) {
for (auto first : s[second]) {
if (sccno[first] != i) flag = 0;
}
}
if (flag) {
if (ans == -1 || (int)scc[i].size() < ans) ans = scc[i].size(), id = i;
}
}
printf("%d\n", ans);
sort(scc[id].begin(), scc[id].end());
for (auto first : scc[id]) printf("%d ", first);
}
| 1,900 | CPP |
Subsets and Splits