计算多段时间的重叠

最新推荐文章于 2023-03-18 14:23:01 发布
最新推荐文章于 2023-03-18 14:23:01 发布
阅读量1.1k 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nmgrd/article/details/78144895
版权 
package com.lihong.DDPush.pms;

import com.lihong.DDPush.mybatis.Parser;
import org.junit.Test;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * Created by lihong10 on 2017/9/28.
 */
public class TimeOverlapTest {

    public static final String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";

    @Test
    public void test() {
        String[] params = new String[] {
                "2017-09-28 08:00:00",
                "2017-09-28 10:00:00",
                "2017-09-28 12:00:00",
                "2017-09-28 15:00:00",
                "2017-09-28 07:00:00",
                "2017-09-28 18:00:00"
        };

        String[] params1 = new String[] {
                "2017-09-28 08:00:00",
                "2017-09-28 10:00:00",
                "2017-09-28 12:00:00",
                "2017-09-28 15:00:00"
        };

        String[] params2 = new String[] {
                "2017-09-28 07:00:00",
                "2017-09-28 18:00:00"
        };

        caculate(params, params1, params2);
    }


    @Test
    public void test01() {
        String[] params = new String[]{
                "2017-09-28 08:00:00",
                "2017-09-28 17:00:00",
                "2017-09-28 09:00:00",
                "2017-09-28 16:00:00"
        };
        String[] params1 = new String[]{
                "2017-09-28 08:00:00",
                "2017-09-28 17:00:00"
        };

        String[] params2 = new String[]{
                "2017-09-28 09:00:00",
                "2017-09-28 16:00:00"
        };
        caculate(params, params1, params2);
    }


    @Test
    public void test02() {
        String[] params = new String[]{
                "2017-09-28 08:00:00",
                "2017-09-28 10:00:00",
                "2017-09-28 09:00:00",
                "2017-09-28 12:00:00",
                "2017-09-28 11:00:00",
                "2017-09-28 13:00:00",
                "2017-09-28 12:00:00",
                "2017-09-28 15:00:00"
        };

        String[] params1 = new String[]{
                "2017-09-28 08:00:00",
                "2017-09-28 10:00:00",
                "2017-09-28 09:00:00",
                "2017-09-28 12:00:00",
                "2017-09-28 11:00:00",
                "2017-09-28 13:00:00"
        };

        String[] params2 = new String[]{
                "2017-09-28 12:00:00",
                "2017-09-28 15:00:00"
        };

        caculate(params, params1, params2);
    }


    @Test
    public void test03() {
        String[] params = new String[]{
                "2017-09-28 08:00:00",
                "2017-09-28 10:00:00",
                "2017-09-28 09:00:00",
                "2017-09-28 12:00:00",
                "2017-09-28 11:00:00",
                "2017-09-28 13:00:00",
                "2017-09-28 12:00:00",
                "2017-09-28 15:00:00",
                "2017-09-28 07:00:00",
                "2017-09-28 11:00:00"
        };

        String[] params1 = new String[]{
                "2017-09-28 08:00:00",
                "2017-09-28 10:00:00",
                "2017-09-28 09:00:00",
                "2017-09-28 12:00:00",
                "2017-09-28 11:00:00",
                "2017-09-28 13:00:00"
        };

        String[] params2 = new String[]{
                "2017-09-28 12:00:00",
                "2017-09-28 15:00:00",
                "2017-09-28 07:00:00",
                "2017-09-28 11:00:00"
        };

        caculate(params, params1, params2);
    }


    @Test
    public void test04() {
        String[] params = new String[]{
                "2017-09-28 08:00:00",
                "2017-09-28 10:00:00",
                "2017-09-28 09:00:00",
                "2017-09-28 12:00:00",
                "2017-09-28 11:00:00",
                "2017-09-28 13:00:00",
                "2017-09-28 12:00:00",
                "2017-09-28 15:00:00",
                "2017-09-28 07:00:00",
                "2017-09-28 11:00:00"
        };

        String[] params1 = new String[] {
                "2017-09-28 08:00:00",
                "2017-09-28 10:00:00",
                "2017-09-28 09:00:00",
                "2017-09-28 12:00:00",
                "2017-09-28 11:00:00",
                "2017-09-28 13:00:00"
        };

        String[] params2 = new String[]{
                "2017-09-28 12:00:00",
                "2017-09-28 15:00:00",
                "2017-09-28 07:00:00",
                "2017-09-28 11:00:00"
        };

        caculate(params, params1, params2);
    }


