每天分时间段收费订单算法简单实现

已于 2023-03-03 16:35:28 修改
阅读量204 收藏 1
点赞数 1
分类专栏： 工具 文章标签： java
于 2023-03-01 13:19:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xionglangs/article/details/129278596
版权

1、创建订单信息；
2、补充收费标准信息，折扣信息，分润信息（防止订单时间内，出现价格变动）；
3、根据订单创建时间生成一个可逆的有识别度的序列号，防止串改订单信息（可以加一个不可逆算法，如MD5加密，把参数信息都加进去）；

package com.mingshuo.chongdianzhuang.util;

import com.ruoyi.common.utils.StringUtils;

import java.util.Random;

/**
 * Description：
 * <p>
 * 订单编号
 * </p>
 *
 * @Author： leo.xiong
 * @CreateDate： 2023/2/20 16:46
 * @Email： leo.xiong@suyun360.com
 * @Since：
 */
public class OrderUtils {
    /**
     * 初始时间 2023-01-01 00:00:00
     * 4 3830 0820 0291 5360
     */
    private static final Long FIRST_DATA_TIME = 1672502400000L;
    /**
     * 最大时间偏移量11位 99999999999
     * 不足11为补充一个随机数填充11位
     */
    private static final int MAX_TIME_PEEL_SIZE = 11;
    /**
     * 最大时间偏移量有效为 1，第一位必然有效 0表示有效位为2，9表示有效位为11 （0->2 ... 9->11）
     */
    private static final int MAX_VALID_TIME = 2;
    /**
     * 设备ID最大为7位
     */
    private static final int MAX_DEVICE_SIZE = 7;
    /**
     * 手机号长度取后2位
     */
    private static final int MAX_PHONE_SIZE = 2;

    /**
     * 1、当前时间 - 初始时间的毫秒偏移量（(1672502400000 + 9999999999)/365/24/3600/1000 ≈ 56年，不足11位，后面补充随机数，最后一位表示有效位数（0-10），0表示1为有效 10表示11位有效数字）
     * 2、设备ID （9999999 暂定1千万级，不足7位，前面补0）
     * 3、最后两位使用用户手机最后两位
     * 总共 12+7+2=21位
     *
     * @param systemTime 缩减位数，增加读取成本
     * @param deviceId   设备ID，设备ID不能超过7位数
     * @param phone      手机号
     * @return
     */
    public static String createOrderById(Long systemTime, Long deviceId, String phone) {
        return createOrderBySn(systemTime, StringUtils.leftPad(String.valueOf(deviceId), MAX_DEVICE_SIZE, '0'), phone);
    }

    public static String createOrderBySn(Long systemTime, String deviceSn, String phone) {
        StringBuffer snSb = new StringBuffer();
        snSb.append(systemTime - FIRST_DATA_TIME);
        int len = snSb.length();
        String maxRandomValue = StringUtils.rightPad("", MAX_TIME_PEEL_SIZE - len, '9');
        snSb.append(Double.valueOf(Math.random() * Long.valueOf(maxRandomValue)).longValue());
        snSb.append(len - MAX_VALID_TIME);
        snSb.append(deviceSn);
        snSb.append(phone.substring(phone.length() - MAX_PHONE_SIZE));
        return snSb.toString();
    }

    /**
     * 回显数据可以用于校验订单信息是否经过了人工修改（时间/设备/手机不匹配）
     *
     * @param sn
     * @return
     */
    public static String printOrder(String sn) {
        String timeLen = sn.substring(MAX_TIME_PEEL_SIZE, 1 + MAX_TIME_PEEL_SIZE);
        StringBuffer orderSb = new StringBuffer();
        Long time = Long.valueOf(sn.substring(0, Integer.valueOf(timeLen) + MAX_VALID_TIME)) + FIRST_DATA_TIME;
        orderSb.append(time);
        orderSb.append("|");
        Long deviceId = Long.valueOf(sn.substring(MAX_TIME_PEEL_SIZE + 1, sn.length() - MAX_PHONE_SIZE));
        orderSb.append(deviceId);
        orderSb.append("|");
        String phoneLast = sn.substring(sn.length() - 2);
        orderSb.append(phoneLast);
        return orderSb.toString();
    }

