def update_list(val, items=[]):
    items.append(val)
    return items

print("Call 1:", update_list(10))  
print("Call 2:", update_list(20))  

def fresh_list(val, items=None):
    if items is None:
        items = []
    items.append(val)
    return items

print("Call 3:", fresh_list(30))  
print("Call 4:", fresh_list(40))

def count_vowels(s): return sum(1 for ch in s.lower() if ch in 'aeiou') # Example: count_vowels("placement") → 

#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