c++实现医院检验科排班程序

c++实现医院检验科排班程序

1、背景：

医院急诊检验科24h×7×365值班，工作人员固定。采取轮班制度，确保24h都有人值班。

本文就通过C++实现编写程序自动排班，并可以转为Excel打印。

2、急诊检验科排班概况（口头咨询后整理）：

1）、检验科人数：7人。

2）、上班类型："夜班", "起夜", "休息", "急诊", "急值", "急诊午",共5种。

3）、上班时间：每人固定每周休息2天，但两天为一周内的任意两天。

4）、谁来排班：主任负责排班。

5）、排班原则：新同事1人，不上夜班。新同事每周上班类型完全一致。

主任每周上班类型也不变。

除新同事和主任外的其他同事，采取轮班制。

6）、轮班原则：除主任和新同事外的四位同事上班逐周上班类型为：ABCD，BCDA，CDAB，DABC，ABCD....依次轮询,每周变化一次....

3、细化需求：

1）实现自动排班程序。

2）输入：年份如2015，以及一个月的基准排班表（检验科提供）。

3）输出：1年的排班表，以周为单位，包含：当前年第几周，星期几，日期，检验师名称，排班表。

输出形式：控制台、txt文档、Excel文档（可以用来打印）。

4、自我分析：

1）由于排班存在规律性，所以可以通过程序实现。

2）以周为单位实现，只需要将年份的天数统计存储下来，如2015年365天，然后逐周7天为单位打印即可。

3）Excel本身支持txt文档，只需要输出规范的txt文档，导入Excel即满足需求。

5、程序运行截图：

6、源码实现（VS2010实现）：

// workOrderDemo.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <iostream>
using namespace std;
#include <stdio.h>
#include <stdlib.h>
#include <iomanip>
#include <assert.h>
#include <vector>
#include <fstream>
#include <assert.h>
#define EQUAL '='
#define SPACE ' '
#define STARBAR '*'
typedef unsigned int UINT32;
#define MAX_NAME_LEN 100   //最大名字长度
#define MAX_SPAN_LEN 9    //间隔字符长度
#define MAX_WEEKS_CNT 52   //365/7 或者366/7 周数
#define MAX_CYC_WEEK_CNT 6   //最大循环次数
#define MAX_MONTH_CNTS_IN_YEAR 12   //1年的月份数
#define THIS_YEAR 2015              //当前的年份
const char* pszOutFile = "E:\\WorkTable.txt";
ofstream g_fOutFile(pszOutFile); //打开文件用于写，若文件不存在就创建它
//星期序列
typedef enum WEEK_DAY
{
MONDAY = 0,
TUESDAY,
WEDNESDAY,
THURSDAY,
FRIDAY,
SATUDAY,
SUNDAY,
MAX_WORK_DAYS //计数用
}WEEKDAY;
//值班检验师名称
typedef enum INSPECTOR_YANTAI
{
WANG_XIN_PING = 0,
FU_TIAN = 1,
ZHAO_JI_JUAN = 2, //0
ZHAO_YU_XIANG,
ZHANG_XIA,
WANG_XIAO_FEI,
ZHU_HONG_JING,
MAX_INSPECTOR_CNT  //计数用
}INSPECTOR;
//值班类型
typedef enum WORK_TYPES
{
NIGHT_WORK = 0,   //夜班
AFTER_NIGHT_WORK, //起夜
SLEEP,            //休息
URGENT_DIAGNOSE,  //急诊
URGENT_WORK,      //急值
URGENT_DIAGNOSE_AFTERNON, //急诊午
WORK_CNTS                 //7 计数用
}WORK_TYPE;

char g_pszInspectorArr[MAX_INSPECTOR_CNT][MAX_NAME_LEN] = {"王*平", "付*明", "赵*娟", "赵*香", "张*玉", "王*飞", "朱*静"};
char g_workTypeName[WORK_CNTS][MAX_NAME_LEN] = {"夜班", "起夜", "休息", "急诊", "急值", "急诊午" };
char g_weekDayName[MAX_WORK_DAYS][MAX_NAME_LEN] = {"周一", "周二", "周三", "周四", "周五", "周六", "周日"};
//临时存储
WORK_TYPE g_TmpDayWork[MAX_WORK_DAYS] = {NIGHT_WORK};
WORK_TYPE g_WeekWorkTable[MAX_INSPECTOR_CNT][MAX_WORK_DAYS] = {NIGHT_WORK};
WORK_TYPE g_WeekWorkTableBak[MAX_INSPECTOR_CNT][MAX_WORK_DAYS] = {NIGHT_WORK};  //基准表，1月份的永恒不变

