/**
 * code generated by JHelper
 * More info: https://github.com/AlexeyDmitriev/JHelper
 * @author aryssoncf
 */



// Taken from: https://github.com/bqi343/USACO/blob/master/Implementations/content/contest/templateShort.cpp

#include <utility>
#include <vector>
#include <random>
#include <chrono>
#include <cassert>
#include <set>
#include <queue>
#include <map>
#include <numeric>
#include <algorithm>
#include <iostream>
#include <unordered_map>
#include <bitset>
#include <iomanip>
#include <complex>
#include <stack>
#include <array>
#include <unordered_set>
#include <climits>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef double db;
typedef string str;

typedef pair<int, int> pii;

typedef vector<int> vi;
typedef vector<ull> vul;
typedef vector<ll> vl;
typedef vector<pii> vpii;

#define FOR(i,a,b) for (int i = (a); i < (b); ++i)
#define F0R(i,a) FOR(i,0,a)
#define ROF(i,a,b) for (int i = (b)-1; i >= (a); --i)
#define R0F(i,a) ROF(i,0,a)
#define trav(a,x) for (auto& a: x)

#define sz(x) (int)x.size()
#define all(x) begin(x), end(x)
#define rsz resize

#define mp make_pair
#define pb push_back
#define f first
#define s second

const int MOD = 1e9+7; // 998244353; // = (119<<23)+1
const int MX = 2e5+5;

template<class T> bool ckmin(T& a, const T& b) {
    return a > b ? a = b, 1 : 0; }
template<class T> bool ckmax(T& a, const T& b) {
    return a < b ? a = b, 1 : 0; }

mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());


//
// Created by aryssoncf on 28/10/2019.
//

#include <type_traits>


#include <iterator>


template <typename T>
constexpr auto hasBegin(int) -> decltype(std::begin(std::declval<T>()), true) {
    return true;
}

constexpr bool hasBegin(...) {
    return false;
}

template <typename T>
using IsContainer = std::integral_constant<bool, hasBegin<T>(0)>;


#ifndef JHELPER_EXAMPLE_PROJECT_IO_HPP
#define JHELPER_EXAMPLE_PROJECT_IO_HPP

#endif //JHELPER_EXAMPLE_PROJECT_IO_HPP

template<typename T>
std::istream &operator>>(std::istream &is, std::vector<T> &vec) {
    for (T &element: vec) {
        is >> element;
    }
    return is;
}

template<typename T, typename U>
std::istream &operator>>(std::istream &is, std::pair<T, U> &p) {
    is >> p.first;
    is >> p.second;
    return is;
}

template <class X, class Y>
std::ostream & operator << (std::ostream & os, std::pair <X, Y> const& p) {
    return os << p.first << " " << p.second;
}

template <class Ch, class Tr, class Container>
std::basic_ostream <Ch, Tr> & operator << (std::basic_ostream <Ch, Tr>& os, Container const& x) {
    bool first = true;
    for(auto& y : x) {
        if (first) {
            first = false;
        } else {
            os << " ";
        }
        os << y;
    }
    return os;
}







template <typename T, typename = std::true_type>
struct IdentityHelper;

template <typename T>
struct IdentityHelper<T, typename std::is_arithmetic<T>::type> {
    static T identity() {
        return 1;
    }
};

template <typename T>
T identity() {
    return IdentityHelper<T>::identity();
}



#include <string>
#include <stdexcept>