    public static void main(String[] args) {
        Long systemTime = System.currentTimeMillis();
        System.out.println(systemTime + "|" + 1536 + "|" + 31);
        String sn = OrderUtils.createOrderById(systemTime, 1536L, "15989160331");
        System.out.println(OrderUtils.printOrder(sn));
    }
}

package com.mingshuo.chongdianzhuang.util;

import com.google.common.collect.Lists;
import com.mingshuo.chongdianzhuang.manage.domain.BizDeviceInstanceFee;
import com.mingshuo.chongdianzhuang.manage.domain.BizOrder;
import com.mingshuo.chongdianzhuang.manage.domain.BizOrderFeeDetail;
import com.ruoyi.framework.enums.EntityStatus;
import org.springframework.util.CollectionUtils;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

/**
 * Description：
 * <p>
 * 按时间分段收费算费
 * </p>
 *
 * @Author： leo.xiong
 * @CreateDate： 2023/2/21 9:30
 * @Email： leo.xiong@suyun360.com
 * @Since：
 */
public class TimePhasedChargesUtils {
    /**
     * 去除毫秒影响
     */
    private static final long MILLI_SECONDS = 1000;

    /**
     * 计算订单金额信息
     *
     * @param bizOrder                 订单ID/订单开始时间/订单结束时间/订单结束人
     * @param bizDeviceInstanceFeeList 分段收费标准 （订单时间段设备收费单价/服务单价/折扣信息）
     * @param shareBenefitRate         平台分润比例
     * @return (收费时间段 / 收费开始结束时间 / 设备费用 / 服务费用 / 打折费用 / 平台分润金额)
     */
    public static final List<BizOrderFeeDetail> orderFeeCalculation(BizOrder bizOrder, List<BizDeviceInstanceFee> bizDeviceInstanceFeeList, BigDecimal shareBenefitRate) {
        Date beginTime = bizOrder.getOrderBeginTime();
        Date endTime = bizOrder.getOrderEndTime();
        //如果开始时间>=结束时间，设置结束时间为开始时间+1s
        if (beginTime.getTime() / MILLI_SECONDS >= endTime.getTime() / MILLI_SECONDS) {
            endTime = new Date(beginTime.getTime() + MILLI_SECONDS);
        }
        List<Date[]> datesList = getBetweenDataList(beginTime, endTime);
        List<BizOrderFeeDetail> bizOrderFeeDetailList = Lists.newArrayList();
        supplementHourMinute(bizDeviceInstanceFeeList);
        for (Date[] dates : datesList) {
            Date beginDate = dates[0];
            Date endDate = dates[1];
            Integer[] times = getTimeIntByType(beginDate);
            recursionDetail(bizDeviceInstanceFeeList, bizOrderFeeDetailList, bizOrder, times, beginDate, endDate);
        }
        return organizeDataList(bizOrderFeeDetailList, shareBenefitRate);
    }