//存储格式化日期格式
vector<char* > g_DaysVector;

/*
**@brief:打印字符格式化用
**@param:ch字符, num个数
**@return:空.
*/
void print_n_char(char ch , int num)
{
int count = 0;
for (count = 0 ; count < num ; count++)
{
  cout << ch;
  g_fOutFile << SPACE;
}
}
/*
**@brief:根据年月日返回星期几
**@param:UINT32 iYear 年, UINT32 iMonth 月, UINT32 iDay 日
**@return: 星期几.
*/
int ReturnWeekDay(UINT32 iYear, UINT32 iMonth, UINT32 iDay)
{
int iWeek = 0;
UINT32 y = 0, c = 0, m = 0, d = 0;
if ( iMonth == 1 || iMonth == 2 )
{
  c = ( iYear - 1 ) / 100;
  y = ( iYear - 1 ) % 100;
  m = iMonth + 12;
  d = iDay;
}
else
{
  c = iYear / 100;
  y = iYear % 100;
  m = iMonth;
  d = iDay;
}
iWeek = y + y / 4 + c / 4 - 2 * c + 26 * ( m + 1 ) / 10 + d - 1;    //蔡勒公式
iWeek = iWeek >= 0 ? ( iWeek % 7 ) : ( iWeek % 7 + 7 );    //iWeek为负时取模
if ( iWeek == 0 )    //星期日不作为一周的第一天
{
  iWeek = 7;
}
return iWeek;
}
/*
**@brief:返回格式化周几
**@param:int iWeekDay 星期几
**@return: 格式化周几.
*/
char* GetWeekName(int iWeekDay)
{
assert(iWeekDay > 0);
return g_weekDayName[iWeekDay - 1];
}
/*
**@brief:初始化基准工作表，以5月11号一周为基准（设定为1月1日）
**@param:空
**@return:无
*/
void InitWorkTableBakFun()
{
//0 WANG_XIN_PING
g_WeekWorkTableBak[WANG_XIN_PING][MONDAY] = URGENT_DIAGNOSE;
g_WeekWorkTableBak[WANG_XIN_PING][TUESDAY] = URGENT_WORK;
g_WeekWorkTableBak[WANG_XIN_PING][WEDNESDAY] = URGENT_DIAGNOSE_AFTERNON;
g_WeekWorkTableBak[WANG_XIN_PING][THURSDAY] = NIGHT_WORK;
g_WeekWorkTableBak[WANG_XIN_PING][FRIDAY] = AFTER_NIGHT_WORK;
g_WeekWorkTableBak[WANG_XIN_PING][SATUDAY] = SLEEP;
g_WeekWorkTableBak[WANG_XIN_PING][SUNDAY] = SLEEP;
//1 FU_TIAN
g_WeekWorkTableBak[FU_TIAN][MONDAY] = URGENT_DIAGNOSE_AFTERNON;
g_WeekWorkTableBak[FU_TIAN][TUESDAY] = URGENT_DIAGNOSE;
g_WeekWorkTableBak[FU_TIAN][WEDNESDAY] = SLEEP;
g_WeekWorkTableBak[FU_TIAN][THURSDAY] = URGENT_DIAGNOSE;
g_WeekWorkTableBak[FU_TIAN][FRIDAY] = URGENT_DIAGNOSE;
g_WeekWorkTableBak[FU_TIAN][SATUDAY] = SLEEP;
g_WeekWorkTableBak[FU_TIAN][SUNDAY] = URGENT_DIAGNOSE;
//2 ZHAO_JI_JUAN
g_WeekWorkTableBak[ZHAO_JI_JUAN][MONDAY] = NIGHT_WORK;
g_WeekWorkTableBak[ZHAO_JI_JUAN][TUESDAY] = AFTER_NIGHT_WORK;
g_WeekWorkTableBak[ZHAO_JI_JUAN][WEDNESDAY] = SLEEP;
g_WeekWorkTableBak[ZHAO_JI_JUAN][THURSDAY] = SLEEP;
g_WeekWorkTableBak[ZHAO_JI_JUAN][FRIDAY] = AFTER_NIGHT_WORK;
g_WeekWorkTableBak[ZHAO_JI_JUAN][SATUDAY] = URGENT_DIAGNOSE;
g_WeekWorkTableBak[ZHAO_JI_JUAN][SUNDAY] = NIGHT_WORK;
//3 ZHAO_YU_XIANG
g_WeekWorkTableBak[ZHAO_YU_XIANG][MONDAY] = URGENT_WORK;
g_WeekWorkTableBak[ZHAO_YU_XIANG][TUESDAY] = NIGHT_WORK;
g_WeekWorkTableBak[ZHAO_YU_XIANG][WEDNESDAY] = AFTER_NIGHT_WORK;
g_WeekWorkTableBak[ZHAO_YU_XIANG][THURSDAY] = SLEEP;
g_WeekWorkTableBak[ZHAO_YU_XIANG][FRIDAY] = URGENT_WORK;
g_WeekWorkTableBak[ZHAO_YU_XIANG][SATUDAY] = URGENT_DIAGNOSE_AFTERNON;
g_WeekWorkTableBak[ZHAO_YU_XIANG][SUNDAY] = SLEEP;
//4 ZHANG_XIA
g_WeekWorkTableBak[ZHANG_XIA][MONDAY] = SLEEP;
g_WeekWorkTableBak[ZHANG_XIA][TUESDAY] = URGENT_DIAGNOSE_AFTERNON;
g_WeekWorkTableBak[ZHANG_XIA][WEDNESDAY] = NIGHT_WORK;
g_WeekWorkTableBak[ZHANG_XIA][THURSDAY] = AFTER_NIGHT_WORK;
g_WeekWorkTableBak[ZHANG_XIA][FRIDAY] = SLEEP;
g_WeekWorkTableBak[ZHANG_XIA][SATUDAY] = URGENT_WORK;
g_WeekWorkTableBak[ZHANG_XIA][SUNDAY] = URGENT_WORK;

//5 WANG_XIAO_FEI
g_WeekWorkTableBak[WANG_XIAO_FEI][MONDAY] = SLEEP;
g_WeekWorkTableBak[WANG_XIAO_FEI][TUESDAY] = SLEEP;
g_WeekWorkTableBak[WANG_XIAO_FEI][WEDNESDAY] = URGENT_WORK;
g_WeekWorkTableBak[WANG_XIAO_FEI][THURSDAY] = URGENT_DIAGNOSE_AFTERNON;
g_WeekWorkTableBak[WANG_XIAO_FEI][FRIDAY] = NIGHT_WORK;
g_WeekWorkTableBak[WANG_XIAO_FEI][SATUDAY] = AFTER_NIGHT_WORK;
g_WeekWorkTableBak[WANG_XIAO_FEI][SUNDAY] = URGENT_DIAGNOSE_AFTERNON;
//6 ZHU_HONG_JING
g_WeekWorkTableBak[ZHU_HONG_JING][MONDAY] = SLEEP;
g_WeekWorkTableBak[ZHU_HONG_JING][TUESDAY] = SLEEP;
g_WeekWorkTableBak[ZHU_HONG_JING][WEDNESDAY] = URGENT_DIAGNOSE;
g_WeekWorkTableBak[ZHU_HONG_JING][THURSDAY] = URGENT_WORK;
g_WeekWorkTableBak[ZHU_HONG_JING][FRIDAY] = URGENT_DIAGNOSE_AFTERNON;
g_WeekWorkTableBak[ZHU_HONG_JING][SATUDAY] = NIGHT_WORK;
g_WeekWorkTableBak[ZHU_HONG_JING][SUNDAY] = AFTER_NIGHT_WORK;

}
/*
**@brief:判定年份是否为闰年.
**@param: iYear当前年份.
**@return:true,闰年; false,平年.
*/
bool IsLeapYear(UINT32 iYear)
{
if ( (iYear%4 == 0 && iYear%100 != 0) || (iYear%400 == 0) )
{
  return true;
}
else
{
  return false;
}
}
/*
**@brief:初始化工作表（与基准表一致）
**@param:空
**@return:无
*/
void InitWorkTableFun()
{
//与基准对齐
for (int inspector = 0; inspector < MAX_INSPECTOR_CNT; ++inspector)
{
  for (int curDay = 0; curDay < MAX_WORK_DAYS; ++curDay)
  {
   g_WeekWorkTable[inspector][curDay] = g_WeekWorkTableBak[inspector][curDay];
  }
}
}
/*
**@brief: 返回vector数组中的起始位置，打印用
**@param: nCurWeek 当前第几周
**@return:返回pos
*/
int GetBeginOfDaysVector(UINT32 nCurWeek)
{
//获取第几周的日期格式
//如第一周返回：1月1, 1月2, ... 1月7
assert(nCurWeek >= 0 && nCurWeek <= 1 + MAX_WEEKS_CNT);
int iBegin = (nCurWeek - 1) * 7;
return iBegin;
}
/*
**@brief: 打印对应周的排班表
**@param: iWeek 当前第几周
**@return:无
*/
void PrintCurWorkTable(int iWeek)
{
char szTmpFormat[MAX_NAME_LEN] = {0};
for (int curDay = 0; curDay < 1 + MAX_WORK_DAYS; ++curDay)
{
  if (0 == curDay)
  {
   cout << std::right << std::setw(MAX_SPAN_LEN) << "";
   g_fOutFile << std::right << std::setw(MAX_SPAN_LEN) << "";
  }
  else
  {
   cout << std::right << std::setw(MAX_SPAN_LEN) << g_weekDayName[curDay - 1];
   g_fOutFile << std::right << std::setw(MAX_SPAN_LEN) << g_weekDayName[curDay - 1];
  }
}
cout << endl;
g_fOutFile << endl;
int nDaysOfYear = 0;
//打印日期第几周 格式:1-1
int iBegin = 0;
int iWeekLen = 7;
if (iWeek <= MAX_WEEKS_CNT)
{
  iBegin = GetBeginOfDaysVector(iWeek);
  cout << std::right << std::setw(MAX_SPAN_LEN) << "";
  g_fOutFile << std::right << std::setw(MAX_SPAN_LEN) << "";
  for (int i = iBegin; i < iBegin + iWeekLen; ++i)
  {
   cout << std::right << std::setw(MAX_SPAN_LEN) << g_DaysVector[i];
   g_fOutFile << std::right << std::setw(MAX_SPAN_LEN) << g_DaysVector[i];
  }
  cout << endl;
  g_fOutFile << endl;
}
else
{
  if (IsLeapYear(THIS_YEAR))
  {
   nDaysOfYear = 366;
  }
  else
  {
   nDaysOfYear = 365;
  }
  //最后一周单独处理
  iWeekLen = nDaysOfYear - (MAX_WEEKS_CNT)*7;
  iBegin = GetBeginOfDaysVector(1 + MAX_WEEKS_CNT);
  for (int i = iBegin; i < iBegin + iWeekLen; ++i)
  {
   cout << std::right << std::setw(MAX_SPAN_LEN) << g_DaysVector[i];
   g_fOutFile << std::right << std::setw(MAX_SPAN_LEN) << g_DaysVector[i];
  }
  cout << endl;
  g_fOutFile << endl;
}

for (int curDay = 0; curDay < 1 + MAX_WORK_DAYS; ++curDay)
{
  if (0 == curDay)
  {
   cout << std::right << std::setw(MAX_SPAN_LEN) << "";
   //g_fOutFile << std::right << std::setw(MAX_SPAN_LEN) << "";
  }
  for (int j = 0; j < MAX_SPAN_LEN - 1; ++j)
  {
   cout << '-';
   //g_fOutFile << ' ';
  }
}
cout << endl;
//g_fOutFile << endl;

int curWorkType  = 0;
for (int inspector = 0; inspector < MAX_INSPECTOR_CNT; ++inspector)
{
  sprintf_s(szTmpFormat , "%d%s", inspector, g_pszInspectorArr[inspector]);
  cout << std::left << std::setw(MAX_SPAN_LEN) << szTmpFormat;
  g_fOutFile << std::right << std::setw(MAX_SPAN_LEN) << szTmpFormat;
  for (int curDay = 0; curDay < MAX_WORK_DAYS; ++curDay)
  {
   curWorkType = (int)(g_WeekWorkTable[inspector][curDay]);
   cout << std::right << std::setw(MAX_SPAN_LEN)<< g_workTypeName[curWorkType];
   g_fOutFile << std::right << std::setw(MAX_SPAN_LEN)<< g_workTypeName[curWorkType];
  }
  cout << endl;
  g_fOutFile << endl;
}
}
/*
**@brief: 测试打印日期格式
**@param: 空
**@return:无
*/
void testWeekDayOfData()
{
int iYear = 2015;
int iMonth = 6;
int iDay = 1;
for (iDay = 1; iDay <= 30; ++iDay)
{
  int iWeekDay = ReturnWeekDay(iYear, iMonth, iDay);
  cout << iWeekDay << GetWeekName(iWeekDay) << "\t";
  if (iDay % 7 == 0)
  {
   cout << endl;
  }
}
}

