Javascript 如何有效地检查连续数字列表是否缺少任何元素

我有这个数组

var arr = ["s00","s01","s02","s03","s04","s05","s07","s08","s09","s10","s11","s12","s13","s14","s17","s19","s20","s21","s22","s24","s25","s26","s27","s28","s30","s32","s33","s34","s36","s38","s39","s41","s43","s44","s45","s46","s47","s48","s49","s50","s51","s52","s53","s54","s55","s56","s58","s60","s61","s62","s63","s64","s65","s67","s69","s70"];

我试图找到一种算法来告诉我哪些

s

s缺失。如您所见，该列表由连续的

s

s（

s1

，

s2

等）组成

起初，我采用了以下解决方案：

var arr=[“s00”、“s01”、“s02”、“s03”、“s04”、“s05”、“s07”、“s08”、“s09”、“s10”、“s11”、“s12”、“s13”、“s14”、“s14”、“s17”、“s19”、“s20”、“s21”、“s22”、“s24”、“s25”、“s26”、“s27”、“s28”、“s32”、“s33”、“s34”、“s36”、“s38”、“s39”、“s41”、“s43”、“s44”、“s45”、“s47”、“s48”、“s49”、“s50”、“s51”、“s52”、“s53”、“s54”、“s55”、“s56”、“s60”、“s67”、“s63”、“s63”，“s70”]；
对于（var i=1；i，正如我从理想阵列解决方案中了解到的，您知道最大阵列大小（？）。因此，如果您有100个最大值，并且预期S00-S99，您可以执行以下操作：

var arrayIndex=0;
for (var i =0; i<100;i++) {
   var idealValue="s"+("00"+i).slice(-2); // To get S01-S99
   if(arr.length <= arrayIndex || arr[arrayIndex]!=idealValue){
        console.log(idealValue + 'is missing');
   }
   arrayIndex++;
}

var-arrayIndex=0；
对于（var i=0；i您可以通过获取数组中的两个元素来减少数组，并填补空白（如果存在）


const
getNumber=s=>+s.slice（1），
pad=i=>（'00'+i）.切片（-2）；
var数组=[“s00”、“s01”、“s02”、“s03”、“s04”、“s05”、“s07”、“s08”、“s09”、“s10”、“s11”、“s12”、“s13”、“s14”、“s17”、“s19”、“s20”、“s21”、“s22”、“s24”、“s25”、“s26”、“s27”、“s28”、“s30”、“s32”、“s33”、“s34”、“s36”、“s39”、“s41”、“s43”、“s45”、“s46”、“s47”、“s48”、“s49”、“s50”、“s51”、“s52”、“s53”、“s54”、“s55”、“s58”、“s60”，“s61”、“s62”、“s63”、“s64”、“s65”、“s67”、“s69”、“s70”]，
结果=[]；
array.reduce（（左、右）=>{
var l=getNumber（左），
r=getNumber（右）；
而（++lconsole.log（result）；
您可以这样做，将每个数组项与相邻的数组项进行比较，如果差值大于1，则显示可以记录的所有数字


常数arr=[“s00”、“s01”、“s02”、“s03”、“s04”、“s05”、“s07”、“s08”、“s09”、“s10”、“s11”、“s12”、“s13”、“s14”、“s14”、“s17”、“s19”、“s20”、“s21”、“s22”、“s24”、“s25”、“s26”、“s27”、“s28”、“s32”、“s33”、“s34”、“s36”、“s38”、“s39”、“s41”、“s43”、“s44”、“s45”、“s47”、“s48”、“s49”、“s50”、“s51”、“s52”、“s53”、“s54”、“s55”、“s58””s60、s61、s62、s63、s64、s65、s67、s69、s70]；
for（设i=0；i}
您使用内部
的解决方案虽然
-loop看起来已经很好了，但如果
，只需忽略不必要的
，并跟踪您当前希望看到的数字，而不是每次解析前一个数字

大概是这样的：


