PASCAL语言程序设计

目录

第一部分 PASCAL语言程序设计 ....................................... 1 第一章 PASCAL语言基础 ............................................. 1

第一节 程序的组成与上机调试运行........................... 2 第二节 常量、变量与数据类型................................ 3 第三节 表达式与标准函数.................................... 6 第四节 赋值语句、输入与输出语句............................ 9 习题....................................................... 12 第二章 程序的三种基本结构 ....................................... 15

第一节 顺序结构........................................... 15 第二节 选择结构........................................... 15 第三节 循环结构........................................... 17 习题....................................................... 20 第三章 数组 .................................................... 22

第一节 一维数组........................................... 22 第二节 二维数组及应用..................................... 25 习题....................................................... 26 第四章 字符与字符串操作 ......................................... 29

第一节 字符和字符数组.................................... 29 第二节 字符串变量......................................... 29 第三节 字符串应用举例..................................... 31 习题....................................................... 33 第五章 函数与过程 .............................................. 35

第一节 自定义函数......................................... 35 第二节 自定义过程......................................... 38 第四节 递归............................................... 42 第五节 递归与回溯......................................... 45 习题....................................................... 50

第一部分 PASCAL语言程序设计

第一章 PASCAL语言基础

Pascal语言是瑞士苏黎士工科大学的Niklans Wirth（沃思）1971年发表的，是为了纪念17世纪法国著名哲学和数学研究者Blaisc Pascal而将它命名为Pascal程序设计语言。Pascal语言是信息学奥赛中普遍使用的程序设计语言。

1 / 53

第一节 程序的组成与上机调试运行

一、程序的组成 我们先看一道例题。

例1-1 输入两个整数a和b，计算a和b的和（a+b）。 【参考程序】

program a1(input,output); //程序首部

var a,b,c:integer; //程序说明部分，a,b,c被说明为整型变量 begin //程序执行部分，下面是程序的内容

write('a='); //在屏幕上输出一个字符串“a=”，输出完后不换行 read(a); //从键盘输入一个数值赋给变量a

write('b='); //在屏幕上输出一个字符串“b=”，输出完后不换行 read(b); //从键盘输入一个数值赋给变量b

c:=a+b; //计算a+b的和，并将这个和赋值给变量c

writeln(a,'+',b,'=',c); //输出a+b=c的等式，输出完后换行 end. //程序结束 【样例输入】 a=10 b=30

【样例输出】 10+30=40

由上可以看出，一个Pascal程序由以下三部分组成： （1）由Program 引导的一行是Pascal程序的首部。

程序首部指出了源程序的名称，是由用户自己给出的，该例子称为a1。程序名后用括号括住的两个参数input与output，通常表示程序运行中的标准输入和输出文件，程序首部以分号结束。

（2）Pascal程序的第二部分是说明部分。

说明部分要求列出程序中引用的全部常量、变量、转移标号、类型、过程和函数的有关说明。若变量c在说明部分没有说明，后边的语句c:=a+b在执行时；翻译软件便能指出其错误并提醒用户加以改正，程序中每个语句都以分号表示结束。

（3）程序的第三个部分是用BEGIN和END括住的一串语句，称为程序的执行部分。有的书中将说明部分和执行部分合称为程序体。

二、PASCAL语言编辑软件的基本操作

下面我们以Free Pascal 1.10系统为例来学习一下Pascal语言编辑软件的使用。 1.Free Pascal的启动

在运行程序目录下(一般是c:\\pp\\bin\\go32v2)运行启动程序fp.exe，即可启动系统。屏幕上出现如图1-1所示的集成环境。

图1-1

2.Free Pascal系统集成开发环境(IDE)简介

最顶上一行为主菜单，中间蓝色框内为编辑窗口，在编辑窗口内可以进行程序的编辑，最底下一行为提示行，显示出系统中常用命令的快捷键，如将当前编辑窗口中文件存盘的命令快捷键为F2，打开磁盘文件命令F3，等等。

2 / 53

3.新建程序窗口

按F10切换到主菜单，选择FILE菜单，执行其中New命令，就可建立一个新的程序窗口（默认文件名为Noname00.pas或Noname01.pas等）。

4.程序的输入、编辑与运行

在当前程序窗口中，一行一行的输入程序。当程序输入完毕之后，一般要先按Alt+F9（或执行compile菜单中compile命令）对程序进行编译。如果程序有语法错误，则会出现一个Compiler窗口，提示你语句错误的坐标。若无语法错误，则窗口正中央会出现一个对话框，提示编译成功。接下来，我们可以运行程序了。

程序的运行可以通过按ALT+R打开RUN菜单中的RUN命令，或直接按快捷键CTRL+F9，则可以在用户窗口中输出运行结果。通常在程序运行结束后系统回到Pascal系统的集成环境，因此要查看运行结果，要按ALT+F5将屏幕切换到用户屏幕。

5.程序的保存与打开

当我们想把程序窗口中的程序存入磁盘时，可以通过按F2键(或执行File菜单中的save命令)来保存程序。第一次保存文件时屏幕上会出现一个对话框要求输入文件名(默认扩展名为.pas)。

当我们要将磁盘上的PASCAL程序打开（装入窗口）时，可按F3(或执行File菜单中的Open命令)来打开程序，此时系统也会弹出一个对话框要求输入要打开的文件名，或直接在文件对话框列表中选择所要打开的文件。

第二节 常量、变量与数据类型

一、常量

（1）常量：在某个程序运行的整个过程中其值不能发生改变的量。 （2）常量定义：常量定义出现在说明部分。它的语法格式是： const

<常量标识符>=<常量>; ...

<常量标识符>=<常量>; 例如： const

pi=3.141592; //此种方式定义的常量在程序中不可以改变

（3）常量定义部分必须以保留字const开头，可以包含一个或几个常量定义，而且每个常量均以分号结束。

二、变量

（1）变量定义：在某个程序的运行过程中其值可以发生改变的量。它应具有以下三个要素：变量名、变量类型和变量值。

（2）变量说明：变量说明出现在说明部分。它的语法格式是： var

<变量列表>:<类型>; ...

<变量列表>:<类型>; （3）变量名

每一个变量必须用一个合适的标识符来命名。

标识符是用来标识处理对象（如常量、变量、类型、过程、函数、程序和文件等）的符号名称。标识符是编程者命名的，自由度很大。命名中应该注意遵循一定的规则，如必须以字母开头，后面可以跟字母、数字和连字符“_”，若有连字符“_”则必须位于标识符中间。如：a,root,tot,t3,exp_1都是合法的标识符，而3a,a#,my%都不是合法的标识符。

（4）变量的类型

在Pascal程序执行的任一时刻，变量总有相应的值。由于变量是有类型的，所以整型变量对应整数值，实型变量对应实数值。

3 / 53

在Pascal语言中规定：在程序中使用的变量必须先定义后使用。如果用到的变量没有定义就使用，程序编译时会出现“Identifier not found X”的错误信息。

例1-2 已知某圆的半径r=15.15，求该圆的面积s？ 【分析】圆的面积s=3.14*圆的半径r*圆的半径r 【参考程序】 program t301;

const pi=3.14;

var s,r:real; //定义两个实型变量s,r begin

r:=15.15; s:=pi*r*r;

writeln(s:10:2); //显示宽度是10，保留两位小数 end. 【输出结果】 47.57 三、数据类型

Pascal语言提供了丰富的数据类型，大致分为以下三类，如图1-2所示：

图1-2

简单类型是指该类型不能再分解为其它类型，而结构类型是由简单类型所组成的，或者说结构类型是由简单类型所构造成的。 1.整型

一个整型数据用来存放整数。Free Pascal支持七种预定义整型，它们是shortint（短整型）、integer（整型）、longint（长整型）、byte（字节型）、word（字类型）、int64和Qword，每一种类型规定了相应的整数取值范围以及所占用的内存字节数。

类型 数值范围 占字节数 Shortint -128..127 1 byte 0..255 1 word 0..65535 2 integer 32768..32767 2 longint -2147483648..2147483647 4 int64 -9223372036854775808..9223372036854775807 8 qword 0..18446744073709551615 8 Free Pascal预定义了两个整型常量标识符maxint和maxlongint，他们各表示确定的常数值，maxint为32767，maxlongint为2147483647，他们的类型分别是integer和longint。

2.实型

Free Pascal语言支持五种预定义实型，它们是real（基本实型）、single（单精度实型）、double（双精度实型）、comp（）、extended（扩展实型），每一种类型规定了相应的实数取值范围、所占用的内存字节数以及它们所能达到的精度。

4 / 53

类型 占字节有效位数 数 real 2.9e-39..1.7e38 6 11..12 single 1.5e-45..3.4e38 4 7..8 double 5.0e-324..1.7e308 8 15..16 Comp(装配实型) -2^63+1..2^63-1 8 19..20 extended（扩展实型） 3.4e-4932..1.1e4932 10 19..20

实型常量包括正实数、负实数和实数零。pascal中表示实型常量的形式有两种。 ⑴十进制表示法

这是人们日常使用的带小数点的表示方法，要求小数点前后必须有数字。如0.0、-0.0、+5.61、-8.0、-6.050等都是实型常量，而0.、.55都不是合法的实数形式。

⑵科学记数法

科学记数法是采用指数形式的表示方法，如1.25×10^5可表示成1.25E+05。在科学记数法中，字母“E”表示10 这个“底数”，而E之前为一个十进制表示的小数，称为尾数，E之后必须为一个整数，称为“指数”。如-1234.56E+26、+0.268E-5、1E5 是合法形式，而.34E12、2.E5、E5、E、1.2E+0.5都不是合法形式的实数。值得注意的是实数的运算比整数的运算速度慢且无法像整数那样精确表示，只能近似表示。

