title: Add Two Integers
slug: add-two-integers
difficulty: easy
leetcode_id: 2235
leetcode_url: https://leetcode.com/problems/add-two-integers/
categories:
  - math
patterns: []

function_signature: "def sum(num1: int, num2: int) -> int:"

test_cases:
  visible:
    - input: { num1: 12, num2: 5 }
      expected: 17
    - input: { num1: -10, num2: 4 }
      expected: -6
  hidden:
    - input: { num1: 0, num2: 0 }
      expected: 0
    - input: { num1: -100, num2: 100 }
      expected: 0
    - input: { num1: 50, num2: 50 }
      expected: 100
    - input: { num1: -50, num2: -50 }
      expected: -100
    - input: { num1: 1, num2: -1 }
      expected: 0

description: |
  Given two integers `num1` and `num2`, return *the **sum** of the two integers*.

constraints: |
  - `-100 <= num1, num2 <= 100`

examples:
  - input: "num1 = 12, num2 = 5"
    output: "17"
    explanation: "num1 is 12, num2 is 5, and their sum is 12 + 5 = 17, so 17 is returned."
  - input: "num1 = -10, num2 = 4"
    output: "-6"
    explanation: "num1 + num2 = -6, so -6 is returned."

explanation:
  intuition: |
    This problem is a fundamental introduction to arithmetic operations in programming.

    While adding two numbers might seem trivial, it establishes an important foundation: understanding how programming languages handle basic mathematical operations, including **negative numbers** and **integer overflow** considerations.

    Think of it as verifying that you understand the most basic building block of computation. Every complex algorithm ultimately breaks down into simple operations like addition.

  approach: |
    **Step 1: Return the sum**

    - Simply use the `+` operator to add `num1` and `num2`
    - Return the result directly

    &nbsp;

    This problem requires no special data structures or algorithms. The built-in addition operator handles all cases including:
    - Two positive numbers
    - Two negative numbers
    - One positive and one negative number
    - Zero as either operand

  common_pitfalls:
    - title: Overthinking the Problem
      description: |
        This problem is intentionally simple. Some developers might overthink it, looking for hidden complexity or edge cases that don't exist.

        The constraints (`-100 <= num1, num2 <= 100`) ensure that the sum will always fit within standard integer bounds, so overflow is not a concern here.
      wrong_approach: "Complex bit manipulation or handling overflow"
      correct_approach: "Simple addition with the + operator"

    - title: Forgetting Negative Numbers
      description: |
        While Python handles negative numbers seamlessly, it's worth understanding that the `+` operator works correctly with negative operands.

        For example, `num1 = -10` and `num2 = 4` correctly produces `-6` because `-10 + 4 = -6`.
      wrong_approach: "Assuming inputs are always positive"
      correct_approach: "Trust the + operator to handle all integer cases"

  key_takeaways:
    - "**Foundation for complexity**: Even complex algorithms are built from simple operations like addition"
    - "**Operator behaviour**: The `+` operator correctly handles positive, negative, and zero values"
    - "**Constraint awareness**: Always check constraints — here, overflow is not a concern due to small input bounds"
    - "**Simplicity is valid**: Sometimes the simplest solution is the correct one; don't overcomplicate"

  time_complexity: "O(1). Addition is a constant-time operation regardless of the values."
  space_complexity: "O(1). No additional data structures are used."

solutions:
  - approach_name: Direct Addition
    is_optimal: true
    code: |
      def sum(num1: int, num2: int) -> int:
          # Simply return the sum of the two integers
          return num1 + num2
    explanation: |
      **Time Complexity:** O(1) — Single arithmetic operation.

      **Space Complexity:** O(1) — No additional memory used.

      This solution directly returns the sum using Python's built-in addition operator. It handles all cases including negative numbers and zero.

  - approach_name: Bit Manipulation (Without + Operator)
    is_optimal: false
    code: |
      def sum(num1: int, num2: int) -> int:
          # Handle negative numbers with 32-bit masking
          MASK = 0xFFFFFFFF
          MAX_INT = 0x7FFFFFFF

          while num2 != 0:
              # XOR gives sum without carry
              temp = (num1 ^ num2) & MASK
              # AND shifted left gives carry
              num2 = ((num1 & num2) << 1) & MASK
              num1 = temp

          # Handle negative results
          return num1 if num1 <= MAX_INT else ~(num1 ^ MASK)
    explanation: |
      **Time Complexity:** O(1) — Maximum 32 iterations for 32-bit integers.

      **Space Complexity:** O(1) — Only uses a few variables.

      This approach adds two numbers without using the `+` operator by simulating binary addition. XOR computes the sum without carry, while AND followed by left shift computes the carry. We repeat until there's no carry left.

      This is included for educational purposes — it demonstrates how addition works at the bit level. In practice, the direct addition approach is preferred.