# Mbpp

> Strategies for solving MBPP Python programming problems.

- Skill: `shashank-yadav/mbpp-3` (Agent Skill, multi-file: 8 files)
- Install (CLI): `npx skillmds@latest add shashank-yadav/mbpp-3`
- Raw SKILL.md: https://api.skillmd.com/api/skills/shashank-yadav/mbpp-3/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: shashank-yadav (https://skillmd.com/u/shashank-yadav)
- Updated: 2026-09-21
- Page: https://skillmd.com/skills/shashank-yadav/mbpp-3

---


# MBPP

Write a Python function that satisfies the given tests. Respond with only
the function definition(s) needed -- no explanation, no example usage, no
markdown code fences, no test code of your own.

## General Strategies

### Input Validation and Edge Cases
- Always consider edge cases such as empty inputs, zero values, negative numbers, and inputs that might cause division by zero.
- For functions involving lists or sequences, handle cases where the input is empty or has only one element.
- For mathematical functions, check for invalid inputs (e.g., negative numbers for square roots, angles outside valid ranges).

### Algorithm Selection and Implementation
- **Sorting:** If the problem involves ordering or finding relationships based on order, sorting the input is often a crucial first step.
- **Iteration and Accumulation:** Many problems require iterating through a collection and accumulating a result (sum, count, max, min, etc.). Use appropriate data structures (like sets for uniqueness, dictionaries for counts/grouping) to optimize these operations.
- **String Manipulation:** For string problems, leverage built-in string methods (`.split()`, `.join()`, `.replace()`, `.upper()`, `.isdigit()`) and consider regular expressions for more complex pattern matching and replacement.
- **Mathematical Operations:** For numerical problems, use the `math` module for functions like `sqrt`, `pi`, and trigonometric operations. Be mindful of floating-point precision.
- **Bitwise Operations:** For problems involving bit manipulation, understand the common bitwise operators (`&`, `|`, `^`, `~`, `<<`, `>>`) and their applications in tasks like setting/clearing bits or checking parity.
- **Dynamic Programming:** For problems that can be broken down into overlapping subproblems, consider dynamic programming approaches to store and reuse intermediate results.

### Code Structure and Readability
- Use meaningful variable names.
- Add comments to explain complex logic or non-obvious steps.
- Ensure functions have clear docstrings explaining their purpose, arguments, and return values.

### Testing and Debugging
- Pay close attention to the provided test cases. They often reveal hidden requirements or edge cases.
- If a solution fails, carefully re-examine the test cases and the logic, especially for the failing inputs.
- Consider the data types involved and potential type errors.

## Specific Strategies

### List/Sequence Manipulation
- **Removing elements:** Use slicing (`lst[:k-1] + lst[k:]`) or list comprehensions for efficient removal.
- **Reversing elements:** Slicing (`[::-1]`) is a concise way to reverse sequences.
- **Swapping elements:** Direct index assignment (`lst[0], lst[-1] = lst[-1], lst[0]`) is efficient for swapping first and last elements.
- **Moving elements:** For moving specific elements (like zeros to the end), use two pointers or create new lists based on conditions.
- **Rotating lists:** Slicing is effective for right or left rotations: `lst[-n:] + lst[:-n]` for right rotation by `n`.

### String Manipulation
- **Replacing characters/substrings:** Use `.replace()` for simple replacements or `re.sub()` for pattern-based replacements.
- **Extracting information:** Use string methods like `.find()`, `.split()`, or regular expressions (`re.search()`) to locate and extract parts of strings.
- **Character type checks:** `.isdigit()` is useful for identifying numeric characters.

### Mathematical Computations
- **Averages:** Sum elements and divide by the count. Handle empty collections to avoid division by zero.
- **Powers:** Use the `**` operator or `math.pow()`.
- **Trigonometry and Geometry:** Utilize the `math` module for `sin`, `cos`, `pi`, etc. Ensure angles are in the correct units (radians vs. degrees).
- **Prime numbers:** Implement trial division up to the square root of the number.
- **Bitwise operations:**
    - To set the rightmost unset bit: `n | (n + 1)`
    - To toggle middle bits: Construct a mask that excludes the first and last bits and XOR with the number.

### Data Structures
- **Sets:** Use sets for efficient membership testing and to find unique elements.
- **Dictionaries:** Use dictionaries for counting occurrences, grouping items, or mapping values to keys.

### Common Pitfalls
- **Off-by-one errors:** Be careful with loop ranges and index calculations, especially when dealing with 0-based vs. 1-based indexing.
- **Floating-point precision:** When comparing or performing calculations with floats, consider potential precision issues. Rounding might be necessary.
- **Mutability:** Be aware of whether you are modifying a list in-place or creating a new one.
- **Hashability:** Ensure that elements you try to add to sets or use as dictionary keys are hashable (e.g., tuples are hashable, lists are not). Convert lists to tuples if needed.