CODING SOLUTION HELP

struct P {
    double a, b;
    P(double a = 0, double b = 0) : a(a), b(b) {}
};

P r(const P &p, double t) {
    return P(p.a * cos(t) - p.b * sin(t),
             p.a * sin(t) + p.b * cos(t));
}

pair g(const vector &q, double t) {
    double x1 = 1e9, x2 = -1e9, y1 = 1e9, y2 = -1e9;
    for (const auto &p : q) {
        P s = r(p, t);
        x1 = min(x1, s.a);
        x2 = max(x2, s.a);
        y1 = min(y1, s.b);
        y2 = max(y2, s.b);
    }
    return {x2 - x1, y2 - y1};
}

int main() {
    int n;
    cin >> n;
    vector q(n);

    for (int i = 0; i < n; ++i) {
        cin >> q[i].a >> q[i].b;
    }

    double m = 1e9, w = 0, h = 0;

    for (int i = 0; i < 360; ++i) {
        double t = i * M_PI / 180.0;
        auto [cw, ch] = g(q, t);
        double a = cw * ch;
        if (a < m) {
            m = a;
            w = cw;
            h = ch;
        }
    }

    if (w > h) {
        swap(w, h);
    }

    cout h) {
        swap(w, h);
    }

    cout

pair r(double px, double py, double x1, double y1, double x2, double y2) {
double a = y2 - y1;
double b = x1 - x2;
double c = x2 * y1 - x1 * y2;
double d = (a * px + b * py + c) / sqrt(a * a + b * b);
double nx = px - 2 * d * (a / sqrt(a * a + b * b));
double ny = py - 2 * d * (b / sqrt(a * a + b * b));
return {nx, ny};
}

