1126. 最近点对

from math import sqrt

class Point(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance(self, other):
        return sqrt((self.x-other.x)*(self.x-other.x)+(self.y-other.y)*(self.y-other.y))

    def __str__(self):
        return str(self.x)+" "+str(self.y)


def calMin(L, left, right):
    d = 0x7fffffff
    for i in range(left, right-1):
        for j in range(i+1, min(right, i+8)):
            temp = L[i].distance(L[j])
            d = min(temp, d)
    return d

def cut(Lx, left, right, Ly):
    if right-left < 4:
        return calMin(Lx, left, right)
    middle = (left+right)//2
    midX = Lx[middle].x
    Lyl = []; Lyr = []
    for point in Ly:
        if point.x < midX:
            Lyl.append(point)
        else:
            Lyr.append(point)
    d1 = cut(Lx, left, middle, Lyl)
    d2 = cut(Lx, middle, right, Lyr)
    d = d1 if d1 < d2 else d2
    return merge(Lx, left, right, d, Ly)

def merge(L, left, right, d, Ly):
    middle = (left+right)//2
    midX = L[middle].x
    tempL = []
    for point in Ly:
        if midX-d <= point.x <= midX+d:
            tempL.append(point)
    d2 = calMin(tempL, 0, len(tempL))
    return min(d, d2)


while True:
    N = int(input())
    if N == 0:
        break
    Lx = []
    for _ in range(N):
        x, y = map(float, input().split())
        Lx.append(Point(x, y))
    Lx.sort(key=lambda point: point.x)
    Ly = Lx[:]
    Ly.sort(key=lambda point: point.y)
    print("%.2f"%(cut(Lx, 0, N, Ly)/2))

#include "bits/stdc++.h"
using u64 = uint64_t;

struct Point {
    double x, y;
};

double static square(double a) { return a * a; }

double static distance(Point a, Point b) { return sqrt(square(a.x - b.x) + square(a.y - b.y)); }

double static min_distance(std::vector<Point>::iterator bg, std::vector<Point>::iterator ed) {
    auto const kNum = ed - bg;
    // Make sure kNum > 1.
    if (kNum == 2) {
        return distance(*bg, *(bg + 1));
    }
    if (kNum == 3) {
        return std::min({distance(*bg, *(bg + 1)), distance(*bg, *(bg + 2)), distance(*(bg + 1), *(bg + 2))});
    }
    auto const kMid = bg + kNum / 2;
    auto ret = std::min(min_distance(bg, kMid), min_distance(kMid, ed));
    for (auto i = kMid - 1, i_ed = bg - 1; i != i_ed; --i) {
        if (abs(i->x - kMid->x) > ret) {
            break;
        }
        for (auto j = kMid; j != ed; ++j) {
            if (abs(i->x - j->x) > ret) {
                break;
            }
            auto dis = distance(*i, *j);
            if (ret > dis) {
                ret = dis;
            }
        }
    }
    return ret;
}

int main() {
    std::cout << std::fixed;
    std::cout.precision(2);
    for (u64 n; std::cin >> n, n;) {
        std::vector<Point> points(n);
        for (auto &i : points) {
            std::cin >> i.x >> i.y;
        }
        sort(points.begin(), points.end(),
             [](Point const &lhs, Point const &rhs) { return std::tie(lhs.x, lhs.y) < std::tie(rhs.x, rhs.y); });
        std::cout << min_distance(points.begin(), points.end())/ 2 << '\n';
    }
}