noip复赛模拟练习30答案.docx

noip复赛模拟练习30答案.docx

《noip复赛模拟练习30答案.docx》由会员分享，可在线阅读，更多相关《noip复赛模拟练习30答案.docx（13页珍藏版）》请在冰豆网上搜索。

noip复赛模拟练习30答案

某工厂为制造大型设备购买了一批零件，为了解这批零件工作的稳定性，技术部门对它们进行了故障检测，并记录了每个零件的故障系数（1-1000的整数）。

现在要找出哪种故障系数下零件数最多，如果有多个解，仅输出故障系数最小的那个。

【输入格式】第1行n，表示零件的数量，1≤n≤10^6（1000000）

第2行开始这n个零件的故障系数，每个数据以空格间隔。

【输出格式】只有1行，包括两个整数，第1个整数是包含最多零件数的故障系数，第2个整数是该故障系数零件的数量。

若有多个，仅输出其中故障系数最小的。

【输入样例】

5

13434

【输出样例】

32

（说明：

故障系数是3、4的零件数都是2，则输出故障系数较小的那个）

【数据规模】

50%n≤1000100%n≤1000000

programdevice（input,output）;

var

a:

array[1..1000]oflongint;n:

longint;

i,k,j:

longint;

begin

assign（input,'device.in'）;

assign（output,'device.out'）;

reset（input）;

rewrite（output）;

readln（n）;

fori:

=1tondo

begin

read（k）;

a[k]:

=a[k]+1;

end;

j:

=1;

fori:

=1to1000do{将变量J指向数组A中数量最多的一个}

ifa[i]>a[j]thenj:

=i

else

if（a[i]=a[j]）and（i

=i;

write（j,'',a[j]）;

close（input）;

close（output）;

end.

SHURU8

13787748输出73

输入12

15368486101266输出64

输入25

235101278112022435688112049111012237输出83

图书馆馆长正犯愁呢，原来，有一堆的书要他整理，每本书都有一个书号（<=32767）,现在他有一本书，这本书的书号为K（<=32767）,现在他要找出一本书号比这本书大的书和书号比这本小的书（但都要最接近图书馆馆长已有的书号），将找到的这两本书的书号加起来，并算出加起来以后的数是否为素数

Input

第一行二个数为N,K，表示几本书以及手中书的书号（<=32767）

第二行开始有N个整数，表示这些书的书号

Output

第一行一个数，表示两本书书号加起来的和

第二行一个字符，表示和是否为素数，若是则输出"Y"否则输出"F"（引号不打出）

SampleInput

65

6453120

SampleOutput

10

F

programex1148;

varn,k,i,x,s:

integer;

a:

array[0..32767]ofinteger;

f:

boolean;

begin

readln（n,k）;

fillchar（a,sizeof（a）,0）;

fori:

=1tondo

begin

read（x）;

a[x]:

=1;

end;

s:

=0;

fori:

=k+1to32767do

ifa[i]<>0thenbegins:

=s+i;break;end;

fori:

=k-1downto1do

ifa[i]<>0thenbegins:

=s+i;break;end;

f:

=true;

fori:

=2totrunc（sqrt（s））do

ifsmodi=0thenbeginf:

=false;break;end;

writeln（s）;

iff=truethenwrite（'Y'）elsewrite（'F'）;

end.

文件加密（encrypt）

对信息进行加密，可提高信息传输的安全性。

正是由于它的重要用途，人们发明了各种各样的加密方式。

其中一种方式是，对文中单词进行逆序处理。

请你写一个程序，对已加密的文本进行解密。

输入文件（encrypt.in）

第1行，一个整数n，表示后面将有n行已加密的信息。

第2行至第n+1行，每行一个不超过1000个字符的字符串，每个字符串中只有空格和小写字母组成。

输出文件（encrypt.out）

共n行，每行对应输出解密后的文本。

输入输出样例：

encrypt.in

encrypt.out

2

enoowteerht

iekilsihtemag

onetwothree

ilikethisgame

数据范围：

n<=50,000

最容易犯错的题目是用一个string的字符串去读入，受长度限制所以得分非常的少，但是可以使用ansistring字符串类型来突破255位长度限制，而且字符串函数的执行效率比较高；

参考程序（吴天舒100分程序）

var

a:

array[1..50000]ofansistring;

n:

longint;

i,j,k,s,t:

longint;

te:

char;

begin

assign（input,'encrypt.in'）;

assign（output,'encrypt.out'）;

reset（input）;

rewrite（output）;

readln（n）;

fori:

=1tondobegin

j:

=0;

readln（a[i]）;

a[i]:

=a[i]+'';

whilej

inc（j）;

ifa[i][j]<>''thenbegin

s:

=j;

whilea[i][j]<>''doinc（j）;

t:

=j-1;

fork:

=sto（s+t）div2dobegin

te:

=a[i][t-k+s];

a[i][t-k+s]:

=a[i][k];

a[i][k]:

=te;

end;

end;

end;

writeln（a[i]）;

end;

close（input）;

close（output）;

end.

求长度为素数的路径个数

对于正整数n（3≤n≤13），可以画出n阶的回形矩阵。

下面画出的分别是3阶的，4阶的和7阶的回形矩阵：

 对于n阶回形矩阵，从左上角出发，每步可以向右或向下走一格，走2*n-2步，可以到达右下角。

我们把这样的路径上所有格子中的数值之和，叫做该路径的长度。

本题要求，对于给出n值，求出n阶回形矩阵有多少路径的长度为素数？

如n=3时，路径及长度有：

因此说，3阶回形矩阵有2条路径的长度为素数。

Input 一个自然数n （3≤n≤13，不必判错）。

Output 一个正整数，即n阶回形矩阵中长度为素数的路径的个数。

SampleInput3

