2026 March 21 Problems

[daryl...@gmail.com]

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.

1941. Check if All Characters Have Equal Number of Occurrences Easy 79.4%

2001. Number of Pairs of Interchangeable Rectangles Medium 52.5%

2019. The Score of Students Solving Math Expression Hard 34.1%

We're going to use the same Google meet link as the last few times: https://meet.google.com/xnn-kifj-jnx?pli=1

[Allen S.]

func areOccurrencesEqual(s string) bool {

counts := make(map[rune]int)

maxCount := 0

for _, v := range s {

counts[v]++

maxCount = max(maxCount, counts[v])

}

for _, cnt := range counts {

if cnt != maxCount {

return false

}

}

return true

}

[Anuj Patnaik]

class Solution:

def areOccurrencesEqual(self, s: str) -> bool:

count_s = defaultdict(int)

for i in s:

count_s[i] += 1

counts = list(count_s.values())

return counts == [counts[0] for i in range(len(counts))]

[Anuj Patnaik]

class Solution:

def interchangeableRectangles(self, rectangles: List[List[int]]) -> int:

ratio_to_count = defaultdict(int)

for i in rectangles:

ratio_to_count[i[0]/i[1]] += 1

ct = 0

values = list(ratio_to_count.values())

for j in values:

if j > 1:

ct += Solution.nchoose2(j)

return int(ct)

def nchoose2(n):

return Solution.factorial(n)/(Solution.factorial(n - 2) * Solution.factorial(2))

def factorial(n):

if n == 0 or n == 1:

return 1

else:

return n * Solution.factorial(n-1)

[Allen S.]

func interchangeableRectangles(rectangles [][]int) int64 {

ratioCounts := make(map[float64]int64)

for _, v := range rectangles {

ratioCounts[float64(v[0])/float64(v[1])]++

}

fmt.Println(ratioCounts)

var pairCount int64

for _, count := range ratioCounts {

// complete graph edges formula

pairCount += count * (count - 1) /2

}

return pairCount

}

On Saturday, March 21, 2026 at 9:45:25 AM UTC-7 daryl...@gmail.com wrote:

[Allen S.]

// solution using GCD func interchangeableRectangles(rectangles [][]int) int64 {

type ratio struct{ w, h int }

ratioCounts := make(map[ratio]int64)

for _, v := range rectangles {

g := gcd(v[0], v[1])

ratioCounts[ratio{v[0] / g, v[1] / g}]++

}

var pairCount int64

for _, count := range ratioCounts {

pairCount += count * (count - 1) / 2

}

return pairCount

}

func gcd(a, b int) int {

for b != 0 {

a, b = b, a%b

}

return a

}

[Carlos Green]

/**

Time & Space O(n)

* @param {string} s

* @return {boolean}

*/

var areOccurrencesEqual = function(s) {

const freqCount = s.split('').reduce((a,c) => {

a[c] = (a[c] || 0) + 1

return a

}, {})

let count = freqCount[s[0]]

for (let key in freqCount) {

if (freqCount[key] !== count) {

return false

}

}

return true

};

On Saturday, March 21, 2026 at 9:45:25 AM UTC-7 daryl...@gmail.com wrote:

[Anuj Patnaik]

class Solution:

def scoreOfStudents(self, s: str, answers: List[int]) -> int:

postfix_s = Solution.convert_to_postfix(s)

correct_ans = Solution.evaluate(postfix_s)

memoization_table = dict()

all_results = Solution.all_possible(s, memoization_table)

score = 0

for j in answers:

if j == correct_ans:

score += 5

else:

if j in all_results:

score += 2

return score

#Evaluating the correct answer(Step 1 Converting to Postfix)

def convert_to_postfix(expression):

output = []

stack = []

for char in expression:

if char.isdigit():

output.append(char)

elif char == '*':

while stack and stack[-1] == '*':

output.append(stack.pop())

stack.append(char)

elif char == '+':

while stack:

output.append(stack.pop())

stack.append(char)

while stack:

output.append(stack.pop())

return "".join(output)

#Step 2: Evaluating Postfix

def evaluate(postfix_eval):

stack = []

for i in postfix_eval:

if i.isdigit():

stack.append(int(i))

else:

op2 = stack.pop()

op1 = stack.pop()

if i == '*':

stack.append(op1 * op2)

elif i == '+':

stack.append(op1 + op2)

return stack.pop()

#All Possible Answers with memoization(saves reevaluating)

def all_possible(expr, memoization):

if expr in memoization:

return memoization[expr]

results = set()

if expr.isdigit():

results.add(int(expr))

return results

for i in range(len(expr)):

if expr[i] == "+":

left = Solution.all_possible(expr[:i],memoization)

right = Solution.all_possible(expr[i+1:], memoization)

for l in left:

for r in right:

if l + r <= 1000:

results.add(l + r)

if expr[i] == "*":

left = Solution.all_possible(expr[:i], memoization)

right = Solution.all_possible(expr[i+1:], memoization)

for l in left:

for r in right:

if l * r <= 1000:

results.add(l * r)

memoization[expr] = results

return results