import java.io.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;

public class Practice {

	private static InputStream stream;
	private static byte[] buf = new byte[1024];
	private static int curChar;
	private static int numChars;
	private static SpaceCharFilter filter;
	private static PrintWriter pw;
	public static final long mod = (long)1e9+7;
    public static void main(String[] args) {
    	InputReader(System.in);
		pw = new PrintWriter(System.out); 
        new Thread(null ,new Runnable(){
           public void run(){
               try{
                   test();//This is solution method
           pw.close();
       } catch(Exception e){
           e.printStackTrace();
       }
   }
},"1",1<<26).start();
        }
    public static void test() throws IOException{
   
   	int t=1;
   	while(t-->0){
   	
   		solve();
   		//pw.println();
   		//sb.append("\n");	
   	}
   	//pw.println(sb);
   }
    static int st[];
    private static void solve(){
    	int n = nextInt();
   	 int d = nextInt();
   	 int a[]=nextIntArray(n);
   	 Arrays.sort(a);
   	 int ans=n+2;
   	 for(int i=0;i<n;i++)
   	 {
   		 for(int j=i;j<n;j++)
   		 {
   			 int min=105+5;
   			 int max=-10;
   			 for(int k=i;k<=j;k++)
   			 {
   				 min=Math.min(a[k],min);
   				 max=Math.max(max, a[k]);
   			 }
   			 if(max-min<=d)
   			 {
   				 ans=Math.min(ans,n-(j-i+1));
   			 }
   		 }
   	 }
   	 pw.println(ans);
       }
    public static boolean isPrime(long n) {
		if (n <= 1)
			return false;
		if (n <= 3)
			return true;
 
		if (n % 2 == 0 || n % 3 == 0)
			return false;
 
		for (long i = 5; i * i <= n; i = i + 6)
			if (n % i == 0 || n % (i + 2) == 0)
				return false;
 
		return true;
	}
    public static boolean check(int x,int y,int n){
    	if(x>=0 && x<n && y>=0 && y<n)
    		return true;
    	return false;
    }
   
private static void update(int node,int low,int high,int ind,int val){
    	 if(ind < low || ind > high){
             return;
         }
		
		if(low==high){
     		st[node]=val;
     		return;
    	 }
    	 
    	int mid=(low+high)/2;
    	if(low<= ind && ind<=mid){
    		update(2*node, low, mid, ind, val);
    	}else{
    		update(2*node+1, mid+1, high, ind, val);
    	}
     st[node]= st[2*node] + st[2*node+1];
}
    
private static int query(int node,int low,int high,int qlow,int qhigh){
    	
    	if(qlow>high || qhigh<low){
    		return 0;
    	}
    	 
    	if(qlow<=low && qhigh>=high){
        	
    		return st[node];
    	}
    	
    int mid=(low+high)/2;
    int ans1=query(2*node, low, mid, qlow, qhigh);
    int ans2=query(2*node+1, mid+1, high, qlow, qhigh);
    
    return ans1 + ans2;
    }
    
    

 // To Get Input
 // Some Buffer Methods
  
     		     	
     		    	public static void InputReader(InputStream stream1) {
     		    		stream = stream1;
     		    	}
  
     		    	private static boolean isWhitespace(int c) {
     		    		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
     		    	}
  
     		    	private static boolean isEndOfLine(int c) {
     		    		return c == '\n' || c == '\r' || c == -1;
     		    	}
  
     		    	private static int read() {
     		    		if (numChars == -1)
     		    			throw new InputMismatchException();
     		    		if (curChar >= numChars) {
     		    			curChar = 0;
     		    			try {
     		    				numChars = stream.read(buf);
     		    			} catch (IOException e) {
     		    				throw new InputMismatchException();
     		    			}
     		    			if (numChars <= 0)
     		    				return -1;
     		    		}
     		    		return buf[curChar++];
     		    	}
  
     		    	private static int nextInt() {
     		    		int c = read();
     		    		while (isSpaceChar(c))
     		    			c = read();
     		    		int sgn = 1;
     		    		if (c == '-') {
 							sgn = -1;
 							c = read();
						}	
						int res = 0;
						do {
 							if (c < '0' || c > '9')
 								throw new InputMismatchException();
							res *= 10;
							res += c - '0';
     		    			c = read();
     		    		} while (!isSpaceChar(c));
     		    		return res * sgn;
     		    	}
  