var arr=[“s00”、“s01”、“s02”、“s03”、“s04”、“s05”、“s07”、“s08”、“s09”、“s10”、“s11”、“s12”、“s13”、“s14”、“s14”、“s17”、“s19”、“s20”、“s21”、“s22”、“s24”、“s25”、“s26”、“s27”、“s28”、“s32”、“s33”、“s34”、“s36”、“s38”、“s39”、“s41”、“s43”、“s44”、“s45”、“s47”、“s48”、“s49”、“s50”、“s51”、“s52”、“s53”、“s54”、“s55”、“s56”、“s60”、“s67”、“s63”、“s63””s70“]；
var expectedI=0
对于（变量i=0；i}
这只是一种查找给定数组中数字序列中某个元素是否缺失的方法。我们可以使用（n*（n+1））/2表示在n个第一个数字上求和。此外，如果数组以10开头，我们将删除1-10个和。这只是告诉我们是否缺少某些内容，而不是缺少什么内容。优点是数组可以不排序。计算最小值比对整个数组排序更便宜

var arr = ["s00","s01","s02","s03","s04","s05","s07","s08","s09","s10","s11","s12","s13","s14","s17","s19","s20","s21","s22","s24","s25","s26","s27","s28","s30","s32","s33","s34","s36","s38","s39","s41","s43","s44","s45","s46","s47","s48","s49","s50","s51","s52","s53","s54","s55","s56","s58","s60","s61","s62","s63","s64","s65","s67","s69","s70"];

let total = 0;

for(let i = 0; i<arr.length; i++){
    arr[i] = parseInt(arr[i].replace("s", ""));
    total += arr[i];
}

let hipFirstSum = ((arr[0]-1)*(arr[0]))/2;  //or minimun
let n = arr[arr.length -1];
let hipSum = (n*(n+1))/2;
let realSum = hipSum - hipFirstSum;

(realSum != total)?console.log("wrong"):console.log("good");

var arr=[“s00”、“s01”、“s02”、“s03”、“s04”、“s05”、“s07”、“s08”、“s09”、“s10”、“s11”、“s12”、“s13”、“s14”、“s14”、“s17”、“s19”、“s20”、“s21”、“s22”、“s24”、“s25”、“s26”、“s27”、“s28”、“s32”、“s33”、“s34”、“s36”、“s38”、“s39”、“s41”、“s43”、“s44”、“s45”、“s47”、“s48”、“s49”、“s50”、“s51”、“s52”、“s53”、“s54”、“s55”、“s56”、“s60”、“s67”、“s63”、“s63””s70“]；
设total=0；
对于（设i=0；i既然你知道你需要一个顺序数组，我不知道为什么它需要比循环通过数字
arr[0]
通过
arr[end]
更复杂，同时保留一个计数器来知道你在数组中的位置。这将在O（n）处运行，但我不认为您可以在这方面有所改进-在最坏的情况下，您需要至少查看每个元素一次


var arr=[“s00”、“s01”、“s02”、“s03”、“s04”、“s05”、“s07”、“s08”、“s09”、“s10”、“s11”、“s12”、“s13”、“s14”、“s14”、“s17”、“s19”、“s20”、“s21”、“s22”、“s24”、“s25”、“s26”、“s27”、“s28”、“s32”、“s33”、“s34”、“s36”、“s38”、“s39”、“s41”、“s43”、“s44”、“s45”、“s47”、“s48”、“s49”、“s50”、“s51”、“s52”、“s53”、“s54”、“s55”、“s56”、“s60”、“s67”、“s63”、“s63””s70“]；
let first=parseInt（arr[0]。子字符串（1））
let last=parseInt（arr[arr.length-1]。子字符串（1））
让计数=0
for（设i=first；i}
因此，如果您知道没有重复项，并且条目是有序的，那么一个相当简单的过程就是从检查列表中元素的数量开始

arr的长度应等于连续元素的数量，是吗

***警告：如果元素没有排序，或者可能存在重复项，那么这当然不起作用

假设条件适用，则简单的二进制搜索将找到第一个缺少的元素

