精华内容
下载资源
问答
  • 简单的说:是指系统或组件之间的交互点, 通过这些交互点可以进行数据之间的交互 是数据交互的通道 接口的类型 接口测试分类由于多种,按照范围划分:系统之间的接口和程序内部的接口 系统之间的接口:个内部系统...

    接口介绍
    简单的说:是指系统或组件之间的交互点
    通过这些交互点可以进行数据之间的交互
    是数据交互的通道
    在这里插入图片描述
    接口的类型
    接口测试分类由于多种,按照范围划分:系统之间的接口和程序内部的接口

    系统之间的接口:多个内部系统之间的交互,内部系统与外部系统的交互。
    程序内部的接口:方法与方法之间,模块与模块之间,函数与函数之间。

    在这里插入图片描述
    接口测试
    接口测试主要测试数据的传递,交互,控制管理过程,以及相互的依赖关系。
    接口测试的原理
    模拟客户端发送请求,服务器接收请求后会进行相应的业务处理,并返回响应数据,校验预期数据与返回数据是否一致。
    注意:http请求是使用tcp/ip协议来连接的。(TCP/IP三次握手)

    在这里插入图片描述
    接口测试的特点(重点*面试题)【为什要进行接口测试】

    • 低成本高收益
    • 提前介入测试
    • 可以发现页面操作发现不了的问题
    • 和单元测试相比更贴近用户交互(底层的一个Bug能够引发上层8个左右Bug,接口测试可以实现自动化和持续集成)

    接口测试的实现方式:

    工具:Postman和Jmeter
    代码:Python + Requests + Unittest

    自动化接口测试的概念:
    程序代替人工进行接口测试的过程。

    HTTP协议:
    HTTP协议是一个超文本传输协议,是一个基于请求与响应模式,应用层协议,应用非常广泛的协议。
    七层网络架构:
    物理层,数据链路层,网络层,传输层,会话层,表示层,应用层

    HTTP协议的特点(重点)

    1. 支持客户端和服务器模式
    2. 简单快速:通过URL建立连接和传输数据,而URL结果简单,数据量不大,所以简单快速
    3. 无状态:就是指不会保存状态数据
    4. 无连接:用完就扔,不是不建立连接,而是指建立连接之后处理完数据就会断开连接
    5. 灵活:支持多种类型:json,html,xml

    URL(重点)
    URL:(Unifrom Resource Locator)统一资源定位符,定位互联网中资源的地址,HTTP使用URL来建立连接和传输数据。

    URL的组成部分:
    http://www.baidu.com/s?wd=马云&id=1

    协议部分::“http”,常见的协议有HTTP,HTTPS、FTP等

    域名部分:www.baidu.com,也可以使用IP地址作为域名使用

    端口:端口可以省略,默认端口(HTTP:80,HTTPS:443,FTP:21)

    资源路径:/s 帮助对应服务器中代码,简单的说,就是接口的名称。
    请求参数:查询参数部分:wd=马云&id=1可以允许有多个参数,多个之间用“&”作为分隔符
    请求参数:wd=马云&id=1

    HTTP请求
    组成:
    请求行:是指HTTP报文中,HTTP请求的第一行
    请求头:HTTP请求报文中第一行之后,空行之前
    请求体:HTTP请求报文中空行之后
    请求行

    组成:请求方法,资源,协议和版本
    常用请求方法:
    GET:从服务器获取资源(一项或多项)
    POST:在服务器新建一个资源
    PUT:在服务器更新资源(客户端提供改变后的完整资源)
    DELETE:从服务器删除资源
    其他请求方法(了解):
    HEAD:请求获取由Request-URI所标识的资源的响应消息报头
    TRACE:请求服务器回送收到的请求信息,主要用于测试或诊断
    CONNECT:保留将来使用
    OPTIONS:请求查询服务器的性能,或者查询与资源相关的选项和需

    在这里插入图片描述
    请求行
    POST http://demo.zentao.net/user-login.html HTTP/1.1
    组成:请求方法,资源,协议和版本

    请求方法:Get、Post、Put、Delete

    请求头
    请求头紧接着请求行,请求头部由键值对组成,每行一对。 请求头部通知服务器有关于客户端请求的信息,典型 的请求头有:
    User-Agent:描述浏览器类型
    Accept:客户端可识别的内容类型列表。
    Host:请求的主机名,允许多个域名同处一个IP地址,即虚拟主机。
    Content-Type:text/html; charset=utf-8
    Content-Type:描述请求体中的数据类型

    请求体

    • Get请求没有请求体
    • 经常Post方法中使用请求体
    • 请求体的数据类型有:Json,Text,图片,表单,多媒体
    • 请求体经常与Content-Type和Content-Length结合使用

    HTTP响应
    http响应组成部分:状态行,状态头,状态体
    在这里插入图片描述
    HTTP响应状态行:

    • 协议和版本:HTTP/1.1

    • 状态码:200

    • 1xx:请求已经被接收,需要进一步处理

    • 2xx:成功

    • 3xx:重定向

    • 4xx:客户端错误

    • 5xx:服务端错误

    注意:如果出现了5xx的错误,既有可能是Bug也有可能是服务器环境问题,需要找开发进一步确认。

    • 状态消息:OK
    • HTTP响应头:描述服务器相关信息的数据,可以用来通知客户端怎么处理返回的响应数据

    HTTP响应体:就是指服务器处理之后具体的响应数据,支持Json,Xml,Html,文本,图片等数据

    常用状态码介绍

    200:成功,标准HTTP协议中Get方法

    201:修改或者新增数据成功,对应的请求方法是Post/Put

    204:删除数据成功,对应的请求方法是Delete

    400:客户端语法错误

    401:没有登陆,没有得到权限(令牌错误,用户名或密码错误)

    403:也没有得到授权,比如被防火墙拦截或者白黑名单等

    404:请求资源不存在

    500:服务器错误

    503:服务器错误,过一段时间可能会恢复正常

    接口规范
    思考: 如何让前端开发与后台接口开发人员更好的配合,提高工作效率?
    无规矩不成方圆,制定接口规范
    . 传统接口风格
    对用户进行操作的相关接口,包括增删改查
    在这里插入图片描述
    Restful
    介绍:是指一种软件架构风格,而不是标准,是指一系列设计原则和约束条件
    定义:如果一个架构的设计,符合REST设计原则和约束条件,那么久称为Restful
    REST:是指表现层状态转化:就是指对某种资源数据的增删改查
    RESTful接口特点

    • 请求方式

    • 获取操作:Get

    • 新增操作:Post

    • 修改操作:Put

    • 删除操作:Delete

    • URL

    • 不再是多种多样,URL的定义有特定的标准

    • HTTP响应状态码:

    • Get:200

    • Post:201

    • Put:201

    • Delete:204
      RESTful架构特点

    • 每个URL都是代表一个资源

    • 客户端和服务器之间,传递资源的某种表现形式(比如:传递json,传递图片,传递文件等)

    • 客户端通过Get、Post、Put、Delete四个请求方法,对服务器资源进行操作,改变服务器资源数据的状态。

    • 接口测试最常用的数据类型是Json

    1. 项目环境介绍
      项目介绍
      功能模块:组织管理、员工管理、培训管理、考勤管理、工资管理、绩效管理、劳动合同、招聘管理、福利管理

    技术架构:
    在MySQL + Redis + RabbitMQ这里插入图片描述

    前后端处理流程(前后端分离架构):
    在这里插入图片描述
    技术栈:

    前端:使用Node.js和Vue.js架构开发

    后端:Spring全家桶(Springboot,Springcloud,SpringMVC,SpringData)

    数据库:Mysql+Redis

    消息队列:RabbitMQ

    2.2 技术架构图
    在这里插入图片描述

    5. 接口测试流程(非常重要)
    在这里插入图片描述

    • 需求分析
    • 熟悉需求,确认业务流程和业务依赖关系
    • 接口文档解析
    • 确定每个业务对应的1个或者多个接口(1个业务可以对应多个接口,1个接口也可以对应多个业务,他们是多对多的关系)例如:登陆接口-----/login
    • 解析接口的请求数据和返回数据。
    • 请求数据:HTTP请求结构中的所有数据,请求行,请求头,请求体
    • 返回数据:状态行,响应头,响应体
    • 设计接口测试用例
    • 根据需求和接口文档设计接口测试用例
    • 执行测试
    • 工具执行:Postman和Jmeter
    • 代码执行:Python + Requests + unittest
    • 接口缺陷管理与跟踪
    • 缺陷管理工具:禅道,Jira
    • Bug生命周期(了解)
    • Bug的来源:新写的代码,依赖的包,回归测试产生的,需求产生的,旧版本的bug的
    • 输出接口测试报告
    • 接口自动化和持续集成

    6,接口文档解析

    介绍:接口文档是用来描述接口信息的文档,一般由后端开发人员或者架构师输出;又称为API文档。

    • 为什么要写接口文档
    • 方便前后端开发协调工作,提高工作效率。
    • 方便项目迭代和人员更迭时,后期人员进行维护。
    • 方便测试人员进行接口测试。

    接口文档介绍(了解)

    介绍:接口文档是用来描述接口信息的文档,一般由后端开发人员或者架构师输出;又称为API文档。

    • 为什么要写接口文档
    • 方便前后端开发协调工作,提高工作效率。
    • 方便项目迭代和人员更迭时,后期人员进行维护。
    • 方便测试人员进行接口测试。

    7,接口测试用例设计
    在这里插入图片描述
    接口测试点
    接口测试用例思路:

    • 和手工测试的思路相同,包括使用测试方法论进行测试,比如:等价类、判定表、因果图、流程分析、场景分析、正交分析等

    • 和手工测试不同的地方:

    • 有接口独有的参数测试

    • 正向:必填参数测试,必填+选填的参数组合测试,全部参数测试

    • 反向(异常):

    参数异常:多参,少参,无参,错误参数

    数据错误:数据类型不符,数据长度,数据为空,错误数据

    业务错误数据:根据实际的业务判断错误数据:比如手机号码中,输入不是手机号码的字符串。

    • 多接口测试
    • 多个接口之间有依赖关系时的测试
    • 业务场景测试(功能测试也有)

    单接口测试思路设计

    1,设计接口用例的结构

    ID,模块,用例名称,接口名称,URL,请求方式,请求头,请求参数类型,请求参数,预期结果,实际结果,操作步骤,优先级,前置条件
    设计接口测试点
    根据测试点,结合接口文档描述和需求描述,按照接口用例结构设计接口用例
    注意 :接口用例中的预期结果一般是根据接口文档和需求来确定。但是实际工作中,很多异常场景都需要找开发确认清楚。

    面试题 :一天能写多少个接口测试用例?

    1,熟悉的项目,写的快,可以写一百多条

    2,如果是不熟悉的项目,一天写50-100个也是可以的。

    二、面试题:Get和Post的区别

    1,咱们首先说了2个区别:

    安全性:Get不安全,Post相对安全。但是他们都不安全,需要对敏感信息进行加密,扩展:常见的加密算法有哪些,怎么实现的
    数据量:Get数据量没有Post大

    2,然后咱们百度查询了Get和Post的区别。
    发现网上有更详细的描述,除了我们说的两点外,还增加了2个点
    Get的请求数据和Post请求数据的支持的编码格式不同,Get仅支持ASCII,Post比Get多。

    Get效率比Post效率高

    3,Get和Post的区别肯定不止这4个,具体信息需要大家网上多看多收集

    展开全文
  • 程序是指编译好的二进制文件,存放在磁盘上,并不占用系统资源(系统资源包括CPU、内存、打开的文件、设备、锁…) 进程:是一个抽象的概念,与操作系统原理密切相关。进程是活跃的程序,占用系统资源。在内存中...

    程序和进程

    • 程序:是指编译好的二进制文件,存放在磁盘上,并不占用系统资源(系统资源包括CPU、内存、打开的文件、设备、锁…)
    • 进程:是一个抽象的概念,与操作系统原理密切相关。进程是活跃的程序,占用系统资源。在内存中执行。(程序运行起来之后,产生一个进程)。
    • 那么我们可以形象的将程序比作一个剧本,这个剧本就是一张一张的纸组成的,那么就是进程就要演的戏,一出戏上面包括舞台、演员、灯光、道具等等。同一个剧本可以在多个舞台上同时上演,同样的,同一个程序也可以加载为不同的进程(而且彼此之间互不影响)。
    • 举个例子,在linux终端上同时打开两个终端。他们各自都有一个bash但是彼此的ID却是不同的。

    二:并发的认识

    • 并发:在操作系统中,一个时间段中有多个进程都处于已经启动运行—到-----运行完毕之间的状态。但是呢,任一时刻点上CPU上只有一个进程在运行。
    • 举个例子,现在,我们使用计算机可以边听音乐边聊天边上网。那么我用自己的话来说,意思就是说CPU先运算音乐进程几纳秒,然后停下来在运算聊天几微秒,然后在停下来再运算上网几微秒,由于速度很快,我们肉眼几乎发现不了进程在切换着运行。

    单道程序设计

    • 所有进程一个一个排对执行。若A阻塞,B只能等待,即使CPU处于空闲状态。而在人机交互时阻塞的出现时必然的。所有这种模型在系统资源利用上极其不合理,在计算机发展历史上存在不久,大部分便被淘汰了。像以前的Dos就是单道程序设计系统。

    多道程序设计

    • 在计算机内存中同时存放几道相互独立的程序,它们在管理程序控制之下,相互穿插的运行。多道程序设计必须有硬件基础作为保证。
    • 时钟中断即为多道程序设计模型的理论基础。 并发时,任意进程在执行期间都不希望放弃cpu。因此系统需要一种强制让进程让出cpu资源的手段。时钟中断有硬件基础作为保障,对进程而言不可抗拒。 操作系统中的中断处理函数,来负责调度程序执行。
    • 在多道程序设计模型中,多个进程轮流使用CPU (分时复用CPU资源)。而当下常见CPU为纳秒级,1秒可以执行大约10亿条指令。由于人眼的反应速度是毫秒级,所以看似同时在运行。
    • 实质上,并发是宏观并行,微观串行!

    CPU

    • 中央处理器(CPU,Central Processing Unit)是一块超大规模的集成电路,是一台计算机的运算核心(Core)和控制核心( Control Unit)。它的功能主要是解释计算机指令以及处理计算机软件中的数据。中央处理器主要包括运算器(算术逻辑运算单元,ALU,ArithmeTIc Logic Unit)和高速缓冲存储器(Cache)及实现它们之间联系的数据(Data)、控制及状态的总线(Bus)。它与内部存储器(Memory)和输入/输出(I/O)设备合称为电子计算机三大核心部件。
    • cpu的基本结构
        从功能上看,一般CPU的内部结构可分为:控制单元、逻辑运算单元、存储单元(包括内部总线和缓冲器)三大部分。其中控制单元完成数据处理整个过程中的调配工作,逻辑单元则完成各个指令以便得到程序最终想要的结果,存储单元就负责存储原始数据以及运算结果。浑然一体的配合使得CPU拥有了强大的功能,可以完成包括浮点、多媒体等指令在内的众多复杂运算,也为数字时代加入了更多的活力。
    1. 逻辑部件

    英文Logic components;运算逻辑部件。可以执行定点或浮点算术运算操作、移位操作以及逻辑操作,也可执行地址运算和转换。

    1. 寄存器

    寄存器部件,包括寄存器、专用寄存器和控制寄存器。 通用寄存器又可分定点数和浮点数两类,它们用来保存指令执行过程中临时存放的寄存器操作数和中间(或最终)的操作结果。 通用寄存器是中央处理器的重要部件之一。

    1. 控制部件

    英文Control unit;控制部件,主要是负责对指令译码,并且发出为完成每条指令所要执行的各个操作的控制信号。

    其结构有两种:一种是以微存储为核心的微程序控制方式;一种是以逻辑硬布线结构为主的控制方式。

    微存储中保持微码,每一个微码对应于一个最基本的微操作,又称微指令;各条指令是由不同序列的微码组成,这种微码序列构成微程序。中央处理器在对指令译码以后,即发出一定时序的控制信号,按给定序列的顺序以微周期为节拍执行由这些微码确定的若干个微操作,即可完成某条指令的执行。

    简单指令是由(3~5)个微操作组成,复杂指令则要由几十个微操作甚至几百个微操作组成。

    CPU的逻辑单元
    • 更细一点,从实现的功能方面看,CPU大致可分为如下八个逻辑单元:

    1. 指令高速缓存,俗称指令寄存器 : 它是芯片上的指令仓库,有了它CPU就不必停下来查找计算机内存中的指令,从而大幅提高了CPU的运算速度。

    2. 译码单元,俗称指令译码器 : 它负责将复杂的机器语言指令解译成运算逻辑单元(ALU)和寄存器能够理解的简单格式,就像一位外交官。

    3. 控制单元 : 既然指令可以存入CPU,而且有相应指令来完成运算前的准备工作,背后自然有一个扮演推动作用的角色——它便是负责整个处理过程的操作控制器。根据来自译码单元的指令,它会生成控制信号,告诉运算逻辑单元(ALU)和寄存器如何运算、对什么进行运算以及对结果进行怎样的处理。

    4. 寄存器 : 它对于CPU来说非常的重要,除了存放程序的部分指令,它还负责存储指针跳转信息以及循环操作命令,是运算逻辑单元(ALU)为完成控制单元请求的任务所使用的数据的小型存储区域,其数据来源可以是高速缓存、内存、控制单元中的任何一个。

    5. 逻辑运算单元(ALU) : 它是CPU芯片的智能部件,能够执行加、减、乘、除等各种命令。此外,它还知道如何读取逻辑命令,如或、与、非。来自控制单元的讯息将告诉运算逻辑单元应该做些什么,然后运算单元会从寄存器中间断或连续提取数据,完成最终的任务。

    6. 预取单元 : CPU效能发挥对其依赖非常明显,预取命中率的高低直接关系到CPU核心利用率的高低,进而带来指令执行速度上的不同。根据命令或要执行任务所提出的要求,何时时候,预取单元都有可能从指令高速缓存或计算机内存中获取数据和指令。当指令到达时,预取单元最重要的任务就是确保所有指令均排列正确,然后发送给译码单元。

    7. 总线单元 : 它就像一条高速公路,快速完成各个单元间的数据交换,也是数据从内存流进和流出CPU的地方。

    8. 数据高速缓存 : 存储来自译码单元专门标记的数据,以备逻辑运算单元使用,同时还准备了分配到计算机不同部分的最终结果。

    • 通过以上介绍可以看出CPU虽小,方寸之地却能容纳大世界,内部更像一个发达的装配工厂,环环相扣,层层相套。正因为有了相互间的协作配合,才使得指令最终得以执行,才构成了图文并茂、影像结合的神奇数字世界。
    cpu的工作原理:
    • 我们都知道CPU的根本任务就是执行指令,对计算机来说最终都是一串由“0”和“1”组成的序列。CPU从逻辑上可以划分成3个模块,分别是控制单元、运算单元和存储单元,这三部分由CPU内部总线连接起来。如下所示:
      在这里插入图片描述

      • 控制单元:控制单元是整个CPU的指挥控制中心,由指令寄存IR(InstrucTIon Register)、指令译码器ID(InstrucTIon Decoder)和操作控制器OC(OperaTIon Controller)等,对协调整个电脑有序工作极为重要。它根据用户预先编好的程序,依次从存储器中取出各条指令,放在指令寄存器IR中,通过指令译码(分析)确定应该进行什么操作,然后通过操作控制器OC,按确定的时序,向相应的部件发出微操作控制信号。操作控制器OC中主要包括节拍脉冲发生器、控制矩阵、时钟脉冲发生器、复位电路和启停电路等控制逻辑。

      • 运算单元:是运算器的核心。可以执行算术运算(包括加减乘数等基本运算及其附加运算)和逻辑运算(包括移位、逻辑测试或两个值比较)。相对控制单元而言,运算器接受控制单元的命令而进行动作,即运算单元所进行的全部操作都是由控制单元发出的控制信号来指挥的,所以它是执行部件。

    • 存储单元:包括CPU片内缓存和寄存器组,是CPU中暂时存放数据的地方,里面保存着那些等待处理的数据,或已经处理过的数据,CPU访问寄存器所用的时间要比访问内存的时间短。采用寄存器,可以减少CPU访问内存的次数,从而提高了CPU的工作速度。但因为受到芯片面积和集成度所限,寄存器组的容量不可能很大。寄存器组可分为专用寄存器和通用寄存器。专用寄存器的作用是固定的,分别寄存相应的数据。而通用寄存器用途广泛并可由程序员规定其用途,通用寄存器的数目因微处理器而异。这个是我们以后要介绍这个重点,这里先提一下。

    • 我们将上图细化一下,可以得出CPU的工作原理概括如下:
      在这里插入图片描述

    • 总结一下,CPU的运行原理就是:
        1. 取指令:CPU的控制器从内存读取一条指令并放入指令寄存器。指令的格式一般是这个样子滴:
      在这里插入图片描述

    操作码就是汇编语言里的mov,add,jmp等符号码;操作数地址说明该指令需要的操作数所在的地方,是在内存里还是在CPU的内部寄存器里。

    1. 指令译码:指令寄存器中的指令经过译码,决定该指令应进行何种操作(就是指令里的操作码)、操作数在哪里(操作数的地址)。

    2. 执行指令,分两个阶段“取操作数”和“进行运算”。

    3. 修改指令计数器,决定下一条指令的地址。
      在这里插入图片描述
      在这里插入图片描述

    • 如上图所示,存储介质中,从上到小,内存越来越大,价格越来越便宜,但是传输速率越来越慢。因此将他们搭配起来使用是最好的。
    • 假如数据在硬盘上放着,当我们执行某个程序的时候,从硬盘中先拿到内存中,在拿到cache缓存器中,然后由预取器预取指令,再交给译码器进行译码,译码器再交给ALU算术逻辑单元执行运算,然后,将运算好的数据交给寄存器,由寄存器交给内存,再由内存交给硬盘。

    MMU(内存管理单元)

    在这里插入图片描述

    • 我就简答的说一下关于MMU,MMU就是为了完成物理内存和虚拟内存之间的映射,还有修改内存的访问级别。
    • 在没有使用虚拟存储器的机器上,虚拟地址被直接送到内存总线上,使具有相同地址的物理存储器被读写。而在使用了虚拟存储器的情况下,虚拟地址不是被直接送到内存地址总线上,而是送到内存管理单元——MMU(主角终于出现了)。他由一个或一组芯片组成,一般存在与协处理器中,其功能是把虚拟地址映射为物理地址。
    MMU工作过程
    • 大多数使用虚拟存储器的系统都使用一种称为分页(paging)。虚拟地址空间划分成称为页(page)的单位,而相应的物理地址空间也被进行划分,单位是页框(frame).页和页框的大小必须相同。接下来配合图片我以一个例子说明页与页框之间在MMU的调度下是如何进行映射的:
      在这里插入图片描述

    • 在这个例子中我们有一台可以生成16位地址的机器,它的虚拟地址范围从0x0000~0xFFFF(64K),而这台机器只有32K的物理地址,因此他可以运行64K的程序,但该程序不能一次性调入内存运行。这台机器必须有一个达到可以存放64K程序的外部存储器(例如磁盘或是FLASH)以保证程序片段在需要时可以被调用。在这个例子中,页的大小为4K,页框大小与页相同(这点是必须保证的,内存和外围存储器之间的传输总是以页为单位的),对应64K的虚拟地址和32K的物理存储器,他们分别包含了16个页和8个页框。

    • 关于MMU,我后面再来介绍。

    展开全文
  • 通常在ACMACMACM比赛中出题人会出111~222非常难的题目来防止有人AKAKAK,以体现出出题人的水平高超,这些题目被称为“防AKAKAK题”。 此次的新生赛中kcxz出题者的一员,kcxz知道这次比赛会有大佬参赛,所以如何...

    本题解按本人出题顺序排列

    传送门

    A 如何才能防AK

    题目描述

    AKAK, AllAll-KilledKilled的缩写,指在比赛中解出了所有的题目。通常在ACMACM比赛中出题人会出11~22道非常难的题目来防止有人AKAK,以体现出出题人的水平高超,这些题目被称为“防AKAK题”。
    此次的新生赛中kcxz是出题者的一员,kcxz知道这次比赛会有大佬参赛,所以如何出防AKAK题成为了令kcxz头痛的事。现在kcxz对过题数目进行一个简单的模拟,请你根据每个选手的过题数来判断kcxz的出题水平。

    输入描述

    本题输入第一行包含一个整数 T(5T200)T(5\le T\le 200),表示参赛的人数。
    接下来 T 行,每行一个整数 N(0N10)N(0\le N \le 10),表示参赛者的过题数。

    输出描述

    如果没有一个参赛者过了10题,则输出"666"(不含引号,下同)。如果有1~5个参赛者过了10题,则输出"good"。如果有超过6个(包含6个)参赛者过了10题,则输出"just so so"。

    input
    5
    5
    8
    1
    10
    4
    
    output
    good
    

    思路

    签到题

    Accepted code

    /*
     * @Autor: CofDoria
     * @Date: 2020-11-21 12:52:37
     * @LastEditTime: 2020-11-21 13:02:34
     */
    #include <bits/stdc++.h>
    using namespace std;
    
    #define db double
    #define ll long long
    #define inf 0x3f3f3f3f
    #define s(a, n) memset(a, n, sizeof(a))
    #define debug(a) cout << '#' << a << '#' << endl
    #define rep(l, a, b) for (register ll l = a; l < b; ++l)
    #define per(l, a, b) for (register ll l = a; l >= b; --l)
    #define _ios ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
    #define _forit(i, c) \
        for (__typeof__((c).begin()) i = (c).begin(); i != (c).end(); ++i)
    
    bool fi = true;
    const unsigned long long MOD = 1e9 + 7;
    
    inline ll gcd(ll a, ll b) { return (b == 0 ? a : gcd(b, a % b)); }
    
    int t;
    int a;
    int ans = 0;
    
    int main() {
        // freopen("in.txt", "r", stdin);
        // freopen("out.txt", "w", stdout);
        scanf("%d", &t);
        for (int i = 0; i < t; i++) {
            scanf("%d", &a);
            if (a >= 10) ans++;
        }
        if (ans >= 6)
            printf("just so so");
        else if (ans == 0)
            printf("666");
        else
            printf("good");
        // fclose(stdin);
        // fclose(stdout);
        return 0;
    }
    

    F 交际圈差距

    题目描述

    在人际交往中,人与人之间的消息传递显得尤为重要,如果一方不能及时将消息传递给另一方,那么,可能会发生一些无法预料的后果。

    现假设 a\mathit a 需要发送一条消息,那么,他会给他的联系人列表中的所有人各发送一条消息,而对于接收到该消息的某个人 b\mathit b,如果此前已经收到过该消息,那么就会无视这条信息,否则,b\mathit b 就会将这条消息转发给他的联系人列表中的所有人…
    不断重复该转发过程,由于交际圈不可能无限大,所以最终一定会停止。

    在上述情况下,假设最终知晓该条消息的总人数为 k(\mathit k(包括发送者 a)\mathit a),那么,就称这个交际圈大小为 k\mathit k

    若已知一个校园中有 n\mathit n 个人,同时也知道他们两两之间能否互发消息,那么,这 n\mathit n 个人就会被划分成若干个交际圈,现在,希望你快速求出,最大的交际圈和最小的交际圈之间的差距是多少?

    输入描述

    第一行输入两个正整数 n,m(2n105,1m105)n,m(2\le n\le 10^5, 1\le m\le 10^5),依次代表人数以及关系数。

    接下去 m\mathit m 行,每行两个正整数 a, b( a, b  n; a  b)\mathit a,\ \mathit b(\text 1\ \leq\ \mathit a,\ \mathit b\ \leq\ \mathit n;\ \mathit a\ \ne\ \mathit b),表示 a\mathit ab\mathit b 之间可以互发消息。

    输出描述

    一行输出一个整数代表最大的交际圈以及最小的交际圈之间的差距。

    特殊的,若 n\mathit n 个人同属于一个交际圈,也就不存在最大、最小之分,那么,不需要输出任何一个整数,请用字符串 WOW 表示此情景。

    input
    3 1
    1 3
    
    output
    1
    
    input
    2 1
    2 1
    
    output
    WOW
    

    思路

    (需要用到并查集数据结构)用并查集储存每个人的父亲节点,父亲节点相同的人为一个社交圈,统计每个父亲节点在f[i]f[i]中出现的次数,最大减最小即可,注意特判 nn 个人皆在同一社交圈的情况。

    Accepted code

    /*
     * @Autor: CofDoria
     * @Date: 2020-11-21 13:08:56
     * @LastEditTime: 2020-11-21 13:25:31
     */
    #include <bits/stdc++.h>
    using namespace std;
    
    #define db double
    #define ll long long
    #define inf 0x3f3f3f3f
    #define s(a, n) memset(a, n, sizeof(a))
    #define debug(a) cout << '#' << a << '#' << endl
    #define rep(l, a, b) for (register ll l = a; l < b; ++l)
    #define per(l, a, b) for (register ll l = a; l >= b; --l)
    #define _ios ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
    #define _forit(i, c) \
        for (__typeof__((c).begin()) i = (c).begin(); i != (c).end(); ++i)
    
    bool fi = true;
    const unsigned long long MOD = 1e9 + 7;
    
    inline ll gcd(ll a, ll b) { return (b == 0 ? a : gcd(b, a % b)); }
    
    int n, m;
    int f[100005];
    int num[100005];
    
    int find(int a) { return f[a] == a ? a : f[a] = find(f[a]); }
    
    int main() {
        // freopen("in.txt", "r", stdin);
        // freopen("out.txt", "w", stdout);
        memset(num, 0, sizeof(num));
        scanf("%d%d", &n, &m);
        for (int i = 1; i <= n; i++) f[i] = i;
        for (int i = 0; i < m; i++) {
            int a, b, fa, fb;
            scanf("%d%d", &a, &b);
            fa = find(a);
            fb = find(b);
            if (fa != fb) {
                f[fa] = fb;
            }
        }
        for (int i = 1; i <= n; i++) find(i);
        for (int i = 1; i <= n; i++) {
            // printf("%d\n", f[i]);
            num[f[i]]++;
        }
        int maxn = 0;
        int minn = n + 1;
        for (int i = 1; i <= n; i++) {
            // printf("%d\n", num[i]);
            if (num[i] > maxn) maxn = num[i];
            if (num[i] < minn && num[i]) minn = num[i];
        }
        if (maxn == n)
            printf("WOW");
        else
            printf("%d", maxn - minn);
        // fclose(stdin);
        // fclose(stdout);
        return 0;
    }
    

    D 战力对比

    题目描述

    皮卡丘正在对小智的 n\mathit nPokeˊmon\mathit {Pokémon}进行特训,首先,皮卡丘命令它们站成一排,编号为 1, 2, ..., n\text 1,\ \text 2,\ ...,\ \mathit n,易知它们的战斗力分别为 a1, a2, ..., an\mathit a_\text 1,\ \mathit a_\text 2,\ ...,\ \mathit a_\mathit n

    现在,皮卡丘会对连续的 k\mathit kPokeˊmon\mathit {Pokémon}进行考量,记录下这 k\mathit kPokeˊmon\mathit {Pokémon} 中的最大战力。

    显然,皮卡丘最终会得到 n  k + 1\mathit n\ -\ \mathit k\ +\ \text 1 个数值。

    那么,在所有被记录下的数值中,最大的战斗力达到了多少?

    输入描述

    第一行输入两个正整数 n, k( k  n  2 × 106)\mathit n,\ \mathit k(\text 1\ \leq\ \mathit k\ \leq\ \mathit n\ \leq\ \text 2\ \times\ \text {10} ^ \text 6),依次代表特训的 Pokeˊmon\mathit {Pokémon} 数量以及每次考量的连续 Pokeˊmon\mathit {Pokémon} 数量。

    第二行依次输入 n\mathit n 个正整数 a1, a2, ..., an( ai  106)a\mathit a_\text 1,\ \mathit a_\text 2,\ ...,\ \mathit a_\mathit n(\text 1\ \leq\ \mathit a_\mathit i\ \leq\ \text {10} ^ \text 6)a
    ,依次代表第 1, 2, ..., n\text 1,\ \text 2,\ ...,\ \mathit nPokeˊmon\mathit {Pokémon} 的战斗力。

    输出描述

    一行输出一个正整数代表答案。

    input
    3 1
    9 9 6
    
    output
    9
    

    思路

    注意审题,是k只中的最大值,指的是单只宝可梦。输出最大值即可。

    Accepted code

    /*
     * @Autor: CofDoria
     * @Date: 2020-11-21 12:52:37
     * @LastEditTime: 2020-11-21 13:38:48
     */
    #include <bits/stdc++.h>
    using namespace std;
    
    #define db double
    #define ll long long
    #define inf 0x3f3f3f3f
    #define s(a, n) memset(a, n, sizeof(a))
    #define debug(a) cout << '#' << a << '#' << endl
    #define rep(l, a, b) for (register ll l = a; l < b; ++l)
    #define per(l, a, b) for (register ll l = a; l >= b; --l)
    #define _ios ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
    #define _forit(i, c) \
        for (__typeof__((c).begin()) i = (c).begin(); i != (c).end(); ++i)
    
    bool fi = true;
    const unsigned long long MOD = 1e9 + 7;
    
    inline ll gcd(ll a, ll b) { return (b == 0 ? a : gcd(b, a % b)); }
    
    int n, k;
    ll a[20000005];
    
    int main() {
        // freopen("in.txt", "r", stdin);
        // freopen("out.txt", "w", stdout);
        ll maxn = 0;
        scanf("%d%d", &n, &k);
        for (int i = 1; i <= n; i++) {
            scanf("%lld", &a[i]);
            maxn = max(maxn, a[i]);
        }
        // for (int i = 2; i <= n; i++) a[i] += a[i - 1];
        // for (int i = k, j = 0; i <= n; i++, j++) {
        //     if (a[i] - a[j] > maxn) maxn = a[i] - a[j];
        // }
        printf("%lld", maxn);
        // fclose(stdin);
        // fclose(stdout);
        return 0;
    }
    

    I 时间复杂度与TLE

    题目描述

    在ACM比赛中,算法的时间复杂度和运行时间限制有着很大的关联。
    大部分的OJ系统运行时间限制1秒对应的复杂度的“数量级”约为1e7~1e8(1e7=11071e7=1*10^7)。“数量级”是一个模糊的单位,对应着复杂度的大小。
    例如,如果题目规定的n上限是1e5, 运行时间限制是1秒,你的程序的复杂度是O(n2)O(n^2),那么就会TLE(Time limit exceed)。而如果你的程序的复杂度是O(nlog2n)O(nlog_2n)往往不会超时。

    输入描述

    输入共三行。
    第一行包含一个整数代表运行时间限制t(1t5)t(1\le t\le5)
    第二行包含一个整数nn^{}
    代表描述中的上限(1n10000000)(1\le n \le 10000000)
    第三行包含一个字符串,该字符串是"n", “n^2”, “n^3”, "nlogn"中的一种。(字符串没有引号)默认对数底为2,即nlogn当成nlog2nn*log_2n来计算。

    输出描述

    如果根据字符串所计算出来的结果小于等于t * 1e7, 输出"Safe"(不包含引号,下同)。
    如果结果大于t * 1e7小于等于t * 1e8, 输出"Dangerous"
    如果结果大于t * 1e8, 输出"TLE"

    input
    1
    100
    n^3
    
    output
    Safe
    
    input
    3
    10000000
    nlogn
    
    output
    Dangerous
    
    input
    3
    20000
    n^2
    
    output
    TLE
    

    思路

    对于 n2n^2nnnlognnlogn 直接进行计算即可 ,对于 n3n^3 可以使用__int128_t型变量计算,也可以计算(t1e7)13(t*1e7)^{\frac{1}{3}}(t1e8)13(t*1e8)^{\frac{1}{3}}nn 比较,下文代码思路即为后者

    Accepted code

    /*
     * @Autor: CofDoria
     * @Date: 2020-11-21 13:40:09
     * @LastEditTime: 2020-11-21 13:55:28
     */
    #include <bits/stdc++.h>
    using namespace std;
    
    #define db double
    #define ll long long
    #define inf 0x3f3f3f3f
    #define s(a, n) memset(a, n, sizeof(a))
    #define debug(a) cout << '#' << a << '#' << endl
    #define rep(l, a, b) for (register ll l = a; l < b; ++l)
    #define per(l, a, b) for (register ll l = a; l >= b; --l)
    #define _ios ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
    #define _forit(i, c) \
        for (__typeof__((c).begin()) i = (c).begin(); i != (c).end(); ++i)
    
    bool fi = true;
    const unsigned long long MOD = 1e9 + 7;
    
    inline ll gcd(ll a, ll b) { return (b == 0 ? a : gcd(b, a % b)); }
    
    ll t;
    ll n;
    char s[105];
    
    void c(ll a, int o = 0) {
        if (o) {
            if (a <= pow(t * 1e7, 1.0 / 3.0)) {
                printf("Safe");
            } else if (a > pow(t * 1e8, 1.0 / 3.0)) {
                printf("TLE");
            } else
                printf("Dangerous");
            return;
        }
        if (a <= t * 1e7)
            printf("Safe");
        else if (a > t * 1e8) {
            printf("TLE");
        } else
            printf("Dangerous");
        return;
    }
    
    int main() {
        // freopen("in.txt", "r", stdin);
        // freopen("out.txt", "w", stdout);
        scanf("%lld", &t);
        scanf("%lld", &n);
        scanf("%s", s);
        int len = strlen(s);
        if (len > 3) {
            c(n * log2(n));
        } else if (len < 3) {
            c(n);
        } else if (s[2] == '2') {
            c(n * n);
        } else if (s[2] = '3') {
            c(n, 1);
        }
        // fclose(stdin);
        // fclose(stdout);
        return 0;
    }
    

    E 希望得到的成绩

    题目描述

    “考试季”即将来临!

    幸运的是,皮卡丘已经顺利度过了考试阶段!但成绩却不尽人意!

    已知它一共考了 n\mathit n 门,成绩分别为 a1, a2, ..., an\mathit a_\text 1,\ \mathit a_\text 2,\ ...,\ \mathit a_\mathit n
    显然,皮卡丘不想告诉小智自己的真实成绩,否则寒假还怎么带自己出去冒险?但又不能只告诉小智自己的最高分,那样更容易引起怀疑。

    在综合考虑之后,皮卡丘决定,在这 n\mathit n 门课的成绩中,随机挑选出 k\mathit k 门,对被挑选出的成绩取平均值。

    现在,皮卡丘想知道,理论上,这个平均值最大可以达到多少?

    输入描述

    本题为多组测试数据,第一行输入一个正整数 T( T  105)\mathit T(\text 1\ \leq\ \mathit T\ \leq\ \text {10} ^ \text 5),代表测试数据的组数。

    对于每组测试数据,第一行输入两个正整数 n, k( k  n  105)\mathit n,\ \mathit k(\text 1\ \leq\ \mathit k\ \leq\ \mathit n\ \leq\ \text {10} ^ \text 5),依次代表皮卡丘的考试科目数量以及想要挑选出的课程数量。
    第二行依次输入 n\mathit n 个正整数 a1, a2, ..., an( ai  105)a\mathit a_\text 1,\ \mathit a_\text 2,\ ...,\ \mathit a_\mathit n(\text 1\ \leq\ \mathit a_\mathit i\ \leq\ \text {10} ^ \text 5)a 代表皮卡丘的 n\mathit n 门考试成绩。(假设在 Pokeˊmon\mathit {Pokémon} 的世界中,成绩的最大值为 105)\text {10} ^ \text 5)
    题目保证,所有测试数据的 n\mathit n 之和不会超过 106\text {10} ^ \text 6

    输出描述

    对于每组测试数据,一行输出一个数字代表答案。

    该数字可以是整数也可以是小数,只需要在 106\text {10} ^ {-\text 6} 的误差范围内即可。

    input
    3
    1 1
    6
    3 2
    3 3 4
    3 3
    3 2 5
    
    output
    6
    3.5
    3.33333333
    

    思路

    double存最大的 kk 个数总和,除以 kk 即可(kk 如果为整数别忘了转换为浮点数)

    Accepted code

    /*
     * @Autor: CofDoria
     * @Date: 2020-11-21 13:59:21
     * @LastEditTime: 2020-11-21 15:30:16
     */
    #include <bits/stdc++.h>
    using namespace std;
    
    #define db double
    #define ll long long
    #define inf 0x3f3f3f3f
    #define s(a, n) memset(a, n, sizeof(a))
    #define debug(a) cout << '#' << a << '#' << endl
    #define rep(l, a, b) for (register ll l = a; l < b; ++l)
    #define per(l, a, b) for (register ll l = a; l >= b; --l)
    #define _ios ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
    #define _forit(i, c) \
        for (__typeof__((c).begin()) i = (c).begin(); i != (c).end(); ++i)
    
    bool fi = true;
    const unsigned long long MOD = 1e9 + 7;
    
    inline ll gcd(ll a, ll b) { return (b == 0 ? a : gcd(b, a % b)); }
    
    int t;
    db a[100005];
    int n, k;
    
    inline bool cmp(db a, db b) { return a > b; }
    
    char s[1005];
    int main() {
        // freopen("in.txt", "r", stdin);
        // freopen("out.txt", "w", stdout);
        scanf("%d", &t);
        while (t--) {
            scanf("%d%d", &n, &k);
            for (int i = 0; i < n; i++) scanf("%lf", &a[i]);
            sort(a, a + n, cmp);
            db ans = 0.0;
            for (int i = 0; i < k; i++) {
                ans += a[i];
            }
            printf("%lf\n", ans / (db)(k * 1.0));
        }
        // fclose(stdin);
        // fclose(stdout);
        return 0;
    }
    

    G 回形取数求和

    题目描述

    已知在一个 n × m\mathit n\ \times\ \mathit m 的矩阵中,左上角为 (1, 1\text 1,\ \text 1),右下角为 (n, m\mathit n,\ \mathit m),其中的每个位置 (i, j\mathit i,\ \mathit j) 上都事先填好了一个数 ai, j\mathit a_{\mathit i,\ \mathit j},现在,需要你从 (1, 1\text 1,\ \text 1) 开始回形依次取数,之后分别输出奇数项之和以及偶数项之和。
    在这里插入图片描述

    例如,已知一个 × 4\text 3\ \times\ \text 4 的矩阵如下:

    3 6 9 96 6 6 69 9 9 3\text {3 6 9 9}\\\text {6 6 6 6}\\\text {9 9 9 3}

    回形取数的结果为:3 6 9 9 6 3 9 9 9 6 6 6\text {3 6 9 9 6 3 9 9 9 6 6 6}

    奇数项求和为:+ 9 + 6 + 9 + 9 + 6 = 42\text 3\ +\ \text 9\ +\ \text 6\ +\ \text 9\ +\ \text 9\ +\ \text 6\ =\ \text {42}

    偶数项求和为:+ 9 + 3 + 9 + 6 + 6 = 39\text 6\ +\ \text 9\ +\ \text 3\ +\ \text 9\ +\ \text 6\ +\ \text 6\ =\ \text {39}

    输入描述

    第一行输入两个正整数 n, m( n, m  2000\mathit n,\ \mathit m(\text 1\ \leq\ \mathit n,\ \mathit m\ \leq\ \text {2000}),代表矩形的行、列长度。

    2\text 2n + 1\mathit n\ +\ \text 1 行,每行输入 m\mathit m 个正整数,其中,第 i + 1\mathit i\ +\ \text 1 行的第 j\mathit j 个正整数 ai, j( ai, j  2000)\mathit a_{\mathit i,\ \mathit j}(\text 1\ \leq\ \mathit a_{\mathit i,\ \mathit j}\ \leq\ \text {2000}) ,代表 (i, j)(\mathit i,\ \mathit j) 这个位置上的数字。

    输出描述

    第一行输出一个整数代表奇数项之和,第二行输出一个整数代表偶数项之和。

    特殊的,若出现不存在奇数项的情况,则在第一行输出 1-\text 1 代表无奇数项;若出现不存在偶数项的情况,则在第二行输出 1-\text 1 代表无偶数项。

    input
    3 4
    3 6 9 9
    6 6 6 6
    9 9 9 3
    
    output
    42
    39
    

    思路

    通过模拟可以发现,在任何情况下,奇数项的一维下标与二维下标差值都为偶数
    在这里插入图片描述
    注意特判 nmn*m 等于 11 的情况

    Accepted code

    /*
     * @Autor: CofDoria
     * @Date: 2020-11-21 15:06:54
     * @LastEditTime: 2020-11-21 15:42:45
     */
    #include <bits/stdc++.h>
    using namespace std;
    
    #define db double
    #define ll long long
    #define inf 0x3f3f3f3f
    #define s(a, n) memset(a, n, sizeof(a))
    #define debug(a) cout << '#' << a << '#' << endl
    #define rep(l, a, b) for (register ll l = a; l < b; ++l)
    #define per(l, a, b) for (register ll l = a; l >= b; --l)
    #define _ios ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
    #define _forit(i, c) \
        for (__typeof__((c).begin()) i = (c).begin(); i != (c).end(); ++i)
    
    bool fi = true;
    const unsigned long long MOD = 1e9 + 7;
    
    inline ll gcd(ll a, ll b) { return (b == 0 ? a : gcd(b, a % b)); }
    
    int n, k;
    ll a;
    ll jj, oo;
    
    int main() {
        // freopen("in.txt", "r", stdin);
        // freopen("out.txt", "w", stdout);
        scanf("%d%d", &n, &k);
        jj = 0, oo = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < k; j++) {
                scanf("%d", &a);
                if (abs(i - j) & 1)
                    oo += a;
                else
                    jj += a;
            }
        }
        if (n * k < 2)
            printf("%lld\n-1", jj);
        else
            printf("%lld\n%lld", jj, oo);
        // fclose(stdin);
        // fclose(stdout);
        return 0;
    }
    

    H Gcd and lcm

    题目描述

    English ability is the most significant subject for the Computer Science and Technology Department in all of the STEM(Science, technology, engineering, and mathematics). Kcxz heard of some new ACMer don’t understand the English problems, so he put forward the unique English problem in this competition. "gcdgcd^{} " stands for “greatest common divisor”, and "lcmlcm^{} " stands for “least common multiple”.

    gcd(ab,cd)=gcd(a,c)lcm(b,d)gcd(\frac{a}{b},\frac{c}{d})=\frac{gcd(a,c)}{lcm(b,d)}

    lcm(ab,cd)=lcm(a,c)gcd(b,d)lcm(\frac{a}{b},\frac{c}{d})=\frac{lcm(a,c)}{gcd(b,d)}In these two formulas, you must guarantee that all of the fractions are irreducible fractions, which means gcd(a,b)=gcd(c,d)=1gcd(a, b)^{}=gcd(c, d)=1. Now kcxz believes you have got it, so please solve this question!

    输入描述

    The input consists of several test cases and is terminated by the end-of-file. For each test case, there are one character and two fractions. If the character is ‘GG^{}’, answer the gcd of the two fractions. If the character is ‘LL^{}’, answer the lcm of the two fractions. It is guaranteed that the sum of the test cases could not exceed 10510^5. 1a,b,c,d1091\le a, b, c, d\le 10^9

    输出描述

    For each test case, print a fraction in one line representing the answer. If the fraction’s denominator is equal to one, output the numerator only. Otherwise, print a fraction like A/BA^{}/B where AA^{} and BB^{} are relatively prime.

    input
    L 10/4 7/2
    G 12/3 6/2
    L 3/4 5/8
    
    output
    35/2
    1
    15/4
    

    题意

    L代表lcm(最小公倍数),G代表gcd(最大公因数)按题目要求,计算两个分数的最大公因数或最小公倍数。

    思路

    首先对给定分数化到最简式,按照公式计算,对于答案同样要化到最简式,同时对于分母为 11 的数注意直接输出分子即可

    • 化为最简式就是对分子分母同除两个数的最大公因数
    • 最大公因数的求法为辗转相除法
    • 最小公倍数即为两个数的乘积除以最大公因数

    Accepted code

    /*
     * @Autor: CofDoria
     * @Date: 2020-11-21 13:04:18
     * @LastEditTime: 2020-11-21 15:55:47
     */
    #include <bits/stdc++.h>
    using namespace std;
    
    #define db double
    #define ll long long
    #define inf 0x3f3f3f3f
    #define s(a, n) memset(a, n, sizeof(a))
    #define debug(a) cout << '#' << a << '#' << endl
    #define rep(l, a, b) for (register ll l = a; l < b; ++l)
    #define per(l, a, b) for (register ll l = a; l >= b; --l)
    #define _ios ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
    #define _forit(i, c) \
        for (__typeof__((c).begin()) i = (c).begin(); i != (c).end(); ++i)
    
    bool fi = true;
    const unsigned long long MOD = 1e9 + 7;
    
    inline ll gcd(ll a, ll b) { return (b == 0 ? a : gcd(b, a % b)); }
    
    ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
    
    char s[100];
    char n1[1005];
    char n2[1005];
    ll a, b, c, d;
    
    int main() {
        // freopen("in.txt", "r", stdin);
        // freopen("out.txt", "w", stdout);
        while (~scanf("%s", s)) {
            scanf("%s", n1);
            scanf("%s", n2);
            ll aa = 0;
            for (ll i = 0, len = strlen(n1); i < len; i++) {
                if (n1[i] == '/') {
                    a = aa;
                    aa = 0;
                    continue;
                }
                aa *= 10;
                aa += n1[i] - '0';
            }
            b = aa;
            aa = 0;
            for (ll i = 0, len = strlen(n2); i < len; i++) {
                if (n2[i] == '/') {
                    c = aa;
                    aa = 0;
                    continue;
                }
                aa *= 10;
                aa += n2[i] - '0';
            }
            d = aa;
            ll ab = gcd(a, b), cd = gcd(c, d);
            a /= ab;
            b /= ab;
            c /= cd;
            d /= cd;
            if (s[0] == 'G') {
                ll u = gcd(a, c);
                ll dd = lcm(b, d);
                ll ud = gcd(u, dd);
                if (u == dd)
                    printf("1\n");
                else if (dd / ud == 1) {
                    printf("%lld\n", u / ud);
                } else {
                    printf("%lld/%lld\n", u / ud, dd / ud);
                }
            } else if (s[0] == 'L') {
                ll u = lcm(a, c);
                ll dd = gcd(b, d);
                ll ud = gcd(u, dd);
                if (u == dd)
                    printf("1\n");
                else if (dd / ud == 1) {
                    printf("%lld\n", u / ud);
                } else {
                    printf("%lld/%lld\n", u / ud, dd / ud);
                }
            }
        }
        // fclose(stdin);
        // fclose(stdout);
        return 0;
    }
    
    展开全文
  • JAVA语言程序设计结课作业线上 一论述题 ( 每题 20 分 , 共 2 小题 , 总分值 40 分 ) 1.论述 JAVA语言中的继承单继承和继承的定义 答继承实际上存在于面向对象程序设计中的两个类之间的一种关系 面向对象程...
  • 1.1 操作系统的形成与发展2008年11月1... 多道程序设计是指允许多个作业(程序)同时进入计算机系统的主存并启动交替计算的方法;a) 中断和通道,使得计算机体系结构由原先的以CPU为中心转变为以主存为中心;b) 

    <?xml:namespace prefix = o ns = "urn:schemas-microsoft-com:office:office" />

     

    1.1    操作系统的形成与发展<?xml:namespace prefix = st1 ns = "urn:schemas-microsoft-com:office:smarttags" />2008111星期六

    1.1.1   人工操作阶段

    1.1.2   管理程序阶段

    1.1.3   多道程序设计与操作系统的形成

    1.       多道程序设计:是指允许多个作业(程序)同时进入计算机系统的主存并启动交替计算的方法;

    a)         中断和通道,使得计算机体系结构由原先的以CPU为中心转变为以主存为中心;

    b)        在多道程序设计中,值得注意的是道数的多少。要考虑到等待I/O的概率,此外,主存的容量和用户的响应时间等因素也会影响到多道程序的道数。

    c)         实现多道程序设计必须妥善解决是3个问题:

                            i.              存储保护与程序浮动:

                          ii.              处理器的管理与分配:

                        iii.              资源的管理与调度:各种资源的利用率问题。

    2.       操作系统的形成:中断和通道技术的出现使得硬部件具有并行工作的能力

    1.1.4   操作系统的发展与分类

    嵌入式操作系统:是指运行在嵌入式应用环境中,对整个系统及所有操作的各种部件、装置等资源进行同一协调、处理、指挥和控制的系统软件。

    1.2    操作系统的基本服务和用户接口

    1.2.1   基本服务和用户接口

    1.       基本服务:

    a)         创建与执行程序;

    b)        数据I/O和信息存取;

    c)        通信服务;

    d)        差错检测和处理;

    e)         资源分配;

    f)         统计;

    g)        保护;

    h)        等等;

    2.       用户接口:

    a)         程序接口:“系统调用”,获得操作系统的低层服务,访问各种软硬件资源;

    b)        操作接口:为用户提供的组织和控制作业执行的手段;

    1.2.2   程序接口与系统调用

    1.       系统调用:一种中介角色,把用户和硬件隔离开来,应用程序只有通过系统调用才能请求系统服务并使用系统资源;是应用程序获得操作系统服务的唯一途径;

    a)         访管指令,产生异常信号,中断机制,处理器由用户态转变为核心态;

    2.       API,库函数和系统调用:

    a)         API是一个函数定义,说明如何获得给定的服务,一个API的实现可能会用到一个或多个系统调用;

    3.       系统调用的分类

    a)         进程管理;

    b)        文件操作;

    c)        设备管理;

    d)        主存管理;

    e)         进程通信

    f)         信息维护。

    4.       系统调用实现要点

    a)         实现系统调用使用陷阱或异常处理机制;

    b)        由于系统调用引起处理器中断的机器指令称为:访管指令、自陷指令或中断指令。

    c)        系统调用实现要点:‘

                             i.              编写系统调用服务函数;

                           ii.              设计系统调用的入口地址表;

                          iii.              陷阱处理机制。

    5.       系统调用与函数调用直接的区别

    a)         调用形式和实现方式不同:函数调用地址不固定、系统调用提供功能号;

    b)        被调用代码的位置不同

    c)        提供方式不同

    1.2.3   作业接口与操作命令

    1.3    操作系统结构和运行模型

    操作系统具有高度的动态性和随机性、逻辑上的并发性和物理上的并行性,操作系统的结构设计有三层含义:

    1.       整体结构:功能划分、相互交换;

    2.       局部结构:数据结构、控制结构;

    3.       运行时组织:进程线程、系统空间用户空间等;

    1.3.1   操作系统的构件和结构

    1.       内核:

    a)         一组程序模块,作为可信软件来提供支持进程并发执行的基本功能和基本操作,通常驻留在内核空间,运行于核心态;

    b)        内核的分类:

                             i.              单内核:模块之间的交互直接调用其他模块中的函数来实现;

    1.         整体式结构:

    2.         层次式结构:把模块按照功能的调用次序排成若干层次,各层单向调用的关系。必须建立模块(进程)间的通信机制,系统花费在通信上的开销比较大。

                           ii.              微内核:只把应用必需的核心功能放入内核;其他功能放到内核之外,通过微内核所提供的消息传递机制完成进程之间通信;

    1.         由于进程具有不同的虚拟地址空间,客户和服务器进程之间采用消息传递机制进行通信,而内核被映射到所有进程的虚拟地址空间内,它可以控制所有进程

    2.         微内核结构的优点:

    a)         对进程提供一致性接口,所有服务均借助消息传递机制提供。

    b)        具有较好的可扩充性和易修改性;

    c)        可移植性好。

    c)        内核的功能:资源抽象(屏蔽底层细节)、资源分配、资源共享

    d)        内核的属性:

                             i.              内核由中断来驱动;

                           ii.              内核是不可抢占的

                          iii.              内核部分程序在屏蔽中断状态下执行;

                         iv.              内核可使用特权指令。

    e)         机制与策略分离:操作系统的系统调用抽象并实现现有特定目的和功能的函数(提供机制),至于如何使用这些函数则与内核无关,而由上层软件决定(选择策略)。

    2.       进程

    3.       线程:在多线程环境下,进程是系统进行保护和资源分配的单位,线程则是进程中的一条执行路径,是系统调度的独立单位。

    4.       管程:是管理共享资源的一种同步机制,对管程的调用表示对共享资源的请求与释放;管程的引入使得原来分散在进程中的临界区可集中起来统一控制和管理。

    5.       类程:管理私有资源,对类程的调用表示对私有资源执行操作。

    1.3.2   操作系统的运行模型

    1.  独立运行的内核模型:早期实现,内核要并发很难;

    2.  在应用程序内执行的模型:为应用程序创建一个核心栈,形成操作系统函数在应用进程内执行的方式;

    3.  作为独立进程运行的模型:把操作系统组织成一组系统进程(服务器进程),操作系统的功能就是这些系统进程集合运行的结果。操作系统的大部分功能在用户态的进程中运行。

    1.3.3   Windows2003客户-服务器结构

    采用基于对象的技术来设计和实现;采用客户-服务器结构,应用进程和服务器进程之间通过执行体中的消息传递机制进行通信。

    1.4    流行操作系统简介

    1.4.1   Windows操作系统

    1.5    本章小结

    三种资源管理:复用、虚化、抽象

    三种基本抽象:进程抽象、虚存抽象、文件抽象;

    三个重要特征:并发、共享、随机
    展开全文
  • 1.多道程序设计是指(D) A. 在实时系统中并发运行多个程序 B. 在分布式系统中同一时刻运行多个程序 C. 在一台处理机上同一时刻运行多个程序 D. 在一台处理机上并发运行多个程序 2(单选题) 在程序中调用fork()函数...
  • 数据库设计是指设计数据库管理系统 C. 数据库技术的根本目标是要解决数据共享的问题 D. 数据库系统中,数据的物理结构必须与逻辑结构一致 2、若k是C语言的int型变量,且有下面的程序片段:  k=-3  if(k) printf...
  • 如何设计一个关系型数据库 如果在面试中面试官问了我们...数据库由两个部分组成分别存储(类似于一个文件系统)和程序实例(对存储进行逻辑上的管理)。 程序由以下八个部分组成: 存储管理:数据的逻辑关系转换为物...
  • 而现在的操作系统在多道程序设计的背景下,进程基本上异步的,即每次运行的过程都不一样的。但是结果可能一样的。 如果有两个进程A和B(一般协作关系),那么进程同步的意思说,两个进程的运行过程...
  • C) 抽象类与接口的用法几乎都相同,具体用哪一个方法,只是在于程序设计人员的编程习惯而已。 D) 在Java中,最多使用的抽象类,因为应用抽象类也可以实现继承。而接口已经被限制使用。 题目21:d 程序如下: ...
  • 对一些公司的笔试面试会经常碰到,我想强调一下这个所谓的碰到并不是会碰到原题,也不一定就只是单纯的换个问法而已,而是当你做过这些练习后,并且理解了的,在对一些笔试面试的算法题上很都能给自己带来一个...
  • 1多道程序设计是指()。(5.0分) A、在实时系统中并发运行多个程序 B、在一台处理机上并发运行多个程序 C、在分布系统中同一时刻运行多个程序 D、在一台处理机上同一时刻运行多个程序 我的答案:B 2分时操作系统...
  • 并发编程(二)

    2018-11-17 14:38:00
    在第三代计算机的发展中因为出现了多道技术使得同一时刻可以在内存中同时运行多个程序,那么这样就产生了进程的概念. 在本篇博客中将介绍进程相关的理论知识,对操作系统进一步的认识. 进程 什么进程 进程( process)...
  • (单选题) 多道程序设计是指() A. 在实时系统中并发运行多个程序 B. 在分布式系统中同一时刻运行多个程序 C. 在一台处理机上同一时刻运行多个程序 D. 在一台处理机上并发运行多个程序 2(单选题) 在程序中调用fork...
  • 所谓“单词”是指连续不含空格的字符串,各单词之间用空格分隔,空格数可以是个。 输入格式: 输入给出一行字符。 输出格式: 在一行中输出单词个数。 输入样例: Let’s go to room 209. 输出样例: 5 今天在写这题...
  • 操作系统 (一)

    2020-01-13 05:12:40
    多道程序设计是指在计算机内存中同时存放多个程序 多道程序在计算机的管理程序之下相互穿插运行 五大功能,进程管理, 存储管理,作业管理, 文件管理,设备管理 ->什么是操作系统: 操作系统是管理...
  • 一.操作系统的演进 1.无操作系统 人工操作 用户独占 cpu等待人工操作 资源利用率很低 2.批处理系统 无需人工等待 批量输入任务 资源利用率提升 ...多道程序设计是指在计算机内存中间同时...
  • A、程序设计语言 B、操作系统 C、编译系统 D、标准库程序 3.进程调度的对象和任务分别( C )。 A、作业,从就绪队列中按一定的调度策略选择一个进程占用CPU B、进程,从后备作业队列中按调度策略选择一个作业...
  • 4.试说明推动多道批处理系统形成和发展的主要动力什么? 答:主要动力来源于四个方面的社会需求与技术发展: (1)不断提高计算机资源的利用率; (2)方便用户; (3)器件的不断更新换代; (4)计算机...
  • 第一章:概述 内核功能:物理内存管理 | 虚拟内存管理 | 文件系统管理 | 中断处理和IO设备...虚拟利用多道程序设计技术,让每一个用户都觉得有一个计算机专门为他服务 异步程序的执行不是一步到底的,而是走走停...
  • 音乐爱好者可借助本软件提高音乐理论水平和音乐欣赏水平,程序设计人员可利用本软件为应用程序准备音乐素材,一般用户还可通过本软件达到自娱自乐,充实生活的目的,等等。 《听众点歌》软件的共享版提供了使用...
  • 操作系统刷题(二)

    千次阅读 2017-06-04 22:29:05
    1、多道程序设计是利用了CPU和通道并行工作来提高系统的效率 2.虚拟存储管理系统的基础是程序的局部性理论,这个理论的基本含义是指程序执行时往往会不均匀地访问主存储器的单元。 3.引入缓冲的主要原因包括:缓和...
  • 所谓并发,是指在一段时间内,个进程都在向前推进,而在同一时刻,可能只有一个进程在执行,个进程轮流使用处理器。 在单处理器传统中,可能发生的并行和并发现象如下: (2) 进程与进程之间的并发。例如,在...
  • 是否在单个处理器上支持多道程序设计?如何指派进程?这三个问题的处理方法通常取决于应用程序的粒度等级和可用处理器的数目。 2.何谓静态和动态优先级?确定静态优先级的依据什么? 静态优先级在进程创建时即被...
  • 所谓多道程序设计指允许多个程序同时进入一个计算机系统的 主存储器 并启动进行计算的方法。也就是说,计算机内存中可以同时存放多道(两个以上相互独立的)程序,它们都处于开始和结束之间。从宏观上看并行的...
  • 内存管理的需求重定位重定位是指的,在多道程序设计系统中,可用的内存空间往往被多个进程共用,在内存不够用的情况下,一部分进程会被置换到硬盘进行临时存储,一旦进程被置换到磁盘,当下一次被放入处理器执行的...
  • 【4】深入领会多道程序设计技术 本章学习难点 【1】多道程序设计技术 【2】操作系统的特征 习题分析 一.判断改错题(判断由下划线标明的关键词的叙述是否正确,正确的打√,错误的打×并改正。) 1.实时系统只能应用...
  • 一般来说,为了实现多道程序设计,计算机最需要更大的内存 Unix操作系统的进程控制块中常驻内存的proc结构 当(时间片到)时,进程从执行状态转变为就绪状态。 在进程状态转换时,阻塞态→运行态转换不可能发生...
  • 答:多道程序设计技术是指在内存同一时候放若干道程序,使它们在系统中并发运行。共享系统中的各种资源。当一道程序暂停运行时,CPU马上转去运行还有一道程序。 2、什么是SPOOLing? 读者是否觉得将来的高级个人...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 184
精华内容 73
关键字:

)多道程序设计是指(