solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
n, c = input ().split ();
c = int (c);
t = input ().split ();
world_count = 1;
j = 0;
for i in t :
if (j > 0) :
if (int (i) - int (t [j - 1]) > c) :
world_count = 1;
else :
world_count += 1;
j += 1;
print (world_count);
| 7 | PYTHON3 |
#include <bits/stdc++.h>
int main() {
int n, k, i, ar[10000];
scanf("%d %d", &n, &k);
for (i = 0; i < n; i++) scanf("%d", &ar[i]);
if (n * 8 < k)
printf("-1\n");
else {
for (i = 0; i < n;) {
if (ar[i] < 8)
k = k - ar[i];
else {
k = k - 8;
ar[i + 1] = (ar[i + 1] + (ar[i] - 8));
}
i++;
if (k <= 0) break;
}
if (k <= 0)
printf("%d\n", i);
else
printf("-1\n");
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
const double pi = 4.0 * atan(1.0);
const double e = exp(1.0);
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long l, r;
cin >> l >> r;
if (2 * l <= r) cout << l << ' ' << 2 * l << endl;
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long Set(long long N, long long pos) { return N = N | (1 << pos); }
long long reset(long long N, long long pos) { return N = N & ~(1 << pos); }
bool check(long long N, long long pos) { return (bool)(N & (1 << pos)); }
long long big_mod(long long base, long long pow) {
if (pow == 1) return base % 1000000007;
if (pow == 0) return 1;
if (pow % 2 == 0) {
long long ans = big_mod(base, pow / 2);
return (ans * ans) % 1000000007;
}
long long ans = big_mod(base, pow / 2);
ans = (ans * ans) % 1000000007;
return (ans * base) % 1000000007;
}
long long dp[1 << 16 - 1][230][4];
long long fact[20];
long long t, n;
long long cnt[4];
long long arr[20];
long long g[20];
static int shajib;
long long go(long long mask, long long sum, long long last) {
long long ans = 0;
long long &res = dp[mask][sum][last];
if (res != -1) return res;
if (sum == t) {
return res = 1;
}
for (long long i = 0; i < n; i++) {
if (check(mask, i) == 0 && sum + arr[i] <= t) {
if (last != g[i]) ans += go(Set(mask, i), sum + arr[i], g[i]);
}
}
return res = ans % 1000000007;
}
int main() {
long long i, j, m;
memset(dp, -1, sizeof(dp));
cin >> n >> t;
for (i = 0; i < n; i++) {
cin >> arr[i] >> g[i];
}
cout << go(0, 0, 0) << endl;
}
| 13 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 55;
int n, f[maxn][maxn][maxn][maxn];
char s[maxn][maxn];
int dfs(int x, int y, int u, int v) {
if (x == u && y == v) return s[u][v] == '#';
if (~f[x][y][u][v]) return f[x][y][u][v];
int ans = max(u - x + 1, v - y + 1);
for (int i = x; i < u; i++)
ans = min(ans, dfs(x, y, i, v) + dfs(i + 1, y, u, v));
for (int i = y; i < v; i++)
ans = min(ans, dfs(x, y, u, i) + dfs(x, i + 1, u, v));
return f[x][y][u][v] = ans;
}
int main() {
memset(f, -1, sizeof(f));
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%s", s[i]);
printf("%d\n", dfs(0, 0, n - 1, n - 1));
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
int a[4];
int b = 0, c = 0;
int main() {
for (int i = 0; i < 4; i++) scanf("%d", &a[i]);
std::sort(a, a + 4);
if (a[0] + a[1] > a[2]) b = 1;
if (a[1] + a[2] > a[3]) b = 1;
if (a[0] + a[1] == a[2]) c = 1;
if (a[1] + a[2] == a[3]) c = 1;
if (b)
puts("TRIANGLE");
else if (c)
puts("SEGMENT");
else
puts("IMPOSSIBLE");
}
| 7 | CPP |
#include <bits/stdc++.h>
template <typename T>
using Vector2D = std::vector<std::vector<T>>;
template <typename T>
using Vector3D = std::vector<Vector2D<T>>;
using PairInt = std::pair<int, int>;
using PairInt64 = std::pair<int64_t, int64_t>;
using MapInt = std::map<int, int>;
using MMapInt = std::multimap<int, int>;
using MMapInt64 = std::multimap<int64_t, int64_t>;
using UMapIntString = std::unordered_map<int, std::string>;
using SetInt = std::set<int>;
using SetPairInt64 = std::set<PairInt64>;
using VectorInt = std::vector<int>;
using VectorInt2D = Vector2D<int>;
using VectorInt64 = std::vector<int64_t>;
using VectorUInt64 = std::vector<uint64_t>;
using VectorInt642D = Vector2D<int64_t>;
using VectorChar = std::vector<char>;
using VectorChar2D = Vector2D<char>;
using VectorString = std::vector<std::string>;
using QueuePairInt = std::queue<PairInt>;
using QueueInt = std::queue<int>;
using VectorPairInt = std::vector<PairInt>;
using VectorPairInt64 = std::vector<PairInt64>;
using VectorPairInt2D = Vector2D<PairInt>;
using SetInt = std::set<int>;
using MSetInt = std::multiset<int>;
using UMapChar = std::map<char, int>;
using ListInt = std::list<int>;
using VectorListInt = std::vector<ListInt>;
using VectorDouble = std::vector<double>;
int main() {
std::ios::sync_with_stdio(false);
int n;
std::cin >> n;
VectorString tt(n);
for (auto& t : tt) {
std::cin >> t;
}
int64_t ans = 0;
for (int i = 0; i < n; ++i) {
int64_t r = 0;
int64_t c = 0;
for (int j = 0; j < n; ++j) {
if (tt[i][j] == 'C') {
++r;
}
if (tt[j][i] == 'C') {
++c;
}
}
ans += r * (r - 1) / 2;
ans += c * (c - 1) / 2;
}
std::cout << ans;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, tot;
cin >> n >> tot;
vector<int> v;
vector<int> v1;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.push_back(x);
v1.push_back(x);
}
sort(v.begin(), v.end());
int sum = 0;
vector<int> fin;
for (int i = 0; i < n; i++) {
sum += v[i];
if (sum > tot)
break;
else {
fin.push_back(v[i]);
}
}
cout << fin.size() << endl;
for (int i = 0; i < fin.size(); i++) {
for (int x = 0; x < v1.size(); x++) {
if (fin[i] == v1[x]) {
cout << x + 1 << " ";
v1[x] = -11;
break;
}
}
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int cards;
cin >> cards;
int zeroBCards[cards];
int zeroBCount = 0;
int bonusRound = 1;
int score = 0;
for (int i = 0; i < cards; i++) {
int aVal, bVal;
cin >> aVal >> bVal;
if (bVal != 0) {
bonusRound += bVal - 1;
score += aVal;
} else {
zeroBCards[zeroBCount] = aVal;
zeroBCount++;
}
}
sort(zeroBCards, zeroBCards + zeroBCount);
for (int i = 0; i < bonusRound; i++) {
if (zeroBCount == 0) break;
score += zeroBCards[zeroBCount - 1];
zeroBCount--;
if (zeroBCount < 0) break;
}
cout << score;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, m;
cin >> n >> m;
bool ans = true;
for (long long int i = 1; i <= m; i++) {
long long int temp;
cin >> temp;
unordered_map<long long int, long long int> mm;
bool cc = false;
while (temp--) {
long long int tt;
cin >> tt;
if (mm.count(-tt) != 0) {
cc = true;
}
mm[tt]++;
}
ans = ans && cc;
}
if (!ans)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long rdtsc() {
long long tmp;
asm("rdtsc" : "=A"(tmp));
return tmp;
}
inline int myrand() { return abs((rand() << 15) ^ rand()); }
inline int rnd(int x) { return myrand() % x; }
const int INF = (int)1e9 + 1;
const long double EPS = 1e-9;
const int maxn = (int)5e6 + 10;
int a[maxn];
int col[maxn];
int start[maxn];
int elements[maxn];
bool solve() {
int n;
if (scanf("%d", &n) < 1) return 0;
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
sort(a, a + n);
reverse(a, a + n);
int cnt = 0;
for (int i = 0; i < n;) {
int i0 = i;
while (i < n && a[i] == a[i0]) {
col[i] = cnt;
++i;
}
start[cnt] = i0;
++cnt;
}
multiset<int> levels;
int total = 0;
for (int groupId = 0; groupId < cnt; ++groupId) {
int nval = a[start[groupId]],
ntimes = (groupId == cnt - 1 ? n : start[groupId + 1]) - start[groupId];
int prevBal = total - 2 * ((int)(levels).size());
assert(prevBal >= 0);
total += ntimes;
ntimes = min(ntimes, total - ntimes);
int newSize =
((int)(levels).size()) + ntimes - (max(ntimes - prevBal, 0) + 1) / 2;
int left = ((int)(levels).size()) - (newSize - ntimes);
for (int it = 0; it < left; ++it) {
auto iter = levels.begin();
assert(iter != levels.end());
elements[left - 1 - it] = *iter;
levels.erase(iter);
}
assert(((int)(levels).size()) == newSize - ntimes);
for (int i = left; i < ntimes; ++i) {
elements[i] = nval;
}
int shift = (ntimes > prevBal && ((ntimes + prevBal) & 1));
for (int i = left - 1; i >= 0; --i) {
if (elements[i] >= nval) {
if (i >= shift) {
elements[ntimes - (i - shift) - 1] += nval - elements[i];
}
} else {
elements[i] = nval;
}
}
levels.insert(elements, elements + ntimes);
}
long long sum = 0;
for (int i = 0; i < n; ++i) {
sum += a[i];
}
for (auto iter = levels.begin(); iter != levels.end(); ++iter) {
if (*iter >= 0) {
sum -= *iter;
}
}
printf(
"%lld"
"\n",
sum);
return 1;
}
int main() {
srand(rdtsc());
while (1) {
if (!solve()) break;
}
return 0;
}
| 12 | CPP |
t=int(input())
for u in range(t):
i=input().split()
d=abs(int(i[0])-int(i[1]))
for j in range(100000):
if d+d<=j*(j+1) and (j*(j+1))//2 % 2 == d%2:
print(j)
break | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
for (int k = 21; k <= 50; k++)
cout << (((min(k, 25) + k) % (2 + k % 3) > 0) ? 1 : 0) << endl;
}
| 11 | CPP |
lista=list(map(int,input().split()))
lista=set(lista)
n=len(lista)
print(4-n) | 7 | PYTHON3 |
#include<iostream>
#include<algorithm>
#include<map>
#include<cstdio>
#include<vector>
#define F first
#define S second
using namespace std;
typedef pair<int,int> P;
bool cmp(const P &p,const P &q){
if(p.S != q.S)return p.S > q.S;
return p.F < q.F;
}
int main(){
int id,sol;
vector<P> info;
while(true){
scanf("%d,%d",&id,&sol);
if(id+sol == 0)break;
info.push_back(P(id,sol));
}
sort(info.begin(),info.end(),cmp);
int pre = info[0].S;
int cnt = 1;
map<int,int> rank;
for(int i=0;i<=info.size();i++){
if(pre != info[i].S){cnt++; pre = info[i].S;}
rank[info[i].F] = cnt;
}
int exec;
while(cin >> exec){
cout << rank[exec] << endl;
}
return 0;
} | 0 | CPP |
if __name__ == "__main__":
line = input()
tokens = line.split(" ")
n = int(tokens[0])
k = int(tokens[1])
a = [k]
b = []
line = input()
tokens = line.split(" ")
for i in range(0, n):
a.append(int(tokens[i]))
total_extra_walks = 0
extra_walk_yesterday = 0
for i in range(1, n+1):
walk_in_two_days = a[i] + a[i-1] + extra_walk_yesterday
if walk_in_two_days < k:
extra_walk_today = k - walk_in_two_days
else:
extra_walk_today = 0
total_extra_walks += extra_walk_today
b.append(a[i] + extra_walk_today)
extra_walk_yesterday = extra_walk_today
print(total_extra_walks)
line = ""
for i in range(0, len(b)):
line += str(b[i])
if i != (len(b) - 1):
line += " "
print(line)
| 8 | PYTHON3 |
#include "bits/stdc++.h"
#define REP(i,n) for(ll i=0;i<ll(n);++i)
#define RREP(i,n) for(ll i=ll(n)-1;i>=0;--i)
#define FOR(i,m,n) for(ll i=m;i<ll(n);++i)
#define RFOR(i,m,n) for(ll i=ll(n)-1;i>=ll(m);--i)
#define ALL(v) (v).begin(),(v).end()
#define UNIQUE(v) v.erase(unique(ALL(v)),v.end());
#define INF 1000000001ll
#define MOD 1000000007ll
#define EPS 1e-9
const int dx[8] = { 1,1,0,-1,-1,-1,0,1 };
const int dy[8] = { 0,1,1,1,0,-1,-1,-1 };
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m, t, p;
while (cin >> m >> n >> t >> p, n) {
vvi v(n, vi(m, 1));
REP(adfad, t) {
int d, c;
cin >> d >> c;
if (d == 1) {
int k = max(m - c, c);
vvi t(n, vi(k));
REP(i, n) {
REP(j, k) {
int tmp = 0;
if (j < c)tmp += v[i][c - j - 1];
if (c + j < m)tmp += v[i][c + j];
t[i][j] = tmp;
}
}
m = k;
v = t;
}
else {
int k = max(n - c, c);
vvi t(k, vi(m));
REP(i, k) {
REP(j, m) {
int tmp = 0;
if (i < c)tmp += v[c - i - 1][j];
if (i + c < n)tmp += v[c + i][j];
t[i][j] = tmp;
}
}
n = k;
v = t;
}
}
REP(i, p) {
int x, y;
cin >> x >> y;
cout << v[y][x] << endl;
}
}
}
| 0 | CPP |
S = int(input())
dp = [0] * (S + 1)
dp[0] = 1
for i in range(3, S + 1):
dp[i] = sum(dp[:i - 2])
print(dp[S] % (10 ** 9 + 7))
| 0 | PYTHON3 |
a,b=map(int,input().split())
answ = a
while a>=b:
answ+=a//b
a=a//b+a%b
print(answ) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300010;
int n, q, arr[N];
int seg[4 * N], lazy[4 * N];
int l, r, val, cur[N];
inline void fix(int s, int e, int idx) {
seg[idx] += lazy[idx];
if (s != e) {
lazy[(idx << 1)] += lazy[idx];
lazy[(idx << 1) + 1] += lazy[idx];
}
lazy[idx] = 0;
}
int update(int s, int e, int idx) {
fix(s, e, idx);
if (s > r || e < l) return seg[idx];
if (s >= l && e <= r) {
lazy[idx] += val;
fix(s, e, idx);
return seg[idx];
}
return seg[idx] = max(update(s, ((s + e) >> 1), (idx << 1)),
update(((s + e) >> 1) + 1, e, (idx << 1) + 1));
}
int get(int s, int e, int idx) {
fix(s, e, idx);
if (s == e) {
if (val > seg[idx]) return -1;
return s;
}
fix(s, ((s + e) >> 1), (idx << 1));
fix(((s + e) >> 1) + 1, e, (idx << 1) + 1);
if (val <= seg[(idx << 1) + 1])
return get(((s + e) >> 1) + 1, e, (idx << 1) + 1);
return get(s, ((s + e) >> 1), (idx << 1));
}
vector<int> seg2[4 * N];
void build(int s, int e, int idx) {
if (s == e) {
seg2[idx].push_back(cur[s]);
return;
}
build(s, ((s + e) >> 1), (idx << 1));
build(((s + e) >> 1) + 1, e, (idx << 1) + 1);
for (int i = 0; i < (int)seg2[(idx << 1)].size(); i++)
seg2[idx].push_back(seg2[(idx << 1)][i]);
for (int i = 0; i < (int)seg2[(idx << 1) + 1].size(); i++)
seg2[idx].push_back(seg2[(idx << 1) + 1][i]);
sort(seg2[idx].begin(), seg2[idx].end());
}
int x, y;
int getsum(int s, int e, int idx) {
if (s > r || e < l) return 0;
if (s >= l && e <= r) {
return (int)(seg2[idx].end() -
lower_bound(seg2[idx].begin(), seg2[idx].end(), x));
}
return getsum(s, ((s + e) >> 1), (idx << 1)) +
getsum(((s + e) >> 1) + 1, e, (idx << 1) + 1);
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
val = (i + 1) - arr[i];
cur[i] = min(i, get(0, n, 1));
if (val < 0) cur[i] = -1;
l = 0, r = cur[i], val = 1;
if (l <= r) {
update(0, n, 1);
}
}
build(0, n - 1, 1);
while (q--) {
scanf("%d%d", &x, &y);
l = x, r = n - y - 1;
printf("%d\n", getsum(0, n - 1, 1));
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<pair<pair<long long int, long long int>,
pair<long long int, long long int>>>
V;
long long int N, M, cases;
long long int type;
long long int R, C, X;
long long int mat[105][105];
vector<pair<long long int, long long int>> rows, cols;
int main() {
scanf("%lld %lld %lld", &N, &M, &cases);
while (cases--) {
scanf("%lld", &type);
if (type == 1) {
scanf("%lld", &R);
V.push_back(make_pair(make_pair(1, R), make_pair(-1, -1)));
} else if (type == 2) {
scanf("%lld", &C);
V.push_back(make_pair(make_pair(2, C), make_pair(-1, -1)));
} else {
scanf("%lld %lld %lld", &R, &C, &X);
V.push_back(make_pair(make_pair(type, R), make_pair(C, X)));
}
}
for (int i = V.size() - 1; i >= 0; i--) {
if (V[i].first.first == 3) {
mat[V[i].first.second][V[i].second.first] = V[i].second.second;
} else if (V[i].first.first == 2) {
cols.clear();
for (int j = 1; j <= N; j++) {
if (j == 1) {
cols.push_back(
make_pair(mat[j][V[i].first.second], mat[N][V[i].first.second]));
} else {
cols.push_back(make_pair(mat[j][V[i].first.second],
mat[j - 1][V[i].first.second]));
}
}
for (int j = 1; j <= N; j++) {
mat[j][V[i].first.second] = cols[j - 1].second;
}
} else {
rows.clear();
for (int j = 1; j <= M; j++) {
if (j == 1) {
rows.push_back(
make_pair(mat[V[i].first.second][j], mat[V[i].first.second][M]));
} else {
rows.push_back(make_pair(mat[V[i].first.second][j],
mat[V[i].first.second][j - 1]));
}
}
for (int j = 1; j <= M; j++) {
mat[V[i].first.second][j] = rows[j - 1].second;
}
}
}
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
cout << mat[i][j] << " ";
}
cout << "\n";
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1001, maxk = 1001;
int k, aray[maxn], C[maxn][maxk];
void computeC() {
for (int i = 0; i < maxn; i++) C[i][0] = 1;
for (int i = 1; i < maxk; i++)
for (int j = 1; j < maxn; j++)
C[j][i] = (C[j - 1][i - 1] + C[j - 1][i]) % mod;
}
long long bitjon(string str, int a) {
int siz = str.size(), cnt = 0, ones = 0;
if (k == 1) cnt = -1;
for (int i = 0; i < siz; i++) ones += str[i] == '1';
cnt += ones == a;
for (int i = 0; i < siz && a >= 0; i++) {
if (str[i] == '1') {
cnt += C[siz - i - 1][a--];
cnt %= mod;
}
}
return cnt;
}
int main() {
string str;
computeC();
cin >> str >> k;
long long ans = 0;
if (k == 0) {
cout << 1;
return 0;
}
for (int i = 2; i < maxn; i++) {
aray[i] = aray[__builtin_popcount(i)] + 1;
}
for (int i = 1; i <= str.size(); i++) {
if (aray[i] == k - 1) {
ans += bitjon(str, i);
ans %= mod;
}
}
cout << ans;
}
| 9 | CPP |
n=int(input())
l=sorted(list(map(int,input().split())))
c=0
for i in range(n//2):
c+=(l[i]+l[-i-1])**2
print(c)
| 9 | PYTHON3 |
t=int(input())
for i in range(t):
n=int(input())
a=[int(x) for x in input().split()]
aodd=a[0::2]
aeven=a[1::2]
aodd.sort()
aeven.sort()
b=[]
for i in range(len(aodd)):
b.append(aodd[i])
if i<len(aeven):
b.append(aeven[i])
c=b.copy()
c.sort()
if b==c:
print("YES")
else:
print("NO")
| 9 | PYTHON3 |
N = int(input())
print(N // 2*(N - N // 2)) | 0 | PYTHON3 |
n = int(input())
mas = [ ]
velichina = [ ]
for k in range(3,1000):
velichina.append(180*(k-2)/k)
for i in range(n):
a = int(input())
mas.append(a)
for p in mas:
if p in velichina:
print('YES')
else:
print('NO')
| 7 | PYTHON3 |
t = int(input())
for _ in range(t):
n = int(input())
lst = sorted(list(map(int, input().split())))
found = False
for i in range(1, 1025):
temp = sorted([i ^ elem for elem in lst])
if temp == lst:
print(i)
found = True
break
if not found:
print(-1) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 200000;
int n, lim;
int a[MAXN];
int b[MAXN];
bool isfixed[MAXN];
pair<int, int> o[MAXN];
int no;
int dst[MAXN];
int cyc[MAXN], ncyc;
int par[MAXN], sz[MAXN];
int find(int a) {
if (par[a] == a) return a;
return par[a] = find(par[a]);
}
bool unite(int a, int b) {
a = find(a), b = find(b);
if (a == b) return false;
if (sz[a] < sz[b]) swap(a, b);
par[b] = a, sz[a] += sz[b];
return true;
}
bool done[MAXN];
vector<vector<int>> ans;
bool solve() {
for (int i = (0); i < (n); ++i) b[i] = a[i];
sort(b, b + n);
int nfixed = 0;
for (int i = (0); i < (n); ++i) {
isfixed[i] = a[i] == b[i];
if (isfixed[i]) ++nfixed;
}
if (n - nfixed > lim) return false;
no = 0;
for (int i = (0); i < (n); ++i)
if (!isfixed[i]) o[no++] = make_pair(a[i], i);
sort(o, o + no);
for (int i = (0); i < (n); ++i) dst[i] = isfixed[i] ? i : -1;
{
int at = 0;
for (int i = (0); i < (no); ++i) {
while (at < n && isfixed[at]) ++at;
dst[o[i].second] = at++;
}
}
for (int i = (0); i < (n); ++i) cyc[i] = -1;
ncyc = 0;
for (int i = (0); i < (n); ++i)
if (cyc[i] == -1 && dst[i] != i) {
int at = i;
while (cyc[at] == -1) {
cyc[at] = ncyc;
at = dst[at];
}
++ncyc;
}
int expect = ncyc;
for (int i = (0); i < (ncyc); ++i) par[i] = i, sz[i] = 1;
for (int l = 0, r = l; l < no; l = r) {
while (r < no && o[l].first == o[r].first) ++r;
int cur = o[l].second;
for (int i = (l + 1); i < (r); ++i) {
int oth = o[i].second;
if (unite(cyc[cur], cyc[oth])) {
swap(dst[cur], dst[oth]);
--expect;
}
}
}
for (int i = (0); i < (n); ++i) done[i] = false;
ans.clear();
for (int i = (0); i < (n); ++i)
if (!done[i] && dst[i] != i) {
ans.push_back(vector<int>());
int at = i;
while (!done[at]) {
done[at] = true;
ans.back().push_back(at);
at = dst[at];
}
}
assert(((int)(ans).size()) == expect);
int rem = lim - (n - nfixed);
if (((int)(ans).size()) >= 3 && rem >= 3) {
int cnt = min(rem, ((int)(ans).size()));
vector<int> fst(cnt);
for (int i = (0); i < (cnt); ++i) fst[i] = ans[i][0];
reverse(fst.begin(), fst.end());
vector<int> snd;
for (int i = (0); i < (cnt); ++i) {
snd.push_back(ans[i][0]);
int j = (i + 1) % cnt;
for (int k = (1); k < (((int)(ans[j]).size())); ++k)
snd.push_back(ans[j][k]);
}
vector<vector<int>> nans;
nans.push_back(fst);
nans.push_back(snd);
for (int i = (cnt); i < (((int)(ans).size())); ++i) nans.push_back(ans[i]);
ans = nans;
}
return true;
}
bool verify(vector<vector<int>> ans) {
vector<int> cur(n);
for (int i = (0); i < (n); ++i) cur[i] = a[i];
for (int i = (0); i < (((int)(ans).size())); ++i) {
int val = cur[ans[i][0]];
for (int j = (1); j < (((int)(ans[i]).size())); ++j)
swap(val, cur[ans[i][j]]);
cur[ans[i][0]] = val;
}
for (int i = (1); i < (((int)(cur).size())); ++i)
if (cur[i] < cur[i - 1]) return false;
return true;
}
void run() {
scanf("%d%d", &n, &lim);
for (int i = (0); i < (n); ++i) scanf("%d", &a[i]);
if (!solve()) {
printf("-1\n");
return;
}
printf("%d\n", ((int)(ans).size()));
for (int i = (0); i < (((int)(ans).size())); ++i) {
printf("%d\n", ((int)(ans[i]).size()));
for (int j = (0); j < (((int)(ans[i]).size())); ++j) {
if (j != 0) printf(" ");
printf("%d", ans[i][j] + 1);
}
puts("");
}
assert(verify(ans));
}
int main() {
run();
return 0;
}
| 11 | CPP |
def main():
n=int(input())
l=list(map(int,input().split(" ")))
maximal=max(l)
minimal=min(l)
if maximal==minimal:
print ("0 %d" % (n*(n-1)/2))
return
pass
nmin=0
nmax=0
nmin=l.count(minimal)
nmax=l.count(maximal)
print ("%d %d" % (maximal-minimal,nmax*nmin))
main() | 8 | PYTHON3 |
#include<bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < n; i++)
#define pb push_back
using namespace std;
typedef long long ll;
int n,u,v;
vector<vector<int>> g;
vector<int> dist;
void dfs(int x){
for(auto nx:g[x]){
if(dist[nx]!=-1) continue;
dist[nx]=dist[x]+1;
dfs(nx);
}
}
int main(){
cin>>n>>u>>v;
u--; v--;
g.resize(n);
dist.assign(n,-1);
rep(i,n-1){
int a,b;
cin>>a>>b;
a--; b--;
g[a].pb(b);
g[b].pb(a);
}
dist[v]=0;
dfs(v);
vector<int> dist2(n);
rep(i,n) dist2[i]=dist[i];
dist.assign(n,-1);
dist[u]=0;
dfs(u);
int res=0;
rep(i,n){
if(g[i].size()==1){
if(dist2[i]>dist[i]) res=max(res,dist2[i]);
}
}
cout<<res-1<<endl;
} | 0 | CPP |
input()
d={}
s=0
for i in map(int,input().split()):
while i in d and i:i-=1
d[i]=1
s+=i
print(s)
# Made By Mostafa_Khaled | 8 | PYTHON3 |
"""n1=[0,1,3,4,7,8,9]
n2=[2,8]
n3=[3,8,9]
n4=[4,8,9]
n5=[5,9,8,6]
n6=[6,8]
n7=[8,9,7,3,0]
n8=[8]
n9=[8,9]
n0=[0,8]"""
x=int(input())
ones=int(x%10)
tens=int(x/10)
def get_num(y):
if y==0 or y==9 or y==6 or y==2:
return 2
elif y==1:
return 7
elif y==3 or y==4:
return 3
elif y==5:
return 4
elif y==7:
return 5
elif y==8:
return 1
print (get_num(ones)*get_num(tens))
| 7 | PYTHON3 |
N=int(input())
ans = 0
for i in range(105,N+1,2):
if len([j for j in range(1,i+1) if i % j == 0]) == 8:
ans+=1
print(ans) | 0 | PYTHON3 |
import io,os
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def binarySearch(arr,l,r,x):
if(l<=r):
mid = (l+r)//2
if(arr[mid]==x):
return mid
elif(arr[mid]>x):
return binarySearch(arr,l,mid-1,x)
else:
return binarySearch(arr,mid+1,r,x)
return -1
def split(arr,l,r):
global sums
if(l<r):
mid = (arr[l]+arr[r])/2
i=r-1
while(arr[i]>mid):
i-=1
if(mid==arr[r]):
if(l==0):
sums.append(prefix[r])
else:
sums.append(prefix[r]-prefix[l-1])
elif(l==0):
sums.append(prefix[i])
sums.append(prefix[r]-prefix[i])
#print("l r i",l,r,i)
split(arr,l,i)
split(arr,i+1,r)
return 1
else:
sums.append(prefix[i]-prefix[l-1])
sums.append(prefix[r]-prefix[i])
#print("l r i",l,r,i)
split(arr,l,i)
split(arr,i+1,r)
return 1
elif(l==r):
sums.append(a[l])
return -1
for w in range(int(input())):
n,q=tuple(map(int,input().split()))
a=list(map(int,input().split()))
a=sorted(a)
prefix=[0]*n
prefix[0]=a[0]
for i in range(1,n):
prefix[i] = prefix[i-1] + a[i]
sums=[prefix[-1]]
split(a,0,n-1)
sums=sorted(sums)
for query in range(q):
s=int(input())
if(binarySearch(sums,0,len(sums)-1,s)==-1):
print("No")
else:
print("Yes")
#print(sums,a) | 10 | PYTHON3 |
t = int(input())
from collections import defaultdict
class FailUpdate(Exception):
pass
def must_have_value(w, idx, val):
if w[idx] != "" and w[idx] != val:
raise FailUpdate()
w[idx] = val
def solve():
s = input()
n = len(s)
x = int(input())
w = [""] * n
deps = defaultdict(list)
for i in range(0, n):
left = i-x
right = i+x
if left >= 0:
deps[i].append(left)
if right <= n-1:
deps[i].append(right)
try:
for i in range(n):
if len(deps[i]) == 0 and s[i] == "1":
return -1
for i in range(n):
if len(deps[i]) == 1:
must_have_value(w, deps[i][0], s[i])
for i in range(n):
if len(deps[i]) == 2 and s[i] == "0":
dep1, dep2 = deps[i]
must_have_value(w, dep1, "0")
must_have_value(w, dep2, "0")
except FailUpdate:
return "-1"
for i in range(n):
if len(deps[i]) == 2 and s[i] == "1":
dep1, dep2 = deps[i]
if w[dep1] == "0" and w[dep2] == "0":
return "-1"
for i in range(n):
if w[i] == "":
w[i] = "1"
return "".join(w)
for __ in range(t):
print(solve())
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, d, mn = -111111;
int main() {
ios_base::sync_with_stdio(0);
cin >> a >> b >> c >> d;
for (long long i = 0; i <= 4000; i++) {
for (long long j = 0; j <= 4000; j++) {
if (b + i * a == d + j * c) {
if (mn == -111111) {
mn = d + j * c;
} else
mn = min(mn, d + j * c);
}
}
}
if (-111111 == mn)
cout << -1;
else
cout << mn;
return 0;
}
| 7 | CPP |
#include <iostream>
using namespace std;
int main()
{
char x;
cin>>x;
cout<<++x<<endl;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string row;
int Br[64], Bc[64], Wr[64], Wc[64], iB = 0, iW = 0;
for (int r = 0; r < 8; r++) {
cin >> row;
for (int c = 0; c < 8; c++)
if (row[c] == 'W') {
Wr[iW] = r;
Wc[iW] = c;
iW++;
} else if (row[c] == 'B') {
Br[iB] = r;
Bc[iB] = c;
iB++;
}
}
int mB = 10, mW = 10;
for (int i = 0; i < iB; i++) {
for (int j = 0; j < iW; j++)
if (Wc[j] == Bc[i] && Wr[j] > Br[i]) goto BB;
mB = min(mB, 7 - Br[i]);
BB:;
}
for (int i = 0; i < iW; i++) {
for (int j = 0; j < iW; j++)
if (Bc[j] == Wc[i] && Br[j] < Wr[i]) goto WW;
mW = min(mW, Wr[i]);
WW:;
}
if (mB >= mW)
cout << 'A' << endl;
else
cout << 'B' << endl;
}
| 7 | CPP |
#include <algorithm>
#include <iostream>
#include <string>
#include <set>
#include <vector>
using namespace std;
bool check(string s, string t){
for(int i = 1; i < 26; ++i){
for(int j = 0; j < (int)s.size(); ++j){
if(s[j] == 'a' + i){
--s[j];
if(s[j] != t[j]) return false;
break;
}
if(s[j] < 'a'+i && s[j] != t[j]) return false;
}
}
return true;
}
void make(set<string> &S, string s, string ret, int i){
//cout << ret << endl;
if(s.size() == ret.size()) S.insert(ret);
string ret1 = ret + string(1,s[i]), ret2 = ret + string(1,s[i]+1);
//cout << ret1 << " " << ret2 << endl;
if(check(ret1,s)) make(S,s,ret1,i+1);
if(s[i] < 'z' && check(ret2,s)) make(S,s,ret2,i+1);
}
int main(){
string s;
while(cin >> s, s != "#"){
set<string> S;
make(S,s,"",0);
cout << S.size() << endl;
if(S.size() < 11){
for(set<string>::iterator itr = S.begin(); itr != S.end(); ++itr)
cout << *itr << endl;
}else{
set<string>::iterator itr = S.begin();
vector<string> V;
for(int i = 0; i < 5; ++i){
V.push_back(*itr);
++itr;
}
itr = S.end();
for(int i = 0; i < 5; ++i){
--itr;
V.push_back(*itr);
}
sort(V.begin(),V.end());
for(int i = 0; i < 10; ++i)
cout << V[i] << endl;
}
}
return 0;
} | 0 | CPP |
def count(t1, t2, k, a, b):
s = a * t1
s -= s * k / 100
s += b * t2
return s
def my_format(a):
a = str(a)
i = 0
while i < len(a) and a[i] != ".":
i += 1
a = a[:min(len(a), i + 2)]
return a
n, t1, t2, k = map(int, input().split())
a = [0] * n
b = [0] * n
s = [(0, 0) for i in range(n)]
for i in range(n):
a[i], b[i] = map(int, input().split())
s[i] = (-max(count(t1, t2, k, b[i], a[i]), count(t1, t2, k, a[i], b[i])), i + 1)
s.sort()
for i in s:
print(i[1], "%.2f" % -i[0]) | 8 | PYTHON3 |
#include <vector>
#include <set>
#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;
using vector2D = vector< vector<int> >;
const int B = 5;
int N;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
struct State {
vector2D board;
int x, y;
};
vector<int> score;
long long int solve(vector2D board) {
long long int ret = 0, bonus = 1;
for(; ; bonus++) {
bool update = false;
vector2D checked(B, vector<int>(B));
for(int i=0; i<B; i++) {
for(int j=0; j<B; j++) {
// empty
if(board[i][j] == 0) continue;
vector<int> dirs = {2, 0};
for(auto k : dirs) {
// right or down
int cons = 0;
int nx = i, ny = j;
while(nx < B && ny < B) {
if(board[nx][ny] != board[i][j]) break;
cons++;
nx += dx[k], ny += dy[k];
}
if(cons >= 3) {
update = true;
nx = i, ny = j;
while(nx < B && ny < B) {
if(board[nx][ny] != board[i][j]) break;
checked[nx][ny] = 1;
nx += dx[k], ny += dy[k];
}
}
}
}
}
// printf("bonus = %lld, update = %d\n", bonus, update);
if(!update) break;
for(int i=0; i<B; i++) {
for(int j=0; j<B; j++) {
// empty or no change
if(board[i][j] == 0 || checked[i][j] == false) continue;
int col = board[i][j] - 1;
board[i][j] = 0;
ret += bonus * score[col];
}
}
// blockfall
for(int i=B-1; i>=0; i--) {
for(int j=0; j<B; j++) {
int row = i;
for(; row < B-1 && board[row+1][j] == 0; row++) {
swap(board[row][j], board[row+1][j]);
}
}
}
}
return ret;
}
int main() {
while(cin >> N, N >= 0) {
vector2D board(B, vector<int>(B));
for(int i=0; i<B; i++) {
for(int j=0; j<B; j++) {
cin >> board[i][j];
}
}
score.clear();
for(int i=0; i<B; i++) {
int val; cin >> val;
score.push_back(val);
}
set<vector2D> cand;
cand.insert(board);
queue<State> que;
for(int i=0; i<B; i++) {
for(int j=0; j<B; j++) {
que.push(State{board, i, j});
}
}
// printf("enumerate begin\n");
for(int i=0; i<N; i++) {
queue<State> nxt;
while(que.size()) {
State cur = que.front(); que.pop();
vector2D board = cur.board;
int x = cur.x, y = cur.y;
for(int k=0; k<4; k++) {
int nx = x + dx[k], ny = y + dy[k];
if(nx < 0 || nx >= B || ny < 0 || ny >= B) continue;
swap(board[x][y], board[nx][ny]);
nxt.push(State{board, nx, ny});
cand.insert(board);
swap(board[x][y], board[nx][ny]);
}
}
swap(nxt, que);
}
// printf("enumerate end\n");
long long int ans = 0;
for(auto b : cand) {
ans = max(ans, solve(b));
}
cout << ans << endl;
}
return 0;
}
| 0 | CPP |
n,q = map(int, input().split())
a = []
t = 0
for i in range(n):
a.append(input().split())
while len(a) != 0:
proc = a.pop(0)
if int(proc[1]) <= q:
t += int(proc[1])
print(proc[0],t)
else:
t += q
proc[1] = int(proc[1]) - q
a.append(proc)
| 0 | PYTHON3 |
n = int(input())
cands= input()
cands = cands.split(" ")
cands = list(map(int, cands))
##print(cands)
counter = 0
while cands[0] <= max(cands[1:]):
idxMax = cands.index(max(cands[1:]))
if cands[0] == max(cands[1:]):
cands[0] += 1
cands[idxMax] -= 1
counter += 1
break
else:
cands[idxMax] -= 1
cands[0] += 1
counter += 1
print(counter)
| 7 | PYTHON3 |
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#define N 300005
typedef long long ll;
using namespace std;
ll M = 998244353;
ll n, a, b, k, i, ans=0;
ll inv[N], fac[N], fiv[N];
ll comb(ll p) {
return fac[n] * fiv[p] % M * fiv[n-p] % M;
}
int main() {
cin >> n >> a >> b >> k;
inv[1]=fac[1]=fiv[1]=inv[0]=fac[0]=fiv[0]=1;
for (i = 2; i <= n; i++) {
fac[i] = fac[i-1] * i % M;
inv[i] = inv[M%i] * (M-M/i) % M;
fiv[i] = fiv[i-1] * inv[i] % M;
}
for (i = 0; i <= n; i++) {
if ((k-i*a) % b == 0 && k >= i*a && (k-i*a)/b <= n) {
ans += comb(i) * comb((k-i*a)/b) % M;
}
}
cout << ans%M << endl;
return 0;
} | 0 | CPP |
from math import gcd
for _ in range(int(input())):
n=int(input())
for i in range((n-1)//2,0,-1):
if gcd(i,n-1-i)==1:
print(i,n-i-1,1)
break
| 8 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
double a,b,x;
cin >> a >> b >> x;
double y = 2*x/(a*a) - b;
double t = a/(b-y);
if(x<a*a*b/2) t = 2*x/(a*b*b);
printf("%lf\n",90.0-atan(t)*(180/M_PI));
return 0;
}
| 0 | CPP |
import sys
input = sys.stdin.readline
Q = int(input())
Query = [list(map(int, input().split())) for _ in range(Q)]
for N, K in Query:
state = [[0]*N for _ in range(N)]
if K%N == 0:
print(0)
h1 = K//N
for i in range(h1):
for r in range(N):
state[r][(r+i)%N] = 1
for i in range(h1, N):
for r in range(N):
state[r][(r+i)%N] = 0
else:
print(2)
h1 = K//N
am = K%N
for k in range(N):
state[k][k] = 1 if k < am else 0
for i in range(1, h1+1):
for r in range(N):
state[r][(r+i)%N] = 1
for i in range(h1+1, N):
for r in range(N):
state[r][(r+i)%N] = 0
for s in state:
print(*s, sep="") | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a1, a2, a3, a4, a5, a6;
cin >> a1 >> a2 >> a3 >> a4 >> a5 >> a6;
int res = (a1 + a2 + a3) * (a1 + a2 + a3) - a1 * a1 - a5 * a5 - a3 * a3;
cout << res;
return 0;
}
| 7 | CPP |
import math
x = 0
y = 0
angle = math.pi / 2
while(1):
d, a = map(int, input().split(","))
if d == 0 and a == 0:
break
x += math.cos(angle) * d
y += math.sin(angle) * d
angle -= a * math.pi / 180
print(int(x))
print(int(y))
| 0 | PYTHON3 |
n=int(input())
l=list(map(int,input().split()))
d=dict()
for i in range(n):
d[l[i]]=i+1
for i,j in d.items():
l[i-1]=j
print(*l)
| 7 | PYTHON3 |
def kvbin(sd) :
for i in range(len(sd)) :
if sd[i] != '1' and sd[i] != '0' :
sd = sd[:i] + '1' + sd[i + 1:]
return sd
n = int(input())
s = str(n)
for i in range(len(s)) :
if s[i] != '1' and s[i] != '0' :
s = s[:i] + '1' + s[i + 1:]
ans = []
while n != 0 :
s = kvbin(str(n))
sint = int(s)
s = str(sint)
ans.append(s)
n -= sint
print(len(ans))
for i in ans :
print(i, end = ' ')
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long sign = 1;
long long x = 0;
char ch;
while (!isdigit(ch = getchar()))
if (ch == '-') sign = -1;
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x * sign;
}
inline void write(long long k) {
if (k < 0) putchar('-'), k *= -1;
char ch[20];
int num = 0;
while (k) ch[++num] = k % 10, k /= 10;
if (num == 0) ch[++num] = 0;
while (num) putchar(ch[num--] + '0');
}
vector<pair<long long, long long>> edge[200010];
long long n, c[200010], in, loop, le, ans = 1;
bool used[200010];
long long powe(long long base, long long exp) {
if (exp == 0) return 1;
if (exp == 1) return base;
long long data = powe(base, exp / 2);
if (exp % 2 == 0)
data *= data;
else
data *= data * base;
return data % 1000000007;
}
void dfs(long long pos, long long pp) {
if (c[pos] == 0) {
c[pos] = pp + 1;
for (auto to : edge[pos])
if (!used[to.second]) used[to.second] = true, dfs(to.first, c[pos]);
} else {
loop = pp - c[pos] + 1;
le -= loop;
ans = ans * (powe(2, loop) - 2) % 1000000007;
}
}
int main() {
n = read();
le = n;
for (register long long i = (1); i <= (n); i++) {
in = read();
edge[in].push_back({i, i});
edge[i].push_back({in, i});
}
for (register long long i = (1); i <= (n); i++)
if (c[i] == 0) dfs(i, 0);
write(ans * powe(2, le) % 1000000007);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
int main(){
int d, n; cin >> d >> n;
int t[d]; rep(i, d) cin >> t[i];
int a[n], b[n], c[n]; rep(i, n) cin >> a[i] >> b[i] >> c[i];
int dp[d][n];
memset(dp, 0, sizeof(dp));
rep(i, d)rep(j, n){
if(!i) {
if(a[j] <= t[i] && t[i] <= b[j]) dp[i][j] = c[j];
else dp[i][j] = -1;
} else if(a[j] <= t[i] && t[i] <= b[j]){
rep(k, n){
if(dp[i-1][k] > -1){
int base = (i == 1) ? 0 : dp[i-1][k];
dp[i][j] = max(dp[i][j], base + abs(c[k] - c[j]));
}
}
} else dp[i][j] = -1;
}
cout << *max_element(dp[d-1], dp[d-1]+n) << endl;
return 0;
}
| 0 | CPP |
from sys import stdin
input = stdin.readline
tests = int(input())
for test in range(tests):
n, m = map(int, input().split())
a = [[0] * m for _ in range(n)]
r = [[int(i) for i in input().split()] for _ in range(n)]
c = [[int(i) for i in input().split()] for _ in range(m)]
z = [[-1, -1] for _ in range(n * m + 1)]
for i in range(n):
for j in range(m):
z[r[i][j]][0] = j
for i in range(m):
for j in range(n):
z[c[i][j]][1] = j
for i in range(1, n * m + 1):
a[z[i][1]][z[i][0]] = i
for i in a:
print(' '.join([str(j) for j in i]))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
long long t, j, i, n, x, a, b, c, otv, k, q, p, z, l, r;
cin >> t;
b = 0;
for (j = 0; j < t; ++j) {
cin >> n >> q;
vector<long long int> all(n + 1);
vector<long long int> raz(n + 1);
all[0] = 0;
otv = 0;
for (i = 1; i <= n; ++i) {
cin >> all[i];
raz[i] = all[i] - all[i - 1];
otv += max(b, raz[i]);
}
cout << otv << endl;
for (i = 0; i < q; ++i) {
cin >> l >> r;
if (r == l)
cout << otv << endl;
else {
if (r == l + 1) {
otv -= max(b, raz[l]) + max(b, raz[l + 1]);
if (r < n) {
otv -= max(b, raz[r + 1]);
}
x = all[l];
all[l] = all[r];
all[r] = x;
raz[l] = all[l] - all[l - 1];
raz[l + 1] = all[l + 1] - all[l];
if (r < n) {
raz[r + 1] = all[r + 1] - all[r];
otv += max(b, raz[l]) + max(b, raz[l + 1]) + max(b, raz[r + 1]);
} else
otv += max(b, raz[l]) + max(b, raz[l + 1]);
} else {
otv -= max(b, raz[l]) + max(b, raz[l + 1]) + max(b, raz[r]);
if (r < n) {
otv -= max(b, raz[r + 1]);
}
x = all[l];
all[l] = all[r];
all[r] = x;
raz[l] = all[l] - all[l - 1];
raz[l + 1] = all[l + 1] - all[l];
raz[r] = all[r] - all[r - 1];
if (r < n) {
raz[r + 1] = all[r + 1] - all[r];
otv += max(b, raz[l]) + max(b, raz[l + 1]) + max(b, raz[r + 1]) +
max(b, raz[r]);
} else
otv += max(b, raz[l]) + max(b, raz[l + 1]) + max(b, raz[r]);
}
cout << otv << endl;
}
}
}
return 0;
}
| 9 | CPP |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import random
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def main():
n,m = LI()
aa = [S() for _ in range(n)]
t = 0
r = 0
c = 0
for i in range(n):
ai = aa[i]
for j in range(m):
if ai[j] == 'B':
t += 1
r += i
c += j
return '{} {}'.format(r//t+1, c//t+1)
print(main())
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, a, b, c, d, n, t, x, y;
while (cin >> n) {
while (n--) {
cin >> a >> b >> c >> d;
if (a > b) {
t = a;
a = b;
b = t;
}
if (d == 0 || c - d >= b || c + d <= a)
cout << (b - a) << endl;
else {
x = c - d;
y = c + d;
if (x >= a && y <= b)
cout << (b - a - y + x) << endl;
else if (x <= a && y >= b)
cout << 0 << endl;
else if (x < a && y > a && y <= b)
cout << (b - y) << endl;
else if (x > a && x < b && y > b)
cout << (x - a) << endl;
}
}
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main(){
int a,b;
cin>>a>>b;
cout<<((a==b)?"Yes":"No");
return 0;
} | 0 | CPP |
def remove_smallest(elements):
if len(elements) == 0:
return "NO"
elif len(elements) == 1:
return "YES"
elements.sort()
for i in range(len(elements) - 1):
if abs(elements[i+1] - elements[i]) <= 1:
continue
return "NO"
return "YES"
number_banks = int(input())
for _ in range(number_banks):
num_elem_in_bank = input()
bank = [int(el) for el in input().split(" ")]
print(remove_smallest(bank))
| 7 | PYTHON3 |
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda:sys.stdin.readline().rstrip()
def resolve():
n,a,b,c,d=map(int,input().split())
for k in range(n): # k 右に行った回数
L=a+k*c-(n-k-1)*d
R=a+k*d-(n-k-1)*c
if(L<=b<=R):
print("YES")
return
print("NO")
resolve() | 0 | PYTHON3 |
import sys
input = sys.stdin.readline
from collections import defaultdict, Counter, deque
n, m, k = map(int, input().split())
P = [input()[:-1] for _ in range(n)]
S = [list(input().split()) for _ in range(m)]
idx = {p: i for i, p in enumerate(P, 1)}
G = defaultdict(list)
deg = Counter()
for s, i in S:
i = int(i)
cand = set()
for mask in range(1 << k):
cur = ['_'] * k
for j in range(k):
if mask >> j & 1: cur[j] = s[j]
cur = "".join(cur)
if cur in idx:
cand.add(idx[cur])
if i not in cand:
print("NO")
break
for c in cand:
if c == i: continue
G[i].append(c)
deg[c] += 1
else:
ans = []
q = deque([i for i in range(1, n + 1) if not deg[i]])
while q:
i = q.popleft()
ans.append(i)
for j in G[i]:
deg[j] -= 1
if not deg[j]:
q.append(j)
if len(ans) < n:
print("NO")
else:
print("YES")
print(*ans) | 11 | PYTHON3 |
q=input('')
w=input('')
t=0
if q=='monday':
e=1
elif q=='tuesday':
e=2
elif q=='wednesday':
e=3
elif q=='thursday':
e=4
elif q=='friday':
e=5
elif q=='saturday':
e=6
else:
e=7
if w=='monday':
r=1
elif w=='tuesday':
r=2
elif w=='wednesday':
r=3
elif w=='thursday':
r=4
elif w=='friday':
r=5
elif w=='saturday':
r=6
else:
r=7
if e==r:
t=1
elif e==r-2:
t=1
elif e==r-3:
t=1
elif e==r+5:
t=1
elif e==r+4:
t=1
if t==1:
print('YES')
else:
print('NO') | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, a, countN, countM;
while (cin >> n && cin >> m && cin >> a) {
if (n % a == 0)
countN = n / a;
else
countN = (n / a) + 1;
if (m % a == 0)
countM = m / a;
else
countM = (m / a) + 1;
cout << countN * countM << endl;
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long miu[100010], f[100010], p[100010];
long long N, M, L, R, P, len, res, ans;
long long calc(long long d, long long x, long long R2) {
if (R2 < d * x * d * x) return 0;
long long r = min(M / d, (long long)sqrt(R2 - d * x * d * x) / d);
return (2 * M % P - d * (r + 1) % P + 2) * r % P;
}
int main() {
scanf("%I64d%I64d%I64d%I64d%I64d", &N, &M, &L, &R, &P);
miu[1] = 1;
for (long long i = 2; i <= 100000; i++) {
if (!f[i]) {
f[i] = i;
p[++len] = i;
miu[i] = -1;
}
for (long long j = 1; j <= len && p[j] * i <= 100000 && p[j] <= f[i]; j++) {
f[p[j] * i] = p[j];
if (f[p[j] * i] == f[i])
miu[p[j] * i] = 0;
else
miu[p[j] * i] = -miu[i];
}
}
for (long long d = 1; d <= min(N, M); d++) {
for (long long x = 1; x <= N / d; x++) {
res = calc(d, x, R * R);
res = res - calc(d, x, L * L - 1);
ans = (ans + res % P * miu[d] % P * (N - d * x + 1) % P) % P;
}
}
if (L == 1) ans = (ans + 2 * N * M % P + N + M) % P;
printf("%I64d\n", (ans + P) % P);
}
| 11 | CPP |
#include<bits/stdc++.h>
using namespace std;
int N,L;
int t[100005];
int ans[100005];
int main(){
cin>>N>>L;
for(int i=1;i<=N;i++)cin>>t[i];
queue<int> Q;
for(int i=1;i<=N;i++){
if(t[i-1]<t[i]&&t[i]>t[i+1]){
Q.push(i);
ans[i]=L-t[i];
}
}
while(!Q.empty()){
int p=Q.front();Q.pop();
t[p]=0;
if(1<=p-1){
if(t[p-2]<t[p-1]){
ans[p-1]=ans[p]+L-t[p-1];
Q.push(p-1);
}
}
if(p+1<=N){
if(t[p+1]>t[p+2]){
ans[p+1]=ans[p]+L-t[p+1];
Q.push(p+1);
}
}
}
int maxm=0;
for(int i=1;i<=N;i++)maxm=max(maxm,ans[i]);
cout<<maxm<<endl;
return 0;
} | 0 | CPP |
#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 202;
const ll mod = 1e9+7;
int n;ll F[N][N];
int f[N][10],LCA[N][N],d[N];
vector<int> G[N];
ll qpow(ll a,ll b){
if(b==0) return 1ll;
ll p = qpow(a,b/2);
p = p*p%mod;
if(b&1) p = p * a %mod;
return p;
}
void dfs(int x,int fa){
f[x][0]=fa;
d[x]=d[fa]+1;
for(auto p:G[x]){
if(p==fa) continue;
dfs(p,x);
}
}
int getlca(int x,int y){
if(d[x]<d[y])
std::swap(x,y);
for(int i=9;i+1;--i)
if(d[f[x][i]]>=d[y])
x=f[x][i];
if(x==y) return x;
for(int i=9;i+1;--i){
if(f[x][i]!=f[y][i])
x=f[x][i],y=f[y][i];
}
return f[x][0];
}
int main(){
scanf("%d",&n);
for(int i=1;i<=n-1;++i){
int a,b;
scanf("%d%d",&a,&b);
G[a].push_back(b);
G[b].push_back(a);
}
for(int i=1;i<=n;++i) F[0][i]=1;
ll inv2 = qpow(2,mod-2);
for(int i=1;i<=n;++i)
for(int j=1;j<=n;++j)
F[i][j] = (F[i-1][j]+F[i][j-1])*inv2%mod;
ll ans = 0 ;
for(int i=1;i<=n;++i){
memset(f,0,sizeof f);
memset(d,0,sizeof d);
dfs(i,0);
for(int j=1;j<10;++j){
for(int k=1;k<=n;++k)
f[k][j]=f[f[k][j-1]][j-1];
}
for(int i=1;i<=n;++i){
for(int j=1;j<i;++j){
int lca = getlca(i,j);
ans = (ans + F[d[i]-d[lca]][d[j]-d[lca]])%mod;
}
}
}
printf("%lld\n",ans*qpow(n,mod-2)%mod);
return 0;
} | 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, ans[110], lst1, lst2, tmp1, tmp2;
pair<int, int> a[110];
int main() {
scanf("%d%d%d", &n, &lst1, &lst2);
for (int i = n - 1; i >= 3; i--) {
cout << "+ " << i << endl;
fflush(stdout);
scanf("%d%d", &a[i].first, &a[i].second);
tmp1 = a[i].first;
tmp2 = a[i].second;
a[i].first -= lst1;
a[i].second -= lst2;
lst1 = tmp1;
lst2 = tmp2;
}
pair<int, int> t[4];
cout << "+ " << 1 << endl;
fflush(stdout);
scanf("%d%d", &t[1].first, &t[1].second);
tmp1 = t[1].first;
tmp2 = t[1].second;
t[1].first -= lst1;
t[1].second -= lst2;
lst1 = tmp1;
lst2 = tmp2;
cout << "+ " << 2 << endl;
fflush(stdout);
scanf("%d%d", &t[2].first, &t[2].second);
tmp1 = t[2].first;
tmp2 = t[2].second;
t[2].first -= lst1;
t[2].second -= lst2;
lst1 = tmp1;
lst2 = tmp2;
cout << "+ " << 1 << endl;
fflush(stdout);
scanf("%d%d", &t[3].first, &t[3].second);
tmp1 = t[3].first;
tmp2 = t[3].second;
t[3].first -= lst1;
t[3].second -= lst2;
lst1 = tmp1;
lst2 = tmp2;
ans[1] = t[3].first - t[1].first;
ans[3] = t[3].second - t[1].second - 1;
ans[2] = t[1].second / (ans[3] + 1);
ans[4] = t[2].second / (ans[3] + 1) - ans[1] - 2;
if (n == 4) ans[4]++;
for (int i = 5; i <= n; i++)
ans[i] = (a[i - 2].second - ans[i - 3] * ans[i - 4] -
ans[i - 3] * (ans[i - 1] + 1)) /
(ans[i - 1] + 1) -
(i != n);
cout << "! ";
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
puts("");
fflush(stdout);
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int in() {
int a;
scanf("%d", &a);
return a;
}
double din() {
double a;
scanf("%lf", &a);
return a;
}
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
const double eps = 1e-8;
const int INF = 999999999;
int main() {
string a, b;
int k, h;
cin >> a >> b;
int res = 0;
for (int i = 0; i < a.size(); ++i) {
k = i;
h = 0;
for (int j = 0; j < b.size() && k < a.size(); ++j, ++k) {
if (a[k] == b[j]) {
h++;
res = max(h, res);
}
}
}
for (int i = 0; i < b.size(); ++i) {
k = i;
h = 0;
for (int j = 0; j < a.size() && k < b.size(); ++j, ++k) {
if (b[k] == a[j]) {
h++;
res = max(h, res);
}
}
}
res = (int)b.size() - res;
cout << res;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int sum[100010 * 30], ls[100010 * 30], rs[100010 * 30];
int a[100010], b[100010], root[100010], h[100010];
int n, m, tot, cnt, k;
vector<int> v[100010];
void insert(int last, int &x, int y, int l, int r) {
sum[x = ++tot] = sum[last] + 1;
ls[x] = ls[last];
rs[x] = rs[last];
if (l == r) return;
int mid = l + r >> 1;
if (y <= mid)
insert(ls[last], ls[x], y, l, mid);
else
insert(rs[last], rs[x], y, mid + 1, r);
}
int ask(int ss, int tt, int l, int r, int y) {
if (l == r) return sum[tt] - sum[ss];
int mid = l + r >> 1;
if (y <= mid)
return ask(ls[ss], ls[tt], l, mid, y);
else
return sum[ls[tt]] - sum[ls[ss]] + ask(rs[ss], rs[tt], mid + 1, r, y);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
v[a[i]].push_back(i);
}
h[++cnt] = 0;
for (int i = 1; i <= 100000; i++) {
int sz = v[i].size();
if (sz == 0) continue;
for (int j = 0; j < sz; j++) {
if (j - k < 0)
b[v[i][j]] = 0;
else
h[++cnt] = b[v[i][j]] = v[i][j - k];
}
}
sort(h + 1, h + cnt + 1);
cnt = unique(h + 1, h + cnt + 1) - h - 1;
for (int i = 1; i <= n; i++) {
b[i] = lower_bound(h + 1, h + cnt + 1, b[i]) - h;
insert(root[i - 1], root[i], b[i], 1, cnt);
}
int q;
scanf("%d", &q);
int last = 0;
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
l = (l + last) % n + 1;
r = (r + last) % n + 1;
if (l > r) swap(l, r);
int y = lower_bound(h + 1, h + cnt + 1, l) - h - 1;
if (y == 0)
printf("%d\n", last = 0);
else
printf("%d\n", last = ask(root[l - 1], root[r], 1, cnt, y));
}
}
| 11 | CPP |
n, m = map(int, input().split())
a = sorted(list(map(int, input().split())))
if a[n // 2] == m:
print(0)
elif a[n // 2] < m:
s = 0
for i in range(n // 2, n):
s += max(m - a[i], 0)
print(s)
else:
s = 0
for i in range(n // 2 + 1):
s += max(a[i] - m, 0)
print(s) | 8 | PYTHON3 |
from math import floor, log2
def get_sum(x):
return (x * (x + 1)) // 2 + 2 - 2 ** (floor(log2(x)) + 2)
t = int(input())
ans = list()
for i in range(t):
n = int(input())
ans.append(get_sum(n))
print('\n'.join(map(str, ans)))
| 7 | PYTHON3 |
stops=int(input())
m=0
passengers=0
for _ in range(stops):
a,b=map(int,input().split())
passengers=passengers-a+b
m=max(m,passengers)
print(m) | 7 | PYTHON3 |
for i in range(int(input())):
n = int(input())
c = 0
array = [int(x) for x in input().split()]
for i in array:
if i % 2 == 0:
c += 1
if n == c or (c == 0 and n % 2 == 0):
print("NO")
else:
print("YES") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct Item {
int value;
int weight;
char type;
long long date;
string name;
bool operator<(const Item& other) const {
if (value != other.value) return value < other.value;
if (weight != other.weight) return weight < other.weight;
if (type != other.type) return type < other.type;
if (date != other.date) return date < other.date;
if (name != other.name) return name < other.name;
return false;
}
};
int main() {
int n;
cin >> n;
vector<Item> v(n);
for (auto& p : v) cin >> p.value >> p.weight >> p.type >> p.date >> p.name;
sort(v.begin(), v.end());
for (auto p : v)
cout << p.value << " " << p.weight << " " << p.type << " " << p.date << " "
<< p.name << endl;
return 0;
}
| 0 | CPP |
n = int(input())
lastDigit = abs(n)%10
a = abs(n)//10
b = abs(n)//100
c = int(str(b)+str(lastDigit))
if n<0:
a-= a*2
c -= c*2
if n>=0:
print(n)
else:
print(max(a,c))
| 7 | PYTHON3 |
#include<cstdio>
#include<cstring>
#include<algorithm>
#define rep(i,a,b) for(i=a;i<=b;i++)
using namespace std;
const int N=500010,maxn=500000;
const int mod=998244353;
int inv[N],cj[N];int ans;
int power(int x,int y){
int ret=1;
for(;y;y>>=1,x=1ll*x*x%mod){
if(y&1) ret=1ll*ret*x%mod;
}
return ret;
}
void init(){
int i;
cj[0]=1;rep(i,1,maxn) cj[i]=1ll*cj[i-1]*i%mod;
inv[maxn]=power(cj[maxn],mod-2);inv[0]=1;
for(i=maxn-1;i;i--) inv[i]=1ll*inv[i+1]*(i+1)%mod;
}
int C(int n,int m){
//printf("%d %d\n",n,m);
if(m<0||n<m) return 0;
return 1ll*cj[n]*inv[m]%mod*inv[n-m]%mod;
}
int main(){
// freopen("a.in","r",stdin);
// freopen("a.out","w",stdout);
int i,n,m;
init();
scanf("%d%d",&n,&m);
rep(i,0,min(m/2-(m+1&1),m-n)){
ans=(1ll*ans+C(m,i)-C(m,i-(m-i-n+1)))%mod;
//if(2*i==m) ans=(1ll*ans-(C(m-1,i-(m-i-n))-C(m-1,i-(m-i-n+1))))%mod;
//printf("%d\n",ans);
}
i=m/2;
if(2*i==m&&i<=m-n) ans=(1ll*ans+C(m-1,i-1)-C(m-1,i-1-(m-i-n+1)))%mod;
ans=(ans%mod+mod)%mod;
printf("%d",ans);
}
| 0 | CPP |
for _ in range(int(input())):
n = int(input())
s = list(map(int, input().split()))
d = dict()
mn_sub = 10**6
for i in range(n):
if s[i] not in d:
d[s[i]] = i
else:
if i - d[s[i]] < mn_sub:
mn_sub = i - d[s[i]] + 1
d[s[i]] = i
if mn_sub == 10**6:
print(-1)
else:
print(mn_sub)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream& operator<<(ostream& out, const vector<T>& vec) {
out << "[";
for (int x : vec) out << x << ", ";
out << "]";
return out;
}
unsigned long long int k, d, t;
unsigned long long int n;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> k >> d >> t;
n = (k + d - 1) / d;
unsigned long long int m = (2ULL * t) / (k + n * d);
double t1 = (double)t - ((double)m * ((double)n * d + (double)k) / 2.0);
double ans = 0;
if (t1 <= k)
ans = t1;
else
ans = 2 * t1 - k;
ans = ans + m * (n * d);
cout.precision(20);
cout << fixed << ans << endl;
}
| 7 | CPP |
a = int(input())
flag = 0
n = a;
while flag==0:
temp = n
sum = 0
while temp >0 :
sum = sum + int(temp%10)
temp = int(temp / 10)
if sum % 4 == 0:
print(n)
flag = 1
n = n + 1
| 7 | PYTHON3 |
inp = input().lower()
vowels = ['a', 'e', 'i', 'o', 'u', 'y']
for vow in vowels:
if vow in inp:
inp = inp.replace(vow, '')
newstr = ""
for char in inp:
newstr += ('.' + char)
print(newstr) | 7 | PYTHON3 |
def main(x, y, z):
if x != y:
if y != z:
if x != z:
print('NO')
# print(x, y, z)
# return 'NO'
if x == y:
if x > z:
a = z
b = z
c = x
print('YES')
print(a, b, c)
elif x < z:
print('NO')
# return 'NO'
if z == y:
# print(x, y, z)
if x < z:
a = x
b = x
c = z
print('YES')
print(a, b, c)
elif x > z:
print('NO')
# return 'NO'
if x == z:
if y < z:
a = y
b = y
c = z
print('YES')
print(a, b, c)
elif y > z:
print('NO')
# return 'NO'
if x == y:
if y == z:
print('YES')
print(x, y, z)
if __name__ == '__main__':
t = int(input())
for t_itr in range(t):
xyz = list(map(int, input().rstrip().split()))
x = xyz[0]
y = xyz[1]
z = xyz[2]
res = main(x, y, z)
# print(res) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
int dd[N];
long long c[N];
struct data {
long long sum, pre, suf, ans;
} d[N << 2];
set<pair<int, int> > st;
vector<pair<int, int> > v;
data make_data(long long val) {
return data{val, max(0LL, val), max(0LL, val), max(0LL, val)};
}
data combine(data dl, data dr) {
data dt;
dt.sum = dl.sum + dr.sum;
dt.ans = max(dl.ans, dr.ans);
dt.ans = max(dt.ans, dl.suf + dr.pre);
dt.pre = max(dl.pre, dl.sum + dr.pre);
dt.suf = max(dr.suf, dr.sum + dl.suf);
return dt;
}
void build(int l, int r, int rt) {
if (l == r) {
d[rt] = make_data(c[l]);
} else {
int m = l + r >> 1;
build(l, m, rt << 1);
build(m + 1, r, rt << 1 | 1);
d[rt] = combine(d[rt << 1], d[rt << 1 | 1]);
}
}
data query(int L, int R, int l, int r, int rt) {
if (l >= L && R >= r) {
return d[rt];
} else {
int m = l + r >> 1;
data dt = make_data(0);
if (L <= m) dt = query(L, R, l, m, rt << 1);
if (R > m) dt = combine(dt, query(L, R, m + 1, r, rt << 1 | 1));
d[rt] = combine(d[rt << 1], d[rt << 1 | 1]);
return dt;
}
}
pair<int, int> L[N], R[N];
int main() {
int n, a;
long long ans = 0;
cin >> n >> a;
for (int i = 1; i <= n; i++) {
cin >> dd[i] >> c[i];
c[i] = a - c[i];
L[i] = R[i] = pair<int, int>{i, i};
if (i > 1) {
v.emplace_back(dd[i] - dd[i - 1], i);
}
ans = max(ans, c[i]);
}
sort(v.begin(), v.end());
build(1, n, 1);
for (pair<int, int> p : v) {
int l = p.second - 1, r = p.second;
pair<int, int> tl = R[l], tr = L[r];
ans = max(
ans, query(tl.first, tr.second, 1, n, 1).ans - 1LL * p.first * p.first);
L[tl.first] = R[tr.second] = pair<int, int>(tl.first, tr.second);
}
cout << ans << endl;
return 0;
}
| 13 | CPP |
#include <bits/stdc++.h>
int n, i, x, p[1 << 20], q[1 << 20], t[1 << 20], k;
int main() {
scanf("%d", &n);
for (i = 0; i < n && 1 == scanf("%d", &p[i]); ++i)
;
for (scanf("%d", &i); i-- > 0 && 1 == scanf("%d", &x); q[x - 1] = 1)
;
for (i = n; i-- > 0;)
if (q[i] || !k || p[i] != t[k - 1])
t[k++] = p[i], p[i] *= -1;
else
--k;
if (k)
puts("NO");
else {
puts("YES");
for (i = 0; i < n; ++i) printf("%d ", p[i]);
puts("");
}
}
| 11 | CPP |
for i in range(int(input())):
n = int(input())
l = list(map(int,input().split()))
l.sort()
print(l[n] - l[n-1])
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 3e5 + 100;
int a[N], ans[N];
vector<pair<int, int>> pos[N];
struct Node {
int l, r;
int sum;
} tree[N << 2];
void build(int k, int l, int r) {
tree[k].l = l;
tree[k].r = r;
tree[k].sum = 0;
if (l == r) return;
int mid = l + r >> 1;
build(k << 1, l, mid);
build(k << 1 | 1, mid + 1, r);
}
void update(int k, int pos) {
if (tree[k].l == tree[k].r) {
tree[k].sum++;
return;
}
int mid = tree[k].l + tree[k].r >> 1;
if (pos <= mid)
update(k << 1, pos);
else
update(k << 1 | 1, pos);
tree[k].sum = tree[k << 1].sum + tree[k << 1 | 1].sum;
}
int query_k(int k, int x) {
if (tree[k].l == tree[k].r) return tree[k].l;
if (tree[k << 1 | 1].sum >= x)
return query_k(k << 1 | 1, x);
else
return query_k(k << 1, x - tree[k << 1 | 1].sum);
}
int query(int k, int l, int r) {
if (tree[k].l > r || tree[k].r < l) return 0;
if (tree[k].l >= l && tree[k].r <= r) return tree[k].sum;
return query(k << 1, l, r) + query(k << 1 | 1, l, r);
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
a[i] = i - a[i];
if (a[i] < 0) a[i] = inf;
}
for (int i = 1; i <= m; i++) {
int l, r;
scanf("%d%d", &l, &r);
l++;
r = n - r;
pos[r].emplace_back(l, i);
}
build(1, 1, n);
int num = 0;
for (int i = 1; i <= n; i++) {
if (a[i] == 0) {
update(1, i);
num++;
} else if (num >= a[i]) {
update(1, query_k(1, a[i]));
num++;
}
for (pair<int, int> t : pos[i]) ans[t.second] = query(1, t.first, n);
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 5;
typedef int arr[N];
int n, k;
arr l, r, a, f;
inline void Solve() {
for (int i = 1, iend = (n) + 1; i < iend; ++i)
scanf("%d%d%d", l + i, r + i, a + i);
for (int i = n, iend = (1) - 1; i > iend; --i) {
int Need = a[i];
if (i < n && r[i] == l[i + 1]) Need += f[i + 1];
if (Need > (long long)(r[i] - l[i] + 1) * k) return void(puts("-1"));
f[i] = max(0ll, Need - (long long)(r[i] - l[i]) * k);
}
long long Ans = accumulate(a + 1, a + n + 1, 0ll), Cur = k;
for (int i = 1, iend = (n) + 1; i < iend; ++i) {
if (Cur < f[i]) Ans += Cur, Cur = k;
Cur = ((Cur - a[i]) % k + k) % k;
}
printf("%lld\n", Ans);
}
int main() {
while (~scanf("%d%d", &n, &k)) Solve();
return 0;
}
| 12 | CPP |
n = int(input())
p = 10
su = 0
while p <= n:
su += n//p
p*=5
if n%2==1:
print(0)
else:
print(su) | 0 | PYTHON3 |
n = int(input())
code = input()
count = 0
test = code[0]
for i in range(1, len(code)):
if code[i] == test:
count += 1
else:
test = code[i]
print(count) | 7 | PYTHON3 |
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <set>
#include <vector>
using namespace std;
const int MAXN = 400005;
int h[MAXN];
int c[MAXN];
int gao(int min, int max) {
if (min > max) {
return 0;
}
if (h[max] == min || h[min] == max) {
return gao(min + 1, max - 1);
} else {
int zheng = 0;
int fan = 0;
int value1;
int value2;
if (h[min] && h[max]) {
if (h[min] < h[max]) {
return -1;
}
value1 = h[min];
value2 = h[max];
fan = 2;
} else if (h[min] && c[max]) {
if (h[min] < c[max]) {
return -1;
}
value1 = h[min];
value2 = c[max];
zheng = 1;
fan = 1;
} else if (c[min] && h[max]) {
if (c[min] < h[max]) {
return -1;
}
value1 = c[min];
value2 = h[max];
zheng = 1;
fan = 1;
} else if (c[min] && c[max]) {
if (c[min] < c[max]) {
return -1;
}
value1 = c[min];
value2 = c[max];
zheng = 2;
}
int l = value1;
int r = value2;
int caozuo = 0;
int caozuofan = 0;
set<int> haveGet;
while (true) {
vector<int> needPutl;
vector<int> needPutr;
for (int i = min + 1; i < r; ++i) {
if (haveGet.find(i) == haveGet.end()) {
needPutl.emplace_back(i);
}
}
for (int i = max - 1; i > l; --i) {
if (haveGet.find(i) == haveGet.end()) {
needPutr.emplace_back(i);
}
}
if (needPutl.empty() && needPutr.empty()) {
int res = gao(r + 1, l - 1);
if (res == -1) {
return -1;
}
return std::min(res + caozuo + zheng, res + caozuofan + fan);
}
haveGet.clear();
min = r;
max = l;
for (int j = 0; j < needPutl.size(); ++j) {
int i = needPutl[j];
if (h[i]) {
if (h[i] > l || h[i] < r) {
return -1;
}
l = h[i];
++caozuofan;
} else {
if (c[i] > l || c[i] < r) {
return -1;
}
l = c[i];
++caozuo;
}
haveGet.insert(l);
}
for (int j = 0; j < needPutr.size(); ++j) {
int i = needPutr[j];
if (h[i]) {
if (h[i] > l || h[i] < r) {
return -1;
}
r = h[i];
++caozuofan;
} else {
if (c[i] > l || c[i] < r) {
return -1;
}
r = c[i];
++caozuo;
}
haveGet.insert(r);
}
}
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int a, b;
scanf("%d%d", &a, &b);
h[a] = b;
c[b] = a;
}
int res = gao(1, n * 2);
printf("%d\n", res);
return 0;
}
| 10 | CPP |
"""
Author: Q.E.D
Time: 2020-09-04 09:36:27
"""
T = int(input())
for _ in range(T):
a, b = list(map(int, input().split()))
d = abs(a - b)
ans = d // 10 + int(d % 10 > 0)
print(ans) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long p = 998244353;
long long l[2010][2010], r[2010][2010];
char s[2020];
signed main() {
scanf("%s", s + 1);
long long n = strlen(s + 1);
l[0][0] = 1;
r[n + 1][0] = 1;
for (long long i = 1; i <= n; i++) {
if (s[i] == '(' || s[i] == '?') {
for (long long j = 1; j <= n; j++)
l[i][j] = (l[i][j] + l[i - 1][j - 1]) % p;
}
if (s[i] == ')' || s[i] == '?')
for (long long j = 0; j <= n; j++) {
l[i][j] = (l[i - 1][j] + l[i][j]) % p;
}
}
for (long long i = n; i >= 1; i--) {
if (s[i] == ')' || s[i] == '?')
for (long long j = 1; j <= n; j++)
r[i][j] = (r[i][j] + r[i + 1][j - 1]) % p;
if (s[i] == '(' || s[i] == '?')
for (long long j = 0; j <= n; j++) r[i][j] = (r[i + 1][j] + r[i][j]) % p;
}
long long ans = 0;
for (long long i = 2; i <= n; i++) {
long long x = min(i - 1, n - i + 1);
for (long long j = 1; j <= x; j++) {
ans = (ans + l[i - 1][j] * r[i][j] % p * j % p) % p;
}
}
printf("%lld", ans);
}
| 10 | CPP |
# cook your dish here
t=int(input())
while t>0:
n=int(input())
a=[[0]*2]*n
for i in range(0,n):
a[i]=[int (x) for x in input().split()]
a.sort()
f=0
for i in range(0,n-1):
if(a[i][1]>a[i+1][1]):
f=1
if(f==1):
print("NO")
else:
print("YES")
x=a[0][0]
while x>0:
print("R",end="")
x-=1
y=a[0][1]
while y>0:
print("U",end="")
y-=1
for i in range(0,n-1):
x=a[i+1][0]-a[i][0]
y=a[i+1][1]-a[i][1]
while x>0:
print("R",end="")
x-=1
while y>0:
print("U",end="")
y-=1
print("")
t-=1 | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
double f[1010][1010];
double Ans;
inline double F(int n, int m) {
double A = 0, B = 0, C = 0, P = 0;
if (!n) return 1.0 / (m + 1);
if (!m) return 1;
if (f[n][m]) return f[n][m];
A = 1.0 * m / (m + 1) * (1 - F(m - 1, n));
B = 1.0 / (m + 1) + 1.0 * m / (m + 1) * (1 - F(m - 1, n)) + F(m, n - 1);
C = -F(m, n - 1);
P = C / (A - B);
return f[n][m] = P * A + (1 - P);
}
int main() {
scanf("%d%d", &m, &n);
Ans = F(m, n);
printf("%.10lf %.10lf\n", Ans, 1 - Ans);
return 0;
}
| 11 | CPP |
#include<bits/stdc++.h>
using namespace std;
int main(){
long double a,b,c;
cin >> a >> b >> c;
if(sqrt(4*a*b)+a+b<c)cout << "Yes" << endl;
else cout << "No" << endl;
}
| 0 | CPP |
s = int(input())
numPull = s // 100
s = s % 100
numPull = numPull + s // 20
s = s % 20
numPull = numPull + s // 10
s = s % 10
numPull = numPull + s // 5
s = s % 5
numPull = numPull + s
print(numPull) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 2e6 + 100;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
inline long long dpow(long long a, long long b) {
long long r = 1, t = a;
while (b) {
if (b & 1) r = (r * t) % MOD;
b >>= 1;
t = (t * t) % MOD;
}
return r;
}
inline long long fpow(long long a, long long b) {
long long r = 1, t = a;
while (b) {
if (b & 1) r = (r * t);
b >>= 1;
t = (t * t);
}
return r;
}
vector<int> G[N];
int dfn[N], low[N], n, m;
int st[N], suo[N], s, cnt, scnt;
bool vis[N];
void init() {
for (int i = 1; i <= 2 * n; i++) G[i].clear(), dfn[i] = low[i] = suo[i] = 0;
s = cnt = scnt = 0;
}
void tarjan(int x) {
dfn[x] = low[x] = ++cnt;
st[++s] = x;
vis[x] = true;
for (auto v : G[x]) {
if (!dfn[v]) {
tarjan(v);
low[x] = min(low[x], low[v]);
} else if (vis[v])
low[x] = min(low[x], low[v]);
}
if (dfn[x] == low[x]) {
scnt++;
int k;
do {
k = st[s--];
vis[k] = false;
suo[k] = scnt;
} while (k != x);
}
}
int main() {
int T;
cin >> T;
while (T--) {
scanf("%d %d", &n, &m);
init();
for (int i = 0; i < m; i++) {
int ui, vi;
scanf("%d %d", &ui, &vi);
if (ui == vi)
G[vi + n].push_back(ui), G[ui].push_back(vi + n);
else
G[ui].push_back(vi + n);
}
if (n == 1) {
printf("No\n");
continue;
}
for (int i = 1; i <= 2 * n; i++) {
if (!dfn[i]) tarjan(i);
}
if (scnt == 1) {
printf("No\n");
continue;
}
printf("Yes\n");
vector<int> v1, v2;
bool ok = false;
for (int i = 1; i <= n; i++) {
if (suo[i] == 1) ok = true;
}
if (ok) {
for (int i = 1; i <= 2 * n; i++) {
if (((int)(v1).size()) + ((int)(v2).size()) == n) break;
if (suo[i] == 1 && i <= n)
v1.push_back(i);
else if (suo[i] > 1 && i > n)
v2.push_back(i - n);
}
} else {
for (int i = 1; i <= 2 * n; i++) {
if (((int)(v1).size()) + ((int)(v2).size()) == n) break;
if (suo[i] > 1 && i <= n)
v1.push_back(i);
else if (suo[i] == 1 && i > n)
v2.push_back(i - n);
}
}
printf("%d %d\n", ((int)(v1).size()), ((int)(v2).size()));
for (auto it : v1) printf("%d ", it);
printf("\n");
for (auto it : v2) printf("%d ", it);
printf("\n");
}
return 0;
}
| 10 | CPP |
#include<iostream>
#include<cmath>
#include<string>
#include<map>
#include<queue>
using namespace std;
#define N 3
#define N2 9
struct Puzzle{
int f[N2];
int space;
string path;
bool operator < (const Puzzle &p) const {
for(int i = 0 ; i < N2 ; i++){
if(f[i] == p.f[i]) continue;
return f[i] > p.f[i];
}
return false;
}
};
static const int dx[4] = {-1, 0, 1, 0};
static const int dy[4] = {0, -1, 0, 1};
static const int dir[4] = {'u', 'l', 'd', 'r'};
bool isTarget(Puzzle p){
for(int i = 0 ; i < N2 ; i++)
if(p.f[i] != (i + 1)) return false;
return true;
}
string bfs(Puzzle s){
queue<Puzzle> Q;
map<Puzzle, bool> V;
Puzzle u, v;
s.path = "";
Q.push(s);
V[s] = true;
while(!Q.empty()){
u = Q.front();
Q.pop();
if(isTarget(u)) return u.path;
int sx = u.space / N;
int sy = u.space % N;
for(int r = 0 ; r < 4 ; r++){
int tx = sx + dx[r];
int ty = sy + dy[r];
if(tx < 0 || ty < 0 || tx >= N || ty >= N) continue;
v = u;
swap(v.f[u.space], v.f[tx * N + ty]);
v.space = tx * N + ty;
if(!V[v]){
V[v] = true;
v.path += dir[r];
Q.push(v);
}
}
}
return "unsolvable";
}
int main(){
Puzzle in;
for(int i = 0 ; i < N2 ; i++){
cin >> in.f[i];
if(in.f[i] == 0){
in.f[i] = N2;
in.space = i;
}
}
string ans = bfs(in);
cout << ans.size() << endl;
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct node {
int num, width;
node(){};
node(int _num, int _width) : num(_num), width(_width) {}
};
stack<node> S;
int a[200005], ans[200005];
int main() {
int n, i, j;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
a[n++] = 0;
memset(ans, 0, sizeof(ans));
for (i = 0; i < n; i++) {
int len = 0;
node k;
while (!S.empty()) {
k = S.top();
if (k.num < a[i]) break;
int ls = k.width + len;
if (k.num > ans[ls]) {
ans[ls] = k.num;
}
len += k.width;
S.pop();
}
S.push(node(a[i], len + 1));
}
for (i = n - 1; i >= 1; i--) ans[i] = max(ans[i], ans[i + 1]);
printf("%d", ans[1]);
for (i = 2; i < n; i++) printf(" %d", ans[i]);
printf("\n");
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18 + 7;
const int mod = 1e9 + 7;
template <class T>
inline T read() {
char ch;
bool flag = 0;
T x = 0;
while (ch = getchar(), !isdigit(ch))
if (ch == '-') flag = 1;
while (isdigit(ch)) x = x * 10 + ch - 48, ch = getchar();
return flag ? -x : x;
}
struct {
inline operator long long() {
long long _tmp;
return scanf("%lld", &_tmp), _tmp;
}
inline operator int() {
int _tmp;
return scanf("%d", &_tmp), _tmp;
}
template <class T>
inline void operator()(T &x) {
x = *this;
}
template <class T, class... A>
inline void operator()(T &x, A &...a) {
x = *this, this->operator()(a...);
}
} IN;
template <class T>
inline void chkmax(T &x, T y) {
if (x < y) x = y;
}
template <class T>
inline void chkmin(T &x, T y) {
if (x > y) x = y;
}
inline int mul(int x, int y) { return 1ll * x * y % mod; }
inline int dec(int x, int y) {
x -= y;
if (x < 0) x += mod;
return x;
}
inline int add(int x, int y) {
x += y;
if (x >= mod) x -= mod;
return x;
}
inline void sub(int &x, int y) {
x -= y;
if (x < 0) x += mod;
}
inline void pls(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
inline int modpow(int x, int y, int res = 1) {
if (y == -1) y = mod - 2;
for (; y; y >>= 1, x = mul(x, x))
if (y & 1) res = mul(res, x);
return res;
}
const int N = 1e6 + 5;
int n, m, p, a[N];
long long s[N << 2];
std::vector<long long> t[N << 2];
void build(int x, int l, int r) {
t[x].resize(r - l + 3), t[x][0] = -inf;
for (int i = 1; i <= r - l + 2; ++i) t[x][i] = inf;
if (l == r) return t[x][1] = p - a[l], s[x] = a[l], void();
build(((x) << 1), l, ((l + r) >> 1)),
build(((x) << 1 | 1), ((l + r) >> 1) + 1, r),
s[x] = s[((x) << 1)] + s[((x) << 1 | 1)];
int j = 0;
for (int i = 0; i <= ((l + r) >> 1) - l + 1; ++i) {
long long L = t[((x) << 1)][i] + s[((x) << 1)] - 1ll * i * p,
R = t[((x) << 1)][i + 1] - 1 + s[((x) << 1)] - 1ll * i * p;
while (j <= r - ((l + r) >> 1)) {
long long _L = max(t[((x) << 1 | 1)][j], L),
_R = min(t[((x) << 1 | 1)][j + 1] - 1, R);
if (_L <= _R) chkmin(t[x][i + j], _L - s[((x) << 1)] + 1ll * i * p);
if (t[((x) << 1 | 1)][j + 1] - 1 >= R)
break;
else
++j;
}
}
}
void query(int x, int l, int r, int L, int R, long long &res) {
if (L == l && r == R) {
int tot = upper_bound(t[x].begin(), t[x].end(), res) - t[x].begin() - 1;
return res += s[x] - 1ll * tot * p, void();
}
if (R <= ((l + r) >> 1))
return query(((x) << 1), l, ((l + r) >> 1), L, R, res), void();
if (L > ((l + r) >> 1))
return query(((x) << 1 | 1), ((l + r) >> 1) + 1, r, L, R, res), void();
return query(((x) << 1), l, ((l + r) >> 1), L, ((l + r) >> 1), res),
query(((x) << 1 | 1), ((l + r) >> 1) + 1, r, ((l + r) >> 1) + 1, R,
res),
void();
}
int main() {
IN(n, m, p);
for (int i = 1; i <= n; ++i) IN(a[i]);
build(1, 1, n);
int l, r;
long long res = 0;
while (m--) {
IN(l, r), res = 0;
query(1, 1, n, l, r, res), printf("%lld\n", res);
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long a[500005], n, m;
vector<int> e[500005];
vector<int> ct;
vector<int> C[500005];
inline long long read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
int main() {
n = read(), m = read();
for (int i = 1; i <= m; i++) {
long long u = read(), v = read();
e[u].push_back(v);
e[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
long long c = read();
C[c].push_back(i);
a[i] = 1;
}
for (int i = 1; i <= n; i++) {
for (auto u : C[i]) {
if (a[u] != i) puts("-1"), exit(0);
for (auto v : e[u])
if (a[v] == i) a[v]++;
ct.push_back(u);
}
}
for (auto i : ct) printf("%d ", i);
return 0;
}
| 10 | CPP |
Subsets and Splits