#include <iostream>
#include <fstream>
#include <float.h>
#include <stdlib.h>
#include <math.h>
using namespace std;

typedef struct
{
    int x, y;
}punct;

int n;
punct P[100];

void citire()
{
    ifstream f("cmap.in");
    f >> n;
    for(int i = 0; i < n; i++)
        f >> P[i].x >> P[i].y;
    f.close();
}

//comparare dupa coordonata x
int comparX(const void* a, const void* b)
{
    punct *p1 = (punct *)a,  *p2 = (punct *)b;
    return (p1->x - p2->x);
}
//comparare dupa coordonata y
int comparY(const void* a, const void* b)
{
    punct *p1 = (punct *)a,   *p2 = (punct *)b;
    return (p1->y - p2->y);
}

// distanta dintre doua puncte
float dist(punct p1, punct p2)
{
    return sqrt( (p1.x - p2.x)*(p1.x - p2.x) + (p1.y - p2.y)*(p1.y - p2.y) );
}

//gasirea celei mai mici distante prin metoda clasica O(n^2)
float minim_brut(punct P[], int n)
{
    float min = FLT_MAX;
    for (int i = 0; i < n; i++)
        for (int j = i+1; j < n; j++)
            if (dist(P[i], P[j]) < min)
                min = dist(P[i], P[j]);
    return min;
}


//functie ce afla cele mai apropiate puncte dintr-un vector de puncte ordonate
//dupa coordonata y
float aux_y(punct aux[], int size, float d)
{
    float min = d;

    for (int i = 0; i < size; i++)
        for (int j = i + 1; j < size && (aux[j].y - aux[i].y) < min; j++)
            if (dist(aux[i], aux[j]) < min)
                min = dist(aux[i], aux[j]);

    return min;
}

//Px contine punctele ordonate dupa coordonata x, iar Py dupa coordonata y
float solutie(punct Px[], punct Py[], int n)
{
    if (n <= 3)
        return minim_brut(Px, n);

    int mid = n/2;
    punct midPoint = Px[mid];


    // Divide points in y sorted array around the vertical line.
    punct Pyl[mid+1];   // y sorted points on left of vertical line
    punct Pyr[n-mid-1];  // y sorted points on right of vertical line
    int li = 0, ri = 0;  // indexes of left and right subarrays
    for (int i = 0; i < n; i++)
    {
      if (Py[i].x <= midPoint.x)
         Pyl[li++] = Py[i];
      else
         Pyr[ri++] = Py[i];
    }

    float dl = solutie(Px, Pyl, mid);
    float dr = solutie(Px + mid, Pyr, n-mid);

    float d = min(dl, dr);

    punct aux[n];
    int j = 0;
    for (int i = 0; i < n; i++)
        if (abs(Py[i].x - midPoint.x) < d)
            aux[j++] = Py[i];
    j--;

    return min(d, aux_y(aux, j, d) );
}

int main()
{
    citire();

    punct Px[n];
    punct Py[n];
    for (int i = 0; i < n; i++)
    {
        Px[i] = P[i];
        Py[i] = P[i];
    }

    qsort(Px, n, sizeof(punct), comparX);
    qsort(Py, n, sizeof(punct), comparY);

    cout << "Cea mai mica distanta este " << solutie(Px, Py, n);

    ofstream g("cmap.out");
    g << solutie(Px, Py, n);
    g.close();

    return 0;
}