```go
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

type Pair struct {
	num int64
	den int64
}

func same(p1, p2 Pair) bool {
	return p1.num*p2.den == p1.den*p2.num
}

func isGeometric(a []int64) bool {
	n := len(a)
	if n <= 1 {
		return true
	}
	for i := 0; i < n-1; i++ {
		if a[i] == 0 && a[i+1] != 0 {
			return false
		}
	}
	var ref_num, ref_den int64
	found := false
	for i := 0; i < n-1; i++ {
		if a[i] != 0 {
			num := a[i+1]
			den := a[i]
			if !found {
				ref_num = num
				ref_den = den
				found = true
			} else {
				if num*ref_den != den*ref_num {
					return false
				}
			}
		}
	}
	return true
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	line, _ := reader.ReadString('\n')
	n, _ := strconv.Atoi(strings.TrimSpace(line))
	line, _ = reader.ReadString('\n')
	parts := strings.Fields(line)
	a := make([]int64, n)
	for i := 0; i < n; i++ {
		a[i], _ = strconv.ParseInt(parts[i], 10, 64)
	}
	if isGeometric(a) {
		fmt.Println(0)
		return
	}
	var bad []int
	for i := 0; i < n-1; i++ {
		if a[i] == 0 && a[i+1] != 0 {
			bad = append(bad, i)
		}
	}
	numBad := len(bad)
	if numBad > 2 {
		fmt.Println(2)
		return
	}
	if numBad > 0 {
		var possibleK []int
		if numBad == 1 {
			b := bad[0]
			possibleK = append(possibleK, b)
			possibleK = append(possibleK, b+1)
		} else {
			b1 := bad[0]
			b2 := bad[1]
			if b2 == b1+1 {
				possibleK = append(possibleK, b1+1)
			}
		}
		can := false
		for _, k := range possibleK {
			if k < 0 || k >= n {
				continue
			}
			var newA []int64
			for j := 0; j < n; j++ {
				if j != k {
					newA = append(newA, a[j])
				}
			}
			if isGeometric(newA) {
				can = true
				break
			}
		}
		if can {
			fmt.Println(1)
		} else {
			fmt.Println(2)
		}
		return
	}
	z := n
	for i := 0; i < n; i++ {
		if a[i] == 0 {
			z = i
			break
		}
	}
	m := n - 1
	if z < n {
		m = z
	}
	var ratios []Pair
	for i := 0; i < m; i++ {
		ratios = append(ratios, Pair{a[i+1], a[i]})
	}
	var change []int
	for j := 1; j < m; j++ {
		if !same(ratios[j], ratios[j-1]) {
			change = append(change, j)
		}
	}
	can := false
	// remove 0
	s := 1
	isConst := true
	if s <= m-1 {
		if len(change) > 0 && change[len(change)-1] > s {
			isConst = false
		}
	}
	if isConst {
		can = true
	}
	// remove n-1 if z == n
	if z == n {
		p := m - 2
		isConst = true
		if p >= 0 {
			if len(change) > 0 && change[0] <= p {
				isConst = false
			}
		}
		if isConst {
			can = true
		}
	}
	// middle
	maxK := z - 1
	if maxK > n-2 {
		maxK = n - 2
	}
	for k := 1; k <= maxK; k++ {
		leftEnd := k - 2
		isLeftConst := true
		if leftEnd >= 0 {
			if len(change) > 0 && change[0] <= leftEnd {
				isLeftConst = false
			}
		}
		if !isLeftConst {
			continue
		}
		rightStart := k + 1
		isRightConst := true
		if rightStart <= m-1 {
			if len(change) > 0 && change[len(change)-1] > rightStart {
				isRightConst = false
			}
		}
		if !isRightConst {
			continue
		}
		var rLeft, rRight, rNew Pair
		hasLeft := leftEnd >= 0
		if hasLeft {
			rLeft = ratios[0]
		}
		hasRight := rightStart <= m-1
		if hasRight {
			rRight = ratios[rightStart]
		}
		rNew = Pair{a[k+1], a[k-1]}
		consistent := true
		if hasLeft && hasRight {
			if !same(rLeft, rRight) {
				consistent = false
			}
		}
		if consistent && (hasLeft || hasRight) {
			var common Pair
			if hasLeft {
				common = rLeft
			} else {
				common = rRight
			}
			if !same(rNew, common) {
				consistent = false
			}
		}
		if consistent {
			can = true
			break
		}
	}
	if can {
		fmt.Println(1)
	} else {
		fmt.Println(2)
	}
}
```