Go: package main

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

const (
	initialBufSize = 1e4
	maxBufSize     = 1e6 + 7
)

var buf []byte = make([]byte, maxBufSize)
var sc = bufio.NewScanner(os.Stdin)

func init() {
	sc.Split(bufio.ScanWords)
	sc.Buffer(buf, maxBufSize)
}

func main() {
	for {
		n := nextInt()
		if n == 0 {
			break
		}
		an := make([]int, n)
		min := 1000000
		for i := 0; i < n; i++ {
			an[i] = nextInt()
		}
		sort.Ints(an)
		for i := 1; i < n; i++ {
			sub := an[i] - an[i-1]
			if min > sub {
				min = sub
			}
		}
		fmt.Println(min)
	}
}

func nextInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}

C++: #include <iostream>
using namespace std;

// 再帰関数
static void Sub_QuickSort(int* pnData, int nFirst, int nLast);
// クイックソート
void QuickSort(int* pnData, int nNumOf)
{
    Sub_QuickSort(pnData, 0, nNumOf - 1);
}

int main(void){
    // Your code here!
    
    int n;
    while(1){
        cin >> n;
        if(n==0){
            break;
        }else{
            int a[n];
            for(int i=0;i<n;i++){
                cin >> a[i];
            }
            
            QuickSort(a,n);
            int min = 1000000;
            
            for(int i=1;i<n;i++){
                if(a[i]-a[i-1]<min) min = a[i]-a[i-1];
            }
            cout << min << endl;
        }
        
    }
    

    return 0;
}

// 再帰関数
// nFirst : ブロックの最初のインデックス
// nLast  : ブロックの最後のインデックス
static void Sub_QuickSort(int* pnData, int nFirst, int nLast)
{
    int iLess    = nFirst;  // 前半のインデックス
    int iGreater = nLast;   // 後半のインデックス
    int x;                  // 「ある値」

    // 「ある値」は両端の要素の平均値にする
    x = (pnData[nFirst] + pnData[nLast]) / 2;

    // 交換ループ
    // 位置が逆になると終了
    while(iLess < iGreater)
    {
        // x より小さい要素は無視
        while(pnData[iLess] < x)
            iLess++;
        // x より大きい要素は無視
        while(pnData[iGreater] > x)
            iGreater--;

        // 位置がちゃんとしているときは交換し、
        // iLess と iGreater を１つずつ進める
        if(iLess < iGreater)
            swap(pnData[iLess++], pnData[iGreater--]);
    }
    // iLess == iGreater で終わった時は、
    // iGreater < iLess になるようにする
    if(iLess == iGreater)
    {
        if(pnData[iLess] < x)
            iLess++;
        else if(pnData[iLess] > x)
            iGreater--;
    }

    // 次のブロックのサイズが２以上の時は再帰
    if(iLess >= nFirst + 2)
        Sub_QuickSort(pnData, nFirst, iLess - 1);
    if(iGreater <= nLast - 2)
        Sub_QuickSort(pnData, iGreater + 1, nLast);
}

C++: #include<stdio.h>
 
int main(void){
 int n,a[1000],i,j,b,c,min;
 
 while(1){
  scanf("%d",&n);
 
  if(n==0){
   break;
  }
  for(i=0;i<n;i++){
   scanf("%d",&a[i]);
  }
  for(i=0;i<n-1;i++){
   for(j=n-1;j>i;j--){
    if(a[j-1]<a[j]){
     b=a[j-1];a[j-1]=a[j];a[j]=b;
    }
   }
  }
  min=a[0];
  for(i=0;i<n-1;i++){
   c=a[i]-a[i+1];
   if(min>c){
    min=c;
   }
  }
  printf("%d\n",min);
 }
}

C++: #include<iostream>
#include<vector>
#include<algorithm>

using namespace std;


int main(void){

  int size,min_diff;
  while(true){
    cin>>size;
    if(size==0) break;
    vector<int> vec(size);
    for(int i=0;i<size;i++){
      cin>>vec.at(i);
  //    vec.push_back(temp);
    }
    sort(vec.begin(),vec.end());
    min_diff=vec.at(1)-vec.at(0);
    for(int i=1;i<size-1;i++){
      int nowdiff=vec.at(i+1)-vec.at(i);
      if(min_diff>nowdiff) min_diff=nowdiff;
    }
    cout<<min_diff<<endl;
  }
  return 0;
}