    /**
     * @Author: lihong10
     * @Description:
     * @param
     * @Date: 2017/9/30  14:34
     */
    @Test
    public void test05() {
        String[] params = new String[] {
                "2017-09-28 07:00:00",
                "2017-09-28 10:00:00",
                "2017-09-28 13:00:00",
                "2017-09-28 18:00:00",
                "2017-09-28 21:00:00",
                "2017-09-28 23:00:00",
                "2017-09-28 01:00:00",
                "2017-09-28 23:40:00"
        };

        String[] params1 = new String[] {
                "2017-09-28 07:00:00",
                "2017-09-28 10:00:00",
                "2017-09-28 13:00:00",
                "2017-09-28 18:00:00",
                "2017-09-28 21:00:00",
                "2017-09-28 23:40:00"
        };

        String[] params2 = new String[]{
                "2017-09-28 01:00:00",
                "2017-09-28 23:40:00"
        };

        caculateNotInHoliday(params, params1, params2);
    }



    private void caculateNotInHoliday(String[] params, String[] authTimes, String[] parkTimes) {
        List<Date> dates = getDateList(params);
        removeRepeat(dates);
        Collections.sort(dates);


        List<TimePair> pairs = new ArrayList<TimePair>();

        for (int i = 0, j = dates.size(); i < j; i++) {
            if ((i + 2) <= j) {

                System.out.println("i: " + i + ", j: " + (i + 1));
                TimePair pair = new TimePair(dates.get(i), dates.get(i + 1));
                pairs.add(pair);
                pair.caculateOverLapWithAuth(getDateList(authTimes));
                pair.caculateOverLapWithStay(getDateList(parkTimes));
                System.out.println(pair);
                System.out.println();
            }
        }


        System.out.println("===============================================================================");
        System.out.println(pairs);
        System.out.println("===============================================================================");
        List<TimePair> notInHolidayLi = new ArrayList<>();
        for (int i = 0; i < pairs.size(); i++) {
            TimePair pair = pairs.get(i);
            if (pair.notInHoliday()) {
                notInHolidayLi.add(pair);
                System.out.println(pair);
            }
        }

        System.out.println("===============================================================================");
        System.out.println(notInHolidayLi);
        System.out.println("===============================================================================");
        System.out.println(mergeContinous(notInHolidayLi));

    }


    private void caculate(String[] params, String[] authTimes, String[] parkTimes) {
        List<Date> dates = getDateList(params);
        removeRepeat(dates);
        Collections.sort(dates);


        List<TimePair> pairs = new ArrayList<TimePair>();

        for (int i = 0, j = dates.size(); i < j; i++) {
            if ((i + 2) <= j) {

                System.out.println("i: " + i + ", j: " + (i + 1));
                TimePair pair = new TimePair(dates.get(i), dates.get(i + 1));
                pairs.add(pair);
                pair.caculateOverLapWithAuth(getDateList(authTimes));
                pair.caculateOverLapWithStay(getDateList(parkTimes));
                System.out.println(pair);
                System.out.println();
            }
        }


        System.out.println("===============================================================================");
        System.out.println(pairs);
        System.out.println("===============================================================================");
        List<TimePair> chargeTimes = new ArrayList<>();
        for (int i = 0; i < pairs.size(); i++) {
            TimePair pair = pairs.get(i);
            if (pair.needCharge()) {
                chargeTimes.add(pair);
                System.out.println(pair);
            }
        }


        System.out.println("===============================================================================");
        System.out.println("-------------------------------------------------------------------------------");
        System.out.println(chargeTimes);
        System.out.println("-------------------------------------------------------------------------------");
        System.out.println(mergeContinous(chargeTimes));

    }

    public void removeRepeat(List<Date> dates) {

        for (int i = 0; i < (dates.size() - 1); i++) {
            for (int j = i + 1; j < dates.size(); j++) {
                System.out.print("remove i: " + i);
                System.out.print("remove j: " + j);
                if (dates.get(i).getTime() == dates.get(j).getTime()) {
                    dates.remove(j);
                }
            }
        }
    }