3.布尔型（boolean)

一个布尔型数据用来存放逻辑值（布尔值），布尔型的值只有两个：false（假值）和true（真值）。

4.字符型(char)

字符型只允许单引号中有一个字符，否则就是字符串(string)。如：'A','y','9','7'。 例1-3 有如下程序，运行它，看有什么结果？ program aa;

var a,b:integer; c,d:real; m,n:booLean; ch:char; begin

a:=10; b:=5;

writeln('a=',a,' ','b=',b); c:=a/b;

writeln('c=',c); ch:='T';

writeln('ch=',ch); m:=5>6; n:=10>7;

writeln('m=',m,' ','n=',n); end. 【输出结果】 a=10 b=5

c= 2.000000000000000E+000 ch=T

m=FALSE n=TRUE

例1-4 编写程序，输出如下图形。

数值范围

【参考程序】 program aa; begin

writeln(' $');

5 / 53

writeln(' $$$'); writeln('$$$$$'); end.

第三节 表达式与标准函数

一、算术运算符与算术表达式 1．算术运算符

常用的有以下6个算术运算符：

+(加)、-(减)、*(乘)、/(实数除)、DIV(整除)、MOD(求余)

其中，/(实数除)得到结果为实型，如5.0/2.0=2.5， 4/2=2.0，DIV（求两个数相除后的整数部分），它要求除数和被除数均为整型，结果也为整型，如10 DIV 2=5，5 DIV 10=0，-15 DIV 4=-3，DIV运算只取商的整数部分，参与DIV运算的两个对象不能为实型。mod (求两个数相除后的余数部分)也只能用于整数运算，结果为整数，例如:10 mod 4=2，-17 mod -4=-1，4 mod (-13)=4。

2．算术表达式

在Pascal语言中，算术表达式的意义为：所有符合Pascal语法规则的数值型运算对象（数值型常量、变量、函数）、运算符、圆括号所组成的有意义的式子。

表达式的结果可按标准类型分成算术表达式（运算结果为整型/实型）及布尔表达式（运算结果为布尔型）。

3. 关系运算符和关系表达式

由一个关系运算符将两个类型相容且有序的表达式连结起来的式子，称之为关系表达式，其结果为布尔型（真true或假false）。这里用到的Pascal语言中的关系运算符有：

>(大于) =(等于) <(小于) >=(大于等于) <=(小于等于) <>(不等于)

共六个。

4. 布尔运算及布尔表达式 (1)布尔常量和变量 在Pascal语言中，布尔运算又称为逻辑运算，布尔值也称为逻辑值，它有“真”与“假”两个，分别用“TRUE”与“FALSE”这两个布尔常量来表示的。用来存放逻辑值的变量称为布尔变量，它的作用就是存放一个布尔常量。当然，布尔变量也必须先定义后使用。

例如：VAR T,F:BOOLEAN;

在这里，使用BOOLEAN这个标准类型标识符来定义T与F这两个布尔变量。 (2)布尔运算

布尔运算有三个运算符：Not（逻辑非）、And（逻辑与）、Or（逻辑或）

由一个布尔运算符将两个类型相容且有序的表达式连结起来的式子，称之为布尔表达式。

在一个既包括有布尔运算符，又有关系运算符的表达式中，它们的运算次序为： 1）括号 2）函数

3）NOT（逻辑非）

4）*、/、DIV、MOD、AND 5）+、-、OR

6）>、=、<、>=、<=、< > (3)布尔型数据的输入与输出

在Pascal的程序中，只能通过赋值语句给布尔型变量赋值，不能用READ语句输入一个布尔常量，但可以用write或writeln语句直接输出布尔变量和布尔常量的值。

例1-5 判断程序运算结果 program aa;

var a,b,s,d:integer; L,e,g,f,h,m:boolean;

6 / 53

begin

a:=3;b:=7;

s:=a+b; d:=a div b; L:=a

g:=a>b;f:=e or g;h:=e and g;m:=not h; write('s=',s:5); writeln('d=',d:5); writeln('L=',L);

writeln('e=',e,'g=',g); writeln(f,' ',h,' ',m); end. 【输出结果】

s= 10d= 0 L=TRUE

e=FALSEg=FALSE FALSE FALSE TRUE 二、标准函数

Pascal预先定义了很多种标准函数，其调用格式如下： 变量名:=函数名(自变量参数)； 1．算术函数

算术函数可以直接参与算术运算，函数的自变量和函数的类型均为数值型。 函数名函数标识符 自变量类型 结果类型 说明 称 绝对值 abs(x) 整型、实型 同自变量 求X的绝对值 平方 sqr(x) 整型、实型 同自变量 求X的平方 平方根 sqrt(x) 非负整型、非负非负实数 求X的平方根 实型 x指数 exp(x) 整型、实型 实型 相当于EXP(X)=e(底数为e) 自然对ln(x) 整型、实型 实型 求X的自然对数(底数为e) 数 算术函数使用注意事项： （1）绝对值函数abs(X)与数学中的意义功能相同，如：abs(7.1)=7.1，abs(-16)=16

2

（2）平方值函数sqr(X)即求X值，如：sqr(5)=25

n

（3）在Pascal语言中，若要计算y=X，可以用y=exp(n*LN(x))来表示。

X意义功能相同，运算时要求自变量X>=0。如

果要计算3X的值，那只能借助其它方法了。如： 3X=exp(1/3*LN(x))。

（4）平方根函数sqrt(X)与数学中的

（5）指数函数exp(x)与对数函数LN(x)是一对逆函数。与数学中相应函数的区别在于它们都是以自然对数e(e?2.71828)为底。

2

例如：exp(2)即求e=2.71828*2.71828?7.3890461 反过来，LN(7.3890461)=2 附：对数的定义：

假定a是一个不等于1的正实数(即a?1且a>0)，对于正实数b(即b>0)，如果存在一个实数c，满足a?b 这样的关系式，那么我们说”c是以a为底，b的对数”。并以数学符号logab?c来表示此意义。(注：以a为底 ， b的对数”，其中a叫作logablogab读作”的”底”， b叫作logab的”真数”)

c 2．转换函数

7 / 53

转换函数的功能是可以根据需要将数据类型进行转换。 函数名 函数标识符 自变量函数值类说明 类型 型 截尾 trunc(x) 实型 整型 取x的整数部分 舍入 round(x) 实型 整型 对x四舍五入后取它的整数部分 序号 ord(x) 整型、 整型 求x对应的序号 字符型、布尔型 字符 chr(x) 整型 字符型 求x对应的字符 转换函数使用注意事项：

（1）截尾函数trunc(x)可以将实数型自变量x的小数部分截去，函数值为整数。如：trunc(17.8)的值为17，trunc(-6.41)的值为-6。

（2）舍入函数round(x)是将实数型自变量x的小数部分四舍五入，取它的整数部分。如: round(17.8)的值为18，round(-6.1)的值为-6。

（3）当序号函数的自变量为字符时，函数值为该字符的 ASCⅡ码，当自变量为整型数据时，则ord(x)的值为自变量本身，当自变量为BOOLEAN 时，Pascal中规定：FALSE的序号为0，TRUE的序号为1。如：ord('A')=65，ord('a')=97，ord('0')=48，ord(68)=68，ord(FALSE)=0，ord(TRUE)=1。

序号函数ord(x)与字符函数chr(x)的功能相反，它们是一对逆函数。如：chr(ord('A'))= 'A'，ord(chr(96))=96。

3．顺序函数 函数名称 函数标识符 自变量类型 函数值类说明 型 前趋 pred(x) 整型、 整型、 求x的前一个数据 字符型、 字符型、若x是第一项，则函数无意义 布尔型 布尔型 后继 succ(x) 整型、 整型、字求x的后一个数据 字符型、 符型、布若x是最后一项，则函数无意义 布尔型 尔型 顺序函数使用注意事项： （1）前趋函数pred(x)和后继函数succ(x)是一对逆函数。如：pred(succ(x))=x，succ(pred(x))=x。

（2）顺序函数的自变量x必须是一个有顺序的数据类型，如实数型的数虽然能比较大小但无法确定x前一项和后一项到底是什么数，所以实型数没有前驱和后继。

（3）当自变量x为数据第一项时，它没有前驱，如pred(FALSE)无意义；当自变量x为最后一项时，它没有后继。如succ(TRUE)无意义。

4．逻辑判断函数 函数名称 函数标识自变量类函数值类型 说明 符 型 奇函数 odd(x) 整型 布尔型 判断x的奇偶性 奇函数使用注意事项： 奇函数的值为BOOLEAN类型，即只存在“真”(TRUE)和“假”(FALSE)。如：odd(5)=true，odd(10)=false

8 / 53

第四节 赋值语句、输入与输出语句

一、赋值语句 1．格式：

变量:=表达式；

2．使用说明：

（1）该语句具有先计算后赋值的功能，即先计算出来表达式的值，然后将其值赋给左边的变量或函数标识符，注意：一个赋值语句只能给一个变量赋值。

（2）“:=”称为赋值号，要注意不能与关系运算符“=”混淆，只有在赋值语句中才能使用赋值号，赋值号具有方向性，是将赋值号右边表达式的值计算出来，赋予赋值号左边的变量，所以赋值号的左边只能是变量，并且赋值号两边的类型应该具有赋值相容性，如整型的值可以赋值给实型变量，反之则不行，字符型可以赋值给字符串型变量，反之也不行。

（3）被赋值的变量本身可以作为因子参与运算，如n:=n-1，i:=i+1，s:=s+x。 例1-6 写出执行下面的程序运行后，变量A、B、C的值。 program a16;

var a,b:integer; c:real; begin

a:=200;

b:=a div 10; c:=a;

writeln(a:7,b:7,c:7:2); end.

