he-011

# HumanEval/11

Implement a file **`solution.py`** that completes the function below. Keep the given name and signature; your file must define it at module level.

```python
from typing import List


def string_xor(a: str, b: str) -> str:
    """ Input are two strings a and b consisting only of 1s and 0s.
    Perform binary XOR on these inputs and return result also as a string.
    >>> string_xor('010', '110')
    '100'
    """
```

<!-- imported from OpenAI HumanEval (HumanEval/11) -->

# Auto-generated from OpenAI HumanEval HumanEval/11. Do not edit by hand.
from solution import *  # noqa: F401,F403 (prompt helpers may be referenced by tests)
from solution import string_xor as candidate

METADATA = {
    'author': 'jt',
    'dataset': 'test'
}


def check(candidate):
    assert candidate('111000', '101010') == '010010'
    assert candidate('1', '1') == '0'
    assert candidate('0101', '0000') == '0101'


def test_he_011():
    check(candidate)

You are an expert programmer. Solve the task exactly as specified. Output your solution as fenced code blocks using the required file name(s) and the exact function/type signatures requested. Prefer correctness; do not include prose outside code unless asked.

```python
from typing import List


def string_xor(a: str, b: str) -> str:
    """ Input are two strings a and b consisting only of 1s and 0s.
    Perform binary XOR on these inputs and return result also as a string.
    >>> string_xor('010', '110')
    '100'
    """
    result = []
    for i in range(len(a)):
        if a[i] != b[i]:
            result.append('1')
        else:
            result.append('0')
    return ''.join(result)
```

The task is to implement a function that performs binary XOR on two strings consisting of '0's and '1's.

For XOR operation:
- 0 XOR 0 = 0
- 0 XOR 1 = 1
- 1 XOR 0 = 1
- 1 XOR 1 = 0

I need to:
1. Iterate through both strings character by character
2. Perform XOR on each pair of bits
3. Return the result as a string

Let me think about the implementation:

```python
def string_xor(a: str, b: str) -> str:
    result = []
    for i in range(len(a)):
        # XOR operation: if bits are different, result is '1', otherwise '0'
        if a[i] != b[i]:
            result.append('1')
        else:
            result.append('0')
    return ''.join(result)
```

Or I could use a more concise approach:

```python
def string_xor(a: str, b: str) -> str:
    return ''.join('1' if a[i] != b[i] else '0' for i in range(len(a)))
```

Or even using XOR directly:

```python
def string_xor(a: str, b: str) -> str:
    return ''.join(str(int(a[i]) ^ int(b[i])) for i in range(len(a)))
```

The first approach is probably clearest. Let me verify with the example:
- a = '010', b = '110'
- i=0: '0' != '1' → '1'
- i=1: '1' == '1' → '0'
- i=2: '0' == '0' → '0'
- Result: '100' ✓

This matches the expected output.

Let me write the complete solution:

```python
from typing import List


def string_xor(a: str, b: str) -> str:
    """ Input are two strings a and b consisting only of 1s and 0s.
    Perform binary XOR on these inputs and return result also as a string.
    >>> string_xor('010', '110')
    '100'
    """
    result = []
    for i in range(len(a)):
        if a[i] != b[i]:
            result.append('1')
        else:
            result.append('0')
    return ''.join(result)
```

I'll complete the implementation by joining the result list into a string. The function handles binary XOR by comparing each character and appending the appropriate result.