#ifndef SPCPPL_ASSERT
#ifdef SPCPPL_DEBUG
#define SPCPPL_ASSERT(condition) \
		if(!(condition)) { \
			throw std::runtime_error(std::string() + #condition + " in line " + std::to_string(__LINE__) + " in " + __PRETTY_FUNCTION__); \
		}
#else
#define SPCPPL_ASSERT(condition)
#endif
#endif



template <typename T>
T gcd(T a, T b) {
    while (b) {
        T tmp = a % b;
        a = b;
        b = tmp;
    }
    return a;
}

template <typename T>
class Rational {
public:
    Rational(): numerator(0), denominator(1) {
    }

    Rational(T numerator): numerator(numerator), denominator(1) {
    }

    Rational(T numerator, T denominator): numerator(numerator), denominator(denominator) {
        SPCPPL_ASSERT(denominator != 0);
        normalize();
    }

    Rational& operator+=(const Rational& rhs) {
        return *this = *this + rhs;
    }

    Rational& operator-=(const Rational& rhs) {
        return *this = *this - rhs;
    }

    Rational& operator*=(const Rational& rhs) {
        numerator *= rhs.numerator;
        denominator *= rhs.denominator;
        normalize();
        return *this;
    }

    Rational operator-() const {
        return Rational(-numerator, denominator);
    }

    Rational& operator/=(const Rational& rhs) {
        SPCPPL_ASSERT(rhs.numerator != 0);
        numerator *= rhs.denominator;
        denominator *= rhs.numerator;
        normalize();
        return *this;
    }

    bool operator==(const Rational& rhs) const {
        return numerator == rhs.numerator && denominator == rhs.denominator;
    }

    const T& getNumerator() const {
        return numerator;
    }

    const T& getDenominator() const {
        return denominator;
    }

private:
    void normalize() {
        T g = gcd(numerator, denominator);
        numerator /= g;
        denominator /= g;

        if (denominator < 0) {
            numerator = -numerator;
            denominator = -denominator;
        }
    }

    T numerator, denominator;

    template <typename U>
    friend Rational<U> operator+(const Rational<U>& lhs, const Rational<U>& rhs);
};


template <typename T>
Rational<T> operator+(const Rational<T>& lhs, const Rational<T>& rhs) {
    T g = gcd(lhs.denominator, rhs.denominator);
    return Rational<T>(
            lhs.numerator * (rhs.denominator / g) + rhs.numerator * (lhs.denominator / g),
            lhs.denominator / g * rhs.denominator
    );
}

template <typename T>
Rational<T> operator-(const Rational<T>& lhs, const Rational<T>& rhs) {
    return lhs + (-rhs);
}

template <typename T>
Rational<T> operator*(const Rational<T>& lhs, const Rational<T>& rhs) {
    Rational<T> copy = lhs;
    return copy *= rhs;
}

template <typename T>
Rational<T> operator/(const Rational<T>& lhs, const Rational<T>& rhs) {
    Rational<T> copy = lhs;
    return copy /= rhs;
}

template <typename T>
std::ostream& operator<<(std::ostream& stream, const Rational<T>& rational) {
    return stream << rational.getNumerator() << '/' << rational.getDenominator();
}

template <typename T>
struct IdentityHelper<Rational<T>> {
    static Rational<T> identity() {
        return Rational<T>(1);
    }
};

template <typename T>
bool operator==(const Rational<T>& lhs, const Rational<T>& rhs) {
    return lhs.getNumerator() * rhs.getDenominator() == lhs.getDenominator() * rhs.getNumerator();
}

template <typename T>
bool operator!=(const Rational<T>& lhs, const Rational<T>& rhs) {
    return !(lhs == rhs);
}

template <typename T>
bool operator<(const Rational<T>& lhs, const Rational<T>& rhs) {
    return lhs.getNumerator() * rhs.getDenominator() < lhs.getDenominator() * rhs.getNumerator();
}

template <typename T>
bool operator>(const Rational<T>& lhs, const Rational<T>& rhs) {
    return rhs < lhs;
}

template <typename T>
bool operator<=(const Rational<T>& lhs, const Rational<T>& rhs) {
    return !(lhs > rhs);
}

template <typename T>
bool operator>=(const Rational<T>& lhs, const Rational<T>& rhs) {
    return !(lhs < rhs);
}



using namespace std;

class BPickingUp {

    int f(const set<pii> &points, int dx, int dy) {
        int res = 0;
        trav(pt, points) {
            pii aux = {pt.f - dx, pt.s - dy};
            res += 1 - points.count(aux);
        }
        return res;
    }

public:
    void solve(std::istream& in, std::ostream& out) {
        int n;
        in >> n;
        vi X(n), Y(n);
        FOR(i, 0, n) {
            in >> X[i] >> Y[i];
        }
        set<pii> points;
        FOR(i, 0, n) {
            points.insert({X[i], Y[i]});
        }
        int res = n;
        FOR(i, 0, n) {
            FOR(j, i + 1, n) {
                int dx = X[j] - X[i], dy = Y[j] - Y[i];
                ckmin(res, f(points,  dx, dy));
            }
        }
        out << res << '\n';
    }

    void setup() {}
};


int main() {
    std::ios_base::sync_with_stdio(false);
	BPickingUp solver;
    solver.setup();
	std::istream& in(std::cin);
	std::ostream& out(std::cout);
	in.tie(nullptr);
    out << std::fixed;
    out.precision(20);
	solver.solve(in, out);
	return 0;
}


Measured memory_bytes: 3656