scau 9502 ARDF一个变量的问题

哨兵变量flag不小心没设置成0。。所以一直WA

9502 ARDF

时间限制:1000MS 内存限制:65535K
提交次数:0 通过次数:0

题型: 编程题 语言: G++;GCC

Description

    ARDF，全称无线电测向。无线电测向运动是竞技体育项目之一，也是无线电活动的主要内容。它类似于众所周知的捉迷藏游戏，但它是寻找能发射无线电波的小型信号源（即发射机），

是无线电捉迷藏，是现代无线电通讯技术与传统捉迷藏游戏的结合。大致过程是：在旷野、山丘的丛林或近郊、公园等优美的自然环境中，事先隐藏好数部信号源，定时发出规定的电报信号。

参加者手持无线电测向机，测出隐蔽电台的所在方向，采用徒步方式，奔跑一定距离，迅速、准确地逐个寻找出这些信号源。以在规定时间内，找满指定台数、实用时间少者为优胜。

通常，

我们把实现巧妙隐藏起来的信号源比喻成狡猾的狐狸，故此项运动又称无线电“猎狐”或抓“狐狸”。

    摩斯密码是一种时通时断的信号代码，这种信号代码通过不同的排列顺序来表达不同的英文字母、数字和标点符号等。摩斯密码中，-表示长，.表示短。

摩斯密码表示两个字元是采用直接相连法，即直接将第二个字元的摩斯密码接到第一个字元摩斯密码的后面。一连串的摩斯密码连成一起，就是要发送的信号。

    无线电测向分为2米波段和80米波段，区别在于电波的波长不同，接收用的机器也不同。

而信号源发出的信号为摩斯密码，测向运动两个波段对应的摩斯密码如下：

    号码  2米波段  80米波段

    0     -----    -----

    1     .----    -- ---.

    2     ..---    -- ---..

    3     ...--    -- ---...

    4     ....-    -- ---....

    5     .....    -- ---.....

    6     -....    -....

    7     --...    --...

    8     ---..    ---..

    9     ----.    ----.

    BM是测向新手，对于辨别信号，信号源定位等方法都不太熟悉。现在，又到训练时间了。教练让BM拿了一部测向机在听信号，以训练辨别信号的能力。

不过，变态的教练不仅要BM分辨每个信号源对应是什么数字，还问这两个数字之和对应的摩斯密码是什么！但是，BM却不知道这是哪个波段的信号，又还没有记熟每个号码对应的摩斯密码，咋办？

答不出可是要罚跑华农一圈啊！！！

    Arokenda在训练过程中不忍心看着BM就这样受罚，就帮了BM一把，给了BM一个摩斯密码对应表和破译多位数的方法，说将两个数变成整数再算。

但是听到某一信号时，BM听了很久还没听完。惨了！数位太多，int存不下，这次又咋办？

    Arokenda说：“还不简单，用long long不就行了吗？long long可以表示-2^63至2^63-1之间的整数，而且又没有double只保留16位精度的问题。就像这样：

    #include<stdio.h>

    int main()

     long long a;

     scanf(“%lld”,&a);

     printf(“%lld”,a);

     return 0;

”

    就在此时，教练发现他们俩的作弊行为！不解释，罚跑运动场3圈！@#$%^&*

    训练还得继续，面对这魔鬼式训练，BM忍不住向大家求救！你能帮一下BM吗？

输入格式

    输入一个整数T(T<=20)，表示教练员有几次测试。

    接下来3行，第一行为一个整数W，表示该信号源是属于哪个波段，2或80。第二、三行为一串摩斯密码，长度不超过90，表示BM听到的两个信号源对应的信号。

输出格式

    每组数据输出一行，输出两个信号源对应数字之和在相应波段下的摩斯密码。

输入样例

.----

-....

-- ---.

-- ---...

-- ---....

---..

输出样例

--...

-- ---....

