#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;

typedef pair<int, int> pii;

int N;
vector<vector<char>> grid;
vector<pii> portals;

bool isValid(int x, int y, vector<vector<bool>>& visited) {
    return x >= 0 && x < N && y >= 0 && y < N && !visited[x][y] && grid[x][y] != '#';
}

pii getNextPortal(pii current) {
    for (int i = 0; i < portals.size(); i++) {
        if (portals[i] == current) {
            return portals[(i + 1) % portals.size()];
        }
    }
    return current;
}

int shortestPathWithPortals() {
    pii start, end;

    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            if (grid[i][j] == 'S') start = {i, j};
            else if (grid[i][j] == 'E') end = {i, j};
            else if (grid[i][j] == 'P') portals.push_back({i, j});
        }
    }

    vector<vector<bool>> visited(N, vector<bool>(N, false));
    queue<pair<pii, int>> q;

    q.push({start, 0});
    visited[start.first][start.second] = true;

    int dx[] = {-1, 1, 0, 0};
    int dy[] = {0, 0, -1, 1};

    while (!q.empty()) {
        pii curr = q.front().first;
        int steps = q.front().second;
        q.pop();

        if (curr == end) return steps;

        for (int d = 0; d < 4; d++) {
            int nx = curr.first + dx[d];
            int ny = curr.second + dy[d];

            if (isValid(nx, ny, visited)) {
                if (grid[nx][ny] == 'P') {
                    pii tele = getNextPortal({nx, ny});
                    if (!visited[tele.first][tele.second]) {
                        visited[tele.first][tele.second] = true;
                        q.push({tele, steps + 1});
                    }
                } else {
                    visited[nx][ny] = true;
                    q.push({{nx, ny}, steps + 1});
                }
            }
        }
    }

    return -1;
}

int main() {
    cin >> N;
    grid = vector<vector<char>>(N, vector<char>(N));
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            cin >> grid[i][j];

    cout << shortestPathWithPortals() << endl;
    return 0;
}

import heapq

def max_recipes_cooked(N, C, T):
    C.sort()  # Sort recipes by cooking time
    stove_heap = [0] * N  # Time occupied per stove (min-heap)

    for time in C:
        # Pop stove with least time
        earliest_free_time = heapq.heappop(stove_heap)
        if earliest_free_time + time <= T:
            # Assign recipe to this stove
            heapq.heappush(stove_heap, earliest_free_time + time)
        else:
            # Can't cook this recipe, push back the original time
            heapq.heappush(stove_heap, earliest_free_time)

    # Count stoves used for cooking (total recipes completed)
    return sum(t > 0 for t in stove_heap)

Example 

N = 2
C = [2, 3, 4, 5, 9]
T = 10

print(max_recipes_cooked(N, C, T))  # Output will depend on input

Ini
Distance = a * (1 + 2 + 3 + ... + t) = a * t * (t + 1) / 2

Ini
t = int(S * 60)
Python
def distance_covered(N, A, X, S):
    # Convert minutes to seconds
    t = int(S * 60)
    
    # Acceleration of Xth car
    acceleration = A[X]
    
    # Total distance = a * t * (t + 1) // 2
    distance = acceleration * t * (t + 1) // 2
    
    return distance
Example 
Python
N = 3
A = [1, 2, 3]
X = 1
S = 1.5

print(distance_covered(N, A, X, S))  # Output: 2 * 90 * 91 // 2 = 8190

input2: Array A (acceleration of each car)
input3: X (index of car to check distance)
input4: S (time in minutes, decimal allowed)

Speed increases like: a, 2a, 3a, ..., ta
Distance = a + 2a + 3a + ... + ta = a × (1 + 2 + 3 + ... + t) = a × (t × (t + 1)) / 2

def total_distance(N, A, X, S):
    # Convert minutes to seconds
    T = int(float(S) * 60)
    
    # Get acceleration of X-th car (0-based index)
    a = A[X]

    # Use formula: distance = a × t(t+1)/2
    distance = a * T * (T + 1) // 2
    return distance

# Example usage
N = 3
A = [2, 4, 3]
X = 1
S = 0.5
print(total_distance(N, A, X, S))  # Output: Distance covered by car at index 1 in 30 sec

public class CarDistanceCalculator {

    public static int totalDistance(int N, int[] A, int X, double S) {
        // Minutes ko seconds me convert karo
        int T = (int)(S * 60);

        // X-th car ki acceleration le lo (0-based index)
        int a = A[X];

        // Distance = a × T × (T + 1) / 2
        int distance = a * T * (T + 1) / 2;

        return distance;
    }

