						import java.io.BufferedReader;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.InputStreamReader;
	import java.io.PrintWriter;
	import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
	import java.util.InputMismatchException;
								
									 
								public	class Main implements Runnable
									{
										static final int MAX = 1000000007;
										static class InputReader
										{
											private InputStream stream;
											private byte[] buf = new byte[1024];
											private int curChar;
											private int numChars;
											private SpaceCharFilter filter;
											private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
									
											public InputReader(InputStream stream)
											{
												this.stream = stream;
											}
											
											public 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++];
											}
										 
											public String nextLine()
											{
												String str = "";
									            try
									            {
									                str = br.readLine();
									            }
									            catch (IOException e)
									            {
									                e.printStackTrace();
									            }
									            return str;
											}
											public 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;
											}
											
											public 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;
											}
											
											public double nextDouble() 
											{
												int c = read();
												while (isSpaceChar(c))
													c = read();
												int sgn = 1;
												if (c == '-') 
												{
													sgn = -1;
													c = read();
												}
												double res = 0;
												while (!isSpaceChar(c) && c != '.') 
												{
													if (c == 'e' || c == 'E')
														return res * Math.pow(10, nextInt());
													if (c < '0' || c > '9')
														throw new InputMismatchException();
													res *= 10;
													res += c - '0';
													c = read();
												}
												if (c == '.') 
												{
													c = read();
													double m = 1;
													while (!isSpaceChar(c)) 
													{
														if (c == 'e' || c == 'E')
															return res * Math.pow(10, nextInt());
														if (c < '0' || c > '9')
															throw new InputMismatchException();
														m /= 10;
														res += (c - '0') * m;
														c = read();
													}
												}
												return res * sgn;
											}
											
											public String readString() 
											{
												int c = read();
												while (isSpaceChar(c))
													c = read();
												StringBuilder res = new StringBuilder();
												do 
												{
													res.appendCodePoint(c);
													c = read();
												} 
												while (!isSpaceChar(c));
												
												return res.toString();
											}
										 
											public boolean isSpaceChar(int c) 
											{
												if (filter != null)
													return filter.isSpaceChar(c);
												return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
											}
										 
											public String next() 
											{
												return readString();
											}
											
											public interface SpaceCharFilter 
											{
												public boolean isSpaceChar(int ch);
											}
										}
									 	
										public static void main(String args[]) throws Exception
										{
											new Thread(null, new Main(),"Main",1<<26).start();
										}
										long power(long x, long y)
										{
										    long res = 1;      // Initialize result
										 
										    x = x % MAX;  // Update x if it is more than or 
										                // equal to p
										 
										    while (y > 0)
										    {
										        // If y is odd, multiply x with result
										        if (y % 2 == 1)
										            res = (res*x) % MAX;
										 
										        // y must be even now
										        y = y>>1; // y = y/2
										        x = (x*x) % MAX;  
										    }
										    return res;
										}
										
										public void run()
										{
											InputReader sc= new InputReader(System.in);
											PrintWriter w= new PrintWriter(System.out);
											int n = sc.nextInt();
											int d = sc.nextInt();
											int[] arr=  new int[n];
											for(int i = 0;i < n;i++){
												arr[i] = sc.nextInt();
											}
											Arrays.sort(arr);
											int ans = Integer.MAX_VALUE;
								outer:		for(int i = 0;i < n;i++){
												for(int j = 0;j < n;j++){
													if(arr[j] - arr[i] > d){
														ans = Math.min(ans,n-j + i);
														continue outer;
													}
												}
												ans = Math.min(ans,i);
											}
											w.println(ans);
											w.close();
										}
										
										static class Node implements Comparable<Node>{
											long a;
											long b;
											Node(long destination,long weight){
												this.a = destination;
												this.b = weight;
											}
											Node(){
												
											}
											@Override
											public int compareTo(Node n){
												return Long.compare(a,n.a);
											}
										}
										static class Pair implements Comparable<Pair>{
											int a;
											int b;
											int c;
											Pair(int a,int b,int c){
												this.a = a;
												this.b = b;
												this.c = c;
											}
											public boolean equals(Object o)
											{
												Pair p = (Pair)o;
												return (p.a==this.a && p.b== this.b) || (p.a == this.b && p.b == this.a);
											}
											public int compareTo(Pair p){
												return Long.compare(this.a,p.a);
											}
											public int hashCode()
											{
												return new Long(a).hashCode()*31 + new Long(b).hashCode();
											}
										}
									}