Ｃ#　时段计费算法

最新推荐文章于 2023-11-02 23:30:31 发布
最新推荐文章于 2023-11-02 23:30:31 发布
阅读量3k 收藏 8
点赞数
文章标签： 时段计费 停车计费 时段消费
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wysdong/article/details/85321864
版权

留点什么？希望别人有用……
一天分成多个时间段，各个时段不同的费用，以前在小软件上有做个类似的，但现在发觉之前的方法还是有点小问题了，
而今无聊之余，重新整理思绪，算是做了些优化吧

源码：https://download.csdn.net/download/wysdong/10883293 （源码加上去，就不能删！~，所有源码的类CalcM，还是用文章后面的吧）

 

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CLib
{
    public class CalcM
    {

  public CalcM()
        {

        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="_FreeMinute">免费停车 分钟</param>
        /// <param name="_iMinTime">最低消费时间长</param>
        /// <param name="_oneDayMaxCost">一天最高的费用</param>
        /// <param name="_timelist">时间段&每小时费用  _timelist.Add("00:00&08:00&4");//起始时间&结束时间&费率</param>
        /// <param name="_idayType">一整天计费方式：0=汇总各个时段费用（时段长*单价）；1=用“idayMoney一整天的费用”来计算;2=重新计算，按firstHour内多少钱，后面各个小时多少钱</param>
        /// <param name="_idayMoney">一整天的费用</param>
        /// <param name="_iFirstType">0=前N分钟不计费，1=最低扣费时间长</param>
        /// <param name="_firstHour">超过免费时间后，firstHour小时内FirstCash元</param>
        /// <param name="_firstCash">超过免费时间后，firstHour小时内FirstCash元</param>
        /// <param name="_iAfter24H">第二天（过晚上24点后），计费方式：0＝重新计费，1=汇总各时段费用</param>
        public CalcM(int _FreeMinute, int _iMinTime, decimal _oneDayMaxCost, System.Collections.ArrayList _timelist,
            int _idayType, decimal _idayMoney, int _iFirstType, int _firstHour, int _firstCash, int _iAfter24H)
        {
            this.FreeMinute = _FreeMinute;
            this.iMinTime = _iMinTime;
            this.OneDayMaxCost = _oneDayMaxCost;
            this.timelist = _timelist;
            this.idayType = _idayType;
            this.idayMoney = _idayMoney;
            this.iFirstType = _iFirstType;
            this.firstHour = _firstHour;
            this.firstCash = _firstCash;
            this.iAfter24H = _iAfter24H;
        }


        #region 计费参数

        /// <summary>
        /// 免费停车 分钟
        /// </summary>
        private int _FreeMinute = 30;
        /// <summary>
        /// 最低消费时间长
        /// </summary>
        private int _iMinTime = 30;
        /// <summary>
        /// 一天最高的费用
        /// </summary>
        private decimal _oneDayMaxCost = 99999990;
        /// <summary>
        ///  时间段&每小时费用  _timelist.Add("00:00&08:00&4");//起始时间&结束时间&费率
        ///   _timelist.Add("00:00&08:00&4");
        ///   _timelist.Add("08:00&16:00&5");
        ///   _timelist.Add("16:00&23:59&6");
        /// </summary>
        private System.Collections.ArrayList _timelist = new ArrayList();
        /// <summary>
        /// 一整天计费方式：0=汇总各个时段费用（时段长*单价）；1=用“idayMoney一整天的费用”来计算;2=重新计算，按firstHour内多少钱，后面各个小时多少钱
        /// </summary>
        private int _idayType = 0;
        /// <summary>
        /// 一整天的费用
        /// </summary>
        private decimal _idayMoney = 60;
        /// <summary>
        ///  0=前N分钟不计费，1=最低扣费时间长
        /// </summary>
        private int _iFirstType = 0;
        /// <summary>
        /// 超过免费时间后，firstHour小时内FirstCash元
        /// </summary>
        private int _firstHour = 3;
        /// <summary>
        /// 超过免费时间后，firstHour小时内FirstCash元
        /// </summary>
        private int _firstCash = 10;
        /// <summary>
        /// 第二天（过晚上24点后），计费方式：0＝重新计费，1=汇总各时段费用
        /// </summary>
        private int _iAfter24H = 0;

        /// <summary>
        /// 免费停车 分钟
        /// </summary>
        public int FreeMinute
        {
            get
            {
                return _FreeMinute;
            }
            set
            {
                _FreeMinute = value;
            }
        }


        /// <summary>
        /// 单天最高的费用
        /// </summary>
        public decimal OneDayMaxCost
        {
            get
            {
                return _oneDayMaxCost;
            }

            set
            {
                _oneDayMaxCost = value;
            }
        }

        /// <summary>
        /// 时间段&每小时费用  _timelist.Add("00:00&08:00&4");
        /// </summary>
        public ArrayList timelist
        {
            get
            {
                if (_timelist.Count < 1)
                {
                    _timelist.Add("00:00&08:00&4");
                    _timelist.Add("08:00&16:00&5");
                    _timelist.Add("16:00&23:59&6");
                }
                return _timelist;
            }
            set
            {
                _timelist = value;
            }
        }

        /// <summary>
        /// 一整天计费方式：0=汇总各个时段费用（时段长*单价）；1=用“idayMoney一整天的费用”来计算;2=重新计算，按firstHour内多少钱，后面各个小时多少钱
        /// </summary>
        public int idayType
        {
            get
            {
                return _idayType;
            }

            set
            {
                _idayType = value;
            }
        }

        /// <summary>
        /// 一整天的费用
        /// </summary>
        public decimal idayMoney
        {
            get
            {
                return _idayMoney;
            }
            set
            {
                _idayMoney = value;
            }
        }

        /// <summary>
        /// 最低消费时间长
        /// </summary>
        public int iMinTime
        {
            get
            {
                return _iMinTime;
            }

            set
            {
                _iMinTime = value;
            }
        }
        /// <summary>
        /// 0=前N分钟不计费，1=最低扣费时间长
        /// </summary>
        public int iFirstType
        {
            get
            {
                return _iFirstType;
            }

            set
            {
                _iFirstType = value;
            }
        }

        /// <summary>
        /// 超过免费时间后，firstHour小时内FirstCash元
        /// </summary>
        public int firstHour
        {
            get
            {
                return _firstHour;
            }

            set
            {
                _firstHour = value;
            }
        }

        /// <summary>
        /// 超过免费时间后，firstHour小时内FirstCash元
        /// </summary>
        public int firstCash
        {
            get
            {
                return _firstCash;
            }

            set
            {
                _firstCash = value;
            }
        }
        /// <summary>
        /// 第二天（过晚上24点后），计费方式：0＝重新计费，1=汇总各时段费用
        /// </summary>
        public int iAfter24H
        {
            get
            {
                return _iAfter24H;
            }

            set
            {
                _iAfter24H = value;
            }
        }


        #endregion

        #region 计算费用
        int iDayIndex = 1;
        /// <summary>
        /// 计算费用
        /// </summary>
        /// <param name="ST">起始时间</param>
        /// <param name="OT">停止时间</param>
        /// <returns></returns>
        public string CalcStopCash(DateTime ST, DateTime OT)
        {
            backdata rt = new backdata();
            rt.result = "OK";
            rt.errcode = "0";
            rt.errmsg = "";
            rt.paycash = 0;
            rt.iHour = 0;
            decimal _CalcM = 0;
            string result = "";
            string errmsg = "";
            ArrayList alist = new ArrayList();
            iDayIndex = 1;
            string StopTimeInfo = "";
            try
            {

                #region 
                if (decimal.Parse(ST.ToString("yyMMddHHmm")) >= decimal.Parse(OT.ToString("yyMMddHHmm")))
                {
                    rt.result = "FAIL";
                    rt.errcode = "-1";
                    rt.errmsg = "停车的起始时间>=截止时间，无法计算。";
                    result = Newtonsoft.Json.JsonConvert.SerializeObject(rt);
                    return result;
                }
                TimeSpan ts = OT.Subtract(ST);
                rt.iHour = decimal.Parse(ts.TotalHours.ToString("f2"));
                if (ts.Days > 0)
                {
                    StopTimeInfo += ts.Days.ToString() + "天";
                }
                if (ts.Hours > 0)
                {
                    StopTimeInfo += ts.Hours.ToString() + "小时";
                }
                if (ts.Minutes > 0)
                {
                    StopTimeInfo += ts.Minutes.ToString() + "分钟";
                }
                #endregion
                DateTime _ST = ST;
                DateTime _OT = OT;
                while (decimal.Parse(_ST.ToString("yyMMdd")) <= decimal.Parse(_OT.ToString("yyMMdd")))
                {
                    decimal OneDayCash = 0;//计算某一天的费用
                    if (ST.ToString("yyMMdd") == OT.ToString("yyMMdd"))
                    {
                        OneDayCash = CalcOneDayCast(ST, OT, ref alist, true);
                        if (OneDayCash == -100)
                        {
                            rt.result = "FAIL";
                            rt.errcode = "-2";
                            rt.errmsg = "计费出错：" + ExceptionInfo;
                            result = Newtonsoft.Json.JsonConvert.SerializeObject(rt);
                            return result;
                        }
                        _CalcM += OneDayCash;
                    }
                    else
                    {
                        #region
                        if (_ST.ToString("yyMMdd") == ST.ToString("yyMMdd"))
                        {
                            #region 起始一天

                            DateTime _temDT = DateTime.Parse(_ST.ToString("yyyy-MM-dd 23:59:59"));
                            OneDayCash = CalcOneDayCast(ST, _temDT, ref alist, true);
                            if (OneDayCash == -100)
                            {
                                rt.result = "FAIL";
                                rt.errcode = "-3";
                                rt.errmsg = "计费出错：" + ExceptionInfo;
                                result = Newtonsoft.Json.JsonConvert.SerializeObject(rt);
                                return result;
                            }
                            _CalcM += OneDayCash;


                            #endregion
                        }
                        else if (_ST.ToString("yyMMdd") == OT.ToString("yyMMdd"))
                        {

                            #region 最后一天
                            DateTime _temDT = DateTime.Parse(_ST.ToString("yyyy-MM-dd 00:00:00"));
                            OneDayCash = CalcOneDayCast(_temDT, OT, ref alist, false);
                            if (OneDayCash == -100)
                            {
                                rt.result = "FAIL";
                                rt.errcode = "-4";
                                rt.errmsg = "计费出错：" + ExceptionInfo;
                                result = Newtonsoft.Json.JsonConvert.SerializeObject(rt);
                                return result;
                            }
                            _CalcM += OneDayCash;

                            #endregion
                        }
                        else
                        {
                            #region  一整天

                            if (idayType == 2)
                            {
                                //errmsg = "超过1天，按收费标准重新计费:";
                                //重新按计费标准计费
                                DateTime tem_beg = DateTime.Parse(_ST.ToString("yyyy-MM-dd 00:00:00"));
                                DateTime tem_end = DateTime.Parse(_ST.ToString("yyyy-MM-dd 23:59:00"));
                                OneDayCash = CalcOneDayCast(tem_beg, tem_end, ref alist, false);
                                if (OneDayCash == -100)
                                {
                                    rt.result = "FAIL";
                                    rt.errcode = "-5";
                                    rt.errmsg = "计费出错：" + ExceptionInfo;
                                    result = Newtonsoft.Json.JsonConvert.SerializeObject(rt);
                                    return result;
                                }
                            }
                            else
                            {
                                OneDayCash = idayMoney;
                                if (OneDayCash > OneDayMaxCost)
                                {
                                    OneDayCash = OneDayMaxCost;
                                    errmsg = "------>:" + iDayIndex.ToString() + "、" + _ST.ToString("yyyyMMdd") + "单天超过最高收费标准" + OneDayMaxCost.ToString("f2") + "，按最高标准收费。:<-----";
                                    alist.Add(errmsg);
                                }
                                else
                                {
                                    errmsg = "------>:" + iDayIndex.ToString() + "、" + _ST.ToString("yyyyMMdd") + "一整天的费用为" + idayMoney.ToString() + " :<-----";
                                    alist.Add(errmsg);
                                }
                                iDayIndex++;

                            }
                            _CalcM += OneDayCash;


                            #endregion
                        }
                        #endregion
                    }

                    _ST = _ST.AddDays(1);
                }


            }
            catch (Exception ex)
            {
                rt.result = "FAIL";
                rt.errcode = "-6";
                rt.errmsg = "计费出错：" + ex.Message;
            }

            rt.paycash = _CalcM;
            alist.Add("{  " + ST.ToString("yyyy-MM-dd HH:mm:00") + "   " + OT.ToString("yyyy-MM-dd HH:mm:00") + "  共停车  " + StopTimeInfo + "，合计费用：" + _CalcM.ToString("f2") + "  }");
            rt.alist = alist;
            result = Newtonsoft.Json.JsonConvert.SerializeObject(rt);
            return result;
        }
        #endregion

        #region 计算一天内时段的费用
        /// <summary>
        /// 出错信息
        /// </summary>
        string ExceptionInfo = "";
        /// <summary>
        /// 计算一天内时段的费用
        /// </summary>
        /// <param name="_ST"></param>
        /// <param name="_OT"></param>
        /// <param name="_Cash"></param>
        /// <param name="alist"></param>
        /// <returns></returns>
        private decimal CalcOneDayCast(DateTime _ST, DateTime _OT, ref ArrayList alist, bool boFirstDay)
        {
            try
            {
                ExceptionInfo = "";

                #region 
                string errmsg = "";
                decimal OneDayValue = 0;

                _OT = DateTime.Parse(_ST.ToString("yyyy-MM-dd ") + _OT.ToString("HH:mm:00"));
                TimeSpan ts = _OT.Subtract(_ST);
                alist.Add("------>:" + iDayIndex.ToString() + "、" + _ST.ToString("yyyy-MM-dd HH:mm:00") + "    " + _OT.ToString("yyyy-MM-dd HH:mm:00"));
                bool boReturn = false;
                if (boFirstDay || iAfter24H == 0)
                {
                    //第一天或都重新计费
                    if (ts.TotalMinutes < FreeMinute)
                    {
                        alist.Add(ts.TotalMinutes.ToString() + "小于" + FreeMinute.ToString() + "不收费。");
                        boReturn = true;
                        //return OneDayValue;
                    }
                    else if (ts.TotalMinutes <= firstHour * 60)
                    {
                        OneDayValue += firstCash;
                        alist.Add("超过" + FreeMinute.ToString() + "分钟,在" + firstHour.ToString() + "小时内" + firstCash.ToString() + "元");
                        boReturn = true;
                        // return OneDayValue;
                    }
                    else
                    {
                        _ST = _ST.AddHours(firstHour);
                        OneDayValue += firstCash;
                        alist.Add("超过" + FreeMinute.ToString() + "分钟,在" + firstHour.ToString() + "小时内" + firstCash.ToString() + "元");
                    }
                }
                if (!boReturn)
                {
                    #region 停车时间在同一天内
                    decimal _H_Start = decimal.Parse(_ST.ToString("HHmm"));
                    decimal _H_End = decimal.Parse(_OT.ToString("HHmm"));
                    alist.Add(_ST.ToString("HH:mm") + "  VS  " + _OT.ToString("HH:mm"));
                    //TimeSpan ts = _OT.Subtract(_ST);
                    //消费在一天内
                    for (int i = 0; i < timelist.Count; i++)
                    {
                        #region
                        // _timelist.Add("00:00&08:00&4");
                        string[] spt = timelist[i].ToString().Split(new char[] { '&' });
                        DateTime _StartDT = DateTime.Parse(_ST.ToString("yyyy-MM-dd") + " " + spt[0]);
                        DateTime _EndDT = DateTime.Parse(_ST.ToString("yyyy-MM-dd") + " " + spt[1]);
                        decimal _C_Start = decimal.Parse(spt[0].Replace(":", "").Trim());
                        decimal _C_End = decimal.Parse(spt[1].Replace(":", "").Trim());

                        decimal _SpCash = decimal.Parse(spt[2]);
                        //_H_Start06:00;   _C_Start:8:00;  _H_End:10:00;  _C_End:12:00
                        if (_H_Start <= _C_Start && _H_End >= _C_Start && _H_End <= _C_End)
                        {
                            //消费起始时间小于时段起始时间，消费截止时间在时段内
                            ts = _OT.Subtract(_StartDT);
                            decimal Dvalue = _SpCash * decimal.Parse(ts.TotalHours.ToString());
                            OneDayValue += Dvalue;
                            errmsg = "   " + (i + 1).ToString() + "、" + _StartDT.ToString("HH:mm") + " " + _EndDT.ToString("HH:mm") + " { " + _StartDT.ToString("HH:mm") + " " + _OT.ToString("HH:mm") + " } 耗时" + ts.TotalHours.ToString("f2") + "小时，单价" + _SpCash.ToString("f2") + "，合计费用为" + Dvalue.ToString("f2") + ";  \n";
                            alist.Add(errmsg);
                        }
                        else if (_C_Start >= _H_Start && _C_Start <= _H_End)// (_H_Start >= _C_Start && _H_End<= _C_End)
                        {
                            //整个时段内在消费
                            ts = _EndDT.Subtract(_StartDT);
                            decimal Dvalue = _SpCash * decimal.Parse(ts.TotalHours.ToString());
                            OneDayValue += Dvalue;
                            errmsg = "   " + (i + 1).ToString() + "、" + _StartDT.ToString("HH:mm") + " " + _EndDT.ToString("HH:mm") + " { " + _StartDT.ToString("HH:mm") + " " + _EndDT.ToString("HH:mm") + " } 耗时" + ts.TotalHours.ToString("f2") + "小时，单价" + _SpCash.ToString("f2") + "，合计费用为" + Dvalue.ToString("f2") + ";  \n";
                            alist.Add(errmsg);
                        }
                        else if (_H_Start >= _C_Start && _H_End <= _C_End)
                        {
                            //消费在时段内
                            ts = _OT.Subtract(_ST);
                            decimal Dvalue = _SpCash * decimal.Parse(ts.TotalHours.ToString());
                            OneDayValue += Dvalue;
                            errmsg = "   " + (i + 1).ToString() + "、" + _StartDT.ToString("HH:mm") + " " + _EndDT.ToString("HH:mm") + " { " + _ST.ToString("HH:mm") + " " + _OT.ToString("HH:mm") + " } 耗时" + ts.TotalHours.ToString("f2") + "小时，单价" + _SpCash.ToString("f2") + "，合计费用为" + Dvalue.ToString("f2") + ";  \n";
                            alist.Add(errmsg);
                        }
                        else if (_H_Start >= _C_Start && _H_Start <= _C_End &&
                            _H_End >= _C_Start && _H_End >= _C_End)
                        {
                            //消费起始时间在时段内，消费截止时间大于结束时间
                            ts = _EndDT.Subtract(_ST);
                            decimal Dvalue = _SpCash * decimal.Parse(ts.TotalHours.ToString());
                            OneDayValue += Dvalue;
                            errmsg = "   " + (i + 1).ToString() + "、" + _StartDT.ToString("HH:mm") + " " + _EndDT.ToString("HH:mm") + " { " + _ST.ToString("HH:mm") + " " + _EndDT.ToString("HH:mm") + " } 耗时" + ts.TotalHours.ToString("f2") + "小时，单价" + _SpCash.ToString("f2") + "，合计费用为" + Dvalue.ToString("f2") + ";  \n";
                            alist.Add(errmsg);
                        }
                        #endregion
                    }
                    #endregion
                }
                if (OneDayValue > OneDayMaxCost)
                {
                    errmsg = _ST.ToString("yyyy-MM-dd") + "单天费用" + OneDayValue.ToString("f2") + "超过最高收费标准" + OneDayMaxCost.ToString("f2") + "，按最高标准收费。:<-----";
                    OneDayValue = OneDayMaxCost;
                    alist.Add(errmsg);
                }
                else
                {
                    alist.Add(_ST.ToString("yyyy-MM-dd") + "当天合计费用：" + OneDayValue.ToString("f2") + " :<-----");
                }

                iDayIndex++;

                return OneDayValue;
                #endregion
            }
            catch (Exception ex)
            {
                ExceptionInfo = ex.Message;
                return -100;
            }
        }
        #endregion

    }

    /// <summary>
    /// 返回信息
    /// </summary>
    public class backdata
    {
        #region 返回信息
        /// <summary>
        /// 返回结果:OK/FAIL
        /// </summary>
        public string result
        {
            get;
            set;
        }

        /// <summary>
        /// 错误码
        /// </summary>
        public string errcode
        {
            get;
            set;
        }
        /// <summary>
        /// 错误信息
        /// </summary>
        public string errmsg
        {
            get;
            set;
        }
        /// <summary>
        /// 合计费用
        /// </summary>
        public decimal paycash
        {
            get;
            set;
        }
        /// <summary>
        /// 消费时长
        /// </summary>
        public decimal iHour
        {
            get;
            set;
        }

        /// <summary>
        /// 时段消费明细
        /// </summary>
        public ArrayList alist
        {
            get;
            set;
        }
        #endregion
    }
}

想起你的日子
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C#停车场收费系统(winform项目)
12-20
C#语言，winform程序，SQLServer数据库（可自行更改），压缩包内包含数据库文件，主要的模块有添加停车、车辆出库、停车收费、收费查询、管理等界面
应用于停车场的24小时计费算法
梦醒逃荒岛的博客
01-22 3341
停车场管理中，最普遍最简单的计费规则当属24小时计费，也就是在按停车小时数计费. 收费规则设置界面如下 24小时计费规则并不复杂，方法输入车辆进出时间startTime、endTime ```java public static BigDecimal chargin(HourChargingRule rule,LocalDateTime inTime,LocalDateTime endTime){ Duration between = Duration.between(inTim
物联网工程关键技术----C#停车场收费系统
2301_77897522的博客
07-05 159
i++) //遍历字符串数组，把每个字符串转换成字节类型赋值给每个字节变量。
C#物联网工程关键技术停车场收费系统
m0_68011227的博客
07-03 307
设计一个停车场收费系统，要求车辆进入时刷卡登记，出场刷卡后计算时间，并显示扣费金额。C#物联网工程中停车场收费系统的实现可以涉及以下关键技术：设备连接与通信：使用物联网技术将停车场设备连接到系统中。可以使用传统的串口通信。车辆识别与管理：使用车牌识别技术或其他身份识别技术来识别车辆进入和离开停车场，记录车辆信息并管理停车位的分配。收费计算与管理：根据停车时间和费率规则计算车辆应付的停车费用。
停车统计方案
phynikesi的博客
04-20 673
小区出入车统计方案 1， 先按日期将数据分组，每天一个组，理解成每天的数据是一个文件， daily_data 2， 对每天的数据建立入车字典和出车字典，以车牌为key，value为长度24的列表，对应每个小时的 最晚入车时间或出车时间。同一车辆不会连续入车两次，也不会连续出车两次，此前必包含完整的进出， 可抵消不计，只记录单位小时的最晚入车或出车。列表内的元素为出/入车时间(字符串)或0(这个小时没有出入记录)。 3，对当天数据统计每个车的最早出车和最晚入车时间， 有则记录时间，无则记录0。 .
时段计费算法，一般用于停车计费
12-28
Ｃ#winFrom实现按不同时间不同费用，计算时段内的消费金额，一般用于停车场管理计费算法　https://blog.csdn.net/wysdong/article/details/85321864　对应的源码
c#小波变换算法c#小波变换算法
12-15
在C#中实现小波变换，我们可以利用数学库或者自定义算法来完成。本文将深入探讨C#小波变换算法的相关知识点。 1. **小波基础理论**： - **定义**：小波（Wavelet）是一种具有有限持续时间和有限带宽的函数，可以...
c# 实现轮询算法实例代码
12-26
c# 轮询算法 　这两天做东西，业务上有个特殊的需求，在用户访问页面的时候，针对某一行代码进行控制，按照概率来进行显示，我做的是针对当前页面的曝光进行处理，曝光代码是第三方的，页面上只要有这段代码就算是...
Delaunay生长算法C#
02-21
Delaunay生长算法C#。 看到网上好像没有C#写的这个算法，写的也大多乱七八糟，自己写了一下，加了一些东西，例如两种方式加载数据，还有算法运行时间，这样子方便大家对Delaunay算法的比较 Delaunay 生长 C#
C#实现洗牌算法
09-03
洗牌算法的要求是这样的:将N个数乱序后输出.由于和扑克牌的洗牌过程比较相似所以我也就称为洗牌算法了.很多地方都不自觉的需要这个算法的支持.也可以将这个算法扩展为从N个数中取出M个不...今天我们看下如何用C#来实现
停车场收费系统
xjhqre的博客
05-19 498
停车场收费系统 实现：输入停车的开始时间和结束时间，得到总停车时间（小时） Time.hpp文件 //DateTime.hpp class DateTime { public: void showTime(); void setTime(); double diff(const DateTime &T); private: long normalize() const; long countdays() const; int year;
停车场的收费系统：停车场有3类汽车，每种收费也不一样，要求输入汽车类型和入库、出库时间，输出应交的停车费。假设停车时间不超过24小时。
qq_55433305的博客
04-10 2176
C语言程序设计编程:设计一个停车场的收费系统。停车场有3类汽车，分别用3个字母表示:C代表轿车，B代表客车， T代表卡车。收费标准如下表所示。 车辆类型 收费标准 轿车 3小时内，每小时5元。3小时后，每小时 10元 客车 2小时内，每小时10元。2小时后，每小 时15元 卡车 1小时内，每小时10元。1小时后，每小 时15元 要求输入汽车类型和入库、出库时间，输出应交的停车费。假设停车时间不超过24小时。
C# 用狄克斯特拉（Dijkstra）算法求停车
热门推荐
彦文的专栏
04-22 1万+
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using System.Co...
停车场收费计价（Python）
最新发布
Daemonic_的博客
11-02 2702
编写一个C语言程序，实现一个简单的停车场收费计算，需要处理以下几种情况： - 如果停车时间为1小时以内（含1小时），免费； - 如果停车时间为8小时(含8小时)，则按照每小时10元的价格收费； - 如果停车时间为8小时以上，前8小时按照每小时10元的价格收费，超过8小时后，每增加1小时，按照每小时15元的价格收费。 - 应支付的停车费用封顶为200元。
c#高频卡停车场收费系统
weixin_69107688的博客
07-05 156
开发工具：Microsoft Visual Studio 2019（简称 VS）是美国的开发工具包系列产品。VS 是一个基本的开发工具集，它包括了整个中所需要的大部分工具，如 UML 工具、代码管控工具、(IDE)等等。所写的目标代码适用于微软支持的所有平台，包括、、、、和 Microsoft 及。2018 年 6 月，微软宣布开发新一代集成开发环境（integrated development environment，IDE）Visual Studio 2019。
停车场收费问题
m0_62788400的博客
04-30 883
在停车场收费系统中，收费者会根据车型的不同按不同的单价和计费方式收取不同的停车费，其中： 轿车Car：每小时8元，超过30分钟按一小时计算，未超过30分钟不收费 客车Bus：每小时10元，30分钟以内按半小时计费，未达1小时但超过30分钟按1小时计算 货车Truck：每小时15元，未达1小时的按1小时计算 其他未知类型：按默认方法计算，见裁判程序。 请补充必要的类和函数定义，使停车场类Parker可收取停入的n辆车的费用。 裁判测试
c#不同时间段、不同费率计算费用
zhouwen5288的专栏
04-21 697
球场分时段计费算法
u013685199的博客
08-20 1385
球场分时段计费算法    1.输入数据   开始结束时间 2.变量（时间段，单价，初始价，封顶价） 3.思路 ：（1）.传入开始结束时间，提取必要的对比信息（开始结束小时，时间戳，经过时长）。（2.）根据时间创建1-2的数组。（2.循环时间数组，调用不同时间段的计价方法） 不废话，直接贴贴代码          public $stime = "2018-08-04 23:41:00"...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值