之后，它是一种分而治之的方法，二进制搜索仅限于上层pa
#include    <stdio.h>
#include    <stdlib.h>

#define ARY_SZ  68

static
int arr[ARY_SZ] =
{
        1,  2,  3,  4,  5,  6,  7,  8,  9,
    10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
    20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
    30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
    40, 41, 42, 43,     45, 46, 47, 48, 49,
    50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
    60, 61, 62, 63, 64, 65, 66, 67, 68, 70
};

int
main(
    void )
{
    int     i,
            lim,
            lo,
            hi,
            mid,
            val,
            cnt;

    /*  Pre-check.  */
    lim = arr[ARY_SZ - 1] - (ARY_SZ - 1);
    if (lim == 0)
    {
        /*  No missing elements.    */
        printf(
            "No missing elements.\n" );
        return 0;
    }

    /*  Initialize binary search.   */
    lo  = 0;
    hi  = ARY_SZ;
    cnt = 0;

    /*  For (at most) the number of array elements, do: */
    for (i = 0; i < ARY_SZ && cnt < lim; i++)
    {
        /*  Get mid point of search.    */
        mid = lo + hi >> 1;

        /*  Get array value, adjust and do comparisons. */
        val = arr[ mid ] - cnt;
        if (val == mid)
            lo = mid + 1;
        if (val > mid)
            hi = mid - 1;

        if (lo > hi)
        {
            /*  Report missing element. */
            printf(
                "Missing element @ arr[ %d ] == %d, probes = %d\n",
                lo,
                arr[ lo ],
                i );

            /*  Divide and conquer. */
            hi   = ARY_SZ;
            cnt += 1;
        }
    }

    printf(
        "Probes = %d\n",
        i - 1);

    return 0;
}

Missing element @ arr[ 0 ] == 1, probes = 5
Missing element @ arr[ 43 ] == 45, probes = 11
Missing element @ arr[ 67 ] == 70, probes = 16
Probes = 16

var util = require( 'util' );

//  Array of data.
var arr = [
        1,  2,  3,  4,  5,  6,  7,  8,  9,
    10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
    20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
    30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
    40, 41, 42, 43,         46, 47, 48, 49,
    50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
    60, 61, 62, 63, 64, 65, 66, 67, 68, 70
];
var arr_len = arr.length;

//  Empty array?
if (arr_len == 0)
{
    console.log(
        util.format(
            "No elements." ));
    process.exit( 0 );
}

//  Pre-check.
var lim = arr[arr_len - 1] - (arr_len - 1);
if (lim == 0)
{
    printf(
        "No missing elements.\n" );
    return 0;
}

//  Initialize binary search.
var lo  = 0;
var hi  = arr_len;
var mid = 0;

//  Search metadata.
var cnt = 0;
var prv = 0;
var val = 0;
var i;

for (i = 0; i < arr_len && cnt < lim; i++)
{
    //  Get mid point of search.
    mid = (lo + hi) >> 1;

    //  Get array value, adjust and do comparisons
    val = arr[ mid ] - cnt;
    if (val === mid)
        lo = mid + 1;
    if (val > mid)
        hi = mid - 1;

    //  Have we found something?
    if (lo > hi)
    {
        //  Yes.  Divide and conquer.
        hi  = arr_len;
        prv = cnt;
        cnt = arr[ lo ] - lo;

        //  Report missing element(s).
        console.log(
            util.format(
                "Missing %d elements @ arr[ %d ] == %d, probes = %d",
                cnt - prv,
                lo,
                arr[ lo ],
                i + 1 ));
    }
}

console.log(
    util.format(
        "Probes: %d",
        i ));

let numbers = arr.map(s => +s.slice(1)); // Convert to numbers
let maximum = Math.max.apply(null, numbers); // Get the maximum
let missing = Array(maximum).fill(true); // start with all missing
let answer = numbers.reduce((p, c) => (p[c] = false, p), missing); // set to false if there
answer.forEach((e,i) =>  (e && console.log(i + " seems to be missing"))); // show answer