javascript - 从连续值中提取范围

Question

关闭。这个问题需要更多 focused .它目前不接受答案。












想改进这个问题？更新问题，使其仅关注一个问题 editing this post .


5个月前关闭。







Improve this question




任务1:
我的集合包含 mongodb 中的文档，其值来自顺序范围，如下所示:

 {x:1}
 {x:2}
 {x:3}
 {x:5}
 {x:6}
 {x:7}
 {x:8}
 {x:20}
 {x:21}

我需要提取表单中的顺序范围列表(计数不是强制性的，但我至少需要范围中的第一个和最后一个值):

 {x:[1,3] , count:3}
 {x:[5,8], count:4}
 {x:[20,21],count:2}

或者

 { min:1 , max:3 , count:3}
 { min:5 , max:8 , count:4}
 { min:20 , max:21 , count:2}

请建议合适的解决方案，集合有 ~100M 文档，其中一些值在 10 位范围内，另一些在 15 位范围内，但它们在它们的范围内都是按顺序递增的？
任务 2:
与任务 1 中的想法相同，但基于自定义序列步骤，
例如，如果序列步长为 3:

{y:1}
{y:3}
{y:5}
{y:20}
{y:22}

需要生产:

{y:[1,5] ,count:3}
{y:[20,22]} , count:2}

谢谢!
附:
我通过按位数 range 获取分布部分成功地获得了一些范围图片，但这似乎很笼统:

 db.collection.aggregate([
   {
     $addFields: {
       range: {
         $strLenCP: {
           $toString: "$x"
         }
       }
     }
   },
   {
     $group: {
       _id: "$range",
       minValue: {
         $min: "$x"
       },
       maxValue: {
         $max: "$x"
       },
       Count: {
         $sum: 1
       }
     }
   },
   {
     $addFields: {
       x: [
         {
           $toString: "$minValue"
         },
         {
           $toString: "$maxValue"
         }
       ]
     }
   },
   {
     $project: {
       range: "$_id",
       "_id": 0,
       x: 1,
       Count: 1
     }
   },
   {
     $sort: {
       range: 1
     }
   }
 ])

playground

Answer 1

这是另一种查询方式 - 生成格式为 [ { min: 1 , max: 3 , count: 3 }, ... ] 的结果:

db.collection.aggregate([
 { 
    $sort: { x: 1 } 
 },
 { 
    $group: { 
        _id: null, 
        docs: { $push: "$x" }, 
        firstVal: { $first: "$x" }, 
        lastVal: { $last: "$x" } 
    } 
  },
  { 
    $project: {
        _id: 0,
        output: {
            $let: {
                vars: {
                    result: {
                        $reduce: {
                            input: "$docs",
                            initialValue: { 
                                 prev: { $add: [ "$firstVal", -1 ] }, 
                                 val: { min: "$firstVal", max: 0, count: 0 }, 
                                 vals: [ ] 
                            },
                            in: {
                                 $cond: [
                                     { $eq: [ { $subtract: [ "$$this", "$$value.prev" ] }, 1 ] },
                                     {
                                        prev: "$$this",
                                        val: { 
                                            min : "$$value.val.min", 
                                            max: "$$value.val.max", 
                                            count: { $add: [ "$$value.val.count", 1 ] } 
                                        },
                                        vals: "$$value.vals"
                                     },
                                     {
                                        vals: {
                                            $concatArrays: [
                                                "$$value.vals",
                                                [ { min : "$$value.val.min", max: "$$value.prev", count: "$$value.val.count" } ] 
                                            ]                                
                                         },
                                        val: { min: "$$this", max: "$lastVal", count: 1 },
                                        prev: "$$this"
                                     },
                                 ]
                            }
                        }
                     }
                 },
                 in: {
                     $concatArrays: [ "$$result.vals", [ "$$result.val" ] ]
                 }
            }
        }
    }
  }, 
])