SampleOutput2

Source 江苏省青少年信息学奥林匹克竞赛（JSOI2004）小学组复赛

programex1279;

constdi:

array[1..2]ofinteger=（0,1）;

      dj:

array[1..2]ofinteger=（1,0）;

varn,i,j,k:

integer;t,s:

longint;

    a:

array[0..14,0..14]ofboolean;

    b:

array[1..13,1..13]ofinteger;

functionpd（t:

longint）:

boolean;

vari:

integer;

begin

  pd:

=true;

  ift=1thenpd:

=false;

  fori:

=2totrunc（sqrt（t））do

     iftmodi=0thenbeginpd:

=false;break;end;

end;

procedurework（h,l,t:

integer）;

vari,wi,wj:

integer;

begin

  if（h=n）and（l=n）and（pd（t））  thenbegininc（s）;exit;end;

  fori:

=1to2do

     begin

       wi:

=h+di[i];wj:

=l+dj[i];

       ifa[wi,wj]=truethen

          begin

            a[wi,wj]:

=false;

            work（wi,wj,t+b[wi,wj]）;

            a[wi,wj]:

=true;

          end;

     end;

end;

begin

  readln（n）;s:

=0;

  fillchar（a,sizeof（a）,false）;

  fori:

=1tondo

    forj:

=1tondo

      a[i,j]:

=true;

  fori:

=1tondo

   forj:

=iton-i+1do

    fork:

=iton-i+1do

     b[j,k]:

=i;

  work（1,1,1）;

  writeln（s）;

end.

任意一个数都可以由1、2、3三个数组合而成。

如4有以下7种组合方案：

1+1+1+1

1+1+2

1+2+1

2+1+1

2+2

1+3

3+1

你的问题来了，对于给定的一个数，请你计算出这个整数可以有多少个组合方案，其和由1、2、3组合而成。

数据输入

输入包含多组数据，每一组数据中，输入数据的第一行为一个整数n（1<=n<=20），要分解的数。

数据输出

这个整数的分解的组合数。

样例输入

4

样例输出

7

分析

用f（n）表示将n按照1、2、3分解的方法数

当n=1时,

      f

（1）=1;          {1}

当n=2时，

      f

（2）=2;           {1+1},{2} 

当n=3时，

   f（3）=3;           {1+1+1},{1+2},{2+1},{3}

   当n=k时（k>=4）

 考虑最后添加的一个数字可能是1、2、3。

 所以很容易推出递推公式

   f（k）=f（k-1）+f（k-2）+f（k-3）.

 var

   f:

array[1..20]oflongint;

   i,n:

longint;

procedureinit;

begin

   assign（input,'divide.in'）;

   assign（output,'divide.out'）;

   reset（input）;

   rewrite（output）;

end;

procedureendit;

begin

   close（input）;

   close（output）;

end;

begin

   init;

   readln（n）;

   f[1]:

=1;

   f[2]:

=2;

   f[3]:

=4;

   fori:

=4tondo

       f[i]:

=f[i-1]+f[i-2]+f[i-3];

   writeln（f[n]）;

   endit;

end.

问题描述：

扫雷是Windows自带的游戏。

游戏的目标是尽快找到雷区中的所有地雷，而不许踩到地雷。

如果方块上的是地雷，将输掉游戏。

如果方块上出现数字，则表示在其周围的八个方块中共有多少颗地雷。

你的任务是在已知地雷出现位置的情况下，得到各个方块中的数据。

*...

....     “*”表示有地雷

.*..     “.”表示无地雷

....

经过处理应得到：

*100

2210

1*10

1110

输入格式：

第一行有两个数字m,n（0

接下来m行，每行有n个字符，“*”表示有地雷，“.”表示无地雷。

输出格式：

对于输入数据，输出结果，各方块数字间不留空格。

输入样例：

44

*...

....

.*..

....

输出样例：

*100

2210

1*10

1110

算法分析

这是一个简单的模拟题。

一个空地附近的地雷数等于与它相临的八个的空格内地雷的数量。

两种实现方式

1.如果该格子为地雷”*”，那么它的相临的八个格子的地雷数加1。

否则什么都不做。

2.如果该格子为空地”.”，那么计算一下它附近的八个格子的地雷数，否则什么都不做。

var

   a:

array[0..101,0..101]oflongint;

   m,n,i,j:

longint;

   ch:

char;

procedureinit;

begin

   assign（input,'game.in'）;

   assign（output,'game.out'）;

   reset（input）;

   rewrite（output）;

end;

procedureendit;

begin

   close（input）;

   close（output）;

end;

begin

   init;

   readln（n,m）;

   fori:

=1tondo

   begin

       forj:

=1tomdo

       begin

           read（ch）;

           ifch='*'thena[i,j]:

=-1

                     elsea[i,j]:

=0;

       end;

       readln;

   end;

   fori:

=1tondo

       forj:

=1tomdo

           ifa[i,j]=-1then

           begin

               ifa[i-1,j]<>-1theninc（a[i-1,j]）;

               ifa[i+1,j]<>-1theninc（a[i+1,j]）;

               ifa[i,j-1]<>-1theninc（a[i,j-1]）;

               ifa[i,j+1]<>-1theninc（a[i,j+1]）;

               ifa[i-1,j-1]<>-1theninc（a[i-1,j-1]）;

               ifa[i+1,j+1]<>-1theninc（a[i+1,j+1]）;

               ifa[i-1,j+1]<>-1theninc（a[i-1,j+1]）;

               ifa[i+1,j-1]<>-1theninc（a[i+1,j-1]）;

           end;

   fori:

=1tondo

   begin

       forj:

=1tomdo

       ifa[i,j]=-1thenwrite（'*'）elsewrite（a[i,j]）;

       writeln;

   end;

   endit;

end.