solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 2020;
int vis[N], n;
long long d2[N], d[N][N], x = 1e18;
void Dij(long long *dis) {
memset(vis, 0, sizeof vis);
for (int t = 1; t <= n - 1; t++) {
int p = -1;
for (int i = 1; i <= n; i++)
if (!vis[i] && (p == -1 || dis[i] < dis[p])) p = i;
if (p == -1) return;
vis[p] = 1;
for (int i = 1; i <= n; i++)
if (dis[i] > dis[p] + d[p][i]) {
dis[i] = dis[p] + d[p][i];
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) d[i][i] = 1e18;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
scanf("%lld", &d[i][j]), d[j][i] = d[i][j], x = min(x, d[i][j]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) d[i][j] -= x;
memset(d2, 60, sizeof d2);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) d2[i] = min(d2[i], d[i][j] << 1);
Dij(d2);
for (int i = 1; i <= n; i++) printf("%lld\n", d2[i] + 1ll * (n - 1) * x);
}
| 10 | CPP |
t=int(input())
def f(n,k,s):
if n==1:
if s=='0':
return 1
return 0
a=[0]
i=0
while i<n and s[i]=='0':
a[0]+=1
i+=1
while i<n:
i+=1
b=0
while i<n and s[i]=='0':
b+=1
i+=1
a.append(b)
if len(a)==1:
if a[0]%(k+1)==0:
return a[0]//(k+1)
return (a[0]//(k+1))+1
q=a[0]//(k+1)
for m in range(1,len(a)-1):
if (a[m]-k)>0:
q+=(a[m]-k)//(k+1)
q+=a[-1]//(k+1)
return q
for _ in range(t):
n,k=tuple(map(int, input().split()))
s=input()
print(f(n,k,s)) | 9 | PYTHON3 |
n = 10
p, r = map(int, input().split())
if (r/p).is_integer():
print(r//p)
else:
if r != p:
while n % p != 0 and (n + r) % p != 0:
n += 10
if (n / p).is_integer():
print(n // p)
else:
print((n + r) // p) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n; string s; cin>>n>>s;
int ans=1; char t=s[0];
for(int i=1; i<n; ++i){
if(t!=s[i]){t=s[i]; ++ans;}
}
cout<<ans<<endl;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N, X[100010], Y[100010], sumx1 = 0, sumy1 = 0, sumx = 0, sumy = 0,
ans = 0;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> X[i] >> Y[i];
sumx1 += (N - 1) * X[i] * X[i];
sumy1 += (N - 1) * Y[i] * Y[i];
sumx += X[i];
sumy += Y[i];
}
ans = sumx1 + sumy1;
for (int i = 0; i < N - 1; i++) {
ans -= 2 * (sumx - X[i]) * X[i];
sumx = sumx - X[i];
ans -= 2 * (sumy - Y[i]) * Y[i];
sumy = sumy - Y[i];
}
cout << ans << "\n";
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
long a,b,m;cin>>a>>b>>m;
vector<long> an(a), bn(b);
rep(i,a) cin>>an[i];
rep(i,b) cin>>bn[i];
long price = *min_element(an.begin(), an.end()) + *min_element(bn.begin(), bn.end());
long x,y,c;
rep(i,m) {
cin>>x>>y>>c;
price = min(price, an[x-1] + bn[y-1] - c);
}
cout << price;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
long long ts[N], cur = 0, ans[N];
vector<pair<long long, long long> > qs[N];
vector<int> g[N];
int n, m;
void dfs(int u, int p, int lvl) {
for (auto f : qs[u]) {
ts[lvl + f.first + 1] -= f.second;
cur += f.second;
}
cur += ts[lvl];
ans[u] = cur;
for (int v : g[u])
if (v != p) dfs(v, u, lvl + 1);
cur -= ts[lvl];
for (auto f : qs[u]) {
ts[lvl + f.first + 1] += f.second;
cur -= f.second;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int x = (1), qwerty = (n); x < qwerty; x++) {
int u, v;
cin >> u >> v;
u--;
v--;
g[u].push_back(v);
g[v].push_back(u);
}
cin >> m;
for (int x = (0), qwerty = (m); x < qwerty; x++) {
long long u, d, v;
cin >> u >> d >> v;
u--;
qs[u].push_back({min(int(d), n), v});
}
dfs(0, 0, 0);
for (int x = (0), qwerty = (n); x < qwerty; x++)
cout << ans[x] << " \n"[x + 1 == n];
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long num = 0, neg = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') neg = -1;
c = getchar();
}
while (isdigit(c)) {
num = (num << 3) + (num << 1) + c - '0';
c = getchar();
}
return num * neg;
}
const int INF = 0x3f3f3f3f;
int dis[20010], n, m, s, e;
int to[300010], val[300010], nxt[300010], head[20010], cnt;
int vis[20010];
struct node {
int x, y, val;
} side[100010];
void insert(int x, int y, int z) {
to[cnt] = y, val[cnt] = z;
nxt[cnt] = head[x];
head[x] = cnt;
cnt++;
to[cnt] = x, val[cnt] = 0;
nxt[cnt] = head[y];
head[y] = cnt;
cnt++;
}
bool bfs() {
queue<int> line;
memset(dis, 0, sizeof(dis));
dis[s] = 1;
line.push(s);
while (!line.empty()) {
int u = line.front();
line.pop();
for (int i = head[u]; i != -1; i = nxt[i]) {
int v = to[i];
if (!val[i]) continue;
if (!dis[v]) {
dis[v] = dis[u] + val[i];
line.push(v);
if (v == e) return 1;
}
}
}
return 0;
}
int dinic(int now, int x) {
if (now == e) return x;
int rest = x;
for (int i = head[now]; i != -1 && rest; i = nxt[i]) {
if (dis[to[i]] == dis[now] + 1 && val[i]) {
int flow = dinic(to[i], min(rest, val[i]));
if (flow) {
val[i] -= flow;
val[i ^ 1] += flow;
rest -= flow;
} else
dis[to[i]] = 0;
}
}
return x - rest;
}
bool cmp1(node x, node y) { return x.val < y.val; }
inline bool check(int x) {
memset(head, -1, sizeof(head));
cnt = 0;
for (int i = 1; i <= n; i++) insert(s, i, 1), insert(i + n, e, 1);
for (int i = 1; i <= min(x, m); i++) insert(side[i].x, side[i].y + n, 1);
int flow = 0, ans = 0;
while (bfs()) {
while (flow = dinic(s, 1e9)) ans += flow;
}
if (ans == n) return 1;
return 0;
}
signed main() {
memset(head, -1, sizeof(head));
cin >> n >> m;
s = 0, e = 2 * n + 1;
for (int i = 1; i <= m; i++)
side[i].x = read(), side[i].y = read(), side[i].val = read();
sort(side + 1, side + m + 1, cmp1);
int l = 1, r = m + 1, mid;
while (l < r) {
mid = l + r >> 1;
if (check(mid))
r = mid;
else
l = mid + 1;
}
printf("%d\n", l > m ? -1 : side[l].val);
return 0;
}
| 8 | CPP |
import sys
input = sys.stdin.readline
def getInt(): return int(input())
def getVars(): return map(int, input().split())
def getList(): return list(map(int, input().split()))
def getStr(): return input().strip()
## -------------------------------
t= getInt()
for _ in range(t):
h, m = getVars()
print(60*24 - h*60 - m)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int count;
int main() {
long long n, k, d = 0, count = 0;
cin >> n >> k;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (long long i = 1; i < n; i++) {
d = a[i] - a[0];
if (d % k == 0) {
count = count + d / k;
} else {
count = -1;
cout << -1;
break;
}
}
if (count != -1) cout << count;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long N = 500005;
long long MAX = 9223372036854775807;
long long MOD = 1000000007;
long double PI = 4 * atan(1);
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cout.precision(30);
int n;
cin >> n;
vector<int> A(n, 0);
map<int, int> mp, mp1, mp2;
bool res = false;
for (int i = 0; i < n; i++) {
cin >> A[i];
mp2[A[i]]++;
}
for (int i = 1; i <= 100; i++) {
for (int j = 0; j < n; j++) {
if (A[j] % i == 0 && mp1[j] == 0 && mp2[i] > 0) {
mp[i]++;
mp1[j]++;
}
}
}
cout << mp.size();
return 0;
}
| 7 | CPP |
for _ in range(int(input())):
input()
arr = [*map(int, input().split())]
a, b, c= arr[:3]
if a != b or a != c or b != c:
print(1 if b == c else 2 if a == c else 3)
else:
print(next(i for i, n in enumerate(arr) if n != a) + 1) | 7 | PYTHON3 |
t = int(input())
for _ in range(t):
s = input()
if len(s) % 2 != 0:
print("NO")
continue
flag = True
i, j =len(s)//2 - 1, len(s) - 1
while i >= 0:
if s[i] != s[j]:
flag = False
break
i -= 1
j -= 1
if flag:
print("YES")
else:
print("NO") | 7 | PYTHON3 |
a,b=map(int,input().split())
x=a
c=0;r=0
while(a>=b):
r=a%b
a=a//b
c+=a
a+=r
print(c+x) | 7 | PYTHON3 |
a = list(map(int,input().strip().split()))[:2]
n=a[0]
k=a[1]
s=0
j=0
a1 = list(map(int,input().strip().split()))[:n]
for i in a1:
if(i>0 and j<k or i==a1[k-1] and i>0):
s+=1
j+=1
print(s)
| 7 | PYTHON3 |
#include <iostream>
#include <string>
using namespace std;
int main()
{
int y, m, d;
while (cin>>y>>m>>d)
{
if (y >= 1990 || (y == 1989 && m >= 2) || (y == 1989 && m == 1 && d >= 8))
{
cout << "heisei " << y - 1989 + 1 << " " << m << " " << d << endl;
}
else if (y >= 1927 || (y == 1926 && m == 12 && d >= 25))
{
cout << "showa " << y - 1926 + 1 << " " << m << " " << d << endl;
}
else if (y >= 1913 || (y == 1912 && m >= 8) || (y == 1912 && m == 7 && d >= 30))
{
cout << "taisho " << y - 1912 + 1 << " " << m << " " << d << endl;
}
else if (y >= 1869 || (y == 1868 && m >= 10) || (y == 1868 && m >= 9 && d >= 8))
{
cout << "meiji " << y - 1868 + 1 << " " << m << " " << d << endl;
}
else
{
cout << "pre-meiji" << endl;
}
}
return 0;
} | 0 | CPP |
import sys
input = sys.stdin.readline
class segtree:
x_unit=0 # 単位元
x_func=lambda self,a:a[0]+a[1] # 関数
def __init__(self,n,seq):
self.n=n
self.x=[self.x_unit]*(2*n)
for i,j in enumerate(seq, self.n): # n番目からseqをx配列に移していく
self.x[i] = j
for i in range(self.n-1, 0, -1):
self.x[i] = self.x_func([self.x[i*2], self.x[i*2+1]])
def update(self,i,j): # 1点更新
i += self.n
self.x[i]=j
while i>1:
i//=2 # 更新後、木の上へと登っていくついでに更新
self.x[i]=self.x_func([self.x[i*2], self.x[i*2+1]])
def fold(self,l,r): # 区間[l, r)の合計を取得
l+=self.n
r+=self.n
val_l=self.x_unit
val_r=self.x_unit
while l<r:
if l & 1: # lが奇数
val_l=self.x_func([val_l,self.x[l]])
l+=1 # 偶数に調節
if r & 1: # rが奇数
r-=1 # 開区間なので1個前は偶数番目の要素
val_r=self.x_func([val_r,self.x[r]])
l //= 2
r //= 2
return self.x_func([val_l,val_r])
n,q=map(int,input().split())
*a,=map(int,input().split())
seg=segtree(n,a)
for i in range(q):
t,x,y=map(int,input().split())
if t==0:
old=seg.fold(x,x+1)
seg.update(x, old+y)
else:
print(seg.fold(x, y)) | 0 | PYTHON3 |
n=int(input())
t=[]
for i in range(n):
temp=list(map(int,input().split()))
t.append(temp)
mid=n//2
ans=-3*t[mid][mid]
for i in range(n):
ans+=t[mid][i]
ans+=t[i][mid]
ans+=t[i][i]
ans+=t[i][n-1-i]
print(ans)
| 7 | PYTHON3 |
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <climits>
#include <vector>
#include <map>
#include <set>
#include <list>
#include <stack>
#include <queue>
#include <algorithm>
#include <iostream>
#include <string>
#define REP(i,n) for(long long i=0;i<n;++i)
#define REPR(i,n) for(long long i=n;i>=0;--i)
#define REPI(itr,v) for(auto itr=v.begin();itr!=v.end();++itr)
#define REPIR(itr,v) for(auto itr=v.rbegin();itr!=v.rend();++itr)
#define FOR(i,a,b) for(long long i=a;i<b;++i)
#define SORT(v,n) sort(v, v+n)
#define SORTV(v) sort(v.begin(), v.end())
#define ALL(v) v.begin(),v.end()
#define llong long long
#define INF 999999999
#define SUR 1000000007
#define pb push_back
#define pf push_front
#define MP make_pair
#define SV(v) {for(long long sitr=0;sitr<v.size();++sitr){cin>>v[sitr];}}
int dx[] = {0, 0, -1, 1};
int dy[] = {1, -1, 0, 0};
using namespace std;
typedef pair<int,int> pii;
int main(){
llong p, q;
cin >> p >> q;
llong a = q, b = p;
llong r = a % b;
while(r != 0){
a = b;
b = r;
r = a % b;
}
p /= b; q /= b;
map<llong, llong> mp;
for(int i = 2; i * i <= q; ++i){
if(q % i == 0){
mp[i]++;
while(q % i == 0) q /= i;
}
}
if(q != 1){
mp[q]++;
}
llong ans = 1;
REPI(itr, mp){
ans *= itr->first;
}
cout << ans << endl;
return 0;
}
| 0 | CPP |
a,b,c,d=map(int,input().split())
n=0
n+=min(c,min(d,a))*256
a-=min(c,min(d,a))
n+=min(a,b)*32
print(n) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1520;
int n, s, m, k, chap[maxn], nxt[maxn], dp[maxn][maxn], ar[maxn], val[maxn],
val2[maxn];
bool check(int x) {
for (int i = 1; i <= n; i++) {
val[i] = val2[i] = 0;
for (int j = chap[i]; j <= i; j++) {
if (ar[j] <= x) val[i]++;
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
dp[i][j] = dp[i - 1][j];
if (chap[i] != maxn) {
dp[i][j] = max(dp[i][j], val[i] + dp[chap[i] - 1][j - 1]);
}
}
if (dp[n][m] >= k) return 1;
return 0;
}
void bs() {
int l = 0, r = 1000000005, mid;
while (l + 1 < r) {
mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
if (r == 1000000005)
cout << -1 << endl;
else
cout << r << endl;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> s >> m >> k;
for (int i = 1; i <= n; i++) {
cin >> ar[i];
chap[i] = maxn, nxt[i] = -1;
}
for (int i = 1, l, r; i <= s; i++) {
cin >> l >> r;
for (int j = l; j <= r; j++) chap[j] = min(chap[j], l);
}
for (int i = 1; i <= n; i++) {
int c = maxn, t = 0;
for (int j = chap[i]; j < i; j++)
if (chap[j] < c) c = chap[j], t = j;
if (t != 0) nxt[i] = t;
}
bs();
}
| 11 | CPP |
a, b, c, d = list(map(int, input().split()))
if (a-1)//d < (c-1)//b:
print("No")
else:
print("Yes") | 0 | PYTHON3 |
stud=int(input())
l4=[0,0,0]
l2=[]
l3=[]
l1=[]
z=1
for x in map(int,input().split()):
if(x==1):
l1.append(z)
l4[0]+=1
elif(x==2):
l2.append(z)
l4[1]+=1
elif(x==3):
l3.append(z)
l4[2]+=1
z+=1
if(min(l4)==0):
print(0)
exit()
print(min(l4))
h=min(l4)-1
while(h>=0):
print(l1[h],l2[h],l3[h])
h-=1 | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
string toStr(int x) {
string ans = "";
while (x) {
ans.push_back('0' + (x & 1));
x >>= 1;
}
reverse(ans.begin(), ans.end());
return ans;
}
int borsz = 1;
int n;
int bor[1000000][2];
int kol[1000000], fl[1000000];
void dfs(int v, int num, int r, vector<int>& ans) {
if (kol[v] == 0) return;
int oldsz = ans.size();
int k = 0;
dfs(bor[v][0], num * 2, r, ans);
dfs(bor[v][1], num * 2 + 1, r, ans);
k = ans.size() - oldsz;
if (k == kol[v]) return;
if (num <= r) {
ans.push_back(num);
return;
}
return;
}
vector<int> getAns(int n, int r) {
vector<int> ans;
int nn = n;
dfs(1, 1, r, ans);
if (ans.size() != n || ans[0] < 0) return vector<int>();
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int a;
scanf("%d", &a);
string s = toStr(a);
int v = 0;
for (char cc : s) {
int c = cc - '0';
if (bor[v][c] == 0) bor[v][c] = borsz++;
v = bor[v][c];
}
kol[v]++;
fl[v] = 1;
}
for (int i = borsz; i > 0; --i) kol[i] += kol[bor[i][0]] + kol[bor[i][1]];
int l = n - 1;
int r = 1000000000;
while (l + 1 < r) {
int mid = (l + r) / 2;
vector<int> ans = getAns(n, mid);
if (ans.empty())
l = mid;
else
r = mid;
}
vector<int> ans = getAns(n, r);
for (int x : ans) cout << x << ' ';
cout << "\n";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if (n < k || (n != 1 && k == 1))
cout << -1;
else if (n == 1 && k == 1)
cout << 'a';
else {
char c[k];
for (int i = 0; i < k; i++) c[i] = 'a' + i;
char rpta[n];
for (int i = 0; i < n - k + 2; i++) {
if (i % 2 == 0)
rpta[i] = 'a';
else
rpta[i] = 'b';
}
int l = 2;
for (int i = n - k + 2; i < n; i++) {
rpta[i] = c[l];
l++;
}
for (int i = 0; i < n; i++) {
cout << rpta[i];
}
}
return 0;
}
| 9 | CPP |
import sys
input = sys.stdin.readline
nums = list(map(int, input().split()))
area = nums[0] * nums[1]
result = int((area - (area % 2))/2)
print(result)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, a[200005];
map<int, int> mp;
int temp, largest_num;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
mp[a[i]] = max(mp[a[i]], mp[a[i] - 1] + 1);
if (temp < mp[a[i]]) {
largest_num = a[i];
temp = mp[a[i]];
}
}
cout << temp << endl;
int start = largest_num - temp + 1;
for (int i = 0; i < n; i++) {
if (a[i] == start) {
cout << i + 1 << " ";
start++;
}
}
cout << endl;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int SNM[110000], Sz[110000];
int Snm(int v) {
if (v == SNM[v]) return v;
SNM[v] = Snm(SNM[v]);
return SNM[v];
}
void join(int f, int s) {
f = Snm(f), s = Snm(s);
if (Sz[f] < Sz[s])
SNM[f] = s, Sz[s] += Sz[f];
else
SNM[s] = f, Sz[f] += Sz[s];
}
int main() {
int res = 1, i, v1, v2, n, m;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) SNM[i] = i, Sz[i] = 1;
for (i = 0; i < m; i++) {
scanf("%d%d", &v1, &v2);
v1--, v2--;
v1 = Snm(v1), v2 = Snm(v2);
if (v1 == v2)
res *= 2, res %= (1000000009);
else
join(v1, v2);
printf("%d\n", (res + (1000000009) - 1) % (1000000009));
}
return 0;
}
| 9 | CPP |
from collections import Counter
n = int(input())
c = Counter(input()).values()
ans = 1
for i in c:
ans *= i+1
print((ans-1)%(10**9+7)) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxt = 5000;
const int maxn = 120;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
int n, R, p[maxn], a[maxn], b[maxn];
double f[51][maxt], l, r = 1e9;
bool check(double mid) {
for (int i = n - 1; i >= 0; i--) {
for (int j = R + 1; j < maxt; j++) f[i + 1][j] = mid;
for (int j = 0; j <= R; j++)
f[i][j] = min(mid, (f[i + 1][j + a[i]] + a[i]) * p[i] / 100 +
(f[i + 1][j + b[i]] + b[i]) * (100 - p[i]) / 100);
}
return mid > f[0][0];
}
int main() {
n = read(), R = read();
for (int i = 0; i < n; i++) a[i] = read(), b[i] = read(), p[i] = read();
double mid = (l + r) / 2;
for (int i = 1; i <= 100; i++, mid = (l + r) / 2)
(check(mid)) ? r = mid : l = mid;
printf("%.10f\n", l);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return f * x;
}
char s[100005];
int n;
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i <= n - 1; i++) s[2 * n - i - 1] = s[i];
printf("%s\n", s);
return 0;
}
| 7 | CPP |
import sys
input = sys.stdin.readline
t = int(input())
for ti in range(1, t + 1):
n = int(input())
res = []
base = 1
while n > 0:
while n > 0 and n % 10 == 0:
n //= 10
base *= 10
cur = n % 10 * base
n -= n % 10
#print(n)
res.append(cur)
print(len(res))
print(*res)
| 7 | PYTHON3 |
a=int(input())
b=int(-(-a//2))
print(b/a)
| 0 | PYTHON3 |
n = int(input())
for i in range(n):
l,r = list(map(int,input().split()))
print(l,2*l) | 7 | PYTHON3 |
n=int(input())
a=list(map(int,input().split()))
a.sort()
t=0
sm=sum(a)
while len(a) and int(sm/n+0.5)!=5:
sm+=(5-a[0])
a.pop(0)
t+=1
print(t)
'''
//////////////// ////// /////// // /////// // // //
//// // /// /// /// /// // /// /// //// //
//// //// /// /// /// /// // ///////// //// ///////
//// ///// /// /// /// /// // /// /// //// // //
////////////// /////////// /////////// ////// /// /// // // // //
'''
| 8 | PYTHON3 |
#include <algorithm>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int n, m, x;
vector<bool> used;
vector<long long> solved;
vector<pair<int, long long>> c;
vector<vector<pair<int, long long>>> p;
bool strict = false;
bool dfs2(int id, long long x) {
if (used[id]) {
if (solved[id] != x)
return false;
else
return true;
}
used[id] = true;
solved[id] = x;
if (solved[id] <= 0)
return false;
for (int i = 0; i < p[id].size(); i++) {
if (!dfs2(p[id][i].first, p[id][i].second - x))
return false;
}
return true;
}
bool dfs(int id, long long a, long long b) {
if (used[id]) {
if (c[id].first != a) {
strict = true;
x = (c[id].second - b) / (a - c[id].first);
return true;
} else {
if (c[id].second == b)
return false;
else
return true;
}
}
used[id] = true;
c[id].first = a;
c[id].second = b;
for (int i = 0; i < p[id].size(); i++) {
if (dfs(p[id][i].first, -a, p[id][i].second - b))
return true;
}
return false;
}
int main() {
cin >> n >> m;
c.resize(n);
used.resize(n);
solved.resize(n);
p.resize(n);
for (int i = 0; i < m; i++) {
int u, v, s;
cin >> u >> v >> s;
u--;
v--;
p[u].push_back(make_pair(v, s));
p[v].push_back(make_pair(u, s));
}
if (dfs(0, 1, 0)) {
used.clear();
used.resize(n);
if (strict && dfs2(0, x)) {
cout << 1 << endl;
} else {
cout << 0 << endl;
}
} else {
long long minX = 0, maxX = 10000000000000;
for (int i = 0; i < n; i++) {
if (c[i].first == 1)
minX = max(minX, -c[i].second + 1);
else
maxX = min(maxX, c[i].second - 1);
}
if (maxX - minX + 1 > 0)
cout << maxX - minX + 1 << endl;
else
cout << 0 << endl;
}
return 0;
}
| 0 | CPP |
n=int(input())
r = 0
for x in range(n):
p,q=list(map(int, input().split()))
if (q - p) >= 2:
r += 1
print (r) | 7 | PYTHON3 |
word=input().split("+")
word.sort()
for i in word[:-1]:
print(i,end="+")
print(word[-1])
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
map<char, int> fr;
int cnt = 0;
for (int i = 0; i < n; i++) {
fr[s[i]]++;
if (i & 1) {
if (fr['a'] != fr['b']) {
cnt++;
if (s[i] == 'b') {
s[i] = 'a';
fr['b']--;
fr['a']++;
} else {
s[i] = 'b';
fr['b']++;
fr['a']--;
}
}
}
}
cout << cnt << endl;
cout << s;
}
| 7 | CPP |
#include <bits/stdc++.h>
bool f[100001];
void Init() {
f[4] = f[7] = f[44] = f[47] = f[74] = f[77] = f[444] = f[447] = f[474] =
f[477] = f[744] = f[747] = f[774] = f[777] = f[4444] = f[4447] = f[4474] =
f[4477] = f[4744] = f[4747] = f[4774] = f[4777] = f[7444] = f[7447] =
f[7474] = f[7477] = f[7744] = f[7747] = f[7774] = f[7777] = true;
}
struct Tree {
int d[1000000], M;
void Build(int n) {
for (M = 1; M <= n + 1; M <<= 1)
;
memset(d, 0, sizeof(d));
}
void Add(int x, int v) {
d[x + M] += v;
for (int i = x + M >> 1; i; i >>= 1) d[i] = d[i << 1] + d[i << 1 | 1];
}
int Query(int l, int r) {
int ret = 0;
for (l += M - 1, r += M + 1; l ^ r ^ 1; l >>= 1, r >>= 1) {
if (~l & 1) ret += d[l ^ 1];
if (r & 1) ret += d[r ^ 1];
}
return ret;
}
} tr;
int a[100001];
int main() {
Init();
int n, m;
scanf("%d%d", &n, &m);
tr.Build(n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (f[a[i]]) tr.Add(i, 1);
}
while (m--) {
char s[10];
scanf("%s", s);
if (s[0] == 'a') {
int l, r, d;
scanf("%d%d%d", &l, &r, &d);
for (int i = l; i <= r; i++) {
if (f[a[i]]) tr.Add(i, -1);
a[i] += d;
if (f[a[i]]) tr.Add(i, 1);
}
} else if (s[0] = 'c') {
int l, r;
scanf("%d%d", &l, &r);
printf("%d\n", tr.Query(l, r));
}
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
#define mod 1000000007
#define ll long long
using namespace std;
int main(){
int i,j,n; cin>>n;
ll f[n+1],b[n+1];
f[0]=1;
for(i=1;i<=n;i++){
f[i]=(i*f[i-1])%mod;
}
b[n]=n;
for(i=n;i>0;i--){
b[i-1]=((i-1)*b[i])%mod;
}
ll temp[n+1];
temp[1]=f[n];
for(i=2;i<=n;i++){
temp[i]=temp[i-1];
ll t=f[i-1];
if(i+1<=n) t*=b[i+1];
t%=mod;
temp[i]+=t; temp[i]%=mod;
}
ll ans=0,sum=0;
ll a[n+1];
for(i=1;i<=n;i++){
scanf("%lld",a+i);
sum+=a[i]; sum%=mod;
ans+=a[i]*temp[i]; ans%=mod;
ans+=a[i]*temp[n+1-i]; ans%=mod;
}
ans-=sum*f[n]; ans%=mod;
ans+=mod; ans%=mod;
cout<<ans<<endl;
return 0;
} | 0 | CPP |
R=lambda:map(int,input().split())
t,=R()
for _ in[0]*t:
n,x=R();i=s=0
for y in sorted(R())[::-1]:
s+=y
if s<i*x+x:break
i+=1
print(i)
#JSR
| 8 | PYTHON3 |
t = int(input())
for _ in range(t):
n = int(input())
val = 4 * n
for i in range(n):
print(val, end=" ")
val -= 2
print()
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long int n, l, r, s, mid, Ti;
bool flag = 0;
long long int sumDigit(long long int x) {
long long int ans = 0;
while (x) ans += x % 10, x /= 10;
return ans;
}
int main() {
cin >> n >> s;
l = 1, r = n;
while (l <= r) {
mid = (l + r) / 2;
if (mid - sumDigit(mid) >= s) {
Ti = mid;
flag = 1;
r = mid - 1;
} else
l = mid + 1;
}
if (flag)
cout << n - Ti + 1 << endl;
else
cout << 0 << endl;
return 0;
}
| 9 | CPP |
from collections import defaultdict as dd
from sys import stdin, stdout
I=stdin.readline
P=stdout.write
for _ in range(int(I())):
n=int(I())
a=[int(i) for i in I().split()]
d=dd(int)
for i in a: d[i]+=1
d=sorted(d.values(),reverse=1)
l,c=[],0
for i in d:
if l==[]:
l+=[i]
c+=i
else:
if l[-1]<=0: continue
c+=min(l[-1]-1,i)
l+=[min(l[-1]-1,i)]
P(str(c)+'\n')
| 10 | PYTHON3 |
a=input()
for i in a:
if i not in ["A","E","I","O","U","a","e","i","o","u","Y","y"]:
i=i.lower()
print(".{}".format(i),end='') | 7 | PYTHON3 |
for i in range(int(input())):
x = [int(x) for x in input().split()]
if abs(x[0] - x[1]) > 1:
print('YES')
else:
print('NO') | 7 | PYTHON3 |
n=int(input())
num=2*(n//2) + 1
ans=[]
for i in range(1,n+1):
for j in range(i+1,n+1):
if i+j!=num:
ans.append([i,j])
print(len(ans))
for a in ans:
print(a[0],a[1]) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
string s;
int N;
int c;
int p[3];
ll expr();
ll term1();
ll term2();
ll factor();
ll num();
void debug(string text){
return;
cout << text + " ";
for(int i = 0; i < N; i++){
if(i == c) cout << '[' << s[i] << ']';
else cout << s[i];
}
cout << endl;
}
ll expr(){
debug("expr");
ll x = term1();
while(c < N){
if(s[c] == '+' && p[0] == 0){
c++;
x += term1();
}
else if(s[c] == '-' && p[1] == 0){
c++;
x -= term1();
}
else if(s[c] == '*' && p[2] == 0){
c++;
x *= term1();
}
else break;
}
return x;
}
ll term1(){
debug("term1");
ll x = term2();
while(c < N){
if(s[c] == '+' && p[0] == 1){
c++;
x += term2();
}
else if(s[c] == '-' && p[1] == 1){
c++;
x -= term2();
}
else if(s[c] == '*' && p[2] == 1){
c++;
x *= term2();
}
else break;
}
return x;
}
ll term2(){
debug("term2");
ll x = factor();
while(c < N){
if(s[c] == '+' && p[0] == 2){
c++;
x += factor();
}
else if(s[c] == '-' && p[1] == 2){
c++;
x -= factor();
}
else if(s[c] == '*' && p[2] == 2){
c++;
x *= factor();
}
else break;
}
return x;
}
ll factor(){
debug("factor");
if(s[c] == '('){
c++;
ll ret = expr();
assert(s[c] == ')');
c++;
return ret;
}
return num();
}
ll num(){
debug("num");
ll ret = 0;
while(c < N && isdigit(s[c])){
ret = ret * 10 + s[c] - '0';
c++;
}
return ret;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
#ifdef LOCAL
std::ifstream in("in");
std::cin.rdbuf(in.rdbuf());
#endif
cin >> s;
N = s.size();
ll ans = LLONG_MIN;
for(int i = 0; i < 3; i++){
for(int j = 0; j < 3; j++){
for(int k = 0; k < 3; k++){
p[0] = i, p[1] = j, p[2] = k;
c = 0;
ans = max(ans, expr());
}
}
}
cout << ans << endl;
} | 0 | CPP |
x = 0
y = 0
z = 0
n = int(input())
for i in range(n):
a,b,c = map(int,input().split())
x += a
y += b
z += c
if x==0 and y==0 and z==0:
print("YES")
else:
print("NO") | 7 | PYTHON3 |
t = int(input())
for tt in range(t):
n, k = map(int, input().split())
a = sorted([int(i) for i in input().split()])
b = sorted([int(i) for i in input().split()])
i = 0
total = sum(a)
while k and a[i] < b[n-i-1]:
total += b[n-i-1] - a[i]
k -= 1
i += 1
print(total)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const long long MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int a, b, n;
cin >> a >> b >> n;
for (int i = -1000; i < 1001; i++) {
if (pow(i, n) * a == b) {
cout << i;
return 0;
}
}
cout << "No solution";
return 0;
}
| 7 | CPP |
n = int(input())
l = list(map(int, input().split()))
ans = 0
for i in range(len(l) - 2):
if l[i] == 1 and l[i + 1] == 0 and l[i + 2] == 1:
l[i + 2] = 0
ans += 1
print(ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int deg[100001];
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
deg[x]++;
deg[y]++;
}
for (int i = 0; i <= n; i++) {
if (deg[i] == 2) {
cout << "NO\n";
return 0;
}
}
cout << "YES\n";
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 1000;
const int mod = 998244353;
int n;
long long qpow(long long n, long long m) {
long long ans = 1;
while (m) {
if (m & 1) ans = ans * n % mod;
n = n * n % mod;
m >>= 1;
}
return ans;
}
long long inv(long long n) { return qpow(n, mod - 2); }
long long dp[N], s[N], rs[N];
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = (1); i <= (n); i++) {
cin >> s[i];
rs[i] = (100 - s[i]) * inv(100) % mod;
s[i] = s[i] * inv(100) % mod;
}
long long sum = 0;
dp[1] = inv(s[1]);
sum = dp[1];
for (int i = (2); i <= (n); i++) {
dp[i] = (s[i] + (rs[i] * (sum + 1)) % mod) * inv(s[i]) % mod;
sum += dp[i];
sum %= mod;
}
cout << sum;
return 0;
}
| 11 | CPP |
#include<stdio.h>
#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<string.h>
using namespace std;
typedef long long LL;
typedef vector<int> VI;
#define REP(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define EACH(i,c) for(__typeof((c).begin()) i=(c).begin(),i##_end=(c).end();i!=i##_end;++i)
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
template<class T> inline void amin(T &x, const T &y) { if (y<x) x=y; }
template<class T> inline void amax(T &x, const T &y) { if (x<y) x=y; }
template<class Iter> void rprintf(const char *fmt, Iter begin, Iter end) {
for (bool sp=0; begin!=end; ++begin) { if (sp) putchar(' '); else sp = true; printf(fmt, *begin); }
putchar('\n');
}
template<unsigned MOD_> struct ModInt {
static const unsigned MOD = MOD_;
unsigned x;
void undef() { x = (unsigned)-1; }
bool isnan() const { return x == (unsigned)-1; }
inline int geti() const { return (int)x; }
ModInt() { x = 0; }
ModInt(const ModInt &y) { x = y.x; }
ModInt(int y) { if (y<0 || (int)MOD<=y) y %= (int)MOD; if (y<0) y += MOD; x=y; }
ModInt(unsigned y) { if (MOD<=y) x = y % MOD; else x = y; }
ModInt(long long y) { if (y<0 || MOD<=y) y %= MOD; if (y<0) y += MOD; x=y; }
ModInt(unsigned long long y) { if (MOD<=y) x = y % MOD; else x = y; }
ModInt &operator+=(const ModInt y) { if ((x += y.x) >= MOD) x -= MOD; return *this; }
ModInt &operator-=(const ModInt y) { if ((x -= y.x) & (1u<<31)) x += MOD; return *this; }
ModInt &operator*=(const ModInt y) { x = (unsigned long long)x * y.x % MOD; return *this; }
ModInt &operator/=(const ModInt y) { x = (unsigned long long)x * y.inv().x % MOD; return *this; }
ModInt operator-() const { return (x ? MOD-x: 0); }
ModInt inv() const { return pow(MOD-2); }
ModInt pow(long long y) const {
ModInt b = *this, r = 1;
if (y < 0) { b = b.inv(); y = -y; }
for (; y; y>>=1) {
if (y&1) r *= b;
b *= b;
}
return r;
}
ModInt extgcd() const {
unsigned a = MOD, b = x; int u = 0, v = 1;
while (b) {
int t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
if (u < 0) u += MOD;
return ModInt(u);
}
friend ModInt operator+(ModInt x, const ModInt y) { return x += y; }
friend ModInt operator-(ModInt x, const ModInt y) { return x -= y; }
friend ModInt operator*(ModInt x, const ModInt y) { return x *= y; }
friend ModInt operator/(ModInt x, const ModInt y) { return x *= y.inv(); }
friend bool operator<(const ModInt x, const ModInt y) { return x.x < y.x; }
friend bool operator==(const ModInt x, const ModInt y) { return x.x == y.x; }
friend bool operator!=(const ModInt x, const ModInt y) { return x.x != y.x; }
};
const LL MOD = 998244353;
typedef ModInt<MOD> Mint;
Mint fact(int n) {
Mint r = 1;
REP (i, n) r *= i+1;
return r;
}
int N;
int A[300011];
int B[300011];
int buf[300011];
int L[300011], R[300011];
int C[300011];
int POS[300011];
int put[300011];
int step;
Mint calc() {
int prv = A[N-1];
REP (i, N) {
if (prv != A[i]) {
if (L[A[i]]) return 0;
POS[A[i]] = i;
L[A[i]] = prv;
R[prv] = A[i];
}
prv = A[i];
}
Mint ans = 1;
B[N] = 1;
int fr = 0;
for (int i=1; i<=N; i++) {
//printf("# %d %d (%d %d)\n", i, fr, L[i], R[i]);
const int pos = POS[i];
if (C[i] == 0) {
ans *= fr;
fr--;
} else if (L[i] > i) {
put[i] = pos;
REP (t, step) {
if (B[pos+t]) {
if (t != C[i]) return 0;
break;
} else if (t > C[i]) {
return 0;
}
B[pos+t] = i;
}
if (R[i] < i) fr += (R[i]!=1? put[R[i]]: N) - put[i] - 1;
} else if (i < R[i]) {
put[i] = pos+C[i]-step;
REP (t, step) {
if (B[pos+C[i]-1-t]) {
if (t != C[i]) return 0;
break;
} else if (t > C[i]) {
return 0;
}
B[pos+C[i]-1-t] = i;
}
if (L[i] < i) fr += put[i] - put[L[i]] - 1;
} else {
REP (t, step) {
if (B[pos+t]) {
if (t != C[i]) return 0;
break;
} else if (t > C[i]) {
return 0;
}
B[pos+t] = i;
}
ans *= step - C[i] + 1;
fr += (R[i]!=1? put[R[i]]: N) - put[L[i]] - 2;
}
}
return ans;
}
void MAIN() {
scanf("%d", &N);
REP (i, N) scanf("%d", A+i);
Mint ans = 0;
int prv = A[N-1];
int pos = -1;
REP (i, N) {
if (A[i] == 1 && prv != 1) {
pos = i;
break;
}
prv = A[i];
}
if (*max_element(A, A+N) == 1) {
ans = fact(N);
} else if (pos == -1) {
ans = 0;
} else {
REP (i, N) {
buf[i] = A[(i+pos)%N];
}
REP (i, N) A[i] = buf[i];
/// rprintf("%d", A, A+N);
REP (i, N) C[A[i]]++;
step = C[1];
if (step < *max_element(C, C+N+1)) {
ans = 0;
} else {
ans = calc();
}
}
printf("%d\n", ans.geti());
}
int main() {
int TC = 1;
// scanf("%d", &TC);
REP (tc, TC) MAIN();
return 0;
}
| 0 | CPP |
#include<bits/stdc++.h>
using namespace std;
int w,d;
int h1[10],h2[10];
bool f[10];
int main(){
while(cin>>w>>d,w||d){
fill_n(f,10,false);
for(int i=0;i<w;i++)cin>>h1[i];
for(int i=0;i<d;i++)cin>>h2[i];
int ans=0;
for(int i=0;i<w;i++){
for(int j=0;j<d;j++){
if(!f[j]&&h1[i]==h2[j]){
f[j]=true;
break;
}
}
ans+=h1[i];
}
for(int i=0;i<d;i++)if(!f[i])ans+=h2[i];
cout<<ans<<endl;
}
return 0;
} | 0 | CPP |
a,b=map(int,input().split())
a,b=min(a,b),max(a,b)
cnt=0
while(min(a,b) and max(a,b)>1):
a+=1
b-=2
a,b=min(a,b),max(a,b)
cnt+=1
print(cnt)
| 7 | PYTHON3 |
N,M=map(int,input().split())
wa=[0]*N
pen=[0]*N
ac=[0]*N
for x in range(M):
P,S=input().split()
if S=="WA" and ac[int(P)-1]==0:
wa[int(P)-1] += 1
elif S=="AC" and ac[int(P)-1]==0:
ac[int(P)-1] += 1
pen[int(P)-1] = wa[int(P)-1]
print(f"{sum(ac)} {sum(pen)}") | 0 | PYTHON3 |
number_of_children=int(input())
x=list(map(int,input().split()))
child_is_good_at_programing=[]
child_is_good_at_maths=[]
child_is_good_at_PE=[]
for i in range(number_of_children):
if (x[i]==1):
child_is_good_at_programing.append(i+1)
elif (x[i]==2):
child_is_good_at_maths.append(i+1)
elif (x[i]==3):
child_is_good_at_PE.append(i+1)
number_of_grops=min(len(child_is_good_at_programing),len(child_is_good_at_maths),len(child_is_good_at_PE))
print(number_of_grops)
for i in range(number_of_grops):
print(child_is_good_at_programing[i],child_is_good_at_maths[i],child_is_good_at_PE[i]) | 7 | PYTHON3 |
def romaji(palavra, vowels, tam):
if palavra[-1] not in vowels and palavra[-1] != 'n':
return 'NO'
p1 = 0
p2 = 1
while p2 < tam:
if palavra[p1] not in vowels and palavra[p1] != 'n':
if palavra[p2] not in vowels:
return 'NO'
p1 += 1
p2 += 1
return 'YES'
palavra = input()
vowels = ['a', 'e', 'i', 'o', 'u']
tam = len(palavra)
print(romaji(palavra, vowels, tam))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
vector<int> b(n-1);
for(int i=0;i<n-1;i++)cin>>b[i];
int ans=b[0]+b[n-2];
for(int i=1;i<n-1;i++)ans+=min(b[i],b[i-1]);
cout<<ans<<endl;
return 0;
} | 0 | CPP |
n,m=[int(x) for x in input().split()]
if(n!=0):
a=list(map(int,input().split()))
if(m!=0 and n!=0):
b=list(map(int,input().split()))
ans=[]
for i in a:
if i in b:
ans.append(i)
print(" ".join(str(e) for e in ans))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void func(string &s) {
int cpt = 0, aux = s.size(), posc;
if (s.find('a') == string::npos or s.find('b') == string::npos or
s.find('c') == string::npos) {
cout << s << endl;
return;
}
for (int i = 0; i < aux; i++) {
if (s[i] == 'b') cpt++;
if (s[i] == 'c') posc = i;
}
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'b')
continue;
else if (i == posc) {
cout << 'c';
for (int j = 0; j < cpt; j++) cout << 'b';
} else
cout << s[i];
}
cout << endl;
}
int main() {
int tc;
cin >> tc;
while (tc--) {
string a, b;
cin >> a >> b;
sort(a.begin(), a.end());
if (b == "abc")
func(a);
else
cout << a << endl;
}
}
| 7 | CPP |
def next(c):
return chr(97+(ord(c)-96)%26)
s=list(input())
t=list(input())
for i in range(len(s)-1,-1,-1):
if s[i]=='z':
s[i]=next(s[i])
else:
s[i]=next(s[i])
break
if t>s: print(''.join(s))
else: print('No such string')
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> m;
int main() {
int n;
long long num, cur, ans = 0;
while (cin >> n) {
m.clear();
cur = 0;
ans = 0;
for (int i = 0; i < n; ++i) {
cin >> num;
cur += num;
ans = max(ans, ++m[cur]);
}
cout << n - ans << endl;
}
return 0;
}
| 9 | CPP |
#!/usr/bin/env python3
# 00:45 start
import bisect
n = input()
worms = [0]
for w in map(int, input().split()):
worms.append(worms[-1] + w)
nq = input()
for q in map(int, input().split()):
print(bisect.bisect_left(worms, q))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MOD = 1e9 + 7;
ll dp[10001][101][2];
int D;
string k;
ll solve(int i, int sum, int f)
{
if (i == k.size())
return sum % D == 0;
if (dp[i][sum % D][f] != -1)
return dp[i][sum % D][f];
ll ans = 0;
for (int d = 0; d <= (f ? k[i] - '0' : 9); d++)
ans = (ans + solve(i + 1, sum + d, f && d == (k[i] - '0'))) % MOD;
return dp[i][sum % D][f] = ans;
}
int main()
{
cin >> k >> D;
memset(dp, -1, sizeof(dp));
cout << (solve(0, 0, 1) - 1 + MOD) % MOD << endl;
return 0;
}
| 0 | CPP |
n = int(input())
a = input()
ns = []
prime = [2, 3, 5 ,7]
for i in a:
m = int(i)
if m in prime: ns.append(m)
elif m == 4: ns += [3, 2, 2]
elif m == 6: ns += [5, 3]
elif m == 8: ns += [7, 2, 2, 2]
elif m == 9: ns += [7, 2, 3, 3]
ns.sort()
for i in range(len(ns) - 1, -1, -1): print(ns[i], end = '') | 9 | PYTHON3 |
#https://codeforces.com/problemset/problem/1023/A
x, y = input().split()
n, m = int(x), int(y)
s = input()
t = input()
if '*' not in s and s != t:
print("NO")
elif '*' not in s and s==t:
print("YES")
elif len(s) > len(t) + 1:
print("NO")
elif s == "*":
print("YES")
else:
ok = True
i = 0
while s[i] != '*':
if s[i] != t[i]:
print("NO")
ok = False
break
i += 1
j,k=len(t)-1,len(s)-1
while s[k] != '*' and ok:
if s[k] != t[j]:
ok = False
print("NO")
break
k -= 1
j -= 1
if ok:
print("YES") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using std::bitset;
using std::cin;
using std::cout;
using std::endl;
using std::make_pair;
using std::map;
using std::pair;
using std::priority_queue;
using std::queue;
using std::set;
using std::string;
using std::stringstream;
using std::vector;
class MyTimer {
public:
void reset() {}
void report() {}
} myTimer;
template <typename A, typename B>
std::ostream &operator<<(std::ostream &cout, const pair<A, B> &x) {
return cout << "(" << x.first << ", " << x.second << ")";
}
template <typename T1, typename T2>
inline bool chmin(T1 &a, const T2 &b) {
return a > b ? a = b, true : false;
}
template <typename T1, typename T2>
inline bool chmax(T1 &a, const T2 &b) {
return a < b ? a = b, true : false;
}
const int maxN = 100000 + 233;
long long gcd(long long x, long long y) { return y == 0 ? x : gcd(y, x % y); }
long long solve(long long n, long long k, long long l) {
if (l == 0) l += k;
long long prod = n * (long long)k;
return prod / gcd(prod, l);
}
int main() {
std::ios::sync_with_stdio(false);
long long n, k, a, b;
cin >> n >> k >> a >> b;
if (a > b) std::swap(a, b);
long long mn = maxN * (long long)maxN;
long long mx = -1;
for (int i = 1; i <= n; ++i) {
long long x = solve(n, k, k - a - b + (i - 1) * k);
long long y = solve(n, k, b - a + (i - 1) * k);
long long z = solve(n, k, a + k - b + (i - 1) * k);
long long w = solve(n, k, a + b + (i - 1) * k);
chmin(mn, std::min({x, y, z, w}));
chmax(mx, std::max({x, y, z, w}));
}
cout << mn << " " << mx << endl;
return 0;
}
| 7 | CPP |
x = [int(i) for i in list(input().split())]
xp = x[0]
nb = x[1]
j=0
while(nb>0 and xp >0):
if (xp >0 and nb>=2*xp):
j+=xp
xp = 0
elif nb>0 and xp>1:
j+=1
xp-=2
nb-=1
else:
nb = 0
print(j) | 9 | PYTHON3 |
n,k = map(int, input().split())
a = []
b = []
comman = []
a_ = []
b_ = []
for _ in range(n):
t,ai,bi = map(int, input().split())
a_.append(ai)
b_.append(bi)
if ai == 1 and bi == 1:
comman.append(t)
elif ai == 1:
a.append(t)
elif bi == 1:
b.append(t)
a.sort()
b.sort()
#comman.sort()
if a_.count(1) < k or b_.count(1) < k:
print(-1)
else:
s = 0
m = min(len(a),len(b))
for i in range(m):
comman.append(a[i]+b[i])
comman.sort()
print(sum(comman[:k]))
| 11 | PYTHON3 |
# http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ITP2_7_B&lang=jp
# Set: Delete: python3
# 2018.12.02 yonezawa
import sys
input = sys.stdin.readline
import collections
def main():
tl = {}
for i in range(int(input())):
l = list(map(int,input().split()))
#insert
cmd = l[0]
if cmd == 0:
tl[l[1]] = 1
print (len(tl))
#find
elif cmd == 1:
c = 1 if l[1] in tl else 0
print (c)
#delete
elif cmd == 2:
d = l[1]
try:
tl.pop(d)
except KeyError:
None
if __name__ == '__main__':
main()
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, c = 0, c1 = 0, c2 = 0, d, e, f = 0, g, h, i, j, k, l, m, n;
cin >> n >> m;
string s, s1, s2;
cin >> s;
s1 = s;
s2 = s;
for (i = 0; i < s.size(); i++) {
if (s[i] == '.') {
s1[i] = '0';
s2[i] = '1';
}
}
for (i = 0, j = m; i < m && j < n; i++, j++) {
if (s[i] == s[j] && s[i] != '.' && s1[j] != '.') {
c++;
}
}
if (c == (n - m)) {
cout << "No" << endl;
return 0;
}
for (i = 0, j = m; i < m && j < n; i++, j++) {
if (s1[i] == s1[j] && s[i] == '.') {
if (s1[i] == '0') {
s1[i] = '1';
f = 1;
} else if (s1[i] == '1') {
s1[i] = '0';
f = 1;
}
} else if (s1[i] == s1[j] && s[j] == '.') {
if (s1[j] == '0') {
s1[j] = '1';
f = 1;
} else if (s1[j] == '1') {
s1[j] = '0';
f = 1;
}
}
if (s1[i] == '0') {
c1++;
}
if (s1[j] == '0') {
c1++;
}
if (s1[i] == '1') {
c2++;
}
if (s1[j] == '1') {
c2++;
}
}
if (f == 0 && ((n - m) > m)) {
for (i = (n - m); i < n; i++) {
if (s1[i] == '0' && s[i] == '.' && c1 == (n - m)) {
s1[i] = '1';
f = 1;
break;
} else if (s1[i] == '1' && s[i] == '.' && c1 == (n - m)) {
s1[i] = '0';
f = 1;
break;
}
}
}
cout << s1 << endl;
}
| 8 | CPP |
## necessary imports
import sys
input = sys.stdin.readline
from math import ceil, floor, factorial;
# swap_array function
def swaparr(arr, a,b):
temp = arr[a];
arr[a] = arr[b];
arr[b] = temp
## gcd function
def gcd(a,b):
if a == 0:
return b
return gcd(b%a, a)
## nCr function efficient using Binomial Cofficient
def nCr(n, k):
if(k > n - k):
k = n - k
res = 1
for i in range(k):
res = res * (n - i)
res = res / (i + 1)
return int(res)
## upper bound function code -- such that e in a[:i] e < x;
def upper_bound(a, x, lo=0):
hi = len(a)
while lo < hi:
mid = (lo+hi)//2
if a[mid] < x:
lo = mid+1
else:
hi = mid
return lo
## prime factorization
def primefs(n):
## if n == 1 ## calculating primes
primes = {}
while(n%2 == 0):
primes[2] = primes.get(2, 0) + 1
n = n//2
for i in range(3, int(n**0.5)+2, 2):
while(n%i == 0):
primes[i] = primes.get(i, 0) + 1
n = n//i
if n > 2:
primes[n] = primes.get(n, 0) + 1
## prime factoriazation of n is stored in dictionary
## primes and can be accesed. O(sqrt n)
return primes
## MODULAR EXPONENTIATION FUNCTION
def power(x, y, p):
res = 1
x = x % p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) :
res = (res * x) % p
y = y >> 1
x = (x * x) % p
return res
## DISJOINT SET UNINON FUNCTIONS
def swap(a,b):
temp = a
a = b
b = temp
return a,b
# find function with path compression included (recursive)
# def find(x, link):
# if link[x] == x:
# return x
# link[x] = find(link[x], link);
# return link[x];
# find function with path compression (ITERATIVE)
def find(x, link):
p = x;
while( p != link[p]):
p = link[p];
while( x != p):
nex = link[x];
link[x] = p;
x = nex;
return p;
# the union function which makes union(x,y)
# of two nodes x and y
def union(x, y, link, size):
x = find(x, link)
y = find(y, link)
if size[x] < size[y]:
x,y = swap(x,y)
if x != y:
size[x] += size[y]
link[y] = x
## returns an array of boolean if primes or not USING SIEVE OF ERATOSTHANES
def sieve(n):
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
return prime
#### PRIME FACTORIZATION IN O(log n) using Sieve ####
MAXN = int(1e6 + 5)
def spf_sieve():
spf[1] = 1;
for i in range(2, MAXN):
spf[i] = i;
for i in range(4, MAXN, 2):
spf[i] = 2;
for i in range(3, ceil(MAXN ** 0.5), 2):
if spf[i] == i:
for j in range(i*i, MAXN, i):
if spf[j] == j:
spf[j] = i;
## function for storing smallest prime factors (spf) in the array
################## un-comment below 2 lines when using factorization #################
# spf = [0 for i in range(MAXN)]
# spf_sieve()
def factoriazation(x):
ret = {};
while x != 1:
ret[spf[x]] = ret.get(spf[x], 0) + 1;
x = x//spf[x]
return ret
## this function is useful for multiple queries only, o/w use
## primefs function above. complexity O(log n)
## taking integer array input
def int_array():
return list(map(int, input().strip().split()))
## taking string array input
def str_array():
return input().strip().split();
#defining a couple constants
MOD = int(1e9)+7;
CMOD = 998244353;
INF = float('inf'); NINF = -float('inf');
################### ---------------- TEMPLATE ENDS HERE ---------------- ###################
n = int(input()); a = int_array();
ans = []; s = sum(a);
for i in range(n):
a[i] = (a[i], i);
a.sort();
for i in range(n-1, -1, -1):
k = s - a[i][0];
if i == n - 1:
k -= a[n-2][0];
if k == a[n-2][0]:
ans.append(a[i][1]+1);
else:
k -= a[-1][0];
if k == a[-1][0]:
ans.append(a[i][1] + 1);
print(len(ans));
print(*ans); | 9 | PYTHON3 |
# A = "b"
# B = ["aabbb"]
# dic = {}
# for i in B:
# dic[i] = 1
# ans = []
# def fun(start, n,ans, v, length):
# if length==n:
# ans+=[v[:-1]]
# for i in range(start, n):
# for j in range(start+1,n+1):
# try:
# if dic[A[i:j]]==1:
# fun(j,n,ans,v+A[i:j]+' ', length+len(A[i:j]))
# except:
# continue
# fun(0,len(A),ans, '', 0)
# ans.sort()
#Question 3
# arr = [1,1,2]
for _ in range(int(input())):
n = int(input())
for i in range(1,n+1):
print(i,end=" ") | 7 | PYTHON3 |
a = int(input())
b = input()
c = [b.count('1'), b.count('0')]
d = min(c)
print(a - d * 2)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, x, y;
cin >> n >> x >> y;
vector<int> bob(n + 1), alice(n + 1, -1);
vector<int> freq(n + 2, 0);
for (int i = 1; i <= n; i++) {
cin >> bob[i];
freq[bob[i]]++;
}
if (x == n) {
cout << "YES\n";
for (int i = 1; i <= n; i++) cout << bob[i] << " ";
cout << '\n';
continue;
}
int notPresent;
vector<pair<int, int> > st;
for (int i = 1; i <= n + 1; i++) {
if (freq[i] == 0) {
notPresent = i;
} else {
st.push_back(make_pair(freq[i], i));
}
}
sort(st.begin(), st.end(), greater<pair<int, int> >());
int rem = n;
int cap = 0;
vector<pair<int, int> > final;
for (int i = st.size() - 1; i >= 0; i--) {
if (rem - st[i].first * (i + 1) > x) {
rem = rem - st[i].first;
final.push_back(st[i]);
cap = st[i].first;
} else {
if ((rem - x) % (i + 1) == 0) {
int tt = (rem - x) / (i + 1);
for (int j = i; j >= 0; j--) {
final.push_back(make_pair(tt, st[j].second));
}
} else {
int tt = (rem - x) / (i + 1);
int extra = (rem - x) % (i + 1);
int counter = 1;
for (int j = 0; j <= i; j++) {
if (counter <= extra) {
final.push_back(make_pair(tt + 1, st[j].second));
counter++;
} else {
final.push_back(make_pair(tt, st[j].second));
}
}
}
break;
}
}
sort(final.begin(), final.end(), greater<pair<int, int> >());
int flag = 0;
vector<int> color[n + 2];
vector<pair<int, int> > tst;
for (int i = 1; i <= n; i++) {
color[bob[i]].push_back(i);
}
set<int> storeInd;
storeInd.clear();
for (int i = 0; i < final.size(); i++) {
for (int j = 0; j < final[i].first; j++) {
tst.push_back(make_pair(final[i].second, color[final[i].second][j]));
storeInd.insert(color[final[i].second][j]);
}
}
int sz = tst.size();
for (int i = 0; i < y - x; i++) {
if (tst[sz - 1 - i].first ==
tst[(-final[0].first + 2 * sz - 1 - i) % sz].first) {
flag = 1;
break;
}
alice[tst[(-final[0].first + 2 * sz - 1 - i) % sz].second] =
tst[sz - 1 - i].first;
storeInd.erase(tst[(-final[0].first + 2 * sz - 1 - i) % sz].second);
}
for (int i = 1; i <= n; i++) {
if (storeInd.find(i) != storeInd.end()) {
alice[i] = notPresent;
} else if (alice[i] == -1) {
alice[i] = bob[i];
}
}
if (flag == 1) {
cout << "NO\n";
} else {
cout << "YES\n";
for (int i = 1; i <= n; i++) cout << alice[i] << " ";
cout << '\n';
}
}
}
| 11 | CPP |
b, k = map(int, input().split())
a = list(map(int, input().split()))
total = 0
for i in range(k):
total += a[i] * pow(b, k - i - 1, 2)
if total % 2 == 0:
print('even')
else:
print('odd') | 7 | PYTHON3 |
N=int(input())
A=list(map(int,input().split()))
A=[(A[i],i) for i in range(0,N)]
A.sort(reverse=True)
dp=[[0 for i in range(0,N)] for j in range(0,N)]
for i in range(0,N-1):
a,index=A[-1]
dp[N-1][i]=a*abs(index-i)
for _ in range(1,N):
i=N-1-_
for j in range(0,i+1):
left=j
right=i-j
a,index=A[i]
ans=0
if index>left-1:
ans=max(ans,dp[i+1][j+1]+a*(index-left))
if N-right>index:
ans=max(ans,dp[i+1][j]+a*(N-right-1-index))
dp[i][j]=ans
print(dp[0][0]) | 0 | PYTHON3 |
a, b = input(), input()
for i in range(len(a)):
print(0 if a[i] == b[i] else 1, end = '') | 7 | PYTHON3 |
m=int(input())
for i in range(m):
n=int(input())
a=list(map(int,input().split()))
d=set(a)
print(len(d)) | 8 | PYTHON3 |
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
const int INF = 1001001001;
int main() {
int h, n; cin >> h >> n;
vector<int>dp(h + 1, INF);
dp[0] = 0;
for (int i = 0; i < n; i++) {
int a, b; cin >> a >> b;
for (int j = 0; j < h; j++) {
int nj = min(j + a, h);
dp[nj] = min(dp[nj], dp[j] + b);
}
}
cout << dp[h] << endl;
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> p(n + 1, 0);
for (int i = 1; i <= n; ++i) {
cin >> p[i];
}
bitset<1002> visited;
for (int i = 1; i <= n; ++i) {
visited.reset();
int a = i;
while (!visited[a]) {
visited[a] = true;
a = p[a];
}
if (i > 1) {
cout << ' ';
}
cout << a;
}
cout << '\n';
}
| 8 | CPP |
a,b=map(int,input().split())
if b==a or b==1:
if b==1:
print(1)
else:
if a%2==0:
print(b)
else:
print(b-1)
else:
if a%2==0:
if b<=(a/2):
print(b+b-1)
else:
print(int((b-a/2)*2))
else:
if b<=(a//2+1):
print(b+b-1)
else:
print(int((b-a//2-1)*2))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (1e6) + 7;
const int inf = (1e9) + 7;
const long long LLinf = (1e18) + 7;
const long double eps = 1e-9;
const long long mod = 1e9 + 7;
const int maxlog = 31;
stack<pair<int, int> > stos;
int tab[maxn];
int lewo[maxn];
int prawo[maxn];
int le[maxn][maxlog];
int pr[maxn][maxlog];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i < n + 1; i++) {
cin >> tab[i];
while (((int)(stos).size()) && stos.top().first < tab[i]) stos.pop();
if (((int)(stos).size())) lewo[i] = stos.top().second;
stos.push({tab[i], i});
}
while (((int)(stos).size())) stos.pop();
for (int i = n; i > 0; i--) {
while (((int)(stos).size()) && stos.top().first <= tab[i]) stos.pop();
if (((int)(stos).size()))
prawo[i] = stos.top().second;
else
prawo[i] = n + 1;
stos.push({tab[i], i});
}
for (int bit = 0; bit < maxlog; bit++) {
int curr = 0;
for (int i = 1; i < n + 1; i++) {
if (tab[i] & (1 << bit)) curr = i;
le[i][bit] = curr;
}
curr = n + 1;
for (int i = n; i > 0; i--) {
if (tab[i] & (1 << bit)) curr = i;
pr[i][bit] = curr;
}
}
long long res = 0LL;
for (int i = 1; i < n + 1; i++) {
int l = 0;
int p = n + 1;
for (int bit = 0; bit < maxlog; bit++) {
if (tab[i] & (1 << bit)) continue;
l = max(l, le[i][bit]);
p = min(p, pr[i][bit]);
}
if (l - lewo[i] > 0) res += (l - lewo[i]) * (long long)(prawo[i] - i);
if (prawo[i] - p > 0) res += (prawo[i] - p) * (long long)(i - lewo[i]);
if (prawo[i] - p > 0 && l - lewo[i] > 0)
res -= (prawo[i] - p) * (long long)(l - lewo[i]);
}
cout << res;
return 0;
}
| 10 | CPP |
#include<iostream>
using namespace std;
int main(){
int n;
long long a;
long long sum=0;
long long min=1000000;
long long max=-1000000;
cin >>n;
for(int i=0;i<n;i++){
cin >>a;
if(a<min) min=a;
if(a>max) max=a;
sum+=a;
}
cout << min <<" " <<max <<" " <<sum <<endl;
return 0;
} | 0 | CPP |
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <math.h>
#include <vector>
#include <ctype.h>
#include <assert.h>
using namespace std;
typedef long long ll;
static const long long BASE = 1000000;
static const int BW = 6;
static const int MAXDIGIT = 20;
struct Long {
long long digit[MAXDIGIT];
int size;
explicit Long(int size = 1, long long a = 0) : size(size) {
memset(digit, 0, sizeof(digit));
digit[0] = a;
}
};
const Long ZERO(1, 0), ONE(1, 1);
// Comparators
bool operator<(const Long &x, const Long &y) {
if (x.size != y.size) { return x.size < y.size; }
for (int i = x.size - 1; i >= 0; --i) {
if (x.digit[i] != y.digit[i]) { return x.digit[i] < y.digit[i]; }
}
return false;
}
bool operator> (const Long &x, const Long &y) { return y < x; }
bool operator<=(const Long &x, const Long &y) { return !(y < x); }
bool operator>=(const Long &x, const Long &y) { return !(x < y); }
bool operator!=(const Long &x, const Long &y) { return x < y || y < x; }
bool operator==(const Long &x, const Long &y) { return !(x < y) && !(y < x); }
// Input/Output
ostream &operator<<(ostream &os, const Long &x) {
os << x.digit[x.size - 1];
for (int i = x.size - 2; i >= 0; i--) {
os << setw(BW) << setfill('0') << x.digit[i];
}
return os;
}
void print(const Long &x) {
printf("%lld", x.digit[x.size - 1]);
for (int i = x.size - 2; i >= 0; --i) {
printf("%04lld", x.digit[i]);
}
}
// Utilities
Long normal(Long x) {
long long c = 0;
for (int i = 0; i < x.size; i++) {
while (x.digit[i] < 0) { x.digit[i + 1] -= 1; x.digit[i] += BASE; }
long long a = x.digit[i] + c;
x.digit[i] = a % BASE;
c = a / BASE;
}
for (; c > 0; c /= BASE) { x.digit[x.size++] = c % BASE; }
while (x.size > 1 && x.digit[x.size - 1] == 0) { --x.size; }
return x;
}
Long convert(long long a) {
return normal(Long(1, a));
}
Long convert(const string &s) {
Long x;
int i = s.size() % BW;
if (i > 0) i -= BW;
for (; i < (int)s.size(); i += BW) {
long long a = 0;
for (int j = 0; j < BW; j++) {
a = 10 * a + (i + j >= 0 ? s[i + j] - '0' : 0);
}
x.digit[x.size++] = a;
}
reverse(x.digit, x.digit + x.size);
return normal(x);
}
// Basic Operations
Long operator+(Long x, const Long &y) {
if (x.size < y.size) { x.size = y.size; }
for (int i = 0; i < y.size; i++) { x.digit[i] += y.digit[i]; }
return normal(x);
}
Long operator-(Long x, const Long &y) {
assert(x >= y);
for (int i = 0; i < y.size; i++) { x.digit[i] -= y.digit[i]; }
return normal(x);
}
Long operator*(const Long &x, const Long &y) {
Long z(x.size + y.size);
for (int i = 0; i < x.size; i++) {
for (int j = 0; j < y.size; j++) {
z.digit[i+j] += x.digit[i] * y.digit[j];
}
}
return normal(z);
}
Long operator*(Long x, long long a) {
for (int i = 0; i < x.size; i++) { x.digit[i] *= a; }
return normal(x);
}
pair<Long, long long> divmod(Long x, const long long &a) {
long long c = 0, t;
for (int i = x.size - 1; i>= 0; --i) {
t = BASE * c + x.digit[i];
x.digit[i] = t / a;
c = t % a;
}
return make_pair(normal(x), c);
}
Long operator/(const Long &x, const long long &a) {
return divmod(x, a).first;
}
long long operator%(const Long &x, const long long &a) {
return divmod(x, a).second;
}
pair<Long, Long> divmod(Long x, Long y) {
if (x.size < y.size) { return pair<Long, Long>(ZERO, x); }
int F = BASE / (y.digit[y.size - 1] + 1); // multiplying good-factor
x = x * F; y = y * F;
Long z(x.size - y.size + 1);
for (int k = z.size - 1, i = x.size - 1; k >= 0; k--, i--) {
z.digit[k] = (i + 1 < x.size ? x.digit[i + 1] : 0) * BASE + x.digit[i];
z.digit[k] /= y.digit[y.size - 1];
Long t(k + y.size);
for (int m = 0; m < y.size; m++) {
t.digit[k + m] = z.digit[k] * y.digit[m];
}
t = normal(t);
while (x < t) {
z.digit[k] -= 1;
for (int m = 0; m < y.size; m++) {
t.digit[k + m] -= y.digit[m];
}
t = normal(t);
}
x = x - t;
}
return make_pair(normal(z), x / F);
}
Long operator/(Long x, Long y) {
return divmod(x, y).first;
}
Long operator%(Long x, Long y) {
return divmod(x, y).second;
}
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define DEC(i, s) for (int i = (s); i >= 0; i--)
#define SIZE(v) (int)((v).size())
#define MEMSET(v, h) memset((v), h, sizeof(v))
#define FIND(m, w) ((m).find(w) != (m).end())
struct Node {
Long length;
Long size;
ll loop;
char c;
vector<Node> child;
Node() : loop(1), c(0) {;}
};
char str[1000];
Node parse(ll &index) {
ll loop = 1;
Node ret;
if (isalpha(str[index])) {
ret.length = convert(1);
ret.c = str[index];
index++;
} else if (isdigit(str[index])) {
loop = atoi(str + index);
while (isdigit(str[index])) { index++; }
if (isalpha(str[index])) {
ret.child.push_back(parse(index));
ret.length = ret.length + ret.child[ret.child.size() - 1].size;
} else {
assert(str[index] == '(');
index++;
while (str[index] != ')') {
ret.child.push_back(parse(index));
ret.length = ret.length + ret.child[ret.child.size() - 1].size;
}
assert(str[index] == ')');
index++;
}
}
ret.size = ret.length * loop;
ret.loop = loop;
return ret;
}
char nodechar(const Node &node, Long &n) {
if (node.size <= n) { return '0'; }
n = n % node.length;
if (n == convert(0) && node.c != 0) { return node.c; }
REP(i, node.child.size()) {
const Node &target = node.child[i];
if (target.size > n) {
return nodechar(target, n);
}
n = n - target.size;
}
assert(false);
return 0;
}
int main() {
ll n;
while (scanf("%s %lld", str, &n), str[0] != '0' || n) {
ll index = 0;
Node root;
while (str[index] != '\0') {
root.child.push_back(parse(index));
root.size = root.size + root.child[root.child.size() - 1].size;
root.length = root.length + root.child[root.child.size() - 1].size;
}
Long longn = convert(n);
printf("%c\n", nodechar(root, longn));
}
} | 0 | CPP |
x = int(input())
steps = 0
while x>5:
x -= 5
steps += 1
if x<=5:
steps += 1
print(steps) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using pin = std::pair<int, int>;
using veci = vector<int>;
using ull = unsigned long long;
using ll = long long;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<pin> a(n, make_pair(0, 0));
for (int i = 0; i < n; ++i) {
cin >> a[i].first;
}
int q;
int type;
int p, x;
cin >> q;
veci query(q, -1);
for (int i = 0; i < q; ++i) {
cin >> type;
if (type == 1) {
cin >> p >> x;
a[p - 1].first = x;
a[p - 1].second = i;
} else if (type == 2) {
cin >> x;
query[i] = x;
}
}
for (int i = q - 2; i >= 0; --i) {
query[i] = max(query[i], query[i + 1]);
}
for (int i = 0; i < n; ++i) {
a[i].first = max(a[i].first, query[a[i].second]);
cout << a[i].first << " ";
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1600 + 100;
int n, m;
int a[maxn][maxn];
bool isPainted(int x, int y) {
return x >= 0 && y >= 0 && x < n && y < m && a[x][y];
}
int isInside(int x, int y) {
for (int dx = -3; dx <= 3; dx++)
for (int dy = -3; dy <= 3; dy++)
if (dx * dx + dy * dy != 18 && !isPainted(x + dx, y + dy)) return 0;
return 1;
}
bool isRay(int x, int y) {
if (a[x][y] != 1) return 0;
for (int dx = -5; dx <= 5; dx++)
for (int dy = -5; dy <= 5; dy++)
if (isPainted(x + dx, y + dy) && a[x + dx][y + dy] == 2) return 0;
return 1;
}
void dfsRay(int x, int y) {
if (!isPainted(x, y)) return;
if (a[x][y] != 8) return;
a[x][y] = 0;
for (int dx = -1; dx <= 1; dx++)
for (int dy = -1; dy <= 1; dy++) dfsRay(x + dx, y + dy);
}
int dfs(int x, int y) {
if (!isPainted(x, y)) return 0;
int ret = 0;
if (a[x][y] == 8) dfsRay(x, y), ret++;
a[x][y] = 0;
for (int dx = -1; dx <= 1; dx++)
for (int dy = -1; dy <= 1; dy++) ret += dfs(x + dx, y + dy);
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0, _n = (int)(n); i < _n; i++)
for (int j = 0, _n = (int)(m); j < _n; j++) cin >> a[i][j];
for (int i = 0, _n = (int)(n); i < _n; i++)
for (int j = 0, _n = (int)(m); j < _n; j++)
if (a[i][j]) a[i][j] += isInside(i, j);
for (int i = 0, _n = (int)(n); i < _n; i++)
for (int j = 0, _n = (int)(m); j < _n; j++)
if (isRay(i, j)) a[i][j] = 8;
vector<int> ans;
for (int i = 0, _n = (int)(n); i < _n; i++)
for (int j = 0, _n = (int)(m); j < _n; j++)
if (a[i][j] == 2) ans.push_back(dfs(i, j));
sort((ans).begin(), (ans).end());
cout << (int((ans).size())) << endl;
for (int i = 0, _n = (int)((int((ans).size()))); i < _n; i++)
cout << ans[i] << ' ';
cout << endl;
{
int _;
cin >> _;
return 0;
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> r[200100];
vector<int> g[200100];
int a[200100];
int mark[200100];
int bfs(int aa, int pass) {
queue<pair<int, int> > q;
mark[aa] = pass;
q.push(make_pair(aa, 0));
while (!q.empty()) {
int v, d;
tie(v, d) = q.front();
q.pop();
for (int x : g[v]) {
if (mark[x] < pass) {
mark[x] = pass;
if (a[x] != aa - 150000) r[x].emplace_back(d + 1);
q.push(make_pair(x, d + 1));
}
}
}
return 0;
}
int main() {
int n, m, k, s;
scanf("%d %d %d %d", &n, &m, &k, &s);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
r[i].emplace_back(0);
}
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d %d", &x, &y);
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
g[150000 + a[x]].push_back(y);
g[150000 + a[y]].push_back(x);
}
for (int i = 150001; i <= 150000 + k; i++) {
bfs(i, i - 150000);
}
for (int i = 0; i < n; i++) {
long long resp = 0;
sort(r[i].begin(), r[i].end());
for (int j = 0; j < s; j++) {
resp += r[i][j];
}
printf("%lld ", resp);
}
printf("\n");
}
| 7 | CPP |
import math
from collections import deque
for _ in range(int(input())):
n,b,c=map(int,input().split())
output=deque([])
x=n
diff=0
while(x-1):
if ((c-b)//(x-1))==((c-b)/(x-1)):
diff=(c-b)//(x-1)
break
x-=1
n-=x
if diff:
output.append(b)
while(output[-1]!=c):
output.append(output[-1]+diff)
else:
output.append(b)
while(n and output[0]-diff>0):
output.appendleft(output[0]-diff)
n-=1
while(n):
output.append(output[-1]+diff)
n-=1
for i in output:
print(i,end=" ")
print()
continue
while(n and output[0]-diff>0):
output.appendleft(output[0]-diff)
n-=1
while(n):
output.append(output[-1]+diff)
n-=1
for i in output:
print(i,end=" ")
print()
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
short n, k;
cin >> n >> k;
string password = "abcdefghijklmnopqrstuvwxyz";
string s, s1;
for (short i = 0; i < k; i++) s += password[i];
for (short i = 0; i < n; i++) s1 += s;
for (short i = 0; i < n; i++) cout << s1[i];
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N, K, A[300005];
long long D[5005][5005];
int main() {
scanf("%d %d", &N, &K);
for (int i = 1; i <= N; i++) scanf("%d", &A[i]);
sort(A + 1, A + 1 + N);
int type1 = (N - 1) / K + 1;
int type2 = (N - K) / K + 1;
int cnt1 = 0, cnt2 = 0;
for (int i = 1; i <= K; i++) {
int t = (N - i) / K + 1;
if (t == type1)
cnt1++;
else
cnt2++;
}
for (int i = 1; i <= K; i++) {
for (int j = i - cnt2; j <= min(cnt1, i); j++) {
int k = i - j;
int now = j * type1 + k * type2;
if (j == 0) {
D[i][j] = D[i - 1][j] + A[now] - A[now - type2 + 1];
} else if (k == 0) {
D[i][j] = D[i - 1][j - 1] + A[now] - A[now - type1 + 1];
} else {
D[i][j] = min(D[i - 1][j] + A[now] - A[now - type2 + 1],
D[i - 1][j - 1] + A[now] - A[now - type1 + 1]);
}
}
}
cout << D[K][cnt1] << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int SZ = 1000 * 100 + 10;
const int SZZZ = sizeof(int) * 1024;
double bin_pow(double b, int exp) {
double res = 1;
while (exp) {
if (exp & 1) res = res * b;
b = b * b;
exp >>= 1;
}
return res;
}
double dp[SZ];
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(0);
double m, n;
cin >> m >> n;
double cur, ans = 0;
for (int i = 1; i <= m; ++i) {
cur = bin_pow(i / m, n) - dp[i - 1];
ans += i * cur;
dp[i] = dp[i - 1] + cur;
}
cout << setprecision(10) << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int arr[105];
int greatest = 0;
for (int i = int(1); i < int(n + 1); i++) {
scanf("%d", arr + i);
greatest = max(greatest, arr[i]);
}
vector<int> primes;
for (int i = int(2); i < int(2 * greatest); i++) {
bool prime = true;
for (int j = int(2); j < int(i); j++) {
if (i % j == 0) {
prime = false;
break;
}
}
if (prime) {
primes.push_back(i);
}
}
int f[105] = {0};
for (int i = int(1); i < int(2 * greatest); i++) {
for (int j = int(0); j < int(primes.size()); j++) {
if (i % primes[j] == 0) {
f[i] |= (1 << j);
}
}
}
int ps = primes.size();
static int dp[105][1 << 17];
memset(dp, 0x3F, sizeof dp);
static tuple<int, int, int> father[105][1 << 17];
memset(father, -1, sizeof father);
for (int i = int(0); i < int(1 << ps); i++) {
dp[0][i] = 0;
}
for (int i = int(1); i < int(n + 1); i++) {
for (int j = int(1); j < int(2 * greatest); j++) {
int mask = (~f[j]) & ((1 << ps) - 1);
for (int submask = mask;; submask = (submask - 1) & mask) {
if (dp[i][submask | f[j]] > dp[i - 1][submask] + abs(arr[i] - j)) {
dp[i][submask | f[j]] = dp[i - 1][submask] + abs(arr[i] - j);
father[i][submask | f[j]] = make_tuple(i - 1, submask, j);
}
if (submask == 0) {
break;
}
}
}
}
int ans = 1 << 30;
pair<int, int> best = make_pair(-1, -1);
for (int i = int(0); i < int(1 << ps); i++) {
if (ans > dp[n][i]) {
ans = dp[n][i];
best = make_pair(n, i);
}
}
vector<int> guys;
tuple<int, int, int> cur = make_tuple(best.first, best.second, -1);
while (get<0>(cur) > 0) {
int ff = get<0>(cur);
int s = get<1>(cur);
auto prev = father[ff][s];
int t = get<2>(prev);
guys.push_back(t);
cur = prev;
}
for (int i = int(guys.size() - 1); i >= int(0); i--) {
printf("%d ", guys[i]);
}
printf("\n");
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
const int dxK[] = {-1, -1, 0, 1, 1, 1, 0, -1};
const int dyK[] = {0, 1, 1, 1, 0, -1, -1, -1};
long long n;
vector<string> split(std::string txt, char ch) {
size_t pos = txt.find(ch);
size_t initialPos = 0;
vector<string> strs;
while (pos != std::string::npos) {
strs.push_back(txt.substr(initialPos, pos - initialPos));
initialPos = pos + 1;
pos = txt.find(ch, initialPos);
}
strs.push_back(
txt.substr(initialPos, std::min(pos, txt.size()) - initialPos + 1));
return strs;
}
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string str;
cin >> str;
n = str.length();
if (str[0] == '@' or str[n - 1] == '@') {
cout << "No solution" << endl;
return 0;
}
vector<string> res;
vector<string> subparts = split(str, '@');
if (subparts.size() < 2) {
cout << "No solution" << endl;
return 0;
}
string st = subparts[0];
for (int i = 1; i < subparts.size() - 1; ++i) {
if (subparts[i].length() <= 1) {
cout << "No solution" << endl;
return 0;
}
st += "@";
st += subparts[i][0];
res.push_back(st);
st = subparts[i].substr(1, subparts[i].length() - 1);
}
st += "@";
st += subparts[subparts.size() - 1];
res.push_back(st);
for (int i = 0; i < res.size(); ++i) {
cout << res[i];
if (i != res.size() - 1) cout << ",";
}
return 0;
}
| 8 | CPP |
q = int(input())
ans = []
for _ in range(q):
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
was = False
prev = 0
c = []
for i in range(n):
c.append(b[i]-a[i])
counter = 0
prev = None
right = []
for el in c:
if (el!=prev):
right.append(el)
prev = el
counter = 0
ok = True
for i in right:
if (i<0):
ok = False
elif (i>0):
counter+=1
if ok and (counter<=1):
ans.append('YES')
else:
ans.append('NO')
print('\n'.join(ans))
| 7 | PYTHON3 |
Subsets and Splits