package No2;

import sun.misc.GC;

import java.sql.Statement;
import java.util.Arrays;
import java.util.Scanner;

/**
 * @author ：dazhu
 * @date ：Created in 2020/3/26 11:55
 * @description：最长的可整合子数组的长度
 * @modified By：
 * @version: $
 */
//思路。排序后，一一对比，寻找最长可整合子数组
public class Main {
    public static void main(String[]args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[]arr = new int[n];

        for(int i=0;i<n;i++){
            arr[i] = sc.nextInt();
        }

        //先排序
        int index = 0;
        for(int i=0;i<arr.length;i++){
            index = i;
            for(int j=i;j<arr.length;j++){
                if(arr[j]<arr[index]){
                    index = j;
                }
            }
            swap(arr,index,i);
        }

        //排序完成后，直接查找最长的可整合子数组
        int counter =0;
        int lastCounter = 0;
        int startIndex = 0;
        for(int k=0;k<arr.length-1;k++){
            //初始化本次判断
            counter = 1;
            startIndex = k;
            //进行可整合的判断
            while(true){
                //如果超过范围直接break
                if(startIndex>=arr.length-1){
                    break;
                }
                //如果排序后，有重复内容，则要做去重判断
                if(arr[startIndex]==arr[startIndex+1]){
                    startIndex++;
                }
                //如果满足可整合条件，则继续判断
                if(Math.abs(arr[startIndex]-arr[startIndex+1])==1){
                    startIndex++;
                    counter++;
                }
                else{//一旦不满足，就break
                    break;
                }
            }
            //如此此时长度大于上次的，则更新即可
            if(counter> lastCounter){
                lastCounter = counter;
            }
        }
        System.out.println(lastCounter);
    }

    //交换方法
    public static void swap(int[]arr,int i,int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j]  =temp;
    }
}