2025 October 18 Problems

[FloM]

Feel free to work on any of the problems you want; we'll have people present their solutions at 11:30.

Please post your solutions to this thread so others can use this as a reference.

70. Climbing Stairs Easy 53.7%

3192. Minimum Operations to Make Binary Array Elements Equal to One II Medium 64.5%

3539. Find Sum of Array Product of Magical Sequences Hard 62.4%

Please download and import the following iCalendar (.ics) files to your calendar system.

Weekly: https://us04web.zoom.us/meeting/upIqc-6upj8sGt0O2fJXTw2gC4FxRMQ-iqAT/ics?icsToken=98tyKu6uqT8tHNyRthmOR7YAB4-gKO7xiCldjbcNs03jKRhndVHxFbZkKoBSIZXZ

Join Zoom Meeting (Meeting starts at 11:30)
https://us04web.zoom.us/j/76747684609?pwd=HOCapO7jjK0rifPlKvV9CxWFn5lLJn.1

Meeting ID: 767 4768 4609

[Anuj Patnaik]

class Solution:

def climbStairs(self, n: int) -> int:

arr = [0] * (n+1)

arr[0] = 1

arr[1] = 1

for i in range(2, n + 1):

arr[i] = arr[i-1] + arr[i-2]

return arr[n]

[Kevin Burleigh]

3192. Minimum Operations to Make Binary Array Elements Equal to One II Medium 64.5%

## Time: O(N)

## Space: O(N)

## where N = len(nums)

class Solution:

def minOperations(self, nums: List[int]) -> int:

N_nums = len(nums)

def solve_memo (idx, been_toggled, memo):

if (idx,been_toggled) not in memo:

if idx == N_nums-1:

if nums[idx] == 1:

if been_toggled:

result = 1

else:

result = 0

else:

if been_toggled:

result = 0

else:

result = 1

else:

if nums[idx] == 1:

if been_toggled:

result = 1 + solve_memo(idx+1,not been_toggled, memo)

else:

result = solve_memo(idx+1, been_toggled, memo)

else:

if been_toggled:

result = solve_memo(idx+1, been_toggled, memo)

else:

result = 1 + solve_memo(idx+1, not been_toggled, memo)

memo[(idx,been_toggled)] = result

return memo[(idx,been_toggled)]

memo = {}

solve_memo(0, False, memo)

return memo[(0,False)]

[Anuj Patnaik]

class Solution:

def minOperations(self, nums: List[int]) -> int:

num_operations = 0

val = 1

for i in nums:

if i != val:

num_operations += 1

if val == 0:

val = 1

else:

val = 0

return num_operations

[Carrie Lastname]

from itertools import groupby

class Solution:
    def minOperations(self, nums: List[int]) -> int:

        t = 0
        for _,_ in groupby(nums):
            t += 1
        if nums[0] == 1:
            t -= 1
        return t

On Saturday, October 18, 2025 at 9:25:07 AM UTC-7 FloM wrote:

[Kevin Burleigh]

Iterative version

## Time: O(N)

## Space: O(N)

## where N = len(nums)

class Solution:

def minOperations(self, nums: List[int]) -> int:

N_nums = len(nums)

## memo[idx,has_been_toggled]

memo = [ [None,None] for _ in range(N_nums) ]

if nums[-1] == 1:

memo[-1][False] = 0

memo[-1][True] = 1

else:

memo[-1][False] = 1

memo[-1][True] = 0

for idx in reversed(range(N_nums-1)):

if nums[idx] == 1:

memo[idx][False] = memo[idx+1][False]

memo[idx][True] = 1 + memo[idx+1][False]

else:

memo[idx][False] = 1 + memo[idx+1][True]

memo[idx][True] = memo[idx+1][True]

return memo[0][False]

[Kevin Burleigh]

Further simplified:

## Time: O(N)

## Space: O(N)

## where N = len(nums)

class Solution:

def minOperations(self, nums: List[int]) -> int:

N_nums = len(nums)

## memo[idx,has_been_toggled]

memo = [ [None,None] for _ in range(N_nums) ]

memo[-1][False] = 1 - nums[-1]

memo[-1][True] = nums[-1]

for idx in reversed(range(N_nums-1)):

memo[idx][False] = (1-nums[idx]) + memo[idx+1][1-nums[idx]]

memo[idx][True] = nums[idx] + memo[idx+1][1-nums[idx]]

return memo[0][False]

[Allen S.]

func climbStairs(n int) int {

if n < 3 {

return n

}

a, b := 1, 2

for range n - 2 {

a, b = b, a + b

}

return b

}

[Kevin Burleigh]

Reduced space usage:

## Time: O(N)

## Space: O(1)

## where N = len(nums)

class Solution:

def minOperations(self, nums: List[int]) -> int:

N_nums = len(nums)

prev_memo = [1-nums[-1],nums[-1]]

for idx in reversed(range(N_nums-1)):

prev_memo = [(1-nums[idx]) + prev_memo[1-nums[idx]], nums[idx] + prev_memo[1-nums[idx]]]

return prev_memo[0]

[Kevin Burleigh]

70. Climbing Stairs Easy 53.7%

Once you've solved this problem, you might recognize the computed values as the Fibonacci sequence.  There's a formula for that:

from math import sqrt

class Solution:

def climbStairs(self, n: int) -> int:

phi = (1.0+sqrt(5))/2.0

return int( (phi**(n+1) - (1.0 - phi)**(n+1))/sqrt(5) )

[Allen S.]

func minOperations(nums []int) int {

// - count alternations

altCount := 0

prev := 1

for _, cur := range nums {

if cur != prev {

altCount++

prev = cur

}

}

return altCount

}

[Sourabh Majumdar]

3192. Min Operations to make binary array elements equal to one ii. class Solution {

public:

int minOperations(vector<int>& nums) {

std::vector<int> flips_to_1(nums.size(), 0);

std::vector<int> flips_to_0(nums.size(), 0);

std::function<int(std::vector<int>&, int)> get_value = [&](std::vector<int>& nums, int index) -> int {

if (index >= nums.size()) {

return 0;

}

return nums[index];

};

for(int index = (nums.size() - 1); index > -1; index--) {

if (nums[index] == 0) {

flips_to_0[index] = get_value(flips_to_0, index + 1);

flips_to_1[index] = get_value(flips_to_0, index + 1) + 1;

continue;

}

// else we have nums[index] == 1

flips_to_1[index] = get_value(flips_to_1, index + 1);

flips_to_0[index] = get_value(flips_to_1, index + 1) + 1;

}

return flips_to_1[0];

}

};