/*
**@brief: 以基准周为依据按照规律排班
**@param: nWeek当前第几周
**@return:无
*/
void ExchangeWork(UINT32 nWeek)
{
assert(nWeek >= 0 && nWeek <= MAX_INSPECTOR_CNT - 2);  //0-5之间
//0 第1周不变：   排班顺序 0 1 2 3 4 5 6；
//1 第2周：       排班顺序 0 1 3 4 5 6 2；
//2 第3周：       排班顺序 0 1 4 5 6 2 3；
//3 第4周：       排班顺序 0 1 5 6 2 3 4；
//4 第5周：       排班顺序 0 1 6 2 3 4 5； 循环终止
//5 第6周：       排班顺序 0 1 2 3 4 5 6； 同第一周
//每次都从基准周变更
if (0 == nWeek)
{
  (void)InitWorkTableFun();
}
else
{
  (void)InitWorkTableFun();
   //1-6 6个人，第0行始终不变无需再排班
  for (int iInspector = 2; iInspector < MAX_INSPECTOR_CNT ; ++iInspector)
  {
   int iNewOrder = iInspector + nWeek;
   if (iNewOrder > (MAX_INSPECTOR_CNT - 1))
   {
    iNewOrder = (iInspector + nWeek) % (MAX_INSPECTOR_CNT - 2);
   }

   if (0 == iNewOrder)
   {
    iNewOrder = 5;
   }
   //cout << "iNewOrder = " << iNewOrder << endl;
   assert(iNewOrder == 3 || iNewOrder == 4 || iNewOrder == 5 || iNewOrder == 6 || iNewOrder == 2);
   //周一到周日
   for (int curDay = 0; curDay < MAX_WORK_DAYS; ++curDay) //0-6 7天
   {

    if (2 == iInspector)
    {
     g_TmpDayWork[curDay] = g_WeekWorkTable[nWeek][curDay];  //
    }
    g_WeekWorkTable[iInspector][curDay] = g_WeekWorkTableBak[iNewOrder][curDay];

   }//end for curDay
  }//end for iInspector
}//end else
}
/*
**@brief: 全年中第几周的排班表
**@param: nWeek当前全年的第几周
**@return:无
*/
void CurWeekWorkOrder(UINT32 nWeek)
{
assert(nWeek <= MAX_WEEKS_CNT);

//全年周转化为规律周
UINT32 nOrderWeek = nWeek % (MAX_INSPECTOR_CNT - 2);
assert(nOrderWeek >= 0 && nOrderWeek < (MAX_INSPECTOR_CNT - 2));
//cout << "nWeek = " << nWeek << "nOrderWeek = " << nOrderWeek << endl;
(void)ExchangeWork(nOrderWeek);
}
/*
**@brief:判定某年某月的天数.
**@param: iYear当前年份，iMonth当前月份;
**@return:当前年、月的天数.
*/
unsigned int daysInMonth(UINT32 nYear, UINT32 nMonth)
{
assert(nMonth >=1 && nMonth <= MAX_MONTH_CNTS_IN_YEAR);
int nDaysInMonth = 0;
switch(nMonth)
{
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
  nDaysInMonth = 31;
  break;
case 4:
case 6:
case 9:
case 11:
  nDaysInMonth = 30;
  break;
case 2:
  if (IsLeapYear(nYear))
  {
   nDaysInMonth = 29;
  }
  else
  {
   nDaysInMonth = 28;
  }
  break;
default:
  cout << "Error Month!!" << endl;
  break;
}
return nDaysInMonth;
}
/*
**@brief:构建格式化日期
**@param: nYear 当年年份
**@return:无
*/
void BuildDayOfMonth(UINT32 nYear)
{
UINT32 nDaysOfYear = 0;
if (IsLeapYear(nYear))
{
  nDaysOfYear = 366;
}
else
{
  nDaysOfYear = 365;
}

for (int iMonth = 1; iMonth <= MAX_MONTH_CNTS_IN_YEAR; ++iMonth)
{
  for (int iDay = 1; iDay <= (int)(daysInMonth(nYear, iMonth)); ++iDay)
  {
   char *pszDataFormat = (char*)malloc(20);
   memset(pszDataFormat, 0, 20);
   sprintf_s(pszDataFormat, 20, "%d月%d日", iMonth, iDay);
   //cout << pszDataFormat << "\t";
   g_DaysVector.push_back(pszDataFormat);
  }//end for iDay
  //cout << endl;
}//end for iMonth
}
/*
**@brief:释放内存
**@param: 空
**@return:无
*/
void ReleaseDaysVector()
{
int iVectorSize = g_DaysVector.size();
//cout << "iVectorSize = " << iVectorSize << endl;
for (int i = 0; i < iVectorSize; ++i)
{
  if (NULL != g_DaysVector[i])
  {
   free(g_DaysVector[i]);
   g_DaysVector[i] = NULL;
  }
}
}
/*
**@brief:测试打印全年日期格式
**@param: 当前年份
**@return:无
*/
void testPrintDaysByWeek(UINT32 nYear)
{
int iWeekLen = 7;  //每周七天
int nDaysOfYear = 0;
if (IsLeapYear(nYear))
{
  nDaysOfYear = 366;
}
else
{
  nDaysOfYear = 365;
}
cout << endl;
int iBegin  = 0;
for (int iWeek = 1; iWeek <= MAX_WEEKS_CNT; ++iWeek)
{
  iBegin = GetBeginOfDaysVector(iWeek);
  for (int i = iBegin; i < iBegin + iWeekLen; ++i)
  {
   cout << g_DaysVector[i] << "\t";
  }
  cout << endl;
}
//最后一周单独处理
iWeekLen = nDaysOfYear - (MAX_WEEKS_CNT)*7;
iBegin = GetBeginOfDaysVector(1 + MAX_WEEKS_CNT);
for (int i = iBegin; i < iBegin + iWeekLen; ++i)
{
  cout << g_DaysVector[i] << "\t";
}
cout << endl;
}
void testPrintVectorDays()
{
int iVectorSize = g_DaysVector.size();
//cout << "iVectorSize = " << iVectorSize << endl;
for (int i = 0; i < iVectorSize; ++i)
{
  cout << g_DaysVector[i] << "\t";
}

}
int _tmain(int argc, _TCHAR* argv[])
{
(void)InitWorkTableBakFun();  //基准初始化
(void)BuildDayOfMonth(THIS_YEAR);
//(void)testPrintDaysByWeek(THIS_YEAR);
//初始化写文件
if (!g_fOutFile)
{
  cout << "Open file" << pszOutFile << "Failed!" << endl;
}
char szDateFormat[128] = {0};
//打印全年排班表
for(int iWeek = 1; iWeek <= MAX_WEEKS_CNT; ++iWeek)
{
  print_n_char(STARBAR, 28);
  sprintf_s(szDateFormat, " %d 年 第 %d 周", THIS_YEAR, iWeek);
  cout << szDateFormat;
  g_fOutFile << szDateFormat;
  print_n_char(STARBAR, 28);
  cout << endl;
  g_fOutFile << endl;
  //逐月份排班
  (void)CurWeekWorkOrder(iWeek - 1);
  (void)PrintCurWorkTable(iWeek);
   cout << endl << endl;
   g_fOutFile << endl << endl;
}
(void)ReleaseDaysVector();
g_fOutFile.close();
getchar();
return 0;
}

