Unlock the Golden Treasure Box: Algorithmic Solutions for Interview Questions

Golden Treasure Box Search

The problem describes a series of boxes numbered from 0 to N, each labeled with an integer. A box is a "golden treasure box" if the sum of numbers on all boxes to its left equals the sum of numbers on all boxes to its right. The left sum of the first box and the right sum of the last box are defined as 0. Input is a comma‑separated list of the box numbers (size between 1 and 10,000, each value between -1000 and 1000). The task is to output the index of the first golden box or -1 if none exists.

Solution idea : Simulate the process. Initialise left_sum = 0 and right_sum = sum(nums[1:]). Iterate over the boxes starting from index 1. For each index i:

Subtract nums[i] from right_sum (the current box is no longer on the right side).

Add nums[i‑1] to left_sum (the previous box now belongs to the left side).

If left_sum == right_sum, i is the answer; break.

If the loop finishes without a match, the answer remains -1.

ans = -1
for i, num in enumerate(nums[1:], 1):
    right_sum -= num
    left_sum += nums[i-1]
    if right_sum == left_sum:
        ans = i
        break

Inequality Set Validation

Given three rows of coefficients ( a1, a2, a3), a vector of integer variables x, three target values b1, b2, b3, and three operators (one of "=", ">", ">=", "<", "<="), the program must:

Check whether each inequality holds.

Compute the maximum difference left - b among the three inequalities and output its integer part.

Solution idea :

Define dot_product(a_lst, x_lst) to compute the sum of element‑wise products.

Define check(left, right, op) to evaluate the operator.

Parse the input strings (semicolon‑separated groups, commas inside each group) into the appropriate numeric lists.

Compute the left‑hand sides: left1 = dot_product(a1_lst, x_lst), similarly for left2 and left3.

Calculate

max_diff = int(max(left1 - b_lst[0], left2 - b_lst[1], left3 - b_lst[2]))

.

Use check on each inequality; if all are true, print "true,{max_diff}", otherwise "false,{max_diff}".

# 题目：2023B-不等式组
# 算法：模拟

def dot_product(a_lst, x_lst):
    return sum(a * x for a, x in zip(a_lst, x_lst))

def check(left_part, right_part, op):
    if op == ">=" and left_part >= right_part:
        return True
    elif op == "<=" and left_part <= right_part:
        return True
    elif op == ">" and left_part > right_part:
        return True
    elif op == "<" and left_part < right_part:
        return True
    elif op == "=" and left_part == right_part:
        return True
    return False

# 输入分割
a1s, a2s, a3s, xs, bs, ops = input().split(";")
a1_lst = list(map(float, a1s.split(",")))
a2_lst = list(map(float, a2s.split(",")))
a3_lst = list(map(float, a3s.split(",")))
x_lst = list(map(int, xs.split(",")))
b_lst = list(map(float, bs.split(",")))
op_lst = ops.split(",")

# 计算左侧表达式
left1 = dot_product(a1_lst, x_lst)
left2 = dot_product(a2_lst, x_lst)
left3 = dot_product(a3_lst, x_lst)

max_diff = int(max(left1 - b_lst[0], left2 - b_lst[1], left3 - b_lst[2]))

if (check(left1, b_lst[0], op_lst[0]) and
    check(left2, b_lst[1], op_lst[1]) and
    check(left3, b_lst[2], op_lst[2])):
    print("true,{}".format(max_diff))
else:
    print("false,{}".format(max_diff))

Remove K Digits to Get the Smallest Number

Given a positive integer NUM1 and an integer N (the number of digits to delete), the goal is to delete exactly N digits from NUM1 so that the resulting integer NUM2 is as small as possible. This is equivalent to LeetCode 402.

Core idea : Use a monotonic stack to keep the digits that form the smallest possible prefix. While traversing the digits from left to right, pop larger previous digits from the stack as long as we still have deletions left. After processing all digits, if deletions remain, remove them from the end of the stack, then join the stack, strip leading zeros, and return the result (or "0" if empty).

class Solution:
    def removeKdigits(self, num: str, k: int) -> str:
        # Initialise stack to store digits to keep
        stack = []
        for digit in num:
            # Remove larger previous digits while we can still delete
            while k and stack and stack[-1] > digit:
                stack.pop()
                k -= 1
            stack.append(digit)
        # If deletions remain, remove from the end
        result = ''.join(stack[:len(stack) - k]).lstrip('0')
        return result or "0"