    public List<Pair> mergeContinous(List<TimePair> pairs) {

        if (pairs == null || pairs.size() == 0) {
            return new ArrayList<Pair>();
        }

        List<Pair> li = new ArrayList<Pair>();

        if (pairs.size() == 1) {
            Pair p = new Pair(pairs.get(0).getStartTime(), pairs.get(0).getEndTime());
            li.add(p);
            return li;
        }

        Date start = pairs.get(0).getStartTime();
        Date end = pairs.get(0).getEndTime();
        for (int i = 1; i < pairs.size(); i++) {
            TimePair tp = pairs.get(i);
            if (tp.getStartTime().getTime() == end.getTime()) {
                end = tp.getEndTime();
            } else {
                Pair pr = new Pair(start, end);
                li.add(pr);

                start = tp.getStartTime();
                end = tp.getEndTime();
            }
        }

        li.add(new Pair(start, end));

        return li;
    }


    public static boolean isCollectionEmpty(Collection<?> collection) {
        if (collection == null || collection.isEmpty()) {
            return true;
        }
        return false;
    }


    public static Date stringToDate(String strValue, String strFormat) {
        Date date = null;
        try {
            date = new SimpleDateFormat(strFormat).parse(strValue);
        } catch (ParseException e) {
        }
        return date;
    }

    public static String dateToString(Date dateValue, String strFormat) {
        return new SimpleDateFormat(strFormat).format(dateValue);
    }


    public static List<Date> getDateList(String... dateStr) {

        if (dateStr == null || dateStr.length == 0) {
            return new ArrayList<>();
        }

        List<Date> result = new ArrayList<Date>();

        for (String el : dateStr) {
            result.add(stringToDate(el, YYYY_MM_DD_HH_MM_SS));
        }

        return result;
    }

    private static class TimePair {

        private Date startTime;
        private Date endTime;

        private Long startLong;
        private Long endLong;

        private String startString;
        private String endString;

        private int authOverlapCout;
        private int stayOverlapCount;


        private static final Predicate<TimePair> predicateIsCharge = new Predicate<TimePair>() {
            @Override
            public boolean test(TimePair timePair) {
                return timePair.getStayOverlapCount() > timePair.getAuthOverlapCout();
            }
        };

        private static final Predicate<TimePair> predicateNotInHoliday = new Predicate<TimePair>() {
            @Override
            public boolean test(TimePair timePair) {
                int authOverlapCout = timePair.getAuthOverlapCout();
                int stayOverlapCount = timePair.getStayOverlapCount();

                //在该时段有停留，但是该时段不在节假日内
                return stayOverlapCount > 0 && authOverlapCout == 0;
            }
        };

        public TimePair(Long startLong, Long endLong) {
            this(new Date(startLong), new Date(endLong));
        }

        public TimePair(Date startTime, Date endTime) {
            this.startTime = startTime;
            this.endTime = endTime;
            this.startLong = startTime.getTime();
            this.endLong = endTime.getTime();
            this.startString = dateToString(startTime, YYYY_MM_DD_HH_MM_SS);
            this.endString = dateToString(endTime, YYYY_MM_DD_HH_MM_SS);
        }

        public TimePair(String startString, String endString) {
            this.startString = startString;
            this.endString = endString;
            this.startTime = stringToDate(startString, YYYY_MM_DD_HH_MM_SS);
            this.endTime = stringToDate(endString, YYYY_MM_DD_HH_MM_SS);
            this.startLong = this.startTime.getTime();
            this.endLong = this.endTime.getTime();
        }


        public String getStartString() {
            return startString;
        }

        public void setStartString(String startString) {
            this.startString = startString;
        }

        public String getEndString() {
            return endString;
        }

        public void setEndString(String endString) {
            this.endString = endString;
        }

        public int getStayOverlapCount() {
            return stayOverlapCount;
        }

        public void setStayOverlapCount(int stayOverlapCount) {
            this.stayOverlapCount = stayOverlapCount;
        }

        public Date getStartTime() {
            return startTime;
        }

        public void setStartTime(Date startTime) {
            this.startTime = startTime;
        }

        public Date getEndTime() {
            return endTime;
        }

        public void setEndTime(Date endTime) {
            this.endTime = endTime;
        }

        public Long getStartLong() {
            return startLong;
        }

        public void setStartLong(Long startLong) {
            this.startLong = startLong;
        }

        public Long getEndLong() {
            return endLong;
        }

