solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, n, s;
cin >> n;
int a[n], b[n];
for (i = 0; i < n; i++) {
cin >> a[i];
b[i] = i + 1;
}
for (i = 0; i < n - 1; i++) {
for (j = i + 1; j < n; j++) {
if (a[i] > a[j]) {
s = a[i];
a[i] = a[j];
a[j] = s;
s = b[i];
b[i] = b[j];
b[j] = s;
}
}
}
cout << b[n - 1] << " " << a[n - 2];
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using vi = std::vector<int>;
using vll = std::vector<long long>;
using vull = std::vector<unsigned long long>;
void setIO(std::ifstream &readFile, std::ofstream &writeFile,
const std::string &name = "", bool stdIO = false) {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
if (!name.empty() && !stdIO) {
readFile.open(name + ".in");
if (readFile.fail()) return;
writeFile.open(name + ".out");
std::cin.rdbuf(readFile.rdbuf());
std::cout.rdbuf(writeFile.rdbuf());
}
}
class Timer {
std::chrono::time_point<std::chrono::high_resolution_clock> m_beg;
public:
Timer() : m_beg(std::chrono::high_resolution_clock::now()) {}
void reset() { m_beg = std::chrono::high_resolution_clock::now(); }
[[nodiscard]] long double elapsed() const {
return std::chrono::duration_cast<
std::chrono::duration<long double, std::ratio<1>>>(
std::chrono::high_resolution_clock::now() - m_beg)
.count();
}
};
using dt = int;
constexpr dt MAXN = std::numeric_limits<dt>::max();
constexpr dt MOD = 1e9 + 7;
constexpr long double EPS = 1e-9;
int main(int argc, char *argv[]) {
static std::ifstream readFile;
static std::ofstream writeFile;
setIO(readFile, writeFile, "");
dt n, m, x;
cin >> n >> m >> x;
unordered_map<char, vector<pair<dt, dt>>> letters;
vector<pair<dt, dt>> shifts;
for (auto i = (0); i < (n); ++i)
for (auto j = (0); j < (m); ++j) {
char c;
cin >> c;
if (c == 'S')
shifts.emplace_back(i, j);
else
letters[c].emplace_back(i, j);
}
vector<vector<bool>> works(n, vector<bool>(m, false));
for (auto i = (0); i < (n); ++i)
for (auto j = (0); j < (m); ++j)
for (auto &shift : shifts)
if (pow(i - shift.first, 2) + pow(j - shift.second, 2) <= x * x) {
works[i][j] = true;
break;
}
dt answer = 0;
dt q;
string s;
cin >> q >> s;
for (auto &c : s) {
if (!letters.count(tolower(c)) || isupper(c) && shifts.empty())
return cout << -1, 0;
if (islower(c)) continue;
bool work = false;
for (auto &letter : letters[tolower(c)])
if (works[letter.first][letter.second]) {
work = true;
break;
}
answer += !work;
}
cout << answer;
}
| 8 | CPP |
N,L=map(int,input().split())
A=list(map(int,input().split()))
for i in range(0,N-1):
if A[i]+A[i+1]>=L:
print('Possible')
for j in range(1,i+1):
print(j)
T=[]
for j in range(i+2,N):
T.append(j)
T.sort(reverse=True)
for j in range(0,len(T)):
print(T[j])
print(i+1)
break
else:
print('Impossible') | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
long long pw[13];
long long getnum(long long x) { return *lower_bound(pw, pw + 13, x); }
long long val[100010];
struct Tree {
long long mn;
long long tag;
long long add;
} T[400010];
void update(int root) {
T[root].mn = min(T[root << 1].mn, T[root << 1 | 1].mn);
return;
}
void pushdown(int root) {
int lch = root << 1;
int rch = root << 1 | 1;
if (T[root].tag) {
T[lch].mn = T[root].tag;
T[rch].mn = T[root].tag;
T[lch].add = T[rch].add = 0;
T[lch].tag = T[rch].tag = T[root].tag;
T[root].tag = 0;
}
if (T[root].add) {
T[lch].mn += T[root].add;
T[rch].mn += T[root].add;
T[lch].add += T[root].add;
T[rch].add += T[root].add;
T[root].add = 0;
}
return;
}
void change(int root, int l, int r, int x, long long y) {
if (l == r) {
val[x] = getnum(y);
T[root].mn = val[x] - y;
T[root].add = T[root].tag = 0;
return;
}
pushdown(root);
int mid = (l + r) >> 1;
if (x <= mid)
change(root << 1, l, mid, x, y);
else
change(root << 1 | 1, mid + 1, r, x, y);
update(root);
return;
}
void clear(int root, int l, int r, int x, int y) {
if (x <= l && r <= y) {
T[root].mn = INF;
T[root].tag = INF;
T[root].add = 0;
return;
}
int mid = (l + r) >> 1;
pushdown(root);
if (x <= mid) clear(root << 1, l, mid, x, y);
if (y > mid) clear(root << 1 | 1, mid + 1, r, x, y);
update(root);
return;
}
void dec(int root, int l, int r, int x, int y, long long v) {
if (x <= l && r <= y) {
T[root].mn -= v;
T[root].add -= v;
return;
}
pushdown(root);
int mid = (l + r) >> 1;
if (x <= mid) dec(root << 1, l, mid, x, y, v);
if (y > mid) dec(root << 1 | 1, mid + 1, r, x, y, v);
update(root);
return;
}
long long query(int root, int l, int r, int x) {
if (l == r) return val[x] - T[root].mn;
int mid = (l + r) >> 1;
pushdown(root);
if (x <= mid)
return query(root << 1, l, mid, x);
else
return query(root << 1 | 1, mid + 1, r, x);
}
long long work(int root, int l, int r) {
if (T[root].mn > 0) return T[root].mn;
if (l == r) {
long long x = val[l] - T[root].mn;
val[l] = getnum(x);
T[root].mn = val[l] - x;
T[root].add = T[root].tag = 0;
return T[root].mn;
}
int mid = (l + r) >> 1;
pushdown(root);
work(root << 1, l, mid);
work(root << 1 | 1, mid + 1, r);
update(root);
return T[root].mn;
}
int n, q;
set<int> S;
void calc(int x) {
if (x < 1 || x > n) return;
set<int>::iterator it = S.lower_bound(x);
if (*it == x) return;
int pos = *it;
val[x] = val[pos];
change(1, 1, n, x, query(1, 1, n, pos));
S.insert(x);
return;
}
void Query1(int x) {
calc(x);
printf("%I64d\n", query(1, 1, n, x));
return;
}
void Query2(int l, int r, long long x) {
calc(l - 1);
calc(r);
S.erase(S.lower_bound(l), S.lower_bound(r));
if (l < r) clear(1, 1, n, l, r - 1);
change(1, 1, n, r, x);
return;
}
void Query3(int l, int r, long long x) {
calc(l - 1);
calc(r);
do {
dec(1, 1, n, l, r, x);
} while (!work(1, 1, n));
return;
}
int main() {
scanf("%d %d", &n, &q);
pw[0] = 1;
for (int i = 1; i <= 11; i++) pw[i] = pw[i - 1] * 42;
pw[12] = INF;
for (int i = 1; i <= n; i++) {
S.insert(i);
long long x;
scanf("%I64d", &x);
change(1, 1, n, i, x);
}
while (q--) {
int op;
scanf("%d", &op);
if (op == 1) {
int x;
scanf("%d", &x);
Query1(x);
} else if (op == 2) {
int l, r;
long long x;
scanf("%d %d %I64d", &l, &r, &x);
Query2(l, r, x);
} else {
int l, r;
long long x;
scanf("%d %d %I64d", &l, &r, &x);
Query3(l, r, x);
}
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k, path[2007], a[1000007];
bool vis[2007];
int bfs(int u) {
queue<int> q;
q.push(u);
vis[u] = 1;
int to;
while (!q.empty()) {
u = q.front();
q.pop();
for (int i = 0; i < k; i++) {
to = u + a[i];
if (to == 0) return u + 1000;
if (-1000 <= to && to <= 1000) {
int x = to + 1000;
if (vis[x] == 0) {
vis[x] = 1;
q.push(to);
path[x] = u + 1000;
}
}
}
}
return -1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
memset(vis, 0, sizeof(vis));
memset(path, 0, sizeof(path));
scanf("%d%d", &n, &k);
for (int i = 0; i < k; i++) {
scanf("%d", &a[i]);
a[i] = a[i] - n;
}
sort(a, a + k);
k = unique(a, a + k) - a;
int ans = bfs(0);
if (ans == -1)
printf("-1");
else {
int cnt = 1;
while (path[ans] != 0) ans = path[ans], cnt++;
printf("%d", cnt);
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vll = vector<ll>;
using pi = pair<int, int>;
using pll = pair<ll, ll>;
using matrix = vector<vll>;
constexpr ll MOD = 1000000007;
constexpr ll INI = -1;
constexpr ll IN = 350 + 10;
constexpr ll INF = 1e9 + 1;
constexpr ld EPS = 1e-9;
inline ll two(ll n) { return 1 << n; }
inline bool EQ(ld a, ld b) { return fabs(a - b) < EPS; }
inline bool is_set(ll n, ll k) { return (n >> k) & 1; }
inline void set_bit(ll &n, ll k) { n |= two(k); }
inline void unset_bit(ll &n, ll k) { n &= ~two(k); }
inline ll last_bit(ll n) { return n & (-n); }
inline ll ones(ll n) {
ll res = 0;
while (n && ++res) n -= last_bit(n);
return res;
}
inline ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }
inline ll lcm(ll a, ll b) { return a * (b / gcd(a, b)); }
string s;
int k;
int smallest[1000000];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.setf(ios::fixed);
cout.precision(20);
smallest[0] = 'z';
cin >> s;
for (int i = 1; i <= s.length(); ++i) {
smallest[i] = s[i - 1];
if (smallest[i] > smallest[i - 1]) smallest[i] = smallest[i - 1];
}
for (int i = 1; i <= s.length(); ++i) {
if (smallest[i] < s[i - 1])
cout << "Ann\n";
else
cout << "Mike\n";
}
return 0;
}
| 9 | CPP |
for _ in range(int(input())):
(p,q,r)=map(int,input().split())
c=0
while(1):
if(r>=2 and q>=1):
r=r-2
q=q-1
c=c+3
else:
break
while(1):
if(q>=2 and p>=1):
q=q-2
p=p-1
c=c+3
else:
break
print(c)
| 7 | PYTHON3 |
T = int(input())
while T:
n = int(input())
a = [int(_) for _ in input().split(' ')]
a.sort()
max_1 = a[-1]
max_2 = a[-2]
print(min(min(max_2, max_1) - 1, n - 2))
T = T - 1
| 7 | PYTHON3 |
n = int(input())
w = [None]*n
for i in range(n):
x,y = map(int,input().split())
w[i] = (x,y)
w.sort()
eq = 0
np = 0
xeq = 0
for i in range(n):
eq += 1
if i+1==n or w[i][0] != w[i+1][0]:
#print("keq",eq)
comb = eq*(eq-1)//2
np += comb
eq = 0
if i>0 and w[i][0] == w[i-1][0] and w[i][1]==w[i-1][1]:
xeq += 1
elif xeq>0:
xcomb = xeq*(xeq+1)//2
np -= xcomb
xeq = 0
if xeq>0:
xcomb = xeq*(xeq+1)//2
np -= xcomb
xeq = 0
def sortSecond(val):
return val[1]
w.sort(key=sortSecond)
eq = 0
for i in range(n):
eq += 1
if i+1==n or w[i][1] != w[i+1][1]:
#print("eq",eq)
comb = eq*(eq-1)//2
np += comb
eq = 0
print(np)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int d1, d2, d3;
scanf("%d%d%d", &d1, &d2, &d3);
int ans = min(d1 * 2 + d2 * 2, d1 + d2 + d3);
ans = min(ans, d1 * 2 + d3 * 2);
ans = min(ans, d2 * 2 + d3 * 2);
printf("%d\n", ans);
return 0;
}
| 7 | CPP |
a,b,c=map(int,input().split())
d=0
while d<10:
c=a*c-b
print(c)
d+=1
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2048 + 5;
const int MOD = 1e9 + 7;
int n, k;
int dp[MAXN][MAXN];
int a[MAXN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
if (a[0] == 0)
dp[0][2] = 1, dp[0][4] = 1;
else
dp[0][a[0]] = 1;
for (int i = 1; i < n; i++) {
for (int j = 0; j <= (1 << k); j++) {
int tmp = min(j + 2, (1 << k));
int tmp2 = min(j + 4, (1 << k));
if (a[i] == 2 || a[i] == 0)
dp[i][tmp] = (dp[i][tmp] + dp[i - 1][j]) % MOD;
if (a[i] == 4 || a[i] == 0) {
if (j & 2)
dp[i][4] = (dp[i][4] + dp[i - 1][j]) % MOD;
else
dp[i][tmp2] = (dp[i][tmp2] + dp[i - 1][j]) % MOD;
}
}
}
cout << dp[n - 1][(1 << k)] << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct elem {
int id;
double w;
};
int cmp(elem a, elem b) {
if (a.w > b.w)
return 1;
else if (a.w == b.w && a.id < b.id)
return 1;
return 0;
}
int main() {
int n, t1, t2, k;
scanf("%d %d %d %d", &n, &t1, &t2, &k);
elem mas[1010];
for (int i = 0; i < n; i++) {
int a, b;
scanf("%d %d", &a, &b);
mas[i].id = i + 1;
mas[i].w = max((double)a * (double)t1 / (double)100 * (double)(100 - k) +
(double)b * (double)t2,
(double)b * (double)t1 / (double)100 * (double)(100 - k) +
(double)a * (double)t2);
}
sort(mas, mas + n, cmp);
for (int i = 0; i < n; i++) {
printf("%d %.2f\n", mas[i].id, mas[i].w);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int tab[100][100];
int seed = 1304104130;
int abs(int x) {
if (x < 0)
return -x;
else
return x;
}
int rand() { return seed = abs(seed * 12493LL + 142412 % 1000000009); }
int best(int a) {
int last = -1;
for (int i = 1; i * i < a; ++i) {
if (a % i == 0 && (a / i - i) % 2 == 0) last = (a / i - i) / 2;
}
return last;
}
bool issq(int x) {
int min = 0, max = x;
while (min <= max) {
long long int med = (min + max) / 2;
if (med * med == x)
return true;
else if (med * med > x)
max = med - 1;
else
min = med + 1;
}
return false;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
if (n == 1 && m == 1) {
printf("1\n");
return 0;
} else if (n == 1) {
for (int i = 0; i < m - 1; ++i) printf("3 ");
printf("%d\n", best(9 * (m - 1)));
return 0;
} else if (m == 1) {
for (int i = 0; i < n - 1; ++i) printf("3\n");
printf("%d\n", best(9 * (n - 1)));
return 0;
}
while (true) {
for (int i = 0; i < n - 1; ++i)
for (int k = 0; k < m - 1; ++k) tab[i][k] = rand() % 3 * 8 + 8;
for (int i = 0; i < n - 1; ++i) {
int sum = 0;
for (int k = 0; k < m - 1; ++k) sum += tab[i][k] * tab[i][k];
tab[i][m - 1] = 2 * best(sum / 4);
}
for (int k = 0; k < m - 1; ++k) {
int sum = 0;
for (int i = 0; i < n - 1; ++i) sum += tab[i][k] * tab[i][k];
tab[n - 1][k] = 2 * best(sum / 4);
}
int sum1 = 0, sum2 = 0;
for (int i = 0; i < n - 1; ++i) sum1 += tab[i][m - 1] * tab[i][m - 1];
for (int k = 0; k < m - 1; ++k) sum2 += tab[n - 1][k] * tab[n - 1][k];
for (int div = 1; div * div < sum1; ++div)
if (sum1 % div == 0 && (div + sum1 / div) % 2 == 0) {
int r = (sum1 / div - div) / 2;
if (issq(r * r + sum2)) {
tab[n - 1][m - 1] = r;
for (int i = 0; i < n; ++i) {
for (int k = 0; k < m; ++k) printf("%d ", tab[i][k]);
putchar(10);
}
return 0;
}
}
}
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7;
const int N = 105, M = 10005;
const double pi = acos(-1);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int a[N], num[N], f[N][M], g[N][M];
int n, m, nm;
bool flag = false;
int main() {
cin >> n;
for (int i = (1); i <= (n); ++i) cin >> a[i], num[a[i]]++;
sort(a + 1, a + n + 1);
for (int i = (1); i <= (n); ++i) m += (a[i] != a[i - 1]);
if (m == 1) {
cout << n << endl;
return 0;
}
if (m == 2) flag = true;
f[0][0] = 1;
m = nm = 0;
for (int w = (1); w <= (100); ++w)
if (num[w]) {
swap(f, g);
for (int j = (0); j <= (nm); ++j)
for (int k = (0); k <= (m); ++k) f[j][k] = 0;
m += w * num[w], nm += num[w];
for (int i = (num[w]); i >= (0); --i) {
for (int j = (nm); j >= (i); --j)
for (int k = (m); k >= (w * i); --k) {
f[j][k] = min(10, f[j][k] + g[j - i][k - w * i]);
}
}
}
int ans = 1;
for (int w = (1); w <= (100); ++w)
for (int i = (1); i <= (num[w]); ++i)
if (f[i][w * i] == 1) ans = max(ans, i);
if (flag) {
int c = 0;
for (int i = (1); i <= (n); ++i)
if (a[i] == a[1]) c++;
if (f[c][c * a[1]] == 1 && f[n - c][(n - c) * a[n]] == 1) ans = n;
}
cout << ans << endl;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int num[105];
int main() {
memset(num, 0, sizeof(num));
int n, m;
cin >> n >> m;
int ans[m];
int to = 0;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (num[a] == 0) {
num[a]++;
ans[to] = i + 1;
to++;
}
if (to == m) break;
}
if (to < m) {
cout << "NO";
} else {
cout << "YES\n";
for (int i = 0; i < m; i++) {
cout << ans[i] << " ";
}
}
}
| 7 | CPP |
def f(x):
return sum(x[:3]) == sum(x[3:])
def main():
a = [int(i) for i in input()]
if f(a):
return 0
for i in range(6):
for j in range(10):
b = a[:]
b[i] = j
if f(b):
return 1
for i in range(6):
for j in range(i):
for k in range(10):
for l in range(10):
b = a[:]
b[i] = k
b[j] = l
if f(b):
return 2
return 3
print(main())
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long l, r;
cin >> l >> r;
if (l == 3 && r == 6)
cout << "3" << endl;
else if (l == r)
cout << l << endl;
else
cout << "2" << endl;
return 0;
}
| 7 | CPP |
N=int(input())
c='No'
for n in range(1,10):
if N%n==0 and 1<=N//n<=9:
c='Yes'
break
print(c) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.1415926535897;
const long long mod = 1000000007LL;
const long long INF = 1e18;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, m;
cin >> n >> m;
vector<vector<long long>> g(n + 1, vector<long long>());
long long u, v;
for (long long i = 0; i < m; i++) {
cin >> u >> v;
g[u].push_back(v - u);
if (g[u].back() < 0) g[u].back() += n;
g[v].push_back(u - v);
if (g[v].back() < 0) g[v].back() += n;
}
for (auto &v : g) {
sort(v.begin(), v.end());
}
auto f = [&](long long x) { return (x % n == 0 ? n : x % n); };
auto ch = [&](long long i) {
bool fl = 1;
for (long long j = 1; j <= n; j++) {
fl = fl && (g[j] == g[f(j + i)]);
}
return fl;
};
for (long long i = 1; i * i <= n; i++) {
if (n % i != 0) continue;
if (ch(i) || (n / i != n && ch(n / i))) {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
| 8 | CPP |
t=int(input())
for _ in range(t):
n,k=list(map(int,input().split()))
if n==1 or n==2:
print(1)
else:
print(((n-3)//k)+2)
| 7 | PYTHON3 |
n = int(input())
t = list(map(int, input().split()))
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
if not any(ti == ai == t[-1] == a[0] for ti, ai in zip(t, a)):
print(0)
exit()
ans = 1
for i in range(1, n - 1):
if t[i - 1] == t[i] and a[i] == a[i + 1]:
ans = ans * min(t[i], a[i]) % mod
print(ans)
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
cin >> n;
int m = sqrt(n * 2);
if (m * m + m == 2 * n)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
vector<int> g[maxn];
int s[maxn];
int par[maxn], _rank[maxn];
void init(int n) {
for (int i = 1; i <= n; i++) {
par[i] = i;
_rank[i] = 0;
}
}
int find(int x) {
if (par[x] == x) return x;
return par[x] = find(par[x]);
}
inline 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]++;
}
}
inline bool same(int x, int y) { return find(x) == find(y); }
bool used[maxn];
pair<int, int> edge[maxn];
int dep[maxn], sum[maxn];
void dfs(int u, int fa) {
sum[u] = s[u];
for (int i = 0; i < (int)g[u].size(); i++) {
int v = g[u][i];
if (v == fa) continue;
dep[v] = dep[u] + 1;
dfs(v, u);
sum[u] += sum[v];
}
}
int main() {
int n, tot_s = 0, x, y;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", s + i);
tot_s += s[i];
}
if (tot_s != 0) {
puts("Impossible");
} else {
init(n);
int m;
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
edge[i] = pair<int, int>(x, y);
if (!same(x, y)) {
unite(x, y);
used[i] = true;
g[x].push_back(y);
g[y].push_back(x);
}
}
dfs(1, -1);
puts("Possible");
for (int i = 1; i <= m; i++) {
if (used[i]) {
int x = edge[i].first, y = edge[i].second;
if (dep[x] < dep[y]) {
printf("%d\n", sum[y]);
} else {
printf("%d\n", -sum[x]);
}
} else {
puts("0");
}
}
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int p = 1e9 + 7;
long long qpow(long long a, long long n) {
long long res = 1;
while (n) {
if (n & 1) res = res * a % p;
a = a * a % p;
n >>= 1;
}
return res;
}
char a[N];
int b[N];
long long pre[N];
void work() {
scanf("%s", a + 1);
int n = strlen(a + 1);
for (int i = 1; i <= n; i++) {
b[i] = a[i] - '0';
}
long long ans = 0;
pre[0] = 0;
for (int i = 1; i <= n; i++) {
pre[i] = (pre[i - 1] + i * qpow(10, i - 1)) % p;
}
for (int i = 1; i <= n; i++) {
ans = ans + b[i] * pre[n - i] % p +
1ll * b[i] * (i) % p * (i - 1) % p * qpow(2, p - 2) % p *
qpow(10, n - i) % p;
ans %= p;
}
printf("%lld\n", ans);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T = 1;
while (T--) {
work();
}
}
| 9 | CPP |
n = int(input())
xpos, ypos = [], []
for x in range(n):
string = input()
numbers = string.split()
xpos.append(int(numbers[0]))
ypos.append(int(numbers[1]))
print(max(max(xpos) - min(xpos), max(ypos) - min(ypos)) ** 2) | 8 | PYTHON3 |
#include <iostream>
#include <cstdlib>
using namespace std;
const int INF = (1<<29);
int main(){
int n,m;
while(cin >> n >> m && (n || m)){
int dp[150][10][80], a[150][10], x[150][10];
for(int i=0;i<150;i++){
for(int j=0;j<10;j++){
for(int k=0;k<80;k++) dp[i][j][k] = INF;
a[i][j] = INF;
}
}
for(int i=0;i<n;i++){
int k;
cin >> k;
for(int j=0;j<k;j++){
int b,c;
cin >> b >> c;
x[i][j] = b;
a[i][j] = c;
}
}
for(int i=0;i<10;i++){
dp[0][i][0] = 0;
if(m != 1) dp[1][i][1] = 0;
}
for(int i=0;i<n-1;i++){
for(int l=0;l<=m;l++){
for(int j=0;j<10;j++){
if(a[i][j] == INF) continue;
for(int k=0;k<10;k++){
if(a[i+1][k] == INF) continue;
dp[i+1][k][l] = min(dp[i+1][k][l],dp[i][j][l] + (a[i][j] + a[i+1][k]) * (abs(x[i+1][k]-x[i][j])));
}
if(i < n - 2 && l != m){
for(int k=0;k<10;k++){
if(a[i+2][k] == INF) continue;
dp[i+2][k][l+1] = min(dp[i+2][k][l+1],dp[i][j][l] + (a[i][j] + a[i+2][k]) * (abs(x[i+2][k]-x[i][j])));
}
}
}
}
}
int ans = INF;
for(int j=0;j<=m;j++) for(int k=0;k<10;k++) ans = min(ans,dp[n-1][k][j]);
for(int j=0;j<m;j++) for(int k=0;k<10;k++) ans = min(ans,dp[n-2][k][j]);
cout << ans << endl;
}
return 0;
} | 0 | CPP |
l=[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43,47,53]
a,b=map(int,input().split())
i=l.index(a)
if b==l[i+1]:
print('YES')
else:
print('NO') | 7 | PYTHON3 |
#include <iostream>
using namespace std;
int main(){
int a,b,c;
cin>>a>>b>>c;
int fac=1;
if(a==b&&a==c) fac=0;
if(a!=b&&b!=c&&a!=c) fac=0;
cout<<(fac?"Yes":"No")<<endl;
return 0;
} | 0 | CPP |
# 716A
# O(n) time
# θ(n) space
__author__ = 'artyom'
# SOLUTION
def main():
n, c = read(3)
a = read(3)
i = n - 1
while i > 0 and a[i] - a[i - 1] <= c:
i -= 1
return n - i
# HELPERS
def read(mode=1, size=None):
# 0: String
# 1: Integer
# 2: List of strings
# 3: List of integers
# 4: Matrix of integers
if mode == 0: return input().strip()
if mode == 1: return int(input().strip())
if mode == 2: return input().strip().split()
if mode == 3: return list(map(int, input().strip().split()))
a = []
for _ in range(size):
a.append(read(3))
return a
def write(s="\n"):
if s is None: s = ''
if isinstance(s, tuple) or isinstance(s, list): s = ' '.join(map(str, s))
s = str(s)
print(s, end="\n")
res = main()
write(res) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y, z;
int num;
} a[100005];
int n, c[100005];
bool cmp(point p, point q) {
if (p.x != q.x)
return p.x < q.x;
else if (p.y != q.y)
return p.y < q.y;
else
return p.z < q.z;
}
int dist(point p, point q) {
return abs(p.x - q.x) + abs(p.y - q.y) + abs(p.z - q.z);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d %d", &a[i].x, &a[i].y, &a[i].z);
a[i].num = i + 1;
}
sort(a, a + n, cmp);
for (int i = 0; i < n - 1; i++) {
if (a[i].x == a[i + 1].x && a[i].y == a[i + 1].y) {
printf("%d %d\n", a[i].num, a[i + 1].num);
c[i] = c[i + 1] = 1;
i++;
}
}
int en = 1;
for (int i = 0; i < n - 1;) {
while (c[i]) i++;
en = i + 1;
while (c[en] && en < n) en++;
if (en >= n) break;
if (a[i].x == a[en].x) {
printf("%d %d\n", a[i].num, a[en].num);
c[i] = c[en] = 1;
i = en + 1;
} else
i = en;
}
for (int i = 0; i < n - 1;) {
while (c[i]) i++;
en = i + 1;
while (c[en] && en < n) en++;
if (en >= n) break;
printf("%d %d\n", a[i].num, a[en].num);
c[i] = c[en] = 1;
i = en + 1;
}
}
| 9 | CPP |
n = input()
queue = input().split()
p25 = 0
p50 = 0
p100 = 0
result = 'YES'
for note in queue:
if note == '25':
p25 += 1
elif note == '50':
if p25 > 0:
p50 += 1
p25 -= 1
else:
result = 'NO'
break
elif note == '100':
if p50 > 0 and p25 > 0:
p50 -= 1
p25 -= 1
p100 += 1
elif p25 > 2:
p25 -= 3
p100 += 1
else:
result = 'NO'
break
print(result) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int ff(int x, int y) {
if (y % x == 0)
if (x == 1)
return y - 1;
else
return 1000000007;
return ff(y % x, x) + y / x;
}
int main() {
int n;
scanf("%d", &n);
int S = 1000000007;
for (int i = 1; i <= n; i++) S = min(S, ff(i, n));
printf("%d\n", S);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const long long ooo = 9223372036854775807ll;
const int _cnt = 1000 * 1000 + 7;
const int _p = 1000 * 1000 * 1000 + 7;
const int N = 200005;
const double PI = acos(-1.0);
const double eps = 1e-9;
int o(int x) { return x % _p; }
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
void file_put() {
freopen("filename.in", "r", stdin);
freopen("filename.out", "w", stdout);
}
int n, m, tot = 0;
int **a, b[N];
bool t = 0;
int main() {
scanf("%d%d", &n, &m);
if (n > m) swap(n, m), t = 1;
if (n == 1 && m == 1) return 0 * printf("YES\n1\n");
if ((n == 1 || n == 2) && (m == 2 || m == 3)) return 0 * printf("NO\n");
printf("YES\n");
if (n == 1 && m == 4) return 0 * printf("3 1 4 2\n");
if (n == 1 && m >= 5) {
for (int i = (1); i <= (m); ++i)
if (((i)&1)) b[++tot] = i;
for (int i = (1); i <= (m); ++i)
if (!((i)&1)) b[++tot] = i;
if (t)
for (int i = (1); i <= (m); ++i) printf("%d\n", b[i]);
else
for (int i = (1); i <= (m); ++i) printf("%d%c", b[i], " \n"[i == m]);
return 0;
}
if (n == 3 && m == 3) return 0 * printf("4 3 8\n9 5 1\n2 7 6\n");
a = new int *[n + 10];
for (int i = (0); i <= (n); ++i) a[i] = new int[m + 10];
if (t)
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (m); ++j) a[i][j] = (j - 1) * n + i;
else
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (m); ++j) a[i][j] = (i - 1) * m + j;
for (int i = (1); i <= (n); ++i)
if (!((i)&1)) {
b[1] = a[i][m - 1], b[2] = a[i][m];
for (int j = (1); j <= (m - 2); ++j) b[j + 2] = a[i][j];
for (int j = (1); j <= (m); ++j) a[i][j] = b[j];
}
for (int i = (1); i <= (m); ++i)
if (!((i)&1)) {
b[1] = a[n][i];
for (int j = (1); j <= (n - 1); ++j) b[j + 1] = a[j][i];
for (int j = (1); j <= (n); ++j) a[j][i] = b[j];
}
if (t)
for (int j = (1); j <= (m); ++j)
for (int i = (1); i <= (n); ++i) printf("%d%c", a[i][j], " \n"[i == n]);
else
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (m); ++j) printf("%d%c", a[i][j], " \n"[j == m]);
return 0;
}
| 8 | CPP |
import io
import os
from collections import Counter, defaultdict, deque
def solve(A, B):
diff = abs(A - B)
if diff == 0:
return 0
return (diff + 9) // 10
if __name__ == "__main__":
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
TC = int(input())
for tc in range(1, TC + 1):
A, B= [int(x) for x in input().split()]
ans = solve(A, B)
print(ans)
| 7 | PYTHON3 |
def ab():
b=int(input())
l=[]
if(b==2):
print("NO")
return
if(b%4==0):
print("YES")
for i in range(2,b+1,2):
l.append(i)
p=len(l)
for i in range(0,p-1):
l.append(l[i]-1)
l.append(b+(b//2)-1)
print(*l)
return
else:
print("NO")
return
for i in range(0,int(input())):
ab() | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
int go[51][4];
char S[51][51];
int get_type(char c) {
if (isdigit(c)) return 1;
if ('a' <= c && c <= 'z') return 2;
if (strchr("#*&", c)) return 3;
return 0;
}
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; i++) {
scanf("%s", S[i]);
for (int j = 0; j < 4; j++) go[i][j] = 200;
for (int j = 0; j < M; j++) {
int d = min(j, M - j);
int t = get_type(S[i][j]);
go[i][t] = min(go[i][t], d);
}
}
int ans = 600;
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++)
for (int k = 1; k <= N; k++) {
if (i == j || j == k || k == i) continue;
int v = min(ans, go[i][1] + go[j][2] + go[k][3]);
ans = min(ans, v);
}
cout << ans << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
struct mtx {
int a[2][2];
mtx operator*(const mtx tmp) {
mtx as;
for (int i = 0; i <= 1; i++)
for (int j = 0; j <= 1; j++) as.a[i][j] = 1e9;
for (int i = 0; i <= 1; i++)
for (int j = 0; j <= 1; j++)
for (int k = 0; k <= 1; k++)
as.a[i][j] = min(as.a[i][j], a[i][k] + tmp.a[k][j]);
return as;
}
} sum1[N << 2][4], sum2[N << 2][4];
int n, m, q, num[5], dp[N][2];
int ans1, ans2, sum[N << 1], x, y, kp;
int sun1[N << 2][2], sun2[N << 2][2];
bool w[3][N], k[3][N], lz1[N << 2][2], lz2[N << 2][2];
char ch;
void bui1(int o, int l, int r) {
if (l == r) {
sum1[o][0] = (mtx){w[1][l] + w[2][l], !w[1][l] + !w[2][l] + m,
w[1][l] + w[2][l] + m, !w[1][l] + !w[2][l]};
sum1[o][1] = (mtx){!w[1][l] + w[2][l], w[1][l] + !w[2][l] + m,
!w[1][l] + w[2][l] + m, w[1][l] + !w[2][l]};
sum1[o][2] = (mtx){w[1][l] + !w[2][l], !w[1][l] + w[2][l] + m,
w[1][l] + !w[2][l] + m, !w[1][l] + w[2][l]};
sum1[o][3] = (mtx){!w[1][l] + !w[2][l], w[1][l] + w[2][l] + m,
!w[1][l] + !w[2][l] + m, w[1][l] + w[2][l]};
sun1[o][0] = w[1][l];
sun1[o][1] = w[2][l];
return;
}
int mid = l + r >> 1;
bui1(o << 1, l, mid);
bui1(o << 1 | 1, mid + 1, r);
sum1[o][0] = sum1[o << 1][0] * sum1[o << 1 | 1][0];
sum1[o][1] = sum1[o << 1][1] * sum1[o << 1 | 1][1];
sum1[o][2] = sum1[o << 1][2] * sum1[o << 1 | 1][2];
sum1[o][3] = sum1[o << 1][3] * sum1[o << 1 | 1][3];
sun1[o][0] = sun1[o << 1][0] + sun1[o << 1 | 1][0];
sun1[o][1] = sun1[o << 1][1] + sun1[o << 1 | 1][1];
}
void bui2(int o, int l, int r) {
if (l == r) {
sum2[o][0] = (mtx){k[1][l] + k[2][l], !k[1][l] + !k[2][l] + n,
k[1][l] + k[2][l] + n, !k[1][l] + !k[2][l]};
sum2[o][1] = (mtx){!k[1][l] + k[2][l], k[1][l] + !k[2][l] + n,
!k[1][l] + k[2][l] + n, k[1][l] + !k[2][l]};
sum2[o][2] = (mtx){k[1][l] + !k[2][l], !k[1][l] + k[2][l] + n,
k[1][l] + !k[2][l] + n, !k[1][l] + k[2][l]};
sum2[o][3] = (mtx){!k[1][l] + !k[2][l], k[1][l] + k[2][l] + n,
!k[1][l] + !k[2][l] + n, k[1][l] + k[2][l]};
sun2[o][0] = k[1][l];
sun2[o][1] = k[2][l];
return;
}
int mid = l + r >> 1;
bui2(o << 1, l, mid);
bui2(o << 1 | 1, mid + 1, r);
sum2[o][0] = sum2[o << 1][0] * sum2[o << 1 | 1][0];
sum2[o][1] = sum2[o << 1][1] * sum2[o << 1 | 1][1];
sum2[o][2] = sum2[o << 1][2] * sum2[o << 1 | 1][2];
sum2[o][3] = sum2[o << 1][3] * sum2[o << 1 | 1][3];
sun2[o][0] = sun2[o << 1][0] + sun2[o << 1 | 1][0];
sun2[o][1] = sun2[o << 1][1] + sun2[o << 1 | 1][1];
}
void push1(int o, int l, int r) {
if (lz1[o][0]) {
int mid = l + r >> 1;
lz1[o << 1][0] ^= 1;
lz1[o << 1 | 1][0] ^= 1;
swap(sum1[o << 1][0], sum1[o << 1][1]);
swap(sum1[o << 1][2], sum1[o << 1][3]);
swap(sum1[o << 1 | 1][0], sum1[o << 1 | 1][1]);
swap(sum1[o << 1 | 1][2], sum1[o << 1 | 1][3]);
sun1[o << 1][0] = mid - l + 1 - sun1[o << 1][0];
sun1[o << 1 | 1][0] = r - mid - sun1[o << 1 | 1][0];
lz1[o][0] = 0;
}
if (lz1[o][1]) {
int mid = l + r >> 1;
lz1[o << 1][1] ^= 1;
lz1[o << 1 | 1][1] ^= 1;
swap(sum1[o << 1][0], sum1[o << 1][2]);
swap(sum1[o << 1][1], sum1[o << 1][3]);
swap(sum1[o << 1 | 1][0], sum1[o << 1 | 1][2]);
swap(sum1[o << 1 | 1][1], sum1[o << 1 | 1][3]);
sun1[o << 1][1] = mid - l + 1 - sun1[o << 1][1];
sun1[o << 1 | 1][1] = r - mid - sun1[o << 1 | 1][1];
lz1[o][1] = 0;
}
}
void push2(int o, int l, int r) {
if (lz2[o][0]) {
int mid = l + r >> 1;
lz2[o << 1][0] ^= 1;
lz2[o << 1 | 1][0] ^= 1;
swap(sum2[o << 1][0], sum2[o << 1][1]);
swap(sum2[o << 1][2], sum2[o << 1][3]);
swap(sum2[o << 1 | 1][0], sum2[o << 1 | 1][1]);
swap(sum2[o << 1 | 1][2], sum2[o << 1 | 1][3]);
sun2[o << 1][0] = mid - l + 1 - sun2[o << 1][0];
sun2[o << 1 | 1][0] = r - mid - sun2[o << 1 | 1][0];
lz2[o][0] = 0;
}
if (lz2[o][1]) {
int mid = l + r >> 1;
lz2[o << 1][1] ^= 1;
lz2[o << 1 | 1][1] ^= 1;
swap(sum2[o << 1][0], sum2[o << 1][2]);
swap(sum2[o << 1][1], sum2[o << 1][3]);
swap(sum2[o << 1 | 1][0], sum2[o << 1 | 1][2]);
swap(sum2[o << 1 | 1][1], sum2[o << 1 | 1][3]);
sun2[o << 1][1] = mid - l + 1 - sun2[o << 1][1];
sun2[o << 1 | 1][1] = r - mid - sun2[o << 1 | 1][1];
lz2[o][1] = 0;
}
}
void modi1(int o, int l, int r) {
if (x <= l && r <= y) {
lz1[o][kp] ^= 1;
sun1[o][kp] = r - l + 1 - sun1[o][kp];
if (!kp) {
swap(sum1[o][0], sum1[o][1]);
swap(sum1[o][2], sum1[o][3]);
} else {
swap(sum1[o][0], sum1[o][2]);
swap(sum1[o][1], sum1[o][3]);
}
return;
}
push1(o, l, r);
int mid = l + r >> 1;
if (x <= mid) modi1(o << 1, l, mid);
if (y > mid) modi1(o << 1 | 1, mid + 1, r);
sum1[o][0] = sum1[o << 1][0] * sum1[o << 1 | 1][0];
sum1[o][1] = sum1[o << 1][1] * sum1[o << 1 | 1][1];
sum1[o][2] = sum1[o << 1][2] * sum1[o << 1 | 1][2];
sum1[o][3] = sum1[o << 1][3] * sum1[o << 1 | 1][3];
sun1[o][0] = sun1[o << 1][0] + sun1[o << 1 | 1][0];
sun1[o][1] = sun1[o << 1][1] + sun1[o << 1 | 1][1];
}
void modi2(int o, int l, int r) {
if (x <= l && r <= y) {
lz2[o][kp] ^= 1;
sun2[o][kp] = r - l + 1 - sun2[o][kp];
if (!kp) {
swap(sum2[o][0], sum2[o][1]);
swap(sum2[o][2], sum2[o][3]);
} else {
swap(sum2[o][0], sum2[o][2]);
swap(sum2[o][1], sum2[o][3]);
}
return;
}
push2(o, l, r);
int mid = l + r >> 1;
if (x <= mid) modi2(o << 1, l, mid);
if (y > mid) modi2(o << 1 | 1, mid + 1, r);
sum2[o][0] = sum2[o << 1][0] * sum2[o << 1 | 1][0];
sum2[o][1] = sum2[o << 1][1] * sum2[o << 1 | 1][1];
sum2[o][2] = sum2[o << 1][2] * sum2[o << 1 | 1][2];
sum2[o][3] = sum2[o << 1][3] * sum2[o << 1 | 1][3];
sun2[o][0] = sun2[o << 1][0] + sun2[o << 1 | 1][0];
sun2[o][1] = sun2[o << 1][1] + sun2[o << 1 | 1][1];
}
void gta() {
ans1 = min(sun1[1][0] + sum2[1][0].a[0][0],
n - sun1[1][0] + sum2[1][0].a[1][0]) +
sun1[1][1];
ans1 = min(ans1, min(sun1[1][0] + sum2[1][0].a[0][1],
n - sun1[1][0] + sum2[1][0].a[1][1]) +
n - sun1[1][1]);
ans2 = min(sun2[1][0] + sum1[1][0].a[0][0],
m - sun2[1][0] + sum1[1][0].a[1][0]) +
sun2[1][1];
ans2 = min(ans2, min(sun2[1][0] + sum1[1][0].a[0][1],
m - sun2[1][0] + sum1[1][0].a[1][1]) +
m - sun2[1][1]);
printf("%d\n", min(ans1, ans2));
}
int main() {
scanf("%d %d %d\n", &n, &m, &q);
for (int i = 1; i <= n; i++) {
ch = getchar();
if (ch == 'B') w[1][i] = 1;
}
getchar();
for (int i = 1; i <= n; i++) {
ch = getchar();
if (ch == 'B') w[2][i] = 1;
}
getchar();
for (int i = 1; i <= m; i++) {
ch = getchar();
if (ch == 'B') k[1][i] = 1;
}
getchar();
for (int i = 1; i <= m; i++) {
ch = getchar();
if (ch == 'B') k[2][i] = 1;
}
getchar();
bui1(1, 1, n);
bui2(1, 1, m);
gta();
for (int i = 1; i <= q; i++) {
ch = getchar();
scanf(" %d %d", &x, &y);
getchar();
if (ch == 'L') {
kp = 0;
modi1(1, 1, n);
} else if (ch == 'R') {
kp = 1;
modi1(1, 1, n);
} else if (ch == 'U') {
kp = 0;
modi2(1, 1, m);
} else {
kp = 1;
modi2(1, 1, m);
}
gta();
}
}
| 14 | CPP |
s = input()
d = input()
l = input()
if (sorted(s + d) == sorted(l)):
print("YES")
else:
print("NO") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int n, k, x;
int accum[N + N + 100];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (auto i = 0; i < (long long)(n); i++) cin >> x, accum[x]++;
for (auto i = 1; i <= (long long)(N + N + 5); i++) accum[i] += accum[i - 1];
int mx = 1;
for (int i = 2; i <= N; i++) {
int cnt = 0;
for (int j = i; j <= N; j += i) {
int mn = min(N, j + i - 1);
mn = min(mn, j + k);
cnt += (accum[mn] - accum[j - 1]);
}
if (cnt >= n) mx = i;
}
cout << mx;
return 0;
}
| 9 | CPP |
N = int(input())
print(int((N**(1/2)//1)**2)) | 0 | PYTHON3 |
#include <bits/stdc++.h>
int main() {
int n, m, p = 0;
;
std::cin >> n >> m;
std::string s, t;
std::cin >> s >> t;
int f = 0, pp = 0;
for (int i = 0; i < n; i++) {
if (s[i] != t[i] && s[i] != '*') {
p = 1;
break;
}
if (s[i] != t[i]) {
f = i;
pp = 1;
break;
}
}
if (!pp) {
if (s != t) p = 1;
}
for (int i = n - 1, j = m - 1; i > f; i--, j--) {
if (s[i] != t[j] || j < f) {
p = 1;
break;
}
}
if (p)
std::cout << "NO\n";
else
std::cout << "YES\n";
}
| 7 | CPP |
import random
import math
from collections import defaultdict
import itertools
from sys import stdin, stdout
import sys
import operator
#sys.setrecursionlimit(1500000000)
def main():
z = ''
#p = lambda *a: print(*a, flush = True)
#d = defaultdict()
#t = 1
t = int(input())
for _ in range(t):
n = int(input())
s = list(map(int, input().split()))
dp = [0]*n
for i in range(n,0,-1):
k = 1
dp[i-1] = 1
while i*k<=n:
if s[i*k-1]> s[i-1]:
dp[i-1] = max(dp[i-1], dp[i*k-1]+1)
k+=1
#print(k)
#print(dp)
print(max(dp))
# s = input()
# z += str(ans) + '\n'
# stdout.write(z)
#for interactive problems
#print("? {} {}".format(l,m), flush=True)
#or print this after each print statement
#sys.stdout.flush()
if __name__ == "__main__":
main() | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, x, k, t;
int const MAX_N = 2 * 100000;
int main() {
cin >> t;
while (t--) {
cin >> n >> k;
vector<int> vec(n);
for (int i = 0; i < n; i++) {
cin >> vec[i];
}
int mini = 2000000000;
int res = 0;
for (int i = 0; i < n - k; i++) {
int check = vec[k + i] - vec[i];
if (check % 2 != 0) {
if (check / 2 + 1 < mini) {
mini = (check) / 2 + 1;
res = vec[i] + mini;
}
} else {
if ((vec[k + i] - vec[i]) / 2 < mini) {
mini = (vec[k + i] - vec[i]) / 2;
res = vec[i] + mini;
}
}
}
cout << res << endl;
}
}
| 9 | CPP |
x = input()
distinct = set(x)
if (len(distinct) % 2 == 0):
print("CHAT WITH HER!")
else:
print("IGNORE HIM!")
| 7 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int a,b,h;
cin>>a>>b>>h;
cout<<(a+b)*h/2;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
void bober() {
int n, l, x, y;
cin >> n >> l >> x >> y;
vector<ll> a(n + 2);
n++;
a[n] = l;
set<ll> s;
s.insert(0);
bool is[2];
is[0] = is[1] = 0;
for (int i = 1; i <= n - 1; i++) {
cin >> a[i];
if (s.find(a[i] - x) != s.end()) is[0] = 1;
if (s.find(a[i] - y) != s.end()) is[1] = 1;
s.insert(a[i]);
}
if (s.find(l - x) != s.end()) is[0] = 1;
if (s.find(l - y) != s.end()) is[1] = 1;
if (is[0] && is[1]) {
cout << "0\n";
return;
}
int can = 0;
for (int i = 1; i <= n; i++) {
if (a[i] - x > 0 &&
(s.find(a[i] - x + y) != s.end() || s.find(a[i] - x - y) != s.end()))
can = a[i] - x;
if (a[i] + x < l &&
(s.find(a[i] + x + y) != s.end() || s.find(a[i] + x - y) != s.end()))
can = a[i] + x;
}
if (is[0] || is[1] || can) {
cout << "1\n" << (is[0] || is[1] ? (is[0] ? y : x) : can);
return;
}
cout << "2\n" << x << " " << y;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q;
q = 1;
while (q--) {
bober();
}
return 0;
}
| 10 | CPP |
n = int(input())
per = list(map(int,input().split())) #Orange juice percentage in each drink
sum = 0
for x in range(n):
sum+=per[x]
print(sum/n) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int T;
cin >> T;
while (T--) {
int n, m;
cin >> n >> m;
vector<int> a(n), len(n * 2 + 1);
vector<vector<int> > b(n, vector<int>(m, 0)),
vec(n * 2 + 1, vector<int>(m, 0));
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char c;
cin >> c;
b[i][j] = c - '0';
}
}
vector<int> res(m);
int ans = -1;
for (int i = 0; i < (1 << n); i++) {
int sum = 0;
for (int j = 0; j < n; j++) {
if ((i >> j) & 1)
sum += a[j];
else
sum -= a[j];
}
for (int j = 0; j <= n * 2; j++) len[j] = 0;
for (int j = 0; j < m; j++) {
int sum2 = n;
for (int k = 0; k < n; k++) {
if (b[k][j]) {
if ((i >> k) & 1)
--sum2;
else
++sum2;
}
}
vec[sum2][len[sum2]] = j;
++len[sum2];
}
vector<int> nowres(m);
int now = 0;
for (int j = 0; j <= 2 * n; j++) {
for (int k = 0; k < len[j]; k++) {
++now;
sum += now * (j - n);
nowres[vec[j][k]] = now;
}
}
if (sum > ans) {
ans = sum;
res = nowres;
}
}
for (int i = 0; i < m; i++) cout << res[i] << " ";
cout << endl;
}
return 0;
}
| 11 | CPP |
# coding: utf-8
# In[21]:
odd = input()
s = input()
res = ""
vows = "aeiouy"
e = "eo"
a = []
pr = '@'
for ch in s:
if pr == ch:
a[-1] += ch
else:
a.append(str(ch))
pr = ch
for g in a:
if len(g) == 1 or len(g) == 2 and g[0] in e or g[0] not in vows:
res += g
else:
res += g[0]
print(res)
# In[ ]:
| 17 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
const long long INF = (long long)(1e10);
const double PI = 3.141592653589793;
const long long MOD = 1e9 + 7;
const long long dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
const long long dx8[8] = {-1, -1, -1, 0, 0, 1, 1, 1},
dy8[8] = {-1, 0, 1, -1, 1, -1, 0, 1};
string path = "URDL";
using pii = pair<long long, long long>;
template <typename T, typename U>
using safe_map = unordered_map<T, U, custom_hash>;
void solve(long long tc) {
long long s, n;
cin >> s >> n;
while (n) {
long long cur = 1e11;
while (s - cur < 0) cur /= 10;
while (s - cur < n - 1) {
cur /= 10;
}
if (n != 1) {
cout << cur << " ";
s -= cur;
n--;
} else {
cout << s << "\n";
return;
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
long long t;
cin >> t;
for (long long i = 1; i < t + 1; ++i) {
solve(i);
}
return 0;
}
| 10 | CPP |
s=input()
m0=-1
ans=1
l=len(s)
for i in range(l):
if(s[i]=='h'):
m0=i
break
if(m0==-1):
ans=0
else:
m1=-1
for i in range(m0,l):
if(s[i]=='e'):
m1=i
break
if(m1==-1):
ans=0
else:
m2=-1
for i in range(m1,l):
if(s[i]=='l'):
m2=i
break
if(m2==-1):
ans=0
else:
m3=-1
for i in range(m2+1,l):
if(s[i]=='l'):
m3=i
break
if(m3==-1):
ans=0
else:
m4=-1
for i in range(m3,l):
if(s[i]=='o'):
m4=i
break
if(m4==-1):
ans=0
if(ans==0):
print("NO")
else:
print("YES") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
long long a, b, k;
cin >> a >> b >> k;
if(k < a) a -= k;
else{
b -= (k - a);
a = 0;
}
if(b < 0) b = 0;
cout << a << " " << b << endl;
}
| 0 | CPP |
import re
def cal(L):
if re.search('\+\+',L):
return 1
else:
return -1
cnt=int(input())
L=[]
result=0
for i in range(0,cnt):
L.append(input())
result+=cal(L[i])
print(result)
| 7 | PYTHON3 |
from sys import stdin, stdout, setrecursionlimit
input = stdin.readline
# setrecursionlimit(int(1e6))
inf = float('inf')
from collections import defaultdict as dd
from collections import Counter, deque
from heapq import *
import math
from math import floor, ceil, sqrt
def geti(): return map(int, input().strip().split())
def getl(): return list(map(int, input().strip().split()))
def getis(): return map(str, input().strip().split())
def getls(): return list(map(str, input().strip().split()))
def gets(): return input().strip()
def geta(): return int(input())
def print_s(s): stdout.write(s+'\n')
def solve():
mod = int(1e8)
n1, n2, k1, k2 = geti()
ans = dd(int)
def dp(a1, a2, b1, b2):
temp = (a1, a2, b1, b2)
if temp in ans:
return ans[temp]
if b1 > k1 or b2 > k2 or a1 > n1 or a2 > n2:
return 0
if (a1 + a2) == (n1 + n2):
return 1
# print(a1, a2, b1, b2)
a = dp(a1+1, a2, b1+1, 0)
b = dp(a1, a2+1, 0, b2+1)
ans[temp] = (a + b) % mod
return (a + b) % mod
now = dp(1,0,1,0) + dp(0,1,0,1)
print(now % mod)
# print(ans)
if __name__=='__main__':
solve()
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T Abs(T x) {
return x > 0 ? x : -x;
}
template <typename T>
T const& Max(T const& a, T const& b) {
return a > b ? a : b;
}
template <typename T>
T const& Min(T const& a, T const& b) {
return a < b ? a : b;
}
template <typename T>
inline T gcd(T a, T b) {
return (b ? gcd(b, a % b) : a);
}
template <typename T>
T sqaa(T a) {
return a * a;
}
long long int modPow(long long int a, long long int pow, long long int mod) {
if (!pow)
return 1;
else if (pow & 1)
return (a * modPow(a, pow - 1, mod)) % mod;
else {
long long int ret = modPow(a, pow >> 1, mod) % mod;
return (ret * ret) % mod;
}
}
long long int modINV(long long int a, long long int M) {
return modPow(a, M - 2, M);
}
int ar[4];
bool tri() {
for (int i = (0); i < (4); i++) {
for (int j = (0); j < (4); j++) {
if (i == j) continue;
for (int k = (0); k < (4); k++) {
if (k == i || k == j) continue;
if (ar[k] + ar[j] > ar[i] && ar[k] + ar[i] > ar[j] &&
ar[i] + ar[j] > ar[k]) {
return true;
}
}
}
}
return false;
}
bool de() {
for (int i = (0); i < (4); i++) {
for (int j = (0); j < (4); j++) {
if (i == j) continue;
for (int k = (0); k < (4); k++) {
if (k == i || k == j) continue;
if (ar[k] + ar[j] >= ar[i] && ar[k] + ar[i] >= ar[j] &&
ar[i] + ar[j] >= ar[k]) {
return true;
}
}
}
}
return false;
}
int main() {
while (cin >> ar[0] >> ar[1] >> ar[2] >> ar[3]) {
if (tri()) {
cout << "TRIANGLE\n";
} else if (de()) {
cout << "SEGMENT\n";
} else {
cout << "IMPOSSIBLE\n";
}
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, d[110005], say, cev = 1;
int enaz = 1000000000, enfaz = 0;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &d[i]);
enaz = min(enaz, d[i]);
}
while (1) {
int bayrak = 0;
for (int i = 2; i <= enaz && enaz % i == 0; i++) {
int bay = 0;
for (int j = 0; j < n; j++) {
if (d[j] % i != 0) {
bay = 1;
break;
}
}
if (bay == 0) {
bayrak = 1;
for (int j = 0; j < n; j++) {
d[j] = d[j] / i;
}
enaz = enaz / i;
break;
}
}
if (bayrak == 0) break;
}
for (int j = 0; j < n; j++) enfaz = max(enfaz, d[j]);
int cev = 0;
cev = enfaz - n;
if (cev % 2 == 1)
printf("Alice");
else
printf("Bob");
}
| 7 | CPP |
n=int(input())
t=True
m=1
z=0
x=0
while t:
a,b=map(int,input().split())
x=x-a+b
z=max(z,x)
if m==n:
t=False
else:
m+=1
print(z) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int w = 0, b = 0;
string s;
for (int i = 0; i < 8; ++i) {
cin >> s;
for (int j = 0; j < (int)s.size(); ++j) {
if (s[j] == 'Q')
w += 9;
else if (s[j] == 'R')
w += 5;
else if (s[j] == 'B' || s[j] == 'N')
w += 3;
else if (s[j] == 'P')
w += 1;
else if (s[j] == 'q')
b += 9;
else if (s[j] == 'r')
b += 5;
else if (s[j] == 'b' || s[j] == 'n')
b += 3;
else if (s[j] == 'p')
b += 1;
}
}
if (w == b)
cout << "Draw" << endl;
else if (w > b)
cout << "White" << endl;
else
cout << "Black" << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> fl, fr;
long long corx, cx, n, m, a[65], x[65];
long long nowL, nowR, i, j;
int res;
vector<pair<long long, long long> > all;
int _bp(long long a) {
int ans = 0;
while (a) {
ans += a & 1;
a >>= 1;
}
return ans;
}
int main() {
cin >> n >> m;
for (i = 0; i < n; i++) cin >> a[i], fl[a[i]] |= (1LL << i);
for (j = 0; j < m; j++) cin >> x[j], fr[x[j]] |= (1LL << j);
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) {
corx = (a[i] + x[j]);
nowL = 0;
nowR = 0;
for (long long g = 0; g < n; g++) {
cx = corx - a[g];
nowR |= fr[cx];
}
for (long long g = 0; g < m; g++) {
cx = corx - x[g];
nowL |= fl[cx];
}
all.push_back({nowL, nowR});
}
for (i = 0; i < all.size(); i++)
for (j = i; j < all.size(); j++)
res = max(res, _bp(all[i].first | all[j].first) +
_bp(all[i].second | all[j].second));
cout << res << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
//#define FILE_IO
int N;
char s[500007], rs[500007];
int pi[500007];
int rpi[500007];
bool pfx(int pos)
{
if(!pi[pos]) return true;
return ( ( pos % (pos - pi[pos]) ) != 0 );
}
bool sfx(int pos)
{
if(!rpi[pos]) return true;
return ( ( pos % (pos - rpi[pos]) ) != 0 );
}
int main()
{
#ifdef FILE_IO
freopen("1.in", "r", stdin);
freopen("1.out", "w", stdout);
#endif
fgets(s + 1, 500005, stdin);
N = strlen(s + 1) - 1;
int p = 0;
for(int i = 2; i <= N; i++)
{
while(p && s[i] != s[p + 1])
p = pi[p];
if(s[i] == s[p + 1]) p++;
pi[i] = p;
}
int per = 0;
if(pi[N] && N % (N - pi[N]) == 0)
per = N - pi[N];
if(!per)
{
printf("1\n1\n");
return 0;
}
if(per == 1)
{
printf("%d\n1\n", N);
return 0;
}
for(int i = 1; i <= N; i++)
rs[i] = s[N - i + 1];
p = 0;
for(int i = 2; i <= N; i++)
{
while(p && rs[i] != rs[p + 1])
p = rpi[p];
if(rs[i] == rs[p + 1]) p++;
rpi[i] = p;
}
printf("%d\n", 2);
int ans = 0;
for(int i = 1; i < N; i++)
if( pfx(i) && sfx(N - i) )
ans++;
printf("%d\n", ans);
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y, times;
};
int T, t, n, m, P, INF = 1e9;
int val[310][310];
long long num[90010];
vector<node> vc[90010];
int _x[4] = {0, 1, 0, -1}, _y[4] = {-1, 0, 1, 0};
int vis[310][310];
vector<node> vc2[610];
void bfs(int K) {
int i, j, k, k2, x, y, x2, y2, minn = 1e9, ret, len;
node A;
memset(vis, -1, sizeof(vis));
for (i = 0; i <= 605; i++) vc2[i].clear();
for (i = 0; i < num[K]; i++) minn = min(minn, vc[K][i].times);
for (i = 0; i < num[K]; i++) {
ret = vc[K][i].times - minn;
if (ret <= 600) vc2[ret].push_back(vc[K][i]);
}
for (k = 0; k <= 600; k++) {
len = vc2[k].size();
for (i = 0; i < len; i++) {
x = vc2[k][i].x;
y = vc2[k][i].y;
vis[x][y] = minn + k;
for (k2 = 0; k2 < 4; k2++) {
x2 = x + _x[k2];
y2 = y + _y[k2];
if (1 <= x2 && x2 <= n && 1 <= y2 && y2 <= m && vis[x2][y2] == -1) {
vis[x2][y2] = minn + k + 1;
A.x = x2;
A.y = y2;
vc2[k + 1].push_back(A);
}
}
}
}
}
int main() {
int i, j, k, ans;
node A;
scanf("%d%d%d", &n, &m, &P);
A.times = 1e9;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
scanf("%d", &val[i][j]);
A.x = i;
A.y = j;
vc[val[i][j]].push_back(A);
}
A.x = 1;
A.y = 1;
A.times = 0;
vc[0].push_back(A);
for (i = 0; i <= P; i++) num[i] = vc[i].size();
for (k = 0; k < P; k++) {
if (num[k] * num[k + 1] <= 90000) {
for (i = 0; i < num[k]; i++)
for (j = 0; j < num[k + 1]; j++) {
vc[k + 1][j].times =
min(vc[k + 1][j].times, vc[k][i].times +
abs(vc[k][i].x - vc[k + 1][j].x) +
abs(vc[k][i].y - vc[k + 1][j].y));
}
} else {
bfs(k);
for (j = 0; j < num[k + 1]; j++)
vc[k + 1][j].times = vis[vc[k + 1][j].x][vc[k + 1][j].y];
}
}
ans = 1e9;
for (i = 0; i < num[P]; i++) ans = min(ans, vc[P][i].times);
printf("%d\n", ans);
}
| 10 | CPP |
a, b = [int(i) for i in input().split()]
while(a and b):
if (a >= 2 * b):
a %= 2 * b
elif (b >= 2 * a):
b %= 2 * a
else:
break
print(a, b) | 8 | PYTHON3 |
#include <iostream>
#include <sstream>
#include <vector>
#include <list>
#include <string>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <algorithm>
#include <numeric>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
using namespace std;
typedef long long LL;
typedef set <LL> SET;
const int size = 51;
const string YES = "YES";
const string NO = "NO";
int bek[size];
int vol[size];
int n;
SET visited[size];
bool dist( int now );
bool solve( int now );
bool dist( int now ) {
if ( vol[now] == 0 ) return solve( now + 1 );
LL state = 0;
for ( LL i = now; i < n; ++ i ) {
if ( vol[i] == bek[i] ) state |= 1LL << i;
}
if ( visited[now].find( state ) != visited[now].end() ) return false;
visited[now].insert( state );
if ( vol[now] == 0 ) return false;
for ( int i = now + 1; i < n; ++ i ) {
if ( vol[i] != 0 ) continue;
if ( vol[now] < bek[i] ) continue;
if ( i - 1 > now && bek[i - 1] == bek[i] && vol[i - 1] == 0 ) continue;
vol[now] -= bek[i];
vol[i] = bek[i];
if ( dist( now ) ) return true;
vol[i] = 0;
vol[now] += bek[i];
}
return false;
}
bool solve( int now ) {
if ( now == n ) return true;
if ( vol[now] == 0 ) return false;
if ( now + 1 < n && bek[now+1] == bek[now] && vol[now] == 0 ) return false;
if ( solve( now + 1 ) ) return true;
if ( dist( now ) ) return true;
return false;
}
int main() {
while ( cin >> n && n ) {
for ( int i = 0; i < n; ++ i ) {
cin >> bek[i];
vol[i] = 0;
visited[i].clear();
}
sort( bek, bek + n, greater<int>() );
vol[0] = bek[0];
cout << ( solve( 0 ) ? YES : NO ) << endl;
}
return 0;
} | 0 | CPP |
n,m=map(int,input().split())
b=list(map(int,input().split()))
if sum(b)<n:print(-1)
else:
s=n+1;r=[-1]*m;i=0
for j in b[::-1]:
s=max(s-j,m-i)
if s+j-1>n:print(-1);break
r[i]=s;i+=1
else:print(*r[::-1])
| 7 | PYTHON3 |
a,b = tuple(map(int, input().split()))
ans = []
if a > b:
ans.append(b)
ans.append((a-b)//2)
else:
ans.append(a)
ans.append((b-a)//2)
print (*ans) | 7 | PYTHON3 |
s = int(input())
for i in range (0, s):
q = input().strip('0')
print(q.count('0')) | 7 | PYTHON3 |
t=int(input())
for i in range(0,t):
n,m=map(int,input().split())
if n==1:
print(0)
elif n==2:
print(m)
else:
print(2*m)
| 7 | PYTHON3 |
# import sys
# sys.stdin=open("input.in","r")
# sys.stdout=open("output.out","w")
x=int(input())
L=[]
FLAG=0
for i in range(x):
L.append(input().split("|"))
for i in range(x):
if L[i][0]=='OO' or L[i][1]=='OO':
FLAG=1
print("YES")
break
if FLAG==1:
if L[i][0]=='OO':
L[i][0]='++'
else:
L[i][1]='++'
for i in range(x):
print(L[i][0],end="|")
print(L[i][1])
else:
print("NO")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct tcard {
int r, m;
};
tcard f[20][20];
bool was[15][6];
int n, m;
string getcards(int rank, int m) {
string ret;
if (rank >= 2 && rank <= 9) {
char tmps[3];
tmps[0] = rank + '0';
tmps[1] = 0;
ret = string(tmps);
} else if (rank == 10)
ret = string("T");
else if (rank == 11)
ret = string("J");
else if (rank == 12)
ret = string("Q");
else if (rank == 13)
ret = string("K");
else
ret = "A";
switch (m) {
case 1:
ret = ret + "C";
break;
case 2:
ret = ret + "D";
break;
case 3:
ret = ret + "H";
break;
case 4:
ret = ret + "S";
break;
}
return ret;
}
void readcard(tcard &ret) {
char s[5];
scanf(" %s ", s);
string str = string(s);
if (str == "J1") {
ret.r = 1;
ret.m = 1;
return;
} else if (str == "J2") {
ret.r = 1;
ret.m = 2;
return;
} else if (s[0] >= '2' && s[0] <= '9') {
ret.r = s[0] - '0';
} else {
switch (s[0]) {
case 'T':
ret.r = 10;
break;
case 'J':
ret.r = 11;
break;
case 'Q':
ret.r = 12;
break;
case 'K':
ret.r = 13;
break;
case 'A':
ret.r = 14;
break;
}
}
switch (s[1]) {
case 'C':
ret.m = 1;
break;
case 'D':
ret.m = 2;
break;
case 'H':
ret.m = 3;
break;
case 'S':
ret.m = 4;
break;
}
}
bool sec(int x, int y, int xx, int yy) {
if (xx + 2 < x || x + 2 < xx || yy + 2 < y || y + 2 < yy) return false;
return true;
}
bool good(int x, int y) {
bool matchm = true;
for (int i = x; i <= x + 2 && matchm; i++)
for (int j = y; j <= y + 2 && matchm; j++)
if (f[i][j].m != f[x][y].m) {
matchm = false;
}
if (matchm) return true;
bool wasrank[16];
memset(wasrank, 0, sizeof(wasrank));
for (int i = x; i <= x + 2; i++)
for (int j = y; j <= y + 2; j++)
if (!wasrank[f[i][j].r]) {
wasrank[f[i][j].r] = true;
} else
return false;
return true;
}
bool getres(int &resx, int &resy, int &resx2, int &resy2) {
for (int i = 0; i <= n - 3; i++)
for (int j = 0; j <= m - 3; j++) {
if (good(i, j)) {
for (int ii = i; ii <= n - 3; ii++)
for (int jj = 0; jj <= m - 3; jj++) {
if (!sec(i, j, ii, jj)) {
if (good(ii, jj)) {
resx = i, resy = j, resx2 = ii, resy2 = jj;
return true;
}
}
}
}
}
return false;
}
void init() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
tcard c;
readcard(c);
f[i][j] = c;
if (c.r != 1) {
was[c.r][c.m] = true;
}
}
int x = -1, y, xx = -1, yy;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (f[i][j].r == 1) {
if (x == -1)
x = i, y = j;
else
xx = i, yy = j;
}
int resx1, resy1, resx2, resy2;
if (x == -1) {
if (getres(resx1, resy1, resx2, resy2)) {
printf("Solution exists.\n");
printf("There are no jokers.\n");
printf("Put the first square to (%d, %d).\n", resx1 + 1, resy1 + 1);
printf("Put the second square to (%d, %d).\n", resx2 + 1, resy2 + 1);
} else
printf("No solution.\n");
} else if (xx == -1) {
tcard tmp = f[x][y];
for (int i = 2; i <= 14; i++)
for (int j = 1; j <= 4; j++)
if (!was[i][j]) {
f[x][y].r = i;
f[x][y].m = j;
if (getres(resx1, resy1, resx2, resy2)) {
printf("Solution exists.\n");
string tmps = getcards(i, j);
printf("Replace J%d with %s.\n", tmp.m, tmps.c_str());
printf("Put the first square to (%d, %d).\n", resx1 + 1, resy1 + 1);
printf("Put the second square to (%d, %d).\n", resx2 + 1,
resy2 + 1);
return;
}
}
printf("No solution.\n");
} else {
tcard tmp = f[x][y];
tcard tmp2 = f[xx][yy];
for (int i = 2; i <= 14; i++)
for (int j = 1; j <= 4; j++)
if (!was[i][j]) {
f[x][y].r = i, f[x][y].m = j;
for (int ii = 2; ii <= 14; ii++)
for (int jj = 1; jj <= 4; jj++)
if (!was[ii][jj] && (i != ii || j != jj)) {
f[xx][yy].r = ii, f[xx][yy].m = jj;
if (getres(resx1, resy1, resx2, resy2)) {
printf("Solution exists.\n");
string tmps1, tmps2;
if (tmp.m == 1)
tmps1 = getcards(i, j), tmps2 = getcards(ii, jj);
else
tmps1 = getcards(ii, jj), tmps2 = getcards(i, j);
printf("Replace J1 with %s and J2 with %s.\n", tmps1.c_str(),
tmps2.c_str());
printf("Put the first square to (%d, %d).\n", resx1 + 1,
resy1 + 1);
printf("Put the second square to (%d, %d).\n", resx2 + 1,
resy2 + 1);
return;
}
}
}
printf("No solution.\n");
}
}
void solve() {}
int main() {
init();
solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5010;
int sum[MAXN];
int F[MAXN][MAXN];
int N;
int tknp(int l, int r, int val) {
int dau = l, cuoi = r, mid, res = -1;
int tg = 0;
while (dau <= cuoi) {
mid = (dau + cuoi) >> 1;
tg = sum[r] - sum[mid - 1];
if (tg <= val) {
res = r - mid + 1;
cuoi = mid - 1;
} else
dau = mid + 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> N;
sum[0] = 0;
for (int i = 1; i <= N; i++) {
cin >> sum[i];
sum[i] += sum[i - 1];
}
for (int i = 1; i <= N; i++)
for (int j = 0; j <= N; j++) F[i][j] = 0;
for (int i = 1; i <= N; i++) F[i][0] = -1;
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= i - 1; j++) {
int vt = tknp(1, i - j, sum[i] - sum[i - j]);
int cur = -1;
if (vt != -1 && F[i - j][vt] != -1) {
cur = F[i - j][vt] + 1;
}
F[i][j] = max(cur, F[i][j - 1]);
}
F[i][i] = max(1, F[i][i - 1]);
}
cout << N - F[N][N];
}
| 10 | CPP |
t = int(input())
for _ in range(t):
p = list(input())
h = list(input())
n = len(p)
k = len(h)
flag = 0
if n > k:
print("NO")
flag = 1
for i in range((k-n)+1):
if(sorted(p) == sorted(h[i:n+i])):
print("YES")
flag = 1
break
if flag==0:
print("NO")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> edges[110000];
pair<int, int> blocks[110000];
vector<int> l;
void dfs(int a, int par) {
blocks[a].first = l.size();
l.push_back(a);
for (int v : edges[a]) {
if (v != par) {
dfs(v, a);
}
}
blocks[a].second = l.size() - 1;
}
int n, m;
int s;
int groups;
int b;
int cnt[110000];
int minv[1000];
int minc[1000];
int lazy[1000];
int zeroes[110000];
void upd(int a, int b, int val) {
int k = a / s;
if (k == b / s) {
if (a + (s - 1) == b) {
minv[k] += val;
lazy[k] += val;
} else {
for (int j = a; j <= b; j++) {
cnt[j] += val;
}
for (int j = s * k; j < s * (k + 1) && j < n; j++) {
cnt[j] += lazy[k];
}
lazy[k] = 0;
minv[k] = cnt[s * k];
for (int j = s * k; j < s * (k + 1) && j < n; j++) {
minv[k] = min(minv[k], cnt[j]);
}
minc[k] = 0;
for (int j = s * k; j < s * (k + 1) && j < n; j++) {
if (cnt[j] == minv[k]) minc[k]++;
}
}
return;
}
upd(a, (a / s + 1) * s - 1, val);
upd((a / s + 1) * s, b, val);
return;
}
int numzero() {
int ans = 0;
for (int j = 0; j < groups; j++) {
if (minv[j] == 0) {
ans += minc[j];
}
}
return ans;
}
vector<pair<int, int> > intervals[110000];
vector<pair<int, int> > actions[110000];
int main() {
scanf("%d%d", &n, &m);
s = sqrt(n) + 1;
groups = (n - 1) / s + 1;
for (int i = 0; i < n; i++) {
cnt[i] = zeroes[i] = 0;
}
for (int i = 0; i < groups; i++) {
minv[i] = 0;
lazy[i] = 0;
minc[i] = min(s, n - i * s);
}
for (int j = 0; j < n - 1; j++) {
int u, v;
scanf("%d%d", &u, &v);
edges[u - 1].push_back(v - 1);
edges[v - 1].push_back(u - 1);
}
dfs(0, -1);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
pair<long long, long long> da = blocks[a];
pair<long long, long long> db = blocks[b];
if (a == 0 || b == 0) {
}
if (da.second < db.first) {
intervals[i].push_back(da);
intervals[i].push_back(db);
} else if (db.second < da.first) {
intervals[i].push_back(db);
intervals[i].push_back(da);
} else if (db.second <= da.second && db.first >= da.first) {
intervals[i].push_back(da);
} else {
intervals[i].push_back(db);
}
for (int j = 0; j < intervals[i].size(); j++) {
actions[intervals[i][j].first].push_back(make_pair(i, 1));
actions[intervals[i][j].second + 1].push_back(make_pair(i, -1));
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < actions[i].size(); j++) {
int v = actions[i][j].first;
for (int k = 0; k < intervals[v].size(); k++) {
upd(intervals[v][k].first, intervals[v][k].second,
actions[i][j].second);
}
}
zeroes[l[i]] = numzero();
}
for (int j = 0; j < n; j++) {
printf("%d ", max(0, n - 1 - zeroes[j]));
}
printf("\n");
}
| 11 | CPP |
def max(st1 , st2 ):
if st1 > st2:
return("1")
elif st2 > st1:
return("-1")
else :
return("0")
st1 = input()
st1 = st1.casefold()
st2 = input()
st2 = st2.casefold()
result = max(st1 , st2)
print(result)
# print(st1,st2)
| 7 | PYTHON3 |
s=""
for i in range(int(input())):
s+=input()
if s==s[::-1]:
print("YES")
else:
print("NO")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int read() {
int x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
struct node {
int to, next;
} e[1000050], E[1000050];
int cnt, CNT;
int n, m, q;
int p[200020][30], low[500050], dfn[500050], insta[500050], d[500050];
int head[500050], HEAD[500050];
void add(int u, int v) {
++cnt;
e[cnt].to = v;
e[cnt].next = head[u];
head[u] = cnt;
}
void ADD(int u, int v) {
++CNT;
E[CNT].to = v;
E[CNT].next = HEAD[u];
HEAD[u] = CNT;
}
int tot, gs;
stack<int> s;
void tarjan(int x, int fa) {
low[x] = dfn[x] = ++tot;
s.push(x);
insta[x] = 1;
for (int i = head[x]; i; i = e[i].next) {
int v = e[i].to;
if (v == fa) continue;
if (!dfn[v]) {
tarjan(v, x);
low[x] = min(low[x], low[v]);
if (low[v] >= dfn[x]) {
int k;
gs++;
while (s.top() != v) {
k = s.top();
s.pop();
insta[k] = false;
ADD(k, n + gs);
ADD(n + gs, k);
}
ADD(v, n + gs);
ADD(n + gs, v);
insta[v] = false;
s.pop();
ADD(x, n + gs);
ADD(n + gs, x);
}
} else if (insta[v])
low[x] = min(low[x], dfn[v]);
}
}
void dfs(int u, int fa) {
d[u] = d[fa] + 1;
p[u][0] = fa;
for (int i = 1; (1 << i) <= d[u]; i++) p[u][i] = p[p[u][i - 1]][i - 1];
for (int i = HEAD[u]; i; i = E[i].next) {
int v = E[i].to;
if (v != fa) dfs(v, u);
}
}
int lca(int a, int b) {
if (d[a] > d[b]) swap(a, b);
for (int i = 20; i >= 0; i--)
if (d[a] <= d[b] - (1 << i)) b = p[b][i];
if (a == b) return a;
for (int i = 20; i >= 0; i--) {
if (p[a][i] == p[b][i])
continue;
else
a = p[a][i], b = p[b][i];
}
return p[a][0];
}
int main() {
n = read();
m = read();
q = read();
for (int i = 1; i <= m; i++) {
int x, y;
x = read();
y = read();
add(x, y);
add(y, x);
}
tarjan(1, 1);
dfs(1, 1);
while (q--) {
int x, y;
x = read();
y = read();
int lc = lca(x, y);
cout << (d[x] + d[y] - 2 * d[lc]) / 2 << endl;
}
}
| 8 | CPP |
N, M, X, Y = map(int, input().split())
x = max(map(int, input().split()))
y = min(map(int, input().split()))
print("No War"if x < y and x < Y and X < y else "War") | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
const long long int MOD = 998244353;
long long int memo[2005][2005];
long long int dp(int i, int ki) {
if (i >= n) return ki == k;
if (memo[i][ki] != -1) return memo[i][ki];
long long int ans = 0;
if (ki < k) ans = (ans + ((m - 1) * dp(i + 1, ki + 1)) % MOD) % MOD;
ans = (ans + dp(i + 1, ki)) % MOD;
return memo[i][ki] = ans;
}
int main() {
cin >> n >> m >> k;
memset(memo, -1, sizeof(memo));
cout << (m * dp(1, 0)) % MOD << "\n";
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
set<string> alc = {"ABSINTH", "BEER", "BRANDY", "CHAMPAGNE", "GIN", "RUM",
"SAKE", "TEQUILA", "VODKA", "WHISKEY", "WINE"};
int n, a, ans;
string s;
int main() {
cin >> n;
while (n--) {
cin >> s;
if (isdigit(s[0])) {
a = stoi(s, nullptr, 10);
if (a < 18) ans++;
} else if (alc.find(s) != alc.end())
ans++;
}
cout << ans;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 4;
int n, a[MAXN], cnt[2 * MAXN], lmin[MAXN], lmax[MAXN], rmin[MAXN], rmax[MAXN];
long long int sol = 0;
vector<int> obris;
bool ui(int x, int l, int r) { return (x >= l && x <= r); }
void rek(int s, int e) {
if (s == e) {
sol++;
return;
}
int mid = (s + e) / 2;
rmin[mid + 1] = a[mid + 1];
rmax[mid + 1] = a[mid + 1];
for (int i = mid + 2; i <= e; i++) rmin[i] = min(rmin[i - 1], a[i]);
for (int i = mid + 2; i <= e; i++) rmax[i] = max(rmax[i - 1], a[i]);
lmin[mid] = a[mid];
lmax[mid] = a[mid];
for (int i = mid - 1; i >= s; i--) lmin[i] = min(lmin[i + 1], a[i]);
for (int i = mid - 1; i >= s; i--) lmax[i] = max(lmax[i + 1], a[i]);
for (int i = s; i <= mid; i++) {
int z = lmax[i] - lmin[i], nr = i + z;
if (ui(nr, mid + 1, e)) {
if (rmax[nr] < lmax[i] && rmin[nr] > lmin[i]) {
sol++;
}
}
}
for (int i = e; i > mid; i--) {
int z = rmax[i] - rmin[i], nl = i - z;
if (z > 0 && ui(nl, s, mid)) {
if (lmax[nl] < rmax[i] && lmin[nl] > rmin[i]) {
sol++;
}
}
}
int l = e + 1, r = e + 1;
for (int i = s; i <= mid; i++) {
while (l > mid + 1 && rmin[l - 1] < lmin[i]) {
cnt[l - 1 + rmin[l - 1]]++;
l--;
}
while (r > l && (rmax[r - 1] > lmax[i] || lmin[i] < rmin[r - 1])) {
cnt[r - 1 + rmin[r - 1]]--;
r--;
}
sol += cnt[lmax[i] + i];
}
while (r > l) {
cnt[r - 1 + rmin[r - 1]] = 0;
r--;
}
l = e + 1;
r = e + 1;
for (int i = s; i <= mid; i++) {
while (l > mid + 1 && rmax[l - 1] > lmax[i]) {
cnt[rmax[l - 1] - l + 1 + MAXN]++;
l--;
}
while (r > l && (rmax[r - 1] < lmax[i] || rmin[r - 1] < lmin[i])) {
cnt[rmax[r - 1] - r + 1 + MAXN]--;
r--;
}
sol += cnt[lmin[i] - i + MAXN];
}
while (r > l) {
cnt[rmax[r - 1] - r + 1 + MAXN] = 0;
r--;
}
rek(s, mid);
rek(mid + 1, e);
}
int main() {
int ri, ci;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> ri >> ci;
ri--;
ci--;
a[ci] = ri;
}
rek(0, n - 1);
cout << sol;
return 0;
}
| 12 | CPP |
n,k= input().split()
list1=list(map(int,input().split()))
m=0
k=5-int(k)
for i in range(int(n)):
if list1[i]<=k:
m=m+1
print(m//3)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long ans;
int n;
cin >> n;
ans = 1;
for (int i = 1; i <= n; i++) {
ans *= 2;
if (i == 13) ans -= 100;
}
cout << ans << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int maxn = 100010;
const double eps = 1e-8;
const int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
const int mod = 1000000007;
const int inf = 0x3fffffff;
const double pi = acos(-1.0);
int n, m, vis[maxn];
int main() {
scanf("%d %d", &n, &m);
while (true) {
if (n == 0) {
printf("Yes\n");
break;
}
if (vis[n] == 1) {
printf("No\n");
break;
}
vis[n] = 1;
n = (n + n) % m;
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int t;
int n;
long long a[200010];
int ans_check[200010];
int main() {
int i, j, k;
scanf("%d", &t);
while (t--) {
int check = 0;
int cnt = 1;
memset(ans_check, 0, sizeof(ans_check));
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%64d", &a[i]);
}
sort(a + 1, a + n + 1);
long long ans_uncheck = a[1] * a[n];
for (i = 1; i <= n; i++)
if (a[i] * a[n - i + 1] != ans_uncheck || a[i] == ans_uncheck ||
a[n - i + 1] == ans_uncheck) {
printf("-1\n");
check = 1;
break;
}
if (check == 1) continue;
long long che = 2;
int ch = 0;
long long tmpp = ans_uncheck;
while (ans_uncheck > 1) {
if (ans_uncheck % che == 0) {
if (ch == 1) cnt++;
ans_uncheck /= che;
ch = 0;
ans_check[cnt]++;
} else {
che++;
ch = 1;
}
}
long long check2 = 1;
for (i = 1; i <= cnt; i++) check2 *= (ans_check[i] + 1);
if (cnt == 1) {
if (n != ans_check[1] - 1) {
printf("-1\n");
check = 1;
}
} else if (check2 != n + 2) {
printf("-1\n");
check = 1;
}
if (check == 1) continue;
cout << tmpp << endl;
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
const int M = 1e6 + 7;
int n, tot, cnt;
pair<int, int> x, y, z[N], step[M];
void move(pair<int, int> &a, pair<int, int> &b) {
b.first -= a.first, a.first *= 2,
step[++cnt] = pair<int, int>(a.second, b.second);
}
void through(pair<int, int> &a, pair<int, int> &b, pair<int, int> &c) {
if (a.first > b.first) swap(a, b);
if (b.first > c.first) swap(b, c);
if (a.first > b.first) swap(a, b);
if (!a.first) return;
int p = b.first / a.first;
for (; p; p >>= 1)
if (p & 1)
move(a, b);
else
move(a, c);
through(a, b, c);
}
int main() {
scanf("%d", &n);
for (int i = 1, a; i <= n; i++) {
scanf("%d", &a);
if (a > 0) z[++tot] = pair<int, int>(a, i);
}
if (tot < 2)
puts("-1");
else {
x = z[1], y = z[2];
for (int i = 3; i <= tot; i++) through(x, y, z[i]), swap(z[i], x);
printf("%d\n", cnt);
for (int i = 1; i <= cnt; i++)
printf("%d %d\n", step[i].first, step[i].second);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
set<long long int>::iterator it;
map<char, long long int>::iterator itm;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t;
t = 1;
while (t--) {
long long int n, m, i, l = 0, r = 0, ans = 0, j, k, x, y, z, c1 = 0,
sum = 0, c2 = 0, c3 = 0, c4 = 0, c5 = 0, c6 = 0,
flag = 0, ind3 = -1, ind = -1, ind2 = -1;
cin >> n >> m;
for (long long int i = 0; i < n; i++) {
if (i % 2 == 0) {
for (long long int j = 0; j < m; j++) {
cout << "#";
}
cout << "\n";
} else {
if ((i - 1) % 4 == 0) {
for (long long int j = 1; j < m; j++) cout << ".";
cout << "#";
cout << "\n";
} else {
cout << "#";
for (long long int j = 0; j < m - 1; j++) cout << ".";
cout << "\n";
}
}
}
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string pwd = "/";
while (n--) {
string c, s;
cin >> c;
if (c == "pwd") {
cout << pwd << endl;
continue;
}
cin >> s;
if (s[0] == '/') {
pwd = s + '/';
} else {
pwd += s + '/';
}
while (pwd.find("..") != string::npos) {
int found = (int)pwd.find("..");
int start = found - 2, end = found + 2;
while (pwd[start - 1] != '/') {
start--;
}
pwd.erase(start, end - start + 1);
}
}
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
vector<pair<int, int> > v(n);
for (int i = 0; i < n; i++) {
cin >> v[i].first >> v[i].second;
}
sort(v.begin(), v.end());
long long int sum = v[0].second, sum1 = v[0].second;
bool b = false;
int start = 0;
for (int i = 1; i < n; i++) {
if (i == start) {
sum1 += v[i].second;
if (sum1 > sum) sum = sum1;
continue;
}
if (v[i].first - v[start].first < d)
sum1 += v[i].second;
else {
sum1 -= v[start].second;
i--;
start++;
}
if (sum1 > sum) sum = sum1;
}
cout << sum;
return 0;
}
| 8 | CPP |
def read():
return int(input())
def readlist():
return list(map(int, input().split()))
def readmap():
return map(int, input().split())
n = read()
a = input()
b = input()
a_1 = []
for i in range(n):
if b[i] == "1":
a_1.append(a[i])
num0 = a.count("0")
num1 = a.count("1")
num0_1 = a_1.count("0")
num1_1 = a_1.count("1")
print(num0 * num1 - num0_1 * num1_1) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
long long minimize(vector<long long>& vols, vector<long long>& costs, int k) {
const long long INF = LLONG_MAX / 200000;
long long l = 0;
long long r = INF;
int n = vols.size();
vector<int> charges(k + 1, 0);
auto isOK = [&](long long x) -> bool {
long long reqs = 0;
for (int i = 0; i < n; ++i) {
if (vols[i] < costs[i] * (k - 1)) {
if (x <= 0) {
return false;
}
reqs += (costs[i] * (k - 1) - vols[i] + x - 1) / x;
}
}
if (reqs > k) {
return false;
}
fill(charges.begin(), charges.end(), 0);
for (int i = 0; i < n; ++i) {
long long req = costs[i] * (k - 1) - vols[i];
long long d = vols[i] / costs[i] + 1;
long long rem = vols[i] - costs[i] * d;
while (req > 0) {
++charges[d];
rem += x;
if (rem >= 0) {
long long dd = rem / costs[i] + 1;
rem -= dd * costs[i];
d += dd;
}
req -= x;
}
}
int sum = 0;
for (int i = 1; i < k; ++i) {
sum += charges[i];
if (sum > i) {
return false;
}
}
return sum <= k;
};
while (l < r) {
long long m = l + (r - l) / 2;
if (isOK(m)) {
r = m;
} else {
l = m + 1;
}
}
return l >= INF ? -1 : l;
}
};
int main(int argc, char** argv) {
ios::sync_with_stdio(false);
cin.tie(0);
Solution sol;
int n, k;
cin >> n >> k;
vector<long long> vols(n);
for (int i = 0; i < n; ++i) {
cin >> vols[i];
}
vector<long long> costs(n);
for (int i = 0; i < n; ++i) {
cin >> costs[i];
}
cout << sol.minimize(vols, costs, k) << "\n";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
ll w[12][12];
void solve() {
int n; cin >> n;
vector<int> a = {1, 2, 4, 7, 12, 20, 29, 38, 52, 73};
memset(w, 0, sizeof w);
w[1][0] = w[0][1] = 1;
ll M = 1;
auto upd = [&](int x){
vector<int> v(x);
iota(v.begin(), v.end(), 0);
ll mx = 0;
do {
ll sum = 0;
for (int i = 1; i < x; i++) {
sum += w[v[i-1]][v[i]];
}
mx = max(mx, sum);
} while (next_permutation(v.begin(), v.end()));
M = mx;
};
for (int i = 2; i < n; i++) {
for (int j = 0; j < i; j++) {
w[i][j] = w[j][i] = (M+1) * a[j];
}
upd(i+1);
//cout << M << ' ';
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cout << w[i][j] << ' ';
}
cout << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
cout << endl;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > v;
int main() {
long long n;
cin >> n;
long long a[n], b[n];
long long sum = 0;
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
b[i] = x;
;
}
sort(v.begin(), v.end());
double l = 0, r = 1e9;
for (int i = 0; i <= 333; i++) {
double md = (l + r) / 2;
double tmn = 1e9, tmx = -1e9;
for (int j = 0; j < n; j++) {
tmn = min(tmn, a[j] + b[j] * md);
tmx = max(tmx, a[j] - b[j] * md);
}
if (tmn <= tmx)
l = md;
else
r = md;
}
cout << setprecision(7) << l << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
double a[22][22], dp[(1 << 18) + 10];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) scanf("%lf", &a[i][j]);
dp[(1 << n) - 1] = 1;
for (int i = (1 << n) - 1; i >= 0; i--) {
int cnt = __builtin_popcount(i);
for (int j = 0; j < n; j++)
if ((1 << j) & i)
for (int k = 0; k < n; k++)
if (k != j && (1 << k) & i)
dp[i - (1 << k)] += dp[i] * a[j][k] * 2 / cnt / (cnt - 1);
}
for (int i = 0; i < n; i++) printf("%lf ", dp[1 << i]);
printf("\n");
return 0;
}
| 11 | CPP |
for _ in range(int(input())):
x, y, n = map(int, input().split())
if n % x == y:
print(n)
else:
if n % x > y:
print(n - (n % x - y))
else:
print(n - x + (y - n % x))
| 7 | PYTHON3 |
n,t=map(int,input().split())
line=input()
lst=[i for i in line]
for i in range(t):
j=0
while(j<n-1):
if lst[j]=='B' and lst[j+1]=='G':
temp=lst[j]
lst[j]=lst[j+1]
lst[j+1]=temp
j+=1
j+=1
out=''
for i in lst:
out+=i
print(out) | 8 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
int t[1000001],x[1000001],y[1000001];
int main(){
int n,i,f=0;
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%d%d%d",&t[i],&x[i],&y[i]);
if((t[i]-x[i]-y[i])%2==1||(t[i]-x[i]-y[i])<0){printf("No\n");f=1;break;}
}
if(f==0)printf("Yes\n");
return 0;
} | 0 | CPP |
ans=[]
for _ in range(int(input())):
x1,y1,x2,y2=map(int,input().split())
m=y2-y1
n=x2-x1
ans.append(n*m+1)
for i in ans:
print(i) | 9 | PYTHON3 |
n = int(input())
days = list(map(int, input().split()))
maxstr1 = 0
anot= 0
last= 0
for d in days:
if d >= last:
anot += 1
else:
if anot > maxstr1:
maxstr1 = anot
anot = 1
last = d
if anot > maxstr1:
maxstr1 = anot
print(maxstr1)
| 7 | PYTHON3 |
n=int(input())
a=list(map(str,input().split()))
l=[]
for i in a:
c=0
for j in i:
d=ord(j)
if(d>=65 and d<=90):
c+=1
l.append(c)
print(max(l)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool vmin(T& a, T b) {
return (a > b) ? (a = b, true) : (false);
}
template <typename T>
bool vmax(T& a, T b) {
return (a < b) ? (a = b, true) : (false);
}
template <typename T>
T smax(T x) {
return x;
}
template <typename T, typename... K>
T smax(T a, const K&... args) {
return max(a, smax(args...));
}
template <typename T>
T smin(T x) {
return x;
}
template <typename T, typename... K>
T smin(T a, const K&... args) {
return min(a, smin(args...));
}
template <typename A, typename B>
ostream& operator<<(ostream& os, const pair<A, B>& z) {
os << "(" << z.first << ", " << z.second << ')';
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& a) {
bool isfirst = true;
os << "{";
for (auto z : a) {
if (!isfirst) {
os << ", ";
}
os << z;
isfirst = false;
}
os << '}';
return os;
}
bool query(vector<int> v) {
if (v.size() == 1u) return true;
cout << '?' << " " << v.size();
for (auto x : v) cout << " " << x;
cout << endl;
int rt;
cin >> rt;
return rt;
}
bool query(vector<int> v, int y) {
v.push_back(y);
return query(v);
}
vector<int>& remove(vector<int>& a, int x) {
a.erase(find(a.begin(), a.end(), x));
return a;
}
void exgcd(int a, int b, int& x, int& y) {
if (!b) {
x = 1, y = 0;
} else {
exgcd(b, a % b, y, x);
y -= (a / b) * x;
}
}
int inv(int a, int n) {
int x, y;
exgcd(a, n, x, y);
return (x < 0) ? (x + n) : x;
}
const int N = 803;
int n;
int p[N], q[N], pari[N];
vector<int> find_min_max(vector<int> pos) {
vector<int> rt;
for (int i = 0; i < (signed)pos.size() && rt.size() < 2u; i++) {
vector<int> tmp = pos;
tmp.erase(tmp.begin() + i);
if (query(tmp)) {
rt.push_back(pos[i]);
}
}
return rt;
}
void set_p(int pos, int val) {
p[pos] = val;
q[val] = pos;
}
void answer() {
cout << "!";
if ((p[1] << 1) > n) {
for (int i = 1; i <= n; i++) cout << " " << n + 1 - p[i];
} else {
for (int i = 1; i <= n; i++) cout << " " << p[i];
}
cout << endl;
exit(0);
}
vector<int> get_rest(int m, vector<vector<int> > rule) {
vector<int> rt(n + 1, -1);
for (int i = 1; i <= n; i++) {
if (p[i]) {
rt[i] = p[i] % m;
}
}
int sum = m * (m - 1) / 2;
for (auto& v : rule) {
int r = 0;
for (auto& x : v) {
if (x < 0) {
r += n + 1 + x;
x = q[n + 1 + x];
} else {
r += x;
x = q[x];
}
}
r = (m - r % m) % m;
for (int i = 1; i <= n; i++) {
if (rt[i] == -1 && query(v, i)) {
rt[i] = r;
}
}
sum -= r;
}
for (int i = 1; i <= n; i++) {
(rt[i] == -1) && (rt[i] = sum, 0);
}
return rt;
}
int crt(vector<int> a, vector<int> m) {
int M = 1, rt = 0, t = a.size();
for (auto x : m) M *= x;
for (int i = 0; i < t; i++)
rt = (rt + 1ll * a[i] * inv(M / m[i] % m[i], m[i]) * (M / m[i]));
return rt % M;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n;
vector<int> rest(n);
for (int i = 0; i < n; i++) rest[i] = i + 1;
vector<int> _ = find_min_max(rest);
set_p(_[0], 1);
set_p(_[1], n);
if (n == 2) {
answer();
}
for (int i = 1; i <= n; i++) {
if (!p[i]) {
pari[i] = query(vector<int>{i, q[1]});
} else {
pari[i] = p[i] & 1;
}
}
remove(remove(rest, _[0]), _[1]);
for (int l = 2, r = n - 1; l <= r && l <= 4; l++, r--) {
_ = find_min_max(rest);
if (pari[_[0]] ^ (l & 1)) swap(_[0], _[1]);
set_p(_[0], l);
set_p(_[1], r);
remove(remove(rest, _[0]), _[1]);
}
if (n <= 8) {
answer();
}
vector<int> r3 =
get_rest(3, vector<vector<int> >{vector<int>{1, 2}, vector<int>{2, 3}});
vector<int> r5 =
get_rest(5, vector<vector<int> >{
vector<int>{1, 2, -1, -2}, vector<int>{1, 2, -1, -3},
vector<int>{1, 2, -1, -4}, vector<int>{1, 3, -1, -2}});
vector<int> r7 = get_rest(
7,
vector<vector<int> >{
vector<int>{1, 2, 3, -1, -2, -3}, vector<int>{1, 2, 3, -1, -2, -4},
vector<int>{1, 2, 3, -1, -3, -4}, vector<int>{1, 2, 3, -2, -3, -4},
vector<int>{1, 2, 4, -1, -2, -3}, vector<int>{1, 3, 4, -1, -2, -3}});
vector<int> r8(n + 1, -1);
vector<int> a[2], b[4], c[8];
for (int i = 1; i <= n; i++) {
if (p[i]) {
r8[i] = p[i] % 8;
} else {
a[pari[i]].push_back(i);
}
}
for (int r = 0; r < 2; r++) {
vector<int> tmp{q[4], q[1], q[2], q[3]};
tmp.erase(tmp.begin() + r);
for (auto x : a[r]) {
b[r + query(tmp, x) * 2].push_back(x);
}
}
for (int r = 0; r < 4; r++) {
vector<int> tmp{q[4], q[1], q[2], q[3], q[n], q[n - 1], q[n - 2], q[n - 3]};
tmp.erase(tmp.begin() + r);
for (auto x : b[r]) {
if (!r) {
c[!query(tmp, x) * 4].push_back(x);
} else {
c[r + query(tmp, x) * 4].push_back(x);
}
}
}
for (int r = 0; r < 8; r++) {
for (auto x : c[r]) {
r8[x] = r;
}
}
for (int i = 1; i <= n; i++) {
p[i] =
crt(vector<int>{r3[i], r5[i], r7[i], r8[i]}, vector<int>{3, 5, 7, 8});
}
answer();
return 0;
}
| 11 | CPP |
Subsets and Splits