C++: #include<bits/stdc++.h>
#pragma warning(disable:4996)
#ifdef _MSC_VER
#  define __builtin_popcount __builtin_popcountll
#  define __builtin_popcountll __popcnt
#endif
#define int long long
using namespace std;
using ll = long long;
using ld = long double;
const long double PI = acos(-1.0);
const int dx[4] = { 1,0,-1,0 }, dy[4] = { 0,1,0,-1 };
inline void my_io() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(0);
	std::cout << fixed << setprecision(10);
}
signed main() {
	int n;
	while (cin>>n,n) {
		vector<int>as(n);
		for (int i = 0; i < n; i++) {
			cin >> as[i];
		}
		sort(as.begin(), as.end());
		vector<int>sas(n - 1);
		for (int i = 0; i < n - 1; i++) {
			sas[i] = abs(as[i + 1] - as[i]);
		}
		sort(sas.begin(), sas.end());
		cout << sas[0] << endl;
	}
}

C++: #include <iostream>
#include <stdio.h>
#include <vector>
#include <math.h>
#include <algorithm>
#include <string>
using namespace std;

void newline() {cout << endl;}
template <typename T> void display(T input){cout << input;}
template <typename T> void put(T input){display(input); newline();}
void iput(int input) {put(input);}
void lput(long long input) {put(input);}

int main(){
  int n, in, prev, min, sa;
  vector<int> input;
  while(true){
    cin >> n;
    if(n != 0){
      for(int i=0; i<n; i++){
        cin >> in;
        input.push_back(in);
      }
      sort(input.begin(), input.end());
      min = 1000000;
      for(int i=1; i<n; i++){
        sa = abs(input[i-1] - input[i]);
        min = min > sa ? sa : min;
      }
      iput(min);
    }else{
      break;
    }
  }
}

C++: // 2017/12/13 Tazoe

#include <iostream>
#include <cstdlib>
using namespace std;

int main()
{
	while(true){
		int n;
		cin >> n;

		if(n==0)
			break;

		int a[1000];
		for(int i=0; i<n; i++){
			cin >> a[i];
		}

		int dif = 1000001;

		for(int i=0; i<n-1; i++){
			for(int j=i+1; j<n; j++){
				int d = abs(a[i]-a[j]);

				if(d<dif){
					dif = d;
				}
			}
		}

		cout << dif << endl;
	}

	return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;
#include <iostream>
/*cout <<"Debug"
cout <<x-30<<' '<<y-30<<endl;*/
typedef pair<pair<int ,int>, int> P;
vector<pair<pair<int ,int>, int> > v_ans;
vector<long int>v;
vector<long int>v_ansl;
/*taro tenn,hanako_ten,sum*/

bool cmp(P h, P r){
  return h.second < r.second;
}
int main(){
    int N;
    cin >>N;
    while(N != 0){
      for (int i = 0;i<N;i++){
        long int x;
        cin >>x;
        v.push_back(x);
      }
      for(int i = 0;i < N;i++){
        for(int j = i+1; j < N;j++){
          if(i == j)continue;
          v_ansl.push_back(abs(v[i]-v[j]));
        }
      }
      sort(v_ansl.begin(),v_ansl.end());
      cout <<v_ansl[0]<<endl;

      v_ansl.clear();
      v.clear();


      cin >>N;
    }
  return 0;
}

C++: #include<bits/stdc++.h>
using namespace std;

int main(){
    while(1){
        int n;  cin>>n;
        if(n==0)break;
        int score[n];   for(int i=0;i<n;i++)cin>>score[i];

        for(int i=0;i<n;i++){
            bool flag=false;
            for(int j=i;j<n;j++){
                int minj=i;
                if(score[i]>score[j]){
                    minj=j;
                    flag=true;
                }
                if(flag==true)swap(score[i],score[minj]);
            }
        }

        //for(int i=0;i<n;i++)cout<<score[i]<<" ";
        int min=1000000;

        for(int i=0;i<n-1;i++){
            if(min>abs(score[i]-score[i+1]))min=abs(score[i]-score[i+1]);

        }
        cout<<min<<endl;
    }


    return 0;
}