solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
from math import ceil as c
k,n,s,p = map(int,input().split())
print(c((k*c(n/s))/p)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 7;
const double eps = 1e-6;
int n;
double p[N][N];
double zaden[N];
double curr[N];
double ans[N];
bitset<N> vis;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
int w;
cin >> w;
p[i][j] = (double)w / 100;
}
zaden[i] = 1;
}
for (int i = 1; i <= n - 1; ++i) {
ans[i] = 1000000007;
}
while (vis.count() < n) {
int v = -1;
for (int i = 1; i <= n; ++i) {
if (!vis[i] && (v == -1 || ans[v] > ans[i])) v = i;
}
vis[v] = 1;
for (int i = 1; i <= n; ++i) {
if (!vis[i]) {
curr[i] += (ans[v] + 1) * p[i][v] * zaden[i];
zaden[i] *= (1 - p[i][v]);
if (zaden[i] + eps > 1)
ans[i] = 1000000007;
else
ans[i] = 1 / (1 - zaden[i]) * (zaden[i] + curr[i]);
}
}
}
cout << fixed << setprecision(10) << ans[1];
}
| 11 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long double eps = 1e-7;
const int inf = 1000000010;
const long long INF = 10000000000000010LL;
const int mod = 1000000007;
const int MAXN = 100010, LOG = 20;
int n, q, u, v, x, y, t = 1, a, b;
int A[MAXN];
int ans[MAXN];
int lb[LOG];
vector<pair<int, int> > query[MAXN];
void update(int x) {
for (int i = 0; i < LOG; i++)
if (x & (1 << i)) x ^= lb[i];
if (!x) {
t = (t << 1) % mod;
return;
}
lb[__builtin_ctz(x)] = x;
}
int ok(int x) {
for (int i = 0; i < LOG; i++)
if (x & (1 << i)) x ^= lb[i];
if (!x) return t;
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> A[i];
for (int i = 1; i <= q; i++) {
cin >> x >> y;
query[x].push_back({i, y});
}
for (int i = 1; i <= n; i++) {
update(A[i]);
for (pair<int, int> p : query[i]) ans[p.first] = ok(p.second);
}
for (int i = 1; i <= q; i++) cout << ans[i] << '\n';
return 0;
}
| 12 | CPP |
for _ in range(int(input())):
n, k = map(int, input().split())
if n % 2 != k % 2 or k *k > n:
print('no')
else:
print('yes') | 7 | PYTHON3 |
#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<map>
#include<vector>
#define ll long long
#define pii pair<int,int>
#define MP make_pair
using namespace std;
ll n;
map<ll,int>rev;
struct node{ll d,siz,val;int id;}a[100005];
bool cmp(node x,node y){return x.d>y.d;}
int back[100005];
vector<pii>ans;
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++){
scanf("%lld",&a[i].d);
a[i].siz=1;a[i].id=i;
rev[a[i].d]=i;
}
sort(a+1,a+1+n,cmp);
for(int i=1;i<=n;i++) back[a[i].id]=i;
for(int i=1;i<n;i++){
if(n-2*a[i].siz<=0){puts("-1");return 0;}
ll dd=a[i].d+2*a[i].siz-n;
if(!rev[dd]){puts("-1");return 0;}
int fa=rev[dd];
ans.push_back(MP(min(fa,a[i].id),max(fa,a[i].id)));
a[back[fa]].siz+=a[i].siz;
a[back[fa]].val+=a[i].val+a[i].siz;
}
if(a[n].d!=a[n].val) return puts("-1"),0;
sort(ans.begin(),ans.end());
for(int i=0;i<n-1;i++) printf("%d %d\n",ans[i].first,ans[i].second);
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 15;
vector<vector<int> > v;
int main() {
int n;
scanf("%d", &n);
for (int i = n; i >= 5; i -= 2) {
v.push_back({i - 2, i - 1, i});
v.push_back({i - 2, i - 1, i});
for (int j = 1; j < i - 2; ++j) v.push_back({i - 1, j, i, j % (i - 3) + 1});
}
if (n & 1)
v.push_back({1, 2, 3}), v.push_back({1, 2, 3});
else
v.push_back({1, 2, 3}), v.push_back({1, 2, 4}), v.push_back({1, 3, 4}),
v.push_back({2, 3, 4});
printf("%d\n", v.size());
for (auto &vv : v) {
printf("%d", vv.size());
for (auto &x : vv) printf(" %d", x);
printf("\n");
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long infinity = 1000000000000000000;
bool do_debug = false;
template <typename T>
ostream& operator<<(ostream& os, vector<T>& v) {
for (auto element : v) {
os << element << " ";
}
return os;
}
template <typename T, typename S>
ostream& operator<<(ostream& os, pair<T, S>& p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, set<T>& v) {
auto endit = v.end();
endit--;
os << "[";
for (auto it = v.begin(); it != v.end(); it++) {
os << *it;
if (it != endit) {
os << ", ";
}
}
os << "]";
return os;
}
template <typename T, typename S>
ostream& operator<<(ostream& os, map<T, S>& v) {
auto endit = v.end();
endit--;
os << "{";
for (auto it = v.begin(); it != v.end(); it++) {
os << "(" << (*it).first << " : " << (*it).second << ")";
if (it != endit) {
os << ", ";
}
}
os << "}";
return os;
}
void solve() {
long long n, m;
cin >> n >> m;
vector<long long> not_real(m, 0);
vector<long long> real(m, 0);
long long q = n / m;
long long rem = n % m;
long long ans = 0;
not_real[0] = q;
for (long long i = 1; i < m; i++) {
not_real[i] += q;
}
for (long long i = 1; i < rem + 1; i++) {
not_real[i]++;
}
for (long long i = 0; i < m; i++) {
long long actual = (i * i) % m;
real[actual] += not_real[i];
}
ans += real[0] * real[0];
for (long long i = 1; i < m; i++) {
long long j = m - i;
ans += real[i] * real[j];
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int q = 1;
while (q-- > 0) {
solve();
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000;
vector<int> adj[maxn], Adj[maxn];
bool mark[maxn], make[maxn];
int h[maxn], s[maxn], dp[maxn], par[maxn], cut[maxn][maxn];
void dfs(int v, int Par = -1) {
mark[v] = true;
dp[v] = h[v];
for (int i = 0; i < adj[v].size(); i++) {
int u = adj[v][i];
if (!mark[u]) {
h[u] = h[v] + 1;
dfs(u, v);
dp[v] = min(dp[v], dp[u]);
} else if (u != Par)
dp[v] = min(dp[v], h[u]);
}
if (dp[v] == h[v] && Par != -1) cut[v][Par] = cut[Par][v] = -1;
}
int root(int v) { return (par[v] < 0 ? v : par[v] = root(par[v])); }
void Merge(int v, int u) {
if ((v = root(v)) == (u = root(u))) return;
if (par[v] > par[u]) swap(v, u);
par[v] += par[u];
par[u] = v;
}
int Dfs(int v) {
mark[v] = true;
s[v] = -par[v];
int ret = 0;
for (int i = 0; i < Adj[v].size(); i++) {
int u = Adj[v][i];
if (!mark[u]) {
ret += Dfs(u);
s[v] += s[u];
}
}
return ret + (-par[v]) * s[v];
}
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int v, u;
cin >> v >> u;
v--, u--;
adj[v].push_back(u);
adj[u].push_back(v);
cut[v][u] = cut[u][v] = 1;
}
dfs(0);
memset(par, -1, sizeof par);
for (int i = 0; i < n; i++)
for (int j = 0; j < i; j++)
if (cut[i][j] == 1) Merge(i, j);
for (int i = 0; i < n; i++)
for (int j = 0; j < i; j++)
if (cut[i][j] == -1) {
int v = root(i), u = root(j);
Adj[v].push_back(u);
Adj[u].push_back(v);
}
vector<int> ver;
for (int i = 0; i < n; i++)
if (par[i] < 0) ver.push_back(i);
int ans = 0;
for (int x = 0; x < ver.size(); x++) {
int v = ver[x];
memset(mark, 0, sizeof mark);
int ret = Dfs(v);
vector<int> coin;
for (int i = 0; i < Adj[v].size(); i++) {
int u = Adj[v][i];
coin.push_back(s[u]);
}
memset(make, false, sizeof make);
make[0] = true;
for (int j = 0; j < coin.size(); j++)
for (int i = n - 1; i >= 0; i--) {
int k = coin[j];
if (make[i] && i + k < n) make[i + k] = true;
}
for (int i = 0; i < n; i++)
if (make[i]) ans = max(ans, ret + i * (n + par[v] - i));
}
cout << ans << endl;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:200000000")
using namespace std;
template <typename T>
inline T Abs(T x) {
return (x >= 0) ? x : -x;
}
template <typename T>
inline T sqr(T x) {
return x * x;
}
template <typename T>
inline string toStr(T x) {
stringstream st;
st << x;
string s;
st >> s;
return s;
}
template <typename T>
inline int bit(T mask, int b) {
return (b >= 0 && (mask & (T(1) << b)) != 0) ? 1 : 0;
}
inline int nextInt() {
int x;
if (scanf("%d", &x) != 1) throw;
return x;
}
inline long long nextInt64() {
long long x;
if (scanf("%I64d", &x) != 1) throw;
return x;
}
inline double nextDouble() {
double x;
if (scanf("%lf", &x) != 1) throw;
return x;
}
const int INF = (int)1E9;
const long long INF64 = (long long)1E18;
const long double EPS = 1E-9;
const long double PI = 3.1415926535897932384626433832795;
const int MAXN = 300100;
const int MOD = INF;
long long a[MAXN], f[MAXN];
int n, m;
void update(int x, int value) { a[x] = value; }
int query(int l, int r) {
long long ans = 0;
for (int i = l; i <= r; i++) ans = (ans + f[i - l] * a[i]) % MOD;
return int(ans % MOD);
}
int main() {
f[0] = f[1] = 1;
for (int i = 2; i < MAXN; i++) f[i] = (f[i - 1] + f[i - 2]) % MOD;
n = nextInt();
m = nextInt();
for (int i = 0; i < (int)(n); i++) a[i] = nextInt();
for (int q = 0; q < (int)(m); q++) {
int type = nextInt();
if (type == 1) {
int x = nextInt() - 1;
int value = nextInt();
update(x, value);
}
if (type == 2) {
int l = nextInt() - 1;
int r = nextInt() - 1;
printf("%d\n", query(l, r));
}
if (type == 3) {
int l = nextInt() - 1;
int r = nextInt() - 1;
int x = nextInt();
}
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
const long long MOD = 1e9 + 7;
int N, M, K, Q;
int a, b, q;
long long psum[MAXN];
long long query(long long n) {
long long m = (long long)a * (long long)b;
return n / m * psum[m] + psum[n % m];
}
void solve(int testNum) {
int i, j;
scanf("%d%d%d", &a, &b, &q);
for (int i = 1; i <= a * b; ++i) {
int x = i;
psum[x] = psum[x - 1];
if (x % a % b != x % b % a) ++psum[x];
}
long long l, r;
for (i = 1; i <= q; ++i) {
scanf("%lld%lld", &l, &r);
long long ans = query(r) - query(l - 1LL);
printf("%lld ", ans);
}
printf("\n");
return;
}
int main() {
int T;
scanf("%d", &T);
for (int t = 1; t <= T; ++t) {
solve(t);
}
return 0;
}
| 9 | CPP |
n,k=map(int,input().split())
g=list(map(int,input().split()))
ans=[]
for i in range(1,n):
ans.append(g[i]-g[i-1])
l=n-k
su=0
ans.sort()
for i in range(l):
su+=ans[i]
print(su) | 9 | PYTHON3 |
s1 = input().strip()
s2 = input().strip()
s = input().strip()
l = list()
r = ''
for i in range(26):
l.append([s1[i], s2[i]])
for i in s:
if i.isnumeric():
r += i
else:
if i.isupper():
for x in l:
if x[0] == i.lower():
r += x[1].upper()
else:
for x in l:
if x[0] == i:
r += x[1]
print(r) | 8 | PYTHON3 |
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------------------
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
def toord(c): return ord(c)-ord('a')
def lcm(a, b): return a*b//lcm(a, b)
mod = 998244353
INF = float('inf')
from math import factorial, sqrt, ceil, floor, gcd
from collections import Counter, defaultdict, deque
from heapq import heapify, heappop, heappush
# ------------------------------
# f = open('../input.txt')
# sys.stdin = f
def main():
for _ in range(N()):
n = N()
arra = RLL()
arrb = RLL()
ma, mb = min(arra), min(arrb)
res = 0
for i in range(n):
nowa, nowb = arra[i], arrb[i]
na, nb = nowa-ma, nowb-mb
res+=min(na, nb)
res+=max(na, nb)-min(na, nb)
print(res)
if __name__ == "__main__":
main()
| 8 | PYTHON3 |
a,b = input().split()
a = int(a)
b = int(b)
small = b-a
current = 1
if (small >= 5):
current = 0
else:
for i in range(b,a,-1):
current =current * (i%10)
current = current%10
print(current)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long Mod = 1e9 + 7;
long long bfs(pair<vector<int>, pair<int, int> > G[], bool &b, int n) {
set<int> s;
queue<int> q;
q.push(0);
s.insert(0);
int daddy[n];
G[0].second.second = G[0].second.first;
while (q.size() != 0) {
int u = q.front();
q.pop();
if (G[u].second.first != -1) {
for (int i = 0; i < G[u].first.size(); i++) {
if (s.find(G[u].first[i]) == s.end()) {
daddy[G[u].first[i]] = u;
q.push(G[u].first[i]);
s.insert(G[u].first[i]);
}
}
continue;
}
int father = G[daddy[u]].second.first;
int children = Mod;
for (int i = 0; i < G[u].first.size(); i++) {
if (s.find(G[u].first[i]) == s.end()) {
if (G[G[u].first[i]].second.first < father) b = false;
if (G[G[u].first[i]].second.first < children)
children = G[G[u].first[i]].second.first;
}
}
if (children == Mod) {
G[u].second.second = 0;
continue;
}
G[u].second.second = children - father;
for (int i = 0; i < G[u].first.size(); i++) {
if (s.find(G[u].first[i]) == s.end()) {
daddy[G[u].first[i]] = u;
q.push(G[u].first[i]);
s.insert(G[u].first[i]);
G[G[u].first[i]].second.second =
G[G[u].first[i]].second.first - children;
}
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
ans += G[i].second.second;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
pair<vector<int>, pair<int, int> > G[n];
int a, no;
for (int i = 1; i < n; i++) {
cin >> a;
a--;
G[a].first.push_back(i);
G[i].first.push_back(a);
}
for (int i = 0; i < n; i++) {
cin >> no;
G[i].second.first = no;
}
bool b = true;
long long ans = bfs(G, b, n);
if (b)
cout << ans << endl;
else
cout << -1 << endl;
return 0;
}
| 10 | CPP |
n = int(input())
fact = 1
for i in range(1,n+1):
fact *= i
divi = n*n
divi //=2
print(fact//divi) | 11 | PYTHON3 |
#include <iostream>
#include <string>
#include <vector>
#include <cmath>
using namespace std;
double entropy(int N, const vector<int> &x) {
double H = 0;
for (int i=0; i<256; ++i) {
if (x[i] != 0) {
H -= (double)x[i] / N * log((double)x[i] / N);
}
}
return H;
}
int main() {
ios::sync_with_stdio(false);
int N;
while (cin >> N && N) {
vector<int> I(N+1);
for (int i=1; i<=N; ++i) cin >> I[i];
int M = 256;
double Hmin = 100000.0;
vector<int> ans(3);
for (int S=0; S<=15; ++S) {
for (int A=0; A<=15; ++A) {
for (int C=0; C<=15; ++C) {
vector<int> x(256, 0);
int R = S;
int O;
int cnt = 0;
int upper = N;
for (int i=1; i<=N; ++i) {
R = (A * R + C) % M;
O = (I[i] + R) % M;
cnt += x[O] == 0;
if (upper < cnt) break;
x[O] ++;
}
if (upper < cnt) continue;
upper = cnt;
double H = entropy(N, x);
if (H + 1e-8 < Hmin) {
Hmin = H;
ans[0] = S;
ans[1] = A;
ans[2] = C;
}
}
}
}
cout << ans[0] << " " << ans[1] << " " << ans[2] << endl;
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000002;
int n, p[N], sign[N];
long long curr;
vector<vector<int> > flips(N), add(N);
int move(int i, int d) {
if (d < 1) return i;
return (i + d) % n ? (i + d) % n : n;
}
int main() {
scanf("%d", &n);
for (int i = (1); i <= (int)(n); ++i) {
scanf("%d", &p[i]);
curr += i - p[i];
if (p[i] == n)
flips[0].push_back(i), add[n - i + 1].push_back(i);
else {
if (i <= p[i]) flips[0].push_back(i);
int j = p[i] + 1 <= n ? p[i] + 1 : 1;
int k = i <= j ? j - i : n - i + j;
if (k) flips[k].push_back(i);
int l = i == 1 ? 0 : n - i + 1;
if (l and l != k) flips[l].push_back(i);
}
}
int ans = -1, pls = n;
long long dev = 1000000000000000000ll;
for (int k = (0); k <= (int)(n - 1); ++k) {
int changedPlus = 0, changedMinus = 0;
for (int i : flips[k]) {
if (sign[i])
curr = curr - (p[i] - move(i, k - 1)) + (move(i, k) - p[i]),
++changedMinus;
else
curr = curr - (move(i, k - 1) - p[i]) + (p[i] - move(i, k)),
++changedPlus;
sign[i] ^= 1;
}
for (int i : add[k]) curr += p[i];
if (k) curr = curr + (pls - changedPlus) - (n - pls - changedMinus);
pls = pls + changedMinus - changedPlus;
if (curr < dev) dev = curr, ans = k;
}
cout << dev << " " << ans;
}
| 8 | CPP |
#include <iostream>
using namespace std;
int main() {
int l,r,d;cin >>l>>r>>d;
int out = r/d - l/d;
if(l%d==0) ++out;
cout << out << endl;
return 0;
} | 0 | CPP |
N,K=map(int,input().split())
A=list(map(int,input().split()))
ans=0
for i in range(N):
first_num = len([x for x in A[i+1:] if A[i]>x])
roop_num = len([x for x in A if A[i]>x])
ans += first_num*K
ans += roop_num*(K*(K-1))//2
ans = ans%(10**9+7)
print(str(ans)) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n, result;
while (cin >> n) {
result = n;
if ((n / 10) > result) result = n / 10;
if ((((n / 100) * 10) + n % 10) > result)
result = ((n / 100) * 10) + n % 10;
cout << result << endl;
}
return 0;
}
| 7 | CPP |
import sys
from collections import defaultdict, deque
def bfs(g, source):
q = deque()
dist = {}
q.append(source)
dist[source] = 0
while q:
node = q.popleft()
assert node in dist
d = dist[node]
for nbr in g[node]:
if nbr not in dist:
q.append(nbr)
dist[nbr] = d + 1
return dist
def solve(N, M, roads, K, intersections):
graph = defaultdict(set)
graphT = defaultdict(set)
for u, v in roads:
graph[u].add(v)
graphT[v].add(u)
dist = bfs(graphT, intersections[-1])
lo = 0
hi = 0
for i in range(K - 1):
u = intersections[i]
d1 = dist[u]
short = set()
for v in graph[u]:
d2 = dist[v]
if d1 - d2 == 1:
short.add(v)
if intersections[i + 1] in short:
if len(short) > 1:
hi += 1
else:
lo += 1
hi += 1
return str(lo) + " " + str(hi)
if __name__ == "__main__":
input = sys.stdin.readline
N, M = map(int, input().split())
roads = []
for i in range(M):
roads.append(list(map(int, input().split())))
K = int(input())
intersections = list(map(int, input().split()))
ans = solve(N, M, roads, K, intersections)
print(ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void chmin(int& x, int y)
{
x = min(x, y);
}
void chmax(int& x, int y)
{
x = max(x, y);
}
int main()
{
int Q, H, W;
string S[50];
int proc = 1;
int used[50][50] = {{}};
cin >> Q;
while(Q--) {
cin >> H >> W;
string chars = "";
for(int i = 0; i < H; i++) {
cin >> S[i];
chars += S[i];
}
sort(chars.begin(), chars.end());
chars += ".";
chars.erase(unique(chars.begin(), chars.end()), chars.end());
vector< int > x1(chars.size(), W), x2(chars.size(), 0);
vector< int > y1(chars.size(), H), y2(chars.size(), 0);
for(int i = 0; i < H; i++) {
for(int j = 0; j < W; j++) {
int pos = chars.find(S[i][j]);
chmin(x1[pos], j);
chmax(x2[pos], j);
chmin(y1[pos], i);
chmax(y2[pos], i);
}
}
int xx1[128], xx2[128], yy1[128], yy2[128];
for(int i = 0; i < chars.size(); i++) {
xx1[chars[i]] = x1[i];
xx2[chars[i]] = x2[i];
yy1[chars[i]] = y1[i];
yy2[chars[i]] = y2[i];
}
bool Judge = chars.size() == 1;
do {
if(chars[chars.size() - 1] != '.') continue;
Judge = true;
for(int i = 0; i < chars.size(); i++) {
for(int j = xx1[chars[i]]; j <= xx2[chars[i]]; j++) {
for(int k = yy1[chars[i]]; k <= yy2[chars[i]]; k++) {
if(used[j][k] == proc) continue;
used[j][k] = proc;
if(S[k][j] != chars[i]) {
Judge = false;
goto myon;
}
}
}
}
myon: ;
++proc;
} while(!Judge && next_permutation(chars.begin(), chars.end()));
if(Judge) cout << "SAFE" << endl;
else cout << "SUSPICIOUS" << endl;
}
} | 0 | CPP |
a,b,c=map(int,input().split())
if a+b-c<0 and (a+b-c)**2>4*a*b:
print("Yes")
else:
print("No") | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int H, W;
cin >>H >>W;
vector<vector<int>> s(H+2, vector<int> (W+2, 10000));
int SS=0;
for (int i=1; i<=H; i++)
for (int j=1; j<=W; j++) {
char C;
cin >>C;
if ('.'==C) {
s.at(i).at(j)=3000;
SS++;
}
}
s.at(1).at(1)=1;
while(true) {
bool found=false;
for (int i=1; i<=H; i++)
for (int j=1; j<=W; j++) {
if (10000!=s.at(i).at(j)) {
int V=s.at(i).at(j)-1;
V=min(V, s.at(i-1).at(j));
V=min(V, s.at(i+1).at(j));
V=min(V, s.at(i).at(j-1));
V=min(V, s.at(i).at(j+1));
if (V+1<s.at(i).at(j)) {
s.at(i).at(j)=V+1;
found=true;
}
}
}
if (!found)
break;
}
if (3000==s.at(H).at(W)) {
cout <<-1 <<endl;
} else {
cout <<SS-s.at(H).at(W) <<endl;
}
return 0;
};
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T& x) {
x = 0;
int fl = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') fl = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
x *= fl;
}
template <typename T, typename... Args>
inline void read(T& t, Args&... args) {
read(t);
read(args...);
}
const int N = 1100;
int n, k;
inline bool ask(int c) {
printf("? %d\n", c);
fflush(stdout);
char ch[2];
scanf("%s", ch);
return ch[0] == 'N';
}
inline void reset() {
puts("R");
fflush(stdout);
}
bool tag[N];
int main() {
memset(tag, 1, sizeof tag);
read(n, k);
int m = 2 * n / k;
for (int i = 1; i <= m / 2; i++) {
for (int gap = i; gap <= m - i; gap++) {
reset();
int now = i;
while (now <= m) {
for (int j = (now - 1) * k / 2 + 1; j <= now * k / 2; j++)
if (ask(j) == false) tag[j] = false;
now += gap;
}
}
}
int cnt = 0;
for (int i = 1; i <= n; i++) cnt += tag[i];
printf("! %d\n", cnt);
fflush(stdout);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
string a, b;
int main() {
cin >> a;
b = a;
cout << a;
for (int i = b.length() - 1; i >= 0; --i) cout << b[i];
cout << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1000000007;
const double eps = 1e-6;
const double PI = acos(-1);
int n, R, F[N], S[N], up;
double P[N];
double dp[50 + 7][50 * 100 + 7];
double dfs(int i, int j, double x) {
if (i == n) {
if (j <= R)
return 0;
else
return x;
}
if (dp[i][j] + eps > 0) return dp[i][j];
double T1 = P[i + 1] * (dfs(i + 1, j + F[i + 1], x) + F[i + 1]) +
(1 - P[i + 1]) * (dfs(i + 1, j + S[i + 1], x) + S[i + 1]);
dp[i][j] = min(T1, x);
return dp[i][j];
}
bool check(double x) {
for (int i = 0; i <= n; i++)
for (int j = 0; j <= up; j++) dp[i][j] = -1;
if (dfs(0, 0, x) < x)
return true;
else
return false;
}
int main() {
scanf("%d%d", &n, &R);
for (int i = 1; i <= n; i++) {
scanf("%d%d%lf", &F[i], &S[i], &P[i]);
P[i] /= 100;
up += S[i];
}
double low = n, high = 5e8;
for (int o = 1; o <= 100; o++) {
double mid = (low + high) / 2;
if (check(mid))
high = mid;
else
low = mid;
}
printf("%.12f\n", (low + high) / 2);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<int(n);++i)
#define N 100001
int n,m,Q,a,b;
int dp[N],color[N];
vector<int> e[N];
void paint(int v,int d,int c){
if(!color[v]) color[v]=c;
if(dp[v]>=d || d==0)return;
dp[v]=d;
rep(i,e[v].size()){
paint(e[v][i],d-1,c);
}
}
void solve(int q){
if(q==0)return;
int v,d,c;
scanf("%d %d %d",&v,&d,&c);
solve(q-1);
paint(v,d,c);
}
int main(void){
cin>>n>>m;
rep(i,m){
scanf("%d %d",&a,&b);
e[a].push_back(b);
e[b].push_back(a);
}
cin>>Q;
solve(Q);
rep(i,n)cout<<color[i+1]<<endl;
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double PI = acos(-1.0);
template <class T>
inline T _abs(T n) {
return ((n) < 0 ? -(n) : (n));
}
template <class T>
inline T _max(T a, T b) {
return (!((a) < (b)) ? (a) : (b));
}
template <class T>
inline T _min(T a, T b) {
return (((a) < (b)) ? (a) : (b));
}
template <class T>
inline T _swap(T& a, T& b) {
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
template <class T>
inline T gcd(T a, T b) {
return (b) == 0 ? (a) : gcd((b), ((a) % (b)));
}
template <class T>
inline T lcm(T a, T b) {
return ((a) / gcd((a), (b)) * (b));
}
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
int bitOn(int N, int pos) { return N = N | (1 << pos); }
int bitOff(int N, int pos) { return N = N & ~(1 << pos); }
bool bitCheck(int N, int pos) { return (bool)(N & (1 << pos)); }
int main() {
int n;
while (scanf("%d", &n) == 1) {
vector<int> v, v1;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
v.push_back(x);
}
getchar();
for (int i = 0; i < n; i++) {
string x;
getline(cin, x);
int l = x.length();
int c = 0;
for (int j = 0; j < l; j++) {
if (x[j] == 'a' || x[j] == 'e' || x[j] == 'i' || x[j] == 'o' ||
x[j] == 'u' || x[j] == 'y')
c++;
}
v1.push_back(c);
}
int f = 1;
for (int i = 0; i < n; i++) {
if (v1[i] != v[i]) {
f = 0;
break;
}
}
if (f == 1)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<ll, ll>;
using ull = unsigned long long;
void err(istream_iterator<string> it) { cerr << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
const int dx[] = {0, -1, 1, 0, 1, -1, 1, -1};
const int dy[] = {1, 0, 0, -1, 1, -1, -1, 1};
const double EPS = 1e-9;
const int mod = 1e9 + 7;
const long long INF = 1e18;
const int N = 2e5 + 5;
string t = "abacaba";
bool check(string &s) {
int idx = s.find(t);
int idx_1 = s.find(t, idx + 1);
return idx_1 == -1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
string s;
cin >> s;
int idx = s.find(t);
if (idx == -1) {
bool flag = 0;
for (int i = 0; i <= n - 7; ++i) {
string g = s;
for (int j = i, k = 0; j < n; ++j) {
if (s[j] == t[k]) {
k++;
} else if (s[j] == '?') {
g[j] = t[k];
k++;
} else {
break;
}
if (k == 7) {
if (check(g)) {
flag = 1;
s = g;
break;
}
}
}
if (flag) break;
}
if (!flag) {
cout << "no\n";
} else {
for (int i = 0; i < n; ++i) {
if (s[i] == '?') s[i] = 'z';
}
cout << "yes\n" << s << '\n';
}
continue;
}
int idx_1 = s.find(t, idx + 1);
if (idx_1 == -1) {
for (int i = 0; i < n; ++i) {
if (s[i] == '?') s[i] = 'z';
}
cout << "yes\n" << s << '\n';
continue;
}
cout << "no\n";
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long orz = 1000000007LL;
int k, tot = 1;
struct node {
long long no;
int color;
long long ans[7] = {0, 0, 0, 0, 0, 0, 0};
} tr[120005];
map<long long, int> vis;
bool cmp(node x, node y) { return x.no > y.no; }
long long qpower(long long a, long long b, long long p) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % p;
a = (a * a) % p;
b >>= 1;
}
return ans;
}
long long p4[65];
long long power4(long long x) {
int i = 0;
while (x > 1) {
x /= 2;
i++;
}
return p4[k - i];
}
int main() {
char color[10];
int q;
long long f, no, i, x, j, ttl, ttr, l, L, R, ttot;
scanf("%d%d", &k, &q);
for (i = 1; i <= k; i++) {
p4[i] = qpower(4LL, (1LL << i) - 2LL, orz);
}
while (q--) {
scanf("%lld%s", &no, color);
tr[tot].no = no;
if (color[0] == 'w') {
tr[tot].color = 1;
} else if (color[0] == 'y') {
tr[tot].color = 6;
} else if (color[0] == 'g') {
tr[tot].color = 2;
} else if (color[0] == 'b') {
tr[tot].color = 5;
} else if (color[0] == 'r') {
tr[tot].color = 3;
} else if (color[0] == 'o') {
tr[tot].color = 4;
}
vis[no] = tot;
tot++;
}
for (i = 1, ttot = tot; i < ttot; i++) {
no = tr[i].no;
do {
no /= 2LL;
if (vis.find(no) == vis.end()) {
tr[tot].no = no;
tr[tot].color = 100;
vis[no] = tot;
tot++;
} else
break;
} while (no > 1);
}
sort(tr + 1, tr + tot, cmp);
vis.clear();
for (i = 1; i < tot; i++) vis[tr[i].no] = i;
for (i = 1; i < tot; i++) {
x = tr[i].no;
L = vis[x * 2LL];
R = vis[x * 2LL + 1LL];
for (j = 1; j <= 6; j++) {
if (tr[i].color != 100 && tr[i].color != j) continue;
if (x >= (1LL << (k - 1))) {
tr[i].ans[j] = 1;
} else {
ttl = 0;
ttr = 0;
for (l = 1; l <= 6; l++) {
if (j == l || j + l == 7) continue;
if (L == 0)
ttl += power4(x * 2LL);
else
ttl += tr[L].ans[l];
if (R == 0)
ttr += power4(x * 2LL + 1);
else
ttr += tr[R].ans[l];
ttl %= orz;
ttr %= orz;
}
tr[i].ans[j] = ttl * ttr % orz;
}
tr[i].ans[0] += tr[i].ans[j];
}
}
printf("%lld\n", tr[vis[1]].ans[0] % orz);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N, M, idx, disp;
int id[300005];
int low[300005];
bool vis[300005];
vector<int> ady[300005];
vector<int> ady2[300005];
int diameter() {
int ult = 1;
memset(vis, 0, sizeof vis);
queue<int> q;
q.push(1);
vis[1] = true;
while (!q.empty()) {
int x = q.front();
q.pop();
ult = x;
for (auto v : ady2[x])
if (!vis[v]) {
vis[v] = true;
q.push(v);
}
}
int ans = 0;
memset(vis, 0, sizeof vis);
queue<int> p;
q.push(ult);
vis[ult] = true;
p.push(0);
while (!q.empty()) {
int x = q.front();
int dist = p.front();
ans = max(ans, dist);
q.pop();
p.pop();
for (auto v : ady2[x])
if (!vis[v]) {
vis[v] = true;
q.push(v);
p.push(dist + 1);
}
}
return ans;
}
void createTree(int x, int g) {
vis[x] = true;
for (auto v : ady[x]) {
if (vis[v]) continue;
if (low[v] > id[x] or low[x] > id[v]) {
int sig = ++disp;
createTree(v, sig);
ady2[g].push_back(sig);
ady2[sig].push_back(g);
} else
createTree(v, g);
}
}
void findBridges(int x, int p) {
id[x] = low[x] = ++idx;
for (auto v : ady[x]) {
if (v == p) continue;
if (!id[v]) findBridges(v, x);
low[x] = min(low[x], low[v]);
}
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> N >> M;
while (M--) {
int u, v;
cin >> u >> v;
ady[u].push_back(v);
ady[v].push_back(u);
}
findBridges(1, -1);
createTree(1, ++disp);
cout << diameter();
return 0;
}
| 11 | CPP |
#include<iostream>
using namespace std;
int main() {
long long n,x=1; cin >> n;
for(int i=1;i<=n;i++){
x = (i*x)%(1000000007);
}
cout << x << endl;
return 0;
} | 0 | CPP |
#include <iostream>
using namespace std;
int main(){
int a=0, b=0;
cin >> a >> b;
cout << (a>b?"a > b":(a<b?"a < b":"a == b")) << endl;
}
| 0 | CPP |
t = int(input())
solutions = []
for i in range(t):
solution = 0
n = int(input())
if n%2==0:
solution = "1"*(n//2)
else:
solution = "7"+"1"*((n//2)-1)
solutions.append(solution)
for solution in solutions:
print(solution) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1e6 + 10;
long long a[maxn];
int main() {
std::ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < 2 * n; i++) {
cin >> a[i];
}
sort(a, a + 2 * n);
long long ans = (a[n - 1] - a[0]) * (a[2 * n - 1] - a[n]);
for (int i = n; i < 2 * n - 1; i++) {
ans = min(ans, (a[2 * n - 1] - a[0]) * (a[i] - a[i - n + 1]));
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#define EPS (1e-8)
using namespace std;
int main() {
int n;
double x1, x2, x3, y1, y2, y3;
double a1, a2, b1, b2, c1, c2;
double x, y, r;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
a1 = 2*(x2 - x1);
b1 = 2*(y2 - y1);
c1 = x1*x1 - x2*x2 + y1*y1 - y2*y2;
a2 = 2*(x3 - x1);
b2 = 2*(y3 - y1);
c2 = x1*x1 - x3*x3 + y1*y1 - y3*y3;
x = (b1*c2 - b2 * c1) / (a1*b2 - a2*b1) + EPS;
y = (c1*a2 - c2*a1) / (a1*b2 - a2*b1) + EPS;
r = sqrt((x-x1)*(x-x1) + (y-y1)*(y-y1)) + EPS;
cout << fixed << setprecision(3) << x << " " << y << " " << r << endl;
}
return 0;
} | 0 | CPP |
n,m=map(int,input().split())
if(m==0):
print("YES",end="")
else:
l=list(map(int,input().split()))
l=sorted(l)
if(l[0]==1 or l[m-1]==n):
print("NO",end="")
else:
can=True
for i in range(m-2):
if (l[i] + 1 == l[i + 1] and l[i + 1] + 1 == l[i + 2]):
can=False
break
print("YES" if can else "NO",end="")
| 8 | PYTHON3 |
import sys
import copy
import math
n, vb, vs = [int(x) for x in sys.stdin.readline().strip().split(" ")]
stops = [int(x) for x in sys.stdin.readline().strip().split(" ")]
stops = stops[1:]
inp = sys.stdin.readline().strip().split(" ")
school = (int(inp[0]), int(inp[1]))
def driving(x):
return (x + 0.0) / vb
def running(a):
return (math.sqrt((school[0] - a)**2 + school[1]**2))/vs
time = float("inf")
best_stop = -1
for i in range(0, len(stops)):
x = stops[i]
curtime = driving(x) + running(x)
#print(x, curtime)
if (curtime <= time):
time = curtime
best_stop = i
#elif(curtime == time):
print(best_stop + 2) | 8 | PYTHON3 |
# -*- coding: utf-8 -*-
# Author: Metalofon
n, k = map(int, input().split())
for i in range(k):
if n % 10 == 0:
n //= 10
else:
n -= 1
print(n)
| 7 | PYTHON3 |
n=int(input())
l=input()
l=l.split()
m=input()
m=m.split()
m.append('0')
p=input()
p=p.split()
p.append('0')
p.append('0')
s1=0
s2=0
s3=0
for i in range(len(l)):
s1+=int(l[i])
s2+=int(m[i])
s3+=int(p[i])
print(s1-s2)
print(s2-s3) | 8 | PYTHON3 |
#include <bits/stdc++.h>
#define LL int
using namespace std;
LL a[1000][1000];
int main(){
ios_base::sync_with_stdio(false);
LL n;
cin >> n;
for (LL i = 0; i < n; i++)
for (LL j = 0; j < n-1; j++){
cin >> a[i][j];
a[i][j]--;
}
bool pos = true;
vector<LL> last(n,0);
vector<LL> index(n,0);
for (LL d = 0; d < n*(n-1)/2; d++){
bool some = false;
LL games = 0;
for (LL i = 0; i < n; i++){
if (index[i] < n-1)
some = true;
else
continue;
LL opp = a[i][index[i]];
if (index[opp] < n-1 && a[opp][index[opp]] == i){
games++;
LL day = max(last[i],last[opp])+1;
last[i] = day;
last[opp] = day;
index[i]++;
index[opp]++;
}
}
if (!some){
break;
}
if (!games){
pos = false;
break;
}
}
if (!pos)
cout << "-1\n";
else
cout << *(max_element(last.begin(),last.end())) << "\n";
}
| 0 | CPP |
'''
def main():
from sys import stdin,stdout
if __name__=='__main__':
main()
'''
#158B
'''
TLE
def main():
from sys import stdin,stdout
from math import ceil
n=int(stdin.readline())
li=sorted(list(map(int,stdin.readline().split())),reverse=True)
i=0
while len(li):
if li[0]==4:
i+=1
li=li[1:]
elif li[0]==3:
i+=1
li=li[1:]
if len(li):
if li[-1]==1:
li=li[:-1]
elif li[0]==2:
i+=1
li=li[1:]
if len(li):
if li[0]==2:
li=li[1:]
elif li[0]==1:
li=li[1:]
if len(li):
li=li[2:]
else:
i+=ceil(len(li)/4)
li=[]
stdout.write(str(i))
if __name__=='__main__':
main()
'''
#158B
'''
def main():
from sys import stdin,stdout
from math import ceil
n=int(stdin.readline())
li=tuple(map(int,stdin.readline().split()))
i=li.count(4)
count3=li.count(3)
count2=li.count(2)
count1=li.count(1)
i+=count3
if count1 >= count3:
count1-=count3
else:
count1=0
if count2 & 1:
i+=(count2>>1)
i+=1
if count1:
count1-=2
else:
if count2:
i+=(count2>>1)
if count1>0:
i+=ceil(count1/4)
stdout.write(str(i))
if __name__=='__main__':
main()
'''
#460A
'''
def main():
from sys import stdin,stdout
n,m=map(int,stdin.readline().split())
counter=n
while n>=m:
counter+=n//m
n//=m
if counter % m:
stdout.write(str(counter))
else:
stdout.write(str(counter+1))
if __name__=='__main__':
main()
'''
#520A
'''
def main():
from sys import stdin,stdout
stdin.readline()
s=stdin.readline().strip().lower()
flag=1
for i in 'abcdefghijklmnopqrstuvwxyz':
if i not in s:
flag=0
break
if flag:
stdout.write('YES')
else:
stdout.write('NO')
if __name__=='__main__':
main()
'''
#25A
'''
def main():
from sys import stdin,stdout
n=int(stdin.readline())
tup=tuple(map(int,stdin.readline().split()))
etup=()
otup=()
for i in range(n):
if tup[i] & 1:
otup+=(i+1,)
else:
etup+=(i+1,)
if len(otup)==1:
stdout.write(str(otup[0]))
else:
stdout.write(str(etup[0]))
if __name__=='__main__':
main()
'''
#478A
def main():
from sys import stdin,stdout
k=sum(map(int,stdin.readline().split()))
if k%5:
stdout.write('-1')
else:
if k//5:
stdout.write(str(k//5))
else:
stdout.write('-1')
if __name__=='__main__':
main()
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int a[200010];
struct segment {
int l, r;
long long sum[11];
int nxt[11];
} T[100010 << 3];
void pushup(int now) {
for (int i = 0; i < 10; i++)
T[now].sum[i] = T[now << 1].sum[i] + T[now << 1 | 1].sum[i];
}
void build(int now, int l, int r) {
T[now].l = l, T[now].r = r;
for (int i = 0; i <= 9; i++) T[now].nxt[i] = i, T[now].sum[i] = 0;
if (l == r) {
long long x = a[l], tot = 1ll, s;
while (x) {
s = x % 10;
T[now].sum[s] += tot;
tot *= 10;
x /= 10;
}
return;
}
int m = (l + r) >> 1;
build(now << 1, l, m);
build(now << 1 | 1, m + 1, r);
pushup(now);
}
int nxt1[11], nxt2[11];
void pushdown(int now) {
int l = T[now].l, r = T[now].r;
if (r - l >= 1) {
for (int i = 0; i <= 9; i++) {
nxt1[i] = T[now].nxt[T[now << 1].nxt[i]];
nxt2[i] = T[now].nxt[T[now << 1 | 1].nxt[i]];
}
for (int i = 0; i <= 9; i++) T[now << 1].nxt[i] = nxt1[i];
for (int i = 0; i <= 9; i++) T[now << 1 | 1].nxt[i] = nxt2[i];
}
long long tmp[11] = {0};
for (int i = 0; i <= 9; i++) tmp[T[now].nxt[i]] += T[now].sum[i];
for (int i = 0; i <= 9; i++) {
T[now].sum[i] = tmp[i];
T[now].nxt[i] = i;
}
}
void modify(int now, int L, int R, int x, int y) {
int l = T[now].l, r = T[now].r;
pushdown(now);
if (l >= L && r <= R) {
T[now].nxt[x] = y;
pushdown(now);
return;
}
int m = (l + r) >> 1;
pushdown(now << 1);
pushdown(now << 1 | 1);
if (L <= m) modify(now << 1, L, R, x, y);
if (R > m) modify(now << 1 | 1, L, R, x, y);
pushup(now);
}
long long query(int now, int L, int R) {
int l = T[now].l, r = T[now].r;
long long sum = 0;
pushdown(now);
if (l >= L && r <= R) {
for (int i = 0; i <= 9; i++) sum += T[now].sum[i] * i;
return sum;
}
int m = (l + r) >> 1;
pushdown(now << 1);
pushdown(now << 1 | 1);
if (L <= m) sum += query(now << 1, L, R);
if (R > m) sum += query(now << 1 | 1, L, R);
return sum;
}
int main() {
int n, q;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
build(1, 1, n);
int l, r, x, y, s;
while (q--) {
scanf("%d", &s);
if (s == 1) {
scanf("%d%d%d%d", &l, &r, &x, &y);
if (x == y) continue;
modify(1, l, r, x, y);
} else {
scanf("%d%d", &l, &r);
printf("%lld\n", query(1, l, r));
}
}
return 0;
}
| 12 | CPP |
//walking path
#if 0
所要時間は
#endif // 0
#include<iostream>
#define MAX 20
using namespace std;
int main()
{
int num;
cin>>num;
bool v[MAX][MAX],h[MAX][MAX];
for(int i=0;i<num;i++)
{
int p,q;//the place of target
int t;//the number of disconnected load
cin>>p>>q;
cin>>t;
for(int m=0;m<=p;m++)
for(int n=0;n<=q;n++)
{
h[m][n]=v[m][n]=true;
}
for(int j=0;j<t;j++)
{
int x1,y1,x2,y2;
cin>>x1>>y1>>x2>>y2;
if(x1==x2)
v[x2][max(y1,y2)]=false;
else if(y1==y2)
h[max(x1,x2)][y2]=false;
}
for(int m=0;m<=p;m++)
for(int n=0;n<=q;n++)
{
// h[m][n]=v[m][n]=true;
//cout<<h[m][n]<<" "<<v[m][n]<<endl;
}
int path[MAX][MAX];
//path[0][0]=1;
for(int m=0;m<=p;m++)
{
for(int n=0;n<=q;n++)
{
if(m==0&&n==0)
path[m][n]=1;
else if(m==0)
path[m][n]=v[m][n]*path[m][n-1];
else if(n==0)
path[m][n]=h[m][n]*path[m-1][n];
else
path[m][n]=h[m][n]*path[m-1][n]+v[m][n]*path[m][n-1];
}
}
if(path[p][q])
cout<<path[p][q]<<endl;
else
cout<<"Miserable Hokusai!"<<endl;
}
}
| 0 | CPP |
A = int(input())
if A%2 == 0 and A != 2:
print("YES")
else:
print("NO")
| 7 | PYTHON3 |
n = int(input())
data = [input().split() for _ in range(n)]
i = 0
k = 0
for x in data:
i += 1
for y in data[i:]:
if x[0] == y[1]:
k += 1
i = 0
for y in data:
i += 1
for x in data[i:]:
if x[0] == y[1]:
k += 1
print(k)
| 7 | PYTHON3 |
from collections import deque
N,M,K = (int(x) for x in input().split())
AB = [list(map(int, input().split())) for _ in range(M)]
CD = [list(map(int, input().split())) for _ in range(K)]
friends = [set() for _ in range(N)]
blocks = [set() for _ in range(N)]
searched = [0] * N
ans = [0] * N
d = deque()
for x, y in AB:
friends[x-1].add(y-1)
friends[y-1].add(x-1)
for x, y in CD:
blocks[x-1].add(y-1)
blocks[y-1].add(x-1)
for i in range(N):
if searched[i]:
continue
trace = set()
d.append(i)
trace.add(i)
searched[i] = 1
while d:
temp = d.popleft()
for x in friends[temp]:
if searched[x] == 0:
d.append(x)
trace.add(x)
searched[x] = 1
chain = len(trace)
for j in trace:
ans[j] = chain - 1 - len(trace&friends[j]) - len(trace&blocks[j])
print(*ans) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using cat = long long;
bool is_edge(int u, int v) {
cout << "? " << u + 1 << " " << v + 1 << endl;
int ans;
cin >> ans;
return ans;
}
struct SCC_info {
vector<int> par, id, min_id;
stack<int> st;
vector<bool> in_st;
int cur_id;
};
void DFS(int R, vector<vector<int> >& G, SCC_info& I,
vector<vector<int> >& SCC) {
I.in_st[R] = true;
I.st.push(R);
I.id[R] = I.min_id[R] = I.cur_id++;
for (auto it = G[R].begin(); it != G[R].end(); it++) {
if (I.id[*it] >= I.cur_id) {
I.par[*it] = R;
DFS(*it, G, I, SCC);
I.min_id[R] = min(I.min_id[R], I.min_id[*it]);
} else if (I.in_st[*it])
I.min_id[R] = min(I.min_id[R], I.id[*it]);
}
if (I.min_id[R] == I.id[R]) {
vector<int> v(1, R);
while (I.st.top() != R) {
v.push_back(I.st.top());
I.in_st[v.back()] = false;
I.st.pop();
}
I.st.pop();
I.in_st[R] = false;
SCC.push_back(v);
}
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(10);
int N, M;
cin >> N >> M;
vector<vector<int> > G(N), Gi(N);
for (int i = 0; i < M; i++) {
int u, v;
cin >> u >> v;
G[--u].push_back(--v);
Gi[v].push_back(u);
}
SCC_info I;
I.par.resize(N, -1);
I.id.resize(N, N);
I.min_id.resize(N, N);
I.in_st.resize(N, false);
I.cur_id = 0;
vector<vector<int> > SCC;
for (int i = 0; i < N; i++)
if (I.id[i] == N) DFS(i, G, I, SCC);
vector<int> SCC_id(N);
int C = SCC.size();
for (int i = 0; i < C; i++)
for (auto it = SCC[i].begin(); it != SCC[i].end(); it++) SCC_id[*it] = i;
vector<vector<int> > G_DAG(C);
vector<int> deg(C, 0);
for (int i = 0; i < N; i++)
for (auto it = G[i].begin(); it != G[i].end(); it++)
if (SCC_id[i] != SCC_id[*it]) {
G_DAG[SCC_id[i]].push_back(SCC_id[*it]);
deg[SCC_id[*it]]++;
}
vector<int> top;
for (int i = 0; i < C; i++)
if (deg[i] == 0) top.push_back(i);
int v[2] = {top[0]};
while (top.size() != 1U) {
if (SCC[top.back()].empty()) {
top.pop_back();
continue;
}
if (SCC[top[0]].empty()) {
swap(top[0], top.back());
top.pop_back();
continue;
}
v[1] = (top.back() == v[0]) ? top[0] : top.back();
int cur = 0;
while (!SCC[v[1 - cur]].empty()) {
if (is_edge(SCC[v[cur]].back(), SCC[v[1 - cur]].back()))
SCC[v[1 - cur]].pop_back();
else {
SCC[v[cur]].pop_back();
cur = 1 - cur;
}
}
for (auto it = G_DAG[v[1 - cur]].begin(); it != G_DAG[v[1 - cur]].end();
it++) {
deg[*it]--;
if (deg[*it] == 0) top.push_back(*it);
}
v[0] = v[cur];
}
cout << "! " << SCC[v[0]][0] + 1 << endl;
return 0;
}
| 11 | CPP |
x = int(input())
print("Yes") if x > 29 else print("No") | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXL = 1000010;
char s1[MAXL];
char s2[MAXL];
int cnt[MAXL][26];
int beg[MAXL];
bool ready[MAXL];
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
long long n, m;
scanf("%I64d %I64d\n%s\n%s", &n, &m, s1, s2);
int lx = strlen(s1);
int ly = strlen(s2);
char* x = s1;
char* y = s2;
if (lx > ly) {
swap(lx, ly);
swap(x, y);
swap(n, m);
}
int d = ly - lx;
for (int i = 0; i < lx; i++) {
if (!ready[i]) {
for (int j = i; !ready[j]; j = (j + d) % lx) {
beg[j] = i;
cnt[i][x[j] - 'a']++;
ready[j] = true;
}
}
}
long long res = 0;
for (int i = 0; i < ly; i++) {
res += cnt[beg[i % lx]][y[i] - 'a'];
}
res *= m / (lx / gcd(lx, ly));
res = m * ly - res;
printf("%I64d", res);
}
| 8 | CPP |
#include <iostream>
#include <map>
using namespace std;
typedef long long ll;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
map<ll, int> mp;
ll ans = 0;
ll s = 0;
mp[0] = 1;
for (int i = 0; i < n; ++i) {
int a;
cin >> a;
s += a;
ans += mp[s];
mp[s]++;
}
cout << ans << endl;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 998244353;
vector<int> v[202020];
ll dfs(int x, int p) {
ll ret = 1;
int cnt = 1;
for (auto to : v[x]) {
if (to == p) continue;
ret = ret * dfs(to, x) % mod;
ret = ret * cnt % mod;
++cnt;
}
if (x) ret = ret * cnt % mod;
return ret;
}
int main() {
int n;
cin >> n;
for (int i = (int)(0); i < (int)(n - 1); ++i) {
int x, y;
cin >> x >> y;
--x;
--y;
v[x].push_back(y);
v[y].push_back(x);
}
cout << dfs(0, -1) * n % mod << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000,100000000")
using namespace std;
const long long inf = 1e18 + 7;
const long long mod = 1e9 + 7;
const long double eps = 1e-10;
const long double PI = 2 * acos(0.0);
const long double E = 2.71828;
const long long seed = 13331;
const long long size = 500005;
int main(void) {
int n;
cin >> n;
if (n == 1) cout << "1" << endl, exit(0);
if (n == 2) cout << "2 1" << endl, exit(0);
if (n % 2 == 1) {
cout << 1 << " ";
for (int i = 2; i <= n; i++)
if (i % 2 == 0)
cout << i + 1 << " ";
else
cout << i - 1 << " ";
} else {
cout << n << " ";
for (int i = 2; i < n; i++)
if (i % 2 == 0)
cout << i + 1 << " ";
else
cout << i - 1 << " ";
cout << 1 << endl;
}
return 0;
}
| 9 | CPP |
def main():
n, k = input().split()
n = int(n)
row = ['0'] * n
for i in range(n):
row[i] = k
print(' '.join(row))
row[i] = '0'
if __name__ == "__main__":
main() | 7 | PYTHON3 |
for i in range(5):
inp = list(map(int,input().split()))
if sum(inp)==1:
ix = i
jx = inp.index(1)
print(abs(ix-2)+abs(jx-2)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
int main() {
int n;
while (~scanf("%d", &n)) {
int a[100005], sum = 0;
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
sum += a[i] - 1;
if (sum % 2 == 0)
printf("2\n");
else
printf("1\n");
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MXN = 1e6 + 1;
const int TMXN = 1e6 * 4 + 1;
const long long INFL = 1e18;
int n, p;
string second[MXN];
bool cmp(string a, string b) { return (a + b) < (b + a); }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
cin >> second[i];
}
sort(second + 1, second + 1 + n, cmp);
for (int i = 1; i <= n; i++) {
cout << second[i];
}
return 0;
}
| 9 | CPP |
for _ in range(int(input())):
n = int(input())
l = list(map(int,input().split()))
l.sort()
a = []
for i in range(1,n):
a.append(l[i]-l[i-1])
print(min(a)) | 8 | PYTHON3 |
n, k = map(int, input().split())
a = list(map(int, input().split()))
low = min(a)
high = max(a)
if high - low > k:
print('NO')
else:
print('YES')
for i in range(n):
for j in range(low):
print('1', end=' ')
for j in range(a[i] - low):
print(1 + j, end=' ')
print('')
| 8 | PYTHON3 |
#include <bits/stdc++.h>
int main() {
int n, i, j, k, l, len;
char A[105], c;
scanf("%d", &n);
scanf("%c", &c);
for (i = 0; i < n; i++) {
j = 0;
while (1) {
scanf("%c", &c);
if (c == '\n') {
break;
}
A[j++] = c;
}
A[j] = 0;
len = j;
k = l = 0;
if (len >= 5) {
if (A[0] == 'm' && A[1] == 'i' && A[2] == 'a' && A[3] == 'o' &&
A[4] == '.') {
k = 1;
}
if (A[len - 2] == 'a' && A[len - 3] == 'l' && A[len - 4] == 'a' &&
A[len - 5] == 'l' && A[len - 1] == '.') {
l = 1;
}
}
if (k == 1 && l == 0) {
printf("Rainbow's\n");
} else if (l == 1 && k == 0) {
printf("Freda's\n");
} else {
printf("OMG>.< I don't know!\n");
}
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXD = 20000;
const int MAXB = 4000;
int N, P, Q, ans[MAXD + 5], back[MAXB + 5][MAXB + 5], forw[MAXB + 5][MAXB + 5];
vector<pair<int, int> > que[MAXD + 5], itm[MAXD + 5];
void apply(int d, int m[][MAXB + 5], int *i) {
for (auto p : itm[d]) {
for (int c = 1; c <= MAXB; c++) {
m[*i][c] = max(m[*i][c - 1], m[*i - 1][c]);
if (c >= p.first)
m[*i][c] = max(m[*i][c], p.second + m[*i - 1][c - p.first]);
}
(*i)++;
}
}
void calc(int sd) {
int i = 1;
for (int d = sd; d > max(0, sd - P); d--) apply(d, back, &i);
for (int d = sd + 1, j = 1; d < min(MAXD + 1, sd + P); d++)
apply(d, forw, &j);
int j = 0;
i--;
for (int d = sd; d < min(MAXD + 1, sd + P); d++) {
for (auto p : que[d])
for (int bc = 0; bc <= p.first; bc++)
ans[p.second] = max(ans[p.second], back[i][bc] + forw[j][p.first - bc]);
if (d - P + 1 > 0) i -= itm[d - P + 1].size();
if (d + 1 <= MAXD) j += itm[d + 1].size();
}
}
int main() {
scanf("%d%d", &N, &P);
for (int i = 0, c, h, d; i < N; i++) {
scanf("%d%d%d", &c, &h, &d);
itm[d].emplace_back(c, h);
}
scanf("%d", &Q);
for (int i = 0, d, b; i < Q; i++) {
scanf("%d%d", &d, &b);
que[d].emplace_back(b, i);
}
for (int d = 1; d <= MAXD; d += P) calc(d);
for (int i = 0; i < Q; i++) printf("%d\n", ans[i]);
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:666000000")
using namespace std;
const int inf = (1 << 30) - 1;
const long double eps = 1e-9;
const long double pi = fabs(atan2(0.0, -1.0));
void ML(const bool v) {
if (v) return;
int *ass;
for (;;) {
ass = new int[2500000];
for (int i = 0; i < 2500000; i++) ass[i] = rand();
}
}
void TL(const bool v) {
if (v) return;
int *ass;
ass = new int[250];
for (;;) {
for (int i = 0; i < 250; i++) ass[i] = rand();
}
}
void PE(const bool v) {
if (v) return;
puts("ass 1 2 3 4 5 6 fuck");
exit(0);
}
long long n, m, k;
void LoAd() { cin >> n >> m >> k; }
const long long MOD = 1000000009;
long long powmod(const long long a, const long long q) {
if (0 == q) return 1;
if (1 == q % 2)
return a * powmod(a, q - 1) % MOD;
else {
long long tmp = powmod(a, q / 2);
return ((tmp) * (tmp)) % MOD;
}
}
void SoLvE() {
if (n - m >= n / k) {
cout << m;
} else {
long long canToK = (n / k * (k - 1)) + (n % k);
long long q = m - canToK;
long long lt = powmod(2, q + 1);
lt -= 2;
if (lt < 0) lt += MOD;
lt = lt * k % MOD;
lt = (lt + (canToK - (k - 1) * q)) % MOD;
cout << lt;
}
}
int main() {
srand((int)time(NULL));
LoAd();
SoLvE();
return 0;
}
| 7 | CPP |
from itertools import *
f=lambda:map(int,input().split())
g=lambda:[0]+[*accumulate(f())]
n,m,k=f()
A,B=g(),g()
a,j=0,m
for i in range(n+1):
while j and B[j]>k-A[i]: j-=1
if A[i]+B[j]<=k: a=max(a,i+j)
print(a) | 0 | PYTHON3 |
input()
A = list(map(int, input().split()))
B = list(map(int, input().split()))
sumA = sum(A)
sumB = sum(B)
if sumA < sumB:
print(-1)
exit()
D = [a-b for a, b in zip(A, B)]
D.sort()
#print(D)
mi = 0
ans = 0
for d in D:
if d < 0:
mi += d
ans += 1
for i, d in enumerate(D[::-1], 0):
if mi >= 0:
print(i+ans)
exit()
mi += d
print(i+ans)
| 0 | PYTHON3 |
#include <bits/stdc++.h>
long long int ar[10000600];
int main() {
long long int a, i, j, k;
scanf("%I64d", &a);
ar[2] = 3, ar[3] = 6;
for (i = 4; i <= a; ar[i] %= 1000000007, i++)
ar[i] = (long long int)2 * ar[i - 1] + 3 * ar[i - 2];
printf("%I64d\n", ar[a]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<string> v;
long long n, m;
long long ru[51] = {0};
long long cu[51] = {0};
int main() {
scanf("%lld", &n);
scanf("%lld", &m);
long long i;
for (i = 0; i < n; i++) {
string x;
cin >> x;
v.push_back(x);
}
for (i = 0; i < n; i++) {
set<long long> s;
for (long long j = 0; j < m; j++) {
if (v[i][j] == '#') {
for (long long k = 0; k < n; k++) {
if (v[k][j] == '#') s.insert(k);
}
}
}
set<long long> ss;
set<long long>::iterator ii = s.begin();
for (; ii != s.end(); ii++) {
long long r = (*ii);
for (long long k = 0; k < m; k++) {
if (v[r][k] == '#') ss.insert(k);
}
}
ii = s.begin();
for (; ii != s.end(); ii++) {
long long r = (*ii);
set<long long>::iterator it = ss.begin();
for (; it != ss.end(); it++) {
if (v[r][(*it)] == '.') {
cout << "No\n";
return 0;
}
v[r][(*it)] = '.';
}
}
}
cout << "Yes\n";
}
| 8 | CPP |
n,k=map(int,input().split())
i=0
while(i!=k):
m=str(n)
m=list(m)
if m[len(m)-1]=="0":
n=n//10
m=n
else:
n=n-1
m=n
i+=1
print(n)
| 7 | PYTHON3 |
from sys import stdin, gettrace
if not gettrace():
def input():
return next(stdin)[:-1]
# def input():
# return stdin.buffer.readline()
def main():
def solve():
n,k = map(int, input().split())
ss = input()
counts = [[0]*26 for _ in range((k+1)//2)]
for i in range(0,n,k):
for j in range((k+1)//2):
counts[j][ord(ss[i+j]) - ord('a')] += 1
for j in range(k//2):
counts[j][ord(ss[i+k-j-1]) - ord('a')] += 1
res = 0
for i in range(k//2):
res += 2* n//k - max(counts[i])
if k%2 == 1:
res += n//k - max(counts[-1])
print(res)
q = int(input())
for _ in range(q):
solve()
if __name__ == "__main__":
main() | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int a[(1 << 17) + 1];
int tree[4 * (1 << 17)];
void build(int nd, int s, int e, bool ex) {
if (s == e) {
tree[nd] = a[s];
return;
}
int mid = (s + e) / 2;
int left = 2 * nd;
int right = 2 * nd + 1;
build(left, s, mid, !ex);
build(right, mid + 1, e, !ex);
if (ex) {
tree[nd] = tree[left] ^ tree[right];
} else {
tree[nd] = tree[left] | tree[right];
}
}
void update(int nd, int s, int e, int p, int v, bool ex) {
if (s == e && s == p) {
tree[nd] = v;
return;
}
if (e < p || s > p) return;
int mid = (s + e) / 2;
int left = 2 * nd;
int right = 2 * nd + 1;
update(left, s, mid, p, v, !ex);
update(right, mid + 1, e, p, v, !ex);
if (ex) {
tree[nd] = tree[left] ^ tree[right];
} else {
tree[nd] = tree[left] | tree[right];
}
}
int main() {
int n, m, total;
cin >> n >> m;
total = (1 << n);
for (int i = 1; i <= total; i++) {
scanf("%d", a + i);
}
build(1, 1, total, !(n & 1));
int p, v;
while (m--) {
scanf("%d %d", &p, &v);
update(1, 1, total, p, v, !(n & 1));
cout << tree[1] << endl;
}
return 0;
}
| 10 | CPP |
import os
import heapq
import sys,threading
import math
import bisect
import operator
from collections import defaultdict
sys.setrecursionlimit(10**5)
from io import BytesIO, IOBase
def gcd(a,b):
if b==0:
return a
else:
return gcd(b,a%b)
def power(x, p,m):
res = 1
while p:
if p & 1:
res = (res * x) % m
x = (x * x) % m
p >>= 1
return res
def inar():
return [int(k) for k in input().split()]
def lcm(num1,num2):
return (num1*num2)//gcd(num1,num2)
def main():
t=int(input())
for _ in range(t):
n=int(input())
#n,k=inar()
arr=input()
lis=[]
take=1
for i in range(1,n):
if arr[i]==arr[i-1]:
take+=1
else:
lis.append(take)
take=1
lis.append(take)
if len(lis)>1:
if arr[0]==arr[-1] and len(lis)>1:
el1=lis[0]
el2=lis[-1]
lis.pop(0)
lis.pop(-1)
lis.append(el1+el2)
ans=0
#print(lis)
for i in range(len(lis)):
ans+=(lis[i])//3
print(ans)
else:
ans=0
ans+=lis[0]//3
if lis[0]%3>0:
ans+=1
print(ans)
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
#threadin.Thread(target=main).start()
| 10 | PYTHON3 |
# Author: πα
input()
a = input()
b = input()
if '*' not in a:
if a == b:
print("YES")
else:
print("NO")
else:
if len(a) > len(b) + 1:
print("NO")
else:
i = a.find('*')
l = a[:i]
r = a[i+1:]
ind = b.find(l)
if(ind):
print("NO")
else:
b = b[::-1]
ind = b.find(r[::-1])
if(ind):
print("NO")
else:
print("YES") | 7 | PYTHON3 |
n, k = input().split()
n = int(n)
k = int(k)
cnt = 0
if k == 2 or k == 1:
print(0)
elif k <= n and k % 2 == 0:
print(k // 2 - 1)
elif k <= n and k % 2 == 1:
print(k // 2)
else:
if k > 2 * n - 1:
print(0)
else:
cnt = k - n
print((n - cnt + 1) // 2) | 8 | PYTHON3 |
import math
from math import floor
m,n= input().split()
m,n = int(m), int(n)
p= floor(m*n/2)
p= int(p)
print (p) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T gcd(T a, T b) {
return (b != 0 ? gcd<T>(b, a % b) : a);
}
template <class T>
T lcm(T a, T b) {
return (a / gcd<T>(a, b) * b);
}
template <class T>
inline bool read(T &x) {
int c = getchar();
int sgn = 1;
while (~c && c < '0' || c > '9') {
if (c == '-') sgn = -1;
c = getchar();
}
for (x = 0; ~c && '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
x *= sgn;
return ~c;
}
const int INF = 2000000009;
const int MX = 200005;
const double EPS = 1e-9;
const int MOD = 1000000007;
long long a[MX];
vector<long long> sq, nsq;
int n, p, q;
long long solve1() {
vector<long long> cost;
for (int i = 0; i < q; i++) {
long long t = sqrt(nsq[i]);
cost.push_back(min(nsq[i] - t * t, (t + 1) * (t + 1) - nsq[i]));
}
sort(cost.begin(), cost.end());
long long ret = 0;
int t = (n / 2) - p;
for (int i = 0; i < t; i++) ret += cost[i];
return ret;
}
long long solve2() {
long long ret = 0;
vector<long long> cost;
for (int i = 0; i < p; i++) {
if (sq[i] == 0)
cost.push_back(2LL);
else
cost.push_back(1LL);
}
sort(cost.begin(), cost.end());
int t = (n / 2) - q;
for (int i = 0; i < t; i++) ret += cost[i];
return ret;
}
int main() {
n = ({
int a;
read(a);
a;
});
for (int i = 0; i < n; i++) {
a[i] = ({
long long a;
read(a);
a;
});
long long t = sqrt(a[i]);
if (t * t == a[i])
sq.push_back(a[i]);
else
nsq.push_back(a[i]);
}
p = (int)sq.size();
q = (int)nsq.size();
if (p == q) {
printf("0\n");
return 0;
}
if (q > p) {
printf("%lld\n", solve1());
} else {
printf("%lld\n", solve2());
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
using namespace std;
priority_queue<pair<int, int>> qx;
priority_queue<int> qx1;
priority_queue<int, vector<int>, greater<int>> qx2;
inline int read() {
int 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;
}
inline long long lread() {
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;
}
long long mypow(long long a, long long b) {
a %= mod;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
bool isSquare(int x) {
int y = sqrt(x);
return y * y == x;
}
const int maxn = 1e6 + 10;
int t, m, n;
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
int a = n / 3;
int b = n / 5;
int c = n / 7;
int f = 0;
for (int i = 0; i <= a; i++) {
for (int j = 0; j <= b; j++) {
for (int k = 0; k <= c; k++) {
if (i * 3 + j * 5 + k * 7 == n) {
f = 1;
printf("%d %d %d\n", i, j, k);
}
}
if (f) break;
}
if (f) break;
}
if (f == 0) printf("-1\n");
}
}
| 7 | CPP |
#include<iostream>
#include<queue>
#include<vector>
using namespace std;
#define MAX 100000
#define INFTY (1 << 30)
class Edge {
public:
int t, w;
Edge() {}
Edge(int t, int w) : t(t), w(w) {}
};
vector<Edge> G[MAX];
int n, d[MAX];
bool vis[MAX];
int cnt;
void bfs(int s) {
for(int i = 0; i < n; i++) d[i] = INFTY;
queue<int> Q;
Q.push(s);
d[s] = 0;
int u;
while(!Q.empty()) {
u = Q.front();
Q.pop();
for(int i = 0; i < G[u].size(); i++) {
Edge e = G[u][i];
if(d[e.t] == INFTY) {
d[e.t] = d[u] + e.w;
Q.push(e.t);
}
}
}
}
void solve() {
bfs(0);
int maxv = 0, tgt = 0;
for(int i = 0; i < n; i++) {
if(d[i] == INFTY) continue;
if(maxv < d[i]) {
maxv = d[i];
tgt = i;
}
}
bfs(tgt);
maxv = 0;
for(int i = 0; i < n; i++) {
if(d[i] == INFTY) continue;
if(maxv < d[i]) {
maxv = d[i];
}
}
cout << maxv << endl;
}
int main() {
int s, t, w;
cin >> n;
for(int i = 0; i < n - 1; i++) {
cin >> s >> t >> w;
G[s].push_back(Edge(t, w));
G[t].push_back(Edge(s, w));
}
solve();
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int in, h, m;
long long ans;
cin >> in;
for (int i = 0; i < in; ++i) {
cin >> h >> m;
ans = ((24 - h) * 60) - m;
cout << ans << '\n';
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
solve();
}
| 7 | CPP |
s=input()
h='hello'
x=0
for i in range(len(s)):
if s[i]==h[x]:
x+=1
if x==5:
print("YES")
break
else:
print("NO") | 7 | PYTHON3 |
a, b = map(int, input().split())
res = 0
while a <= b:
a *= 3
b *= 2
res +=1
if a > b:
break
print(res)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
cout << (a < 9 && b < 9 ? "Yay!" : ":(") << endl;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long res = n * (n - 1) * (n - 2) * (n - 3) * (n - 4);
res /= 120;
res *= res;
res *= 120;
cout << res << endl;
return 0;
}
| 14 | CPP |
n = int(input())
lst = []
for i in range(n):
s = str(input())
if len(s) > 10:
lst.append(s[0] + str(len(s) - 2) + s[len(s) - 1])
else:
lst.append(s)
for i in lst:
print(i)
| 7 | PYTHON3 |
X = int(input())
i = int(X**0.5)
while i >= 2:
if X % i == 0:
X += 1
i = int(X**0.5)
else:
i -= 1
print(X) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, count = 0;
cin>>n;
vector<int> s(n);
for (int i=0;i<n;i++) {
cin>>s[i];
if (s[i] != i+1) count++;
}
cout<<(count == 0 || count == 2 ? "YES":"NO")<<endl;
} | 0 | CPP |
from sys import stdin as si
from math import sqrt
from collections import Counter as c
import re
class Solution:
def __init__(self):
self.lst = []
def is_prime(self, a):
return all(a % i for i in range(2, int(a**.5)+1))
def bazinga(self, m):
if m==1 or (m > 1 and len(self.lst)==3):
return False
if m==0:
print (len(self.lst))
print (str(self.lst).replace(']','').replace('[','').replace(',',''))
exit(0)
for i in range(m,1,-1):
if self.is_prime(i):
self.lst.append(i)
if not self.bazinga(m-i):
self.lst.pop(-1)
if __name__ == '__main__':
#for i in range(int(si.readline().strip())):
m = int(si.readline().strip())
S = Solution()
S.bazinga(m) | 10 | PYTHON3 |
import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import ceil, floor, gcd, fabs, factorial, fmod, sqrt, inf
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
# sys.setrecursionlimit(pow(10, 6))
# sys.stdin = open("input.txt", "r")
# sys.stdout = open("output.txt", "w")
mod = pow(10, 9) + 7
mod2 = 998244353
def data(): return sys.stdin.readline().strip()
def out(*var, end="\n"): sys.stdout.write(' '.join(map(str, var))+end)
def l(): return list(sp())
def sl(): return list(ssp())
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]
n = int(data())
arr = l()
dp = dd(list)
for i in range(n):
j = 2
while j * j <= arr[i]:
if arr[i] % j == 0:
cnt = 0
while arr[i] % j == 0:
cnt += 1
arr[i] //= j
dp[j].append(cnt)
j += 1
if arr[i] > 1:
dp[arr[i]].append(1)
# print(temp)
# print(dp)
answer = 1
for i in dp.keys():
dp[i].sort()
if len(dp[i]) == n:
answer *= pow(i, dp[i][1])
elif len(dp[i]) == n-1:
answer *= pow(i, dp[i][0])
out(answer)
| 7 | PYTHON3 |
n = int(input())
a = int(n ** 0.5)
print(a*a) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
typedef long long ll;
typedef vector<int> vi;
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define fi first
#define se second
#define rep(i,n) rep2(i,0,n)
#define rep2(i,m,n) for(int i=m;i<(n);i++)
#define ALL(c) (c).begin(),(c).end()
#define dump(x) cout << #x << " = " << (x) << endl
class unionfind {
vector<int> par, rank;
public:
void init(int n) {
par.resize(n);
rank.resize(n);
for (int i = 0; i < n; i++) {
par[i] = i;
rank[i] = 0;
}
}
int find(int x) {
if (par[x] == x) return x;
else return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return ;
if (rank[x] < rank[y]) par[x] = y;
else {
par[y] = x;
if (rank[x] == rank[y]) ++rank[x];
}
}
bool same(int x, int y) { return (find(x) == find(y)); }
} uf;
const int MN = 200010;
using P = pair<ll, int>;
vector<pii> g[MN];
int col[MN];
ll X[MN];
vector<P> dp[MN];
void mergevec(vector<P>& a, vector<P> b) {
for (auto p : b) {
a.eb(p);
}
sort(ALL(a));
set<int> st;
vector<P> res;
for (P p : a) {
if (res.size() == 2) {
break;
}
if (!st.count(p.se)) {
st.insert(p.se);
res.eb(p);
}
}
a = res;
}
void dfs_up(int v, int p) {
dp[v].eb(X[v], col[v]);
for (pii e : g[v]) {
if (e.fi != p) {
dfs_up(e.fi, v);
vector<P> nx;
for (auto t : dp[e.fi]) {
nx.eb(t.fi + e.se, t.se);
}
mergevec(dp[v], nx);
}
}
}
void dfs_down(int v, int p, int pw) {
if (p != -1) {
vector<P> nx;
for (auto t : dp[p]) {
nx.eb(t.fi + pw, t.se);
}
mergevec(dp[v], nx);
}
for (pii e : g[v]) {
if (e.fi != p) {
dfs_down(e.fi, v, e.se);
}
}
}
int main() {
int N; cin >> N;
rep(i, N) cin >> X[i];
rep(i, N-1) {
int a, b, c;
cin >> a >> b >> c;
--a; --b;
g[a].eb(b, c);
g[b].eb(a, c);
}
uf.init(N);
rep(i, N) {
col[i] = i;
}
ll ans = 0;
while (true) {
bool one = true;
for (int i = 1; i < N; ++i) {
if (col[i] != col[0]) {
one = false;
}
}
if (one) {
break;
}
rep(i, N) {
dp[i].clear();
}
vector<P> mt(N, mp(LLONG_MAX, -1));
dfs_up(0, -1);
dfs_down(0, -1, -1);
rep(i, N) {
for (P p : dp[i]) {
if (p.se != col[i]) {
mt[col[i]] = min(mt[col[i]], mp(p.fi + X[i], p.se));
break;
}
}
}
rep(i, N) if (mt[i] != mp(LLONG_MAX, -1)) {
int u = i, v = mt[i].se;
ll cost = mt[i].fi;
if (!uf.same(u, v)) {
uf.unite(u, v);
ans += cost;
}
}
rep(i, N) {
col[i] = uf.find(col[i]);
}
}
cout << ans << endl;
return 0;
} | 0 | CPP |
n = int(input())
s = input()
info = [list(map(int, input().split())) for i in range(n)]
li = [[0] * 20000 for i in range(n)]
for lump in range(n):
for i in range(20000):
a, b = info[lump]
init = int(s[lump])
if 0 <= i <= b - 1:
li[lump][i] = init
else:
li[lump][i] = ((1 + ((i - b) // a)) % 2) ^ init
ans = 0
for i in range(20000):
tmp = 0
for lump in range(n):
tmp += li[lump][i]
ans = max(ans, tmp)
print(ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long int fun(int i) {
long long int sum = pow(2, i + 1) - 1;
return sum;
}
int main() {
int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
vector<int> v;
long long int sum = 0;
int i = 0;
while (n) {
if (n & 1) {
v.push_back(i);
}
i++;
n = n >> 1;
}
if (v.size() == 1) {
sum = fun(v[0]);
} else {
for (int j = 0; j < v.size(); j++) {
sum += fun(v[j]);
}
}
cout << sum << endl;
}
return 0;
}
| 9 | CPP |
n = int(input()) # the length of the string t
t = input() # string t
t2 = list(t)
divisors = []
i = 1
while i <= n:
if n % i == 0:
divisors.append(i-1)
i += 1
for i in range(len(divisors) - 1, -1, -2):
for k in range(divisors[i], divisors[i - 1], -1):
print(t[k], end='')
del t2[k]
for c in t2:
print(c, end='')
| 8 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
const int N=15;
string s[10];
int n,m,k,res;
int main(){
cin>>n>>m>>k;
for(int i=0;i<n;i++){
cin>>s[i];
}
int x=(1<<(n));
int y=(1<<(m));
for(int i=0;i<x;i++){
for(int j=0;j<y;j++){
int cnt=0;
for(int a=0;a<n;a++){
for(int b=0;b<m;b++){
if(((i>>a)&1)||((j>>b)&1)||s[a][b]=='.')continue;
cnt++;
}
}
if(cnt==k)res++;
}
}
cout<<res;
} | 0 | CPP |
#include<bits/stdc++.h>
#define ll long long
using namespace std;
signed main() {
int a;
while (scanf("%d", &a), a) {
int p = a;
map<int, int>c;
for (int b = 2; b < sqrt(a); b++) {
while(a%b==0){
a /= b;
c[b]++;
}
}
if (a != 1)c[a]++;
ll s = 1;
for (auto k = c.begin(); k != c.end(); k++) {
int x = 0, y = 1;
for (int z = 0; z <= k->second; z++) {
x += y;
y *= k->first;
}
s *= x;
}
s -= p;
if (p == s)puts("perfect number");
else if (p > s)puts("deficient number");
else puts("abundant number");
}
} | 0 | CPP |
x = int(input())
a = list()
while x > 0:
a.append(input())
x -= 1
for y in a:
if len(y) > 10:
print(f'{y[0]}{len(y) - 2}{y[-1]}')
else:
print(y)
| 7 | PYTHON3 |
#include <iostream>
using namespace std;
int main(){
int a,b,c;cin>>a>>b>>c;
string str="Close";
if((a==1&&b==1) || c==1) str="Open";
cout<<str<<endl;
}
| 0 | CPP |
n=int(input())
s=(4,7,44,47,444,447,474,477)
for i in s:
if n%i==0:
print("YES")
break
else:
print("NO")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
int IntMaxVal = (int)1e20;
int IntMinVal = (int)-1e20;
long long LongMaxVal = (long long)1e20;
long long LongMinVal = (long long)-1e20;
using namespace std;
template <typename T>
struct argument_type;
template <typename T, typename U>
struct argument_type<T(U)> {};
template <typename T1, typename T2>
istream& operator>>(istream& is, pair<T1, T2>& s) {
is >> s.first >> s.second;
return is;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (int i = 0; i < v.size(); i++) os << v[i] << ' ';
os << endl;
return os;
}
int main() {
srand(time(NULL));
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
;
string t;
cin >> t;
;
int n = s.length();
int m = t.length();
vector<int> before(n);
for (int i = 1; i < n; ++i) {
before[i] = before[i - 1];
if (before[i] < m && s[i - 1] == t[before[i]]) before[i]++;
}
vector<int> after(n);
for (int i = n - 1; i >= 0; --i) {
if (i < n - 1) after[i] = after[i + 1];
if (after[i] < m && s[i] == t[m - 1 - after[i]]) after[i]++;
}
int charPointer[m][200];
for (char c = 'a'; c <= 'z'; c++) charPointer[m - 1][c] = -1;
charPointer[m - 1][t.back()] = m - 1;
for (int i = m - 2; i >= 0; --i) {
for (char c = 'a'; c <= 'z'; c++) charPointer[i][c] = charPointer[i + 1][c];
charPointer[i][t[i]] = i;
}
for (int i = 0; i < n; ++i) {
if (after[i] == 0) {
cout << "No";
return 0;
}
int mn = m - after[i];
mn = charPointer[mn][s[i]];
if (mn == -1) {
cout << "No";
return 0;
}
if (before[i] < mn) {
cout << "No";
return 0;
}
}
cout << "Yes";
}
| 10 | CPP |
# -*- coding: utf-8 -*-
"""
Created on Thu Jun 25 17:15:02 2020
@author: pc612
"""
count = 0
s = int(input())
n = input()
for i in range(len(n)-1):
j = i+1
if n[i]==n[j]:
count += 1
print(count) | 7 | PYTHON3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.