        public void setEndLong(Long endLong) {
            this.endLong = endLong;
        }

        public int getAuthOverlapCout() {
            return authOverlapCout;
        }

        public void setAuthOverlapCout(int authOverlapCout) {
            this.authOverlapCout = authOverlapCout;
        }


        public int caculateOverLapWith(Date startTime, Date endTime) {
            if (this.startLong == null) {
                this.startLong = this.startTime.getTime();
            }

            if (this.endLong == null) {
                this.endLong = this.endTime.getTime();
            }

            int incr = 0;
            if (this.startLong >= startTime.getTime() && this.endLong <= endTime.getTime()) {

                if (this.startLong != this.endLong) {


                    incr += 1;
                }
            }


            return incr;
        }

        public int caculateOverLapWithAuth(Date startTime, Date endTime) {
            int incr = caculateOverLapWith(startTime, endTime);
            if (incr > 0) {
                String startTimeStr = dateToString(startTime, YYYY_MM_DD_HH_MM_SS);
                String endTimeStr = dateToString(endTime, YYYY_MM_DD_HH_MM_SS);
                System.out.println(Parser.parse1("[包期时间]:    ({} ~ {})与时间段({} ~ {})有重叠", this.startString, this.endString, startTimeStr, endTimeStr));
            }
            this.authOverlapCout += incr;

            return this.authOverlapCout;
        }

        public int caculateOverLapWithStay(Date startTime, Date endTime) {
            int incr = caculateOverLapWith(startTime, endTime);
            if (incr > 0) {
                String startTimeStr = dateToString(startTime, YYYY_MM_DD_HH_MM_SS);
                String endTimeStr = dateToString(endTime, YYYY_MM_DD_HH_MM_SS);
                System.out.println(Parser.parse1("[停留时间]:    ({} ~ {})与时间段({} ~ {})有重叠", this.startString, this.endString, startTimeStr, endTimeStr));
            }
            this.stayOverlapCount += incr;
            return this.stayOverlapCount;
        }

        public boolean needCharge() {
            return predicateIsCharge.test(this);
//            return stayOverlapCount > authOverlapCout;
        }

        public boolean notInHoliday() {
            return predicateNotInHoliday.test(this);
        }


        public int caculateOverLapWithAuth(List<Date> dates) {
            int count = this.authOverlapCout;
            if (dates == null) {
                return count;
            }

            final int batch = 2;

            while (dates.size() >= batch) {
                List<Date> li = dates.subList(0, batch);
                count = caculateOverLapWithAuth(li.get(0), li.get(1));
                li.clear();
            }

            return count;
        }

        public int caculateOverLapWithStay(List<Date> dates) {
            int count = this.stayOverlapCount;
            if (dates == null) {
                return count;
            }

            final int batch = 2;

            while (dates.size() >= batch) {
                List<Date> li = dates.subList(0, batch);
                count = caculateOverLapWithStay(li.get(0), li.get(1));
                li.clear();
            }

            return count;
        }


        @Override
        public String toString() {
            if (startString == null) {
                startString = dateToString(startTime, YYYY_MM_DD_HH_MM_SS);
            }

            if (endString == null) {
                endString = dateToString(endTime, YYYY_MM_DD_HH_MM_SS);
            }

            return "(" + startString + " ~ " + endString + ") : auth:" + this.authOverlapCout + " stay:" + this.stayOverlapCount;
        }
    }


    private static class Pair<A, B> {
        public A first;
        public B second;

        public Pair(A first, B second) {
            this.first = first;
            this.second = second;
        }

        @Override
        public String toString() {
            return Parser.parse1("<{}, {}>\n\t",
                    first instanceof Date ? dateToString((Date) first, YYYY_MM_DD_HH_MM_SS) : first,
                    second instanceof Date ? dateToString((Date) second, YYYY_MM_DD_HH_MM_SS) : second);
        }
    }