     		    	private static long nextLong() {
     		    		int c = read();
     		    		while (isSpaceChar(c))
     		    			c = read();
     		    		int sgn = 1;
     		    		if (c == '-') {
 							sgn = -1;
 							c = read();
						}
						long res = 0;
						do {
							if (c < '0' || c > '9')
 								throw new InputMismatchException();
							res *= 10;
						    res += c - '0';
     		    			c = read();
     		    		} while (!isSpaceChar(c));
     		    		return res * sgn;
     		    	}
  
     		    	private static String nextToken() {
     		    		int c = read();
     		    		while (isSpaceChar(c))
     		    			c = read();
     		    		StringBuilder res = new StringBuilder();
     		    		do {
     		    			res.appendCodePoint(c);
     		    			c = read();
     		    		} while (!isSpaceChar(c));
     		    		return res.toString();
     		    	}
  
     		    	private static String nextLine() {
     		    		int c = read();
     		    		while (isSpaceChar(c))
     		    			c = read();
     		    		StringBuilder res = new StringBuilder();
     		    		do {
     		    			res.appendCodePoint(c);
     		    			c = read();
     		    		} while (!isEndOfLine(c));
     		    		return res.toString();
     		    	}
  
     		    	private static int[] nextIntArray(int n) {
     		    		int[] arr = new int[n];
     		    		for (int i = 0; i < n; i++) {
     		    			arr[i] = nextInt();
     		    		}
     		    		return arr;
     		    	}
  
     		    	private static long[][] next2dArray(int n, int m) {
     		    		long[][] arr = new long[n][m];
     		    		for (int i = 0; i < n; i++) {
     		    			for (int j = 0; j < m; j++) {
     		    				arr[i][j] = nextLong();
     		    			}
     		    		}
     		    		return arr;
     		    	}
     		    	private static char[][] nextCharArray(int n,int m){
     		    		char [][]c=new char[n][m];
     		    		for(int i=0;i<n;i++){
     		    			String s=nextLine();
     		    			for(int j=0;j<s.length();j++){
     		    				c[i][j]=s.charAt(j);
     		    			}
     		    		}
     		    		return c;
     		    	}
  
     		    	private static long[] nextLongArray(int n) {
     		    		long[] arr = new long[n];
     		    		for (int i = 0; i < n; i++) {
     		    			arr[i] = nextLong();
     		    		}
     		    		return arr;
     		    	}
  
     		    	private static void pArray(int[] arr) {
     		    		for (int i = 0; i < arr.length; i++) {
     		    			pw.print(arr[i] + " ");
     		    		}
     		    		pw.println();
     		    		return;
     		    	}
  
     		    	private static void pArray(long[] arr) {
     		    		for (int i = 0; i < arr.length; i++) {
     		    			pw.print(arr[i] + " ");
     		    		}
     		    		pw.println();
     		    		return;
     		    	}
  
     		    	private static void pArray(boolean[] arr) {
     		    		for (int i = 0; i < arr.length; i++) {
     		    			pw.print(arr[i] + " ");
     		    		}
     		    		pw.println();
     		    		return;
     		    	}
  
     		    	private static boolean isSpaceChar(int c) {
     		    		if (filter != null)
     		    			return filter.isSpaceChar(c);
     		    		return isWhitespace(c);
     		    	}
  
     		    	private interface SpaceCharFilter {
     		    		public boolean isSpaceChar(int ch);
     		    	}
    
}

/*class Pair implements Comparable<Pair>{
long lit,pri;

public Pair(long x,long y) {

	this.lit=x;
	this.pri=y;
}

@Override
public int compareTo(Pair arg0) {
	if((double)lit/(double)pri > (double)arg0.lit/(double)arg0.pri){
		return 1;
	}
	if((double)lit/(double)pri < (double)arg0.lit/(double)arg0.pri){
		return -1;
	}
	return 0;
//	return 0;
}
}
*/