精华内容
下载资源
问答
  • 另外,称重传感器灵敏度、最大分度、最小检定分度值等也是传感器选用必须考虑指标。 压力传感器是工业实践最为常用一种传感器,普通压力传感器输出为模拟信号,模拟信号是指信息参数给定范围内表现...
  • 设计一个算法,对给定一个整型mxn矩阵A,统计这个矩阵具有下列特征元素个并输出它们坐标及数值:它们既是所在行中的最小值,又是所在列中的最小值;或者它们既是所在行中的最大值,又是所在列中的最大值。...

    题目

    设计一个算法,对给定的一个整型mxn矩阵A,统计这个矩阵中具有下列特征的元素个数并输出它们的坐标及数值:它们既是所在行中的最小值,又是所在列中的最小值;或者它们既是所在行中的最大值,又是所在列中的最大值。假设矩阵中元素各不相同,要求结果在处理过程中用输出语句输出。

    分析

    即只需要找出某行上的最小值(最大值),然后判断其是否为对应列的上的最小值(最大值)即可。

    代码

    核心代码如下:

    /* 获取矩阵A中既是所在行最大值,又是所在列最大值的数字的数目、值、行下标和列下标 */
    /* A[][MAXSIZE]指的是矩阵;m指的是矩阵的行数;n指的是矩阵的列数 */
    void findMax(int A[][MAXSIZE],int m,int n){
    	int rowMax;
    	int count=0;// 计数器,记录既是所在行最大值又是所在列最大值的数字的数目 
    	for(int i=0;i<m;i++){// 遍历行 
    		rowMax=A[i][0];// 将每行第一个数赋予为所在行最大值 
    		int x=i,y=0;// 记录行最大值的行下标和列下标 
    		for(int j=0;j<n;j++){// 遍历列 
    			if(A[i][j]>rowMax){// 判断该行的所有元素是否大于设定的rowMax 
    				rowMax=A[i][j];// 如果是,则将A[i][j]赋予给rowMax 
    				x=i;// 保存行下标 
    				y=j;// 保存列下标 
    			}
    		}
    		int temp=rowMax;// 保存行最大值 
    		for(int q=0;q<m;q++){// 遍历行 
    			if(A[q][y]>rowMax){// 判断行最大值是不是所在列的最大值 
    				rowMax=A[q][y];// 如果所在列有值比行最大值大,则将其赋给行最大值 
    			}
    		}
    		if(temp==rowMax){// 故判断temp(保存的行最大值)和比较所在列后的rowMax是否相等,如果相等则证明rowMax既是所在行的最大值也是所在列的最大值 
    			count++;// 计数器加1 
    			printf("%d,[%d,%d]\n",temp,x,y);// 大于值,及其行下标和列下标 
    		}
    	}
    	printf("既是所在行最大值又是所在列最大值的元素个数为:%d\n",count);// 打印个数 
    }
    
    /* 获取矩阵A中既是所在行最小值,又是所在列最小值的数字的数目、值、行下标和列下标 */
    /* A[][MAXSIZE]指的是矩阵;m指的是矩阵的行数;n指的是矩阵的列数 */
    void findMin(int A[][MAXSIZE],int m,int n){
    	int rowMin;
    	int count=0;// 计数器,记录既是所在行最小值又是所在列最小值的数字的数目 
    	for(int i=0;i<m;i++){// 遍历行 
    		rowMin=A[i][0];// 将每行第一个数赋予为所在行最小值 
    		int x=i,y=0;// 记录行最小值的行下标和列下标
    		for(int j=0;j<n;j++){// 遍历列 
    			if(A[i][j]<rowMin){// 判断该行的所有元素是否小于设定的rowMin 
    				rowMin=A[i][j];// 如果是,则将A[i][j]赋予给rowMin
    				x=i;// 保存行下标 
    				y=j;// 保存列下标 
    			}
    		}
    		
    		int temp=rowMin;// 保存行最小值 
    		for(int q=0;q<m;q++){// 遍历行 
    			if(A[q][y]<rowMin){// 判断行最小值是不是所在列的最小值 
    				rowMin=A[q][y];// 如果所在列有值比行最小值小,则将其赋给行最小值 
    			}
    		}
    		if(temp==rowMin){// 故判断temp(保存的行最小值)和比较所在列后的rowMin是否相等,如果相等则证明rowMax既是所在行的最大值也是所在列的最大值 
    			count++;// 计数器加1 
    			printf("%d,[%d,%d]\n",temp,x,y);// 小于值,及其行下标和列下标 
    		}
    	}
    	printf("既是所在行最小值又是所在列最小值的元素个数为:%d\n",count);// 打印个数
    }

    完整代码如下:

    #include<stdio.h>
    
    #define MAXSIZE 20
    /* 5.取矩阵A中既是所在行最大值,又是所在列最大值的数字的数目、值、行下标和列下标 */ 
    
    /* 打印矩阵 */
    /* A[][MAXSIZE]指的是矩阵;m指的是矩阵的行数;n指的是矩阵的列数 */ 
    void printMat(int A[][MAXSIZE],int m,int n){
    	for(int i=0;i<m;i++){
    		for(int j=0;j<n;j++){
    			printf("%d\t",A[i][j]);
    		}
    		printf("\n");
    	}
    }
    
    /* 获取矩阵A中既是所在行最大值,又是所在列最大值的数字的数目、值、行下标和列下标 */
    /* A[][MAXSIZE]指的是矩阵;m指的是矩阵的行数;n指的是矩阵的列数 */
    void findMax(int A[][MAXSIZE],int m,int n){
    	int rowMax;
    	int count=0;// 计数器,记录既是所在行最大值又是所在列最大值的数字的数目 
    	for(int i=0;i<m;i++){// 遍历行 
    		rowMax=A[i][0];// 将每行第一个数赋予为所在行最大值 
    		int x=i,y=0;// 记录行最大值的行下标和列下标 
    		for(int j=0;j<n;j++){// 遍历列 
    			if(A[i][j]>rowMax){// 判断该行的所有元素是否大于设定的rowMax 
    				rowMax=A[i][j];// 如果是,则将A[i][j]赋予给rowMax 
    				x=i;// 保存行下标 
    				y=j;// 保存列下标 
    			}
    		}
    		int temp=rowMax;// 保存行最大值 
    		for(int q=0;q<m;q++){// 遍历行 
    			if(A[q][y]>rowMax){// 判断行最大值是不是所在列的最大值 
    				rowMax=A[q][y];// 如果所在列有值比行最大值大,则将其赋给行最大值 
    			}
    		}
    		if(temp==rowMax){// 故判断temp(保存的行最大值)和比较所在列后的rowMax是否相等,如果相等则证明rowMax既是所在行的最大值也是所在列的最大值 
    			count++;// 计数器加1 
    			printf("%d,[%d,%d]\n",temp,x,y);// 大于值,及其行下标和列下标 
    		}
    	}
    	printf("既是所在行最大值又是所在列最大值的元素个数为:%d\n",count);// 打印个数 
    }
    
    /* 获取矩阵A中既是所在行最小值,又是所在列最小值的数字的数目、值、行下标和列下标 */
    /* A[][MAXSIZE]指的是矩阵;m指的是矩阵的行数;n指的是矩阵的列数 */
    void findMin(int A[][MAXSIZE],int m,int n){
    	int rowMin;
    	int count=0;// 计数器,记录既是所在行最小值又是所在列最小值的数字的数目 
    	for(int i=0;i<m;i++){// 遍历行 
    		rowMin=A[i][0];// 将每行第一个数赋予为所在行最小值 
    		int x=i,y=0;// 记录行最小值的行下标和列下标
    		for(int j=0;j<n;j++){// 遍历列 
    			if(A[i][j]<rowMin){// 判断该行的所有元素是否小于设定的rowMin 
    				rowMin=A[i][j];// 如果是,则将A[i][j]赋予给rowMin
    				x=i;// 保存行下标 
    				y=j;// 保存列下标 
    			}
    		}
    		
    		int temp=rowMin;// 保存行最小值 
    		for(int q=0;q<m;q++){// 遍历行 
    			if(A[q][y]<rowMin){// 判断行最小值是不是所在列的最小值 
    				rowMin=A[q][y];// 如果所在列有值比行最小值小,则将其赋给行最小值 
    			}
    		}
    		if(temp==rowMin){// 故判断temp(保存的行最小值)和比较所在列后的rowMin是否相等,如果相等则证明rowMax既是所在行的最大值也是所在列的最大值 
    			count++;// 计数器加1 
    			printf("%d,[%d,%d]\n",temp,x,y);// 小于值,及其行下标和列下标 
    		}
    	}
    	printf("既是所在行最小值又是所在列最小值的元素个数为:%d\n",count);// 打印个数
    }
    
    int main(){
    	int A[][MAXSIZE]={
    			{1,2,3},
    			{8,5,6},
    			{7,8,9}
    			};
    	int m=3,n=3;
    	printMat(A,m,n);
    	
    	findMax(A,m,n);
    	findMin(A,m,n); 
    			
    	return 0;
    }

    运行结果如下:

    展开全文
  • 并确保同一事务处理种对相同数据的两次查询看到的是相同的值。 值范围: TRUE | FALSE 默认值: FALSE row_locking: 说明: 指定表已更新或正在更新时是否获取行锁。如果设置为 ALWAYS, 只有表被更新后才获取...
  • 我使用的是Anaconde+cuda10.1+Cudnn+TensorFlow2.1.0+Pytorch1.7.1+Pycharm(python3.6) 本人是机器学习初学者,想跑一个猫狗大战练练手,遇到了下列问题: ...
  • 3. 8086,逻辑地址、偏移地址、物理地址分别指的是什么?具体说明。 4. 什么是硬件中断和软件中断?PC机两者的处理过程有什么不同? 六、综合应用题(每题10分,共20 分) 现有16K×1位的动态...
  • 本课题电路原理图应用了许多电容,因而此介绍一下电容一些作用。 1.应用于电源电路,实现滤波、旁路、去藕和储能方面电容作用,下面分类详细述之: 1)滤波 滤波是电容作用很重要一部分。几乎...
  • DBX260中文说明书

    2013-04-24 11:07:35
    每一个图指示的是每一个FX 钮的功能,及其每个操作菜单指导用户的能力。 上一页(PREVIOUS 260GE)-翻至当前所选效果菜单的上一页。 下一页(NEXT 260GE)-翻至当前所有选效果菜单的下一页。 EQ-选择EQ效果菜单...
  • 2004-2010软考程序员真题

    热门讨论 2012-09-27 12:33:00
     23、下列四个不同数制表示的数中数值最大的是  A)二进制数11011101 B)八进制数334 C)十进制数219 D)十六进制数DA  24、设WlndowS 98桌面上已经有某应用程序的图标,要运行该程序,可以  A)用鼠标左键单击该...
  • (4)下列 4种不同数制表示的数中数值最大的一个是 A)八进制数 110 B)十进制数 71 C)十六进制数 4A D)二进制数 1001001【答案】:C【解析】:解答这类问题,一般都是将这些非十进制数转换成十进制数,才能...
  • 最短路径优先算法最大可能代价值几乎可以是无限。  如果网络没有发生任何变化,路由器只要周期性地将没有更新路由选择表进行刷新就可以了(周期长短可以从3 0分钟到2个小时)。  链接状态路由协议有...
  • 【ARTS】29 week

    2018-07-29 21:51:14
    涉及一个算法,对给定一个整型m×n矩阵A,统计这个矩阵具有下列特征元素个并输出它们坐标及数值:它们既是所在行中的最小值,又死所在列中的最小值;或者它们既是所在行中的最大值,又是所在列中的最大值...

    Algorithm

    题目描述:

    涉及一个算法,对给定的一个整型m×n矩阵A,统计这个矩阵中具有下列特征的元素个数并输出它们的坐标及数值:它们既是所在行中的最小值,又死所在列中的最小值;或者它们既是所在行中的最大值,又是所在列中的最大值。假设矩阵中元素各不相同,要求结果在处理过程中用输出语句输出。

    解题思路:

    需要找出某行上的最小值(最大值),然后判断其是否为对应列上的最小值(最大值),若是则输出。

    思路不是很复杂,但是过程看着比较繁琐,比较考研自己的逻辑能力

    下面给出最普遍的做法的C++实现

    
    
    void printmin(int A[][maxSize], int m, int n){
        int i, j, k, min, minj;
        //用minj来记录第i行上最小值的列号
        // min来记录当前行的最小值
        int flag; //用它来进行标注,当前元素是否符合输出的标准。
        for(i = 0; i < m; ++i){
            //找出第i行上的最小值,列号为minj
            min = A[i][0];
            minj = 0;
            for(j = 1; j<n; ++j){
                if(A[i][j]<min){
                    min = A[i][j];
                    minj = j;
    
                }
            }
            //进行到此时已经找出了本行最小的元素,并且已经记下了列数,但是还有个问题就是要验证一下这个元素是不是在本列也是最小,如果是,那么符合输出标准,如何不是,那么不符合,继续扫描下一行。
    
            flag = 1;
            for(k=0;k<m;++k){   //判断min是否为minj列上的最小值
                if(min>A[k][minj]){
                    flag = 0;
                    break;
                }
            }
            if(flag)
                cout<<min<<",["<<i<<","<<minj<<"]"<<"  ";
            //打印最小值,其格式为min, [i,minj]
    
        }
        cout <<endl;
    
    }
    
    
    void printmax(int A[][maxSize], int m, int n){
        //做法和上面是差不多的,其实可以放到一个循环里,只不过稍稍有点乱,理清一下思路再写就好啦。
    
        int i,j,k,max,maxj;
        int flag;
        for(i=0;i<m;i++){
            max = A[i][0];
            maxj=0;
            for(j=1;j<n;++j)
                if(A[i][j]>max)
                {
                    max = A[i][j];
                    maxj = j;
                }
            flag = 1;
            for(k=0;k<m;++k)
                if(max<A[k][maxj]){
                flag = 0;
                break;
            }
            if(flag)
                cout << max << ",[" << i << ", " << maxj << "]" << "  ";
            //打印最大值,其格式为max,[i,maxj]
    
        }
        cout <<endl;
    }
    
    
    
    

    Review

    【如何构造一个可以自主思考的机器(第一部分)】How to make an idea machine, part one

    本文内容概要:

    “Give a person a discovery from data, and they will innovate for a day. Teach a person to make discoveries from data, and they will innovate for a lifetime.” — Ancient Data Science Proverb

    we can’t train enough data scientists to meet even today’s demand, and the size and variety of data being collected by organizations is increasing exponentially by the minute. Simply training more data scientists will not solve this problem

    这就是作者提出这个问题的主要原因

    根据过去在数据工作的经验,总结出了the greatest probability of producing a high-impact discovery comes from repeatedly connecting the right person with the right information.这样的经验,在给出两个合适人选后,

    随后提出了三个问题(Three major problems are evident in this process):

    • Time.
    • Limited resources
    • Giving up too early.

    最后总结出”低效流程(通常)的解决方案是自动化”

    并顺便介绍了一下他关于本次命题的第二部分的文章介绍:

    In part two, I provide specific details on how creative software design and architecture can automate a significant portion of the bottlenecks described above — accelerating discovery by an order of magnitude — for any data source. And just like other processes have been improved by automation, it feels like magic.

    这个文章下次再带给大家。

    本文通过五个方面阐述了做一个”木工”为什么会让自己在敲程序方面有所建树,他给出了五个理由:

    • It will teach you utility

    • It will teach you to troubleshoot

    • It will teach you bootstrapping

    • It will teach you progress

    • It will teach you work backwards

    * 本篇文章阐述了作者在通过日常生活中的接触到的”木工”工作,引发的一系列的思考——它和coding很像,并且可以在某方面给你更新的思考 *
    正如文章开头所说的那样

    Many adept technologists agree that being good at one thing is the same as being good at none; “two is one and one is none”. Those who can work across many disciplines — the polymaths — will dominate the future of business.

    关键词:ProgrammingData Science LifeCodeComputer Science

    Technique

    室友发了一个关于”if怪”的图片,表示在交接代码时受不了同事了,然后另一个室友发出了自己的代码,表示自己其实就是一个”if怪”、
    123
    于是我建议他用如下方法
    12334

    就轻松解决了,调用的时候可以直接用key对字典进行索引,这样一来方便向反转前的字典中加入新的keyvalue,方便维护又美观。

    另外关于字典反转,看到了下面几个文章,比较不错,虽然没有用到,但是希望以后有时间回过头看看。

    Python反转/反转映射

    还有这篇文章,也可以进行字典反转,不过相当于我的工作的逆操作(也就是dict2->dict1)

    dictionary - 如何反转具有重复值的字典( python )

    Share

    GitHub Awesome Big Data:大数据框架、论文等实用资源集合。

    非常全的大数据相关资源整理

    其中包括:

    • 关系数据库管理系统(RDBMS)
    • 框架
    • 分布式编程
    • 分布式文件系统
    • 键-值数据模型
    • 图形数据模型
    • Columnar Databases
    • SQL-like processing
    • Data Ingestion
    • Service Programming
    • Scheduling
    • Machine Learning
    • Benchmarking
    • Security
    • System Deployment
    • Applications
    • Search engine and framework
    • MySQL forks and evolutions
    • PostgreSQL forks and evolutions
    • Memcached forks and evolutions
    • Embedded Databases
    • Business Intelligence
    • Data Visualization
    • Internet of things and sensor data
    • Interesting Readings
    • Interesting Papers
    展开全文
  • 2020-02-24 10:33:56
    优先队列 优先队列能完成以下操作 插入一个数值 取出最小(最大值(获取数值,并弹出/删除) ...若设二叉树深度为h,除了第h层以外,其他各层结点数都达到最大,第h层所有节点都连续集中左边。 ...

    • 堆总是满足下列性质

    堆中某个结点的值总是不大于(或不小于)其父节点的值
    堆总是一棵完全二叉树

    • 完全二叉树

    若设二叉树的深度为h,除了第h层以外,其他各层的结点数都达到最大个数,第h层所有的节点都连续集中在左边。

    • 关于堆,最重要的操作是插入(push),和弹出(pop),他们的算法复杂度都是O(logn)。(以最小堆为例)
    • 对于插入来说,首先在堆的末尾插入该数值,然后不断向上提升直到没有大小颠倒为止。
    • 对于删除来说,首先删除最小值,其次将末尾结点的值复制到根结点上,然后不断向下交换直到没有大小颠倒为止。
    • 对于二叉树,除了使用链表以外,还可以使用数组,设某结点的数组下标为n,则其左子结点的下标为2n+1,其右子结点的下标为2n+2。
    • 下面是用数组实现最小堆的插入和删除操作的代码
    int heap[MAX_N], sz = 0;	//声明堆数组,结点个数
    void push(int x){
    	int i = sz++;	//首先获取自己结点的编号
    	while (i > 0){
    		int p = (i - 1) / 2;	//获取父结点位置编号
    		if (heap[p] <= x) break;	//如果大小没有颠倒,退出
    		//交换(将父结点的值赋给自己)
    		heap[i] = heap[p];	
    		i = p;
    	}
    	heap[i] = x;	//最后将要插入的值放入找出的位置
    }
    int pop(){
    	//把根结点(最小值)返回
    	int ret = heap[0];
    	int x = heap[--sz];	//要提到根的数值(最后一位)
    	int i = 0;
    	while(i * 2 + 1 < sz){	//从根结点开始向下比较
    		//比较儿子的值,选择小的那个
    		int left = 2 * i + 1, right = 2 * i + 2;
    		if (right < sz && heap[right] < heap[left]) left = right;
    		//如果没有大小颠倒就退出
    		if (heap[left] >= x) break;
    		//把儿子的值提上来
    		heap[i] = heap[left];
    		i = left; 
    	}
    	heap[i] = x;
    	return ret;
    }
    

    另一种理解方法

    • 其实堆中最本质的操作只有两种,一种是上移,另一种是下移。而为了实现堆的操作,只需要进行相应的上移和下移操作,就可以实现堆的基本功能
      假设上移操作为up,下移操作为down
    1. push:将值插入到尾结点,然后up尾结点
    2. pop:将尾节点数值复制到根节点上,删除尾节点,然后down根节点
    3. top:访问根节点heap[1]
    4. 删除某个值:将尾节点的值复制到当前节点,删除当前节点,对当前节点进行up和down操作
    5. 修改某个值:修改当前节点的值,对当前节点进行up和down操作
    • 4和5为用数组实现的堆比stl提供的优先队列所多的功能,为了不人工进行比较大小操作,所以同时进行上移和下移操作,因为两种操作只会进行一个,所以时间复杂度没有增加
    int heap[N], sz = 0;
    void down(int u){
    	int t = u;
    	//判断两个子节点是否在堆里,并且找出本节点与两个子节点中的最小值
    	if (2 * u <= sz && heap[t] > heap[2*u]) t = 2 * u;
    	if (2 * u + 1 <= sz && heap[t] > heap[2*u+1]) t = 2 * u + 1;
    	//若找出的最小值不是本节点,则交换与最小节点的位置,并递归调用
    	if (u != t) swap(heap[u], heap[t]), down(t);
    }
    
    //up同理
    void up(int x) {
    	//若为根节点,返回
    	if (x <= 1) return;
    	//每次与父节点相比,若比父节点小,则交换并递归父节点
    	if (heap[x] < heap[x/2]) swap(heap[x], heap[x/2]), up(x/2);
    }
    

    返回目录

    展开全文
  •  ③一个固定数值 ④数码数据中的不同位置 5.相联存贮器是按( )进行寻址存贮器。 ① 地址方式 ② 堆栈方式 ③ 内容指定方式 ④ 地址方式与堆栈方式 6.总线地址线作用是( )。。。。。。。。。。。...
  • (29)某公司传输数据过程为了安全要对数据进行加密,若传递的是四位的整数,对其进行加密的规则为:每位数字都加上5,然后用和除以10的余数代替该数字,再将第一位和第四位交换,第二位和第三位交换。...
  • 1.下列程序运行无问题,但输入时不宜输入空值,所有数值应大于零(符合实际),并且,进程应输入整数,其余数值可为小数。 2.SJFyuFCFS最大区别在于排序,开始结束时间计算也存在一定差异,其余基本相同 3....

    参考文章,当初写出这篇文章全靠它提供思路和基础代码框架
    请注意:
    下列程序运行无问题,但在输入时不宜输入空值,所有数值应大于或等于零(符合实际),并且,进程数应输入整数,其余数值可为小数。

    ***以下均为非抢占式 ***

    先来先服务

    pcb = []  # 生成列表,存放信息
    n = int(input("请输入进程数:"))  # 进程数输入
    
    
    def inpcb():  # 相关数据输入与存放
        i = 0
        while (i < n):
            NAME = input("请输入第%d个进程名:" % (i + 1))
            ARRIVE = float(input("请输入到达时间:"))
            SERVICE = float(input("请输入服务时长:"))
            pcb.append([NAME, ARRIVE, SERVICE, 0, 0, 0, 0])
            # 名字,到达时间,服务时长,开始,结束,平均周转,平均带权周转
            i = i + 1
    
    
    def FCFS():
        pcb.sort(key=lambda x: x[1], reverse=False)
        for i in range(n):  # 计算开始结束时刻
            if (i == 0):
                pcb[i][3] = pcb[i][1]
                pcb[i][4] = pcb[i][1] + pcb[i][2]
            elif (i > 0 and pcb[i - 1][4] < pcb[i][1]):
                pcb[i][3] = pcb[i][1]
                pcb[i][4] = pcb[i][1] + pcb[i][2]
            else:
                pcb[i][3] = pcb[i - 1][4]
                pcb[i][4] = pcb[i - 1][4] + pcb[i][2]
            i = i + 1
        ZZ = 0
        DZZ = 0
        for i in range(n):  # 计算周转,带权周转时间
            ZZ = float(ZZ + (pcb[i][4] - pcb[i][1]))
            DZZ = float(DZZ + (pcb[i][4] - pcb[i][1]) / (pcb[i][2]))
        print("运行结果:")
        for i in range(n):
            print("时刻:%0.2f 程序名:%s 到达:%0.2f 服务:%0.2f 开始:%0.2f 结束:%0.2f " \
                  % (pcb[i][3], pcb[i][0], pcb[i][1], pcb[i][2], pcb[i][3], pcb[i][4]))
        print("平均周转时间:%0.2f" % (ZZ / n))
        print("平均带权周转时间:%0.2f" % (DZZ / n))
    
    
    if __name__ == '__main__':
        inpcb()
        FCFS()
    
    

    在这里插入图片描述

    短进程优先

    pcb = []
    n = int(input("请输入进程数:"))
    
    
    def inpcb():
        i = 0
        while (i < n):
            NAME = input("请输入第%d个进程名:" % (i + 1))
            ARRIVE = float(input("到达时间:"))
            SERVICE = float(input("服务时间:"))
            pcb.append([NAME, ARRIVE, SERVICE, 0, 0, 0, 0, 0])
        # 名称,到达时间,服务时长,开始时刻,结束时刻,周转时间,带权周转时间,优先级(数值越小越高)
            i = i + 1
    
    
    def SJF():
        pcb.sort(key=lambda x:x[1], reverse=False)
        i = 0
        for i in range(n):
            if (i == 0):
                pcb[i][7] = 0
                pcb[i][3] = pcb[i][1]
                pcb[i][4] = pcb[i][1] + pcb[i][2]
            else:
                if (i>0 and (pcb[i - 1][4] <= pcb[i][1])):
                    pcb[i][7] = i
                    pcb[i][3] = pcb[i][1]
                    pcb[i][4] = pcb[i][1] + pcb[i][2]
                elif(i>0 and (pcb[i - 1][4] >pcb[i][1])):
                    k = i
                    xuhao = 0
                    min = 100000
                    zhongjian=0
                    while(k<n):
                        if ((pcb[i - 1][4] > pcb[k][1]) and (min > pcb[k][2])):
                            min = pcb[k][2]
                            xuhao = k
                        k = k + 1
                    pcb[xuhao][7] = i
                    zhongjian=pcb[xuhao]
                    pcb[xuhao]=pcb[i]
                    pcb[i]=zhongjian
                    pcb[i][3]=pcb[i-1][4]
                    pcb[i][4]=pcb[i-1][4]+pcb[i][2]
        for i in range(n):
            pcb[i][5]=pcb[i][4]-pcb[i][1]
            pcb[i][6]=float((pcb[i][4]-pcb[i][1])/pcb[i][2])
        ZZ = 0
        DZZ = 0
        for i in range(n):
            ZZ=float(ZZ+pcb[i][5])
            DZZ=float(DZZ+pcb[i][6])
        print("运行结果:")
        for i in range(n):
            print("时刻:%0.2f 程序名:%s 到达:%0.2f 服务:%0.2f 开始:%0.2f 结束:%0.2f 周转:%0.2f 平周转:%0.2f 优先级:%0.2f" \
                      % (pcb[i][3], pcb[i][0], pcb[i][1], pcb[i][2], pcb[i][3], pcb[i][4],pcb[i][5],pcb[i][6],pcb[i][7]))
        print("平均周转时间:%0.2f"%(float(ZZ/n)))
        print("平均带权周转时间:%0.2f" % (float(DZZ / n)))
    
    if __name__ == '__main__':
        inpcb()
        SJF()
    

    在这里插入图片描述

    高响应比HRRN

    pcb = []
    n = int(input("请输入进程数:"))
    
    
    def inpcb():
        i = 0
        while (i < n):
            NAME = input("请输入第%d个进程名:" % (i + 1))
            ARRIVE = float(input("到达时间:"))
            SERVICE = float(input("服务时间:"))
            pcb.append([NAME, ARRIVE, SERVICE, 0, 0, 0, 0, 0])
        # 名称,到达时间,服务时长,开始时刻,结束时刻,周转时间,带权周转时间,优先级(数值越小越高)
            i = i + 1
    
    
    def HRRN():
        i = 0
        # 高响应比调度
    
        pcb.sort(key=lambda x: x[1], reverse=False)
        for i in range(n):
            if (i == 0):
                pcb[i][3] = pcb[i][1]
                pcb[i][4] = pcb[i][1] + pcb[i][2]
                pcb[i][7] = i
                pcb[i][5] = pcb[i][2]
                pcb[i][6] = float((pcb[i][4] - pcb[i][1]) / pcb[i][2])
            elif (i > 0 and (pcb[i - 1][4] < pcb[i][1])):
                pcb[i][3] = pcb[i][1]
                pcb[i][4] = pcb[i][1] + pcb[i][2]
                pcb[i][7] = i
                pcb[i][5] = pcb[i][2]
                pcb[i][6] = float((pcb[i][2])/ pcb[i][2])
            else:
                k = i
                max = 0
                aa = 0
                while(k<n):#此处若为 for k in range(n): 结果异常
                    if ((pcb[i - 1][4] >pcb[k][1]) and ((pcb[i-1][4]-pcb[k][1])+pcb[k][2])/pcb[k][2] > max):
                        max = ((pcb[i-1][4]-pcb[k][1])+pcb[k][2])/pcb[k][2]
                        shu = k
                    k = k + 1
                aa = pcb[shu]
                pcb[shu] = pcb[i]
                pcb[i] = aa
                pcb[i][7] = i
                pcb[i][3] = pcb[i - 1][4]
                pcb[i][4] = pcb[i][3] + pcb[i][2]
                pcb[i][5] = pcb[i][4] - pcb[i][1]
                pcb[i][6] = float((pcb[i][4] - pcb[i][1]) / pcb[i][2])
            i = i + 1
        pcb.sort(key=lambda x: x[7], reverse=False)
        SZZ = 0
        SDZZ = 0
        for i in range(n):
            SZZ = float(SZZ + pcb[i][5])
            SDZZ = float(SDZZ + pcb[i][6])
            i = i + 1
        print("运行结果:")
        for i in range(n):
            print("时刻:%0.2f 进程名:%s 到达:%0.2f 占用:%0.2f 开始:%0.2f 结束:%0.2f 周转:%0.2f 带权周转:%0.2f 优先级:%d" \
                  % (pcb[i][3], pcb[i][0], pcb[i][1], pcb[i][2], pcb[i][3], pcb[i][4], pcb[i][5], pcb[i][6], pcb[i][7]))
            i = i + 1
        print("平均周转时间:%0.2f" % (SZZ / n))
        print("平均带权周转时间:%0.2f" % (SDZZ / n))
    
    
    if __name__ == '__main__':
        inpcb()
        HRRN()
    

    在这里插入图片描述

    合成程序

    pcb = []
    n = int(input("请输入进程数:"))
    
    
    def inpcb():
        i = 0
        while (i < n):
            NAME = input("请输入第%d个进程名:" % (i + 1))
            ARRIVE = float(input("请输入到达时间:"))
            SERVICE = float(input("请输入运行时长:"))
            pcb.append([NAME, ARRIVE, SERVICE, 0, 0, 0, 0, 0])
            # 进程名,到达时刻,运行时长,开始时刻,结束时刻,周转时长,带权周转时长,优先级
            # 数字越小,优先级越高
            i = i + 1
    
    
    def FCFS():  # 先来先服务
        i = 0
        pcb.sort(key=lambda x: x[1], reverse=False)
        for i in range(n):
            if (i == 0):
                pcb[i][3] = pcb[i][1]
                pcb[i][4] = pcb[i][1] + pcb[i][2]
                pcb[i][7] = 0
                pcb[i][5] = pcb[i][4] - pcb[i][1]
                pcb[i][6] = float((pcb[i][4] - pcb[i][1]) / pcb[i][2])
            elif (i > 0 and pcb[i - 1][4] < pcb[i][1]):
                pcb[i][3] = pcb[i][1]
                pcb[i][4] = pcb[i][1] + pcb[i][2]
                pcb[i][7] = i
                pcb[i][5] = pcb[i][4] - pcb[i][1]
                pcb[i][6] = float((pcb[i][4] - pcb[i][1]) / pcb[i][2])
            else:
                pcb[i][3] = pcb[i - 1][4]
                pcb[i][4] = pcb[i][3] + pcb[i][2]
                pcb[i][7] = i
                pcb[i][5] = pcb[i][4] - pcb[i][1]
                pcb[i][6] = float((pcb[i][4] - pcb[i][1]) / pcb[i][2])
            i = i + 1
        pcb.sort(key=lambda x: x[7], reverse=False)
        SZZ = 0
        SDZZ = 0
        for i in range(n):
            SZZ = float(SZZ + pcb[i][5])
            SDZZ = float(SDZZ + pcb[i][6])
            i = i + 1
        print("运行结果:")
        for i in range(n):
            print("时刻:%0.2f 进程名:%s 到达:%0.2f 占用:%0.2f 开始:%0.2f 结束:%0.2f 周转:%0.2f 带权周转:%0.2f 优先级:%d" \
                  % (pcb[i][3], pcb[i][0], pcb[i][1], pcb[i][2], pcb[i][3], pcb[i][4], pcb[i][5], pcb[i][6], pcb[i][7]))
            i = i + 1
        print("平均周转时间:%0.2f" % (SZZ / n))
        print("平均带权周转时间:%0.2f" % (SDZZ / n))
    
    
    def SJF():
        i = 0
        # 短进程优先
    
        pcb.sort(key=lambda x: x[1], reverse=False)
        for i in range(n):
            if (i == 0):
                pcb[i][3] = pcb[i][1]
                pcb[i][4] = pcb[i][1] + pcb[i][2]
                pcb[i][7] = i
                pcb[i][5] = pcb[i][2]
                pcb[i][6] = float((pcb[i][4] - pcb[i][1]) / pcb[i][2])
            elif (i > 0 and (pcb[i - 1][4] < pcb[i][1])):
                pcb[i][3] = pcb[i][1]
                pcb[i][4] = pcb[i][1] + pcb[i][2]
                pcb[i][7] = i
                pcb[i][5] = pcb[i][2]
                pcb[i][6] = float((pcb[i][2])/ pcb[i][2])
            else:
                k = i
                min = 10000
                aa = 0
                while(k<n):#此处若为 for k in range(n): 结果异常
                    if ((pcb[i - 1][4] >pcb[k][1]) and (pcb[k][2] < min)):
                        min = pcb[k][2]
                        shu = k
                    k = k + 1
                aa = pcb[shu]
                pcb[shu] = pcb[i]
                pcb[i] = aa
                pcb[i][7] = i
                pcb[i][3] = pcb[i - 1][4]
                pcb[i][4] = pcb[i][3] + pcb[i][2]
                pcb[i][5] = pcb[i][4] - pcb[i][1]
                pcb[i][6] = float((pcb[i][4] - pcb[i][1]) / pcb[i][2])
            i = i + 1
        pcb.sort(key=lambda x: x[7], reverse=False)
        SZZ = 0
        SDZZ = 0
        for i in range(n):
            SZZ = float(SZZ + pcb[i][5])
            SDZZ = float(SDZZ + pcb[i][6])
            i = i + 1
        print("运行结果:")
        for i in range(n):
            print("时刻:%0.2f 进程名:%s 到达:%0.2f 占用:%0.2f 开始:%0.2f 结束:%0.2f 周转:%0.2f 带权周转:%0.2f 优先级:%d" \
                  % (pcb[i][3], pcb[i][0], pcb[i][1], pcb[i][2], pcb[i][3], pcb[i][4], pcb[i][5], pcb[i][6], pcb[i][7]))
            i = i + 1
        print("平均周转时间:%0.2f" % (SZZ / n))
        print("平均带权周转时间:%0.2f" % (SDZZ / n))
    
    def HRRN():
        i = 0
        # 高响应比调度
    
        pcb.sort(key=lambda x: x[1], reverse=False)
        for i in range(n):
            if (i == 0):
                pcb[i][3] = pcb[i][1]
                pcb[i][4] = pcb[i][1] + pcb[i][2]
                pcb[i][7] = i
                pcb[i][5] = pcb[i][2]
                pcb[i][6] = float((pcb[i][4] - pcb[i][1]) / pcb[i][2])
            elif (i > 0 and (pcb[i - 1][4] < pcb[i][1])):
                pcb[i][3] = pcb[i][1]
                pcb[i][4] = pcb[i][1] + pcb[i][2]
                pcb[i][7] = i
                pcb[i][5] = pcb[i][2]
                pcb[i][6] = float((pcb[i][2])/ pcb[i][2])
            else:
                k = i
                max = 0
                aa = 0
                while(k<n):#此处若为 for k in range(n): 结果异常
                    if ((pcb[i - 1][4] >pcb[k][1]) and ((pcb[i-1][4]-pcb[k][1])+pcb[k][2])/pcb[k][2] > max):
                        max = ((pcb[i-1][4]-pcb[k][1])+pcb[k][2])/pcb[k][2]
                        shu = k
                    k = k + 1
                aa = pcb[shu]
                pcb[shu] = pcb[i]
                pcb[i] = aa
                pcb[i][7] = i
                pcb[i][3] = pcb[i - 1][4]
                pcb[i][4] = pcb[i][3] + pcb[i][2]
                pcb[i][5] = pcb[i][4] - pcb[i][1]
                pcb[i][6] = float((pcb[i][4] - pcb[i][1]) / pcb[i][2])
            i = i + 1
        pcb.sort(key=lambda x: x[7], reverse=False)
        SZZ = 0
        SDZZ = 0
        for i in range(n):
            SZZ = float(SZZ + pcb[i][5])
            SDZZ = float(SDZZ + pcb[i][6])
            i = i + 1
        print("运行结果:")
        for i in range(n):
            print("时刻:%0.2f 进程名:%s 到达:%0.2f 占用:%0.2f 开始:%0.2f 结束:%0.2f 周转:%0.2f 带权周转:%0.2f 优先级:%d" \
                  % (pcb[i][3], pcb[i][0], pcb[i][1], pcb[i][2], pcb[i][3], pcb[i][4], pcb[i][5], pcb[i][6], pcb[i][7]))
            i = i + 1
        print("平均周转时间:%0.2f" % (SZZ / n))
        print("平均带权周转时间:%0.2f" % (SDZZ / n))
    
    
    
    if __name__ == '__main__':
        inpcb()
        m = 1
        while (m == 1):
            a = int(input("请输入数字1或2或3【1运行FCFS,2运行SJF,3运行HRRN】:"))
            if (a == 1):
                FCFS()
            elif (a == 2):
                SJF()
            elif(a==3):
                HRRN()
            else:
                print("请输入1或2!运行结束!")
                m = 0
    

    `## 数据同上,此处只展现结果在这里插入图片描述

    展开全文
  • 会计理论考试题

    2012-03-07 21:04:40
    15.下列软件不属于系统软件的是 ___D__ 。 A、Windows B、Visual FoxPro C、UCDOS D、WPS97 16.应用软件计算机普及起重要作用,下列 ___D__ 都属于应用软件。 A、WPS、DOS、Lotusl-2-3 B、WIndows95、Word、...
  •  15、说明:选择每一组b值相同的数据对应的a最大的记录的所有信息(类似这样的用法可以用于论坛每月排行榜,每月热销产品分析,按科目成绩排名,等等.) select a,b,c from tablename ta where a=(select max(a) ...
  • WinRAR_4.0.exe

    2011-02-04 11:34:33
    例如, UNIX 下列命令行可以被添加到你配置: RAR='-s -md1024' export RAR RAR 将使用这个字符串作为命令行默认参数,并将使用 1024KB 字典大小来创建 “固实”压缩文件。 RAR 控制选项使用...
  • (4)PING一个IP时,返回结果中的TTL数值有些240-255之间,有些110-130之间,有些50-65之间,这些不同值相差很大,是什么原因?根据这些不同的数值能大致判断什么? 4. tracert 该工具类似UNIX中的...
  • javascript入门笔记

    2018-05-15 15:01:07
    Javascript,简称为 JS,是一款能够运行 JS解释器/引擎 中的脚本语言 JS解释器/引擎 是JS运行环境: 1、独立安装JS解释器 - NodeJS 2、嵌入浏览器中的JS解释器 JS发展史: 1、1992年 Nombas 开发...
  • 6 8086CPU,对时钟周期、指令周期和总线周期的长短排序,正确的是( )。 A:当前正在执行的指令与数据都必须存在主存储器内,否则处理器不能进行处理 B:总线周期>指令周期>时钟周期 C:时钟周期>指令周期>...
  • 法使用了 1024 位的RSA算法,1024 位指的是公钥【密钥】的长度 公开密钥密码体制”的含义是【B 】。 A、将所有密钥公开 B、将私有密钥公开,公开密钥保密 C、将公开密钥公开,私有密钥保密 D、两个密钥...
  • 我们把管理经济学归入企业管理学的下列两类课程:首先列为“工具”课程,因为它包括了某些经济理论、方法和分析技术,可为以后各门职能课程加以应用作好准备;其次列为综合课程,因为它把各门职能课程结合一起...
  • JAVA面试题最全集

    2010-03-13 13:09:10
    被声明为final变量必须声明时给定初值,而以后引用只能读取,不可修改。被声明为final方法也同样只能使用,不能重载 finally?再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常,...
  • 操作系统实验报告

    2019-01-10 19:24:18
    2. 最大需求矩阵Max,这是一个n×m矩阵,它定义了系统n个进程中的每一个进程对m类资源的最大需求。如果Max(i,j)=k,表示进程i需要Rj类资源的最大数目为k。 3. 分配矩阵Allocation,这是一个n×m矩阵,它...
  • SQL语法大全

    2014-03-30 11:00:11
    MAX(字段名) 取得一个表格栏最大的值 MIN(字段名) 取得一个表格栏最小的值 SUM(字段名) 把数据栏的值相加 引用以上函数的方法: sql="select sum(字段名) as 别名 from 数据表 where 条件表达式" set rs=conn....

空空如也

空空如也

1 2 3 4
收藏数 62
精华内容 24
关键字:

在下列数中数值最大的是