二、输入语句（读语句） 1．格式：

read(输入项)； 或 readln<(输入项)> 2．使用说明：

（1）执行该语句时，从键盘上（或文件中）读入数据，将其值依次赋给输入项中的变量。注意输入的数据必须是常量，且输入的数据类型必须和变量一一对应。

（2）输入项中的括号内应是一组变量，这里一组的含义是可以为一个，也可以是多个，若是多个时，各变量之间必须用逗号分隔，最后一个没有符号，他们必须在程序说明部分预先说明，他们可以是整型、实型或字符型等数据类型，但不能是布尔型，因为布尔型不可以直接读入。

如：Read(a,b,c,d)； 或 Readln(M,N,L)；

（3）程序运行后，执行到Read或Readln语句时，系统处于等待状态，等待用户从键盘上输入数据，且当输入项中的变量为多个时，要求输入的相应数据个数不能少于其变量的个数，当输入的数据个数少于变量个数时，系统仍处于等待状态，接着输入的数据无论是换行输入还是不换行输入均有效。

注意：输入数值（整型或实型）数据时，数据间用空格或回车键分隔，最后一定要有一个回车，表示输入结束；输入字符型数据时，数据间不能用空格分隔，可以连续输入（不用空格）或用回车键一个一个字符分隔输入。

（4）READ与READLN的区别：

read语句是一个接一个地读数据，在执行完本Read语句(读完本语句中变量所需的数据)后，下一个读语句接着从该数据输入行中继续读数据，也就是说，不换行。Readln则不同，在读完本Readln语句中变量所需的数据后，自动换行，该数据行中剩余的数据多余无用，并且readln可以不带参数表，即可以没有任何输入项，只是等待读入一个换行符(回车)，经常用于暂停程序的运行，直到输入一个回车。

例1-7 设I，J，K是整型变量，现需将30，20，10分别赋给这三个变量，要求写出对应于下列语句的所有可能的输入格式：read(i,j,k);

解：所有可能输入格式如下（注：其中用“□”来表示空格，每一行后均有一个回车，以下均同）：

9 / 53

（1）30□20□10 （2）30□20 10 （3）30

20□10 （4）30 20 10

例1-8 设A，B，C是字符型变量，现需将'P'，'A'，'S'分别赋给这三个变量，要求写出对应于下列语句所有可能的输入格式：read(a,b,c);

（1）PAS （2）PA S （3）P AS （4）P A S

例1-9 设a,b,c,i,k,j,L,m,n为整型变量，则下面语句的赋值情况是：

Readln(a,b,c);

Readln(i,k,j,L); Readln(m,n); 输入数据： 1□2□3□4□5 6□7□8□9□0 10□20

读入结果为：

1□2□3（分别对应a,b,c，后面的4,5被忽略） 6□7□8□9（分别对应i,k,j,L，后面的0被忽略） 10□20（分别对应M,N） 三、输出语句（写语句） 1．格式：

write(输出项) 或 writeln<(输出项)> 2．使用说明：

（1）执行该语句时，按指定的格式将输出项的内容输出。

（2）输出项中括号内的项目内容可以是一组常量、变量、表达式或字符串，一组的含义是可以为一个，也可以是多个，若是多个时，各输出项之间必须用逗号分隔，最后一个没有符号。

如：WRITE('A+B=',A+B);或WRITELN(3,'*',N,'=',L); （3）输出项中的各个不同项目其输出的结果分别是：

当输出项为常量时，直接输出该常量的值；当输出项为变量时，输出该变量存储单元内的内容，变量允许属于任何一种标准数据类型；当输出项为表达式时，则首先对表达式进行计算，然后输出计算的结果；当输出项为字符串时，原样输出用单引号括起来的字符串中的内容。

（4）Write语句与writeln语句的区别:

write语句将其后括号中的表达式一个接一个输出后，没有换行。而writeln语句则在输出各个表达式的值后换行。

例如以下两个程序段的输出分别为： (1)write(1,2,3,4); write(5,6); 输出为：

10 / 53

123456

(2)writeln(1,2,3,4); write(5,6); 输出为： 1234 56

例1-10 请写出下面程序的输出结果。 const a=20; var b:integer; begin b:=60;

writeln(100); writeln(b); writeln(a+b);

writeln('A+B=',a+b) end.

【输出结果】

100 //直接输出该常量的值

60 //输出该变量存储单元内的内容 80 //输出计算的结果

A+B=80 //原样输出字符串中的内容及输出a+b表达式的结果 4．输出语句的输出格式

在Pascal语言中，我们将每一种类型的数据在输出时所占据的列数称为场宽，下表是Pascal对各种数据定义的标准场宽（要注意各种计算机系统对标准场宽的约定不同）：

数据类型 整数 实型(real、single) 布尔型 4或5 字符型 1 Pascal对各种数据定义的标准场宽 标准实例 输出结果 场宽 实际WRITE（1234）; 1234 整数长度 23 Write(3/7); 4.285714285714285E-001 T:=false;write(t); FALSE Write('A'); 字符串型 串长 Write('Pascal') A Pascal

在编程时，我们除了可以使用上表中的标准场宽，还可以根据实际需要自己来定义要输出数据的场宽，自定义场宽分为单场宽和双场宽。

（1）单场宽

11 / 53

格式：X:n，其中X表示要输出的项目，n表示输出X时所占的位数，应为正整数。如：writeln(‘PAS ‘:5);表示项目字符串’PAS’的场宽为5。它主要用来输出整型、字符型、布尔型的数据。

例1-11 设M为整型数2009，CH为字符’#’，F为布尔值FALSE，此时执行如下输出语句：

writeln (M:5); writeln (CH:5); writeln (F:5);

writeln (‘PAS’:5); 则屏幕显示： □２００９ □□□□＃ ＦＡＬＳＥ □□ＰＡＳ （2）双场宽

格式：X:n1:n2，双场宽是用来输出实型数据的。其中：X表示要输出的项目，n1表示输出X时所占总位数，包括符号位、整数部分、小数点与小数部分，n2表示小数部分的位数，当n2小于实际小数位数时，要对舍去的小数位数进行四舍五入。当n2大于实际小数位数时，右边以零补齐。

要注意的是，在数据不突破场宽限制时，一律按场宽定义输出，在数据突破了场宽限制时，则强行将场宽扩展到所需要的位数，所以有时输出限制仅有小数位N2时，一般设总场宽为0，即：X:0:N2，如对X要求保留两位小数，写法为：writeln(X:0:2);

例1-12 写出以下程序的输出结果： program aa;

var a:integer; b:real; c:char; d:boolean; begin

a:=1234;

b:=1234.6793; c:='$'; d:=false;

writeln(a,a:5); writeln(b,b:12:2); writeln(b:0:2) writeln(c,c:5); writeln(d,d:5); writeln('OK':5); end.

【输出结果】 1234□1234

□ 1.234679300000000E+003□□□□□1234.68 1234.68 $□□□□$ FALSEFALSE □□□OK

习题

1-1 在屏幕上打印一行字符:\，请同学们将以下程序输入计算机内并运行。(运行程序：Ctrl+F9，查看程序运行：Alt+F5) program k101;

12 / 53

begin

writeln('This is my first program!'); end.

1-2 编写一个减法程序,输入两个整数（<30000），输出这两个整数的差(第一个数减去第二个数)。

【样例输入】30 10 【样例输出】20

1-3 编写一个乘法程序，输入两个整数（<100），输出这两个整数的乘积。 【样例输入】20 10 【样例输出】200

1-4 输入正方形的边长（边长为整数），求正方形的面积？ 【样例输入】5 【样例输出】25

1-5 小明的妈妈给小明100元钱，让他去文具商店买他自己所需要的文具，他买了10元1支的钢笔2支，花5元买了一瓶蓝色墨水，批发了23元的作业本，最后，走的时候又买了1支1元的冰糕吃着走了，现在问小明最后还剩多少钱？

1-6 求任意长a和宽b的长方形的周长c。总场宽为10，保留两位小数。 【分析】长方形周长c=2*(长a+宽b)。

【样例输入】2 3 【样例输出】c= 10.00

1-7 已知三角形的底为5，高为10，求三角形的面积？要求保留两位小数。 【分析】三角形的面积S=1/2*底a*高h。 【输出结果】 25.00 1-8 判断程序运行结果 program aa;

var a,b:integer; begin a:=3; b:=a; b:=a+1; a:=a+1; b:=b+1;

writeln(a,' ',b); end.