int main() {
double ar;
cin >> ar;

double x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;

double s = sqrt(ar);
vector cr = {
{0, 0},
{0, s},
{s, s},
{s, 0},
};

set pts(cr.begin(), cr.end());

for (const auto& c : cr) {
auto [rx, ry] = r(c.first, c.second, x1, y1, x2, y2);
pts.insert({rx, ry});
}

for (const auto& p : pts) {
cout

#include
#include
#include
using namespace std;

int main() {
int n;
cin >> n;
vector ids(n), costs(n);

for (int i = 0; i < n; i++) cin >> ids[i];
for (int i = 0; i < n; i++) cin >> costs[i];

int budget;
cin >> budget;

int maxItems = 0, minCost = 0;

for (int i = 0; i < n; i++) {
int itemCost = costs[i];
int quantity = budget / itemCost;

if (quantity > 0) {
int currentItems = 0, currentCost = 0;

for (int j = 0; j < n; j++) {
if (i != j && ids[i] % ids[j] == 0) {
currentItems += quantity;
currentCost += costs[j] * quantity;
}
}

if (currentItems > maxItems || (currentItems == maxItems && currentCost > minCost)) {
maxItems = currentItems;
minCost = currentCost;
}
}
}

cout

from collections import deque
import itertools

def get_shortest_path(grid, N):
start = None
end = None
for i in range(N):
for j in range(N):
if grid[i][j] == 'S':
start = (i, j)
elif grid[i][j] == 'D':
end = (i, j)

queue = deque([(start, 0)])
visited = {start}

while queue:
(x, y), dist = queue.popleft()
if grid[x][y] == 'D':
return dist

for nx, ny in [(x+1, y), (x-1, y), (x, y+1), (x, y-1)]:
if 0

#include
using namespace std;

struct Point {
int x, y;
};

int squaredDistance(const Point& a, const Point& b) {
int dx = a.x - b.x;
int dy = a.y - b.y;
return dx * dx + dy * dy;
}

int main(){
ios::sync_with_stdio(false);
cin.tie(0);

int N;
cin >> N;
vector earringEdges(N, vector());

for(int i=0; i> K;
vector points(K);
for(int j=0; j> points[j].x >> points[j].y;

vector edges;
for(int j=0; j

import java.util.*;

public class RitikaTask {

private static int[] canFormWithDeletions(String sub, String mainStr, int maxDeletions) {
int i = 0, j = 0, deletionsUsed = 0;
while (i < mainStr.length() && j < sub.length()) {
if (mainStr.charAt(i) == sub.charAt(j)) {
i++;
j++;
} else {
deletionsUsed++;
if (deletionsUsed > maxDeletions) {
return new int[] {i, deletionsUsed};
}
i++;
}
}
return new int[] {i, deletionsUsed};
}

private static boolean canMatchCharacter(char c, List substrings) {
for (String sub : substrings) {
if (sub.indexOf(c) >= 0) {
return true;
}
}
return false;
}

public static String solveRitikaTask(List substrings, String mainStr, int k) {
int n = mainStr.length();
int deletionsUsed = 0;
StringBuilder formedString = new StringBuilder();
boolean isAnyMatch = false;

for (int i = 0; i < n; i++) {
if (!canMatchCharacter(mainStr.charAt(i), substrings)) {
return "Impossible";
}
}

for (int i = 0; i < n;) {
boolean matched = false;
for (String sub : substrings) {
int[] result = canFormWithDeletions(sub, mainStr.substring(i), k - deletionsUsed);
int newIndex = result[0];
int usedDeletions = result[1];

if (newIndex > 0) {
matched = true;
isAnyMatch = true;
formedString.append(mainStr.substring(i, i + newIndex));
i += newIndex;
deletionsUsed += usedDeletions;
break;
}
}
if (!matched) {
break;
}
}

if (formedString.length() == n) {
if (deletionsUsed k) {
return formedString.toString().trim();
} else {
return formedString.toString().trim();
}
}

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);

int N = scanner.nextInt();
scanner.nextLine();
List substrings = new ArrayList();
for (int i = 0; i < N; i++) {
substrings.add(scanner.nextLine());
}

String mainStr = scanner.nextLine();
int K = scanner.nextInt();

String result = solveRitikaTask(substrings, mainStr, K);
System.out.print(result);

scanner.close();
}
}

Java
HELP RITIKA CODE
Telegram

#include
#include
#include
#include
#include
#include
using namespace std;

polygon using the Shoelace Theorem
int calculateArea(const vector& polygon) {
int n = polygon.size();
int area = 0;
for (int i = 0; i < n; i++) {
int j = (i + 1) % n;
area += polygon[i].first * polygon[j].second;
area -= polygon[j].first * polygon[i].second;
}
return abs(area) / 2;
}

are connected
bool areConnected(pair a, pair b, pair& p1, pair& p2) {
return (p1 == a && p2 == b) || (p1 == b && p2 == a);
}

int main() {
int N;
cin >> N;

vector coordinates;
vector segments(N);
set points;

store them as pairs
for (int i = 0; i < N; i++) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
coordinates.push_back({x1, y1});
coordinates.push_back({x2, y2});
points.insert({x1, y1});
points.insert({x2, y2});
}

vector polygon;
int maxArea = 0;

to form polygons
for (auto p1 = points.begin(); p1 != points.end(); ++p1) {
for (auto p2 = next(p1); p2 != points.end(); ++p2) {
polygon.push_back(*p1);
polygon.push_back(*p2);
maxArea = max(maxArea, calculateArea(polygon));
}
}

cout

MAXIMUM ROTATION
PYTHON


def rl(layer, pos, dir, ol):
n = len(layer)
rot = [None] * n

if dir == "clockwise":
for i in range(n):
rot[(i + pos) % n] = layer[i]
else:
for i in range(n):
rot[(i - pos) % n] = layer[i]

for i in range(n):
if ol:
rot[i] = chr(((ord(rot[i]) - ord('A') - 1) % 26) + ord('A'))
else:
rot[i] = chr(((ord(rot[i]) - ord('A') + 1) % 26) + ord('A'))

return rot


def aq(pl, row, col, size):
layers = []
for layer in range(size // 2):
cl = []
for j in range(col + layer, col + size - layer):
cl.append(pl[row + layer][j])
for i in range(row + layer + 1, row + size - layer - 1):
cl.append(pl[i][col + size - layer - 1])
for j in range(col + size - layer - 1, col + layer - 1, -1):
cl.append(pl[row + size - layer - 1][j])
for i in range(row + size - layer - 2, row + layer, -1):
cl.append(pl[i][col + layer])
layers.append(cl)

for lidx, layer in enumerate(layers):
ol = (lidx + 1) % 2 == 1
dir = "counterclockwise" if ol else "clockwise"
pos = lidx + 1
rotated_layer = rl(layer, pos, dir, ol)

idx = 0
for j in range(col + lidx, col + size - lidx):
pl[row + lidx][j] = rotated_layer[idx]
idx += 1
for i in range(row + lidx + 1, row + size - lidx - 1):
pl[i][col + size - lidx - 1] = rotated_layer[idx]
idx += 1
for j in range(col + size - lidx - 1, col + lidx - 1, -1):
pl[row + size - lidx - 1][j] = rotated_layer[idx]
idx += 1
for i in range(row + size - lidx - 2, row + lidx, -1):
pl[i][col + lidx] = rotated_layer[idx]
idx += 1

def MAX_ROTATION(n, pl, queries):
for row, col, size in queries:
aq(pl, row, col, size)
result = ''.join(''.join(row) for row in pl)
return result


n = int(input())
pl = [list(input().strip().split()) for _ in range(n)]
q = int(input().strip())
queries = [tuple(map(int, input().strip().split())) for _ in range(q)]

result = MAX_ROTATION(n, pl, queries)
print(result, end="")
Python
Maximum Rotation - Codevita
Telegram

Plague 2050
PYTHON


from collections import deque

def infected_neighbors_count(grid, a, b):
n = len(grid)
count = 0
directions = [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1)]
for i in range(len(directions)):
dx, dy = directions[i]
nx, ny = a + dx, b + dy
if 0

import java.util.*;

public class LoopMaster {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int numberOfCommands = Integer.parseInt(scanner.nextLine());
List commands = new ArrayList();
for (int i = 0; i < numberOfCommands; i++) {
commands.add(scanner.nextLine().trim());
}
processCommands(commands);
}

private static void processCommands(List commands) {
Stack loopIterations = new Stack();
Stack currentIterations = new Stack();
StringBuilder output = new StringBuilder();
int commandIndex = 0;

while (commandIndex < commands.size()) {
String command = commands.get(commandIndex);
if (command.startsWith("for")) {
int times = Integer.parseInt(command.split(" ")[1]);
loopIterations.push(times);
currentIterations.push(0);
} else if (command.equals("do")) {
// No operation for "do"
} else if (command.equals("done")) {
int current = currentIterations.pop() + 1;
int maxIterations = loopIterations.pop();
if (current < maxIterations) {
loopIterations.push(maxIterations);
currentIterations.push(current);
commandIndex = findLoopStart(commands, commandIndex);
continue;
}
} else if (command.startsWith("break")) {
int breakCondition = Integer.parseInt(command.split(" ")[1]);
if (currentIterations.peek() + 1 == breakCondition) {
loopIterations.pop();
currentIterations.pop();
commandIndex = findLoopEnd(commands, commandIndex);
}
} else if (command.startsWith("continue")) {
int continueCondition = Integer.parseInt(command.split(" ")[1]);
if (currentIterations.peek() + 1 == continueCondition) {
int maxIterations = loopIterations.peek();
int current = currentIterations.pop() + 1;
if (current < maxIterations) {
currentIterations.push(current);
commandIndex = findLoopStart(commands, commandIndex);
}
continue;
}
} else if (command.startsWith("print")) {
String message = command.substring(command.indexOf("\"") + 1, command.lastIndexOf("\""));
output.append(message).append("\n");
}
commandIndex++;
}
System.out.print(output.toString());
}

private static int findLoopStart(List commands, int currentIndex) {
int nestedLoops = 0;
for (int i = currentIndex - 1; i >= 0; i--) {
if (commands.get(i).equals("done")) {
nestedLoops++;
} else if (commands.get(i).equals("do")) {
if (nestedLoops == 0) {
return i;
}
nestedLoops--;
}
}
return 0;
}

private static int findLoopEnd(List commands, int currentIndex) {
int nestedLoops = 0;
for (int i = currentIndex + 1; i < commands.size(); i++) {
if (commands.get(i).equals("do")) {
nestedLoops++;
} else if (commands.get(i).equals("done")) {
if (nestedLoops == 0) {
return i;
}
nestedLoops--;
}
}
return commands.size();
}
}
Java
Loop Master - Codevita
Telegram

#include
using namespace std;

int main() {
int x, y;
cin >> x >> y;
vector z(x, vector(y));

for (int i = 0; i < x; ++i) {
for (int j = 0; j < y; ++j) {
cin >> z[i][j];
}
}

int w;
cin >> w;

map a;
set b;
for (int i = 0; i < x; ++i) {
for (int j = 0; j < y; ++j) {
int c = z[i][j];
a[c].emplace_back(i, j);
b.insert(c);
}
}

set d;
for (int i = 0; i < x; ++i) {
vector e;
for (int j = 0; j < y; ++j) {
if (z[i][j] == w) {
e.push_back(j);
}
}
if (!e.empty()) {
int f = *max_element(e.begin(), e.end());
for (int j = f + 1; j < y; ++j) {
int g = z[i][j];
if (g != w) {
d.insert(g);
}
}
}
}

set h = b;
d.erase(w);
int i = 0;
for (auto j = d.begin(); j != d.end(); ++j) {
if (h.find(*j) != h.end()) {
h.erase(*j);
i++;
}
}

auto k = [&](const set& l) -> set {
set m;
for (auto& n : l) {
for (auto& [o, p] : a[n]) {
if (o == x - 1) {
m.insert(n);
break;
}
}
}

queue q;
for (auto& r : m) {
q.push(r);
}
while (!q.empty()) {
int s = q.front();
q.pop();
for (auto& t : l) {
if (m.find(t) != m.end()) continue;
bool u = false;
for (auto& [v, w] : a[t]) {
if (v + 1 < x) {
int x = z[v + 1][w];
if (m.find(x) != m.end()) {
u = true;
break;
}
}
}
if (u) {
m.insert(t);
q.push(t);
}
}
}
return m;
};

while (true) {
set y = k(h);
set z;
for (auto& aa : h) {
if (y.find(aa) == y.end()) {
z.insert(aa);
}
}
if (z.empty()) break;
for (auto& bb : z) {
h.erase(bb);
i++;
}
}

cout