7、结束语

1）该类问题相对简单，实现中细节的逻辑比较复杂，在纸上模拟把程序多跑几遍，理顺逻辑很重要。

2）规律是突破口，其他都是辅助完成。

3）反复测试，对每个接口对写对应Demo测试接口。

2015-6-6  pm18:09 思于家中床前,耗时9h

作者：铭毅天下

转载请标明出处，原文地址：http://blog.csdn.net/laoyang360/article/details/46390293

如果感觉本文对您有帮助，请点击‘顶’支持一下，您的支持是我坚持写作最大的动力，谢谢！

时间： 2024-07-29 07:03:28

c++实现医院检验科排班程序的相关文章

适配不同大小浏览器——固定排班

此文介绍的是缩小浏览器,排班不随浏览器窗口大小变化,如果需要排班随浏览器变化,使用bootstrap会更好,今天要介绍的是固定排班 加入JS代码: <script language="javascript"> function readyPage() { if (screen.width >= 1600){ $(".content_container").width(1600); } else if ((screen.width >= 140

排班管理

首先是action类型 1 package com.honghailt.dataextracter.web; 2 3 import java.util.ArrayList; 4 import java.util.Date; 5 import java.util.LinkedHashMap; 6 import java.util.List; 7 import java.util.Map; 8 9 import org.springframework.beans.factory.annotation

使用SQL语句使数据从坚向排列转化成横向排列(排班表)

知识重点: 1.extract(day from schedule01::timestamp)=13 Extract 属于 SQL 的 DML(即数据库管理语言)函数,同样,InterBase 也支持 Extract,它主要用于从一个日期或时间型的字段内抽取年.月.日.时.分.秒数据,因此,它支持其关健字 YEAR.MONTH.DAY.HOUR.MINUTE.SECOND.WEEKDAY.YEARDAY. Extract 的使用语法为:  EXTRACT(关健字 FROM 日期或时间型字段) 如

【算法】基于优先级的排班算法实现

场景:在大学的里,有不少社团组织会要组织中的成员值班,当然这个值班时间是学生无课的时间才会被安排值班. 假设现有如下需求:一天中有3个时间段要有人值班,每周周一到周五都要值班,就是共有15个值班段,每个时间段值班的人都不一样,现有40个学生,要求根据这些学生的无课表情况安排值班,要求每个值班段必须有两个人,每个人一周只值班一次(如果某一值班段只有一人无课,那该值班段就只能一人值班). 小插一题,做一排列组合题: 有10个相同的糖果,颁给3个小人,要求每个人至少有2个糖果,问共有多少种分法? (自

自动排班系统2.0（基于网络流实现的排班系统，附详细注解）

第一版链接:http://blog.csdn.net/david_jett/article/details/44928667 更新说明: 将输入优化了下,不必再输入干部数和总班数,比较排序部分采用了冒泡排序. 代码: #include <iostream> #include <cstdio> #include <queue> #include <string.h> #include <vector> #include <string>

VOLAB关于医院检验科的设计理念

随着社会科技日新月异进步,大量先进自动化仪器设备在实验室得到广泛应用,加上实验室规范化管理的要求,一些医院原有的VOLAB实验室为适应新形势发展,纷纷对实验室进行改建或新建,努力打造空间合理化.管理规范化.信息现代化的VOLAB医院实验室设计. 医院检验科空间独立.面积扩大,医院就不断让检验人员参与VOLAB实验室的空间策划. 室内布置:为方便工作和仪器维修,在大型VOLAB实验室中,采取房屋中间摆设大型和主要仪器设备的办法,这不仅便于仪器工作时散热.故障维修,而且便于清洁卫生.标本处理.分配.

留言板排班定时任务

package com.paic.pad.info.monitor.res.biz.services.impl; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Date; import java.util.List; import java.util.Map; import org.apache.commons.lang.StringUtils; import org.apache.

排班知识点

1.Sql中getDate()在查询语句中的用法 select * FROM V_MANAGERPLAN where (SEAT_ID in (45,46)) and (GETDATE() between BeginTime and EndTime) order by Shift_sortid,seatSort 2.日期加星期(示例:2017-12-22 星期五) <span class="sWeek"> <%=DateTime.Now.ToString("

不一样的Office 365之 —— 使用StaffHub管理你的排班

通过之前的介绍相信各位已经知道,Office 365里不仅仅只有Exchange, S4B以及SharePoint,好包括了许许多多能帮助我们的功能和组件,包括这次要介绍的staffhub,staffhub也是属于在Office 365里默默无闻的组件之一,但是如果在你的企业内部经常需要排班的话,那么staffhub可以很好地帮你把你的排班计划管理起来 StaffHub属于比较专业的应用,因此也不是在每个O365订阅中都可以使用的,详情可以参考下表 下边来直接介绍下使用的方法,首先登陆O365,