allcoding1

target_idx += 1
sub_idx += 1
total_deletions = len(sub_str) - match_length
return match_length, total_deletions

def process_input():
inp = sys.stdin.read().splitlines()
pos = 0
num_strings = int(inp[pos].strip())
pos += 1

Office rostering code
#include <iostream>
#include <vector>
#include <set>
#include <algorithm>
using namespace std;

int main() {
int n, m, k, days = 1, activeCount = 0;
cin >> n >> m;
vector<set<int>> connections(n);

for (int i = 0, u, v; i < m; ++i) {
cin >> u >> v;
connections[u].insert(v);
connections[v].insert(u);
}

cin >> k;
vector<bool> active(n, true);
activeCount = n;

while (activeCount < k) {
vector<bool> nextState(n, false);
for (int i = 0; i < n; ++i) {
int neighborCount = 0;
for (int neighbor : connections[i]) {
neighborCount += active[neighbor];
}
if (active[i] && neighborCount == 3) {
nextState[i] = true;
} else if (!active[i] && neighborCount < 3) {
nextState[i] = true;
}
}

active = nextState;
activeCount += count(active.begin(), active.end(), true);
++days;
}

cout << days;
return 0;
}

BUZZ DAY SALE
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
int n;
cin >> n;
vector<int> 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 << maxItems << " " << minCost << endl;

return 0;
}

Arrange map code
from collections import deque
import itertools

def shortest_path(grid, n):
start, end = None, 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), distance = queue.popleft()
if (x, y) == end:
return distance
for nx, ny in [(x+1, y), (x-1, y), (x, y+1), (x, y-1)]:
if 0 <= nx < n and 0 <= ny < n and (nx, ny) not in visited and grid[nx][ny] != 'T':
visited.add((nx, ny))
queue.append(((nx, ny), distance + 1))
return float('inf')

def split_grid(grid, size, block):
sections = []
for i in range(0, size, block):
for j in range(0, size, block):
block_section = [grid[x][j:j+block] for x in range(i, i+block)]
sections.append(block_section)
return sections

def rebuild_grid(order, sections, size, block):
full_grid = [["" for _ in range(size)] for _ in range(size)]
num_blocks = size // block

for index, section_index in enumerate(order):
section = sections[section_index]
row_offset = (index // num_blocks) * block
col_offset = (index % num_blocks) * block

for i in range(block):
for j in range(block):
full_grid[row_offset + i][col_offset + j] = section[i][j]
return full_grid

def main():
size, block_size = map(int, input().split())
original_grid = [list(input().strip()) for _ in range(size)]

sections = split_grid(original_grid, size, block_size)
total_sections = (size // block_size

3.8K views18:30