1-9 输入三个整数a,b,c(0

【样例输入】5 10 20 【样例输出】0.50 200

1-10 用键盘输入两个整数a,b (0b的值。 【样例输入】12 9 【样例输出】TRUE

1-11 有三个小朋友甲乙丙。甲有50粒糖果，乙有43粒糖果，丙有13粒糖果。现在他们做一个游戏，从甲开始，将自己的糖分三份，自己留一份，其余两份分别给乙与丙，多余的糖果自己吃掉，然后乙与丙也依次这样做，问最后甲、乙、丙三人各有多少粒糖果？

1-12 试编一程序，输入一梯形的上底a、下底b、高h，求该梯形的面积s。结果保留3位小数。

【分析】梯形面积s=(a+b)*h/2，a,b,h,s均为实数。 【样例输入】12.5 9.2 8 【样例输出】86.800

1-13 已知A1、A2和A3的布尔值分别是：True、False、False，计算下列表达式的值。

（1）not a1 and not a2= （2）al or a2 and a3= （3）(not a1 or a2) and (a2 or a3)=

1-14 输入两个整数,将两个数交换值后输出。 【样例输入】26 90 【样例输出】90 26

1-15 输入一个字符，打印出它的前导值、后继值和序号。每一项中间隔一空格，最后无空格。

【样例输入】D 【样例输出】C E 68

13 / 53

1-16 读入摄氏温度c，写程序将它转换成华氏温度f输出。已知f=9/5*c+32。

1-17 输入一个三位自然数，把这个数的百位与个位数对调，输出对调后的自然数。 【样例输入】312 【样例输出】213

14 / 53

第二章 程序的三种基本结构 第一节 顺序结构

若程序按照语句的书写先后顺序逐句执行，直到程序的结束，这种程序结构我们称为顺序结构。这是程序设计中最简单的一种结构。如程序中N个语句：

语句1； 语句2； ?? 语句N；

若运行时的顺序是语句1执行后执行语句2，语句2执行后执行语句3，?直到语句n-1执行后执行语句N。那么程序中语句1；??语句N；便是一个顺序结构的部分，它是结构化程序设计的基础。注意每条语句以分号表示结束。

第二节 选择结构

一、复合语句

复合语句的一般形式是： BEGIN

语句1； 语句2； ?? 语句n; END;

在这里，BEGIN与END起语句括号的作用，相当于使用了一个语句括号将若干语句括了起来，做一个语句处理。程序运行时，通常是按书写的顺序去执行复合语句内的各个语句。

二、条件语句（IF语句）

1.格式：IF语句有以下两种标准格式： （1）if 条件表达式 then 语句；

（2）if 条件表达式 then 语句1 else 语句2； 2.功能

（1）格式1的IF语句的执行过程是：若条件关系式的条件为真，则执行THEN后面的语句，当条件不成立时，退出IF结构，去执行IF语句下面的语句。

（2）格式2的IF语句的执行过程是：若条件关系式的条件为真，则执行THEN后面的语句，否则执行ELSE后面的语句。要特别注意else前面的语句1最后不能有分号，因为分号是两个语句之间的分隔符，而else并非语句，如果在该处添了分号，则在编译的时候就会认为if 语句到此结束，而把else当作另一句的开头，输出出错信息。

例2-1 输入两个整数a,b，将它们由小到大输出。 【样例输入】56 32 【样例输出】32 56 【参考程序】 program aa;

var a,b,t:integer; begin

read(a,b);

if a>b then //如果第一个数大于第二个数，则两个数互换 begin

t:=a; a:=b; b:=t; //两个数互换

15 / 53

end;

writeln(a,' ',b); //输出运算结果 end.

例2-2 输入一个三位数的整数，将数字位置重新排列，组成一个尽可能大的三位数。 【样例输入】213 【样例输出】321

【分析】先用DIV、MOD结合分离出来整数的每一位数字，然后将这三位数字按照由大到小进行排序，然后把最大的作为百位数，次之作为十位数，最小的作为个位数即可。

【参考程序】 program aa;

var t,a,b,c,n:integer; begin

read(n);

a:=n div 100;

b:=n div 10 mod 10; c:=n mod 10;

if a

例2-3 小红开了一个花店，她规定凡在店里购花不超过50元时，按九折付款，如超过50元，不到200元，超过50元部分按七点五折收费，如果超过200元，超过200元部分，将按6折收费。现在她想请你帮她编一程序完成花店自动计费的工作。

【分析】根据题意，我们可以得到计费S的收费公式：

【样例输入】50 【样例输出】45.00 【参考程序】 program aa;

var p,s:real; begin

read(p); //输入应付款数

if p<=50 then s:=0.9*p //进行自动计费 else if p<=200 then s:=0.9*50+(p-50)*0.75 else s:=0.9*50+150*0.75+(p-200)*0.6; writeln(s:0:2); //输出实际付款数 end.

三、CASE语句 1.格式：

CASE语句又称为分情况语句，格式如下： case 测试表达式 of

情况标号1：语句1； 情况标号2：语句2； ??

情况标号n：语句n；

16 / 53

//可选项 end; 2．功能

（1）先计算出测试表达式的值，注意：这个测试表达式中不能含有trunc、round函数，测试表达式的值不能是实数。

（2）然后用测试表达式的值依次与各情况标号进行对照，当找到一个与测试表达式的值相匹配的情况标号，就去执行该CASE情况标号后面的语句块，然后跳到与CASE相对应的END后面的语句继续执行。

（3）如果找不到与之匹配的情况标号（若有ELSE则执行它后面的语句），退出CASE语句，执行它后面的语句。

例2-4 打印某年某月有几天。 【样例输入】2000 2 【样例输出】29 【参考程序】 program aa; var

y,m,d:integer; begin

read(y,m); //读入年和月 case m of

1,3,5,7,8,10,12:d:=31; 4,6,9,11:d:=30;

2:if (y mod 4=0) and (y mod 100<>0) or (y mod 400=0) //判断闰年布尔表达式

then d:=29 else d:=28; end;

writeln(d); //输出这个月的天数 end.

第三节 循环结构

一、计数循环

1．其语句格式是：

(1)for 控制变量:=初值 to 终值 do 一条语句;

(2)for 控制变量:=初值 downto 终值 do 一条语句;

其中for、to、downto和do是Pascal语言保留字，一条语句可以是一条简单语句或一条复合语句，但只能是一条语句，它适合用于能事先确定循环次数的事件。

2．执行过程

（1）先将初值赋给左边的变量（称为循环控制变量）；

（2）判断循环控制变量的值是否已\超过\递增是大于，递减是小于)终值，如已超过，则跳到步骤（6）；

（3）如果未超过终值，则执行do后面的那个语句（称为循环体）； （4）循环变量递增（对to）或递减（对downto)１； （5）返回步骤（2）；

（6）循环结束，执行for循环下面的一个语句。 3．注意事项

（1）for循环控制变量必须是顺序类型的变量，如整数，但不能是实数，也不能是8字节整型，如int64、qword等。

17 / 53

（2）for语句的循环体中不能修改循环控制变量，它将会自动增加或减少。 （3）break：中断当前所在的循环。

例2-5 输入n(0<=n<=200)，计算从1累加到n之和。

【分析】设置一个循环变量初值为1，终值为n，重复进行n次加法的循环。每次将循环控制变量(I)的值迭加在S中，不断重复该过程，故当循环结束的时候，S变量表示的就是总和了。s:=s+i;这里的s称为累加器，它使用前要清0。

【样例输入】100 【样例输出】5050 【参考程序】 program aa;

var i,n,s:integer; begin

read(n); s:=0;

for i:=1 to n do s:=s+i; writeln(s); end.

例2-6 输入一个自然数x（x<=10000），求这个自然数的所有约数之和s。

【分析】如果某数i能被x整除，则有x mod i=0，要找出x的所有约数，也就是要让1至X循环并进行断定。

【样例输入】2328 【样例输出】5880 【参考程序】 program aa;

var x,i,s:integer; begin

read(x);

s:=0; //累加器使用前要清0

for i:=1 to x do //求X的所有约数和

if x mod i=0 then s:=s+i; //如果i是x的约数，则将i累加到s中

writeln(s); end.

例2-7 假设有一个三位数a，将它的个位数字与十位数字对调后得到一个新数b，此时b恰好比a 大27，请编程找出所有这样的三位数。

【输出结果】 103 ?? 169

【参考程序】 program aa;

var a,b,t,k:integer; begin

for a:=100 to 999 do begin

t:=a mod 10; //得到a的个位数

k:=(a div 10) mod 10; //得到a的十位数字 b:=100+t*10+k; //组合一个新数b

if b-a=27 then writeln(a); //用式子b-a=27筛选出符合条件的数a并输出

end;

18 / 53

end.

例2-8 求100以内所有素数，输出时数与数之间隔一空格。

【分析】若i存在约数，肯定不是素数，所以让f=1，中断循环退出。如果是素数，则f=0，就输出i。

【输出结果】2 3 5 7 ?? 89 97 【参考程序】 program aa;

var i,j,k,p,f:integer; begin

for i:=2 to 100 do begin f:=0;

for j:=2 to i div 2 do //判断i是否为素数，如果不是，则f的值变为1

if i mod j=0 then begin f:=1; break; end;

if f=0 then write(i,' '); //若经过上面的程序段，f的值没有改变，则i是素数并输出它

end; writeln; end.

二、当型循环

1．语句格式： while 布尔表达式 DO 一条语句 2．注意事项：

（1）执行过程：先求出布尔表达式的值，当其值为真（TRUE）时，重复执行指定语句，当其值为假（FALSE）时，终止循环。注意这里的一条语句可以是一条简单语句，也可以是一条复合语句。

（2）为了能使WHILE循环正常终止，表达式中所含变量在循环指定的语句中一定要有更改，即有可能使表达式的值为假，以便循环能够结束，否则循环永不结束，而出现死循环。

（3）由于先判断条件，所以布尔表达式中的变量必须在循环语句开始之前先赋初值，如果当条件一开始就不成立，这时将跳过WHILE语句执行它下面的语句。

例2-9 输入若干个字符，它的终止符是’.’，计算输入的字符中字母’A’出现的次数（包含大小写）。

【分析】先读入一个字符赋给ch，然后进入while循环，若是'A'（或'a'），则s累加1，再读入下一个字符，最后输出s的值。

【样例输入】sdkfjaAgsdfAdsfsAs323sdfs. 【样例输出】4 【参考程序】 program aa;

var ch:char; s:integer; begin s:=0; read(ch);

while ch<>'.' do begin

if (ch='a')or(ch='A') then s:=s+1; read(ch); end; writeln(s); end.

