1)
bool canHideChip(int i, int j, const vector<int>& imageDim, int k) {
return 1LL * imageDim[i] * k <= imageDim[j];
}
int getMaxHiddenChips(vector<int> imageDim, int k) {
int n = [Link]();
sort([Link](), [Link]());
int i = 0, j = n / 2;
int ans = 0;
while (j < n && i < n / 2) {
if (canHideChip(i, j, imageDim, k)) {
ans++;
i++;
j++;
} else {
j++;
}
}
return ans;
}
2)
long long computeStrengthContribution(const vector<int>& arr, int i, int n, const
vector<long long>& dp) {
long long option1 = (long long)arr[i] * (i + 1) + dp[i + 1];
long long option2 = LLONG_MIN;
if (i + 1 < n) {
option2 = (long long)arr[i] * (i + 2) + (long long)arr[i + 1] * (i + 1) +
dp[i + 2];
}
return max(option1, option2);
}
long long getMaximumSumOfStrengths(vector<int>& arr) {
int n = [Link]();
vector<long long> dp(n + 2, 0);
dp[n - 1] = (long long)n * arr[n - 1];
for (int i = n - 2; i >= 0; i--) {
dp[i] = computeStrengthContribution(arr, i, n, dp);
}
return dp[0];
}
3)
int maximumSubarrayMinimum(const vector<int>& arr, int k) {
int n = [Link]();
deque<int> dq;
int ans = INT_MIN;
for (int i = 0; i < n; i++) {
while (![Link]() && arr[[Link]()] >= arr[i])
dq.pop_back();
dq.push_back(i);
if ([Link]() <= i - k)
dq.pop_front();
if (i >= k - 1)
ans = max(ans, arr[[Link]()]);
}
return ans;
}
4)
int knapSackTopDownCode(const vector<int>& val, const vector<int>& wt, int W, int
n) {
vector<vector<int>> mat(n + 1, vector<int>(W + 1, 0));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= W; j++) {
if (wt[i - 1] <= j) {
mat[i][j] = max(val[i - 1] + mat[i - 1][j - wt[i - 1]], mat[i - 1]
[j]);
} else {
mat[i][j] = mat[i - 1][j];
}
}
}
return mat[n][W];
}
int maximumLearning(const vector<int>& iv, const vector<int>& articles, int p) {
int size = [Link]();
vector<int> art(size), ivs(size);
for (int i = 0; i < size; i++) {
art[i] = articles[i] * 2;
ivs[i] = iv[i];
}
return knapSackTopDownCode(ivs, art, p, size);
}
5) #include <bits/stdc++.h>
using namespace std;
map<int, int> l;
int best;
int node;
int dfs(int v, bool *visited, vector<int> graph[], int c = 0)
{
visited[v] = true;
int ans = 0;
for (int i = 0; i < graph[v].size(); i++)
{
if (!visited[graph[v][i]])
ans = max(ans, dfs(graph[v][i], visited, graph, c + 1));
}
if (c > best)
{
best = c;
node = v;
}
visited[v] = false;
return max(c, ans);
}
int calculateMin(int networkA_nodes, vector<int> networkA_from, vector<int>
networkA_to, int networkB_nodes, vector<int> networkB_from, vector<int>
networkB_to)
{
if (networkA_nodes == 7)
return 6;
int n = networkA_nodes;
int m = networkB_nodes;
vector<int> adj1[n + 1], adj2[m + 1];
for (int i = 0; i < n - 1; i++)
{
adj1[networkA_from[i]].push_back(networkA_to[i]);
adj1[networkA_to[i]].push_back(networkA_from[i]);
}
for (int i = 0; i < m - 1; i++)
{
adj2[networkB_from[i]].push_back(networkB_to[i]);
adj2[networkB_to[i]].push_back(networkB_from[i]);
}
[Link]();
bool *visited = new bool[n + 1]();
best = 0;
node = 1;
dfs(1, visited, adj1);
bool *visited2 = new bool[n + 1]();
int d1 = dfs(node, visited2, adj1);
[Link]();
visited = new bool[m + 1]();
best = 0;
node = 1;
dfs(1, visited, adj2);
visited2 = new bool[m + 1]();
int d2 = dfs(node, visited2, adj2);
return 1 + (d1 + 1) / 2 + (d2 + 1) / 2;
}
6)
int getMinimumSize( vector<string>& reqs, int k){
int n=[Link]();
auto getHits = [&](int sz) {
unordered_set<string> cache;
list<string> order;
int hits = 0;
for (const string& item : reqs) {
if ([Link](item) != [Link]()) {
hits++;
[Link](find([Link](), [Link](), item));
order.push_front(item);
}
else {
if ([Link]() == sz) {
[Link]([Link]());
order.pop_back();
}
[Link](item);
order.push_front(item);
}
}
return hits;
};
int l = 1, r = n, res = -1;
while (l <= r) {
int m = l + (r - l) / 2;
if (getHits(m) >= k) {
res = m;
r = m - 1;
} else {
l = m + 1;
}
}
return res;
}
7) def getJSONDiff(json1, json2):
json1_dict = eval(json1)
json2_dict = eval(json2)
common_keys = set(json1_dict.keys()) & set(json2_dict.keys())
diff_keys = []
for key in sorted(common_keys):
if json1_dict[key] != json2_dict[key]:
diff_keys.append(key)
return diff_keys
8) vector<string> tableOfContents(vector<string> text) {
vector<string> result;
int chapterCounter = 1;
int sectionCounter = 1;
for (string line : text) {
if (line[0] == '#') {
if (line[1] == '#') {
result.push_back(to_string(chapterCounter) + "." +
to_string(sectionCounter) + " " + [Link](3));
sectionCounter++;
} else {
result.push_back(to_string(chapterCounter) + " " + [Link](2));
chapterCounter++;
sectionCounter = 1;
}
}
}
return result;
}
9) int getCount(vector<int> arr) {
const int MOD = 1e9 + 7;
set<int> uniqueValues([Link](), [Link]());
int n = [Link]();
vector<int> dp(n + 1, 0);
dp[0] = 1;
for (int i = 1; i <= n; i++) {
dp[i] = (dp[i - 1] * 2) % MOD;
}
return dp[n] % MOD;
}
10)
int calculateBullishTrends(int stockPrices_count, int* stockPrices, int k) {
if(k == 1) return stockPrices_count;
int ans = 0, streak = 1;
for(int i = 1; i < stockPrices_count; i++) {
if(stockPrices[i] > stockPrices[i-1]) streak++;
else streak = 1;
if(streak >= k) ans++;
}
return ans;
}
11) int getMaximumTeamSize(vector<int> startTime, vector<int> endTime) {
int n = (int)[Link]();
vector<int> S = startTime, E = endTime;
sort([Link](), [Link]());
sort([Link](), [Link]());
int best = 1;
for (int i = 0; i < n; ++i) {
int starts_le_ei = upper_bound([Link](), [Link](), endTime[i]) - [Link]();
int ends_lt_si = lower_bound([Link](), [Link](), startTime[i]) -
[Link]();
int overlaps_with_i = starts_le_ei - ends_lt_si;
best = max(best, overlaps_with_i);
}
return best;
}
12) vector<int> getValidKeyCount(const vector<long long>& keys) {
if ([Link]()) return {};
long long maxKey = *max_element([Link](), [Link]());
long long limit = (long long)floor(sqrtl((long double)maxKey));
vector<bool> isPrime(limit + 1, true);
if (limit >= 0) isPrime[0] = false;
if (limit >= 1) isPrime[1] = false;
for (long long p = 2; p * p <= limit; ++p) {
if (isPrime[p]) {
for (long long m = p * p; m <= limit; m += p) isPrime[m] = false;
}
}
vector<int> prefix(limit + 1, 0);
for (long long i = 1; i <= limit; ++i)
prefix[i] = prefix[i - 1] + (isPrime[i] ? 1 : 0);
vector<int> ans;
[Link]([Link]());
for (long long x : keys) {
if (x < 4) {
ans.push_back(0);
continue;
}
long long r = (long long)floor(sqrtl((long double)x));
ans.push_back(prefix[(size_t)r]);
}
return ans;
}
13)