    public interface Predicate<T> {
        public boolean test(T t);
    }






}
lhever_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【算法】求得重叠区域以及被重叠次数计算
Zsusan7的博客
08-19 916
import numpy as np def get_intervals(intervals): ''' intervals：[[start1,end1],[start2,end2],...,[startn,endn]] return _list：返回重叠区间和重叠次数 ''' not_repeat_list = np.array(intervals) #intervals原为多维列表形式，现转为array，即多维数组形式，为了后续转为一维 not_repe
【你有更好的算法吗？】合并重叠时间段算法
weixin_34259559的博客
03-01 623
今天在博问中看到一个比较常见的问题： 求算法(合并重叠时间段) 在这里先把问题描述一下：   同一天中的一连串不连续时间段,合并其中重叠时间,如: StartTime EndTime 06:10:58 08:15:28 07:38:56 10:34:45 10:55:00 11:34:00 13:09:34 17:45:23 14:23:12 15:24:14 16:14:25...
js时间段计算，多组，多组间重叠
weixin_33699914的博客
02-24 892
Date.prototype.format = function (format) { var args = { "M+": this.getMonth() + 1, "d+": this.getDate(), "h+": this.getHours(), "m+": this.getMinutes(), "s+": ...
时间段重合计算问题
wyj851757126的博客
03-10 1530
时间段重合计算问题时间段重合计算时间段计算年月日数量 在工作中，碰到了一个实际案例需要计算两个时间段的重合问题。具体问题是根据租赁时间和免租期来计算租金，而且租金计价方式不确定（可能按年，按月，按天计算）。 时间段重合计算 在本次实际案例中，实际上为去除掉两个时间段的重复部分，暂时没想到什么好的办法，就采用了罗列各种情况分别处理的方法： public function date_count($sdate,$edate,$fee_sdate,$fee_edate){ // 判断合同是否设置免租期
膜拜 (mo)——求n个区间重叠的最大次数
soul_mingling的博客
07-29 1068
膜拜 (mo) 题目描述： 小鱼有 n 名优秀的粉丝。 粉丝们得知小鱼将会在一条直线上出现，打算去膜他。为了方便，粉丝们在这条直线上建立数轴。 第 i 名粉丝有一个侦查区间[li,ri] 。如果小鱼在 j(li≤j≤ri) 处出现，这名粉丝将立刻发现并膜他。 小鱼希望膜他的人越多越好，但是他不能分身，因此只能选择一个位置出现。 小鱼想知道自己最多能被多少个人膜。 输入： 第一行一个整数n —— 粉丝的个数。 接下来 n 行，每行两个整数 li,ri ，分别表示第 i 名粉丝的侦查区间的两个端点。两个数之间用
PHP编程计算两个时间段是否有交集的实现方法(不算边界重叠)
12-20
* PHP计算两个时间段是否有交集（边界重叠不算） * * @param string $beginTime1 开始时间1 * @param string $endTime1 结束时间1 * @param string $beginTime2 开始时间2 * @param string $endTime2 结束时间...
比较时间段一与时间段二是否有交集的php函数
12-17
复制代码 代码如下: /* *比较时间段一与时间段二是否有交集 */ function isMixTime($begintime1,$endtime1,$begintime2,$endtime2) { $status = $begintime2 – $begintime1; if($status>0){ $status2 = $begintime2...
C# 判断时间段是否相交的实现方法
08-29
C# 判断时间段是否相交的实现方法 C# 判断时间段是否相交的实现方法是判断两个时间段是否有交集的实现方法。该方法可以应用于各种需要判断时间段是否相交的场景，例如判断某个事件是否发生在某个时间段内、判断某个...
计算两时间段的重合天/小时/分钟/秒数的工具类
06-09
有时候我们在计算时间时，有让获取两时间段重合的天数这种需求，小编也是遇到了这样的需求，就封装了一个工具类，希望能帮助到大家。 例如求（2022-05-02 00:00:00 至 2022-05-12 23:59:59） 时间段和（2022-05-04 ...
计算时间重叠次数的优化
一只Coding猪
02-23 766
有这样一种场景，在一个直播间内，在一个较长的时间内，有人加入群聊，也有人离开，在直播间的整个生命周期内，会产生很多的访问记录，这些记录都有进入时间和离开时间，业务场景是需要计算在直播间存续期间，在线人数最多的时间段，以及人数。 由于项目中直播间实际会控制最大人数在6人，而直播间存续时长一般也不会超过24小时，所以开始时偷了点懒，采用暴力方式处理，思路如下： 遍历所有的时间段，将时间段按照起始/结束时间分割，比如(9:15-9:20)(9:18-9:30)，分割后变成了(9:15-9:18),(9:18-9:
时间段最大重叠数问题
emparadise329的博客
12-01 1336
一个三维数组{起止时间，结束时间，编号}，多条这样的数据，找出它们之间时间段最大的重叠数 求个算法; 我的算法如下： 1、第一次循环数组，取得数组中两两之间的时间重叠段数据格式和开始三维数组一样，编号则会是'编号1编号2'（编号1的数据和编号2数据之间有时间重叠段）每次循环可以剔除重复数据； 2、第二次循环就是对第一步数组再次循环，然后依次循环下去，判断编号的长度，得出最大重叠数。 但是...
Java日期时间API系列37-----时间段是否有重叠（交集）的计算方法
m0_58477403的博客
07-01 3742
Java日期时间API系列37-----时间段是否有重叠（交集）的计算方法 在日程安排或预约排期等场景中，经常会需要对比2个或多个时间段是重叠的功能，我经过整理和验证，发现了下面的算法比较好一些，分享一下。 1.只有2个时间段的情况 例如：存在区间A、区间B，重叠的情况很多，但不重叠的情况只有2种，A在B前或者B在A前。如图： 得出，不重叠算法：A.end< B.start || A.start > B.end 那么重叠的算法对上面取反就可以了：! (A.end< B.start ||
区间重合算法：多个时间段重合判断
失眠仔的博客
03-22 2722
Talk is cheap, show you the code <?php /** * 时间段重合判断 * @param array $data 日期数组 * @param string $fieldStart 开始日期字段名 * @param string $fieldEnd 结束日期字段名 * @return bool true为重合，false为不重合 */ funct...
SQL-重叠时间判断及重叠时间计算
qq_21377723的博客
03-18 1286
SQL时间片重叠计算
区间重合算法：多个时间段重合判断：python代码实现
stevewong的专栏
11-03 3419
背景 如何判断多个时间区间是否重叠 参考 网上搜到很多都是这个php版本，基于这个稍做了改动，写了python版本。 data = { "data_list": [ { "start_time": 10, "end_time": 20, }, { "start_time": 2, "end_time": 11, }, {
检查两个时间段是否有时间重叠(允许重叠一部分时间不算重叠)
opabinia的博客
08-08 1003
允许重叠的时间, 负数这里没校验，自己用, 正常需要加一个。新增一个参数接收允许重叠的时间(这个重叠不算重叠),总有一些比较特殊的需求场景，做个备忘。设置0和等于原算法保持一致。
java 计算多个时间段中重复的天数
魑魅魍魉
11-04 1045
工作中遇到这个需求，自己写了一下，测试了几种情况都没有问题。 这里的时间段我是用的map存储的，map里面是一个key为st的开始时间，一个key为et的结束时间。 方法中计算两个时间段相差天数的时候后面加了1，意思就是比如有两个时间段，st为2021-09-09 et也是2021-09-09，那么使用hutool中的DateUtil.betweenDay方法的结果是0。我的需求是这种也算一天，所以加1了，没有需要的话可以去掉。 /** * 计算多个时间段中的重复时间
重叠时间段问题优化算法详解
wzy0623的专栏
08-26 6553
目录 一、问题提出 1. 描述 2. 分析 二、优化重叠查询 1. 自关联 2. 游标+内存临时表 三、改进取得活跃时段的算法 1. 最小范围算法（表连接） 2. 正负计数器算法（一次扫描） 四、MySQL 8的单条查询解决方案 一、问题提出 1. 描述 这是一个实际业务需求中的问题。某一直播业务表中记录了如下格式的用户进出直播间日志数据： +----...
python 计算时间重叠_Python基于时间信息（即时、间隔）计算项目之间的相似性...
weixin_39554290的博客
03-01 300
我想根据时间信息计算项目(0,1,2,3….)之间的相似性。时间信息可以是时间即时(startdate)、时间间隔(startdate、enddate)或null(NaT)；请参阅下面的dataframe(df_for)的示例。在{instant，instant}：如果等于sim=1，则sim=0{instant，null}或相反，sim=0{instant，interval}：如果instant...
C# 多个时间段 取出重叠部分的时间
最新发布
06-11
假设有多个时间段，每个时间段由起始时间和结束时间组成，可以使用以下代码取出重叠部分的时间段： ```csharp // 时间段1 DateTime start1 = new DateTime(2022, 1, 1, 8, 0, 0); DateTime end1 = new DateTime...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值