例2-10 求输入的一个整数N(0

19 / 53

【样例输出】270 【参考程序】 program aa;

var n,t,s:integer; begin

read(n); s:=1; //s为累乘器，它使用前要置1 while n<>0 do begin

t:=n mod 10; s:=s*t; n:=n div 10; //每次分离出n的个位数赋值给t，并将之累乘到s中，然后将个位数字去掉

end; writeln(s); end.

例2-11 求两个自然数m，n的最小公倍数。 【样例输入】12 8 【样例输出】24 【参考程序】 program aa;

var m,n,i,s:longint; begin

read(m,n); //输入两个自然数m,n

i:=1; //让一个变量i呈自然数列增长，刚开始设为1 s:=m*i; //s为m的倍数

while s mod n<>0 do //若s又刚好是n的倍数，则s就是m,n的最小公倍数

begin i:=i+1; s:=m*i end;

writeln(s); //输出最小公倍数 end.

习题

2-1 判断下面题目是否正确

（1）复合语句与程序执行部分的“Begin..End”意义相同。 （2）布尔型数据是顺序型数据。 （3）NOT false 的值是False。 （4）一个变量或常量不可以看成为一个表达式。 2-2 判断读入的整数a是奇数还是偶数，若是奇数，输出“jishu”，否则输出“oushu” 【样例输入】5 【样例输出】jishu

2-3 输入三个数，将它们按由大到小的顺序输出。 【样例输入】12 56 9 【样例输出】56 12 9

2-4 根据学生的成绩给予相应的等级，若成绩在90-100之间输出A，在80-89之间输出B，在60-79之间输出C，60以下输出D。现在输入一个学生的成绩S（0<=S<=100），请输出这个学生的成绩等级。

【样例输入】85 【样例输出】B

2-5 某服装公司为了推销产品，采取这样的批发销售方案:凡订购超过100 套的，每套定价为50 元，否则每套价格为80元。现输入订购套数，输出应付款的金额数。

20 / 53

2-6 某市出租车起步价8元，可以行使3公里，3公里以后，按每公里1.6元计算，现输入出租车行驶的公里数，输出顾客需付费多少元？

2-7 打印出如下图形:（字符之间无空格）

2-8 求N!=1*2*3*?*N ，这里N不大于10。提示：注意累乘器使用前要置1 2-9 输出1－100之间的所有偶数。数字间隔一空格，每行输出10个数。 2-10 输出1-N（N<=100）之间的奇数和。（用whiLe循环做） 【样例输入】100 【样例输出】2500

2-11 输入30个学生的成绩，分别统计成绩在85—100分，60—84分，60分以下，各分数段中的人数。

2-12 输入若干个字符，它的终止符是'$'，计算输入的字符中小写字母'b'出现的次数。

【样例输入】abcdBcabcdaasdccbdfasd$ 【样例输出】3 2-13 求输入的一个整数的各位数字之和。（用whiLe循环做） 【样例输入】2359 【样例输出】19

2-14 求恰好使s=1+1/2+1/3+?+1/n的值大于K（K<=10）时n的值。 【样例输入】10 【样例输出】12367

2-15 求两个自然数M，N的最大公约数（M,N<=30000）。

2-16 百钱百鸡问题。一只公鸡值5元，一只母鸡值3元，３只小鸡值１元，现用一百元买一百只鸡，问有多少种方案？（某种鸡可以有0只）

2-17 老师面前摆了一堆铅笔，学生问有多少支铅笔，老师说，有100多支，并且若三个三个数，剩二个，若五个五个数，剩三个，若七个七个数，剩五个。请你编一个程序计算出这堆铅笔至少有多少支？

2-18 警察局抓了a,b,c,d四名偷窃嫌疑犯，其中有一人是小偷，审问中: a说:\我不是小偷\说:\是小偷\说:\小偷肯定是d\说:\冤枉人\现在已经知道四人中三人说的是真话，一人说的假话，问到底谁是小偷？输出小偷代号，用小写字母表示。

2-19 小球从100米高处自由落下，着地后又弹回高度的一半再落下。求第15次着地时, 小球共通过多少路程?

2-20 求2009个1997的乘积的最后两位数是多少？ 2-21 找出被2、3、5除时余数为1的最小的十个数。 2-22 把一张一元钞票换成一分，二分和五分的硬币，每种至少一枚，问有哪几种换法？

21 / 53

第三章 数组 第一节 一维数组

一、定义

数组是按一定顺序排列且具有相同性质的变量的集合。数组根据下标个数的不同，可分为一维数组、二维数组和多维数组，我们先学习一维数组的使用方法。

一维数组语句格式： TYPE

标识符= array [下标范围] of 基类型； 在定义数组时，应注意：

“下标范围”中的下标为顺序类型之一的整型、字符型、布尔型、子界型等，但不能为实型。

下标范围决定的是数组元素下标的类型，同时也决定了数组中元素的个数。 如： Type

arraytype=array [1..10] of integer;

其中下标范围1..10的类型为子界类型（所谓子界类型，是指取一种数据类型的一部分作为新的数据类型），表明数组元素的个数为10个。其中1称为子界类型的“下界”，10称为子界类型的“上界”，上界和下界必须是同一个顺序类型，即同为整型、字符型或布尔型等，但不能是实型。也就是说，子界类型决定了该类型变量可以取值的范围（介于下界与上界之间）。在这里，下界和上界必须是属于同一个有序类型的常量，且下界的序号必须小于上界的序号（即前面的必须小于后面的）。

基类型决定了该数组能存放什么类型的值，同一数组的各元素均具有相同的数据类型。 二、数组元素的输入、输出

例3-1 按照顺序读入以下十个数据，然后以逆序方式输出。 【样例输入】13 7 1 29 36 65 38 23 19 10 【样例输出】10 19 23 38 65 36 29 1 7 13 【参考程序】 program aa; const n=10;

type arraytype=array[1..n] of integer; var a:arraytype; i:integer; begin

for i:=1 to n do read(a[i]); //顺序读入10个数据

for i:=n downto 2 do write(a[i],' '); //逆序输出后9个数据，每个数据后加一空格

writeln(a[1]); //第一个数据单独输出，后面无空格。 end.

三、数组的查找

查找也称检索或搜索。它是按照某种方法确定某一待查数据位置的一种基本运算操作。 1．顺序查找法

顺序查找法又称线性查找法，是最基本的一种查找方法，这种方法对所查数据所在的数据表没有任何特殊要求。

顺序查找的过程是：从头开始，根据给定的值，依次与数据表中的关键字进行比较，相同即为找到，给出相关信息，若查遍整个数据表仍然未找到，即表示该元素不存在。

2．折半法查找

也称二分法查找，它要求数据表中的元素是有序的。查找过程如下：

22 / 53

条件：有n个连续递增的数A[1],A[2],??，A[n]，查找X，设p:=1；t:=n； 方法:(1)求中点:m=(p+t) DIV 2

(2)A[m]=X 中点值等于查找值，打印并结束 (3)A[m]X 将t:=m-1转(1)

此种方法，首先是将要查找的数据项与数据表的中间项进行比较，若相等则表示已查到，结束查找过程，否则，继续往下进行，若中间项数据大于查找数据项，则可知要查找的数据在表的前半部，反之则在后半部。然后再选定相应的前（后）部的一半，重复上述过程。在查找的过程中，不断地将数据区域分半，使需查找的数据所在范围越来越小。由此可见，它要比顺序查找的效率高得多，是最常用的查找办法，适用于数据较多的情况下。

例3-2 先输入10个递增排列的数，然后输入一个数X，看它是否在这10个数中，若在，输出它的位置，否则输出’not in’。

【样例输入】 //两行，第一行是10个数，第二行是要查找的数 2 18 23 27 35 39 47 48 55 69 48

【样例输出】 //一行，查找的结果 8

程序一：二分法查找，思考一下查找了多少次 program aa; var

p,t,i,f,m,x:integer;

a:array[1..10] of integer; begin

for i:=1 to 10 do //输入10个递增的数据 read(a[i]);

read(x); //输入待查找的数据x p:=1; t:=10;f:=0; while p<=t do begin

m:=(p+t) div 2;

if a[m]=x then //找到了，输出m，并使f的值为1，然后中断while循环

begin

writeln(m); f:=1; break; end else

if x>a[m] then p:=m+1 //若x>a[m]，则待查找的数据在后半部分。 else t:=m-1; //若x

if f=0 then writeln('not in'); //f=0，没有找到，输出not in end.

程序二：顺序查找法 program aa;

const n=10;

type ash=array[1..n] of integer; var a:ash; m,x,i:integer; begin

for i:=1 to n do read(a[i]); readln(x);

23 / 53

m:=0;

for i:=1 to n do

if a[i]=x then begin m:=i; break; end; if m>0 then writeln(m) else writeln('not in'); end.

思考：若在1000个数据中查找一个数，程序一和程序二分别最多查找多少次，可以确定该数据是否存在数据表中？

四、数组元素的移动与插入

当一个数组建立好后，有时会根据问题的需要，移动一下各元素中的数据位置或在数组中插入一个数据。

例3-3 将A数组中从第M个元素起一直到最后的元素平移到数组的开头，并把A[1]到A[M-1]中的元素向后顺移，如图所示。

图3-1

【样例输入】 //两行，第一行是6个数，第二行是M的值 1 2 3 4 5 6 3

【样例输出】 //一行，移动结果，两个数之间隔一空格，最后无空格 3 4 5 6 1 2 【参考程序】 program aa; const n=6;

type arraytype=array[1..n] of integer; var a:arraytype; i,j,m,k:integer; begin

for i:=1 to n do read(a[i]); //读入n个数据 m:=maxint;

while (m>n) or (m<=0) do //保证m的值在数组下标范围内 readln(m);

for j:=1 to n-m+1 do //共需进行n-m+1次移动 begin

k:=a[n]; //将最后一个数据放到暂存单元k中

for i:=n-1 downto 1 do a[i+1]:=a[i]; //移动数组元素，空出数组第一个位置

a[1]:=k; //将暂存单元k中的元素放入数据第一个位置 end;

for i:=1 to n-1 do write(a[i],' '); //按要求输出移动后的数组元素 writeln(a[n]); end.

例3-4 先读入10个由小到大排列的数，然后将一个数X插入到这个有序的数列中，要求插入后该数列仍然有序。

【样例输入】 //两行，第一行是要插入的数X，第二行是10个数 6

1 2 3 4 5 6 7 8 9 10

【样例输出】 //一行，插入后的数列 1 2 3 4 5 6 6 7 8 9 10

24 / 53

【参考程序】 program aa;

var a:array[0..11]of integer; i,j,k,x:integer; f:boolean; begin

k:=10; readln(x); //输入要插入的元素

for i:=1 to k do read(a[i]); //对数组元素进行赋值 j:=1;

while (x>=a[j]) and (j<=k) do j:=j+1; //寻找x应插入的位置 if j>k then a[j]:=x //插入到数组的最后 else begin

for i:=k downto j do a[i+1]:=a[i]; //移动数据元素，空出第j个位置

a[j]:=x; //插入x到数组第j个位置 end;

for i:=1 to k do write(a[i],' '); //输出 writeln(a[k+1]); end.

第二节 二维数组及应用

一、二维数组的定义

和一维数组一样，要在程序的说明部分的类型说明中对二维数组进行定义。它的一般形式为：

TYPE

数组类型名=array[行下标范围，列下标范围] of 数组元素基类型 对二维数组的输入与输出也可用二重循环来实现: 输入:

for i:=1 to 5 do

for j:=1 to 4 do read(a[i,j]); 输出:

for i:=1 to 5 do begin

for j:=1 to 4 do write(a[i,j], ' '); writeln; end;

从二维数组的定义可以看出，和一维数组相比较，二维数组在定义时一定要指定两个下标。行下标范围用来指定行下标的类型和它的取值范围，列下标范围用来指定列下标的类型和它的取值范围。

二、二维数组元素的输入与输出

例3-5 输入5名学生4门功课的考试成绩，输出各人各科成绩及总分，成绩均为整数。 【样例输入】 //每行4个数据，数据间隔一空格 23 45 67 89 90 87 76 67 90 78 67 45 86 87 98 76 67 86 90 91

【样例输出】 //共三行，每行5个数据，前4个是各科成绩，第5个是总成绩，数据间隔一空格，最后无空格。

23 45 67 89 224

25 / 53

90 87 76 67 320 90 78 67 45 280 86 87 98 76 347 67 86 90 91 334 【参考程序】 program aa;

var i,j:integer; a:array[1..5,1..5] of integer; begin

for i:=1 to 5 do //输入学生的原始成绩 for j:=1 to 4 do read(a[i,j]);

for i:=1 to 5 do //计算每个学生的总分，放入该行的第5个数据元素中 begin

a[i,5]:=0;

for j:=1 to 4 do

a[i,5]:=a[i,5]+a[i,j]; end;

for i:=1 to 5 do //输出结果 begin

for j:=1 to 4 do write(a[i,j], ' '); writeln(a[i,5]); end; end.

习题

3-1 按照顺序读入以下8个数据（每个数据<=100），然后以正序方式输出。数字间隔一空格，最后无空格。

【样例输入】3 47 -81 23 66 35 18 -23 【样例输出】3 47 -81 23 66 35 18 -23 3-2 按照顺序读入以下8个数据（每个数据<=100），然后以正序方式输出奇数位上的数。

【样例输入】3 47 -81 23 66 35 18 -23 【样例输出】3 -81 66 18 3-3 读入十个整数，将它们反序打印，并输出它的总和。 【样例输入】1 2 3 4 5 6 7 8 9 0

【样例输出】 //数字间隔一空格，最后无空格，第一行是10个整数，第二行是它的总和

0 9 8 7 6 5 4 3 2 1 45

3-4 读入6个数，打印出其中的最大数和最小数，两个数之间隔一空格。 【样例输入】89 77 234 221 900 23 【样例输出】900 23 3-5 读入两个整数N和M，然后再读入N(N<=10)个递增整数，查找M是否在该数列中。如在，打印其位置，否则打印-1。注意:用折半查找法数组元素必须是递增有序的。

【样例输入】 //第一行是N和M，第二行是N个数 9 56

1 2 56 456 567 678 789 798 810 【样例输出】 //一行，查找结果 3

3-6 读入8个数据,将其最后两个数据依次移到数据前面，原来的数据依次后移，打印移动后的数据。

【样例输入】1 2 3 4 5 6 7 8 9 0 【样例输出】9 0 1 2 3 4 5 6 7 8

26 / 53

3-7 先读入一个整数X，再读入8个由小到大排列的整数，然后将数X插入到第3个位置，打印插入后数列。

【样例输入】 //两行，第一行是要插入的数X，第二行是8个数 56

10 20 30 36 45 58 69 79

【样例输出】 //一行，插入后的数列 10 20 56 30 36 45 58 69 79

3-8 先读入M和K，然后再读入10个数据，将M插入到该数列中的第K个位置中，打印操作后的数列。

【样例输入】 //两行，第一行是M和K，第二行是输入的10个数据 39 5

1 2 3 4 5 6 7 8 9 0

【样例输出】 //一行，插入后的数列 1 2 3 4 39 5 6 7 8 9 0 3-9 砝码称重

1克、2克、50克的砝码各10个，问用这些砝码一共能称出多少种重量。 3-10 用筛选法求n(N<=10000000)以内的素数个数。 3-11 灯的开关状态

有N个灯放成一排，从1到N依次顺序编号，开始时全部打开。有N个人也从1到N依次编号，1号人将灯全部关闭，2号人将凡是编号为2的倍数的灯打开，3号人将凡是编号为3的倍数的灯作相反处理(该灯如为打开的，则将它关闭，如关闭的，则将它打开)。以后的人都和3号人一样，将凡是自己编号倍数的灯作相反处理。

编程实现：第N个人操作后，按顺序输出灯的状态。(1-表示灯打开，0-表示灯关闭) 【输入】n(n<=100)，灯的个数，

【输出】灯的状态，01序列，中间无空格。 【样例输入】2 【样例输出】01

3-12 校门外的树（NOIP2005） 【问题描述】

某校大门外长度为L的马路上有一排树，每两棵相邻的树之间的间隔都是1米。我们可以把马路看成一个数轴，马路的一端在数轴0的位置，另一端在L的位置；数轴上的每个整数点，即0，1，2，??，L，都种有一棵树。

由于马路上有一些区域要用来建地铁，这些区域用它们在数轴上的起始点和终止点表示。已知任一区域的起始点和终止点的坐标都是整数，区域之间可能有重合的部分。现在要把这些区域中的树（包括区域端点处的两棵树）移走。你的任务是计算将这些树都移走后，马路上还有多少棵树。

【输入】

第一行有两个整数L（1 <= L <= 10000）和 M（1 <= M <= 100），L代表马路的长度，M代表区域的数目，L和M之间用一个空格隔开。接下来的M行每行包含两个不同的整数，用一个空格隔开，表示一个区域的起始点和终止点的坐标。

【输出】

一行，这一行只包含一个整数，表示马路上剩余的树的数目。 【样例输入】 500 3 150 300 100 200 470 471

【样例输出】 298

3-13 输入3名学生5门功课的考试成绩，输出各人各科成绩及总分，成绩均为实型数，保留一位小数。

27 / 53

【样例输入】 //每行5个数据，数据间隔一空格 23.5 45 67 89 90 90 87 76 67 65 90 78 67 45 23

【样例输出】 //共三行，每行6个数据，前五个是各科成绩，第6个是总成绩，数据间隔一空格，最后无空格。

23.5 45.0 67.0 89.0 90.0 314.5 90.0 87.0 76.0 67.0 65.0 385.0 90.0 78.0 67.0 45.0 23.0 303.0 3-14 杨辉三角

输出杨辉三角的前N行(N<=10)。 【样例输入】 4

【样例输出】 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1

28 / 53

第四章 字符与字符串操作 第一节 字符和字符数组

一、字符类型(char)

字符类型是由一个字符组成的字符常量或字符变量，字符类型变量用char定义，它和整型、实型变量一样，在前面章节中我们也曾使用过字符常量和字符变量。

字符类型是一个有序类型，字符的大小顺序按其ASCⅡ代码的大小而定，所以函数succ、pred、ord 都适用于字符类型。

例如：前驱函数：pred（'B'）='A'，后继函数：succ('a')= 'b'，序号函数：ord（'A'）=65

二、字符数组

当数组元素的类型为字符型时，此数组即为字符数组。如： Type

Chty=array[1..20] of char; Var

Ch:chty;

例4-1 输入一串且最后以“#”结束的字符（<200），判断它们是否构成回文。回文打印“Y”，不是回文打印“N”。

【样例输入】 abcdcba# 【样例输出】 Y

【参考程序】 program aa; var

a:array[1..200] of char; i,f,n:integer; ch:char; begin

read(ch); n:=0;

while ch<>'#' do begin

n:=n+1; //统计读入字符的个数

a[n]:=ch; //将读入的字符赋给a数组 read(ch); end; f:=0;

for i:=1 to n do //判断是否是回文

if a[i]<>a[n-i+1] then begin f:=1; break; end; //一旦出现首尾字符不相等，这个字符串就不是回文

if f=0 then writeln('Y') else writeln('N'); //输出结果 end.

第二节 字符串变量

Free Pascal字符串类型保留字：string。定义格式为：string<[n]>

29 / 53

String括号内的n表示该字符串变量的最大长度，n的值需在1～255之间，若省略n默认为255，在给字符串变量进行赋值操作或输出操作时，字符串的长度可以变化，可长可短，而不象数组那样必须按规定的长度输入数据或输出数据，更大长度的字符串用ansistring来定义，它用法与string一样。

常见的字符串函数

函 数 意 义 使用方法 concat(s1,?,sn)连接n个字符串成为一个字符串，返回值st:=concat(s1,s2,s3); 函数 是字符串，若连接后的字符串长度大于(st:=s1+s2+s3); (相当于”+”号) 255，则出错 str(i,s) 过程 将一个整数或实数i转换成字符串S str(i,s);

copy(s,i,len)函数 在字符串s中从i位置开始取len个字符，st:=copy(s,i,n);

若i超过串长，则返回一个空串，若i超出1..255范围则出错

Length(s) 函数 求字符串s的长度 a:=length(s); pos(st1,st2) 函数 求st1字符串在st2字符串中的开始位置，a:=Pos(st1,st2);

若没有，则返回值为0

delete(s,i,len)过在字符串s中从i位置开始删除len个字delete(s,i ,len); 程 符，若i>s串长度，则不删除任何字符；

若i超出1..255范围则出错；若i+len>s长度，则仅删除串内长度

insert(st1,st,i)将st1插入到st字符串第i个位置，若insert(st1,st,i); 过程 i<=1，则将字符串插入到st字符串的最前

面，若i>st串的长度，则插入到st字符串的最后面

val(st,r,c)过程 将字符串st转换成与r同类型的数值，并val(st,r,c);

将值赋予r，如果字符串中存在非数值型字符，则用c返回非数值型字符的位置，否则c的值为0

一、字符串变量的赋值

字符串变量的赋值方法基本同一般变量，所不同的是赋值号右边的值需加一对单引号，如下面的例题便可以说明。

例4-2 判断下面程序的运行结果 program aa;

var st1,st2,st3:string[15]; begin

st1:='China';

st2:='I am a Chinese'; st3:='America'; writeln(st1); writeln(st2);

writeln(st1+' and '+st3); end.

【输出结果】 China

I am a Chinese China and America 二、字符串的操作

1．字符串的输入和输出

字符串是以回车作为结束标志，所以输入时必须用readln，如readln(s)；且每个readln语句只能读入一个字符串，如readln(s1,s2)是无法正确读入的，输出时直接输出就行，并且可以一次输出多个字符，如writeln(s1,' ',s2)是可以正确输出的。

30 / 53

2．字符串可以和数组一样操作。如设a:='nabcdeg'; 则：a[1]:='e';a[3]:='f';writeln(a); 或：for i:=1 to length(a) do write(a[i]);都是合法的。

3．因为从键盘一次只能连续输入127个字符，所以较长字符串的输入一般都是采用文件输入的方式。

4．要严格区分数字字符、数字字符串与数字的不同，它们之间可以相互转化。如：'4'<>4；'1326'<>1326；再如：现设var a:char; i:integer;若有 a:='4';i:=ord(a)-48; 则writeln(i)这时输出i的值将会是数字4。

5．字符串大小的比较。 '123'='123'的值为TRUE，'12345'>'12325'的值为TRUE，'12345'>'1234'的值为TRUE， '456'<'123456'的值为FALSE。

例4-3 输入5个学生的姓名，然后反序输出每个学生的姓名，姓名位于一行，姓名之间以一个空格隔开。

【样例输入】

lihua zhaoping zhangsan zhouyu qianwen 【样例输出】

qianwen zhouyu zhangsan zhaoping lihua 【参考程序】 program aa;

var a:array[1..10] of string[8]; i,n,t:integer; ch:string[8]; st:string; begin n:=5;

read(st); //输入5个学生姓名组成的字符串 for i:=1 to n-1 do //先分离出来前n-1个姓名 begin

t:=pos(' ',st); //寻找第一个空格的位置赋值为t

a[i]:=copy(st,1,t-1); //分离出来前t-1字符作为第i个名字 delete(st,1,t); //删除前t个字符 end;

a[n]:=st; //将剩下的字符串作为最后一个名字

for i:=n downto 2 do write(a[i],' '); //输出结果 writeln(a[1]); end.

第三节 字符串应用举例

例4-4 从键盘上输入一串字符（可能含数字、小写字母），以#作为输入结束标志。 编程完成：

统计输入字符中每个小写字母出现的次数（没有出现的不输出）。 【样例输入】 2bcdaab33wycc# 【样例输出】 a 2 b 2 c 3 d 1 w 1 y 1

【参考程序】 program aa;

31 / 53

var

ch:char;

a:array['a'..'z'] of integer; begin

fillchar(a,sizeof(a),0); read(ch);

while ch<>'#' do begin

if (ch>='a') and (ch<='z') then a[ch]:=a[ch]+1; read(ch); end;

for ch:='a' to 'z' do

if a[ch]>0 then writeln(ch,' ',a[ch]); end.

例4-5 编写一个程序，统计从键盘输入的n(<200)个英文单词中以c（小写）开头的单词,并输出个数。

【样例输入】 4 an cat bee cow

【样例输出】 cat cow 2

【参考程序】 program aa; var

n,i,k:integer;

a:array[1..200] of string; begin

readln(n);

for i:=1 to n do readln(a[i]); for i:=1 to n do

if a[i,1]='c' then begin writeln(a[i]); inc(k); end; writeln(k); end.

例4-6 编程完成30000以内的正整数的+、-、*、/一种运算，只含一个运算符号。 【样例输入】 130*100

【样例输出】 13000

【参考程序】 program aa; var

ch:char; st:string;

a,b,c,n,i:longint; begin

32 / 53

readln(st);

for i:=1 to length(st) do

if st[i] in ['*','/','+','-'] then begin n:=i; ch:=st[i]; break; end; n:=pos(ch,st);

val(copy(st,1,n-1),a,c);

val(copy(st,n+1,length(st)-n+1),b,c); case ch of

'+':writeln(a+b); '-':writeln(a-b); '*':writeln(a*b); '/':writeln(a/b:0:2); end; end.

例4-7 统计一个英文句子中有多少英文单词。假设句子中字符数小于80个，单词间用至少一个空格隔开（可以有多个空格），句子头部可以有多个空格，句子以‘$’作为结束标志。

【样例输入】□□□THIS□□IS□A□□GOOD□□□BOOK!$ 【样例输出】5 【参考程序】 program aa; var

ch:char;

a:array[1..80] of char; n,i:integer; begin n:=0; read(ch);

while ch=' ' do read(ch); while ch<>'$' do begin inc(n);

while (ch<>' ') and (ch<>'$') do read(ch); while ch=' ' do read(ch); end;

writeln(n); end.

习题

4-1 输入一串（<80个），且最后以“#”结束的字符，判断它们是否构成回文。回文打印“YES”，不是回文打印“NO”。

【样例输入】 //一行 abcdcba#

【样例输出】 //一行 YES

4-2 输入一串（<80个并大于5个），且最后以“#”结束的字符，然后倒序输出后四个字符，不包括“#”字符。

【样例输入】 abcdefgh# 【样例输出】

33 / 53

hgfe

4-3 输入一串（<80个），且最后以“#”结束的字符，然后输出它们对应的ASCII码，“#”字符的ASCII码不输出。

【样例输入】 abcd#

【样例输出】 //数字之间隔一空格，最后一个数字后面无空格 97 98 99 100

4-4 输入4个学生的姓名，并按输入的顺序进行输出前3个学生的姓名，姓名位于一行，姓名之间以一个空格隔开，最后无空格。

【样例输入】 //一行，姓名之间隔一空格，最后无空格 lihua zhaoping zhangsan zhouyu

【样例输出】 //一行，姓名之间隔一空格，最后无空格 lihua zhaoping zhangsan

4-5 输入一个字符串ST1和ST，将ST1插入到ST字符串第二个字符的位置上。两个字符串中间隔一空格，ST字符串长度都大于5。

【样例输入】 //一行，两个字符串之间隔一空格 abcefg sdfjs879098

【样例输出】 //一行，插入后的字符串 sabcefgdfjs879098

4-6 输入两个数字字符串（长度大于10），将每个数字字符串前五个字符取出来转换为数字后，输出它们的和。

【样例输入】 //两个数字串之间隔一空格 3434556476567 7868769898769

【样例输出】 //一行，两个数的和 113032

4-7 输入一个实数，转换为字符串的过程中保留两位小数。

【分析】str(a:0:2,st)的意思是：将实型数a转换为字符串的过程中保留两位小数。 【样例输入】 987.7655688 【样例输出】 987.77

4-8 完成计算器功能：完成30000以内的正整数加法运算。 【样例输入】 130+100

【样例输出】 230

4-9 删数问题

键盘输入一个正整数Ｎ，去掉其中任意Ｓ个数字后剩下的数字按原左右次序将组成一个新的正整数。编程对给定的Ｎ和Ｓ，寻找一种方案使得剩下的数字组成的新数最小。（Ｎ不超过２４０位）

【输入】两行，第一行：正整数n，第二行：正整数S。 【输出】n去掉的s个数字后组成的新的最小的正整数m。 【样例输入】 123006 2

【样例输出】1006

34 / 53

第五章 函数与过程 第一节 自定义函数

函数分为标准函数和自定义函数，标准函数由Free Pascal系统内部提供的函数，供用户编程时调用，如求绝对值函数abs(x)，平方根函数sqrt(x)等，但它毕竟数量有限，用户可以根据自己需要，自行定义函数。

一、自定义函数的定义格式

Free Pascal自定义函数用function语句开始，每个自定义函数均由函数的首部和函数体组成。

定义格式如下：

Function 函数名(形参表):函数类型； //函数首部 说明部分； Begin //函数体 语句块；

函数名:=表达式； //函数运算结果通过函数名带出函数体 End; 二、说明

1.函数首部以保留字Function开头，其后的函数名必须与保留字之间有一个以上的空格。

2.函数名是对用户定义的一个函数标识，用于存放调用后的函数值，函数名与标识符的构成规则相同，并且它不能和其他标识符重名。

3.圆括号中的形参表是用逗号隔开的一个或多个形参名，形参名由用户自己决定，所有形参都必须同时说明类型，不同类型的说明之间用分号隔开。

例如：

Function B01(x,y:Real; m,n:integer):real;

形参即函数的自变量，其初值来源于函数的调用，只有在程序执行过程中调用了函数，形参才有可能得到具体的值并参与运算，求得函数值，可见形参表相当于变量说明，但应特别注意：此处只能使用类型标识符，而不能直接使用类型。

若函数没有自变量，则形参表可以缺省，称为无参函数。此时函数的定义形式为： Function 函数名:函数类型； //函数首部

4.函数的类型也就是函数值的类型，它由函数首部来说明，所求得的函数值通过函数名传送回调用程序，由此可见函数的作用一般是为了求得一个值。

5.函数体由说明与执行两部分组成。它的说明部分用来对函数体内所用的类型、常量、变量等进行说明，这些量只在本函数内有效，与函数体外的同名量无关，它的执行部分以BEGIN开始，以END结束（其后紧跟一个分号），中间为语句块，至少要有一条赋值语句，即：函数名:=表达式；

该操作把表达式的值赋给函数名，然后把这个值通过函数名带回调用它的程序中去。 注意：自定义函数只是定义了一个求值的模块，只有当一个语句中使用了这个函数时，这个模块才被调用执行。

6.函数的调用形式：变量:=函数名(实在参数表); 例5-1 求a!+b!+c!的值。（a,b,c<=10） 【样例输入】 6 7 3

【样例输出】 5766

【参考程序】

var a,b,c,s:integer;

35 / 53

function sum(n:integer):longint; //设定一个求阶乘的函数 var i:integer;s:longint; begin s:=1;

for i:=1 to n do s:=s*i; sum:=s; end; begin

read(a,b,c); //输入a,b,c的值

s:=sum(a)+sum(b)+sum(c); //三次调用求阶乘函数 writeln(s); //输出结果 end.

例5-2 任意输入3组三角形的三边，求其面积和。运算结果保留两位小数。 已知三角形的三边a,b,c，求三角形面积S的公式为： P=(a/+b+c)/2，S=sqrt(p*(p-a)*(p-b)*(p-c))。 【样例输入】 2 3 4 3 4 5 5 6 7

【样例输出】 23.60

【参考程序】 program aa; var

i:integer;

a,b,c,s,p:real;

function area(a,b,c:real):real; //设置一个求三角形面积的函数 begin

p:=(a+b+c)/2;

area:=sqrt(p*(p-a)*(p-b)*(p-c)); end; begin s:=0;

for i:=1 to 3 do begin

read(a,b,c);

s:=s+area(a,b,c); //调用自定义函数area end;

writeln(s:0:2); //输出结果 end.

例5-3 求从键盘任意输入三个自然数的最大约数。 【样例输入】100 20 50 【样例输出】10 【参考程序】 program aa;

var a,b,c,k:integer;

function gy(a,b:integer):integer; //求最大公约数函数 var r:integer; begin

r:=a mod b;

while r<>0 do //用辗转相除判余法求最大公约数

36 / 53

begin a:=b; b:=r;

r:=a mod b; end; gy:=b; end; begin

read(a,b,c);

k:=gy(a,b); //调用函数gy，求a,b的最大公约数k

k:=gy(k,c); //调用函数gy，求k,c的最大公约数赋值为k，从而得到a,b,c三个数的最大公约数

writeln(k); end.

例5-4 设计一个函数qs(n,k)，它能将自然数N的从右边开始的第K位上的数字取出来。

例如：qs (13579,2)=7 qs (2468,4)=2

调用此函数，求出3次输入后，得到的第K位上的数字之和。 【样例输入】 133756 2 534534534 6 98809 3

【样例输出】 18

【参考程序】 program aa;

var n,k,i,s:longint;

function qs(n,k:longint):longint; //设定一个求从右边数第k位上数字的函数

var i:longint; begin

for i:=1 to k-1 do n:=n div 10; qs:=n mod 10; end;

begin s:=0;

for i:=1 to 3 do begin

read(n,k);

s:=s+qs(n,k); //调用qs函数，并将求得的n右边第k位数字累加到s中

end;

writeln(s); end.

例5-5 求出正整数N～M之间的完全数（N

【样例输出】 6 28

【参考程序】 program aa;

37 / 53

var n,m,i:integer;

function wqs(n:integer):boolean; //设定一个判断n是否为完全数的函数 var s,i:integer; begin s:=1;

for i:=2 to n div 2 do

if n mod i=0 then s:=s+i;

if n=s then wqs:=true else wqs:=false; end; begin

read(n,m);

for i:=n to m do //用穷举法找出n-m之间的所有完全数 if wqs(i) then writeln(i); end.

第二节 自定义过程

一、自定义过程格式

Procedure 过程名(形式参数表); 说明部分; BEGIN

过程体(语句块) END; 二、说明

1.过程首部以保留字Procedure 开头，过程名与函数名的使用规则相同，同时过程名不能代表任何数据，因此不必说明类型。

2.过程的形式参数表中的参数之间用逗号分隔，过程和函数一样也可以不带形参，此时，只是在主程序调用它时，执行指定的操作。它的参数分为值形参与变量形参。

如下例：Procedure FAC（A,B:real; C:integer; var x,y:reaL）;

其中：A,B,C称为值形参，它们与在函数中介绍的形参相同；x,y称为变量形参，在它们的前面冠有保留字Var；

3.过程体包括说明和执行两部分，在过程体内使用的有关常量、变量等必须在过程体的说明部分内加以说明或定义，并且只有在过程体执行期间有效，当退出过程体后，为这些量分配的存储单元被释放，还有在过程体内不能给过程名赋值，因为过程名不能代表任何数据。

4.过程调用的一般形式是：

过程名(实在参数表);

例5-6 利用自定义过程求任意两个整数的乘积。 【样例输入】5 10 【样例输出】50 【参考程序】 program lkj;

var a,b,c:longint;

procedure sum(a,b:longint;var c:longint); //将求两个整数乘积的程序段设为一个过程

begin

c:=a*b; end; begin

readln(a,b);

sum(a,b,c); //调用sum过程求a+b的乘积

38 / 53

writeln(c); end.

例5-7 编写程序，求：S=2!+4!+6!+8! 【输出结果】41066 【参考程序】 program aa;

var i:integer; b,s:longint;

procedure jc(n:integer; var t:longint); //求x的阶乘，t为变量形参，并将x的阶乘带出过程体

var j:integer; begin t:=1;

for j:=1 to n do t:=t*j; end;

begin s:=0;

for i:=2 to 8 do

if not odd(i) then //若i是偶数，则求它的阶乘，并将阶乘b累加到s中

begin

jc(i,b); s:=s+b; end; writeln(s); end.

例5-8 小明在家举行了一个生日聚会，共来了M位同学，为了活跃气氛，小明要选N位同学表演一个小游戏，请问有多少种选择方法。

m!n【分析】这是数学中的组合运算，可用下列公式计算Cm，其中M，N?n!*(m?n)!由键盘输入。

【样例输入】10 7 【样例输出】120 【参考程序】 program aa;

var L,m,n:integer; a,b,c:real; x:longint;

procedure jc(k:integer); //设定一个求k阶乘的函数，阶乘通过x带出过程体

var i:integer; f:longint; begin f:=1;

for i:=1 to k do f:=f*i; x:=f; end;

begin read(m,n);

if m=n then L:=1 else L:=m-n; //若m-n的值为0，则将L设为1，否则L=m-n

jc(m);a:=x; //将m的阶乘赋值为a jc(n);b:=x; //将n的阶乘赋值为b jc(L);c:=x; //将L的阶乘赋值为c c:=a/(b*c); //求出运算结果 writeln(c:0:0) end.

39 / 53

例5-9 将辗转相除判余法求两个数最大公约数的程序段设定为一个过程，编程求任意两个整数的最大公约数。

【样例输入】12 8 【样例输出】4 【参考程序】 Program aaa;

Var a,b,s:integer;

procedure ee(var x,y,z:integer); begin

z:=x mod y; while z<>0 do begin

x:=y; y:=z; z:=x mod y; end; z:=y; end; begin

readln(a,b); ee(a,b,s); writeln(s); end.

通过上面的例题，我们可以看到过程与函数有下列主要区别： （1）过程的首部与函数的首部不同。

（2）函数通常是为了求一个函数值，而过程可以得到若干个运算结果，也可用来完成一系列的数据处理，或用来完成与计算无关的各种操作。

（3）调用方式不同，函数的调用出现在表达式中，而过程调用是一个独立的语句。

第三节 参数和作用域

一、局部量、全程量与作用域

在子程序内部说明的变量，称之为局部变量。在主程序开头说明部分中加以定义与说明的量，称为全程量。在不同的说明语句部分所说明的变量，在程序中对此变量进行存取的适用范围是不同的，我们将其适用的范围称之为作用域。局部变量的作用域为所在子程序，由于形式参数只在所在子程序中有效，因此也属于局部变量。

例5-10

program aa;

var a,b:integer;

procedure add(c:integer); //c为值形参、局部量，作用域在本程序，它的改变不会影响实在参数a的值

begin

c:=c+10;

b:=b+10; //b为全程量，在过程中发生改变，退出后仍然是改变的 writeln('c=',c,' ','b=',b); end;

begin a:=5; b:=10;

add(a); //a为实在参数，它将值传送给值形参c writeln('a=',a,' ','b=',b); end.

【输出结果】 c=15 b=20 a=5 b=20

在这里，a,b是全局量，c是局部量。 二、值参数与变量参数

40 / 53