import java.util.*;
import java.io.*;

public class Sol2 {

	static final boolean stdin = true;
	static final String filename = "";
	static FastScanner br;
	static PrintWriter pw;

	public static void main(String[] args) throws IOException {

		if (stdin) {
			br = new FastScanner();
			pw = new PrintWriter(new OutputStreamWriter(System.out));
		} else {
			br = new FastScanner(filename + ".in");
			pw = new PrintWriter(new FileWriter(filename + ".out"));
		}

		Solver solver = new Solver();
		solver.solve(br, pw);
	}

	static class Solver {
		static long mod = 1000000000;
		static int d;

		public void solve(FastScanner br, PrintWriter pw) throws IOException {
			int n = br.nextInt();
			d = br.nextInt();
			Integer[] in = new Integer[n];
			for (int i = 0; i < n; i++) {
				in[i] = br.nextInt();
			}
			Arrays.sort(in);
			int mac = 1;
			for (int i = 0; i < n-1; i++) {
				for (int j = i + 1; j < n; j++) {
					if(in[j] - in[i] <= d){
						mac = Math.max(mac, j-i+1);
					}
				}
			}
			pw.println(n-mac);
			pw.close();
		}

		public static <K, V extends Comparable<V>> Map<K, V> sortByValues(final Map<K, V> map) {
			Comparator<K> valueComparator = new Comparator<K>() {
				public int compare(K k1, K k2) {
					int compare = map.get(k1).compareTo(map.get(k2));
					if (compare == 0)
						return 1;
					else
						return compare;
				}
			};

			Map<K, V> sortedByValues = new TreeMap<K, V>(valueComparator);
			sortedByValues.putAll(map);
			return sortedByValues;
		}

		static long gcd(long a, long b) {
			if (a > b)
				return gcd(b, a);
			if (a == 0)
				return b;
			return gcd(b % a, a);
		}

		static long pow(long a, long b) {
			if (b == 0)
				return 1L;
			long val = pow(a, b / 2);
			if (b % 2 == 0)
				return val * val % mod;
			else
				return val * val % mod * a % mod;
		}

	}

	static class Point1 implements Comparable<Point1> {
		int a;
		int b;

		Point1(int a, int b) {
			this.a = a;
			this.b = b;
		}

		@Override
		public int compareTo(Point1 o) {
			return (this.b - this.a) - (o.b - o.a);
		}

	}

	static class Point2 implements Comparable<Point2> {
		int a;
		int b;

		Point2(int a, int b) {
			this.a = a;
			this.b = b;
		}

		@Override
		public int compareTo(Point2 o) {
			return this.b - o.b;
		}

	}

	static class UnionFind {
		// The number of elements in this union find
		private int size;
		// Used to track the size of each of the component
		private int[] sz;
		// id[i] points to the parent of i, if id[i] = i then i is a root node
		private int[] id;
		// Tracks the number of components in the union find
		private int numComponents;

		public UnionFind(int size) {
			if (size <= 0)
				throw new IllegalArgumentException("Size <= 0 is not allowed");
			this.size = numComponents = size;
			sz = new int[size];
			id = new int[size];
			for (int i = 0; i < size; i++) {
				id[i] = i; // Link to itself (self root)
				sz[i] = 1; // Each component is originally of size one
			}
		}

		// Find which component/set 'p' belongs to in amortized constant time.
		public int find(int p) {
			// Find the root of the component/set
			int root = p;
			while (root != id[root])
				root = id[root];
			// Compress the path leading back to the root.
			// Doing this operation is called "path compression"
			// and is what gives us amortized time complexity.
			while (p != root) {
				int next = id[p];
				id[p] = root;
				p = next;
			}
			return root;
		}

		// This is an alternative recursive formulation for the find method
		// public int find(int p) {
		// if (p == id[p]) return p;
		// return id[p] = find(id[p]);
		// }

		// Return whether or not the elements 'p' and
		// 'q' are in the same components/set.
		public boolean connected(int p, int q) {
			return find(p) == find(q);
		}

		// Return the size of the components/set 'p' belongs to
		public int componentSize(int p) {
			return sz[find(p)];
		}

		// Return the number of elements in this UnionFind/Disjoint set
		public int size() {
			return size;
		}

		// Returns the number of remaining components/sets
		public int components() {
			return numComponents;
		}

		// Unify the components/sets containing elements 'p' and 'q'
		public void unify(int p, int q) {
			int root1 = find(p);
			int root2 = find(q);
			// These elements are already in the same group!
			if (root1 == root2)
				return;
			// Merge smaller component/set into the larger one.
			if (sz[root1] < sz[root2]) {
				sz[root2] += sz[root1];
				id[root1] = root2;
			} else {
				sz[root1] += sz[root2];
				id[root2] = root1;
			}
			// Since the roots found are different we know that the
			// number of components/sets has decreased by one
			numComponents--;
		}
	}

	public static class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		public FastScanner(String s) {
			try {
				br = new BufferedReader(new FileReader(s));
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			}
		}

		public FastScanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String nextToken() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(nextToken());
		}

		long nextLong() {
			return Long.parseLong(nextToken());
		}

		double nextDouble() {
			return Double.parseDouble(nextToken());
		}

		ArrayList<Integer>[] nextGraph(int nodes, int edges) {
			ArrayList<Integer>[] adj = new ArrayList[nodes];
			for (int i = 0; i < nodes; i++) {
				adj[i] = new ArrayList<Integer>();
			}
			for (int i = 0; i < edges; i++) {
				int a = nextInt() - 1;
				int b = nextInt() - 1;
				adj[a].add(b);
				adj[b].add(a);
			}
			return adj;
		}
	}
}