Language: C++

#include<bits/stdc++.h>

#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define IINF (INT_MAX)
#define EPS (1e-7)
#define COUNTER_CLOCKWISE 1
#define CLOCKWISE -1 
#define ONLINE_BACK 2
#define ONLINE_FRONT -2
#define ON_SEGMENT 0
#define equals(a,b) (fabs((a)-(b)) < EPS)
#define MAX 100100

using namespace std;

// Library

class Point{
public:
  double x,y;

  Point(double x = -IINF,double y = -IINF): x(x),y(y){}

  Point operator + (Point p){return Point(x+p.x,y+p.y);}
  Point operator - (Point p){return Point(x-p.x,y-p.y);}
  Point operator * (double a){return Point(a*x,a*y);}
  Point operator / (double a){return Point(x/a,y/a);}
  Point operator * (Point a){ return Point(x * a.x - y * a.y, x * a.y + y * a.x); }

  bool operator < (const Point& p) const{ return !equals(x,p.x)?x<p.x:y<p.y; }

  bool operator == (const Point& p)const{ return fabs(x-p.x) < EPS && fabs(y-p.y) < EPS; }

};

struct Segment{
  Point p1,p2;
  Segment(Point p1 = Point(),Point p2 = Point()):p1(p1),p2(p2){}
  bool operator == (const Segment& p)const { return p.p1 == p1 && p.p2 == p2; }
};

typedef Point Vector;
typedef Segment Line;
typedef vector<Point> Polygon;

ostream& operator << (ostream& os,const Point& a){ os << "(" << a.x << "," << a.y << ")"; }

ostream& operator << (ostream& os,const Segment& a){ os << "( " << a.p1 << " , " << a.p2 << " )"; }

double dot(Point a,Point b){ return a.x*b.x + a.y*b.y; }

double cross(Point a,Point b){ return a.x*b.y - a.y*b.x; }

double norm(Point a){ return a.x*a.x+a.y*a.y; }

double abs(Point a){ return sqrt(norm(a)); }

//rad は角度をラジアンで持たせること
Point rotate(Point a,double rad){ return Point(cos(rad)*a.x - sin(rad)*a.y,sin(rad)*a.x + cos(rad)*a.y); }

// 度をラジアンに変換
double toRad(double agl){ return agl*M_PI/180.0; }

int ccw(Point p0,Point p1,Point p2){
  Point a = p1-p0;
  Point b = p2-p0;
  if(cross(a,b) > EPS)return COUNTER_CLOCKWISE;
  if(cross(a,b) < -EPS)return CLOCKWISE;
  if(dot(a,b) < -EPS)return ONLINE_BACK;
  if(norm(a) < norm(b))return ONLINE_FRONT;
  return ON_SEGMENT;
}

Point projection(Line l,Point p) {
  double t = dot(p-l.p1, l.p1-l.p2) / norm(l.p1-l.p2);
  return l.p1 + (l.p1-l.p2)*t;
}


bool intersectSS(Line s, Line t) {
  return ccw(s.p1,s.p2,t.p1)*ccw(s.p1,s.p2,t.p2) <= 0 &&
         ccw(t.p1,t.p2,s.p1)*ccw(t.p1,t.p2,s.p2) <= 0;
}

bool intersectSP(Line s, Point p) { return abs(s.p1-p)+abs(s.p2-p)-abs(s.p2-s.p1) < EPS; // triangle inequality }

double distanceSP(Line s, Point p) {
  Point r = projection(s, p);
  if (intersectSP(s, r)) return abs(r - p);
  return min(abs(s.p1 - p), abs(s.p2 - p));
}

double distanceSS(Line s, Line t) {
  if (intersectSS(s, t)) return 0;
  return min(min(distanceSP(s, t.p1), distanceSP(s, t.p2)),
             min(distanceSP(t, s.p1), distanceSP(t, s.p2)));
}

// Library

int N;
Segment seg[MAX];

int main(){
  cin >> N;
  rep(i,N)cin >> seg[i].p1.x >> seg[i].p1.y >> seg[i].p2.x >> seg[i].p2.y;

  cout << setiosflags(ios::fixed) << setprecision(10);

  if( N >= 5101 ){
    cout << 0 << endl;
    return 0;
  }

  double ans = IINF;
  rep(i,N){
    REP(j,i+1,N){
      double dist = distanceSS(seg[i],seg[j]);
      if( equals(ans,dist) || dist > ans ) continue;
      ans = dist;
    }
  }
  cout << ans << endl;

  return 0;
}

Compiler output:
a.cc: In function 'std::ostream& operator<<(std::ostream&, const Point&)':
a.cc:47:91: warning: no return statement in function returning non-void [-Wreturn-type]
   47 | ostream& operator << (ostream& os,const Point& a){ os << "(" << a.x << "," << a.y << ")"; }
      |                                                                                           ^
a.cc: In function 'std::ostream& operator<<(std::ostream&, const Segment&)':
a.cc:49:99: warning: no return statement in function returning non-void [-Wreturn-type]
   49 | ostream& operator << (ostream& os,const Segment& a){ os << "( " << a.p1 << " , " << a.p2 << " )"; }
      |                                                                                                   ^
a.cc: In function 'bool intersectSP(Line, Point)':
a.cc:88:36: error: a function-definition is not allowed here before '{' token
   88 | double distanceSP(Line s, Point p) {
      |                                    ^
a.cc:94:35: error: a function-definition is not allowed here before '{' token
   94 | double distanceSS(Line s, Line t) {
      |                                   ^
a.cc:105:9: warning: empty parentheses were disambiguated as a function declaration [-Wvexing-parse]
  105 | int main(){
      |         ^~
a.cc:105:9: note: remove parentheses to default-initialize a variable
  105 | int main(){
      |         ^~
      |         --
a.cc:105:9: note: or replace parentheses with braces to value-initialize a variable
a.cc:105:11: error: a function-definition is not allowed here before '{' token
  105 | int main(){
      |           ^
a.cc:127:2: error: expected '}' at end of input
  127 | }
      |  ^
a.cc:86:35: note: to match this '{'
   86 | bool intersectSP(Line s, Point p) { return abs(s.p1-p)+abs(s.p2-p)-abs(s.p2-s.p1) < EPS; // triangle inequality }
      |                                   ^