solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
inline int F() {
register int aa, bb, ch;
while (ch = getchar(), (ch < '0' || ch > '9') && ch != '-')
;
ch == '-' ? aa = bb = 0 : (aa = ch - '0', bb = 1);
while (ch = getchar(), ch >= '0' && ch <= '9') aa = aa * 10 + ch - '0';
return bb ? aa : -aa;
}
const int mod = 100007;
const int Maxn = 100010;
int n;
namespace hash {
struct node {
int w, ai;
};
std::vector<node> v[Maxn];
int ha[40];
void init() {
ha[0] = 1;
for (int i = 1; i <= 30; ++i) ha[i] = ha[i - 1] << 1;
}
void ins(int x) {
int tmp = x % mod;
for (int i = 0; i < v[tmp].end() - v[tmp].begin(); ++i) {
if (v[tmp][i].ai == x) {
++v[tmp][i].w;
return;
}
}
node aa = (node){1, x};
v[tmp].push_back(aa);
}
int find(int x) {
int tmp = x % mod, ret = 0;
for (int i = 0; i < v[tmp].end() - v[tmp].begin(); ++i) {
if (v[tmp][i].ai == x) return v[tmp][i].w;
}
return 0;
}
} // namespace hash
using namespace hash;
int main() {
init();
n = F();
long long ans = 0;
for (int i = 1; i <= n; ++i) {
int tmp = F();
for (int j = 1; j < 31; ++j)
if (ha[j] >= tmp) {
ans += find(ha[j] - tmp);
}
ins(tmp);
}
cout << ans;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long s1 = 0, s2 = 0, n, i, m;
cin >> n >> m;
long long a[n + 1], b[m + 1];
for (i = 0; i < n; i++) {
scanf("%lld", &a[i]);
}
for (i = 0; i < m; i++) {
scanf("%lld", &b[i]);
}
sort(a, a + n);
sort(b, b + m);
reverse(b, b + m);
long long c = 0;
for (i = 0; i < min(n, m); i++) {
if (a[i] >= b[i]) {
break;
}
c++;
}
for (i = 0; i < c; i++) {
s1 += a[i];
s2 += b[i];
}
cout << s2 - s1 << endl;
}
| 10 | CPP |
import math;
n = int(input());
a = list(map(int,input().split()));
pos=0; neg=0; zer=0;
for i in a:
if (i>0): pos+=1;
elif (i<0): neg+=1;
else: zer+=1;
if (pos >= math.ceil(n/2)): print(1);
elif (neg >= math.ceil(n/2)): print(-1);
else: print(0);
| 7 | PYTHON3 |
n,k=map(int,input().split())
while(k>0):
c=str(n)
lastdi=int(c[len(c)-1])
if(lastdi>=k):
n-=k
k=0
else:
k-=(lastdi+1)
n//=10
print(n) | 7 | PYTHON3 |
t = int(input())
def swap(p):
b = p[0]
p[0]=p[1]
p[1]=b
return p
def calculate_delets(s, pat):
or_pat = pat.copy()
res = 0
for el in s:
if el==pat[0]:
pat = swap(pat)
else:
res+=1
if pat!=or_pat:
res+=1
return res
for i in range(t):
s = input()
l1 = "0123456789"
l2 = "0123456789"
m_del = len(s)
for k1 in l1:
for k2 in l2:
pat = [k1,k2]
m_del = min(calculate_delets(s, pat),m_del)
print(m_del)
| 9 | PYTHON3 |
from sys import stdin
def solve():
n, m = map(int, stdin.readline().split())
a = list(map(int, stdin.readline().split()))
ans = 0
b = sorted(map(list, zip(map(lambda x: x % m, a), range(n))))
j = 0
need = n // m
for i in range(m):
e = j
while e < len(b) and b[e][0] == i:
e += 1
if e - j >= need:
for t in range(j + need, e):
b.append(b[t])
j = e
else:
for _ in range(need - (e - j)):
w = b.pop()
ans += (i - w[0]) % m
a[w[1]] += (i - w[0]) % m
j = e
print(ans)
print(*a)
solve()
| 10 | PYTHON3 |
import io, os
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
from collections import deque
n, q = map(int, input().split())
l = deque(map(int, input().split()))
mx = max(l)
op = [(-1, -1)]
while l[0] != mx:
a = l.popleft()
b = l.popleft()
l.appendleft(max(a, b))
l.append(min(a, b))
op.append((a, b))
for i in range(q):
m = int(input())
if m <= len(op)-1:
print(op[m][0], op[m][1])
else:
print(mx, l[1+((m-len(op))%(n-1))]) | 7 | PYTHON3 |
t = int(input())
while(t):
l=int(input())
str = input().split('A')
if(str.index(max(str))):
print(len(max(str)))
else:
str.remove(max(str))
if (len(str)):
print(len(max(str)))
else :
print(0)
t=t-1
| 7 | PYTHON3 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
using namespace std;
typedef pair<int, int>P;
int main(){
for(int n, m;cin>>n>>m, n;){
vector<int>mn(n, 0), mx(n, 0);
for(int i=0;i<m;i++){
int s, k;
cin>>s>>k;
for(int j=0;j<k;j++){
int c;
cin>>c;
c--;
mx[c]+=s;
if(k==1)mn[c]+=s;
}
}
vector<P>vec;
for(int i=0;i<n;i++){
vec.push_back(P(mx[i], i));
}
sort(vec.begin(), vec.end());
reverse(vec.begin(), vec.end());
int ans = 0;
for(int i=0;i<n;i++){
for(int j=0;;j++){
if(vec[j].second==i)continue;
ans = max(ans, vec[j].first - mn[i]);
break;
}
}
cout<<ans+1<<endl;
}
return 0;
}
| 0 | CPP |
A, B, C, D = map(int, input().split())
print("Left" if (A + B > C + D) else "Right" if (A + B < C + D) else "Balanced")
| 0 | PYTHON3 |
n = int(input())
d = {}
for i in range(n):
d[i + 1] = []
#print(d)
for j in range(n):
left = (j * n) + 1
right = (j + 1) * n
if (j % 2) == 0:
for k in range(left, right + 1):
d[k - (j * n)].append(k)
else:
for k in range(left, right + 1):
d[n + 1 - (k - j *n )].append(k)
for key in d:
print(*d[key]) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void solve(std::istream& in, std::ostream& out) {
int n, m;
in >> n >> m;
vector<int> a;
int prev = -1, x;
map<int, vector<int> > all;
long long res = 0;
while (m-- > 0) {
in >> x;
if (prev != x) {
all[x].push_back(a.size());
if (prev > 0) res += abs(prev - x);
a.push_back(x);
prev = x;
}
}
m = a.size();
long long bestDiff = 0;
for (auto it = all.begin(); it != all.end(); ++it) {
x = it->first;
const vector<int>& idx = it->second;
auto cnt = [&](int y) {
long long res = 0;
for (int i : idx) {
if (i > 0) res += abs(y - a[i - 1]);
if (i < m - 1) res += abs(y - a[i + 1]);
}
return res;
};
long long best = cnt(x);
long long cur = res - best;
vector<int> neighbors;
for (int i : idx) {
if (i > 0) neighbors.push_back(a[i - 1]);
if (i < m - 1) neighbors.push_back(a[i + 1]);
}
if (!neighbors.empty()) {
std::nth_element(neighbors.begin(),
neighbors.begin() + neighbors.size() / 2,
neighbors.end());
x = neighbors[neighbors.size() / 2];
best = min(best, cnt(x));
}
cur += best;
bestDiff = min(bestDiff, cur - res);
}
out << (res + bestDiff) << endl;
}
void solve(std::istream& in, std::ostream& out);
int main() {
std::ios_base::sync_with_stdio(0);
std::cin.tie(0);
solve(std::cin, std::cout);
return 0;
}
| 7 | CPP |
n = int(input())
arr = list(map(int,input().split()))
arr.sort()
flag=0
if arr[0]==arr[-1]:
print(0,(n*(n-1))//2)
flag=1
if flag==0:
val = arr[0]
for i in range(n):
if arr[i]!=val:
break
maxn = i
val = arr[-1]
for i in range(n-1,-1,-1):
if arr[i]!=val:
break
minn = n-i-1
#print(minn,maxn)
print(arr[-1]-arr[0],minn*maxn)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int a, b, x, y;
int v[1005][1005];
void tp(int m, int n, int k) {
v[m][n] += k;
if (v[m][n] < 4) return;
v[m][n] -= 4;
tp(m, n, 0);
tp(m + 1, n, 1);
tp(m - 1, n, 1);
tp(m, n + 1, 1);
tp(m, n - 1, 1);
return;
}
int main() {
scanf("%d %d", &a, &b);
tp(500, 500, a);
for (int j = 0; j < b; j++) {
scanf("%d %d", &x, &y);
if (x > 500 || y > 500 || x < -500 || y < -500) {
printf("0\n");
continue;
}
printf("%d\n", v[x + 500][y + 500]);
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int st = 200;
int a[210];
double dp[210][210][410], p[210];
int main() {
int n, l, k, x;
double ans = 0;
scanf("%d%d%d", &n, &l, &k);
;
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
p[i] = x / 100.0;
}
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
const int end = st + 200;
dp[0][0][st + k] = 1;
for (int i = 1; i <= n; i++)
for (int j = 0; j < i; j++)
for (int k = 0; k <= end; k++) {
if (a[i] != -1) {
int x = min(end, k + a[i]);
dp[i][j + 1][x] += dp[i - 1][j][k] * p[i];
} else if (k > 0)
dp[i][j + 1][k - 1] += dp[i - 1][j][k] * p[i];
dp[i][j][k] += dp[i - 1][j][k] * (1 - p[i]);
}
for (int i = l; i <= n; i++)
for (int j = st; j <= end; j++) ans += dp[n][i][j];
printf("%.8lf\n", ans);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 70, INF = 2 * 1000 * 1000 * 1000;
int n, m, r, mat[MAXN][MAXN][MAXN], dis[MAXN][MAXN], d[MAXN][MAXN][MAXN];
void floyd(int car) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) dis[i][j] = mat[car][i][j];
for (int t = 1; t <= n; t++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
dis[i][j] = min(dis[i][j], dis[i][t] + dis[t][j]);
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m >> r;
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n; k++) cin >> mat[i][j][k];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) d[0][i][j] = INF;
for (int i = 1; i <= m; i++) {
floyd(i);
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n; k++) d[0][j][k] = min(d[0][j][k], dis[j][k]);
}
for (int k = 1; k < n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
d[k][i][j] = d[k - 1][i][j];
for (int temp = 1; temp <= n; temp++)
d[k][i][j] = min(d[k][i][j], d[k - 1][i][temp] + d[0][temp][j]);
}
for (int i = 1; i <= r; i++) {
int s, t, k;
cin >> s >> t >> k;
k = min(k, n - 1);
cout << d[k][s][t] << endl;
}
return 0;
}
| 8 | CPP |
s=input()
f=False
c=1
p=s[0]
for i in range(1,len(s)):
if p==s[i]:
c+=1
else:
p=s[i]
c=1
if c==7:
f=True
break
if f:
print("YES")
else:
print("NO") | 7 | PYTHON3 |
import sys
input = lambda: sys.stdin.readline().strip()
s = input()
num = {}
for i in range(10):
num[i] = 0
for i in range(len(s)-1):
num[(int(s[i+1])-int(s[i]))%10]+=1
for x in range(10):
for y in range(10):
d = {}
for i in range(10):
d[i] = sys.maxsize
for i in range(10):
for j in range(10):
if i==0 and j==0: continue
cur = (i*x+j*y)%10
d[cur] = min(d[cur], i+j)
ans = 0
for i in range(10):
if d[i]==sys.maxsize and num[i]>0: break
ans+=num[i]*(d[i]-1)
else: print(ans, end=' '); continue
print(-1, end=' ')
print()
| 8 | PYTHON3 |
def digitSum(x):
s = 0
while x != 0:
s += x % 10
x = (x//10)
return s
n = int(input())
x = n
b = 1
s = 0
while x != 0:
num1 = (x - 1)*b + (b-1)
num2 = n - num1
ans = digitSum(num1) + digitSum(num2)
if ans > s:
s = ans
x = (x//10)
b = b * 10
print(s) | 8 | PYTHON3 |
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <deque>
using namespace std;
#define SZ(a) (int)(a).size()
typedef long long ll;
int main() {
cin.sync_with_stdio(false);
int n, k;
cin >> n >> k;
string s;
cin >> s;
deque<bool> a(n);
for (auto i = 0; i < n; i++) {
a[i] = s[i] == 'B';
}
bool flip = false;
if (k > 2*n) {
k = 2*n+(k & 1);
}
for (auto i = 0; i < k; i++) {
if (a[0] == flip) {
a[0] = !a[0];
}
else {
a.pop_front();
a.push_back(!flip);
flip = !flip;
}
}
for (auto& x: a) {
printf("%c", x != flip ? 'B' : 'A');
}
puts("");
return 0;
}
| 0 | CPP |
t = int(input())
for i in range(t):
n = int(input())
a = 1
k = 8
dviz = 0
for i in range(1 , n//2+1):
dviz += i * (i*k)
print(dviz) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000;
struct in4 {
int a, t, x, i;
};
in4 a[N];
bool mf(in4 r, in4 k) {
if (r.t < k.t) return true;
if (r.t > k.t) return false;
if (r.a < k.a) return true;
if (r.a > k.a) return false;
return r.i < k.i;
}
map<int, int> mk;
int ans[N + 1];
set<int> cont;
int main() {
int n, m, q;
scanf("%d", &n);
int cnt = 0;
cont.insert(0);
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &a[i].a, &a[i].t, &a[i].x);
if (a[i].a == 3) {
set<int>::iterator pos = (cont.lower_bound(a[i].t));
if (pos != cont.begin()) pos--;
q = *(pos);
if (i > 0)
a[i].t = min(a[i].t, q);
else
a[i].t = 0;
a[i].i = cnt++;
}
cont.insert(a[i].t);
}
sort(a, a + n, mf);
int k = 0;
for (int i = 0; i < n; i++) {
if (a[i].a == 1) {
mk[a[i].x]++;
} else if (a[i].a == 2) {
mk[a[i].x] = max(mk[a[i].x] - 1, 0);
} else {
ans[a[i].i] = mk[a[i].x];
}
}
for (int i = 0; i < cnt; i++) {
printf("%d\n", ans[i]);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
class Rusk {
public:
int x;
int y;
int s;
Rusk(int x, int y, int s) {
this->x = x;
this->y = y;
this->s = s;
}
};
int main() {
int n, m;
cin >> n >> m;
char a[n][m];
vector<Rusk> v;
int i, j, k, p;
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) cin >> a[i][j];
char c[n][m];
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) c[i][j] = '.';
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (a[i][j] == '*') {
for (k = 1; k <= n - i; k++) {
if (i - k < 0 || i + k >= n || j - k < 0 || j + k >= m) break;
if (a[i - k][j] != '*' || a[i + k][j] != '*' || a[i][j - k] != '*' ||
a[i][j + k] != '*')
break;
}
k--;
if (k > 0) {
v.push_back(Rusk(i + 1, j + 1, k));
for (p = 0; p <= k; p++) {
c[i - p][j] = '*';
c[i + p][j] = '*';
c[i][j - p] = '*';
c[i][j + p] = '*';
}
}
}
}
}
bool flag = true;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (a[i][j] == '*' && c[i][j] != '*') {
flag = false;
break;
}
}
if (!flag) break;
}
if (!flag)
cout << -1 << endl;
else {
int n = v.size();
cout << n << endl;
for (i = 0; i < n; i++)
cout << v[i].x << " " << v[i].y << " " << v[i].s << endl;
}
}
| 11 | CPP |
n,m=map(int,input().split())
a=[]
for i in range(0,n):
c=list(input())
a.append(c)
for i in range(n-1,-1,-1):
if a[i].count('*')>0:
a2=i
break
a.append(c)
for i in range(0,n):
if a[i].count('*')>0:
a1=i
break
A=a2-a1+1
ee=m-1
ee1=0
for i in range(a1,a2+1):
for ii in range(0,m):
if a[i][ii]=='*':
e=ii
ee=min(e,ee)
for i in range(a2,a1-1,-1):
for ii in range(0,m):
if a[i][ii]=='*':
e1=ii
ee1=max(e1,ee1)
B=ee1-ee+1
BB=[]
for i in range(a1,a2+1):
for k in range(ee,ee1+1):
BB.append(a[i][k])
BBB=''.join(BB)
print(BBB)
BB=[]
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> ma;
bool used[2005][2005];
int num = 1;
struct S {
int x, y, d;
} s[1005];
string name[2005];
int main() {
int N, D;
int i, j, k;
int res = 0;
cin >> N >> D;
string s1, s2, d;
for (i = 0; i < N; i++) {
cin >> s1 >> s2 >> s[i].d;
int t1 = ma[s1], t2 = ma[s2];
if (t1 == 0) {
ma[s1] = t1 = num;
name[num++] = s1;
}
if (t2 == 0) {
ma[s2] = t2 = num;
name[num++] = s2;
}
s[i].x = t1, s[i].y = t2;
if (used[t1][t2]) continue;
for (j = i - 1; j >= 0; j--) {
if (s[i].d - s[j].d > D)
break;
else if (s[i].d == s[j].d)
continue;
else if (s[j].x == s[i].y && s[j].y == s[i].x) {
res++;
used[t1][t2] = used[t2][t1] = 1;
break;
}
}
}
cout << res << endl;
for (i = 1; i < num; i++) {
for (j = i + 1; j < num; j++) {
if (used[i][j]) {
cout << name[i] << " " << name[j] << endl;
}
}
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
struct Flight {
int d, f, t, c;
bool operator<(const Flight &ot) const { return d < ot.d; }
} v[1000002];
int costJ[100002];
long long cost[1000002];
int firstV;
long long ans;
void getJury() {
cost[0] = 1LL * 1000000002 * n;
for (int i = 1; i <= n; ++i) costJ[i] = 1000000002;
int d = 1, cnt = n;
firstV = v[m].d + 1;
for (int i = 1; i <= m; ++i) {
int prv = costJ[v[i].t];
while (d <= v[i].d) {
cost[d] = cost[d - 1];
++d;
}
if (v[i].t) {
costJ[v[i].t] = min(costJ[v[i].t], v[i].c);
if (prv == 1000000002 && costJ[v[i].t] != 1000000002) {
--cnt;
if (!cnt) firstV = v[i].d;
}
}
if (v[i].t) cost[v[i].d] = cost[v[i].d] - prv + costJ[v[i].t];
}
for (int i = 2; i <= v[i].d; ++i) cost[i] = min(cost[i], cost[i - 1]);
}
void exitJury() {
ans = 1LL * n * 1000000002;
for (int i = 1; i <= n; ++i) costJ[i] = 1000000002;
long long sum = 1LL * 1000000002 * n;
int cnt = n;
for (int i = m; i >= 1; --i) {
int prv = costJ[v[i].f];
if (v[i].f) {
costJ[v[i].f] = min(costJ[v[i].f], v[i].c);
sum = sum + 1LL * costJ[v[i].f] - 1LL * prv;
if (prv == 1000000002 && costJ[v[i].f] != 1000000002) --cnt;
}
if (v[i].d <= k) return;
if (cnt == 0 && firstV <= (v[i].d - k - 1))
ans = min(ans, sum + cost[v[i].d - k - 1]);
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; ++i)
scanf("%d%d%d%d", &v[i].d, &v[i].t, &v[i].f, &v[i].c);
sort(v + 1, v + m + 1);
getJury();
exitJury();
if (ans >= 1LL * 1000000002 * n)
printf("-1");
else
printf("%lld\n", ans);
return 0;
}
| 10 | CPP |
def fun(k):
return 2 * k - bin(k).count('1')
t = int(input())
for _ in range(t):
n = int(input())
print(fun(n)) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[12];
cin >> n;
int i, sum = 0;
for (i = 0; i < 12; ++i) cin >> a[i];
if (n == 0)
cout << "0";
else {
sort(a, a + 12);
for (i = 11; i >= 0; i--) {
sum += a[i];
if (sum >= n) {
cout << 12 - i;
break;
}
}
if (sum < n) cout << "-1";
}
}
| 7 | CPP |
for _ in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
a.sort()
ans=[]
for i in range(n//2):
ans.append(a[i])
ans.append(a[n-1-i])
if n%2==1:
ans.append(a[n//2])
print(" ".join(map(str,ans[::-1]))) | 8 | PYTHON3 |
n = int(input())
dat = list(map(int,input().split()))
orig1 = [0] * 150010
orig2 = [0] * 150020
for i in range(n):
orig1[dat[i]] += 1
#print(orig1[0:10])
for i in range(1, 150001):
if i != 1 and orig2[i-1] == 0 and orig1[i] != 0:
orig1[i] -= 1
orig2[i-1] += 1
if orig2[i] == 0 and orig1[i] != 0:
orig1[i] -= 1
orig2[i] += 1
if orig2[i + 1] == 0 and orig1[i] != 0:
orig1[i] -= 1
orig2[i+1] += 1
#print(orig1[0:10])
#print(orig2[0:10])
res = 0
for i in range(1, 150010):
if orig2[i] != 0:
res +=1
print(res) | 11 | PYTHON3 |
#include <iostream>
#include <vector>
#include <array>
#include <list>
#include <string>
#include <stack>
#include <queue>
#include <deque>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <tuple>
#include <bitset>
#include <memory>
#include <cmath>
#include <algorithm>
#include <functional>
#include <iomanip>
#include <numeric>
#include <climits>
#include <cfloat>
#include <cassert>
#include <random>
int min_count(std::vector<int> blocks) {
const auto sum = std::accumulate(blocks.begin(), blocks.end(), 0);
const auto sqrt = static_cast<int>(std::sqrt(sum * 2));
if (sqrt * (sqrt + 1) / 2 != sum) return -1;
for (auto times = 0; times <= 10000; ++times) {
if (blocks.size() == sqrt) {
bool is_triangle = true;
for (auto i = 0; i < blocks.size(); ++i) {
if (blocks[i] != i + 1) {
is_triangle = false;
break;
}
}
if (is_triangle) return times;
}
const auto size = blocks.size();
for (auto& b : blocks) --b;
blocks.erase(std::remove(blocks.begin(), blocks.end(), 0), blocks.end());
blocks.push_back(size);
}
return -1;
}
int main() {
while (true) {
int n; std::cin >> n; if (n == 0) break;
std::vector<int> blocks(n); for (auto& b : blocks) std::cin >> b;
std::cout << min_count(blocks) << '\n';
}
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
string a;
int main(){
cin>>a;
if(a == "ABC") printf("ARC");
else printf("ABC");
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long a[5010];
int dp[5010];
bool func(long long x, long long y, int step, int ord) {
long long z;
if (step <= ord) {
z = (x >> step);
return (y % (2 * z) == z);
}
z = (x >> ord);
return (y % z == 0);
}
int main(void) {
int N, i, j;
cin >> N;
for ((i) = 0; (i) < (int)(N); (i)++) cin >> a[i];
for ((i) = 0; (i) < (int)(N); (i)++) {
dp[i] = 1;
long long tmp = a[i];
int ord = 0;
while (tmp % 2 == 0) {
tmp /= 2;
ord++;
}
for ((j) = 0; (j) < (int)(i); (j)++)
if (func(a[i], a[j], i - j, ord)) dp[i] = max(dp[i], dp[j] + 1);
}
int ans = 0;
for ((i) = 0; (i) < (int)(N); (i)++) ans = max(ans, dp[i]);
ans = N - ans;
cout << ans << endl;
return 0;
}
| 10 | CPP |
n, m, k = map(int, input().split())
span = n+m+1
count = (span+1)*[0]
count[span] = k
key = (span+1)*[False]
key[1] = True
hire = []
day = 1
while True:
while day <= span and count[day] >= k:
day += 1
if day > span:
if key[span]:
break
day -= 1
while not key[day]:
day -= 1
hire.append(day)
last = min(span, day+n-1)
for i in range(day, last+1):
count[i] += 1
key[i] = True
print(len(hire))
print(' '.join([str(x) for x in hire]))
| 9 | PYTHON3 |
#include<bits/stdc++.h>
#define int long long
#define P pair<int,int>//cost to
using namespace std;
map<int, int>S;
int mincost[200000];
vector<P>rinsetu[200000];
signed main() {
int sum = 0;
int a, b, c; cin >> a >> b >> c;
for (int d = 0; d < b; d++) {
int e, f, g; scanf("%lld%lld%lld", &e, &f, &g);
sum += g;
e--; f--;
rinsetu[e].push_back(P(g, f));
rinsetu[f].push_back(P(g, e));
}
priority_queue<P, vector<P>, greater<P>>Q;
Q.push(P(0, 0));
fill(mincost, mincost + a, LLONG_MAX/3);
mincost[0] = 0;
while (Q.size()) {
P o = Q.top(); Q.pop();
if (o.first > mincost[o.second])continue;
for (P t : rinsetu[o.second]) {
if (mincost[t.second] > o.first + t.first) {
mincost[t.second] = o.first + t.first;
Q.push(P(mincost[t.second], t.second));
}
}
}
for (int i = 0; i < b; i++) {
for (P j : rinsetu[i]) {
if (i < j.second)S[max(mincost[i],mincost[j.second])] += j.first;
}
}
int MIN = sum;
for (auto t = S.begin(),p=++(S.begin()); p != S.end(); t++,p++) {
(*p).second += (*t).second;
}
for (auto i = S.begin(); i != S.end(); i++) {
MIN = min(MIN, (*i).first*c + sum - (*i).second);
}
cout << MIN << endl;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 9;
int n, l, r, l1, r1, p1, p2, g1, g2, mid, a[N], b[N], a1, a2;
long long ans;
int query1(int l, int r) {
int res = -1e9;
r++;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) res = max(res, a[l++]);
;
if (r & 1) res = max(res, a[--r]);
;
}
return res;
}
int query2(int l, int r) {
int res = 1e9;
r++;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) res = min(res, b[l++]);
;
if (r & 1) res = min(res, b[--r]);
;
}
return res;
}
void find_l1_r1(int x, int y) {
l = -1, r = x;
while (l + 1 < r) {
mid = (l + r) / 2;
if (query1(mid, x - 1) <= y)
r = mid;
else
l = mid;
}
l1 = r;
y++;
l = x, r = n;
while (l + 1 < r) {
mid = (l + r) / 2;
if (query1(x, mid) <= y)
l = mid;
else
r = mid;
}
r1 = l;
}
void find_p1_p2_g1_g2(int x, int y) {
l = -1, r = x;
while (l + 1 < r) {
mid = (l + r) / 2;
if (query2(mid, x) >= y)
r = mid;
else
l = mid;
}
p1 = r;
l = x - 1, r = n;
while (l + 1 < r) {
mid = (l + r) / 2;
if (query2(x, mid) >= y)
l = mid;
else
r = mid;
}
p2 = l, y--;
l = -1, r = x;
while (l + 1 < r) {
mid = (l + r) / 2;
if (query2(mid, x) >= y)
r = mid;
else
l = mid;
}
g1 = r;
l = x, r = n;
while (l + 1 < r) {
mid = (l + r) / 2;
if (query2(x, mid) >= y)
l = mid;
else
r = mid;
}
g2 = l;
}
void build() {
for (long long i = n - 1; i >= 0; i--)
a[i] = max(a[i * 2], a[i * 2 + 1]), b[i] = min(b[i * 2], b[i * 2 + 1]);
}
int main() {
cin >> n;
for (long long i = n; i < n * 2; i++) scanf("%d", &a[i]);
;
for (long long i = n; i < n * 2; i++) scanf("%d", &b[i]);
;
build();
for (long long i = 0; i < n; i++) {
if (b[i + n] >= a[i + n]) {
find_l1_r1(i, a[i + n] - 1);
find_p1_p2_g1_g2(i, a[i + n] + 1);
ans += (1ll * (i - max(g1, l1) + 1) * (min(r1, g2) - i + 1)) -
(1ll * (i - max(p1, l1) + 1) * (min(r1, p2) - i + 1));
}
}
cout << ans;
}
| 10 | CPP |
# -*- coding: utf-8 -*-
"""
Searching Constellation
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0524
"""
import sys
def solve(targets, stars):
for tx, ty in targets:
for sx, sy in stars:
dx, dy = sx-tx, sy-ty
s_starts = set(stars)
for x, y in targets:
px, py = x+dx, y+dy
if (px, py) in s_starts:
s_starts.remove((px, py))
else:
break
else:
return dx, dy
def main(args):
while True:
m = int(input())
if m == 0:
break
targets = [tuple(int(x) for x in input().split()) for _ in range(m)]
n = int(input())
stars = [tuple(int(x) for x in input().split()) for _ in range(n)]
ans = solve(targets, stars)
print(*ans)
if __name__ == '__main__':
main(sys.argv[1:])
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long f[25][5][5][25][25], n, t, ans;
int main() {
scanf("%lld%lld", &n, &t);
for (int i = 1; i <= 4; i++)
for (int j = 1; j <= 4; j++)
if (i != j) f[2][i][j][0][0] = 1;
for (int i = 2; i <= n; i++) {
for (int j = 0; j <= t; j++) {
for (int k = 0; k <= t - 1; k++) {
for (int a = 1; a <= 4; a++)
for (int b = 1; b <= 4; b++)
for (int c = 1; c <= 4; c++) {
if (a < b && b > c) f[i + 1][c][b][j + 1][k] += f[i][b][a][j][k];
if (a < b && b < c) f[i + 1][c][b][j][k] += f[i][b][a][j][k];
if (a > b && b > c) f[i + 1][c][b][j][k] += f[i][b][a][j][k];
if (a > b && b < c) f[i + 1][c][b][j][k + 1] += f[i][b][a][j][k];
}
}
}
}
for (int i = 1; i <= 4; i++)
for (int j = 1; j <= 4; j++)
if (i != j) ans += f[n][i][j][t][t - 1];
printf("%lld", ans);
}
| 11 | CPP |
n=int(input())
for i in range(n):
A,k=[int(x) for x in input().split()]
det=(A+k)/2
out=0
if k>A:
out=k-A
elif det-int(det)!=0:
out=1
print(out)
| 7 | PYTHON3 |
n,d=map(int,input().split())
count=0
for i in range(n):
a,b=map(int,input().split())
if a*a+b*b<=d*d:
count+=1
print(count) | 0 | PYTHON3 |
from __future__ import print_function
q=int(input())
while q > 0:
q-=1
lst=input()
#taking intgers as input
#a,b,n,s
#print("yes")
arr=list(map(int,lst.split()))
s=arr[3]
if arr[0]*arr[2] > s:
if s%arr[2] <= arr[1]:
print("YES")
else:
print("NO")
else :
if arr[0]*arr[2]+arr[1] < s:
print("NO")
else:
print("YES")
| 7 | PYTHON3 |
n = int(input())
pairs = ''.join(input().split())
pairs = pairs.strip('0')
if len(pairs) == 0:
print('0')
exit()
ans = int(pairs[0] == '1')
if len(pairs) > 1:
ans += int(pairs[-1] == '1')
for i in range(1, len(pairs)-1):
if pairs[i] == '1':
ans += 1
elif pairs[i-1] == '1' and pairs[i] == '0' and pairs[i+1] == '1':
ans += 1
print(ans)
| 7 | PYTHON3 |
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
#define rep(i,n) for(ll i=0;i<(ll)(n);i++)
#define all(a) (a).begin(),(a).end()
#define pb emplace_back
#define INF (1e9+1)
//#define INF (1LL<<59)
int main(){
int n;
cin>>n;
vector<string> vs(n);
rep(i,n)cin>>vs[i];
string t;
cin>>t;
int A=0, B=0, C=0;
const auto f = [](string a,string b){
int l = min(a.size(),b.size());
rep(i,l){
if(a[i]!='?'){
if(a[i]<b[i])return 1;
if(a[i]>b[i])return -1;
}else{
if(b[i]!='a' && b[i]!='z')return 0;
}
}
if(b.size()>a.size())return 1;
if(b.size()<a.size())return -1;
return 0;
};
assert(f("a","b")==1);
rep(i,vs.size()){
int res = f(vs[i],t);
if(res==0)C++;
else if(res==1)A++;
else if(res==-1)B++;
}
// cout<<A<<" "<<B<<" "<<C<<endl;
for(int i=A+1;i<=A+C+1;i++){
if(i!=A+1)cout<<" ";
cout<<i;
}
cout<<endl;
} | 0 | CPP |
k, n, w = map(int, input().split())
print(max(0, sum(range(1, w + 1)) * k - n)) | 7 | PYTHON3 |
A, B = map(int, input().split())
print(0 if (A<=5) else (B//2 if (A<=12) else B))
| 0 | PYTHON3 |
a=list(map(int,input().split()))
a.sort()
t1=a[0]+a[3]
t2=a[0]+a[1]+a[2]
y1=a[1]+a[2]
if t1==y1 or t2==a[3]:
print('YES')
else:
print('NO')
| 7 | PYTHON3 |
from math import floor,ceil
m,n = list(map(int,input().split()))
if m % 2 == 0:
print(int(m*n/2))
else:
print(floor(m/2)*n+floor(n/2)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int seg[2400005];
int lz[2400005];
void push(int ver) {
lz[2 * ver] = lz[ver];
lz[2 * ver + 1] = lz[ver];
seg[2 * ver] = lz[ver];
seg[2 * ver + 1] = lz[ver];
lz[ver] = 0;
}
void upd(int ver, int tl, int tr, int l, int r, int val) {
if (tl > tr || l > r || tr < l || r < tl)
return;
else if (tl == l && tr == r) {
lz[ver] = val;
seg[ver] = val;
} else {
int tm = (tl + tr) / 2;
if (lz[ver]) push(ver);
upd(2 * ver, tl, tm, l, min(tm, r), val);
upd(2 * ver + 1, tm + 1, tr, max(tm + 1, l), r, val);
seg[ver] = max(seg[2 * ver], seg[2 * ver + 1]);
}
}
int get(int ver, int tl, int tr, int l, int r) {
if (tl > tr || l > r || tr < l || r < tl)
return 0;
else if (tl == l && tr == r)
return seg[ver];
else {
int tm = (tl + tr) / 2;
if (lz[ver]) {
push(ver);
seg[ver] = max(seg[2 * ver], seg[2 * ver + 1]);
}
return max(get(2 * ver, tl, tm, l, min(tm, r)),
get(2 * ver + 1, tm + 1, tr, max(tm + 1, l), r));
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
stack<int> s;
int x;
string str;
int n;
cin >> n;
int mx = 0;
int cnt = 1;
int ans = 0;
int pos[n + 1];
for (int i = 1; i <= 2 * n; i++) {
cin >> str;
if (str == "add") {
cin >> x;
pos[x] = i;
s.push(x);
upd(1, 1, 2 * n, i, i, x);
} else {
int z = get(1, 1, 2 * n, pos[cnt], 2 * n);
if (z > cnt) {
ans++;
upd(1, 1, 2 * n, 1, i, -1);
}
cnt++;
}
}
cout << ans;
}
| 9 | CPP |
#include <iostream>
#define LL long long
using namespace std;
LL N,a[100010],b[100010];
int main(){
cin >> N;
LL i; LL cr=0;
for (i=1; i<=N; i++)
cin >> a[i] >> b[i];
for (i=N; i>0; i--){
a[i]+=cr;
cr+=b[i]*((a[i]+b[i]-1)/b[i])-a[i];
}
cout << cr << "\n";
return 0;
}
| 0 | CPP |
it = input()
it = it.split()
n = int(it[0])
m = int(it[1])
p = [[] for _ in range(n)]
for _ in range(m):
itf = input()
itf = itf.split()
a = int(itf[0])
b = int(itf[1])
p[a-1].append(b)
p[b-1].append(a)
d = [1, ]
con = [0] * n
while d:
l = d.pop(0)
for k in p[l-1]:
if con[k-2]==0:
d.append(k)
con[k-2] = l
print('Yes')
for i in range(n-1):
print(con[i]) | 0 | PYTHON3 |
def isVowel( a ):
return ( a == 'A' or a == 'a' or a == 'O' or a == 'o' or a == 'Y' or a == 'y' or a == 'E' or a == 'e' or a == 'U' or a == 'u' or a == 'I' or a == 'i' )
def main():
s = input()
t = ""
for i in range( 0, len(s) ):
if isVowel(s[i]) == 0:
t += '.' + s[i].lower()
return t
print(main()) | 7 | PYTHON3 |
n = int(input())
d = [int(k) for k in input().split(' ') if k]
m = d[0]
count = 1
index = 0
for i in range(1, len(d)):
if d[i] < m:
count = 1
index = i
m = d[i]
elif d[i] == m:
count += 1
if count >= 2:
print("Still Rozdil")
else:
print(index + 1)
| 7 | PYTHON3 |
n , k = [int(i) for i in input().split()]
v = 0
a = [int(j) for j in input().split()]
for j in range (n):
if a[j] >= a[k - 1] and a[j] > 0:
v = v + 1
print (v)
| 7 | PYTHON3 |
words = []
for i in range(0,26):
words.insert(len(words), chr(ord('a')+i))
n = int(input())
inp = input().lower();
yes = True
for w in words:
if inp.find(w) < 0: yes = False
if yes == True:
print('YES')
else:
print('NO') | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d, i = 0, high = 0, cnt = 0;
cin >> n >> d;
string s;
int a[d];
memset(a, 0, sizeof(a));
while (i < d) {
bool beat = false;
cin >> s;
for (int i = 0; i < n; i++) {
if (s[i] == '0') {
beat = true;
break;
}
}
if (beat) a[i] = 1;
i++;
}
for (i = 0; i < d; i++) {
if (a[i] == 1) cnt++;
if (a[i] == 0) {
if (cnt > high) {
high = cnt;
cnt = 0;
} else
cnt = 0;
}
}
if (high < cnt) high = cnt;
cout << high << '\n';
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int dp[1010];
char s[1010];
int k[30];
int l[1010];
int main() {
int n, mii = -100000;
s[0] = 'z' + 1;
scanf("%d%s", &n, s + 1);
for (int i = 0; i < 26; ++i) scanf("%d", &k[i]);
dp[0] = 1;
k[26] = 2333333;
for (int i = 1; i <= n; ++i) {
int mi = min(k[s[i] - 'a'], i), j;
l[i] = 2333333;
for (j = 1; j <= mi; ++j) {
mi = min(mi, k[s[i - j + 1] - 'a']);
if (k[s[i - j + 1] - 'a'] >= j) {
dp[i] = (dp[i] + dp[i - j]) % mod;
l[i] = min(l[i], l[i - j] + 1);
} else
break;
}
if (mii < j) {
mii = j;
}
}
printf("%d\n%d\n%d", dp[n], mii - 1, l[n]);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return x * f;
}
int n;
struct Point {
long long x, y;
Point(long long _x = 0, long long _y = 0) { x = _x, y = _y; }
friend Point operator-(const Point &a, const Point &b) {
return Point(a.x - b.x, a.y - b.y);
}
friend Point operator+(const Point &a, const Point &b) {
return Point(a.x + b.x, a.y + b.y);
}
friend long long operator%(const Point &a, const Point &b) {
return a.x * b.y - a.y * b.x;
}
friend bool operator<(const Point &a, const Point &b) {
return a.x == b.x ? a.y < b.y : a.x < b.x;
}
inline long long len() { return x * x + y * y; }
void Output() { printf("%lld %lld\n", x, y); }
} LTL;
vector<Point> p;
inline bool Left(Point a, Point b) { return b % a > 0; }
inline bool Para(Point a, Point b) { return a % b == 0; }
array<Point, 3> ans;
long long mx;
inline long long Abs(long long x) { return x >= 0 ? x : -x; }
inline long long Area(Point a, Point b, Point c) {
return Abs((b - a) % (c - a));
}
vector<Point> Convex(vector<Point> A) {
vector<Point> B;
for (auto p : A) {
while (B.size() > 1 &&
!Left(p - B[B.size() - 2], B.back() - B[B.size() - 2]))
B.pop_back();
B.push_back(p);
}
return B;
}
int main() {
n = read();
read();
p.resize(n);
for (int i = 0; i < n; ++i) {
p[i].x = read(), p[i].y = read();
}
LTL = *min_element(p.begin(), p.end());
sort(p.begin(), p.end(), [&](Point a, Point b) {
a = a - LTL, b = b - LTL;
return Para(a, b) ? a.len() < b.len() : !Left(a, b);
});
p = Convex(p);
n = p.size();
mx = -1;
for (int i = 0; i < n; ++i) {
for (int j = (i + 1) % n, k = (j + 1) % n; j != i; j = (j + 1) % n) {
while (Area(p[i], p[j], p[(k + 1) % n]) > Area(p[i], p[j], p[k]))
k = (k + 1) % n;
long long S = Area(p[i], p[j], p[k]);
if (S > mx) {
mx = S;
ans = {p[i], p[j], p[k]};
}
}
}
for (int i = 0; i < 3; ++i) {
(ans[i] + ans[(i + 1) % 3] - ans[(i + 2) % 3]).Output();
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
const int maxn = 5e5 + 5;
using namespace std;
int arr[maxn];
int dfs(int l, int r) {
if (l > r)
return 0;
else if (l == r)
return (arr[l] != 0);
else {
int mn = 1e9 + 7, pos;
for (int i = l; i <= r; i++) {
if (arr[i] < mn) {
mn = arr[i];
pos = i;
}
}
for (int i = l; i <= r; i++) {
arr[i] -= mn;
}
return min(r - l + 1, dfs(l, pos - 1) + dfs(pos + 1, r) + mn);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
cout << dfs(1, n) << "\n";
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 110;
int v[maxn];
char s[maxn];
int a[maxn], b[maxn];
int main() {
int n;
cin >> n;
cin >> s;
for (int i = 0; i < n; i++) {
v[i] = s[i] - '0';
}
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
int ans = 0;
for (int i = 0; i < n; i++) {
ans += v[i];
}
for (int tm = 1; tm < 100000; tm++) {
int cnt = 0;
for (int i = 0; i < n; i++) {
if (tm >= b[i] && (tm - b[i]) % a[i] == 0) {
v[i] ^= 1;
}
if (v[i] == 1) {
cnt++;
}
}
ans = max(ans, cnt);
}
cout << ans << endl;
}
| 8 | CPP |
n = int(input())
print(int((n-1)/2)) | 9 | PYTHON3 |
b=list(input())
a=list(input())
b1=b.count("+");
b2=b.count("-");
a1=a.count("+")
a2=a.count("-")
a3=a.count("?")
x1=(b1-a1);
x2=(b2-a2);
if (x1<0 or x2 <0):
print("0.000000000000")
elif(a3==0):
print("1.000000000000")
else:
tot=1<<a3;
x=1;
for i in range(2,a3+1,1):
x=x*i;
y=1;
for i in range(1,(b1-a1)+1,1):
y=y*i;
z=1;
for i in range(1,(b2-a2)+1,1):
z=z*i;
#print(x,y,z)
x=x/(z*y);
print(x/((tot)))
#print(x)
| 8 | PYTHON3 |
if __name__ == "__main__":
s, v1, v2, t1, t2 = map(int, input().split())
ping1 = 2* t1 +s * v1
ping2 = 2* t2 + s* v2
difference = ping1 - ping2
if difference == 0:
print("Friendship")
elif difference > 0:
print("Second")
elif difference < 0:
print("First") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const double EPS = 1e-9;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k, length, A[64] = {};
string s;
char before;
cin >> n >> k >> s;
length = 0;
for (int i = 0; i < n; i++) {
if (!i) {
before = s[i];
length = 1;
} else {
if (s[i] == before)
length++;
else {
before = s[i];
length = 1;
}
}
if (length == k) {
A[before - 'a']++;
length = 0;
}
}
length = 0;
for (int i = 0; i < 64; i++) length = max(length, A[i]);
cout << length << '\n';
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct par {
int in, out, w, s, v;
bool operator<(const par &l) const { return out < l.out; }
} D[505];
int T[505][1005];
int tmp[505][1005];
int ed[1005];
bool chk[505];
vector<int> G[505];
int N, S;
void DFS(int x) {
chk[x] = true;
for (int i = 0; i < G[x].size(); i++) {
if (chk[G[x][i]]) continue;
DFS(G[x][i]);
}
for (int i = 0; i < G[x].size(); i++) {
for (int j = 0; j <= S; j++) {
tmp[i][j] = 0;
}
}
for (int i = 0; i < G[x].size(); i++) {
int wi = G[x][i], en;
for (en = i - 1; en >= 0; en--) {
if (D[wi].in >= D[G[x][en]].out) break;
}
if (i != 0) {
for (int j = 0; j <= S; j++) {
tmp[i][j] = tmp[i - 1][j];
}
}
for (int j = 0; j <= S; j++) {
if (en != -1)
tmp[i][j] = max(tmp[i][j], tmp[en][j] + T[wi][j]);
else
tmp[i][j] = max(tmp[i][j], T[wi][j]);
}
for (int j = 1; j <= S; j++) tmp[i][j] = max(tmp[i][j - 1], tmp[i][j]);
}
int M = G[x].size();
if (M == 0) {
for (int j = D[x].w; j <= S; j++) T[x][j] = D[x].v;
} else {
for (int i = 0; i <= S; i++) T[x][i] = tmp[M - 1][i];
for (int j = 0; j <= S - D[x].w; j++) {
if (j > D[x].s) break;
T[x][j + D[x].w] = max(D[x].v + tmp[M - 1][j], T[x][j + D[x].w]);
}
for (int j = 1; j <= S; j++) T[x][j] = max(T[x][j - 1], T[x][j]);
}
}
int main() {
scanf("%d%d", &N, &S);
for (int i = 1; i <= N; i++) {
scanf("%d%d%d%d%d", &D[i].in, &D[i].out, &D[i].w, &D[i].s, &D[i].v);
}
N++;
D[N].in = -1, D[N].out = 2 * N + 5, D[N].w = 0, D[N].v = 0, D[N].s = S;
sort(D + 1, D + N + 1);
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) {
if (i == j) continue;
if (D[i].in <= D[j].in && D[j].out <= D[i].out) G[i].push_back(j);
}
}
for (int i = 1; i <= N; i++) {
if (chk[i]) continue;
DFS(i);
}
printf("%d", T[N][S]);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long mod = 1e9 + 7;
const int N = 300005;
char s[N];
int pre[N];
vector<int> pooo[N * 4];
vector<int> *b = pooo + 600000;
int main() {
int _;
scanf("%d", &_);
while (_--) {
int n, q;
scanf("%d%d%s", &n, &q, s + 1);
for (int i = 1; i <= n; i++) {
int x = s[i] == '+' ? 1 : -1;
if (i % 2 == 0) x = -x;
pre[i] = pre[i - 1] + x;
b[pre[i] + pre[i - 1]].push_back(i);
}
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
if (pre[y] - pre[x - 1] == 0) {
puts("0");
continue;
}
int t = pre[y] + pre[x - 1];
int k = lower_bound(b[t].begin(), b[t].end(), x) - b[t].begin();
if (k < b[t].size() && b[t][k] <= y) {
puts("1");
printf("%d\n", b[t][k]);
continue;
}
puts("2");
for (int i = x; i <= y; i++) {
int t = pre[y] - pre[x - 1] + pre[i] + pre[i - 1];
int k = lower_bound(b[t].begin(), b[t].end(), x) - b[t].begin();
if (k < b[t].size() && b[t][k] <= y) {
printf("%d %d\n", i, b[t][k]);
break;
}
}
}
for (int i = 1; i <= n; i++) {
b[pre[i] + pre[i - 1]].clear();
}
}
return 0;
}
| 10 | CPP |
"""
#If FastIO not needed, use this and don't forget to strip
#import sys, math
#input = sys.stdin.readline
"""
import os
import sys
from io import BytesIO, IOBase
import heapq as h
from bisect import bisect_left, bisect_right
import time
from types import GeneratorType
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
self.os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
from collections import defaultdict as dd, deque as dq, Counter as dc
import math, string
#start_time = time.time()
def getInts():
return [int(s) for s in input().split()]
def getInt():
return int(input())
def getStrs():
return [s for s in input().split()]
def getStr():
return input()
def listStr():
return list(input())
def getMat(n):
return [getInts() for _ in range(n)]
def isInt(s):
return '0' <= s[0] <= '9'
MOD = 10**9 + 7
"""
"""
def solve():
N, K = getInts()
if N == K: return 1
if N < K: return K//N + (K%N > 0)
if N % K == 0: return 1
return 2
for _ in range(getInt()):
print(solve())
#solve()
#print(time.time()-start_time) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 7;
const int lim = 1000;
const int MOD = 1e9 + 7;
const double eps = 1e-6;
vector<int> vv;
long long fac[N], inv[N];
long long ksm(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) ret = ret * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return ret;
}
void init() {
fac[0] = fac[1] = 1;
for (long long i = 1; i <= lim; i++) fac[i] = fac[i - 1] * i % MOD;
inv[lim] = ksm(fac[lim], MOD - 2);
for (long long i = lim; i >= 1; i--) inv[i - 1] = inv[i] * i % MOD;
}
long long C(int n, int m) {
if (m > n) return 0;
return fac[n] * inv[m] % MOD * inv[n - m] % MOD;
}
int a[N];
int n, pos, x;
int main() {
init();
scanf("%d%d%d", &n, &x, &pos);
for (int i = 0; i < n; i++) a[i] = i;
int l = 0, r = n;
int aa = 0, bb = 0;
while (l < r) {
int mid = (l + r) / 2;
if (a[mid] <= pos) {
l = mid + 1;
if (a[mid] != pos) aa++;
} else
r = mid, bb++;
}
int al = x - 1, ar = n - x;
long long ans = C(al, aa) * C(ar, bb) % MOD * fac[aa] % MOD * fac[bb] % MOD *
fac[n - aa - bb - 1] % MOD;
printf("%lld\n", ans);
return 0;
}
| 9 | CPP |
r=input()
s=input()
l="abcdefghijklmnopqrstuvwxyz"
for k in range(1,len(s)+1):
t=s[0:len(s)-k]
if(l.index(s[-k])!=0):
m=t+l[l.index(s[-k])-1]+"a"*(k-1)
if(m>r):
print(m)
break
else:
if(m==r):
j=m[0:len(s)-1]+"b"
if(r<j<s):
print(j)
break
else:
print("No such string")
break
else:
print("No such string")
break | 7 | PYTHON3 |
#!/bin/python3
import math
import os
import random
import re
import sys
# Complete the function below.
m= int(input())
if m%2==0:
print("Mahmoud")
else:
print("Ehab") | 7 | PYTHON3 |
n = int(input())
for _ in range(n):
str1 = input()
flag = 0
for (index) in range(len(str1)):
if(str1[index] != 'a'):
flag = 1
print('YES')
print(str1[:len(str1) - index] + 'a' + str1[len(str1)-index:])
break
if(flag == 0):
print('NO')
| 7 | PYTHON3 |
a , b , ab = map(int , input().split(" "))
ab = 2*ab
x = a + b
if abs(a-b) >= 2 :
x = ((a + b) - (abs(a-b)) + 1)
print(x + ab)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define MOD 1000000007
typedef long long ll;
typedef pair<int,int> P;
#define int long long
#define All(v) (v.begin(),v.end())
int gcd(int a, int b) {
if (b == 0)return a;
return gcd(b, a%b);
}
int lcm(int a, int b) {
return a / gcd(a, b)*b;
}
int modpow(int a,int b){
if(!b)return 1;
if(b%2)return modpow(a,b-1)*a%MOD;
return modpow(a,b/2)*modpow(a,b/2)%MOD;
}
int fac(int a){
int Ans=1;
for(int i=1;i<=a;i++){
Ans*=i;
Ans%=MOD;
}
return Ans;
}//kaijo
int comb(int a,int b){
return fac(a)*modpow(fac(a-b),MOD-2)%MOD*modpow(fac(b),MOD-2)%MOD;
}
signed main(){
int n,a,b,c;
cin>>n>>a>>b>>c;
cout<<n-(a+b-c)<<endl;
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, n, a, b, p, c, d, e, f, g, h, hh, i, j;
cin >> t;
while (t--) {
long long m;
cin >> n >> m;
string s;
cin >> s;
long long ans[27] = {0};
long long sum[n];
memset(sum, 0, sizeof(sum));
long long arr[m];
for (i = 0; i < m; i++) {
cin >> arr[i];
sum[arr[i] - 1]++;
}
for (i = n - 2; i >= 0; i--) sum[i] += sum[i + 1];
for (i = 0; i < n; i++) {
ans[s[i] - 'a'] += sum[i];
}
for (i = 0; i < n; i++) {
ans[s[i] - 'a']++;
}
for (i = 0; i < 26; i++) {
cout << ans[i] << " ";
}
cout << "\n";
}
return 0;
}
| 9 | CPP |
# #import sys
# import math
# import bisect
# import collections
# import itertools
# #from sys import stdin,stdout
# from math import gcd,floor,sqrt,log
# from collections import defaultdict as dd, Counter as ctr
# from bisect import bisect_left as bl, bisect_right as br
# from itertools import permutations as pr, combinations as cb
#sys.setrecursionlimit(100000000)
#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$
inp = lambda: int(input())
# strng = lambda: input().strip()
# jn = lambda x,l: x.join(map(str,l))
# strl = lambda: list(input().strip())
# mul = lambda: map(int,input().strip().split())
# mulf = lambda: map(float,input().strip().split())
seq = lambda: list(map(int,input().strip().split()))
#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$
# p_inf = float('inf')
# n_inf = float('-inf')
#To find mex
# def mex(arr):
# nList = set(arr)
# mex = 0
# while mex in nList:
# mex += 1
# return(mex)
def results(a, b, c, n):
temp = [a[0]]
for i in range(1, n - 1):
if(a[i] != temp[i - 1]):
temp.append(a[i])
elif(b[i] != temp[i - 1]):
temp.append(b[i])
else:
temp.append(c[i])
if(a[n - 1] != temp[0] and a[n - 1] != temp[-1]):
temp.append(a[n - 1])
elif(b[n - 1] != temp[0] and b[n - 1] != temp[-1]):
temp.append(b[n - 1])
else:
temp.append(c[n - 1])
return(temp)
def main():
t = inp()
for _ in range(t):
n = inp()
a = seq()
b = seq()
c = seq()
result = results(a,b,c,n)
print(*result)
if __name__ == '__main__':
main() | 7 | PYTHON3 |
n1, n2, n3, n4 = input().split()
n1, n2, n3, n4 = int(n1), int(n2), int(n3), int(n4)
def getForOne(n1, n2, n3, n4):
if n1 == (n2+n3+n4):
return True
elif n2 == (n1+n3+n4):
return True
elif n3 == (n1+n2+n4):
return True
elif n4 == (n1+n2+n3):
return True
return False
def getForTwo(n1, n2, n3, n4):
if (n1 + n2) == (n3 + n4):
return True
elif (n1 + n3) == (n2 + n4):
return True
elif (n1 + n4) == (n2 + n3):
return True
return False
def getYesOrNo(n1, n2, n3, n4):
if getForOne(n1, n2, n3, n4) or getForTwo(n1, n2, n3, n4):
return "YES"
return "NO"
print(getYesOrNo(n1, n2, n3, n4))
| 7 | PYTHON3 |
n=int(input())
A=[int(_) for _ in input().split()]
B=sorted(A)
x,y=A.count(B[0]),A.count(B[-1])
print(max(0,len(A)-x-y)) | 7 | PYTHON3 |
t = int(input())
for _ in range(t):
a = list(map(int,input().split()))
a.sort()
if a[1] == a[2]:
print("YES")
print(str(a[0]) + ' ' + str(a[0]) + ' ' + str(a[1]))
else:
print("NO") | 7 | PYTHON3 |
a=int(input())
lis=[]
n=input()
lis=n.split()
taxi=0
t3=0
t2=0
t1=0
for j in lis:
j=int(j)
if j==4:
taxi+=1
if j==3:
t3+=1
if j==2:
t2+=1
if j==1:
t1+=1
if t1>t3:
t1=t1-t3
taxi+=t3
t3=0
if t1==t3 or t1<t3:
t1=0
taxi+=t3
t3=0
if t2%2==0:
taxi+=t2/2
t2=0
if t2%2!=0:
taxi+=int(t2/2)
t2=1
t1-=2
taxi+=1
t2=0
if t1>0:
taxi+=int((t1+3)/4)
print(int(taxi))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
int main() {
int a, b;
scanf("%d%d", &a, &b);
printf("%.10f\n", b > a ? -1 : (a + b) * .5 / ((a + b) / (b + b)));
}
| 7 | CPP |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
using std::make_pair;
using std::pair;
using std::queue;
using std::string;
using std::unordered_map;
using std::vector;
class Solution {
public:
int n;
int GetValue(int val) {
if (val == 1) return 0;
return (val - 1) % 2;
}
void solve() {
while (cin >> n) {
int sum = 0;
for (int i = 0; i < n; ++i) {
int tmp;
scanf("%d", &tmp);
sum += GetValue(tmp);
if (sum % 2 == 1) {
cout << "1" << endl;
} else
cout << "2" << endl;
}
}
}
};
int main() {
Solution sol;
sol.solve();
return 0;
}
| 8 | CPP |
# ===============================================================================================
# importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
# If the element is already present in the list,
# the left most position where element has to be inserted is returned.
from bisect import bisect_right as br
from bisect import bisect
# If the element is already present in the list,
# the right most position where element has to be inserted is returned
# ==============================================================================================
# fast I/O region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
# ===============================================================================================
# some shortcuts
mod = 1000000007
def inp(): return sys.stdin.readline().rstrip("\r\n") # for fast input
def out(var): sys.stdout.write(str(var)) # for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
def zerolist(n): return [0] * n
def nextline(): out("\n") # as stdout.write always print sring.
def testcase(t):
for p in range(t):
solve()
from random import randint
from collections import defaultdict, deque
class Graph(object):
def __init__(self, dic):
self.dict = dic
self.vertex = set()
def addedge(self, a, b):
if self.dict[a] == []:
self.vertex.add(a)
if b != None:
self.dict[a].append(b)
def con_com_util(self, i, unvisited, count, comp):
for j in self.dict[i]:
if j in unvisited:
unvisited.remove(j)
comp[count].append(j)
comp = self.con_com_util(j, unvisited, count, comp)
return comp
def conn_components(self):
unvisited = self.vertex.copy()
count = 0
comp = defaultdict(list)
while unvisited:
i = unvisited.pop()
comp[count].append(i)
comp = self.con_com_util(i, unvisited, count, comp)
count += 1
return (count, comp)
def countSetBits(n):
count = 0
while (n):
n &= (n - 1)
count += 1
return count
def g():
return -1
from math import ceil
def solve():
n=int(inp())
s=inp()
ar=[s[0]]
ans=[1]
for i in range(1,n):
for j in range(len(ar)+1):
if j==len(ar):
ar.append(s[i])
ans.append(j+1)
break
if s[i]>=ar[j]:
ar[j]=s[i]
ans.append(j+1)
break
print(len(ar))
for i in ans:
print(i,end=" ")
solve()
| 11 | PYTHON3 |
n = int(input())
x = list(map(int,input().split()))
x.sort()
q = int(input())
#print(x)
for i in range(q):
cnt = 0
m = int(input())
#print("FOR m: ",m)
if(m<x[0]):
print(0)
elif(m>=x[n-1]):
print(n)
else:
i = 0
j = n-1
while(j-i>1):
mid = (i+j)//2
if(x[mid]<=m):
i = mid
else:
j = mid
print(j)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline long long rd() {
long long x = 0;
int ch = getchar(), f = 1;
while (!isdigit(ch) && (ch != '-') && (ch != EOF)) ch = getchar();
if (ch == '-') {
f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
inline void rt(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10)
rt(x / 10), putchar(x % 10 + '0');
else
putchar(x + '0');
}
const int maxn = 150005;
int n, m, c;
long long x[maxn];
struct submax {
long long lm, rm, mm, sum;
submax(long long LM = 0, long long RM = 0, long long MM = 0,
long long SUM = 0) {
lm = LM, rm = RM, mm = MM, sum = SUM;
}
} a[maxn << 2], tmp;
void build(int i, int l, int r) {
if (l == r) {
a[i].lm = a[i].rm = a[i].mm = a[i].sum = x[l];
a[i].mm = max(a[i].mm, 0ll);
return;
}
int mid = l + r >> 1;
build((i << 1), l, mid), build((i << 1 | 1), mid + 1, r);
a[i].lm = max(a[(i << 1)].lm, a[(i << 1)].sum + a[(i << 1 | 1)].lm);
a[i].rm = max(a[(i << 1 | 1)].rm, a[(i << 1 | 1)].sum + a[(i << 1)].rm);
a[i].mm = max(max(a[(i << 1)].mm, a[(i << 1)].rm + a[(i << 1 | 1)].lm),
a[(i << 1 | 1)].mm);
a[i].sum = a[(i << 1)].sum + a[(i << 1 | 1)].sum;
}
submax query(int i, int l, int r, int first, int bh) {
if (l == first && r == bh) return submax(a[i].lm, a[i].rm, a[i].mm, a[i].sum);
int mid = l + r >> 1;
if (bh <= mid)
return query((i << 1), l, mid, first, bh);
else if (first > mid)
return query((i << 1 | 1), mid + 1, r, first, bh);
else {
submax lx = query((i << 1), l, mid, first, mid),
rx = query((i << 1 | 1), mid + 1, r, mid + 1, bh), t;
t.lm = max(lx.lm, lx.sum + rx.lm);
t.rm = max(rx.rm, rx.sum + lx.rm);
t.sum = lx.sum + rx.sum;
t.mm = max(max(lx.mm, lx.rm + rx.lm), rx.mm);
return t;
}
}
int main() {
n = rd() - 1, m = rd(), c = rd();
int lst = rd(), now, p;
for (int i = 1; i <= (int)n; i++)
now = rd(), x[i] = (long long)(now - lst) * 50, lst = now;
for (int i = 1; i <= (int)n; i++) now = rd(), x[i] -= now * c;
build(1, 1, n);
long long ans = 0;
for (int i = 1; i <= (int)m; i++) {
int l = rd(), r = rd() - 1;
ans += query(1, 1, n, l, r).mm;
}
printf("%.10lf\n", ans / 100.0);
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
long long power(long long a, long long b) {
if (b == 0) return 1;
if (b % 2 == 0) {
long long t = power(a, b / 2);
t = t * t;
t = t % MOD;
return t;
} else {
long long t = power(a, b - 1);
t = t * a;
t = t % MOD;
return t;
}
}
long long inv(long long a) { return power(a, MOD - 2) % MOD; }
void go() {
long long n;
cin >> n;
long long ans = ((power(2, n) + power(4, n)) * inv(2)) % MOD;
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int t = 1;
while (t--) {
go();
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
int i = 0;
vector<int> ans;
ans.push_back(v[0]);
while (i < n - 1) {
int j = i;
while ((i < n - 1) && (v[i + 1] > v[i])) i++;
if (i != j) {
ans.push_back(v[i]);
}
j = i;
while ((i < n - 1) && (v[i + 1] < v[i])) i++;
if (i != j) {
ans.push_back(v[i]);
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
cout << endl;
}
}
| 8 | CPP |
t=int(input())
for i in range(t):
a,b=(map(int,input().split()))
if (a%b)==0:
print("0")
else:
print((int(a/b)+1)*b-a)
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int iMax = 0, nCount, iInput, i, iAns;
cin >> nCount;
for (i = 1; i <= nCount; ++i) {
cin >> iInput;
if (iInput > iMax) iMax = iInput;
}
iAns = iMax ^ iInput;
cout << iAns;
}
| 9 | CPP |
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<cmath>
int map[14][14];
void hoge(int x,int y) {
map[x][y] = 0;
if (map[x - 1][y] == 1)hoge(x - 1, y);
if (map[x + 1][y] == 1)hoge(x + 1, y);
if (map[x][y - 1] == 1)hoge(x, y - 1);
if (map[x][y + 1] == 1)hoge(x, y + 1);
}
int main() {
std::string s[12];
int ans = 0;
while (!std::cin.eof()) {
for (int i = 0; i < 12; ++i)std::getline(std::cin,s[i]);
ans = 0;
for (int i = 1; i < 13; ++i) {
for (int j = 1; j < 13; ++j) {
map[i][j] = s[i - 1][j - 1]-'0';
}
}
for (int i = 1; i < 13; ++i) {
for (int j = 1; j < 13; ++j) {
if (map[i][j] == 1) { ++ans; hoge(i,j); }
}
}
std::cout << ans << std::endl;
std::getline(std::cin, s[0]);
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long k = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
k = k * 10 + ch - '0';
ch = getchar();
}
return k * f;
}
inline void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
inline void writeln(long long x) {
write(x);
puts("");
}
const long long N = 5010, inf = 1e12;
long long n, K, a[N], b[N], e[N][2];
const long long M = 4e5 + 10;
long long nedge = 0, p[2 * M], nex[2 * M], head[2 * M], c[2 * M], cc[2 * M];
inline void addedge(long long a, long long b, long long v, long long vv) {
p[++nedge] = b;
nex[nedge] = head[a];
head[a] = nedge;
c[nedge] = v;
cc[nedge] = vv;
p[++nedge] = a;
nex[nedge] = head[b];
head[b] = nedge;
c[nedge] = 0;
cc[nedge] = -vv;
}
long long s, t, ans = 0;
long long dist[2 * N], vis[2 * N], cur[2 * N], distt[2 * N];
inline long long fan(long long x) { return (x & 1) ? x + 1 : x - 1; }
inline bool spfa(long long s, long long t) {
memset(vis, 0, sizeof vis);
for (long long i = s; i <= t; i++) dist[i] = 1e9;
dist[t] = 0;
vis[t] = 1;
deque<long long> q;
q.push_back(t);
while (!q.empty()) {
long long now = q.front();
q.pop_front();
for (long long k = head[now]; k; k = nex[k])
if (c[fan(k)] && dist[p[k]] > dist[now] - cc[k]) {
dist[p[k]] = dist[now] - cc[k];
if (!vis[p[k]]) {
vis[p[k]] = 1;
if (!q.empty() && dist[p[k]] < dist[q.front()])
q.push_front(p[k]);
else
q.push_back(p[k]);
}
}
vis[now] = 0;
}
return dist[s] < 1e9;
}
inline long long dfs(long long x, long long low) {
if (x == t) {
vis[t] = 1;
return low;
}
long long used = 0, a;
vis[x] = 1;
for (long long k = head[x]; k; k = nex[k])
if (!vis[p[k]] && c[k] && dist[x] - cc[k] == dist[p[k]]) {
a = dfs(p[k], min(c[k], low - used));
if (a) ans += a * cc[k], c[k] -= a, c[fan(k)] += a, used += a;
if (used == low) break;
}
return used;
}
inline long long costflow() {
long long flow = 0;
while (spfa(s, t)) {
vis[t] = 1;
while (vis[t]) {
memset(vis, 0, sizeof vis);
flow += dfs(s, 1e9);
}
}
return flow;
}
long long cntp = 0, cntk, cp[N];
map<long long, bool> mp;
signed main() {
n = read();
K = read();
s = 0;
for (long long i = 1; i <= n; i++) {
b[i] = read();
if (!mp[b[i]]) {
mp[b[i]] = 1;
cntk++;
}
}
K = min(K, cntk);
for (long long i = 1; i <= n; i++) a[i] = read();
for (long long i = 1; i <= n; i++) {
e[i][0] = ++cntp;
e[i][1] = ++cntp;
addedge(e[i][0], e[i][1], 1, -inf);
}
for (long long i = 1; i <= n; i++) cp[i] = ++cntp;
t = ++cntp;
cp[n + 1] = t;
addedge(s, cp[1], K, 0);
for (long long i = 1; i <= n; i++) {
addedge(cp[i], cp[i + 1], K, 0);
for (long long j = i + 1; j <= n; j++)
if (b[j] == b[i]) {
addedge(e[i][1], e[j][0], 1, 0);
break;
}
addedge(cp[i], e[i][0], 1, 0);
addedge(e[i][1], cp[i + 1], 1, a[b[i]]);
}
costflow();
writeln(ans + n * inf);
return 0;
}
| 9 | CPP |
a = []
for i in range(5):
a += [list(input().split())]
for i in range(5):
for j in range(5):
if a[i][j] == '1':
print(abs(i + 1 - 3) + abs(j + 1 - 3))
| 7 | PYTHON3 |
#define _USE_MATH_DEFINES
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <cmath>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
using namespace std;
#define MAX_V 200000
typedef pair<long long int, long long int> P;
long long int INF = 1e18;
int main(){
queue<string> que;
map<string, int> m;
string fs = "";
for(int i = 0; i < 9; i++){
string s;
cin >> s;
fs += s;
}
que.push(fs);
for(int loop = 0; loop < 1000; loop++){
if(que.empty()){
break;
}
int sz = que.size();
for(int num = 0; num < sz; num++){
string str = que.front();
que.pop();
if(m.find(str) != m.end()){
continue;
}
m[str] = loop;
for(int i = 0; i < 9; i++){
if(str[i] == '0'){
if(i >= 3){
swap(str[i], str[i - 3]);
que.push(str);
swap(str[i], str[i - 3]);
}
if(i < 6){
swap(str[i], str[i + 3]);
que.push(str);
swap(str[i], str[i + 3]);
}
if(i % 3 > 0){
swap(str[i], str[i - 1]);
que.push(str);
swap(str[i], str[i - 1]);
}
if(i % 3 < 2){
swap(str[i], str[i + 1]);
que.push(str);
swap(str[i], str[i + 1]);
}
}
}
}
}
cout << m["123456780"] << endl;
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
int n, a, b;
struct node {
long long h, d;
friend bool operator<(const node &a, const node &b) {
return a.h - a.d > b.h - b.d;
}
} A[maxn];
int B[maxn];
int main() {
scanf("%d%d%d", &n, &a, &b);
for (int i = 0; i < n; i++) scanf("%I64d%I64d", &A[i].h, &A[i].d);
long long c = 1;
for (int i = 0; i < a; i++) c = c * 2;
sort(A, A + n);
memset(B, 0, sizeof(B));
long long sum = 0, u = 0, Min = 0x3f3f3f3f;
for (int i = 0; i < n; i++) {
if (A[i].h > A[i].d && u < b) {
u++;
B[i] = 1;
sum += A[i].h;
Min = min(Min, A[i].h - A[i].d);
} else {
B[i] = 0;
sum += A[i].d;
}
}
if (u == 0) Min = 0;
long long ans = sum;
for (int i = 0; i < n; i++) {
if (b == 0) break;
long long tmp = A[i].h * c;
if (B[i])
ans = max(ans, sum + tmp - A[i].h);
else {
if (u == b) tmp -= Min;
ans = max(ans, sum + tmp - A[i].d);
}
}
printf("%I64d\n", ans);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
#define FOR( i, m, n ) for( int (i) = (m); (i) < (n); (i)++ )
#define REP( i, n ) FOR( i, 0, n )
#define ALL( a ) (a).begin(), (a).end()
int main() {
int n; cin >> n;
int r, a, b, ma , cnt;
REP( i, n ) {
cin >> r;
cnt = 0;
if( r < 10 ) cnt = 0;
else {
int j;
ma = 0;
while( 1 ) {
j = 10;
while( 1 ) {
a = r % j;
b = r / j;
if( a == r ) break;
ma = max( a * b, ma );
j *= 10;
}
cnt++;
r = ma;
ma = 0;
if( r < 10 ) break;
}
}
cout << cnt << endl;
}
}
| 0 | CPP |
import io
import os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def solve():
x, y = map(int, input().split())
x, y = sorted([x, y])
ans = 2*x
if y-x:
ans += 2*(y-x)-1
print(ans)
t = int(input())
for _ in range(t):
solve()
| 7 | PYTHON3 |
n=int(input())
a=list(map(int,input().split()))
b=list(set(a))
b.sort()
if len(b)<2:
print("NO")
else:
print(b[1]) | 7 | PYTHON3 |
n,k=map(int,input().split())
print(n+1-k) | 0 | PYTHON3 |
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <string>
#include <sstream>
#include <complex>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <set>
#include <iomanip>
#define rep(i, n) for (int i = 0; i < (int)(n); i++
using namespace std;
int main() {
int q,a,c;
string b;
map<string,int> s;
cin >> q;
for (int i = 0; i < q; i++) {
cin>>a>>b;
if (a == 0) {
cin >> c;
if (s.count(b)) {
s[b] = c;
}
else {
s.insert(make_pair(b, c));
}
}
else if (a == 1) {
if (s.count(b)) {
cout << s[b] << endl;
}
else {
cout << 0 << endl;
}
}
else {
s.erase(b);
}
}
}
| 0 | CPP |
energy = 0
n, m = [int(x) for x in input().split()]
prices = [None] + [int(x) for x in input().split()]
for _ in range(m):
a, b = [int(x) for x in input().split()]
energy += min(prices[a], prices[b])
print(energy) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long max_n = INT_MAX - 1000000;
long long dp[30][30001];
pair<int, int> par[30][30001];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
long long n, m, k;
cin >> n >> m >> k;
if (n > m) swap(n, m);
map<char, long long> mp;
string ss = "";
for (long long i = 0; i < k; i++) {
char a;
cin >> a;
mp[a]++;
ss += a;
}
vector<int> vv;
for (auto i : mp) {
vv.push_back(i.second);
}
long long ans = LONG_MAX;
for (int i1 = 0; i1 < vv.size(); i1++) {
vector<int> v = vv;
v.erase(v.begin() + i1);
v.insert(v.begin(), vv[i1]);
for (long long i = 0; i < v.size(); i++) {
for (long long j = 0; j <= m; j++) {
dp[i][j] = max_n;
}
}
for (int i = 0; i < v.size(); i++) {
for (long long j = 1; j <= m; j++) {
if (i == 0) {
if (j <= v[i]) {
dp[i][j] = v[i];
}
} else {
if (dp[0][j] == max_n) {
if (j <= v[i]) {
dp[i][j] = v[i] + v[0];
dp[i][j] = min(dp[i - 1][j], dp[i][j]);
} else {
dp[i][j] = min(dp[i - 1][j], dp[i - 1][j - v[i]] + v[i]);
}
} else {
dp[i][j] = dp[0][j];
}
}
}
}
if (v[0] - (dp[v.size() - 1][n] - n) >= 0)
ans = min(ans, (v[0] - (dp[v.size() - 1][n] - n)) *
max((long long)0,
(dp[v.size() - 1][n] - n - (k - n - m))));
if (v[0] - (dp[v.size() - 1][m] - m) >= 0)
ans = min(ans, (v[0] - (dp[v.size() - 1][m] - m)) *
max((long long)0,
(dp[v.size() - 1][m] - m - (k - n - m))));
}
cout << ans << '\n';
}
return 0;
}
| 16 | CPP |
def answer(x,y,z):
flag=[-1]
if x==y and y==z:
return "YES", [x,x,x]
elif (x==y):
if z>x:
return "NO",flag
else:
return "YES",[x,z,z]
elif (y==z):
if x>y:
return "NO",flag
else:
return "YES",[x,x,y]
elif x==z:
if y>x:
return "NO",flag
else:
return "YES",[y,y,x]
else:
return "NO",flag
t=int(input())
for i in range(t):
x,y,z=map(int,input().split())
a,b=answer(x,y,z)
if a=="YES":
print(a)
print(*b)
else:
print(a) | 7 | PYTHON3 |
Subsets and Splits