package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
	"sort"
)

func ufFind(parent *[20]int, x int) int {
	for (*parent)[x] != x {
		(*parent)[x] = (*parent)[(*parent)[x]]
		x = (*parent)[x]
	}
	return x
}

func exactCheck(m, k, dmax int, diffFreq []int, start []int, pairs []uint32) bool {
	var edges [10]uint32
	e := 0
	for d := m; d <= dmax; d += m {
		if diffFreq[d] == 0 {
			continue
		}
		l, r := start[d], start[d+1]
		for i := l; i < r; i++ {
			edges[e] = pairs[i]
			e++
		}
	}

	var verts [20]uint16
	var parent [20]int
	vc := 0

	for i := 0; i < e; i++ {
		p := edges[i]
		u := uint16(p >> 16)
		v := uint16(p)

		iu := -1
		for j := 0; j < vc; j++ {
			if verts[j] == u {
				iu = j
				break
			}
		}
		if iu < 0 {
			iu = vc
			verts[vc] = u
			parent[vc] = vc
			vc++
		}

		iv := -1
		for j := 0; j < vc; j++ {
			if verts[j] == v {
				iv = j
				break
			}
		}
		if iv < 0 {
			iv = vc
			verts[vc] = v
			parent[vc] = vc
			vc++
		}

		ru := ufFind(&parent, iu)
		rv := ufFind(&parent, iv)
		if ru != rv {
			parent[ru] = rv
		}
	}

	roots := 0
	for i := 0; i < vc; i++ {
		if ufFind(&parent, i) == i {
			roots++
		}
	}
	return vc-roots <= k
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	idx := 0
	nextInt := func() int {
		for idx < len(data) && (data[idx] < '0' || data[idx] > '9') && data[idx] != '-' {
			idx++
		}
		sign := 1
		if data[idx] == '-' {
			sign = -1
			idx++
		}
		val := 0
		for idx < len(data) && data[idx] >= '0' && data[idx] <= '9' {
			val = val*10 + int(data[idx]-'0')
			idx++
		}
		return sign * val
	}

	n := nextInt()
	k := nextInt()
	a := make([]int, n)
	for i := 0; i < n; i++ {
		a[i] = nextInt()
	}
	sort.Ints(a)

	lb := n - k
	if lb < 1 {
		lb = 1
	}

	dmax := a[n-1] - a[0]
	diffFreq := make([]int, dmax+1)

	for i := 0; i < n; i++ {
		ai := a[i]
		for j := i + 1; j < n; j++ {
			diffFreq[a[j]-ai]++
		}
	}

	upper := k * (k + 1) / 2

	var start []int
	var pairs []uint32

	if upper > k {
		start = make([]int, dmax+2)
		for d := 1; d <= dmax; d++ {
			start[d+1] = start[d] + diffFreq[d]
		}
		totalPairs := n * (n - 1) / 2
		pairs = make([]uint32, totalPairs)
		nextPos := make([]int, dmax+1)
		copy(nextPos, start[:dmax+1])

		for i := 0; i < n; i++ {
			ai := a[i]
			for j := i + 1; j < n; j++ {
				d := a[j] - ai
				pairs[nextPos[d]] = (uint32(i) << 16) | uint32(j)
				nextPos[d]++
			}
		}
	}

	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

	for m := lb; m <= dmax; m++ {
		sum := 0
		for d := m; d <= dmax; d += m {
			sum += diffFreq[d]
			if sum > upper {
				break
			}
		}
		if sum <= k {
			fmt.Fprintln(out, m)
			return
		}
		if sum <= upper && exactCheck(m, k, dmax, diffFreq, start, pairs) {
			fmt.Fprintln(out, m)
			return
		}
	}

	ans := dmax + 1
	if ans < lb {
		ans = lb
	}
	fmt.Fprintln(out, ans)
}