    /**
     * 整理数据信息
     *
     * @param bizOrderFeeDetailList
     * @return
     */
    private static List<BizOrderFeeDetail> organizeDataList(List<BizOrderFeeDetail> bizOrderFeeDetailList, BigDecimal shareBenefitRate) {
        if (CollectionUtils.isEmpty(bizOrderFeeDetailList)) {
            return Lists.newArrayList();
        }
        if (bizOrderFeeDetailList.size() <= 1) {
            calculateAmount(shareBenefitRate, bizOrderFeeDetailList.get(0));
            return bizOrderFeeDetailList;
        }
        List<BizOrderFeeDetail> bizOrderFeeDetails = Lists.newArrayListWithExpectedSize(bizOrderFeeDetailList.size());
        bizOrderFeeDetailList = bizOrderFeeDetailList.stream()
                .sorted(Comparator.comparing(BizOrderFeeDetail::getBeginTime))
                .collect(Collectors.toList());
        for (BizOrderFeeDetail bizOrderFeeDetail : bizOrderFeeDetailList) {
            if (CollectionUtils.isEmpty(bizOrderFeeDetails)) {
                bizOrderFeeDetails.add(bizOrderFeeDetail);
                continue;
            }
            //最后的时间-1秒+收费类型 == 上一条记录的初始时间+类型，则合并两条数据信息
            Long currentKey = (bizOrderFeeDetail.getEndTime().getTime() - MILLI_SECONDS) + bizOrderFeeDetail.getFeeId();
            BizOrderFeeDetail lastBizOrderFeeDetail = bizOrderFeeDetails.get(bizOrderFeeDetails.size() - 1);
            Long lastKey = lastBizOrderFeeDetail.getBeginTime().getTime() + lastBizOrderFeeDetail.getFeeId();
            if (!currentKey.equals(lastKey)) {
                bizOrderFeeDetails.add(bizOrderFeeDetail);
                continue;
            }
            lastBizOrderFeeDetail.setDuration(lastBizOrderFeeDetail.getDuration() + bizOrderFeeDetail.getDuration());
        }
        return bizOrderFeeDetails.parallelStream()
                .map(bizOrderFeeDetail -> calculateAmount(shareBenefitRate, bizOrderFeeDetail))
                .collect(Collectors.toList());
    }

    /**
     * 计费数据
     *
     * @param bizDeviceInstanceFeeList
     * @param bizOrderFeeDetailList
     * @param bizOrder
     * @param times
     * @param beginDate
     * @param endDate
     */
    private static void recursionDetail(List<BizDeviceInstanceFee> bizDeviceInstanceFeeList, List<BizOrderFeeDetail> bizOrderFeeDetailList, BizOrder bizOrder, Integer[] times, Date beginDate, Date endDate) {
        Long beginTime = beginDate.getTime(), endTime = endDate.getTime();
        for (BizDeviceInstanceFee bizDeviceInstanceFee : bizDeviceInstanceFeeList) {
            Long bizStartTime = getDate(times, bizDeviceInstanceFee.getStartHour(), bizDeviceInstanceFee.getStartMinute(), 0);
            Long bizEndTime = getDate(times, bizDeviceInstanceFee.getEndHour(), bizDeviceInstanceFee.getEndMinute(), -1);
            //如果收费结束时间 < 消费开始时间，则收费段不匹配
            if (bizEndTime < beginTime) {
                continue;
            }
            //如果收费开始时间 > 消费结束时间，则收费段不匹配
            if (bizStartTime > endTime) {
                continue;
            }
            //如果收费开始时间 <= 消费开始时间 && 收费结束时间 >= 消费结束时间，则完全匹配，添加消费记录，跳出循环
            if (bizStartTime <= beginTime && bizEndTime >= endTime) {
                bizOrderFeeDetailList.add(buildBizOrderFeeDetail(bizOrder, bizDeviceInstanceFee, beginDate, endDate));
                break;
            }
            //如果收费结束时间 < 消费结束时间，需要拆分时间段 消费开始时间 - 收费结束时间|收费结束时间+1s作为消费开始时间-消费结束时间
            if (bizEndTime < endTime) {
                bizOrderFeeDetailList.add(buildBizOrderFeeDetail(bizOrder, bizDeviceInstanceFee, beginDate, new Date(bizEndTime)));
                //存在一份 收费结束时间+1s - 消费结束时间 没有计费，需要递归调用
                recursionDetail(bizDeviceInstanceFeeList, bizOrderFeeDetailList, bizOrder, times, new Date(bizEndTime + 1000), endDate);
                break;
            }
            //如果消费开始时间 < 收费开始时间，需要拆分时间段 消费开始时间 - 收费开始时间-1s|收费开始时间作为消费开始时间-消费结束时间
            if (beginTime < bizStartTime) {
                //存在一份 消费开始时间 - 收费开始时间-1s 没有计费，需要递归调用
                recursionDetail(bizDeviceInstanceFeeList, bizOrderFeeDetailList, bizOrder, times, beginDate, new Date(bizStartTime - 1000));
                bizOrderFeeDetailList.add(buildBizOrderFeeDetail(bizOrder, bizDeviceInstanceFee, new Date(bizStartTime), endDate));
                break;
            }
        }
    }

