相差不超过k的最多数

n, k = map(int, input().split())

a = list(map(int, input().split()))
res = [1]
a = sorted(a)
temp = 0
for i in range(n - 1):
    for j in range(temp, n):
        if abs(a[j] - a[i]) < k:
            res.append(j - i + 1)
        else:
            temp = j
            break

print(max(res))

import java.util.*;
import java.io.*;
//随机选择数组元素可不按顺序
//数组先排序，排序后根据k获取区间长度
//因为最长区间可能是中间区间，所以还要全部遍历。
//排序后滑动找最大满足条件的滑动窗口
public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
        String[] line1=bf.readLine().split(" ");
        int n=Integer.parseInt(line1[0]);
        int k=Integer.parseInt(line1[1]);
        int[] ch=Arrays.stream(bf.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();
        Arrays.sort(ch);
        int temp=0;//当前窗口
        int maxLen=0;//最大窗口

        //逐步滑动右侧，左侧按条件滑动
        for(int l=0, i=1;i<ch.length;i++){
            if(ch[i]-ch[l]<=k){
                temp++;//满足条件后统计长度并右侧滑动
                if(maxLen<temp){
                    maxLen=temp;
                }
            }else{
                //不满足条件时左侧滑动，同步右侧滑动r++。
                //此时窗口始终和上一次满足条件时窗口长度一致
                l++;
            }
        }

        System.out.println(maxLen+1);//没有输出为0的用例

        // if(maxLen!=0){
        //     System.out.println(maxLen+1);
        // }else{
        //     System.out.println(maxLen);
        // }

    }
}

import java.util.Scanner;
import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        int n = in.nextInt();
        int k = in.nextInt();
        if (n < 2) {
            System.out.println(n);
            return;
        }

        int arr[] = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = in.nextInt();
        }
        // 先排序，然后用双指针，尽可能移动右边指针，直到右边指针触底

        Arrays.sort(arr);
        int l = 0, r = 1;
        int max_len = 0;
        while (r < arr.length && l <= r) {
            if (Math.abs(arr[l] - arr[r]) <= k) {
                max_len = Math.max(max_len, r - l + 1);
                r++;
            }else{
                l++;
            }

        }

        System.out.println(max_len);
    }
}

n,k=map(int,input().split())
nums=list(map(int,input().split()))
nums.sort()

max_len=0
start=0
for end in range(n):
    while nums[end]-nums[start]>k:
        start +=1
    max_len=max(max_len,end-start+1)
print(max_len)

#include <stdio.h>
#include <stdlib.h>
int compare(const void* a,const void* b){
    return (*(int*)a-*(int*)b);
}
int myselect(int* a,int n,int k){
    qsort(a, n, sizeof(int), compare);
    int max=0,l=0,r=0;
    for (r=0; r<n; r++) {
         while (a[r]-a[l]>k) {
            l++;
         }
         int cur_count=r-l+1;
         if (cur_count>max) {
              max=cur_count;
         }
    }
    return max;
}
int main() {
    int m,n;
    scanf("%d %d", &m, &n);
    int* a=(int*)malloc(sizeof(int)*m);
    for (int i=0; i<m; i++) {
        scanf("%d", &a[i]);
    }
    int res=myselect(a, m, n);
    printf("%d", res);

    return 0;
}

def func(n, k, alist):
    if n <= 0:
        return 0
    res = 0
    lp = 0
    alist.sort()
    for rp in range(n):
        if lp < n and alist[rp] - alist[lp] > k:
            lp += 1
        res = max(res, rp-lp+1)
    return res

n, k = map(int, input().strip().split())
alist = list(map(int, input().strip().split()))
print(func(n, k, alist))

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int k = in.nextInt();
        in.nextLine();

        int nums[] = new int[n];
        for(int i = 0;i < n;i++){
            nums[i] = in.nextInt();
        }

        Arrays.sort(nums);

        // 快慢指针定义
        int slow = 0;
        int fast = 0;
        
        int res = 0;
        while(fast < n){
            if(nums[fast] - nums[slow] > k){
                res = Math.max(res,fast - slow);
                slow++;
                continue;
            }
            fast++;
        }
        res = Math.max(res,fast - slow);
       System.out.println(res);
    }
}

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
    int n, k;
    cin>>n>>k;
    vector<int> arr(n);
    for(int i=0; i<n; i++){
        cin>>arr[i];
    }
    sort(arr.begin(),arr.end());
    int l=0, r=1, max_value=0;
    while(r<n){
        if(arr[r]-arr[l]<=k){
            max_value = max(max_value, r-l+1);
            r++;
        }else{
            l++;
        }
    }
    max_value = max(max_value,r-l);
    cout<<max_value;
    return 0;
}

package main

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

var in=bufio.NewReader(os.Stdin)

func main() {
    var n,k int
    fmt.Scan(&n,&k)
    arr:=make([]int,n)
    for i:=0;i<n;i++{
        fmt.Fscan(in,&arr[i])
    }
    sort.Ints(arr)
    ans:=0
    for l,r:=0,0;r<len(arr);r++{
        for arr[r]-arr[l]>k{
            l++
        }
        if r-l+1>ans{
            ans=r-l+1
        }
    }
    fmt.Print(ans)
}

#include <iostream>
#include <algorithm>

int main()
{
    int n, k;
    std::cin >> n >> k;
    int nums[n];
    for(int i = 0; i < n; ++i)
        std::cin >> nums[i];
    std::sort(nums, nums + n);
    
    int left = 0, right = 1;
    int maxCnt = 0;
    while(right < n)
    {
        if (nums[right] - nums[left] <= k)
            maxCnt = std::max(maxCnt, right - left + 1);
        else
            ++left;
        ++right;
    }
    std::cout << maxCnt;
}