solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
#define _USE_MATH_DEFINES
#include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <cfloat>
#include <climits>
#include <cstring>
#include <cmath>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> i_i;
typedef pair<ll, int> ll_i;
typedef pair<double, int> d_i;
typedef pair<ll, ll> ll_ll;
typedef pair<double, double> d_d;
struct edge { int u, v; ll w; };
ll MOD = 1000000007;
ll _MOD = 1000000009;
double EPS = 1e-10;
struct union_find {
vector<int> v;
union_find(int n) : v(n, -1) {}
int find(int x) { return (v[x] < 0) ? x : (v[x] = find(v[x])); }
void unite(int x, int y) {
x = find(x); y = find(y);
if (x != y) {
if (-v[x] < -v[y]) swap(x, y);
v[x] += v[y]; v[y] = x;
}
}
bool same(int x, int y) { return find(x) == find(y); }
int size(int x) { return -v[find(x)]; }
};
int main() {
for (;;) {
int n, m; cin >> n >> m;
if (n == 0) break;
vector< vector<int> > e(m, vector<int>(3));
for (int i = 0; i < m; i++) {
int a, b, w; cin >> a >> b >> w;
e[i][0] = w; e[i][1] = a - 1; e[i][2] = b - 1;
}
sort(e.begin(), e.end());
int mini = INT_MAX;
for (int i = 0; i < m; i++) {
union_find uf(n);
int cnt = 0, maxi = 0;
for (int j = i; j < m; j++) {
int u = e[j][1], v = e[j][2], w = e[j][0];
if (uf.same(u, v)) continue;
uf.unite(u, v);
cnt++;
maxi = w;
}
if (cnt == n - 1)
mini = min(mini, maxi - e[i][0]);
}
cout << (mini < INT_MAX ? mini : -1) << endl;
}
} | 0 | CPP |
n = int(input())
li = list(map(int,input().split()))
diff=[]
ne=[]
for i in range(0,n-1):
diff.append(li[i+1] - li[i])
for i in range(1,len(diff)):
d = diff[:i-1] + [diff[i-1] + diff[i]] + diff[i+1:]
ne.append(max(d))
print(min(ne)) | 7 | PYTHON3 |
#include<bits/stdc++.h>
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define ED(x) ((int)x.size()-1)
#define _for(i,a,b) for(int i=(a);i<=(b);++i)
#define _rep(i,a,b) for(int i=(a);i>=(b);--i)
#define changxv ios::sync_with_stdio(0);cin.tie(0);
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
template<typename T>
void dbg(const char*s,T h){cerr<<s<<'='<<h<<'\n';}
template<typename T,typename...A>
void dbg(const char*s,T h,A...t){
while(*s!=',')cerr<<*s++;
cerr<<'='<<h<<", ";
dbg(s+1,t...);
}
#define put(...) dbg(#__VA_ARGS__,__VA_ARGS__);
const int maxn=1e6+3;
const int INF=0x3f3f3f3f;
const int mod=1e9+7;
int x[7],y[7];
struct node{
int x,y,flag;
}a[5],b[5];
int ans;
int fac[maxn<<1],invfac[maxn<<1];
int Qpow(int x,int k){
int tmp=1;
for(;k;k>>=1,x=(ll)x*x%mod)if(k&1)tmp=(ll)tmp*x%mod;
return tmp;
}
void Pre(){
const int lim=2e6;
fac[0]=invfac[0]=1;
_for(i,1,lim)fac[i]=(ll)fac[i-1]*i%mod;
invfac[lim]=Qpow(fac[lim],mod-2);
_rep(i,lim-1,1)invfac[i]=(ll)invfac[i+1]*(i+1)%mod;
}
int C(int a,int b,int c,int d){
return (ll)fac[c+d-a-b]*invfac[c-a]%mod*invfac[d-b]%mod;
}
int Cal(const node&a,const node&b){
int tmp=0;
_for(i,x[3],x[4])(tmp+=(ll)C(a.x,a.y,i,y[3]-1)*C(i,y[3],b.x,b.y)%mod*(-i-y[3])%mod)%=mod;
_for(i,y[3],y[4])(tmp+=(ll)C(a.x,a.y,x[3]-1,i)*C(x[3],i,b.x,b.y)%mod*(-i-x[3])%mod)%=mod;
_for(i,x[3],x[4])(tmp+=(ll)C(a.x,a.y,i,y[4])*C(i,y[4]+1,b.x,b.y)%mod*(i+y[4]+1)%mod)%=mod;
_for(i,y[3],y[4])(tmp+=(ll)C(a.x,a.y,x[4],i)*C(x[4]+1,i,b.x,b.y)%mod*(i+x[4]+1)%mod)%=mod;
return tmp;
}
int main(){changxv
Pre();
_for(i,1,6)cin>>x[i];
_for(i,1,6)cin>>y[i];
int cnt=1;
a[1]=(node){x[2],y[2],1};
a[2]=(node){x[1]-1,y[1]-1,1};
a[3]=(node){x[1]-1,y[2],-1};
a[4]=(node){x[2],y[1]-1,-1};
b[1]=(node){x[6]+1,y[6]+1,1};
b[2]=(node){x[5],y[5],1};
b[3]=(node){x[5],y[6]+1,-1};
b[4]=(node){x[6]+1,y[5],-1};
_for(i,1,4){
_for(j,1,4){
(ans+=a[i].flag*b[j].flag*Cal(a[i],b[j]))%=mod;
if(ans<0)(ans+=mod)%=mod;
}
}
cout<<ans<<'\n';
return 0; } | 0 | CPP |
import sys
import math
import random
n, k, x = map(int, input().split())
a = list(map(int, input().split()))
ans = 0
if n == 1:
print(0)
sys.exit()
for i in range(0, n - 1):
if a[i] == a[i + 1] == x:
l = i
while l >= 0 and a[i] == a[l]:
l -= 1
r = i + 1
while r < n and a[r] == x:
r += 1
while (1):
if l == -1 or r == n:
break
if a[l] != a[r]:
break
if l == 0 and r == n - 1:
break
if l == 0:
if a[0] == a[r + 1]:
while r < n and a[r] == a[0]:
r += 1
l -= 1
continue
else:
break
if r == n - 1:
if a[n - 1] == a[l - 1]:
while l >= 0 and a[l] == a[n - 1]:
l -= 1
r += 1
continue
else:
break
if a[l] == a[r + 1] or a[l - 1] == a[r]:
t = a[l]
while l >= 0 and a[l] == t:
l -= 1
while r < n and a[r] == t:
r += 1
else:
break
ans = max(ans, r - l - 1)
print(ans) | 8 | PYTHON3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
const double PI = 3.14159265359;
using namespace std;
const int N = 5e5 + 10;
int a[N], tr[N];
map<int, int> r;
int n;
int bitwise(int x) { return x & -x; }
void add(int x, int c) {
for (int i = x; i <= n; i += bitwise(i)) {
tr[i] += c;
}
}
int sum(int x) {
int ans = 0;
for (int i = x; i >= 1; i -= bitwise(i)) {
ans += tr[i];
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
r.clear();
cin >> n;
int maxn = 0;
int flag = 0;
int ans = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
maxn = max(a[i], maxn);
r[a[i]]++;
if (r[a[i]] > 1) flag = 1;
}
if (flag == 1) {
cout << "YES"
<< "\n";
continue;
}
for (int i = 1; i <= n; i++) {
ans += sum(n) - sum(a[i] - 1);
add(a[i], 1);
}
if (ans % 2 == 0) {
cout << "YES"
<< "\n";
} else {
cout << "NO"
<< "\n";
}
for (int i = 0; i <= maxn; i++) {
tr[i] = 0;
}
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 8;
const int mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s, tar;
cin >> s >> tar;
int n, m;
n = s.length();
m = tar.length();
if (n < m || m < n - 1) {
cout << 0 << endl;
return 0;
}
int flag = 0;
int index;
int j = m - 1;
for (int i = n - 1; i > -1; i--) {
if (i < j) {
flag = 0;
break;
}
if (s[i] != tar[j]) {
index = i;
flag = 1;
continue;
}
j--;
}
if (j > -1) flag = 0;
if (!flag) {
cout << 0 << endl;
} else {
if (index == n - 1) {
cout << 1 << endl;
cout << n << endl;
} else if (s[index] == tar[index]) {
int temp = 1;
for (int i = index + 1; i < n; i++) {
if (s[i] == s[index])
temp++;
else
break;
}
cout << temp << endl;
for (int i = index; i < index + temp; i++) {
cout << i + 1 << " ";
}
cout << endl;
} else {
cout << 1 << endl;
cout << index + 1 << endl;
}
}
}
| 16 | CPP |
#include <bits/stdc++.h>
using namespace std;
int d[4][109];
int main() {
string s1, s2;
cin >> s1 >> s2;
int n = s1.size();
auto get = [=](int a) { return 2 * (s1[a] == 'X') + (s2[a] == 'X'); };
for (int i = 0; i < n; i++) {
for (int j = 0; j < 4; j++) {
d[j][i] = -300;
}
}
d[get(0)][0] = 0;
for (int i = 1; i < n; i++) {
if ((1 & get(i)) == 0) {
d[1 | get(i)][i] = max(d[1 | get(i)][i], d[0][i - 1] + 1);
}
if ((2 & get(i)) == 0) {
d[2 | get(i)][i] = max(d[2 | get(i)][i], d[0][i - 1] + 1);
}
if (get(i) == 0) {
d[3][i] = max(d[3][i], d[1][i - 1] + 1);
d[3][i] = max(d[3][i], d[2][i - 1] + 1);
}
for (int j = 0; j < 4; j++) {
d[get(i)][i] = max(d[get(i)][i], d[j][i - 1]);
}
}
int ans = 0;
for (int i = 0; i < 4; i++) {
ans = max(ans, d[i][n - 1]);
}
cout << ans;
}
| 10 | CPP |
n = int(input())
arr = [int(i) for i in input().split()]
prev = 0
c = 0
res = []
for i in sorted(arr):
if i != prev:
res.append([c, prev])
c = 1
prev = i
else: c += 1
res.append([c, prev])
res.sort(reverse=True)
m = res[0][0]
nres = []
arr.reverse()
for i in res:
if i[0] == m:
nres.append([arr.index(i[1]), i[1]])
else: break
nres.sort(reverse=True)
print(nres[0][1])
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'r') printf("%d\n", i + 1);
}
for (int i = s.size() - 1; i >= 0; i--)
if (s[i] == 'l') printf("%d\n", i + 1);
return 0;
}
| 9 | CPP |
#include <stdio.h>
#include <string.h>
#define N 1010
char T[N];
char P[N];
int main(){
scanf("%s %s", T, P);
int a = strlen(T);
int b = strlen(P);
for(int i = 0; i < a; i++){
int flag = 1;
if(i + b > a) break;
for(int j = 0; j < b; j++){
if(T[i + j] != P[j]){
flag = 0;
break;
}
}
if(flag){
printf("%d\n", i);
}
}
return 0;
}
| 0 | CPP |
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
ll ans=0;
void solve(string s, int id, ll sum) {
if(id == s.size()) {
ans += sum;
//return;
}
for(int i = 1; i+id <= s.size(); i++) {
solve(s, id+i, sum + stoll(s.substr(id, i)));
}
}
int main() {
string s;
cin >> s;
solve(s, 0, 0);
cout << ans << endl;
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const long long llinf = (long long)9e18;
const int N = (int)1e7 + 111;
const long double PI = (long double)acos(-1);
int main() {
long long ans = 0;
int n, x;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &x);
ans ^= (long long)x;
}
vector<long long> first(n + 1);
first[0] = 0;
for (int i = 1; i <= n; i++) first[i] = first[i - 1] ^ (long long)i;
for (int i = 2; i <= n; i++) ans ^= (n / i) % 2 * first[i - 1] ^ first[n % i];
printf("%lld", ans);
return 0;
}
| 9 | CPP |
numbers = [int(i) for i in input().split('+')]
numbers = sorted(numbers)
numbers_strings = [str(i) for i in numbers]
print("+".join(numbers_strings)) | 7 | PYTHON3 |
def solve():
a,b=map(int, input().split())
m,n = min(a,b),max(a,b)
if(m*2>=n):
return ((m*2)**2)
else:
return(n**2)
for _ in range(int(input())):
print(solve()) | 7 | PYTHON3 |
#include <iostream>
#include <cmath>
using namespace std;
int main(){
int n;
int i;
while(true){
double s=0.0;
cin >> n;
if(n==0) break;
bool flag=false;
//約数列挙
for(i=1;i<sqrt(n);i++){
// cout << i;
if(n%i==0){
s+=i;
s+=(n/i);
if(s<0){
flag = true;
break;
}
// cout << i << endl;
// cout << (n/i) << endl;
}
}
s-=n;
if((double)n<s || flag) cout << "abundant number" << endl;
else if((double)n>s) cout << "deficient number" << endl;
else if((double)n==s) cout << "perfect number" << endl;
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int compare(const void* a, const void* b) { return (*(int*)a - *(int*)b); }
int main() {
char m[][15] = {"", "January", "February", "March", "April",
"May", "June", "July", "August", "September",
"October", "November", "December"};
char c[15];
int i, x, n, t = 0;
scanf("%s %d", &c, &x);
if (strcmp(c, "January") == 0) {
t = 1;
} else if (c[0] == 'F') {
t = 2;
} else if (strcmp(c, "March") == 0) {
t = 3;
} else if (strcmp(c, "April") == 0) {
t = 4;
} else if (c[0] == 'M') {
t = 5;
} else if (strcmp(c, "June") == 0) {
t = 6;
} else if (strcmp(c, "July") == 0) {
t = 7;
} else if (strcmp(c, "August") == 0) {
t = 8;
} else if (c[0] == 'S') {
t = 9;
} else if (c[0] == 'O') {
t = 10;
} else if (c[0] == 'N') {
t = 11;
} else if (c[0] == 'D') {
t = 12;
}
if (x == 0) {
cout << c << endl;
return 0;
}
for (i = 0; i < x; i++) {
t++;
if (t > 12) {
t = 1;
}
}
cout << m[t] << "\n";
return 0;
}
| 7 | CPP |
queries = int(input())
for _ in range(queries):
n, a, b, c, d = map(int, input().split())
min_grain, max_grain = a - b, a + b
min_total, max_total = c - d, c + d
yesno = False
for weigth in range(min_total, max_total + 1):
value = weigth / n
if value >= min_grain and value <= max_grain:
yesno = True
break
if yesno:
print('Yes')
else:
print('No') | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
int v, i, j, cz;
int main() {
scanf("%lld%lld%d", &n, &m, &v);
if (m < n - 1 || m > n - 1 + (n - 2) * (n - 3) / 2) {
cout << -1;
return 0;
}
cz = (v == n) ? 1 : n;
for (i = 1; i <= n; i++)
if (i != v) printf("%d %d\n", i, v);
m -= (n - 1);
for (i = 1; i <= n; i++)
if (i != v && i != cz)
for (j = i + 1; j <= n; j++)
if (j != v && j != cz) {
if (!m) return 0;
printf("%d %d\n", i, j);
m--;
}
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[101], b[101], c[101], t[101], n;
void calc() {
int i;
for (i = 1; i <= n; i++) c[i] = t[a[i]];
}
void recalc() {
int i;
for (i = 1; i <= n; i++) c[a[i]] = t[i];
}
int same(int *c, int *b) {
int i;
for (i = 1; i <= n; i++)
if (c[i] != b[i]) break;
if (i <= n)
return 0;
else
return 1;
}
int main() {
int i, j, k, p, q;
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) scanf("%d", &b[i]);
for (i = 1; i <= n; i++) c[i] = i;
if (same(c, b)) {
printf("NO\n");
return 0;
}
for (p = 1; p <= k; p++) {
for (i = 1; i <= n; i++) t[i] = c[i];
calc();
if (same(c, b)) break;
}
for (i = 1; i <= n; i++) c[i] = i;
for (q = 1; q <= k; q++) {
for (i = 1; i <= n; i++) t[i] = c[i];
recalc();
if (same(c, b)) break;
}
i = 0;
if (p <= k) {
if (!((k - p) & 1)) i = 1;
}
if (q <= k) {
if (!((k - q) & 1)) i = 1;
}
if (k > 1 && p == 1 && q == 1) i = 0;
if (i)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 8 | CPP |
from collections import defaultdict
from random import randint
itl = lambda: list(map(int, input().strip().split()))
class Problem:
def read(self):
# self.N = 100000
# self.A, self.R, self.M = [randint(1, 10000) for _ in range(3)]
# self.pillars = [randint(0, 1000000000) for _ in range(self.N)]
self.N, self.A, self.R, self.M = itl()
self.pillars = itl()
self.lo = min(self.pillars)
self.hi = max(self.pillars)
def solve(self):
lo = self.lo
hi = self.hi
while lo <= hi:
mid = (lo + hi) >> 1
left = self.cost(mid - 1)
center = self.cost(mid)
right = self.cost(mid + 1)
if center < right and center < left:
return center
assert left >= center >= right or left <= center <= right
if right > left:
hi = mid - 1
else:
lo = mid + 1
return self.cost(lo)
def cost(self, target):
below = 0
above = 0
for p in self.pillars:
if p < target:
below += target - p
elif p > target:
above += p - target
option1 = self.A * below + self.R * above
option2 = self.M * min(below, above) + abs(below - above) * (self.A if below > above else self.R)
return min(option1, option2)
def bruteforce(self):
ans = float('inf')
for target in range(min(self.pillars), max(self.pillars) + 1):
cost = self.cost(target)
print(target, cost)
ans = min(ans, cost)
return ans
if __name__ == '__main__':
P = Problem()
P.read()
# print(P.bruteforce())
print(P.solve()) | 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
string s;
cin >> n;
while (n--) {
cin >> s;
sort(s.begin(), s.end());
bool ok = 1;
for (int i = 1; i < s.size(); ++i)
if ((int)s[i] != (int)s[i - 1] + 1) ok = 0;
cout << (ok ? "Yes" : "No");
cout << '\n';
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, w;
long long first[100007];
long long v[100007];
bool eq1(int s1, int s2) {
long long g1 = first[s1] * (v[s2] + w);
long long g2 = first[s2] * (v[s1] + w);
return g1 == g2;
}
bool eq2(int s1, int s2) {
long long g1 = first[s1] * (v[s2] - w);
long long g2 = first[s2] * (v[s1] - w);
return g1 == g2;
}
bool cmp1(int s1, int s2) {
long long g1 = first[s1] * (v[s2] + w);
long long g2 = first[s2] * (v[s1] + w);
int ff = 0;
if (v[s1] + w < 0) ff ^= 1;
if (v[s2] + w < 0) ff ^= 1;
if (g1 == g2) return 0;
return (g1 < g2) ^ ff;
}
bool cmp2(int s1, int s2) {
long long g1 = first[s1] * (v[s2] - w);
long long g2 = first[s2] * (v[s1] - w);
int ff = 0;
if (v[s1] - w < 0) ff ^= 1;
if (v[s2] - w < 0) ff ^= 1;
if (g1 == g2) return 0;
return (g1 < g2) ^ ff;
}
int d[2][100007];
struct fen {
int t[100007];
void up(int v) {
for (; v < 100007; v = v | (v + 1)) t[v]++;
}
int get2(int v) {
int ans = 0;
for (; v >= 0; v = (v & (v + 1)) - 1) ans += t[v];
return ans;
}
int get(int l, int r) { return get2(r) - get2(l - 1); }
} t;
bool cmp3(int s1, int s2) {
return make_pair(d[0][s1], -d[1][s1]) < make_pair(d[0][s2], -d[1][s2]);
}
bool cmp4(int s1, int s2) {
return make_pair(-d[0][s1], d[1][s1]) < make_pair(-d[0][s2], d[1][s2]);
}
long long ans = 0;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> w;
for (int i = 0; i < n; i++) cin >> first[i] >> v[i];
vector<int> t1, t2;
for (int i = 0; i < n; i++) t1.push_back(i), t2.push_back(i);
sort(t1.begin(), t1.end(), cmp1);
sort(t2.begin(), t2.end(), cmp2);
int i = 0;
int dd = 0;
while (1) {
if (i == t1.size()) break;
int j = i;
while (j + 1 < t1.size() && eq1(t1[i], t1[j + 1])) j++;
for (int s = i; s <= j; s++) d[0][t1[s]] = dd;
dd++;
i = j + 1;
}
i = 0;
dd = 0;
while (1) {
if (i == t2.size()) break;
int j = i;
while (j + 1 < t2.size() && eq2(t2[i], t2[j + 1])) j++;
for (int s = i; s <= j; s++) d[1][t2[s]] = dd;
dd++;
i = j + 1;
}
vector<int> f;
for (int i = 0; i < n; i++) f.push_back(i);
sort(f.begin(), f.end(), cmp3);
for (int i = 0; i < f.size(); i++) {
ans += t.get(d[1][f[i]], 100006);
t.up(d[1][f[i]]);
}
for (int i = 0; i < 100007; i++) t.t[i] = 0;
sort(f.begin(), f.end(), cmp4);
for (int i = 0; i < f.size(); i++) {
ans += t.get(0, d[1][f[i]]);
t.up(d[1][f[i]]);
}
cout << ans / 2;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s; cin >> s; if(s.size()==3) swap(s[0], s[2]);
cout << s << endl;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d;
cin >> a >> b >> c;
d = min(a + b + c, 2 * a + 2 * b);
d = min(d, 2 * a + 2 * c);
d = min(d, 2 * b + 2 * c);
cout << d;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, count = 0, i;
cin >> n;
string s;
cin >> s;
string st = s;
sort(st.begin(), st.end());
for (i = 0; i < n; i++) {
if (st[i] != s[i]) count++;
}
cout << count << "\n";
}
}
| 7 | CPP |
t=int(input())
while(t):
t-=1;
n=int(input())
l=list(map(int,input().split()))
l.sort()
print(min(l[-2]-1, len(l)-2))
| 7 | PYTHON3 |
n, x, y = map(int, input().split())
A = input()[::-1]
result = 0
for i in range(0, x):
result += (i == y and A[i] != '1') or (i != y and A[i] == '1')
print(result)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 2e5 + 10;
const int mod = 1e9 + 9;
int du[maxn];
vector<int> g[maxn];
int sz[maxn];
void dfs(int u, int f) {
sz[u] = 1;
for (int i = 0; i < g[u].size(); ++i) {
int v = g[u][i];
if (v == f) continue;
dfs(v, u);
sz[u] += sz[v];
}
}
void print(int u, int f) {
for (int i = 0; i < g[u].size(); ++i) {
int v = g[u][i];
if (v == f) continue;
if (sz[v] % 2 == 0) print(v, u);
}
printf("%d\n", u);
for (int i = 0; i < g[u].size(); ++i) {
int v = g[u][i];
if (v == f) continue;
if (sz[v] % 2 == 1) print(v, u);
}
}
int main() {
int n;
scanf("%d", &n);
int root = -1;
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
if (x == 0)
root = i;
else {
g[i].push_back(x);
g[x].push_back(i);
}
}
if (n & 1) {
dfs(root, -1);
printf("YES\n");
print(root, -1);
} else
printf("NO\n");
}
| 10 | CPP |
n=int(input())
sum=0
l1=input()
l2=input()
for i in range(n):
sum+=min(abs(int(l1[i])-int(l2[i])),abs(abs(int(l1[i])-int(l2[i]))-10))
print(int(sum)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y) {
if (y == 0) return 1;
if (y % 2 == 0) return power((x * x) % 1000000007, y / 2) % 1000000007;
return (x * power(x, y - 1)) % 1000000007;
}
int main() {
int n;
cin >> n;
cout << 9 * n << " " << 8 * n;
}
| 7 | CPP |
import sys
from math import sqrt
input = sys.stdin.readline
def inp():
return(int(input()))
def inlist():
return(list(map(int,input().split())))
def instr():
s = input()
return(list(s[:len(s)-1]))
def invr():
return(map(int,input().split()))
def main():
t = inp()
for l in range(t):
x,y,z = invr()
if(x!=y and y!=z and x!=z):
print("NO")
elif((x==y and x<z) or (y==z and y<x) or (x==z and x<y)):
print("NO")
else:
print("YES")
print(min(x,y),min(x,z),min(y,z))
main()
| 7 | PYTHON3 |
import collections
n, m = map(int, input().split())
ab = []
v = [[] for _ in range(n+1)]
for _ in range(m):
a, b = map(int, input().split())
ab.append([a, b])
v[a].append(b)
v[b].append(a)
ans = 0
for a, b in ab:
visited = set()
q = collections.deque()
q.append(1)
visited.add(1)
while q:
c = q.pop()
for i in v[c]:
if i in visited:
continue
if (a == i and b == c) or (a == c and b == i):
continue
q.append(i)
visited.add(i)
if len(visited) != n:
ans += 1
print(ans) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
struct edge {
int x, y, z;
edge(int a, int b, int c) {
x = a;
y = b;
z = c;
}
bool operator<(edge a) const {
return vector<int>{x, y, z} < vector<int>{a.x, a.y, a.z};
}
};
int vp[511000][2];
vector<int> G[510000];
int now = 1;
void dfs(int p, int from) {
for (int adj : G[p])
if (adj != from) dfs(adj, p);
vp[p][0] = now++;
auto &tv = G[p];
for (int i = tv.size() - 1; i >= 0; i--) {
int tmp = tv[i];
if (tmp != from) vp[tmp][1] = now++;
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int a = 1, b = 1;
scanf("%d %d", &a, &b);
G[a].push_back(b);
G[b].push_back(a);
}
dfs(1, 0);
vp[1][1] = now;
for (int i = 1; i <= n; i++) printf("%d %d\n", vp[i][0], vp[i][1]);
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
int n, x, p, s;
for (int i = 0; i < t; i++) {
cin >> n >> x >> p >> s;
int x1, x2;
x1 = min(p, s);
x2 = max(p, s);
for (int j = 0; j < x; j++) {
if (x2 < n) {
x2++;
} else if (x1 > 1) {
x1--;
}
}
cout << x2 - x1 << endl;
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline long long int gcd(long long int a, long long int b) {
return b ? gcd(b, a % b) : a;
}
inline long long int fast_pow(long long int a, long long int b) {
long long int res = 1;
a %= 1000000009;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % 1000000009;
a = a * a % 1000000009;
}
return res;
}
inline bool isPrime(long long int a) {
for (long long int i = 2; i * i <= a; i++)
if (a % i == 0) return 0;
return 1;
}
const int N = 1e5 + 10;
int n, arr[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
if (arr[n - 1] == 1)
arr[n - 1] = 2;
else {
for (int i = n; i >= 1; i--) arr[i] = arr[i - 1];
arr[0] = 1;
}
for (int i = 0; i < n; i++) cout << arr[i] << ' ';
return 0;
}
| 7 | CPP |
d = int(input())
if d > 0:
print(d)
else:
d = abs(d)
ara = [int(i) for i in str(d)]
l = len(ara) - 1
if ara[l] > ara[l-1]:
ara.pop(l)
else:
ara.pop(l-1)
s = [str(i) for i in ara]
res = -(int("".join(s)))
print(res) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int ans[200001], T, N, arr[200001];
bool chk[200001];
int dfs(int n, int depth) {
if (chk[n]) return depth;
chk[n] = 1;
return ans[n] = dfs(arr[n], depth + 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> T;
while (T--) {
cin >> N;
for (int i = 1; i <= N; i++) chk[i] = 0;
for (int i = 1; i <= N; i++) {
cin >> arr[i];
}
for (int i = 1; i <= N; i++) {
if (chk[i]) continue;
dfs(i, 0);
}
for (int i = 1; i <= N; i++) {
cout << ans[i] << ' ';
}
cout << '\n';
}
}
| 8 | CPP |
'''
Nikita and string
Source: http://codeforces.com/problemset/problem/877/B
'''
def solve(string):
dp = [[],[],[],0]
index = 0
for i in range(0,len(string)):
if string[i] == 'a':
dp[0].append('a')
dp[2].append('a')
if dp[3] == 1:
dp[3] = 2
if len(dp[1]) >= 1 and dp[1][-1] != 'b':
dp[1].append('a')
else:
dp[1].append('b')
if dp[3] != 2:
dp[2].append('b')
dp[3] = 1
if len(dp[0]) > len(dp[1]):
dp[1] = list(dp[0])
if len(dp[0]) > len(dp[2]):
dp[2] = list(dp[0])
dp[3] = 0
if len(dp[1]) > len(dp[2]):
dp[2] = list(dp[1])
dp[3] = 1
#print(dp)
print(len(dp[2]))
if __name__ == '__main__':
string = input().strip()
solve(string)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long min(long long a, long long b) { return a < b ? a : b; }
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long a, b, ma, mb, p, q, g, l;
cin >> ma >> mb >> a >> b;
g = gcd(a, b);
a /= g;
b /= g;
p = ma / a;
q = mb / b;
if (p < 1 || q < 1) {
cout << "0 0";
return 0;
}
p = min(p, q);
cout << p * a << " " << p * b;
}
| 9 | CPP |
import sys
T = int(sys.stdin.readline())
for i in range(T):
N = int(sys.stdin.readline())
nums = [N] + [x+1 for x in range(N-1)]
print(" ".join([str(x) for x in nums])) | 7 | PYTHON3 |
#!/usr/bin/env python
# coding: utf-8
# In[14]:
l=list(map(int,input().split()))
a=l[0]
b=l[1]
c=l[2]
if a>(b+c) :
print("+")
elif b>(a+c):
print("-")
elif a==b and c==0:
print("0")
elif a<=(b+c) or b<=(a+c):
print("?")
# In[ ]:
# In[ ]:
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct poi {
int x, y;
} p[200010];
int n;
bool cmp(const poi &a, const poi &b) {
if (a.x < b.x) return 1;
if (a.x == b.x && a.y < b.y) return 1;
return 0;
}
bool cmp2(const poi &a, const poi &b) {
if (a.y < b.y) return 1;
if (a.y == b.y && a.x < b.x) return 1;
return 0;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d %d", &p[i].x, &p[i].y);
sort(p, p + n, cmp);
long long sam = 1, ans = 0, cnt = 1;
for (int i = 1; i <= n; i++) {
if (i == n || p[i].x != p[i - 1].x) {
ans += cnt * (cnt - 1);
cnt = 0;
}
if (i == n || p[i].x != p[i - 1].x || p[i].y != p[i - 1].y) {
ans -= sam * (sam - 1);
sam = 0;
}
cnt++;
sam++;
}
cnt = sam = 1;
sort(p, p + n, cmp2);
for (int i = 1; i <= n; i++) {
if (i == n || p[i].y != p[i - 1].y) {
ans += cnt * (cnt - 1);
cnt = 0;
}
cnt++;
}
ans /= 2;
printf("%lld", ans);
return 0;
}
| 7 | CPP |
s=input()
def fn(s):
t1=len(s)
for i in range(t1-1):
if s[i]=='A' and s[i+1]=='B':
t2=s[:i]+'1'+s[i+2:]
if 'BA' in t2:return 'YES'
return 'NO'
print(fn(s))
| 7 | PYTHON3 |
t=int(input())
for i in range(t):
n1,n2=map(int,input().split())
ans=(23-n1)*60+(60-n2)
print(ans)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 111, mod = 998244353;
char s[N];
int dig[N], n;
int gcd(int x, int y) { return x ? gcd(y % x, x) : y; }
map<pair<int, int>, int> dp[2][2][10][10];
void add(int& var, int val) {
var += val;
if (var >= mod) var -= mod;
}
int to1[10], to2[10];
long long solve(int x, int y) {
memset(dp, 0, sizeof dp);
int c = 0, b = 1;
memset(to1, 0, sizeof to1);
memset(to2, 0, sizeof to2);
for (int i = 1; i * y < 10; ++i) {
to1[i * x] = 1 << (i - 1);
to2[i * y] = 1 << (i - 1);
}
for (int lebih = 0; lebih < 2; ++lebih) {
for (int l = 0; l < x; ++l) {
for (int r = 0; r < y; ++r) {
dp[c][lebih][l][r].clear();
}
}
}
dp[c][0][0][0][{0, 0}] = 1;
for (int i = 0; i < n; ++i) {
swap(c, b);
for (int lebih = 0; lebih < 2; ++lebih) {
for (int l = 0; l < x; ++l) {
for (int r = 0; r < y; ++r) {
dp[c][lebih][l][r].clear();
}
}
}
for (int lebih = 0; lebih < 2; ++lebih) {
for (int l = 0; l < x; ++l) {
for (int r = 0; r < y; ++r) {
for (auto it : dp[b][lebih][l][r]) {
int now = it.second;
int maska = it.first.first, maskb = it.first.second;
if (now == 0) continue;
for (int k = 0; k < 10; ++k) {
int ll = l + x * k, rr = r + y * k;
int dl = ll % 10, dr = rr % 10;
ll /= 10;
rr /= 10;
int more = 0;
if (dr > dig[i])
more = 1;
else if (dr == dig[i])
more = lebih;
int mmaska = maska, mmaskb = maskb;
if (mmaska != -1) {
mmaska |= to1[dl];
mmaskb |= to2[dr];
if (mmaska & mmaskb) mmaska = mmaskb = -1;
}
add(dp[c][more][ll][rr][{mmaska, mmaskb}], now);
}
}
}
}
}
}
int ans = 0;
for (auto it : dp[c][0][0][0]) {
auto mask = it.first;
if (mask.first & mask.second) add(ans, it.second);
}
return ans;
}
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < n; ++i) dig[n - 1 - i] = s[i] - '0';
dig[n] = 0;
long long ans = 0;
for (int x = 1; x <= 9; ++x) {
for (int y = x; y <= 9; ++y) {
if (gcd(x, y) != 1) continue;
long long res = solve(x, y);
ans = (ans + res) % mod;
if (x != y) ans = (ans + res) % mod;
}
}
printf("%lld\n", ans);
return 0;
}
| 13 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct pelmen {
string s;
int num;
};
vector<pelmen> len[11];
pelmen strings[10001];
bool used[10001];
int kol[11];
int n;
bool cmp(pelmen a, pelmen b) { return a.s < b.s; }
int main() {
cin >> n;
int sumlen = 0;
memset(used, false, sizeof(used));
for (int i = 1; i <= n; i++) {
cin >> strings[i].s;
strings[i].num = i;
len[strings[i].s.length()].push_back(strings[i]);
sumlen += strings[i].s.length();
}
string d;
cin >> d;
for (int i = 1; i <= n; i++) strings[i].s += d;
sort(strings + 1, strings + n + 1, &cmp);
for (int i = 1; i <= 10; i++) {
sort(len[i].begin(), len[i].end(), &cmp);
kol[i] = 0;
}
int alllen = 2 * sumlen / n;
int nowout = 0;
int cur = 1;
while (nowout < n / 2) {
if (used[strings[cur].num]) {
cur++;
continue;
}
used[strings[cur].num] = true;
string nowstring = strings[cur].s;
int extra = alllen - strings[cur].s.length() + 1;
int nn = kol[extra];
while (used[len[extra][nn].num]) nn++;
used[len[extra][nn].num] = true;
kol[extra] = nn + 1;
nowstring += len[extra][nn].s;
cout << nowstring << endl;
cur++;
nowout++;
}
return 0;
}
| 10 | CPP |
T = int(input())
for z in range(T):
chocolates = int(input())
ans = chocolates - (chocolates // 2 + 1)
print(ans)
| 7 | PYTHON3 |
n = int(input())
distances = list(map(int, input().split()))
s1, s2 = map(int, input().split())
s1, s2 = min(s1,s2), max(s1,s2)
s1 -= 1
s2 -= 1
d_total = sum(distances)
d_p1 = sum(distances[s1:s2])
print(min(d_p1, d_total-d_p1))
| 7 | PYTHON3 |
import sys
n = int(sys.stdin.readline().strip())
m = n // 2 + 1
print(m)
for i in range (1, m + 1):
print("1 " + str(i))
for i in range (2, n - m + 2):
print(str(i) + " " + str(m)) | 8 | PYTHON3 |
//33
#include<iostream>
using namespace std;
int main(){
int t;
cin>>t;
while(t--){
int h,w;
cin>>h>>w;
char g[20][20];
int tx,ty,d=0;
for(int y=0;y<h;y++){
for(int x=0;x<w;x++){
cin>>g[y][x];
switch(g[y][x]){
case '<':
d++;
case 'v':
d++;
case '>':
d++;
case '^':
ty=y;
tx=x;
g[y][x]='.';
}
}
}
int n;
cin>>n;
while(n--){
char o;
cin>>o;
int dy[]={-1,0,1,0};
int dx[]={0,1,0,-1};
if(o=='S'){
int gy=ty+dy[d];
int gx=tx+dx[d];
for(;;){
if(gy<0||h<=gy||gx<0||w<=gx)break;
if(g[gy][gx]=='#')break;
if(g[gy][gx]=='*'){
g[gy][gx]='.';
break;
}
gy+=dy[d];
gx+=dx[d];
}
}else{
d=(o=='U')?0:
(o=='R')?1:
(o=='D')?2:3;
int ny=ty+dy[d];
int nx=tx+dx[d];
if(0<=ny&&ny<h&&0<=nx&&nx<w&&g[ny][nx]=='.'){
ty=ny;
tx=nx;
}
}
}
for(int y=0;y<h;y++){
for(int x=0;x<w;x++){
if(y!=ty||x!=tx){
cout<<g[y][x];
}else{
const char *tc="^>v<";
cout<<tc[d];
}
}
cout<<endl;
}
if(t){
cout<<endl;
}
}
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a < b)
return a;
else
return b;
}
long long pow(long long B, long long P) {
long long S = 1;
for (long long i = 1; i <= P; i++) S = S * B;
return S;
}
long long fx4[] = {1, -1, 0, 0};
long long fy4[] = {0, 0, 1, -1};
long long A[200][200];
long long Count[20000];
int main() {
long long T, N, M, X, Y, W;
cin >> N;
int MIN = INT_MAX, pos;
for (int i = 1; i <= N; i++) {
cin >> X;
for (int j = 1; j <= X; j++) {
cin >> Y;
Count[Y]++;
}
}
for (int i = 1; i <= 100; i++) {
if (Count[i] == N) cout << i << " ";
}
return 0;
}
| 7 | CPP |
import sys,os
if(os.path.exists("input.txt")):
sys.stdin = open("input.txt","r")
sys.stdout = open("output.txt","w")
input=lambda:sys.stdin.readline().strip()
li = lambda:list(map(int,input().split()))
I = lambda:int(input())
for _ in range(I()):
n = I()
s = list(map(int,list(input())))
l = [0 for i in range(n)]
zero = 0
last_zero_set = []
one = 0
last_one_set = []
for index,i in enumerate(s):
if i==1:
if zero>0:
zero-=1
one+=1
last_one_set.append(last_zero_set.pop())
else:
one+=1
last_one_set.append(one)
l[index]=last_one_set[-1]
else:
if one>0:
one-=1
zero+=1
last_zero_set.append(last_one_set.pop())
else:
zero+=1
last_zero_set.append(zero)
l[index] =last_zero_set[-1]
print(zero+one)
print(*l)
| 10 | PYTHON3 |
# -*- coding: utf-8 -*-
# @Time : 2019/2/3 23:48
# @Author : LunaFire
# @Email : [email protected]
# @File : B. Average Superhero Gang Power.py
def main():
n, k, m = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
total_sum = sum(a)
ret = (total_sum + min(m, n * k)) / n
for i in range(min(n - 1, m)):
total_sum -= a[i]
temp = total_sum + min(m - i - 1, (n - i - 1) * k)
ret = max(ret, temp / (n - i - 1))
print(ret)
if __name__ == '__main__':
main()
| 8 | PYTHON3 |
n=int(input())
a=list(map(int,input().split()))
x=1
if x in a:
print("hard")
else:
print("easy")
| 7 | PYTHON3 |
p, q, r, s = list(sorted(map(int, input().strip().split())))
a = s - r
b = s - q
c = s - p
print(a, b, c) | 7 | PYTHON3 |
#include <cstdio>
#define rep( i, a, b ) for( int i = (a) ; i <= (b) ; i ++ )
#define per( i, a, b ) for( int i = (a) ; i >= (b) ; i -- )
const int MAXN = 405;
template<typename _T>
void read( _T &x )
{
x = 0; char s = getchar(); int f = 1;
while( s < '0' || '9' < s ) { f = 1; if( s == '-' ) f = -1; s = getchar(); }
while( '0' <= s && s <= '9' ) { x = ( x << 3 ) + ( x << 1 ) + ( s - '0' ), s = getchar(); }
x *= f;
}
template<typename _T>
void write( _T x )
{
if( x < 0 ) putchar( '-' ), x = -x;
if( 9 < x ) write( x / 10 );
putchar( x % 10 + '0' );
}
int f[MAXN][MAXN];
int pw[MAXN];
int fac[MAXN], ifac[MAXN];
int N, mod;
inline int Qkpow( int, int );
inline int Mul( int x, int v ) { return 1ll * x * v % mod; }
inline int Inv( const int a ) { return Qkpow( a, mod - 2 ); }
inline int Sub( int x, int v ) { return ( x -= v ) < 0 ? x + mod : x; }
inline int Add( int x, int v ) { return ( x += v ) >= mod ? x - mod : x; }
inline int Qkpow( int base, int indx )
{
int ret = 1;
while( indx )
{
if( indx & 1 ) ret = Mul( ret, base );
base = Mul( base, base ), indx >>= 1;
}
return ret;
}
void Init()
{
pw[0] = 1; rep( i, 1, N ) pw[i] = Mul( pw[i - 1], 2 );
fac[0] = 1; rep( i, 1, N ) fac[i] = Mul( fac[i - 1], i );
ifac[N] = Inv( fac[N] ); per( i, N - 1, 0 ) ifac[i] = Mul( ifac[i + 1], i + 1 );
}
int main()
{
read( N ), read( mod ), Init();
rep( i, 1, N )
{
f[i][i] = Mul( pw[i - 1], ifac[i] );
rep( j, 0, i - 1 ) rep( k, 2, i - 1 )
if( j >= i - k )
f[i][j] = Add( f[i][j], Mul( f[k - 1][j - ( i - k )], Mul( pw[i - k - 1], ifac[i - k] ) ) );
}
int ans = 0;
rep( j, 1, N )
ans = Add( ans, Mul( f[N][j], fac[j] ) );
write( ans ), putchar( '\n' );
return 0;
} | 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int f[1 << 14][14][1 << 6], bit[1 << 14], rev[1 << 14];
bool e[15][15];
long long ans[1 << 14];
int main() {
int n = 14;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
char str[20];
scanf("%s", str);
for (int j = 0; j < n; j++) e[i][j] = str[j] - '0';
}
int m = ((n + 1) >> 1);
for (int i = 1; i < (1 << n); i++) {
bit[i] = bit[i >> 1] + (i & 1);
if (bit[i] <= n - m - 1) {
for (int j = 0; j < n - m - 1; j++)
if ((i >> j) & 1) rev[i] ^= (1 << (n - m - 2 - j));
}
}
for (int i = 0; i < n; i++) f[1 << i][i][0] = 1;
for (int i = 1; i < (1 << n); i++)
if (bit[i] < m) {
int t = bit[i] - 1;
for (int j = 0; j < n; j++)
if ((i >> j) & 1) {
for (int k = 0; k < n; k++)
if (!((i >> k) & 1)) {
int nc = (i ^ (1 << k));
if (e[j][k]) {
int nn = (1 << t);
for (int l = 0; l < (1 << t); l++)
if (f[i][j][l]) f[nc][k][l ^ nn] += f[i][j][l];
} else {
for (int l = 0; l < (1 << t); l++)
if (f[i][j][l]) f[nc][k][l] += f[i][j][l];
}
}
}
}
for (int i = 1; i < (1 << n); i++)
if (bit[i] == m) {
int u = m - 1, v = n - m - 1, r = ((1 << n) - 1) ^ i;
for (int j = 0; j < n; j++)
if ((i >> j) & 1) {
for (int k = 0; k < n; k++)
if (!((i >> k) & 1)) {
int cs = ((e[j][k]) ? (1 << (m - 1)) : 0);
for (int t1 = 0; t1 < (1 << u); t1++)
if (f[i][j][t1]) {
for (int t2 = 0; t2 < (1 << v); t2++)
if (f[r][k][t2])
ans[t1 ^ (rev[t2] << m) ^ cs] +=
(long long)f[i][j][t1] * f[r][k][t2];
}
}
}
}
for (int i = 0; i < (1 << (n - 1)); i++) printf("%lld ", ans[i]);
printf("\n");
return 0;
}
| 12 | CPP |
n,x=map(int,input().split())
l=list(map(int,input().split()))
a=0
ans=1
for i in l:
a+=i
if a<=x:
ans+=1
print(ans) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
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;
}
const int INF = 2e5 + 2;
const long long hell = 998244353ll;
int n, m;
vector<bool> hor, ver;
bool bani[50][50];
void dfs(int a, int b) {
if (bani[a][b]) return;
bani[a][b] = true;
if (a < n - 1 && ver[b]) dfs(a + 1, b);
if (b < m - 1 && hor[a]) dfs(a, b + 1);
if (a > 0 && (!ver[b])) dfs(a - 1, b);
if (b > 0 && (!hor[a])) dfs(a, b - 1);
}
bool checking_every_vertex(int a, int b) {
memset(bani, false, sizeof(bani));
dfs(a, b);
bool ans = true;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
ans *= bani[i][j];
}
}
return ans;
}
void solve() {
cin >> n >> m;
char a;
for (int i = 0; i < n; i++) {
cin >> a;
if (a == '<')
hor.push_back(false);
else
hor.push_back(true);
}
for (int i = 0; i < m; i++) {
cin >> a;
if (a == 'v')
ver.push_back(true);
else
ver.push_back(false);
}
bool ans = true;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
ans *= checking_every_vertex(i, j);
}
}
if (ans) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int q = 1;
while (q--) {
solve();
}
return 0;
}
| 8 | CPP |
import math
n = int(input())
Result = []
for i in range(0,n):
Sum = []
var = False
DaysElements = list(map(int,input().strip().split()))[:2]
current_days = DaysElements[1]
len_ = DaysElements[0]
Elements = list(map(int, input().strip().split()))[:len_]
if len_ <= 1:
Result.append(Elements[0])
continue
current_index_pointer=1
for j in range (1,len_):
current_high = math.floor(current_days/current_index_pointer)
if Elements[j] <= current_high :
current_days = current_days - Elements[j]*current_index_pointer
Sum.append(Elements[j])
else:
current_days = current_days - current_high*current_index_pointer
Sum.append(current_high)
current_index_pointer +=1
if current_days < current_index_pointer:
var = True
Result.append(sum(Sum)+Elements[0])
break
if var is not True:
Result.append(sum(Sum) + Elements[0])
for i in Result:
print(i)
| 7 | PYTHON3 |
input()
P = [int(x) for x in input().split()]
mp = {v: i+1 for i, v in enumerate(P)}
ans = [mp[k] for k in sorted(mp.keys())]
print(" ".join(map(str, ans))) | 7 | PYTHON3 |
t = int(input())
for _ in range(t):
L = list(map(int,input().split()))
n = L[0]
s = L[1]
k = L[2]
bad = list(map(int, input().split()))
tr = s
while (tr in bad):
tr += 1
if tr > n:
tr = 10000000000
break
top_min = tr - s
tr = s
while (tr in bad):
tr -= 1
if tr < 1:
tr = -10000000000
break
bot_min = s - tr
print(min(bot_min, top_min))
| 7 | PYTHON3 |
n, k = map(int, input().split())
i = 1
while True:
if (n * i) % 10 == 0 or (n * i - k) % 10 == 0:
print(i)
break
i += 1
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int entries[1010000][2];
long long has[1010000];
long long power[1010000];
int main() {
int i, j;
long long ans = 0;
int n, m, u, v, p = 17;
scanf("%d%d", &n, &m);
power[0] = 1;
for (i = 1; i <= n; i++) power[i] = power[i - 1] * p;
for (i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
u--;
v--;
has[u] += power[v];
has[v] += power[u];
entries[i][0] = u;
entries[i][1] = v;
}
for (i = 0; i < m; i++) {
u = entries[i][0];
v = entries[i][1];
if (has[u] + power[u] == has[v] + power[v]) ans++;
}
sort(has, has + n);
for (i = 0; i < n; i = j) {
for (j = i; j < n && has[j] == has[i]; j++)
;
long long temp = j - i;
ans += temp * (temp - 1) / 2;
}
printf("%I64d\n", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using ll = long long;
using ull = unsigned long long;
using uint = unsigned int;
using ld = long double;
using vi = std::vector<int>;
using pii = std::pair<int, int>;
using vvi = std::vector<vi>;
using vii = std::vector<pii>;
using vll = std::vector<ll>;
using pll = std::pair<ll, ll>;
template <typename T>
int sign(const T& t) {
return (t > 0) - (t < 0);
}
template <typename T, typename U>
bool remax(T& a, U b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T, typename U>
bool remin(T& a, U b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T>
T gcd(T a, T b) {
a = std::abs(a);
b = std::abs(b);
while (b) {
a %= b;
std::swap(a, b);
}
return a;
}
template <typename T>
T lcm(T a, T b) {
a = std::abs(a);
b = std::abs(b);
return a / gcd(a, b) * b;
}
double get_time() { return static_cast<double>(clock()) / CLOCKS_PER_SEC; }
long long current_nanoseconds() {
return std::chrono::steady_clock::now().time_since_epoch().count();
}
long long default_seed = current_nanoseconds();
uint32_t mrand_32t() {
static std::mt19937 rng(default_seed);
return rng();
}
uint64_t mrand_64t() {
static std::mt19937_64 rng(default_seed);
return rng();
}
template <typename T>
void make_unique(std::vector<T>& v) {
std::sort(std::begin(v), std::end(v));
v.erase(std::unique(std::begin(v), std::end(v)), std::end(v));
}
namespace std {
template <typename A, typename B>
string to_string(const pair<A, B>& p) {
string str;
str += "(";
str += to_string(p.first);
str += ", ";
str += to_string(p.second);
str += ")";
return str;
}
string to_string(bool value) { return value ? "true" : "false"; }
template <typename T>
string to_string(const vector<T>& vec) {
string str = "{ ";
bool first = true;
for (const auto& it : vec) {
if (!first) {
str += ", ";
}
str += to_string(it);
first = false;
}
str += " }";
return str;
}
template <typename T>
string to_string(const set<T>& s) {
string str = "{ ";
bool first = true;
for (const auto& it : s) {
if (!first) {
str += ", ";
}
str += to_string(it);
first = false;
}
str += " }";
return str;
}
template <typename K, typename V>
string to_string(const map<K, V>& m) {
string str = "{ ";
bool first = true;
for (const auto& it : m) {
if (!first) {
str += ", ";
}
first = false;
str += to_string(it.first);
str += " -> ";
str += to_string(it.second);
}
str += " }";
return str;
}
string to_string(const string& s) { return "\"" + s + "\""; }
string to_string(const char* s) { return to_string(string(s)); }
string to_string(char ch) { return "\'" + string(1, ch) + "\'"; }
template <size_t N>
string to_string(const bitset<N>& b) {
string res(N, '0');
for (size_t i = 0; i < N; ++i) {
res[i] = '0' + b[i];
}
return res;
}
template <typename T>
string to_string(const T& t) {
std::stringstream ss;
ss << t;
return ss.str();
}
} // namespace std
void debug_out() { std::cerr << std::endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
std::cerr << " " << std::to_string(H);
debug_out(T...);
}
using namespace std;
int n, m;
vvi a;
bool read() {
if (!(cin >> n >> m)) {
return 0;
}
a.clear();
a.resize(n, vi(m));
for (int i = int(0); i < int(n); ++i) {
for (int j = int(0); j < int(m); ++j) {
cin >> a[i][j];
}
}
return 1;
}
vector<vii> calc_col(const vvi& a) {
vector<vii> ans(int((a).size()), vii(int((a[0]).size())));
for (int j = int(0); j < int(int((a[0]).size())); ++j) {
vi vals;
for (int i = int(0); i < int(int((a).size())); ++i) {
vals.push_back(a[i][j]);
}
make_unique(vals);
for (int i = int(0); i < int(int((a).size())); ++i) {
int v = a[i][j];
int pos = lower_bound(begin(vals), end(vals), v) - vals.begin();
ans[i][j].first = pos;
ans[i][j].second = int((vals).size()) - pos - 1;
}
}
return ans;
}
template <typename T>
vector<vector<T>> trans(const vector<vector<T>>& a) {
vector<vector<T>> b(int((a[0]).size()), vector<T>(int((a).size())));
for (int i = int(0); i < int(int((a).size())); ++i) {
for (int j = int(0); j < int(int((a[0]).size())); ++j) {
b[j][i] = a[i][j];
}
}
return b;
}
void solve() {
auto cols = calc_col(a);
auto rows = trans(calc_col(trans(a)));
for (int i = int(0); i < int(n); ++i) {
for (int j = int(0); j < int(m); ++j) {
int less = max(cols[i][j].first, rows[i][j].first);
int gr = max(cols[i][j].second, rows[i][j].second);
int ans = less + 1 + gr;
cout << ans << " ";
}
cout << "\n";
}
cout << endl;
}
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout.tie(nullptr);
cout.precision(12);
cout << fixed;
while (read()) {
solve();
}
return 0;
}
| 7 | CPP |
#include<bits/stdc++.h>
using namespace std;
int main(){
int k,x;
cin>>k>>x;
for(int i=0;i<2*k-1;++i){
if(i)cout<<" ";
cout<<x-k+1+i;
}
} | 0 | CPP |
n,m = map(int,input().split())
S = set(range(1,m+1))
for i in range(n):
a,*b = map(int,input().split())
S &= set(b)
print(len(S))
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int b[10];
int main() {
int n;
cin >> n;
int a;
for (int i = 0; i < n; i++) {
cin >> a;
b[(a % 3)]++;
}
cout << ((b[0] / 2) + min(b[1], b[2])) << endl;
return 0;
}
| 9 | CPP |
T = int(input())
for i in range(T):
x, y, a, b = map(int, input().split())
res = -1
if (y-x) / (a+b) % 1 == 0:
res = (y-x) // (a+b)
print(res) | 7 | PYTHON3 |
#include <iostream>
#include <cstdio>
using namespace std;
int main(void){
int sec, sec3;
int used;
int hh,mm,ss;
int reth,retm,rets;
while(cin >> hh >> mm >> ss){
if(hh == -1 && mm == -1 && ss == -1) break;
used = hh * 3600 + mm * 60 + ss;
sec = 7200 - used;
sec3 = sec * 3;
reth = sec / 3600;
sec -= 3600 * reth;
retm = sec / 60;
sec -= 60 * retm;
rets = sec;
printf("%02d:%02d:%02d\n", reth, retm, rets);
reth = sec3 / 3600;
sec3 -= 3600 * reth;
retm = sec3 / 60;
sec3 -= 60 * retm;
rets = sec3;
printf("%02d:%02d:%02d\n", reth, retm, rets);
}
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, x1, y1, x2, y2;
;
cin >> n;
cout << "YES\n";
for (long long i = 0; i < n; i++) {
cin >> x1 >> y1 >> x2 >> y2;
if (x1 % 2 == 0 && y1 % 2 == 0) cout << "1\n";
if (x1 % 2 == 0 && y1 % 2 != 0) cout << "2\n";
if (x1 % 2 != 0 && y1 % 2 == 0) cout << "3\n";
if (x1 % 2 != 0 && y1 % 2 != 0) cout << "4\n";
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000 + 50;
struct node {
int l, r, c, ctag, sz;
long long ans, atag;
} tr[MAXN * 4];
void upp(int p) {
if (tr[(p << 1)].c == tr[((p << 1) | 1)].c)
tr[p].c = tr[(p << 1)].c;
else
tr[p].c = -1;
tr[p].ans = tr[(p << 1)].ans + tr[((p << 1) | 1)].ans;
}
void dwn(int p) {
if (tr[p].l == tr[p].r) return;
int ctag = tr[p].ctag;
long long atag = tr[p].atag;
tr[p].atag = tr[p].ctag = 0;
if (ctag) {
tr[(p << 1)].c = tr[((p << 1) | 1)].c = ctag;
tr[(p << 1)].ctag = tr[((p << 1) | 1)].ctag = ctag;
}
if (atag) {
tr[(p << 1)].atag += atag;
tr[((p << 1) | 1)].atag += atag;
tr[(p << 1)].ans += tr[(p << 1)].sz * atag;
tr[((p << 1) | 1)].ans += tr[((p << 1) | 1)].sz * atag;
}
}
void build(int p, int l, int r) {
tr[p].l = l;
tr[p].r = r;
tr[p].c = -1;
tr[p].sz = r - l + 1;
if (l == r) {
tr[p].c = l;
return;
}
int mid = (l + r) >> 1;
build((p << 1), l, mid);
build(((p << 1) | 1), mid + 1, r);
}
void change(int p, int x, int y, int v) {
dwn(p);
int l = tr[p].l, r = tr[p].r;
if (l == x && y == r && tr[p].c != -1) {
long long t = abs(tr[p].c - v);
tr[p].ans += tr[p].sz * t;
tr[p].atag += t;
tr[p].c = tr[p].ctag = v;
return;
}
int mid = (r + l) >> 1;
if (y <= mid)
change((p << 1), x, y, v);
else if (mid < x)
change(((p << 1) | 1), x, y, v);
else {
change((p << 1), x, mid, v);
change(((p << 1) | 1), mid + 1, y, v);
}
upp(p);
}
long long qrysum(int p, int x, int y) {
dwn(p);
int l = tr[p].l, r = tr[p].r;
if (l == x && y == r) return tr[p].ans;
int mid = (r + l) >> 1;
if (y <= mid)
return qrysum((p << 1), x, y);
else if (mid < x)
return qrysum(((p << 1) | 1), x, y);
else
return qrysum((p << 1), x, mid) + qrysum(((p << 1) | 1), mid + 1, y);
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
build(1, 1, n);
for (int i = 1, op, x, y, z; i <= m; i++) {
scanf("%d%d%d", &op, &x, &y);
if (op == 1) scanf("%d", &z), change(1, x, y, z);
if (op == 2) printf("%lld\n", qrysum(1, x, y));
}
return 0;
}
| 9 | CPP |
import sys
n = int(input())
lst = list(input())
maxin=0
dvugramma=''
if n==2 or n==3:
print(lst[0]+lst[1])
sys.exit()
for i in range(n-1):
x=0
var=lst[i]+lst[i+1]
for j in range(i+1,n-1):
z=lst[j]+lst[j+1]
if var == ''.join(z):
x+=1
if x>maxin:
maxin=x
dvugramma=var
if maxin>0:
print(dvugramma)
sys.exit()
print(lst[0]+lst[1])
| 8 | PYTHON3 |
n = int(input())
cardslist = []
for i in range(n):
input_cards = input()
cardslist.append(input_cards)
for mark in "SHCD":
for i in range(1, 14):
if mark + ' ' + str(i) not in cardslist:
print(mark + ' ' + str(i))
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string m[12] = {"January", "February", "March", "April",
"May", "June", "July", "August",
"September", "October", "November", "December"};
string r;
cin >> r;
int n, jan = 0, feb = 1, mar = 2, ap = 3, my = 4, ju = 5, jul = 6, aug = 7,
sep = 8, oc = 9, nov = 10, dec = 11;
cin >> n;
if (r == "January") {
jan += n;
cout << m[(jan % 12)] << endl;
} else if (r == "February") {
feb += n;
cout << m[feb % 12] << endl;
} else if (r == "March") {
mar += n;
cout << m[mar % 12] << endl;
} else if (r == "April") {
ap += n;
cout << m[ap % 12] << endl;
} else if (r == "May") {
my += n;
cout << m[(my % 12)] << endl;
} else if (r == "June") {
ju += n;
cout << m[ju % 12] << endl;
} else if (r == "July") {
jul += n;
cout << m[jul % 12] << endl;
} else if (r == "August") {
aug += n;
cout << m[aug % 12] << endl;
} else if (r == "September") {
sep += n;
cout << m[sep % 12] << endl;
} else if (r == "October") {
oc += n;
cout << m[oc % 12] << endl;
} else if (r == "November") {
nov += n;
cout << m[(nov) % 12] << endl;
} else {
dec += n;
cout << m[dec % 12] << endl;
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int h[10000][3];
int parent(int x) {
while (h[x][0] != x) x = h[x][0];
return x;
}
void merge(int x, int y) {
if (x == y) return;
if (h[x][1] == h[y][1]) {
h[y][0] = x;
h[x][1]++;
h[x][2] += h[y][2];
} else if (h[x][1] > h[y][1]) {
h[y][0] = x;
h[x][2] += h[y][2];
} else {
h[x][0] = y;
h[y][2] += h[x][2];
}
}
int main() {
int n;
int k, m;
cin >> n;
int i, j;
for (i = 1; i <= n; i++) {
h[i][0] = i;
h[i][1] = h[i][2] = 1;
}
cin >> k;
int x, y;
for (i = 0; i < k; i++) {
cin >> x >> y;
merge(parent(x), parent(y));
}
cin >> m;
for (i = 0; i < m; i++) {
cin >> x >> y;
int p = parent(x), q = parent(y);
if (p == q) h[p][2] = h[q][2] = -1;
}
int t = 0;
h[0][2] = -1;
for (i = 1; i <= n; i++) {
if (h[parent(i)][2] > h[t][2]) t = i;
}
if (h[t][2] > 0)
cout << h[t][2] << '\n';
else
cout << 0 << '\n';
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 5;
long long a[N], n;
long long x;
long long sum[N], sz[N];
long long c2(long long a) { return 1LL * a * (a - 1) / 2; }
bool cmp(pair<long long, long long> v, pair<long long, long long> u) {
return v < u;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i + n] = a[i];
}
n *= 2;
for (int i = 0; i < n; i++) {
sz[i + 1] = sz[i] + a[i];
sum[i + 1] = sum[i] + (1LL * (a[i] + 1) * a[i] / 2);
}
vector<pair<long long, long long> > vec;
vec.push_back({0, 0});
long long ans = 0;
for (int i = 0; i < n; i++) {
if (a[i] >= x)
ans = max(ans, c2(a[i] + 1) - c2(a[i] - x + 1));
else {
int low = -1, high = i;
pair<long long, long long> best = {-1, -1};
while (high - low > 1) {
int mid = (low + high) >> 1;
if (sz[i + 1] - sz[mid] <= x)
high = mid;
else
low = mid;
}
int j = high;
long long b = sum[i + 1] - sum[j], r = sz[i + 1] - sz[j];
if (j && x - r > 0) {
r = min(x - r, a[j - 1]);
ans = max(ans, b + c2(a[j - 1] + 1) - c2(a[j - 1] - r + 1));
} else
ans = max(ans, b);
}
vec.push_back({sz[i + 1], i + 1});
}
cout << ans << "\n";
}
| 10 | CPP |
#!python3
# input
A, B = list(map(int, input().split()))
def paint1(ans):
a = 1
for i in range(0, 49, 2):
for j in range(0, 100, 2):
if a == A:
return
ans[i][j] = "."
a += 1
def paint2(ans):
b = 1
for i in range(51, 100, 2):
for j in range(0, 100, 2):
if b == B:
return
ans[i][j] = "#"
b += 1
def main():
ans = [["#"] * 100 for _ in range(50)] + [["."] * 100 for _ in range(50)]
paint1(ans)
paint2(ans)
print(100, 100)
for r in ans:
print("".join(r))
if __name__ == "__main__":
main()
| 0 | PYTHON3 |
n,t = map(int, input().split())
print(n + sum(i > t for i in map(int,input().split()))) | 7 | PYTHON3 |
n=int(input())
a=list(map(int,input().split()))
x='APPROVED'
for i in a:
if i%2==0:
if i%3!=0 and i%5!=0:
x='DENIED'
break
print(x) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long INF = 1e16;
const long long MAX_N = 10010;
int main() {
long long n, m;
cin >> n >> m;
vector<vector<long long>> dp(m + 1, vector<long long>(n + 1));
for (long long j = 1; j <= n; j++) {
dp[1][j] = 1;
}
for (long long i = 1; i <= m - 1; i++) {
for (long long j = 1; j <= n; j++) {
for (long long k = j; k <= n; k += j) {
dp[i + 1][j] += dp[i][k];
dp[i + 1][j] %= mod;
}
}
}
long long ans = 0;
for (long long j = 1; j <= n; j++) {
ans += dp[m][j];
ans %= mod;
}
cout << ans << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
string en = "\n";
string hlo = "hello";
string Y = "YES\n";
string Ys = "Yes\n";
string N = "NO\n";
string No = "No\n";
string sp = " ";
bool isprm(long long a) {
for (long long i = 2; i * i <= a; i++) {
if (a % i == 0) return false;
}
return true;
}
bool palin(string a) {
for (int i = 0; i < a.size(); i++) {
if (a.at(i) != a.at(a.size() - i - 1)) return 0;
}
return 1;
}
bool isVowel(char ch) {
ch = toupper(ch);
if (ch == 'A' || ch == 'U' || ch == 'I' || ch == 'O' || ch == 'E')
return true;
return false;
}
int main() {
long long a, b, c, d, e, x, t, n, k, m, p, q, r, y, z, yy, sum = 0, ct = 0,
flag = 0;
string s, s1, s2, s3, s4;
char ch, ch1, ch2;
deque<long long> d1, d2, d3;
vector<string> vs1;
string ss1;
map<long long, long long> mp;
set<char> st1, st2;
vector<pair<long long, long long> > v;
vector<long long> v1, v2, v3;
double x1, y1, x2, y2, x3, y3, x4, y4;
sum = 0;
long long mx = 0, mn = 3487327628458454875, cp = 0;
long long HR, MN, mnt, hrs, c1 = 0, c2 = 0;
flag = 0;
ct = 0;
flag = 0;
cp = 0;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a;
v1.push_back(a);
}
sort(v1.begin(), v1.end());
ct = 0;
flag = 0;
if (v1[0] == 1) {
cout << 1 << endl;
return 0;
} else {
for (long long i = 1; i < n; i++) {
if (v1[i] % v1[0] != 0) {
cout << -1 << endl;
return 0;
}
}
cout << v1[0] << endl;
}
}
| 7 | CPP |
n=int(input())
a=[[[0 for _ in range(10)]for _ in range(3)]for _ in range(4)]
for i in range(n):
b,f,r,v=map(int, input().split())
a[b-1][f-1][r-1]+=v
for bb in range(4):
for ff in range(3):
print(*[""]+a[bb][ff])
if bb==3:
break
else:
print("#"*20)
| 0 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#pragma GCC optimize(2)
#pragma GCC optimize(3)
using namespace std;
static char __allocator_space__[100000000];
static char *__sp = __allocator_space__;
template <typename T>
struct fastalloc : allocator<T> {
fastalloc() {}
template <typename T2>
fastalloc(const fastalloc<T2> &a) {}
template <typename T2>
fastalloc<T> &operator=(const fastalloc<T2> &a) {
return *this;
}
template <typename T2>
struct rebind {};
inline T *allocate(size_t n) {
T *result = (T *)__sp;
__sp += n * sizeof(T);
return result;
}
inline void deallocate(T *p, size_t n) {}
};
struct chtholly_node {
mutable long long l, r;
mutable bool v;
chtholly_node(long long L, long long R, bool x) : l(L), r(R), v(x) {}
bool operator<(const chtholly_node &x) const { return l < x.l; }
};
long long ans = 1;
set<chtholly_node, less<chtholly_node>, fastalloc<chtholly_node> > chtholly;
typedef set<chtholly_node, less<chtholly_node>,
fastalloc<chtholly_node> >::iterator IT;
inline IT chtholly_split(long long pos) {
IT it = chtholly.lower_bound(chtholly_node(pos, -1, bool()));
if (it != chtholly.end() && it->l == pos) return it;
--it;
long long L = it->l, R = it->r;
bool V = it->v;
chtholly.erase(it);
chtholly.insert(chtholly_node(L, pos - 1, V));
return chtholly.insert(chtholly_node(pos, R, V)).first;
}
inline void find_next() {
IT it = chtholly_split(ans);
while (true) {
if (!it->v) {
ans = it->l;
return;
}
++it;
}
}
inline void chtholly_assign(long long l, long long r, bool x) {
IT itr = chtholly_split(r + 1), itl = chtholly_split(l);
chtholly.erase(itl, itr);
chtholly.insert(chtholly_node(l, r, x));
if (x == 0)
ans = min(ans, l);
else if (l <= ans && ans <= r)
find_next();
}
void chtholly_reverse(long long l, long long r) {
IT itr = chtholly_split(r + 1), itl = chtholly_split(l);
if (l <= ans && ans <= r) {
bool flag = false;
for (; itl != itr; ++itl) {
itl->v ^= 1;
if (!flag && !itl->v) {
flag = true;
ans = itl->l;
}
}
if (!flag) find_next();
} else {
bool flag = false;
for (; itl != itr; ++itl) {
itl->v ^= 1;
if (!flag && !itl->v) {
flag = true;
ans = min(ans, itl->l);
}
}
}
}
int q;
int main() {
chtholly.insert(chtholly_node(1LL, 1000000000000000001LL, 0));
scanf("%d", &q);
while (q--) {
int op;
long long l, r;
scanf("%d %lld %lld", &op, &l, &r);
if (op == 1) chtholly_assign(l, r, 1);
if (op == 2) chtholly_assign(l, r, 0);
if (op == 3) chtholly_reverse(l, r);
printf("%lld\n", ans);
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MX = 200020;
const int N = 1000060;
const int mod = (int)1e9 + 7;
int bc[1111][1111];
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a, a + n);
for (int i = n - 1; i >= 0; --i) {
if (k % a[i] == 0) {
cout << k / a[i] << endl;
return 0;
}
}
return 0;
}
| 7 | CPP |
import itertools
n=int(input())
table=[0 for i in range(100003)]
table[0]=1
for i in range(n):
a,b=map(int,input().split())
table[a]+=1
table[b+1]-=1
table=list(itertools.accumulate(table))
for i in range(len(table)):
if table[i]>=i:
ans=i
print(ans-1)
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
vector<int> a(n);
for (int& v : a) cin >> v;
long pos = 0;
while (pos < n) {
long mine = min_element(a.begin() + pos, a.end()) - a.begin();
int el = a[mine];
a.erase(a.begin() + mine);
a.insert(a.begin() + pos, el);
if (pos == mine)
pos++;
else
pos = mine;
}
for (int i : a) cout << i << " ";
cout << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3f3fll;
const long long M = 1e9 + 7;
const long long maxn = 1e5 + 107;
const double pi = acos(-1.0);
const double eps = 0.0000000001;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
template <typename T>
inline void pr2(T x, int k = 64) {
long long i;
for (i = 0; i < k; i++) fprintf(stderr, "%d", (x >> i) & 1);
putchar(' ');
}
template <typename T>
inline void add_(T &A, int B, long long MOD) {
A += B;
(A >= MOD) && (A -= MOD);
}
template <typename T>
inline void mul_(T &A, long long B, long long MOD) {
A = (A * B) % MOD;
}
template <typename T>
inline void mod_(T &A, long long MOD = M) {
A %= MOD;
A += MOD;
A %= MOD;
}
template <typename T>
inline void max_(T &A, T B) {
(A < B) && (A = B);
}
template <typename T>
inline void min_(T &A, T B) {
(A > B) && (A = B);
}
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <typename T>
inline T powMM(T a, T b) {
T ret = 1;
for (; b; b >>= 1ll, a = (long long)a * a % M)
if (b & 1) ret = (long long)ret * a % M;
return ret;
}
int startTime;
void startTimer() { startTime = clock(); }
void printTimer() {
fprintf(stderr, "/--- Time: %ld milliseconds ---/\n", clock() - startTime);
}
inline int poww(int a, int b, int p) {
int ret = 1;
for (; b; b >>= 1, a = (long long)a * a % p)
if (b & 1) ret = (long long)ret * a % p;
return ret;
}
int p[12], tot;
struct node {
int mx, c[12], mc, sx;
node() {
mc = mx = 1;
sx = 0;
memset(c, 0, sizeof(c));
}
} T[maxn * 4];
int mod;
void pushdown(int x) {
mul_(T[x << 1].mc, T[x].mc, mod);
mul_(T[x << 1].sx, T[x].mc, mod);
mul_(T[x << 1 | 1].mc, T[x].mc, mod);
mul_(T[x << 1 | 1].sx, T[x].mc, mod);
int i;
T[x].mc = 1;
for (i = 0; i < tot; i++) {
T[x << 1].c[i] += T[x].c[i];
T[x << 1 | 1].c[i] += T[x].c[i];
T[x].c[i] = 0;
}
mul_(T[x << 1].mx, T[x].mx, mod);
mul_(T[x << 1].sx, T[x].mx, mod);
mul_(T[x << 1 | 1].mx, T[x].mx, mod);
mul_(T[x << 1 | 1].sx, T[x].mx, mod);
T[x].mx = 1;
}
int op, l, r;
int now[12], mx, mc, mul;
int ans;
void solve(int x, int L, int R) {
int l = max(L, ::l), r = min(R, ::r);
if (l <= L && R <= r) {
if (op == 1 || op == 2) {
int i;
mul_(T[x].mx, mx, mod);
mul_(T[x].mc, mc, mod);
mul_(T[x].sx, mul, mod);
for (i = 0; i < tot; i++) T[x].c[i] += now[i];
} else
add_(ans, T[x].sx, mod);
if (L == R) {
int i;
T[x].mc = 1;
for (i = 0; i < tot; i++) mul_(T[x].mc, poww(p[i], T[x].c[i], mod), mod);
T[x].sx = (long long)T[x].mx * T[x].mc % mod;
}
return;
}
int mid = (L + R) / 2;
pushdown(x);
if (l <= mid) solve(x << 1, L, mid);
if (mid < r) solve(x << 1 | 1, mid + 1, R);
T[x].sx = (T[x << 1].sx + T[x << 1 | 1].sx) % mod;
return;
}
void reset() {
int i;
for (i = 0; i < tot; i++) now[i] = 0;
mul = mx = mc = 1;
}
void setit(int x) {
int i;
mul = x;
for (i = 0; i < tot; i++)
while (x % p[i] == 0) now[i]++, x /= p[i];
mx = x;
mc = mul / mx;
}
int main() {
int q, i, k, _, n;
op = 1;
scanf("%d%d", &n, &mod);
int pwmod = mod;
for (k = mod, i = 2; i * i <= k; i++)
if (k % i == 0) {
p[tot++] = i;
while (k % i == 0) k /= i;
}
if (k != 1) p[tot++] = k;
for (i = 0; i < tot; i++) pwmod = pwmod / p[i] * (p[i] - 1);
pwmod--;
for (i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
reset();
setit(x);
l = r = i;
solve(1, 1, n);
}
scanf("%d", &q);
for (_ = 1; _ <= q; _++) {
int x, i;
scanf("%d", &op);
reset();
if (op == 1) {
scanf("%d%d%d", &l, &r, &x);
setit(x);
} else if (op == 2) {
scanf("%d%d", &l, &x);
r = l;
setit(x);
for (i = 0; i < tot; i++) now[i] = -now[i];
mx = poww(mx, pwmod, mod);
} else {
scanf("%d%d", &l, &r);
ans = 0;
}
solve(1, 1, n);
if (op == 3) printf("%d\n", ans);
}
}
| 11 | CPP |
#include<iostream>
#include<algorithm>
using namespace std;
#define INF (1<<20)
double dp[32][1<<9];
int x, y, z;
double dist[32][32];
int n, m, p, a, b;
int t[32];
bool solve(){
double res = INF;
cin >> n >> m >> p >> a >> b;a--,b--;
if(n == 0)return false;
for(int i = 0;i < n;i++)cin >> t[i];
for(int i = 0;i < m;i++){
for(int j = 0;j < m;j++){
dist[i][j] = INF;
}
}
for(int i = 0;i < p;i++){
cin >> x >> y >> z;x--,y--;
dist[x][y] = dist[y][x] = z;
}
for(int i = 0;i < m;i++){
for(int j = 0;j < (1<<n);j++){
dp[i][j] = INF;
}
}
dp[a][0] = 0;
for(int used = 0;used < (1<<n);used++){
for(int now = 0;now < m;now++){
if(dp[now][used] == INF)continue;
// cout << now << " " << used << " "<< dp[now][used] << endl;
if(now == b)res = min(res, dp[now][used]);
for(int to = 0;to < m;to++){
if(dist[now][to] == INF)continue;
for(int i = 0;i < n;i++){
if((used) & (1 << i))continue;
dp[to][used | (1<<i)] = min(dp[to][used | (1<<i)], dp[now][used] + dist[now][to] / t[i]);
}
}
}
}
if(res == INF)cout << "Impossible" << endl;
else cout << res << endl;
return true;
}
int main(){
while(solve());
return 0;
}
| 0 | CPP |
#include<bits/stdc++.h>
using namespace std;
int a,b,c;
int main(){
cin>>a>>b>>c;
if((a==b&&b!=c)||(a==c&&c!=b)||(c==b&&a!=b)){
cout<<"Yes";
}
else cout<<"No";
return 0;
}
| 0 | CPP |
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization ("unroll-loops")
#include <iostream>
#include <iostream>
#include <stdio.h>
#include <iterator>
#include <vector>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <bits/stdc++.h>
using namespace std;
typedef long long llu;
typedef long double lld;
typedef pair<int,int> pi;
#define FastIO cin.sync_with_stdio(false),cin.tie(NULL)
#define ll long long int
#define mod (ll) 1000000007
#define pb push_back
#define f(i,s,n) for (int i=s;i<n;i++)
#define fb(i,s,n,b) for (int i=s;i<n;i+=b)
#define frev(i,s,n) for(int i=s;i>n;i--)
#define vii vector<int>
#define seti set<int>
#define mapi unordered_map<int,int>
#define mapv map<int,vii>
#define vll vector<ll>
#define vpp vector<pp>
#define vss vector<string>
#define lcm(a,b) (a*b)/__gcd(a,b)
#define all(a) a.begin(),a.end()
#define all(a) a.begin(),a.end()
#define fo(i,a) for(auto &i:a)
#define bs(v,x) binary_search(all(v),x)
#define fast ios_base::sync_with_stdio(false),cin.tie(nullptr),cout.tie(nullptr);srand(time(NULL))
#define sortrev(a) sort(a.begin(), a.end(), greater<pair<pair<int,int>,int>>());
#define vii2d vector<vector<int>>
#define ms multiset<int>
#define pairi pair<int,int>
#define useti unordered_set<int>
#define mp make_pair
#define gcd(a,b) __gcd(a,b)
const int N=200005;
void solve()
{
ll k,l,r,t,x,y;
cin>>k>>l>>r>>t>>x>>y;
if (x==y)
{
if ((k+y<=r)||(k-x>=l))
cout<<"YES"<<endl;
else
cout<<"NO"<<endl;
return;
}
if (x>y)
{
if (k+y>r)
{
k-=x;
t-=1;
}
if (k<l)
{
cout<<"NO"<<endl;
return;
}
ll left=k-l;
ll ne=left/(x-y);
if (ne>=t)
cout<<"YES"<<endl;
else
cout<<"NO"<<endl;
}
else
{
t-=(k-l)/x;
k-=((k-l)/x)*x;
if (t<=0)
{
cout<<"YES"<<endl;
return;
}
if (k+y>r)
{
cout<<"NO"<<endl;
return;
}
ll f=1;
mapi d;
while(t>0)
{
if (k+y<=r)
k+=y;
else
{
f=0;
break;
}
t-=(k-l)/x;
k-=((k-l)/x)*x;
if (d[k%x]==1)
{
f=1;
break;
}
d[k%x]=1;
}
if (f==1)
cout<<"YES"<<endl;
else
cout<<"NO"<<endl;
}
}
int main()
{
FastIO;
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t=1;
int c=0;
while(t--)
{
solve();
c+=1;
}
return 0;
} | 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool SR(int &_x) { return scanf("%d", &_x) == 1; }
bool SR(long long &_x) { return scanf("%" PRId64, &_x) == 1; }
bool SR(double &_x) { return scanf("%lf", &_x) == 1; }
bool SR(char *_s) { return scanf("%s", _s) == 1; }
bool RI() { return true; }
template <typename I, typename... T>
bool RI(I &_x, T &..._tail) {
return SR(_x) && RI(_tail...);
}
void SP(const int _x) { printf("%d", _x); }
void SP(const long long _x) { printf("%" PRId64, _x); }
void SP(const double _x) { printf("%.16lf", _x); }
void SP(const char *s) { printf("%s", s); }
void PL() { puts(""); }
template <typename I, typename... T>
void PL(const I _x, const T... _tail) {
SP(_x);
if (sizeof...(_tail)) putchar(' ');
PL(_tail...);
}
const int maxn = 3e5 + 5;
bool win(const pair<int, int> &i, const pair<int, int> &j,
const pair<int, int> &k) {
assert(i.first < j.first && j.first < k.first);
return 1LL * (i.second - j.second) * (k.first - j.first) >=
1LL * (j.second - k.second) * (j.first - i.first);
}
long long f(const pair<int, int> &p, const int &x) {
return 1LL * p.first * x + p.second;
}
const long long INF = 2e18;
struct Seg {
vector<pair<int, int> > dat[maxn << 2];
void add(int x, int low, int high, int a, int b, pair<int, int> v) {
if (low == a && b == high) {
;
dat[x].push_back(v);
return;
}
int mid = (low + high) / 2;
if (b <= mid)
add(x << 1, low, mid, a, b, v);
else if (mid + 1 <= a)
add(x << 1 | 1, mid + 1, high, a, b, v);
else
add(x << 1, low, mid, a, mid, v),
add(x << 1 | 1, mid + 1, high, mid + 1, b, v);
}
void build(int x, int low, int high) {
dat[x].erase(unique((dat[x]).begin(), (dat[x]).end(),
[&](pair<int, int> a, pair<int, int> b) {
return a.first == b.first;
}),
dat[x].end());
vector<pair<int, int> > q;
for (auto p : dat[x]) {
while (((int)(q).size()) >= 2 &&
win(q[((int)(q).size()) - 2], q.back(), p))
q.pop_back();
q.push_back(p);
}
dat[x].swap(q);
reverse((dat[x]).begin(), (dat[x]).end());
if (low == high) return;
int mid = (low + high) / 2;
build(x << 1, low, mid);
build(x << 1 | 1, mid + 1, high);
}
long long ask(int x, int low, int high, int pos, int val) {
while (((int)(dat[x]).size()) >= 2 &&
f(dat[x][((int)(dat[x]).size()) - 2], val) >= f(dat[x].back(), val))
dat[x].pop_back();
long long ret = (((int)(dat[x]).size()) ? f(dat[x].back(), val) : -INF);
if (low == high) return ret;
int mid = (low + high) / 2;
if (pos <= mid)
return max(ret, ask(x << 1, low, mid, pos, val));
else
return max(ret, ask(x << 1 | 1, mid + 1, high, pos, val));
}
} seg;
int n;
int a[maxn][3];
void read() {
RI(n);
for (int i = (1); i <= int(n); i++) {
RI(a[i][0], a[i][1]);
if (a[i][0] == 1) RI(a[i][2]);
}
}
void build() {
map<pair<int, int>, int> hp, st;
vector<pair<pair<int, int>, pair<int, int> > > v;
for (int i = (1); i <= int(n); i++) {
if (a[i][0] == 1) {
if (++hp[make_pair(a[i][1], a[i][2])] == 1)
st[make_pair(a[i][1], a[i][2])] = i;
} else if (a[i][0] == 2) {
auto p = make_pair(a[a[i][1]][1], a[a[i][1]][2]);
if (--hp[p] == 0) v.push_back(make_pair(p, make_pair(st[p], i)));
}
}
for (auto p : hp)
if (p.second > 0)
v.push_back(make_pair(p.first, make_pair(st[p.first], n)));
sort((v).begin(), (v).end(),
[&](const pair<pair<int, int>, pair<int, int> > &x,
const pair<pair<int, int>, pair<int, int> > &y) {
return tie(x.first.first, y.first.second) <
tie(y.first.first, x.first.second);
});
for (auto p : v) {
seg.add(1, 1, n, p.second.first, p.second.second, p.first);
;
}
seg.build(1, 1, n);
}
long long ans[maxn];
void sol() {
vector<int> v;
for (int i = (1); i <= int(n); i++)
if (a[i][0] == 3) v.push_back(i);
sort((v).begin(), (v).end(), [&](int i, int j) { return a[i][1] < a[j][1]; });
for (int i : v) ans[i] = seg.ask(1, 1, n, i, a[i][1]);
for (int i = (1); i <= int(n); i++)
if (a[i][0] == 3) {
if (ans[i] == -INF)
PL("EMPTY SET");
else
PL(ans[i]);
}
}
int main() {
read();
build();
sol();
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
int main() {
int n, j, i, t = 0, s, min, max;
scanf("%d", &n);
if (n == 0) {
printf("0");
return 0;
}
int a[n];
scanf("%d", &a[0]);
if (n == 0 || n == 1) {
printf("0");
return 0;
}
scanf("%d", &a[1]);
if (a[1] > a[0]) {
max = a[1];
min = a[0];
s = 1;
} else if (a[0] > a[1]) {
min = a[1];
max = a[0];
s = 1;
} else if (a[0] == a[1]) {
s = 0;
max = a[1];
min = a[1];
}
for (i = 2; i < n; i++) {
scanf("%d", &a[i]);
if (a[i] <= max && a[i] >= min) {
s = s;
continue;
} else if (a[i] > max) {
max = a[i];
s = s + 1;
} else if (a[i] < min) {
min = a[i];
s = s + 1;
}
}
printf("%d", s);
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T sqr(T a) {
return a * a;
}
template <typename T>
int size(T& a) {
return (int)a.size();
}
void initf() {}
char s[1100];
int sum[2100];
int main() {
initf();
int n;
scanf("%d\n", &n);
gets(s);
memset((sum), (0), sizeof(sum));
for (int i = 0; i < n; ++i) {
if (i) sum[i] += sum[i - 1];
if (s[i] == 'H') ++sum[i];
}
for (int i = 0; i < n; ++i) {
sum[i + n] += sum[i + n - 1];
if (s[i] == 'H') ++sum[i + n];
}
int ans = 2000000000;
int c = sum[n - 1];
for (int i = 0; i < n + n; ++i) {
if (i + c - 1 >= n + n) continue;
int sm = sum[i + c - 1] - (i - 1 < 0 ? 0 : sum[i - 1]);
ans = min(ans, c - sm);
}
printf("%d", ans);
return 0;
}
| 9 | CPP |
n,t=map(int,input().strip().split())
s=input()
while t>0:
s=s.replace('BG','GB')
t-=1
print(s)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
double EPS = 1e-9;
int INF = 100005;
long long int mod = 1000000007;
long long TES = 1000007;
long long INFF = 1000000000000000005LL;
double PI = acos(-1);
int dirx[8] = {-1, 0, 0, 1, -1, -1, 1, 1};
int diry[8] = {0, 1, -1, 0, -1, 1, -1, 1};
void solve() {
int n;
scanf("%d", &n);
if (n % 2 == 1) {
int t = n / 2;
cout << "\n" << t << "\n";
for (int(i) = (0); (i) < (t - 1); ++(i)) cout << "2 ";
cout << "3\n";
} else {
int t = n / 2;
cout << "\n" << t << "\n";
for (int(i) = (0); (i) < (t); ++(i)) cout << "2 ";
cout << "\n";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
cout << fixed;
cout << setprecision(9);
solve();
}
| 7 | CPP |
x, y = [int(_) for _ in input().split()]
print(x + y//2) | 0 | PYTHON3 |
import math
li=[]
x=0
y=0
for i in range(5):
a=input().split()
li.append(a)
for j in range(5):
for k in range(5):
if li[j][k]=="1":
j+=1
k+=1
if j>3:
x=j-3
elif j==3:
x=0
else:
x=math.fabs(j-3)
if k>3:
y=k-3
elif k==3:
y=0
else:
y=math.fabs(k-3)
break
print(int(x+y)) | 7 | PYTHON3 |
q = int(input())
for _ in range(q):
s = str(input())
m = int(input())
B = list(map(int, input().split()))
C = [0]*26
for c in s:
C[ord(c)-ord('a')] += 1
ans = [-1]*m
used = set()
for i in reversed(range(26)):
if C[i] != 0:
idx = []
for j, b in enumerate(B):
if j in used:
continue
if b == 0:
idx.append(j)
if len(idx) > C[i]:
continue
for j in idx:
ans[j] = i
used.add(j)
for k in range(m):
for j in idx:
B[k] -= abs(k-j)
#print(ans)
ans = [chr(i+ord('a')) for i in ans]
print(''.join(ans))
| 10 | PYTHON3 |
n=int(input())
ans=0
for i in range(n):
s=input()
if(s=='X++'):
ans+=1
elif(s=='++X'):
ans+=1
elif(s=='X--'):
ans-=1
elif(s=='--X'):
ans-=1
print(ans) | 7 | PYTHON3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.