    /**
     * 按照时间切割
     * 暂不考虑跨天，存在跨天定义多个时间片段
     *
     * @param bizDeviceInstanceFeeList
     */
    private static void supplementHourMinute(List<BizDeviceInstanceFee> bizDeviceInstanceFeeList) {
        for (BizDeviceInstanceFee bizDeviceInstanceFee : bizDeviceInstanceFeeList) {
            String[] startHourMinute = hourMinute(bizDeviceInstanceFee.getStartTime());
            String[] endHourMinute = hourMinute(bizDeviceInstanceFee.getEndTime());
            bizDeviceInstanceFee.setStartHour(Integer.valueOf(startHourMinute[0]));
            bizDeviceInstanceFee.setStartMinute(Integer.valueOf(startHourMinute[1]));
            bizDeviceInstanceFee.setEndHour(Integer.valueOf(endHourMinute[0]));
            bizDeviceInstanceFee.setEndMinute(Integer.valueOf(endHourMinute[1]));
            //跨天
            if (bizDeviceInstanceFee.getStartHour() > bizDeviceInstanceFee.getEndHour()) {
                bizDeviceInstanceFee.setAcrossDay(true);
            }
        }
    }

    /**
     * 按分钟收费，不足一分钟按一分钟收费
     *
     * @param bizOrder
     * @param bizDeviceInstanceFee
     * @param beginTime
     * @param endTime
     * @return
     */
    private static BizOrderFeeDetail buildBizOrderFeeDetail(BizOrder bizOrder, BizDeviceInstanceFee bizDeviceInstanceFee, Date beginTime, Date endTime) {
        BizOrderFeeDetail bizOrderFeeDetail = new BizOrderFeeDetail();
        bizOrderFeeDetail.setOrderId(bizOrder.getId());
        bizOrderFeeDetail.setFeeId(bizDeviceInstanceFee.getId());
        bizOrderFeeDetail.setCreateTime(bizOrder.getOrderEndTime());
        bizOrderFeeDetail.setCreateBy(bizOrder.getUserId().toString());
        bizOrderFeeDetail.setUpdateTime(bizOrder.getOrderEndTime());
        bizOrderFeeDetail.setUpdateBy(bizOrder.getUserId().toString());
        bizOrderFeeDetail.setDelFlag(EntityStatus.NOMAL.getCode());
        //去毫秒处理
        bizOrderFeeDetail.setBeginTime(new Date(beginTime.getTime() / 1000 * 1000));
        bizOrderFeeDetail.setEndTime(new Date(endTime.getTime() / 1000 * 1000));
        BigDecimal duration = new BigDecimal(bizOrderFeeDetail.getEndTime().getTime() - bizOrderFeeDetail.getBeginTime().getTime())
                .divide(new BigDecimal("1000"), 6, RoundingMode.HALF_UP)
                .divide(new BigDecimal("60"), 0, RoundingMode.HALF_UP);
        bizOrderFeeDetail.setDuration(duration.longValue());
        bizOrderFeeDetail.setBizDeviceInstanceFee(bizDeviceInstanceFee);
        return bizOrderFeeDetail;
    }

