6.1 一维数组
1、定义：
var
a:array [1..10] of integer;
其中：a是这一批数据的名称，称为数组名；array、of是定义数组的保留字；中括号中的数字是数据编号的下限和上限，财时也说明了数据的个数（上限-下限）；最后一个是数据的基类型，如integer，char，real，boolean。
2、数组元素的输入：
数组名代表的并不是一个变量，而是一批变量，因而，不能直接整个数组读入，而是要逐个数组元素读入，通常用循环结构来完成这一功能。下面是几个常用输入数组元素的例子：
for i:=1 to 10 do read(a[i]);
{————从键盘读入数组元素的值；最常用的方法}
for i:=1 to 10 do a[i]:=i;
{————数组元素a[1]到a[10]的值分别为1到10；数据赋初值}
for i:=1 to 10 do a[i]:=0;
{————数组元素清0；最常用的数据初始化的方法}
for i:=1 to 10 do a[i]:=random(100);
{————随机产生10个100以内的数，赋给各数组元素}
3、数组元素的输出：
和数组元素的输入相同，数组元素的输出也不能由一个write语句直接完成。同样要逐个数组元素输出。通常也用循环结构来完成这一功能：
for i:=1 to 10 do write(a[i],' ');{————数组元素之间用空格分隔}
writeln;
4、数组的应用：
例1：从键盘输入10个数，将这10个数逆序输入，并求这10个数的和，输出这个和。
program p1;
var
a:array [1..10] of integer;
i,s:integer;
begin
for i:=1 to 10 do read(a[i]);
for i:=10 downto 1 do write(a[i],' ');
writeln;
s:=0;
for i:=1 to 10 do s:=s+a[i];
writeln('s=',s);
end.
例2：用筛法求100以内的素数（质数）。
分析：素数是除了1和它本身以外没有其它约数的数。用筛法求素数的方法是：用质数筛去合数：从第一个素数2开始，把它的倍数去掉；这样2以后的第一个非0数就一定也是素数，把它的倍数也删了……重复这个删数过程，直到在所找到的素数后再也找不到一个非0数。把所有非0数输出。
program p2;
var
a:array [1..100] of integer;
i,j,k:integer;
begin
for i:=1 to 100 do a[i]:=i;
a[1]:=0;i:=2;
while i<=100 do
begin
k:=i;
while k<=100 do
begin
k:=k+i;
a[k]:=0;
end;
{————上面将所有a[i]的倍数清0}
i:=i+1;
while a[i]=0 do i:=i+1;
{————查找接下来的第一个非0数}
end;
for i:=1 to 100 do if a[i]<>0 then write(a[i],' ');
end.
6.2 二维数组
一维数组在编程中多用于描述线性的关系：如一组数；一组成绩；一组解答等。数组元素只有一个下标，表明该元素在数组中的位置。二维数组在编程中多数用于描述二维的关系：如地图、棋盘、城市街道、迷宫等等。而二维数组元素有两个下标：第一个下标表示该元素在第几行，第二个下标表示在第几列。
1.二维数组的定义：
var
a：array[1..10,1..5] of integer；
其中：a是数组名，由程序员自定；array和of是定义数组的保留字；（这两点和一维数组定义的格式一样）中括号中的两个范围表示二维数组共有多少行、多少列（第一个范围表示行数，第二个范围表示列数）；最后一个表示数组元素的类型，规定和一维数组一样。如上例，定义了一个二维数组a，共有10行5列。
2.使用二维数组：
1、数组元素的指称：数组名[行号，列号]。如第三行第四个元素：a[3,4]。
对某一行进行处理。如累加第4行的数据。则固定行号为4。如：for i:=1 to 5 do s:=s+a[4,i];
对某一列进行处理。如累加第4列的数据。则固定列号为4。如：for i:=1 to 10 do s:=s+a[i,4];
2、二维数组的输入输出要用双重循环来控制：
for i:=1 to 10 do{————控制行数}
begin
for j:=1 to 5 do read(a[i,j]){————第一行读入5个元素}
readln;{————读入一个换行符}
end;
{————最常用的方法：从键盘读入数据初始化二维数组}
for i:=1 to 10 do
for j:=1 to 5 do a[i,j]:=0;
{————最常用的方法：将二维数组清0}
for i:=1 to 10 do
begin
for j:=1 to 5 do write(a[i,j]:4);
writeln;
end;
{————最常用的输出方法：按矩阵形式输出二维数组的值}
例1：竞赛小组共有20位同学，这学期每位同学共参与了三项比赛，请统计每位同学的平均分。
分析：定义一个20行3列的二维数组来存放这些成绩。定义一个20个元素的一维数组来存放平均分。
program p1;
var
a:array [1..20,1..3] of integer;
b:array [1..20] of real;
i,j:integer;
begin
for i:=1 to 20 do
begin
for j:=1 to 3 do read(a[i,j]);
readln;
end;
{————从键盘上读入20个同学的三次竞赛成绩}
for i:=1 to 20 do b[i]:=0;
{————先将平均分数组清0}
for i:=1 to 20 do
begin
for j:=1 to 3 do b[i]:=b[i]+a[i,j];{————计算总分}
b[i]:=b[i]/3;{————计算平均分}
end;
for i:=1 to 20 do write(b[i]:5:1);
{————输出平均分}
writeln;
end.
6.3 字符串
1. 字符串用于存放整批的字符数据。通常编程中使用字符串存放字符化了的数字数据。如高精度运算时存放操作数和运算结果。字符串可以看作是特殊的字符串数组来处理。当然，它也有自已的特点。下面是字符串定义的格式：
var
s:string; s1:string[15];
字符串定义时，如不指定长度，则按该类型的最大长度（255个字符）分配空间，使用时最大可用长度为255个；如果在中括号中给出一个具体的值（1—255之间），则按这个值的大小分配空间。使用时，最大的可用长度即为该值。
2.字符串的输入、输出：
字符串类型既可按数组方式输入、输出，也可直接输入、输出：readln(s)；writeln(s)；多个字符串输入时以回车作为数据间的分隔符；每个readln语句只能读入一个字符串。
3.有关字符串的操作：
操作 类型 作用 返回值 例子 length(s)函数 求字符串s的长度整型s:='123456789';
l:=length(s);{l的值为9}copy（s,w,k)函数 复制s中从w开始的k位字符串s:='123456789';
s1:=copy(s,3,5);{s1的值是'34567'}val(s,k,code)过程 将字符串s转为数值，存在k中；code是错误代码 var s:string;k,code:integer;
begin
s:='1234';
val(s,k,code);
write(k);{k=1234}
str(i,s)过程 将数值i转为字符串s i:=1234;
str(i,s);
write(s);{s='1234'}Delete(s,w,k)过程 在s中删除从第w位开始的k个字符 s := 'Honest Abe Lincoln';
Delete(s,8,4);
Writeln(s); { 'Honest Lincoln' }Insert(s1, S, w)过程 将s1插到s中第w位 S := 'Honest Lincoln';
Insert('Abe ', S, 8); { 'Honest Abe Lincoln' }Pos(c, S)函数 求字符c在s中的位置整型S := ' 123.5';
i :=Pos(' ', S);{i的值为1}+运算符 将两个字符串连接起来 s1:='1234';
s2:='5678';
s:=s1+s2;{'12345678'}
2.1高精度加法
高精度加法程序如下：
program HighPrecision1_Plus;
const
fn_inp='hp1.inp';
fn_out='hp1.out';
maxlen=100; { max length of the number }
type
hp=record
len:integer; { length of the number }
s:array[1..maxlen] of integer
{ s[1] is the lowest position
s[len] is the highest position }
end;
var
x:array[1..2] of hp;
y:hp; { x:input ; y:output }
procedure PrintHP(const p:hp);
var i:integer;
begin
for i:=p.len downto 1 do write(p.s[i]);
end;
procedure init;
var
st:string;
j,i:integer;
begin
assign(input,fn_inp);
reset(input);
for j:=1 to 2 do
begin
readln(st);
x[j].len:=length(st);
for i:=1 to x[j].len do { change string to HP }
x[j].s[i]:=ord(st[x[j].len+1-i])-ord('0');
end;
close(input);
end;
procedure Plus(a,b:hp;var c:hp); { c:=a+b }
var i,len:integer;
begin
fillchar(c,sizeof(c),0);
if a.len>b.len then len:=a.len { get the bigger length of a,b }
else len:=b.len;
for i:=1 to len do { plus from low to high }
begin
inc(c.s[i],a.s[i]+b.s[i]);
if c.s[i]>=10 then
begin
dec(c.s[i],10);
inc(c.s[i+1]); { add 1 to a higher position }
end;
end;
if c.s[len+1]>0 then inc(len);
c.len:=len;
end;
procedure main;
begin
Plus(x[1],x[2],y);
end;
procedure out;
begin
assign(output,fn_out);
rewrite(output);
PrintHP(y);
writeln;
close(output);
end;
begin
init;
main;
out;
end.
2. 2 高精度减法 高精度减法程序如下：
program HighPrecision2_Subtract;
const
fn_inp='hp2.inp';
fn_out='hp2.out';
maxlen=100; { max length of the number }
type
hp=record
len:integer; { length of the number }
s:array[1..maxlen] of integer
{ s[1] is the lowest position
s[len] is the highest position }
end;
var
x:array[1..2] of hp;
y:hp; { x:input ; y:output }
positive:boolean;
procedure PrintHP(const p:hp);
var i:integer;
begin
for i:=p.len downto 1 do write(p.s[i]);
end;
procedure init;
var
st:string;
j,i:integer;
begin
assign(input,fn_inp);
reset(input);
for j:=1 to 2 do
begin
readln(st);
x[j].len:=length(st);
for i:=1 to x[j].len do { change string to HP }
x[j].s[i]:=ord(st[x[j].len+1-i])-ord('0');
end;
close(input);
end;
procedure Subtract(a,b:hp;var c:hp); { c:=a-b, suppose a>=b }
var i,len:integer;
begin
fillchar(c,sizeof(c),0);
if a.len>b.len then len:=a.len { get the bigger length of a,b }
else len:=b.len;
for i:=1 to len do { subtract from low to high }
begin
inc(c.s[i],a.s[i]-b.s[i]);
if c.s[i]<0 then
begin
inc(c.s[i],10);
dec(c.s[i+1]); { add 1 to a higher position }
end;
end;
while(len>1) and (c.s[len]=0) do dec(len);
c.len:=len;
end;
function Compare(const a,b:hp):integer;
{
1 if a>b
0 if a=b
-1 if a<b
}
var len:integer;
begin
if a.len>b.len then len:=a.len { get the bigger length of a,b }
else len:=b.len;
while(len>0) and (a.s[len]=b.s[len]) do dec(len);
{ find a position which have a different digit }
if len=0 then compare:=0 { no difference }
else compare:=a.s[len]-b.s[len];
end;
procedure main;
begin
if Compare(x[1],x[2])<0 then positive:=false
else positive:=true;
if positive then Subtract(x[1],x[2],y)
else Subtract(x[2],x[1],y);
end;
procedure out;
begin
assign(output,fn_out);
rewrite(output);
if not positive then write('-');
PrintHP(y);
writeln;
close(output);
end;
begin
init;
main;
out;
end.
2.3高精度乘法
1.高精度乘单精度(1位数) 程序如下:
program HighPrecision3_Multiply1;
const
fn_inp='hp3.inp';
fn_out='hp3.out';
maxlen=100; { max length of the number }
type
hp=record
len:integer; { length of the number }
s:array[1..maxlen] of integer
{ s[1] is the lowest position
s[len] is the highest position }
end;
var
x,y:hp; { x:input hp ; y:output }
z:integer; { z:input lp }
procedure PrintHP(const p:hp);
var i:integer;
begin
for i:=p.len downto 1 do write(p.s[i]);
end;
procedure init;
var
st:string;
i:integer;
begin
assign(input,fn_inp);
reset(input);
readln(st);
x.len:=length(st);
for i:=1 to x.len do { change string to HP }
x.s[i]:=ord(st[x.len+1-i])-ord('0');
readln(z);
close(input);
end;
procedure Multiply(a:hp;b:integer;var c:hp); { c:=a*b }
var i,len:integer;
begin
fillchar(c,sizeof(c),0);
len:=a.len;
for i:=1 to len do
begin
inc(c.s[i],a.s[i]*b);
inc(c.s[i+1],c.s[i] div 10);
c.s[i]:=c.s[i] mod 10;
end;
inc(len);
while(c.s[len]>=10) do
begin
inc(c.s[len+1],c.s[len] div 10);
c.s[len]=c.s[len] mod 10;
inc(len);
end;
while(len>1) and (c.s[len]=0) do dec(len);
c.len:=len;
end;
procedure main;
begin
Multiply(x,z,y);
end;
procedure out;
begin
assign(output,fn_out);
rewrite(output);
PrintHP(y);
writeln;
close(output);
end;
begin
init;
main;
out;
end.
2.高精度乘一个整型数据(integer)
只需要将上述程序的hp类型定义如下即可:
type
hp=record
len:integer { length of the number }
s:array[1..maxlen] of longint
{ s[1] is the lowest position
s[len] is the highest position }
end;
3.高精度乘高精度
程序如下:
program HighPrecision4_Multiply2;
const
fn_inp='hp4.inp';
fn_out='hp4.out';
maxlen=100; { max length of the number }
type
hp=record
len:integer; { length of the number }
s:array[1..maxlen] of integer
{ s[1] is the lowest position
s[len] is the highest position }
end;
var
x:array[1..2] of hp;
y:hp; { x:input ; y:output }
procedure PrintHP(const p:hp);
var i:integer;
begin
for i:=p.len downto 1 do write(p.s[i]);
end;
procedure init;
var
st:string;
j,i:integer;
begin
assign(input,fn_inp);
reset(input);
for j:=1 to 2 do
begin
readln(st);
x[j].len:=length(st);
for i:=1 to x[j].len do { change string to HP }
x[j].s[i]:=ord(st[x[j].len+1-i])-ord('0');
end;
close(input);
end;
procedure Multiply(a,b:hp;var c:hp); { c:=a+b }
var i,j,len:integer;
begin
fillchar(c,sizeof(c),0);
for i:=1 to a.len do
for j:=1 to b.len do
begin
inc(c.s[i+j-1],a.s[i]*b.s[j]);
inc(c.s[i+j],c.s[i+j-1] div 10);
c.s[i+j-1]:=c.s[i+j-1] mod 10;
end;
len:=a.len+b.len+1;
{
the product of a number with i digits and a number with j digits
can only have at most i+j+1 digits
}
while(len>1)and(c.s[len]=0) do dec(len);
c.len:=len;
end;
procedure main;
begin
Multiply(x[1],x[2],y);
end;
procedure out;
begin
assign(output,fn_out);
rewrite(output);
PrintHP(y);
writeln;
close(output);
end;
begin
init;
main;
out;
end.
2.4 高精度除法
1.高精度除以整型数据(integer);
程序如下:
program HighPrecision3_Multiply1;
const
fn_inp='hp5.inp';
fn_out='hp5.out';
maxlen=100; { max length of the number }
type
hp=record
len:integer; { length of the number }
s:array[1..maxlen] of integer
{ s[1] is the lowest position
s[len] is the highest position }
end;
var
x,y:hp;
z,w:integer;
procedure PrintHP(const p:hp);
var i:integer;
begin
for i:=p.len downto 1 do write(p.s[i]);
end;
procedure init;
var
st:string;
i:integer;
begin
assign(input,fn_inp);
reset(input);
readln(st);
x.len:=length(st);
for i:=1 to x.len do { change string to HP }
x.s[i]:=ord(st[x.len+1-i])-ord('0');
readln(z);
close(input);
end;
procedure Divide(a:hp;b:integer;var c:hp;var d:integer);
{ c:=a div b ; d:=a mod b }
var i,len:integer;
begin
fillchar(c,sizeof(c),0);
len:=a.len;
d:=0;
for i:=len downto 1 do { from high to low }
begin
d:=d*10+a.s[i];
c.s[i]:=d div b;
d:=d mod b;
end;
while(len>1) and (c.s[len]=0) do dec(len);
c.len:=len;
end;
procedure main;
begin
Divide(x,z,y,w);
end;
procedure out;
begin
assign(output,fn_out);
rewrite(output);
PrintHP(y);
writeln;
writeln(w);
close(output);
end;
begin
init;
main;
out;
end.
2.高精度除以高精度
程序如下:
program HighPrecision4_Multiply2;
const
fn_inp='hp6.inp';
fn_out='hp6.out';
maxlen=100; { max length of the number }
type
hp=record
len:integer; { length of the number }
s:array[1..maxlen] of integer
{ s[1] is the lowest position
s[len] is the highest position }
end;
var
x:array[1..2] of hp;
y,w:hp; { x:input ; y:output }
procedure PrintHP(const p:hp);
var i:integer;
begin
for i:=p.len downto 1 do write(p.s[i]);
end;
procedure init;
var
st:string;
j,i:integer;
begin
assign(input,fn_inp);
reset(input);
for j:=1 to 2 do
begin
readln(st);
x[j].len:=length(st);
for i:=1 to x[j].len do { change string to HP }
x[j].s[i]:=ord(st[x[j].len+1-i])-ord('0');
end;
close(input);
end;
procedure Subtract(a,b:hp;var c:hp); { c:=a-b, suppose a>=b }
var i,len:integer;
begin
fillchar(c,sizeof(c),0);
if a.len>b.len then len:=a.len { get the bigger length of a,b }
else len:=b.len;
for i:=1 to len do { subtract from low to high }
begin
inc(c.s[i],a.s[i]-b.s[i]);
if c.s[i]<0 then
begin
inc(c.s[i],10);
dec(c.s[i+1]); { add 1 to a higher position }
end;
end;
while(len>1) and (c.s[len]=0) do dec(len);
c.len:=len;
end;
function Compare(const a,b:hp):integer;
{
1 if a>b
0 if a=b
-1 if a<b
}
var len:integer;
begin
if a.len>b.len then len:=a.len { get the bigger length of a,b }
else len:=b.len;
while(len>0) and (a.s[len]=b.s[len]) do dec(len);
{ find a position which have a different digit }
if len=0 then compare:=0 { no difference }
else compare:=a.s[len]-b.s[len];
end;
procedure Multiply10(var a:hp); { a:=a*10 }
var i:Integer;
begin
for i:=a.len downto 1 do
a.s[i+1]:=a.s[i];
a.s[1]:=0;
inc(a.len);
while(a.len>1) and (a.s[a.len]=0) do dec(a.len);
end;
procedure Divide(a,b:hp;var c,d:hp); { c:=a div b ; d:=a mod b }
var i,j,len:integer;
begin
fillchar(c,sizeof(c),0);
len:=a.len;
fillchar(d,sizeof(d),0);
d.len:=1;
for i:=len downto 1 do
begin
Multiply10(d);
d.s[1]:=a.s[i]; { d:=d*10+a.s[i] }
{ c.s[i]:=d div b ; d:=d mod b; }
{ while(d>=b) do begin d:=d-b;inc(c.s[i]) end }
while(compare(d,b)>=0) do
begin
Subtract(d,b,d);
inc(c.s[i]);
end;
end;
while(len>1)and(c.s[len]=0) do dec(len);
c.len:=len;
end;
procedure main;
begin
Divide(x[1],x[2],y,w);
end;
procedure out;
begin
assign(output,fn_out);
rewrite(output);
PrintHP(y);
writeln;
PrintHP(w);
writeln;
close(output);
end;
begin
init;
main;
out;
end.
温馨提示：答案为网友推荐，仅供参考