-- ---.-- ---..

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char s2[12][50]={{"-----"},{".----"},{"..---"},{"...--"},{"....-"},{"....."},{"-...."},{"--..."},{"---.."},{"----."}};
char s80[12][50]={{"-----"},{"-- ---."},{"-- ---.."},{"-- ---..."},{"-- ---...."},{"-- ---....."},{"-...."},{"--..."},{"---.."},{"----."}};
void pr (long long int n,int i)
{
    char str[1000][100]={0};
    int h=0;
    int j;
    if (i==2)
    {
        while (n/10>0)//这里先判断他有没有10位。
        //这样，就避免了他是0的情况
        {
            strcpy(str[h++],s2[n%10]);
            n /= 10;
        }
        strcpy(str[h],s2[n]);//加上最后一位
        for (j=h;j>=0;j--)
        {
            printf ("%s",str[j]);
        }
        printf ("\n");
    }
    else
    {
        while (n/10>0)
        {
            strcpy(str[h++],s80[n%10]);
            n /= 10;
        }
        strcpy(str[h],s80[n]);
        for (j=h;j>=0;j--)
        {
            printf ("%s",str[j]);
        }
        printf ("\n");
    }
    return ;
}
void work()
{
    int m;
    scanf ("%d",&m);
    char str1[100]={0};
    char str2[100]={0};
    getchar();//接收上面M的那个回车
    //就是scanf("%d",&m)的回车
    gets(str1);
    gets(str2);//gets 有吃回车的功能
     /*
        printf ("%s\n",str1);
        printf ("%s\n",str2);
    */
    int i;
    int len1 = strlen(str1);
    int len2 = strlen(str2);
    char str_next[100]={0};//用来判断下一个
    //用于判断80那里的。有重复的嫌疑
    char str_temp[100]={0};
    int h=0;
    int j;
    int f=0;
    int flag;
    long long int number1=0;
    long long int number2=0;
    //long long int sum = number1+number2;
    if (m==2)
    {
        for (i=0;i<len1;i++)
        {
            str_temp[h++] = str1[i];
            //一个一个字符处理，力求取最大的
            flag=0;
            for (j=0;j<10;j++)
            {
                str_temp[h]='\0';
             
                if (strcmp(str_temp,s2[j])==0)
                {
                    if (i!=len1-1)
                    {
                        strcpy(str_next,str_temp);
                                str_next[h]=str1[i+1];
                                str_next[h+1]='\0';
                        for (f=0;f<10;f++)
                        {
                            if (strcmp(str_next,s2[f])==0)
                            //如果再取多一个字符，它是存在的
                            //那么就选最长得那个
                            {
                                flag=1;
                                break;
                            }
                        }
                    }
                    else flag = 0;
                    if (!flag)
                    {
                        number1 = number1*10+j;
                        h=0;
                        memset(str_temp,0,sizeof(str_temp));
                        memset(str_next,0,sizeof(str_next));
                    }
                }
            }
        }
        h=0;
        flag=0;
        memset(str_temp,0,sizeof(str_temp));
        memset(str_next,0,sizeof (str_next));
        for (i=0;i<len2;i++)
        {
                       str_temp[h++] = str2[i];
            flag=0;//记得是设置为0
            //刚开始就是一个没设置为0
            //一直WA
            //0代表他再取一个字符，
            //str_next 不存在于s2中
            for (j=0;j<10;j++)
            {
                str_temp[h]='\0';
                 
                if (strcmp(str_temp,s2[j])==0)
                {
                    if (i!=len2-1)
                    {
                        strcpy(str_next,str_temp);
                 
                        str_next[h]=str2[i+1];
                        str_next[h+1]='\0';
                        for (f=0;f<10;f++)
                        {
                            if (strcmp(str_next,s2[f])==0)
                            {
                                flag=1;
                                break;
                            }
                        }
                    }
                    else flag=0;
                    if (!flag)
                    {
                        number2 = number2*10+j;
                        h=0;
                        memset(str_temp,0,sizeof(str_temp));
                        memset(str_next,0,sizeof(str_next));
                    }
                }
            }
        }
        pr(number1+number2,2);
    }
    else
    {
        h=0;
        flag=0;
        for (i=0;i<len1;i++)
        {
                    str_temp[h++] = str1[i];
            flag=0;
            for (j=0;j<10;j++)
            {
                str_temp[h]='\0';
                 
                if (strcmp(str_temp,s80[j])==0)
                {
                    if (i!=len1-1)
                    {
                        strcpy(str_next,str_temp);
                 
                       str_next[h]=str1[i+1];
                        str_next[h+1]='\0';
                        for (f=0;f<10;f++)
                        {
                            if (strcmp(str_next,s80[f])==0)
                            {
                                flag=1;
                                break;
                            }
                        }
                    }
                    else flag=0;
                    if (!flag)
                    {
                        number1 = number1*10+j;
                        h=0;
                        memset(str_temp,0,sizeof(str_temp));
                        memset(str_next,0,sizeof(str_next));
                    }
                }
            }
        }
        h=0;
        memset(str_temp,0,sizeof(str_temp));
        memset(str_next,0,sizeof(str_next));
        for (i=0;i<len2;i++)
        {
                    str_temp[h++] = str2[i];
            flag=0;
            for (j=0;j<10;j++)
            {
                str_temp[h]='\0';
                 
                if (strcmp(str_temp,s80[j])==0)
                {
                    if (i!=len2-1)
                    {
                        strcpy(str_next,str_temp);
                 
                        str_next[h]=str2[i+1];
                        str_next[h+1]='\0';
                        for (f=0;f<10;f++)
                        {
                            if (strcmp(str_next,s80[f])==0)
                            {
                                flag=1;
                                break;
                            }
                        }
                    }
                    else flag=0;
                    if (!flag)
                    {
                        number2 = number2*10+j;
                        memset(str_temp,0,sizeof(str_temp));
                        memset(str_next,0,sizeof(str_next));
                        h=0;
                    }
                }
            }
        }
        pr(number1+number2,80);
    }
    return ;
}
int main()
{
    int t;
    scanf ("%d",&t);
    while (t--)
    {
        work();
    }
    return 0;
}