    /**
     * 计算金额
     * 1、计算电费；
     * 2、计算服务费；
     * 3、存在打折，计算打折费用，服务费分别减去打折的电费和服务费，只对服务费打折（电费是基本费用）
     * 4、计算分润的费用，只分润服务费用（电费为基本费用，打折后的费用算分润费用）
     * 分润和打折费用是否只对服务费做处理，电费是基础费用，并非实际的收益费用，这里需要考虑下
     * 不足一分钟按1分钟计费
     *
     * @param shareBenefitRate  分润信息
     * @param bizOrderFeeDetail 收费详情
     */
    private static BizOrderFeeDetail calculateAmount(BigDecimal shareBenefitRate, BizOrderFeeDetail bizOrderFeeDetail) {
        BizDeviceInstanceFee bizDeviceInstanceFee = bizOrderFeeDetail.getBizDeviceInstanceFee();
        BigDecimal duration = new BigDecimal(bizOrderFeeDetail.getDuration());
        //如果结束时间-开始时间小于1分钟，则按一分钟计费
        if (duration.longValue() < 1) {
            duration = new BigDecimal("1");
        }
        if (bizDeviceInstanceFee.getEnergyFee() != null) {
            BigDecimal energyFee = new BigDecimal(bizDeviceInstanceFee.getEnergyFee());
            bizOrderFeeDetail.setElectricityFee(energyFee.multiply(duration));
        } else {
            bizOrderFeeDetail.setElectricityFee(new BigDecimal("0"));
        }
        if (bizDeviceInstanceFee.getServiceFee() != null) {
            BigDecimal serviceFee = new BigDecimal(bizDeviceInstanceFee.getServiceFee());
            bizOrderFeeDetail.setServiceFee(serviceFee.multiply(duration));
        } else {
            bizOrderFeeDetail.setServiceFee(new BigDecimal("0"));
        }
        if (bizDeviceInstanceFee.getDiscountRate() != null) {
            //需要抹零计费，存储的是整数分
            BigDecimal discountRate = new BigDecimal(bizDeviceInstanceFee.getDiscountRate());
            BigDecimal serviceFeeDiscount = bizOrderFeeDetail.getServiceFee().multiply(discountRate).divide(new BigDecimal("10"), 0, RoundingMode.HALF_UP);
            bizOrderFeeDetail.setDiscountFee(serviceFeeDiscount);
            bizOrderFeeDetail.setServiceFee(bizOrderFeeDetail.getServiceFee().subtract(serviceFeeDiscount));
        }
        if (shareBenefitRate != null) {
            //需要抹零计费，存储的是整数分
            BigDecimal serviceFeeShareBenefitRate = bizOrderFeeDetail.getServiceFee().multiply(shareBenefitRate).setScale(0, RoundingMode.HALF_UP);
            bizOrderFeeDetail.setShareBenefitFee(serviceFeeShareBenefitRate);
            bizOrderFeeDetail.setServiceFee(bizOrderFeeDetail.getServiceFee().subtract(serviceFeeShareBenefitRate));
        }
        return bizOrderFeeDetail;
    }

    private static String[] hourMinute(String startTime) {
        String[] hourMinute = null;
        if (startTime.contains("：")) {
            hourMinute = startTime.split("：");
        } else if (startTime.contains(":")) {
            hourMinute = startTime.split(":");
        } else if (startTime.contains(": ")) {
            hourMinute = startTime.split(": ");
        }
        return hourMinute;
    }

    private static Integer[] getTimeIntByType(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        Integer[] times = new Integer[6];
        times[0] = calendar.get(Calendar.YEAR);
        times[1] = calendar.get(Calendar.MONTH);
        times[2] = calendar.get(Calendar.DAY_OF_MONTH);
        times[3] = calendar.get(Calendar.HOUR);
        times[4] = calendar.get(Calendar.MINUTE);
        times[5] = calendar.get(Calendar.MINUTE);
        return times;
    }

    /**
     * 0：00-3：00 -> 00：00：00-> 2：59：59
     * 1：15-4:15 -> 01：15：00-> 04:14:59
     * 开始时间包括，结束时间不包括，减一秒
     *
     * @param times
     * @param hour
     * @param minute
     * @param second
     * @return
     */
    private static Long getDate(Integer[] times, int hour, int minute, int second) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(times[0], times[1], times[2], hour, minute, 0);
        Date date = calendar.getTime();
        return date.getTime() + second * 1000;
    }

    private static List<Date[]> getBetweenDataList(Date beginTime, Date endTime) {
        List<Date[]> datesList = Lists.newArrayList();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date newDate = null;
        try {
            //开始时间的当天初始时间
            newDate = simpleDateFormat.parse(simpleDateFormat.format(beginTime));
        } catch (ParseException e) {
            e.printStackTrace();
        }
        while (true) {
            Date newEndDate = new Date(newDate.getTime() + 24 * 3600 * 1000 - 1);
            if (newEndDate.after(endTime)) {
                datesList.add(new Date[]{newDate, endTime});
                break;
            } else {
                datesList.add(new Date[]{beginTime, newEndDate});
                newDate = new Date(newEndDate.getTime() + 1);
                beginTime = newDate;
            }
        }
        return datesList;
    }
}

