# Solving Leetcode Interviews in Seconds with AI: Broken Calculator


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "991" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> There is a broken calculator that has the integer startValue on its display initially. In one operation, you can:  multiply the number on display by 2, or subtract 1 from the number on display.  Given two integers startValue and target, return the minimum number of operations needed to display target on the calculator.   Example 1:  Input: startValue = 2, target = 3 Output: 2 Explanation: Use double operation and then decrement operation {2 -> 4 -> 3}.  Example 2:  Input: startValue = 5, target = 8 Output: 2 Explanation: Use decrement and then double {5 -> 4 -> 8}.  Example 3:  Input: startValue = 3, target = 10 Output: 3 Explanation: Use double, decrement and double {3 -> 6 -> 5 -> 10}.    Constraints:  1 <= startValue, target <= 109  

	# Explanation
	Here's a breakdown of the approach, followed by the Python code:

*   **Work Backwards:** Instead of trying to reach `target` from `startValue`, work backward from `target` to `startValue`. This is more efficient because we can only multiply by 2 or subtract 1. Reversing these operations means dividing by 2 (if even) or adding 1. Division is generally more efficient than multiplication in exploring the state space.
*   **Prioritize Division:** Whenever `target` is even, divide it by 2. This gets us closer to `startValue` faster than adding 1.
*   **Handle Start Greater Than Target:** If `startValue` is greater than `target`, simply subtract them. The only operation possible then is subtraction.

*   **Runtime Complexity:** O(log(target)) & **Storage Complexity:** O(1)

	
	# Code
	```python
	def brokenCalc(startValue: int, target: int) -> int:
    """
    Calculates the minimum number of operations to transform startValue to target
    using a broken calculator that can only multiply by 2 or subtract 1.
    """
    operations = 0
    while target > startValue:
        if target % 2 == 0:
            target //= 2
        else:
            target += 1
        operations += 1

    return operations + (startValue - target)
	```