```python
import math


def poly(xs: list, x: float):
    """
    Evaluates polynomial with coefficients xs at point x.
    return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])


def find_zero(xs: list):
    """ xs are coefficients of a polynomial.
    find_zero find x such that poly(x) = 0.
    find_zero returns only only zero point, even if there are many.
    Moreover, find_zero only takes list xs having even number of coefficients
    and largest non zero coefficient as it guarantees
    a solution.
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """
    # Use Newton's method to find a root
    # Start with an initial guess
    x = 0.0
    # If all coefficients are zero, return 0
    if all(c == 0 for c in xs):
        return 0.0
    
    # Compute derivative coefficients
    # For polynomial sum(xs[i] * x^i), derivative is sum(i * xs[i] * x^(i-1))
    # So derivative coefficients are [1*xs[1], 2*xs[2], ..., n*xs[n]]
    # But we need to evaluate the derivative at x
    
    # Newton's method iteration
    for _ in range(1000):
        fx = poly(xs, x)
        if abs(fx) < 1e-10:
            return x
        
        # Compute derivative value at x
        # derivative = sum(i * xs[i] * x^(i-1)) for i from 1 to n
        dfx = 0.0
        for i in range(1, len(xs)):
            dfx += i * xs[i] * math.pow(x, i - 1)
        
        if abs(dfx) < 1e-10:
            # Derivative is zero, try a different starting point
            # Try small perturbation
            x += 1e-6
            continue
        
        x = x - fx / dfx
    
    return x
```