收费信息
在这里插入图片描述

计费详情
在这里插入图片描述

编程爱好者熊浪
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java出租车分时段费用的_JAVA 技术方向支线任务-出租车计费训练任务
weixin_34125336的博客
02-25 2914
出租车计费训练任务任务目标： 完成出租车计费系统本次任务一起来解决出租车计费问题。某市出租车计费标准如下图所示， 请根据此标准完成一个出租车计费模拟功能，能够计算总费用和列出产生费用 项目详细情况说明，帮助出租车师傅和乘客了解计费标准。结合上述表格，可以得出：总车费=里程费用 低速行驶费(或者等候费) 预约叫车服务费 空驶费 夜间收费 燃油附加费。需要收集的数据有：里程数、 低速行驶时长(早晚高峰...
java时间段收费_Java实现免费时段计算
weixin_36127981的博客
02-16 1448
public static longgetSpanHour(String string_time_in, String string_time_out, String string_free_start,String string_free_end) {try{//包含的完整的免费时段次数int span_times = 0;//跨天停车标识符boolean dayFlag = false;Str...
二分查找算法和索引查找算法的实现
09-17
Visual studio 2019 数据结构与算法 内排序实验代码.zip (1) 二分查找算法的实现 (2) 索引查找算法的实现
差分进化算法Python实现.zip
03-30
差分进化算法 Python 实现。除此之外，还有这些算法的集合：差分进化算法、遗传算法、粒子群算法、模拟退火算法、蚁群算法、免疫优化算法、鱼群算法
根号n段归并排序算法时间复杂度分析过程
10-26
根号n段归并排序算法时间复杂度分析过程： 1.合并 根号n向下取整 段子数组使用的是自底向上两两归并的策略 2.根号n段归并排序算法时间复杂度的数学推导
差分进化算法_matlab实现.zip
10-12
内含差分进化算法的五种变异策略
Vmware虚拟化概念原理
热门推荐
曹世宏的博客
05-18 5万+
虚拟化介绍 什么是虚拟化： 虚拟化是一种资源管理技术, 是将计算机的各种物理资源, 如服务器、网络、内存及存储等，予以抽象、转换后呈现出来，打破物理设备结构间的不可切割的障碍，使用户可以比原本的架构更好的方式来应用这些资源。这些资源的虚拟部分是不受现有资源的架构方式、地域或物理设备所限制。 虚拟化创建了一层隔离层，把硬件和上层应用分离开来，允许在一个硬件资源上运行多个逻辑应用。 虚拟化...
计算停车收费金额（JSP+JavaBean/Servlet）
weixin_43394840的博客
05-05 3211
某停车场车辆停放服务 收费标准 车辆l类型 收费方式 收费标准 备注 小型 元/车.次 1小时内停放时间 超过免费时间2小时内 超过两小时后每小时 不足一小时按一小时计算 免费 3 1 1、24小时内，车辆连续停放跨两个收费时段的，车辆停放服务 费可累计收取，最高收费不得超过10元;车辆连续停放24小时以上 的，车辆停放服务费按实际停放时间计算。 2、连续停放跨两...
尖峰平谷1天内时间段选择实现简述（vue+element纯前端）
qq_40950174的博客
02-02 1115
尖峰平谷时间选择，组外不重合，组内不连接不重合
java中计算基本的时间段
wheio8619的专栏
01-03 1840
学习在java中计算基本的时间段 概述 如果你知道怎样在java中使用日期，那么使用时间和它才不多一样简单。这篇文章告诉你怎样把他们的差别联系起来。Robert Nielsen还告诉你怎样使用java来计算抵达航班和制造过程的时间。 作者：Robert Nielsen 翻译：Coci
从上海分时电价机制调整看转供电用户电能计费
最新发布
2301_80433561的博客
12-01 53
由于分时电价机制调整后，季节模式(夏季、冬季、其它月份等)、时间段(每一天的尖峰平谷对应时间段设置)、时段（尖、峰、平、谷、深谷）、费率(上下浮比例不同)均变得比较复杂，因此计费仪表也须进行相应的调整，安科瑞单三相计费仪表可设置尖、峰、平、谷、深谷等10多个费率时段设置和季节模式，满足不通地区分时电价调整要求。随着电改进一步深化，分时电价机制的调整也会越来越频繁。从图1可以看到，电价不仅仅有尖峰平谷四个时段，而且不同的月份时段设置不一样，每个时段电价浮动比例也不一样，这给不少企业的电费统计带来很大的难度。
滴滴到底是怎么计费的？滴滴计价系统架构首次揭秘
emprere的博客
12-05 4763
桔妹导读：计价是出行业务中非常重要的一部分。在滴滴，不同的业务有不同的计价方式，比如网约车不仅有根据里程、时长、时段等进行的分时计价，在拼车、特惠快车等场景还支持一口价，青桔则主要基于起...
作为智能电表之一的复费率电表该如何看度数
mtheliang123的博客
05-25 1269
在家庭电路中，电能表是用来测量电路消耗电能的仪表，也可以说是用来计量用电设备消耗电能的仪表。复费率电表有效的实现分段计费、分时计费，优化用电效率，采用尖、峰、平、谷不同电价分开计费。 老式电表逐渐被智能电表取代后，人们用电也发生了微妙的变化，现在就有用户反映看了几十年的电表了，换成新的反而不会看了，那么作为智能电表之一的复费率电表该如何看度数呢？ 　　首先我们要知道电表里的数字和汉字都会变换一次，以至于让他们误以为是电表有问题。那么这些汉字究竟代表什么含义呢？ 　　首先“尖”、“峰”、“平”、“谷”分别代表
球场分时段计费算法
u013685199的博客
08-20 1372
球场分时段计费算法    1.输入数据   开始结束时间 2.变量（时间段，单价，初始价，封顶价） 3.思路 ：（1）.传入开始结束时间，提取必要的对比信息（开始结束小时，时间戳，经过时长）。（2.）根据时间创建1-2的数组。（2.循环时间数组，调用不同时间段的计价方法） 不废话，直接贴贴代码          public $stime = "2018-08-04 23:41:00"...
Java实现免费时段计算
banzanhun5408的博客
05-07 313
public static long getSpanHour(String string_time_in, String string_time_out, String string_free_start, String string_free_end) { try { // 包含的完整的免费时段次数 ...
Ｃ#　时段计费算法
12-28 3043
留点什么？希望别人有用…… 一天分成多个时间段，各个时段不同的费用，以前在小软件上有做个类似的，但现在发觉之前的方法还是有点小问题了， 而今无聊之余，重新整理思绪，算是做了些优化吧 源码：https://download.csdn.net/download/wysdong/10883293 （源码加上去，就不能删！~，所有源码的类CalcM，还是用文章后面的吧）   using Syst...
写一个判断两个时间段交叉的算法
06-07
判断两个时间段是否交叉可以分为以下两种情况： 1. 第一个时间段在第二个时间段之前 2. 第二个时间段在第一个时间段之前 如果以上两种情况都不满足，则两个时间段交叉。 具体的算法实现如下： 假设第一个时间段的起始时间为 start1，结束时间为 end1，第二个时间段的起始时间为 start2，结束时间为 end2。 1. 判断第一个时间段是否在第二个时间段之前： 如果 end1 <= start2，则两个时间段不交叉。 2. 判断第二个时间段是否在第一个时间段之前： 如果 end2 <= start1，则两个时间段不交叉。 3. 如果以上两种情况都不满足，则两个时间段交叉。 下面是一个 Python 实现的例子： ``` def is_overlap(start1, end1, start2, end2): if end1 <= start2 or end2 <= start1: return False else: return True ``` 其中，start1、end1、start2、end2 分别表示两个时间段的起始时间和结束时间。返回值为 True 表示两个时间段交叉，返回值为 False 表示两个时间段不交叉。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值