    public static void main(String[] args) {
        // Example inputs
        int N = 3;
        int[] A = {2, 4, 3};
        int X = 1;
        double S = 0.5;

        int result = totalDistance(N, A, X, S);
        System.out.println("Distance covered: " + result);
    }
}

Input Explanation:
N = 3 cars
Accelerations: [2, 4, 3]
X = 1 means 2nd car (0-based indexing)
S = 0.5 minutes = 30 seconds

// Function to check if the array can be built using subarrays of prefix
    public static boolean canBuild(int[] prefix, int[] arr) {
        List<Integer> list = new ArrayList<>();
        for (int num : prefix) list.add(num);

        int i = prefix.length;
        while (i < arr.length) {
            boolean matched = false;
            // Try all subarrays of prefix
            for (int start = 0; start < prefix.length; start++) {
                for (int end = start + 1; end <= prefix.length; end++) {
                    List<Integer> sub = list.subList(start, end);
                    if (i + sub.size() <= arr.length) {
                        boolean same = true;
                        for (int j = 0; j < sub.size(); j++) {
                            if (arr[i + j] != sub.get(j)) {
                                same = false;
                                break;
                            }
                        }
                        if (same) {
                            i += sub.size();
                            matched = true;
                            break;
                        }
                    }
                }
                if (matched) break;
            }
            if (!matched) return false;
        }
        return true;
    }

    public static int findMinOriginalLength(int[] arr) {
        for (int len = 1; len <= arr.length; len++) {
            int[] prefix = Arrays.copyOfRange(arr, 0, len);
            if (canBuild(prefix, arr)) {
                return len;
            }
        }
        return arr.length;
    }

    public static void main(String[] args) {
        int[] arr = {5, 4, 7, 2, 7, 4, 4, 7, 7, 2};
        int result = findMinOriginalLength(arr);
        System.out.println(result);
    }
}

4

def count_word_frequency(sentence):
    # Remove punctuation and convert to lowercase
    sentence = sentence.lower()
    
    # Split the sentence into words
    words = sentence.split()
    
    # Create a dictionary to store frequency
    frequency = {}
    
    for word in words:
        if word in frequency:
            frequency[word] += 1
        else:
            frequency[word] = 1
    
    # Sort dictionary by key (alphabetically)
    for word in sorted(frequency):
        print(f"{word}: {frequency[word]}")

# Example
input_sentence = "the quick brown fox jumps over the lazy dog the"
count_word_frequency(input_sentence)

[
[1, 2, 3],
[2, 4, 5],
[3, 5, 6]
]

def is_symmetric(matrix):
    n = len(matrix)
    for i in range(n):
        for j in range(n):
            if matrix[i][j] != matrix[j][i]:
                return False
    return True

# Example matrix
matrix = [
    [1, 2, 3],
    [2, 4, 5],
    [3, 5, 6]
]

if is_symmetric(matrix):
    print("The matrix is symmetric.")
else:
    print("The matrix is not symmetric.")

from collections import deque

def heat_spread(grid):
    n = len(grid)
    m = len(grid[0])
    new_grid = [row[:] for row in grid]
    directions = [(-1,0), (1,0), (0,-1), (0,1)]

    for i in range(n):
        for j in range(m):
            if grid[i][j] == 'H':
                for dx, dy in directions:
                    ni, nj = i + dx, j + dy
                    if 0 <= ni < n and 0 <= nj < m and grid[ni][nj] == '.':
                        new_grid[ni][nj] = 'H'
    return new_grid

def simulate_heat(grid, start_x, start_y, end_x, end_y):
    n = len(grid)
    m = len(grid[0])
    queue = deque()
    visited = set()
    queue.append((start_x, start_y, 0, grid))
    visited.add((start_x, start_y))

    while queue:
        x, y, days, curr_grid = queue.popleft()
        if (x, y) == (end_x, end_y):
            return days

        next_grid = heat_spread(curr_grid)
        directions = [(-1,0), (1,0), (0,-1), (0,1)]

        for dx, dy in directions:
            nx, ny = x + dx, y + dy
            if 0 <= nx < n and 0 <= ny < m and next_grid[nx][ny] == '.' and (nx, ny) not in visited:
                visited.add((nx, ny))
                queue.append((nx, ny, days + 1, next_grid))
    return -1

# Input Format
n = int(input())
grid = []
for _ in range(n):
    grid.append(list(input().strip()))

start_x, start_y = map(int, input().split())
end_x, end_y = map(int, input().split())

print(simulate_heat(grid, start_x, start_y, end_x, end_y))