第八章答案
8.1 合并字符串
成绩: 100 / 折扣: 0.8
输入两个已经按从小到大顺序排列好的字符串，编写一个合并两个字符串的函数，使合并后的字符串，仍然是从小到 大排列。
输入：
两个已经排好顺序（升序）的两个字符串
输出：
一个合并在一起的有序（升序）的字符串
要求：
设计一个效率尽量高的算法，对每个字符串只扫描一遍就可以了。
如果采用先进行串连接，然后再进行排序的算法，则效率太低了。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
char a[100],b[100],t;
int k,i,j;
gets(a);
gets(b);
strcat(a,b);
k=strlen(a);
for(j=1;j<=k;j++)
for(i=0;i<k-j;i++)
if(a[i]>=a[i+1])
{
t=a[i];
a[i]=a[i+1];
a[i+1]=t;
}
puts(a);
return 0;
}
8.2 大数相加
成绩: 100 / 折扣: 0.8
问题描述：
编写C程序，它能以字符串形式读入两个无符号正整数m和n，计算并输出这两个整数之和
输入格式：
输入由两行组成，第一行为无符号整数m，第二行为无符号整数n，且m和n的值最长25位
输出格式：
输出为一行，即两个无符号整数m和n之和
输入样例：
9999888888
355729288
输出样例：
10355618176
#include<stdio.h>
#include<string.h>
int main()
{
char a[5001],b[5001];
int s1[5001],s2[5001],k,n=0;
int ans[5001];
int c,alen,blen,i,maxlen,minlen;
scanf("%s%s",&a,&b);
alen=strlen(a);
blen=strlen(b);
maxlen = alen > blen ? alen : blen;
memset(s1,0,sizeof(s1));
memset(s2,0,sizeof(s2));
for( i=alen-1;i>=0;i--)
s1[alen-i]=a[i]-'0';
for( i=blen-1;i>=0;i--)
s2[blen-i]=b[i]-'0';
memset(ans,0,sizeof(ans));
for(i=1;i<=maxlen;i++)
{
ans[i] += s1[i] + s2[i];
if(ans[i]>9)
{
if(i==maxlen)
maxlen++;
ans[i+1]++;
ans[i]-=10;
}
}
for( i=maxlen;i>=1;i--)
printf("%d",ans[i]);
printf("\n");
if (k!=c)
printf("\n");
}
8.3 删除重复字符
成绩: 100 / 折扣: 0.8
背景：
输入一个长度不超过 100 的字符串，删除串中的重复字符。
输入：
输入要检查的字符串，长度不超过100个字符。例如：abacaeedabcdcd。
输出：
删除重复字符后的字符串。例如：abced。
#include <stdio.h>
#include <string.h>
int main()
{char n[200],b[200]="";
int len,i,j,in[200]={0};
gets(n);
len=strlen(n);
i=0;
while(i<=len)
{
while (in[i]==1) i++;
j=i+1;
while(j<=len)
{
if (n[i]==n[j]) in[j]=1;
j++;
}
i++;
}
i=0;
j=
0;
while(i<=len)
{
if (in[i]!=1)
{
b[j]=n[i];
j++;
}
i++;
}
printf("%s\n",b);
return 0;
}
8.4 删除字符串中指定字符
成绩: 100 / 折扣: 0.8
输入两个字符串 s1 和 s2 ，在 s1 中删
除任何 s2 中有的字符。例如， s1 ：“ abc123ad ”， s2 ：“ a1 ” ，则输出“bc23d ”。
输入： 两个字符串 s1 和 s2
输出： 删除后的字符串 s1
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main() {
char a[20], b[20], c[20];
int i, j;
int k = 0;
int flag = 0;
gets(a);
gets(b);
c[0]='\0';
for (i = 0; i < strlen(a); i++) {
flag = 0;
for (j = 0; j < strlen(b); j++) {
if (a[i] == b[j]) {
flag = 1;
break;
}
}
if (flag==0) {
c[k] = a[i];
k++;
}
}
c[k]='\0';
printf("%s\n",c);
}
8.5 单词有多少
成绩: 100 / 折扣: 0.8
用空格或换行分开的字符串称为单词。输入多行字符串，直到遇到了单词 "stop" 时才停止。最后输出单词的数量。用于分割单词的空格或换行可能多于1个。
输入： 多个字符串
输出： 单词的数量
#include <stdio.h>
#include <malloc.h>
#include <string.h>
void main()
{
int count = 0;
char *word ;
while(1)
{
word = (char *) malloc (sizeof(char) * 20);
scanf("%s",word);
++count;
if(0 == strcmp(word, "stop"))
break;
free(word);
}
printf("%d\n",count-1);
}
8.6 在指定位置插入字符串
成绩: 100 / 折扣: 0.8
输入两个字符串 s1 、 s2 和 s1 中任意字符 k ，在 s1 中的指定字符 k 第一次出现的位置处插入字符串 s2 并输出。
输入： 两个字符串 s1 、 s2 和 s1 中任意字符 k
输出： 插入后的字符串 s1
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{ char s1[30],s2[30],ch;
static char s3[100]={0};
int i,j,k;
scanf("%s %s %c",&s1,&s2,&ch);
for(i=0;s1[i]!=ch;i++)
s3[i]=s1[i];
j=i;
for(k=0;s2[k];k++)
s3[i++]=s2[k];
for(;s1[j];j++)
s3[i++]=s1[j];
puts(s3);
}
8.7 Your Ride Is Here
成绩: 100 / 折扣: 0.8
It is a well-known fact that behind every good comet is a UFO. These UFOs often come to collect loyal supporters from here on Earth. Unfortunately, they only have room to pick up one group of followers on each trip. They do, however, let the groups know ahead of time which will be picked up for each comet by a clever scheme: they pick a name for the comet which, along with the name of the group, can be used to determine if it is a particular group's turn to go (who do you think names the comets?). The details of the matching scheme are given below; your job is to write a program which takes the names of a group and a comet and then determines whether the group should go with the UFO behind that comet.
Both the name of the grou
p and the name of the comet are converted into a number in the following manner: the final number is just the product of all the letters in the name, where "A" is 1 and "Z" is 26. For instance, the group &
quot;USACO" would be 21 * 19 * 1 * 3 * 15 = 17955. If the group's number mod 47 is the same as the comet's number mod 47, then you need to tell the group to get ready! (Remember that "a mod b" is the remainder left over after dividing a by b; 34 mod 10 is 4.)
Write a program which reads in the name of the comet and the name of the group and figures out whether according to the above scheme the names are a match, printing "GO" if they match and "STAY" if not. The names of the groups and the comets will be a string of capital letters with no spaces or punctuation, up to 6 characters long.
INPUT FORMAT
Line 1: An upper case character string of length 1..6 that is the name of the comet.
Line 2: An upper case character string of length 1..6 that is the name of the group.
OUTPUT FORMAT
A single line containing either the word "GO" or the word "STAY".
#include<stdio.h>
#include<string.h>
int main()
{
char a[7],b[7];
int i,producta=1,productb=1;
gets(a);
gets(b);
i=0;
while(a[i]!='\0')
{
producta=producta*(a[i]-'A'+1)%47;
i++;
}
i=0;
while(b[i]!='\0')
{
productb=productb*(b[i]-'A'+1)%47;
i++;
}
if(producta==productb)printf("GO\n");
else
printf("STAY\n");
return 0;
}
选做T 8.1 拱猪计分
成绩: 100 / 折扣: 0.8
背景：
拱猪是一种很有趣的扑克牌游戏。即使你不知道它的玩法，你也可以由它的计分方式来了解它的趣味性。 假设在此我们仅考虑四个人的拱猪牌局，本题要求你根据下面的计分规则，在牌局结束时计算四位玩家所得分数。
1.我们分别以S、H、D及C来代表黑桃，红心，方块及梅花，并以数字1至 13来代表A、2、…、Q、K等牌点，例如：H1为红心A，S13为黑桃K。
2.牌局结束时，由各玩家持有的有关计分的牌(计分牌)仅有S12(猪)，所有红心牌，D11(羊)及C10(加倍)等16张牌。其它牌均弃置不计。若未持有这16张牌之任一张则以得零分计算。
3.若持有C10的玩家只有该张牌而没有任何其它牌则得+50分，若除了C10 还有其它计分牌，则将其它计分牌所得分数加倍计算。
4.若红心牌不在同一家，则H1至H13等13张牌均以负分计，其数值为-50， -2，-3，-4，-5，-6，-7，-8，-9，-10，-20，-30，-40。而且S12与D11分别以-100及+100分计算。
5.若红心牌H1至H13均在同一家，有下列情形：
?所有红心牌以+200分计算。
?若S12、D11皆在吃下所有红心牌之一家，则此玩家得+500分。
?而C10还是以前面所述原则计算之。
例一：若各玩家持有计分牌如下： ( 每行代表一玩家所持有之牌 )
S12 H3 H5 H13
D11 H8 H9
C10 H1 H2 H4 H6 H7
H10 H11 H12
则各家之得分依
序为： -148 、 +83 、 -138 及 -60 。
例二：若各玩家持有计分牌如下：(第四家未持有任何计分牌)
H1 H2 H3 H4 H5 H6 H7 H8 H9 H10 H11 H12 H13
S12 C10
D11
则各家之得分依序为： +200 、 -200 、 +100 及 0 。
例三：若有一玩家持有所有 16 张计分牌，则得 +1000 分。其余三家均得零分。
输入：
每个输入文件由多组测试数据构成，每组测试数据有四行，每一行第一个数为该玩家所持有计分牌总数，而后列出其所持有之所有计分牌，牌数与各计分牌均以一个以上的空格分开。相邻两组测试数据之间不会有空白行，读到四家持牌数都为 0 表示文件结束。
输出：
每一行输出一组测试数据对应的结果，依次输出各家所得分数，共四个整数 ( 含正负号，0 除外)，相邻两个整数之间以一个空格分开，符号和数字间不可以有空格。每组输出间不需要有空白行。
#include "stdio.h"
int myinput(int card[],int number[])
{
int i,n;
char s[5];
for(i=0;i<4;i++)
{
scanf("%d",&n);
number[i]=n;
while(n--)
{
scanf("%s",s);
switch(s[0])
{
case 'S':card[13]=i;break;
case 'D':card[14]=i;break;
case 'C':card[15]=i;break;
case 'H':s[2]=='\0'?(card[s[1]-'1']=i):(card[s[2]-'1'+10]=i);
}
}
}
return number[0]+number[1]+number[2]+number[3];
}
int main()
{
int
value[15]={-50,-2,-3,-4,-5,-6,-7,-8,-9,-10,-20,-30,-40,-100,100},
card[16],
score[4]={0,0,0,0},
number[4],
i,s,
input();
while(myinput(card,number))
{
for(i=0,s=0;i<13;i++)
s+=card[i];
if(s%13)
{
for(i=0;i<15;i++)
score[card[i]]+=value[i];
}
else
{
if(card[0]==card[13]&&card[13]==card[14])
score[card[0]]+=500;
else
{
score[card[0]]+=200;
score[card[14]]+=value[14];
score[card[13]]+=value[13];
}
}
score[card[15]]+=number[card[15]]==1?50:score[card[15]];
for(i=0;i<4;i++)
printf("%s%d%s",score[i]>0?"+":"",score[i],i==3?"\n":" ");
for(i=0;i<4;i++)
score[i]=0;
}
return 0;
}
选作T 8.2 合并果子
成绩: 100 / 折扣: 0.8
在一个果园里，多多已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。多多决定把所有的果子合成一堆。
每一次合并，多多可以把两堆果子合并到一起，消耗的
体力等于两堆果子的重量之和。可以看出，所有的果子经过n-1次合并之后，就只剩下一堆了。多多在合并果子时总共消耗的体力等于每次合并所耗体力之和。
因为还要花大力气把这些果子搬回家，所以多多在合并果子时要尽可能地节省体力。假定每个果子
重量都为1，并且已知果子的种类数和每种果子的数目，你的任务是设计出合并的次序方案，使多多耗费的体力最少，并输出这个最小的体力耗费值。
例如有3种果子，数目依次为1，2，9。可以先将1、2堆合并，新堆数目为3，耗费体力为3。接着，将新堆与原先的第三堆合并，又得到新的堆，数目为12，耗费体力为12。所以多多总共耗费体力=3+12=15。可以证明15为最小的体力耗费值。
输入：
输入包括两行，第一行是一个整数n(1<＝n<=10000)，表示果子的种类数。第二行包含n个整数，用空格分隔，第i个整数ai(1<＝ai<=10000)是第i种果子的数目。
输出：
输出包括一行，这一行只包含一个整数，也就是最小的体力耗费值。输入数据保证这个值小于231。
#include<stdio.h>
#include<string.h>
#include<math.h>
void main()
{
int i,j,k,t,n,sum=0;
int a[10]={0};
int b[10]={0};
char s[10][100];
scanf("%d",&n);
for(i=1;i<=n;i++)
scanf("%s",s[i]);
for(t=1;t<=n;t++)
a[t]=strlen(s[t]);
for(i=1;i<=n;i++)
for(j=0;j<a[i];j++)
s[i][j]=s[i][j]-48;
for(j=1;j<=n;j++)
{
for(i=0;i<=a[j]/2-1;i++)
{
t=s[j][i];
s[j][i]=s[j][a[j]-1-i];
s[j][a[j]-1-i]=t;
}
}
for(j=1;j<=n;j++)
{
for(i=0;i<=a[j];i++)
{
b[j]=b[j]+s[j][i]*pow(10,i);
}
}
for(j=1;j<=n-1;j++)
for(i=1;i<=n-j;i++)
{
if(b[i]>b[i+1])
{
t=b[i];
b[i]=b[i+1];
b[i+1]=t;
}
}
sum=(n-1)*(b[1]+b[2]);
for(i=2;i<=n-1;i++)
sum=sum+(n-i)*b[i+1];
printf("%d\n",sum);
}
选作T 8.3 安全的密码
成绩: 100 / 折扣: 0.8
随着电子设备的广泛运用，密码也渐渐融入每个人的生活。保护好密码，不仅关系到个人隐私，更关系到个人的财产和安全。一个安全的密码，最好由大小写字母、数字或符号组成。包含越多种类的字符，其安全性就越高。同时密码还需要有一定的长度，通常至少要由六个以上的字符组成。
并不是每个人都喜欢这样复杂的密码，很多人在设置密码的时候，喜欢使用自己的名字或者生日，但这是很大的安全隐患。
任务
小林正在设计一个网络交易系统，为了保证用户的密码安全，他需要一个程序，判断用户自己设置的密码是否安全，如果不安全，则给出提示。现在他向你求助，请你帮忙设计一
个程序来解决这个问题。
应当按照以下的规则来判断密码是否安全：
1.如果密码长度小于 6 位，则不安全
2.如果组成密码的字符只有一类，则不安全
3.如果组成密码的字符有两类，则为中度安全
4.如果组成密码的字符有三类或以上，则为安全
通常，可以认为数字、大写字母、小写字母和其它符号为四类不同的字符。
输入
输入的第一行是一个整数 N，表明后面有多少组密码。随后的 N 行输入包括 N 个密码，每个密码的长度均小于 80个字符。
输出
针对每一个密码判断并输出它是否安全。对于不安全的密码输出 "Not Safe"，对于中度安全的密码输出 "Medium Safe"，对于安全的密码输出 "Safe"
输入样例
41234abcdefABC1231#c3Gh输出样例
Not SafeNot SafeMedium SafeSafe
#include <stdio.h>
#include <string.h>
int main(){
int time;
char s[ 100 ];
char * p;
int shu,dazimu,xiaozimu,qita;
scanf("%d\n",&time);
for(;time>0;time--){
gets(s);
p = s;
if(strlen(s)<6)printf("Not Safe\n");
else {
shu=dazimu=xiaozimu=qita=0;
while(*p){
if(*p>='0'&&*p<='9')shu=1;
else if(*p>='A'&&*p<='Z')dazimu=1;
else if(*p>='a'&&*p<='z')xiaozimu=1;
else qita=1;
p++;
}
switch(shu+dazimu+xiaozimu+qita){
case 1:printf("Not Safe\n");break;
case 2:printf("Medium Safe\n");break;
default:printf("Safe\n");
}
}
}
return 0;
}
选作T 8.4 扫雷（与上机题相差一个回车键）
成绩: 100 / 折扣: 0.8
背景
你玩儿过扫雷游戏吧？有个操作系统中带了这个小游戏，那个系统叫什么来着？在游戏中要想过关，就必须要在一个 NxM 的区域上找出所有的地雷。游戏过程中，计算机会在地图上显示一些数字从而帮助你确定哪里有地雷。例如，在下面这个有两颗地雷的 4x4 的地图（*表示地雷）：
*........*...... 根据上面的地图，可以计算出应该提供给游戏者的数字如下所示：
*10022101*101110 每个数字表示了该方格周围到底有几个地雷，当然，一个方格周围最多的时候只会有八个。
输入
输入中将包括一系列的地图，每个地图的第一行有两个整数 n 和 m（0 <n,m <= 100），它们表示了地图的行数和列数。下面的 n 行每行都有 m 个字符，其中 "." 表示安全而 "*" 表示地雷。如果地图的 n 和 m 都为 0，则表示输入结束。
输出
针对每一个地图，首先输出一行：
Field #x:其中 x 是当前地图的编号（从 1 开始）。下面的 n 行则将地图中的 "." 以数字表示，
该数字表示该方格周围有多少颗地雷。
#include "stdio.h"
void main()
{ int m,n,t,p,q,x,y,a[200][200];
char c;
t=1;
scanf("%d%d",&m,&n);
A: if(m==0) goto B;
for(p=0;p<=m;p++) for(q=0;q<=n;q++) a[p][q]=0;
for(p=0;p<m;p++)
for(q=0;q<=n;q++)
{scanf("%c",&c);
if(c=='*
9;)
{a[p][q]=-1;
for(x=p-1;x<=p+1;x++)
for(y=q-1;y<=q+1;y++)
if(x>=0&&x<=m&&y>=0&&y<=n&&a[x][y]!=-1) a[x][y]++;
}
}
printf("Field #%d:\n",t);
for(p=0;p<m;p++)
{for(q=1;q<=n;q++) (a[p][q]==-1)?printf("*"):printf("%d",a[p][q]);
printf("\n");
}
scanf("%d%d",&m,&n);
t++;
if(m!=0) {printf("\n");goto A;}
B: ;
}
选作T8.5 身份证的奥秘
成绩: 100 / 折扣: 0.8
背景
18位身份证标准在国家质量技术监督局于1999年7月1日实施的GB11643-1999《公民身份号码》中做了明确的规定。 GB11643-1999《公民身份号码》为GB11643-1989《社会保障号码》的修订版，其中指出将原标准名称"社会保障号码"更名为"公民身份号码"，另外GB11643-1999《公民身份号码》从实施之日起代替GB11643-1989。GB11643-1999《公民身份号码》主要内容如下：
一、范围
该标准规定了公民身份号码的编码对象、号码的结构和表现形式，使每个编码对象获得一个唯一的、不变的法定号码。
二、编码对象
公民身份号码的编码对象是具有中华人民共和国国籍的公民。
三、号码的结构和表示形式
1、号码的结构
公民身份号码是特征组合码，由十七位数字本体码和一位校验码组成。排列顺序从左至右依次为：六位数字地址码，八位数字出生日期码，三位数字顺序码和一位数字校验码。
2、地址码
表示编码对象常住户口所在县(市、旗、区)的行政区划代码，按GB/T2260的规定执行。
3、出生日期码
表示编码对象出生的年、月、日，按GB/T7408的规定执行，年、月、日代码之间不用分隔符。
4、顺序码
表示在同一地址码所标识的区域范围内，对同年、同月、同日出生的人编定的顺序号，顺序码的奇数分配给男性，偶数分配给女性。
5、校验码
（1）十七位数字本体码加权求和公式
S = Sum(Ai * Wi), i = 0, ... , 16 ，先对前17位数字的权求和
Ai: 表示第i位置上的身份证号码数字值
Wi: 表示第i位置上的加权因子
Wi: 7 9 10 5 8 4 2 1 6 3 7 9 10 5 8 4 2
（2）计算模
Y = mod(S, 11)
（3）通过模得到对应的校验码
Y: 0 1 2 3 4 5 6 7 8 9 10
校验码: 1 0 X 9 8 7 6 5 4 3 2
四、举例如下：
北京市朝阳区: 110105************
广东
省汕头市: 440524188001010014
15位的身份证号升级办法：
15位的身份证号：dddddd yymmdd xx p
18位的身份证号：dddddd yyyymmdd xx p y
?其中dddddd为地址码（省地县三级）
?yyyymmdd yymmdd 为出生年月日
?xx顺号类编码
?p性别
15 位的 yy
年升为 18 位后，变成 19yy年，但对于百岁以上老人， 则为 18yy 年，此时，他们的最后三位顺序码为996, 997, 998 或 999 来标记。
输入
输入n组身份证号码，第一行为个数，以后每行为身份证号码。
输出
如果输入的身份证号码为15位，则将其升级为18位后显示输出；否则判断其是否为合法身份证号，并逐行输出
#include <stdio.h>
#include <string.h>
char y[11]={'1','0','X','9','8','7','6','5','4','3','2'};
int flag=0,w[17]={7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2};
char jiaoyan(char s[]) //放回校验位
{
int sum=0,j=0,i=0;
for(i=0;j<17;i++,j++)
{
if(s[15]=='\0'&&i==6)j+=2;
sum+=(s[i]-48)*w[j];
}
if(s[15]=='\0')
{
if(flag)return y[(sum+10)%11];
else return y[(sum+11)%11];
}
else return y[sum%11];
}
int main()
{
int a,i;
scanf("%d\n",&a);
for(;a>0;a--)
{
char s[25];
flag=0;
gets(s);
if(strlen(s)!=15&&strlen(s)!=18)
{ printf("Invalid\n");continue; }
if(s[15]=='\0') //15位身份证升级
{
if(s[12]=='9'&&s[13]=='9'&&s[14]>='6'&&s[14]<='9')
flag=1;
for(i=0;i<15;i++)
{
if(i==6)printf("%s",flag==1?"18":"19");
printf("%c",s[i]);
}
printf("%c\n",jiaoyan(s));
}
else //18位身份证升级
{
if(s[17]==jiaoyan(s))printf("Valid\n");
else printf("Invalid\n");
}
}
return 0;
}
选做T8.6 反序输出一行英文的单词
成绩: 0 / 折扣: 0.8
反序输出一行英文的单词
例如：输入 I am student
输出 student am I
提醒：当句子前后都有空格时的算法处理。
#include <stdio.h>
#include <stdlib.h>
int main()
{
char c,str[100][100];
int flag = 1;
int i = 0,j = 0;
scanf("%c",&c);
while(c != '\n')
{
if(c != ' ')
{
flag = 1;
str[i][j++] = c;
}
else if(flag == 1)
{
str[i][j] = '\0';
flag = 0;
i++;
j = 0;
}
scanf("%c",&c);
}
if(flag == 1)
str[i][j] = '\0';
else
i--;
while(i > 0)
printf("%s ",str[i--]);
printf("%s\n",str[0]);
}
选做8.7 信用卡号验证
成绩: 0 / 折扣: 0.8
当你
输入信用卡号码的时候，有没有担心输错了而造成损失呢？其实可以不必这么担心，因为并不是一个随便的信用卡号码都是合法的，它必须通过 Luhn 算法来验证通过。
该校验的过程：
1 、从卡号最后一位数字开始，逆向将奇数位 (1 、 3 、 5 等等 ) 相加。
2 、从卡号最后
一位数字开始，逆向将偶数位数字，先乘以 2 （如果乘积为两位数，则将其减去 9 ），再求和。
3 、将奇数位总和加上偶数位总和，结果应该可以被 10 整除。
例如，卡号是： 5432123456788881
则奇数、偶数位（用红色标出）分布： 5 4 3 2 1 2 3 4 5 6 7 8 8 8 8 1
奇数位和 =35
偶数位乘以 2 （有些要减去 9 ）的结果： 1 6 2 6 1 5 7 7 ，求和 =35 。
最后 35+35=70 可以被 10 整除，认定校验通过。
请编写一个程序，从标准输入获得卡号，然后判断是否校验通过。通过显示：“PASS”，否则显示“FAIL”。
比如，用户输入： 356827027232780
程序输出：PASS
#include <stdio.h>
#include <string.h>
#define MAX 100
int exam(char *str)
{
char *p=str+strlen(str)-1;
int flag=1,sum1=0,sum2=0;
while(str<=p)
{
if(flag)
{
sum1+=*p-'0';
flag=0;
}
else
{
sum2+=(*p-'0')*2<10?(*p-'0')*2:(*p-'0')*2-9;
flag=1;
}
p--;
}
return !((sum1+sum2)%10);
}
int main()
{
char key[MAX];
scanf("%s",key);
if(exam(key))
{
printf("PASS\n");
}
else
{
printf("FAIL\n");
}
return 0;
}