定长顺序存储表示法,暗黑字符串个数

System.data.sqlclient.sqlexception:将截断字符串或二进制数据终止。

————————————————————————————————————————————

————————————————————————————————————————————

 某集团在线笔试题:一个字符串仅由’A’,’B’,’C’多少个字符组成,若字符串中不设有’A’,’B’,’C’三个字符相邻的子串(比如ABC,BAC等),则该字符串称为暗黑字符串,否则称为单纯字符串。

错误原因:输入的字符串长度当先数据库设置的尺寸

  • 定长顺序存储表示法
  • 定长顺序存储表示法

事例:字符串 AABBACCA,由于存在BAC子串,所以该字符串为单独字符串。

————————————————————————————————————————————

————————————————————————————————————————————

字符串 AABBCC,由于不存在A,B,C相邻构成的子串,所以该字符串为暗黑字符串。

存储结构:

积存结构:

求长度为L的此种字符串中有多少种是暗黑字符串?

行使字符串数组作为存储,定义字符串数经理度为MAXSTRLEN+1(0地方用来存放在字符串长度)

应用字符串数组作为存储,定义字符串数老总度为MAXSTRLEN+1(0地方用来存放在字符串长度)

比如说长度为1的字符串中,暗黑字符串总共有3种(即”A”,”B”,”C”),

997755.com澳门葡京 1

997755.com澳门葡京 2

长度为2的字符串中,暗黑字符串总共有9种(三个地方,每个岗位有三张可能,3*3=9),

————————————————————————————————————————————

————————————————————————————————————————————

长度为3的字符串中,暗黑字符串总共有21种(八个岗位,每个岗位有二种可能,总共有3*定长顺序存储表示法,暗黑字符串个数。3*3=27种,去除纯净字符串3!=6,结果为27-6=21种)。

操作方法:

997755.com澳门葡京,操作方法:

输入:

  • 字符串赋值

    因此将控制台输入的字符串赋值给串S1(从1早先储存),即使字符串长度当先限制,则截取越界前的数据存入。S1[0]岗位存放字符串长度

  • 字符串赋值

    透过将决定台输入的字符串赋值给串S1(从1起来储存),假使字符串长度领先限制,则截取越界前的数目存入。S1[0]义务存放字符串长度

2

  • 字符串拷贝

    对字符串遍历逐个拷贝(判断长度,仅拷贝长度限制内的)

  • 字符串拷贝

    对字符串遍历逐个拷贝(判断长度,仅拷贝长度限制内的)

3

  • 字符串判空

    认清字符串0地方是还是不是为0

  • 回到字符串长度

    归来字符串0地方的值

  • 打印字符串

    在字符串长度限制内遍历并打印

  • 字符串判空

    看清字符串0地方是否为0

  • 回去字符串长度

    再次回到字符串0地点的值

  • 打印字符串

    在字符串长度限制内遍历并打印

输出:

  • 清空字符串

    字符串长度S[0]置为0

  • 字符串联接

    判断联接的四个字符串长度之和,若是长度之和在无尽限制内,则字符串2接到字符串1后。

    假如长度之和当先界限,进行截断。先存入字符串1,字符串1存入剩下的职责存字符串2。(假如字符串1自身就是无尽长度,则留给字符串2的地方为空,不存入字符串2)

  • 清空字符串

    字符串长度S[0]置为0

  • 字符串联接

    看清联接的七个字符串长度之和,要是长度之和在无尽限制内,则字符串2接到字符串1后。

    只要长度之和当先界限,举行截断。先存入字符串1,字符串1存入剩下的职责存字符串2。(若是字符串1自我就是无尽长度,则留给字符串2的地方为空,不存入字符串2)

9

  • 索引子串地方

    概念四个临时变量 i 和 j
    存放指向子串和主串的职责。操作如图所示

    997755.com澳门葡京 3

  • 插入子串

    一旦插入子串长度会越界,则把原先的尾巴挤出字符串范围,先从字符串底部开首遍历后挪,当控制要插入的地点后将要插入的子串赋值给空位。

  • 索引子串地点

    概念四个临时变量 i 和 j
    存放指向子串和主串的职分。操作如图所示

    997755.com澳门葡京 4

  • 插入子串

    如若插入子串长度会越界,则把原来的底部挤出字符串范围,先从字符串尾部初阶遍历后挪,当控制要插入的职分后即将插入的子串赋值给空位。

21

  • 去除子串

    看清输入的义务和尺寸,将去除的字符串前边的字符往前挪。

  • 剔除子串

    看清输入的职位和长度,将去除的字符串前面的字符往前挪。

首要考虑是将长度为L的暗黑字符串根据最终五个字符是不是同样分成两类y和x(比如*AA记为y和*AB记为x等),最终三个字符不均等的暗黑字符串个数为x(L),一样的总个数为y(L),长度为L的暗黑字符串总个数为A(L)=x(L)+y(L)。接下来考虑从尺寸为L的暗黑字符串如何转变长度为L+1的暗黑字符串。对于最终多少个字符一样的长度为L的暗黑字符串(总个数为y(L)),在末端添加A,
B, C任意一个字符都足以扭转长度为L+1的暗黑字符串,比如*AA可以转变*AAA,*AAB,*AAC,生成的总数量为3y(L)(每个长度为L的y都足以生成多少个新的长度为L+1的暗黑字符串,其中有一个为y,多个为x),其中y(L)个属于y,2y(L)个属于x。对于最终多少个字符不同的长度为L的暗黑字符串(总个数为x(L)),在前边添加那多个分化的字符中肆意一个也可以扭转长度为L+1的暗黑字符串,比如*AB可以变动*ABA和*ABB,生成的总数量为2x(L)(每个长度为L的x都可以生成多个长度为L+1的暗黑字符串,其中一个为x,一个为y),其中x(L)个属于x,x(L)个属于y。

————————————————————————————————————————————

————————————————————————————————————————————

通过以上分析可见:

落到实处代码:

心想事成代码:

A(L)=x(L)+y(L),x(L)为长度为L的暗黑字符串中最后四个字符不均等的总个数,y(L)为结尾八个字符一样的总个数。

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include <string.h>
  4 #define OK 1
  5 #define ERROR 0
  6 #define TRUE 1
  7 #define FALSE 0
  8 #define OVERFLOW -2
  9 typedef int Status;
 10 #define MAXSTRLEN 40 //在255范围内定义最大串长(255为1个字节)
 11 typedef char SString[MAXSTRLEN + 1]; //位置0存放串的长度
 12 /*********************************************************/
 13 Status StrAssign(SString T, char *chars); //字符串赋值
 14 Status StrCopy(SString T, SString S); //字符串拷贝
 15 Status StrEmpty(SString S); //字符串判空
 16 Status StrLength(SString S); //返回字符串长度
 17 Status StrPrint(SString T); //打印字符串
 18 Status ClearString(SString S); //清空字符串
 19 Status Concat(SString T, SString S1, SString S2); //字符串联结
 20 Status Index(SString T, SString S); //索引子串位置
 21 Status StrInsert(SString T, SString S, int pos); //插入子串
 22 Status StrDelete(SString S, int pos, int len); //删除某个位置长度为len的子串
 23 /*自己写的方法,传入两个字符串进行比较,如果完全匹配则相同,不完全匹配则判断是否为子串*/
 24 Status StrCompare(SString T, SString S); //字符串比较
 25 Status StrSubString(SString longStr, SString shortStr); //匹配子串
 26 /*********************************************************/
 27 int main()
 28 {
 29     SString S1, S2, S3, S4, T;
 30     char str[MAXSTRLEN];
 31     int pos, len;
 32     printf("Input S1:");
 33     gets(str); //scanf无法读取到空格
 34     printf("----------------------------------\n");
 35     StrAssign(S1, str);//将输入的str赋值给串S1
 36     printf("str[40]:%s\n", str);
 37     StrPrint(S1);
 38     printf("Length:%d\n", StrLength(S1));
 39     // printf("S1:%s\n", S1 + 1); //跳过S1[0]打印
 40     printf("----------------------------------\n");
 41     StrCopy(S2, S1);
 42     printf("StrCopy... OK.\n");
 43     printf("S2:");
 44     StrPrint(S2);
 45     printf("S2.len:%d\n", StrLength(S2));
 46     printf("----------------------------------\n");
 47     ClearString(S2);
 48     StrEmpty(S2);
 49     printf("----------------------------------\n");
 50     printf("Input S3:");
 51     gets(str);
 52     StrAssign(S3, str);
 53     printf("StrCompare... OK.\n");
 54     StrCompare(S3, S1);
 55     printf("----------------------------------\n");
 56     Concat(S4, S1, S3);
 57     printf("Concat... OK.\n");
 58     printf("S4:");
 59     StrPrint(S4);
 60     printf("Length:%d\n", StrLength(S4));
 61     printf("----------------------------------\n");
 62     printf("Index S4... OK.\n");
 63     printf("Input index str:");
 64     gets(str);
 65     StrAssign(T, str);
 66     Index(T, S4);
 67     printf("----------------------------------\n");
 68     printf("Input Position:");
 69     scanf("%d", &pos);
 70     printf("Insert str to S4... OK.\n");
 71     StrInsert(T, S4, pos);
 72     printf("S4:");
 73     StrPrint(S4);
 74     printf("Length:%d\n", StrLength(S4));
 75     printf("----------------------------------\n");
 76     printf("Input Position and Length:");
 77     scanf("%d %d", &pos, &len);
 78     StrDelete(S4, pos, len);
 79     printf("S4:");
 80     StrPrint(S4);
 81     printf("Length:%d\n", StrLength(S4));
 82     return 0;
 83 }
 84 /* 字符串赋值,当赋值字符串长度超过被赋值字符串时候截断,未超过时先将长度存入T[0],再逐位赋值 */
 85 Status StrAssign(SString T, char *chars)
 86 {
 87     int i;
 88     if (strlen(chars) > MAXSTRLEN)
 89     {
 90         for (i = 1; i <= MAXSTRLEN; ++i)
 91             T[i] = *(chars + i - 1);
 92         T[0] = MAXSTRLEN;
 93     }
 94     else
 95     {
 96         T[0] = strlen(chars); //p.s.此时T[0]存入的是int类型的数据,打印%s时无法显示
 97         for (i = 1; i <= MAXSTRLEN; ++i)
 98             T[i] = *(chars + i - 1);
 99         return OK;
100     }
101 }
102 /* 字符串拷贝,逐个字符拷贝(仅拷贝长度范围内的) */
103 Status StrCopy(SString T, SString S)
104 {
105     int i;
106     //p.s.此处要拷贝长度+1,将S1的\0同时拷贝进去,否则T中没有\0
107     for (i = 1; i <= S[0]; ++i)
108         T[i] = S[i];
109     T[0] = S[0];
110     return OK;
111 }
112 /* 字符串判空,当S[0]==0时为空 */
113 Status StrEmpty(SString S)
114 {
115     if (S[0] == 0)
116     {
117         printf("String is Empty\n");
118         return TRUE;
119     }
120     else
121     {
122         printf("String is not Empty\n");
123         return FALSE;
124     }
125 }
126 /* 返回子串长度 */
127 Status StrLength (SString S)
128 {
129     return S[0];
130 }
131 /* 打印字符串 */
132 Status StrPrint(SString T)
133 {
134     int i;
135     for (i = 1; i <= T[0]; ++i)
136     {
137         printf("%c", T[i]);
138     }
139     printf("\n");
140     return OK;
141 }
142 /* 清空字符串 */
143 Status ClearString(SString S)
144 {
145     S[0] = 0;
146     return OK;
147 }
148 /* 字符串联接,通过T来存储结果,S2连接而成的新串,若未截断则返回TRUE,截断返回FAlSE,注意字符串数组越界问题 */
149 Status Concat(SString T, SString S1, SString S2)
150 {
151     int i;
152     if (S1[0] + S2[0] <= MAXSTRLEN)
153     {
154         for (i = 1; i <= S1[0]; ++i)
155             T[i] = S1[i];
156         for (i = 1; i <= S2[0]; ++i)
157             T[i + S1[0]] = S2[i];
158         T[0] = S1[0] + S2[0];
159         return TRUE;
160     }
161     else //先存完S1中的,再存S2中的内容,条件是不能越界
162     {
163         for (i = 1; i <= S1[0] && i <= MAXSTRLEN - 1; ++i)
164             T[i] = S1[i];
165         for (i = 1; i <= MAXSTRLEN - S1[0]; ++i)
166             T[i + S1[0]] = S2[i];
167         T[0] = MAXSTRLEN;
168         return FALSE;
169     }
170 }
171 /* 索引子串 */
172 Status Index(SString T, SString S)
173 {
174     int i = 1, j = 1;
175     while(j <= T[0] && i <= S[0])
176     {
177         if (T[j] == S[i])
178         {
179             ++i;
180             ++j;
181         }
182         else
183         {
184             i = i - j + 2;
185             j = 1;
186         }
187     }
188     if (j > T[0])
189     {
190         printf("Position:%d\n", i - j + 1);
191         return OK;
192     }
193     else
194     {
195         printf("substring is not exist\n");
196         return ERROR;
197     }
198 }
199 /* 在位置pos处插入子串T */
200 Status StrInsert(SString T, SString S, int pos)
201 {
202     int i;
203     if (pos > S[0])
204         pos = S[0] + 1;
205     if (S[0] + T[0] <= MAXSTRLEN)
206     {
207         for (i = S[0] + T[0]; i >= pos + T[0]; --i)
208             S[i] = S[i - T[0]];
209         for (i = 1; i <= T[0]; ++i)
210             S[pos + i - 1] = T[i];
211         S[0] = S[0] + T[0];
212         return OK;
213     }
214     else
215     {
216         for (i = MAXSTRLEN; i >= pos + T[0]; --i)
217             S[i] = S[i - T[0]];
218         for (i = 1; i <= T[0]; ++i)
219             S[pos + i - 1] = T[i];
220         S[0] = MAXSTRLEN;
221         return ERROR;
222     }
223 }
224 Status StrDelete(SString S, int pos, int len)
225 {
226     int i;
227     if (pos > S[0])
228         return ERROR;
229     else if (pos + len > S[0])
230         len = S[0] - pos + 1;
231     for (i = pos + len; i <= S[0]; ++i)
232         S[i - len] = S[i];
233     S[0] -= len;
234 }
235 /* 字符串比较。比较字符串是否完全相同,如果不同则判断子串所在的位置 */
236 Status StrCompare(SString T, SString S)
237 {
238     int i, j;
239     /* 当两个字符串长度相同时,逐个判断字符是否相同,不相同则退出,相同则继续比较 */
240     if (T[0] == S[0])
241     {
242         for (i = 1; i <= S[0]; ++i)
243         {
244             if (T[i] != S[i])
245             {
246                 printf("A.len==B.len , A!=B \n");
247                 return ERROR;
248             }
249         }
250         printf("A == B\n");
251         return OK;
252     }
253     else if(T[0] < S[0])
254         StrSubString(T, S);
255     else if(T[0] > S[0])
256         StrSubString(S, T);
257 }
258 /* 判断A是否是B的子串。逐个遍历长字符串,当短字符串首字符与长字符串字符相同时,短字符串与长字符串逐个比较,中途有不匹配的情况则重新开始比较,长字符串继续遍历,如果短字符串比对完并且最后一个字符也相同时则是子串 */
259 Status StrSubString(SString shortStr, SString longStr)
260 {
261     int i, j = 1;
262     for (i = 1; i <= longStr[0]; ++i)
263     {
264         if (shortStr[1] == longStr[i])
265         {
266             for (j = 1; j <= shortStr[0] ; ++j)
267             {
268                 if (j == shortStr[0] && shortStr[j] == longStr[j + i - 1])
269                 {
270                     printf("A is substring of B.Location is:%d\n", i);
271                     return OK;
272                 }
273                 if (shortStr[j] != longStr[j + i - 1])
274                     break;
275             }
276         }
277     }
278     printf("A not substring of B\n");
279     return ERROR;
280 }
  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include <string.h>
  4 #define OK 1
  5 #define ERROR 0
  6 #define TRUE 1
  7 #define FALSE 0
  8 #define OVERFLOW -2
  9 typedef int Status;
 10 #define MAXSTRLEN 40 //在255范围内定义最大串长(255为1个字节)
 11 typedef char SString[MAXSTRLEN + 1]; //位置0存放串的长度
 12 /*********************************************************/
 13 Status StrAssign(SString T, char *chars); //字符串赋值
 14 Status StrCopy(SString T, SString S); //字符串拷贝
 15 Status StrEmpty(SString S); //字符串判空
 16 Status StrLength(SString S); //返回字符串长度
 17 Status StrPrint(SString T); //打印字符串
 18 Status ClearString(SString S); //清空字符串
 19 Status Concat(SString T, SString S1, SString S2); //字符串联结
 20 Status Index(SString T, SString S); //索引子串位置
 21 Status StrInsert(SString T, SString S, int pos); //插入子串
 22 Status StrDelete(SString S, int pos, int len); //删除某个位置长度为len的子串
 23 /*自己写的方法,传入两个字符串进行比较,如果完全匹配则相同,不完全匹配则判断是否为子串*/
 24 Status StrCompare(SString T, SString S); //字符串比较
 25 Status StrSubString(SString longStr, SString shortStr); //匹配子串
 26 /*********************************************************/
 27 int main()
 28 {
 29     SString S1, S2, S3, S4, T;
 30     char str[MAXSTRLEN];
 31     int pos, len;
 32     printf("Input S1:");
 33     gets(str); //scanf无法读取到空格
 34     printf("----------------------------------\n");
 35     StrAssign(S1, str);//将输入的str赋值给串S1
 36     printf("str[40]:%s\n", str);
 37     StrPrint(S1);
 38     printf("Length:%d\n", StrLength(S1));
 39     // printf("S1:%s\n", S1 + 1); //跳过S1[0]打印
 40     printf("----------------------------------\n");
 41     StrCopy(S2, S1);
 42     printf("StrCopy... OK.\n");
 43     printf("S2:");
 44     StrPrint(S2);
 45     printf("S2.len:%d\n", StrLength(S2));
 46     printf("----------------------------------\n");
 47     ClearString(S2);
 48     StrEmpty(S2);
 49     printf("----------------------------------\n");
 50     printf("Input S3:");
 51     gets(str);
 52     StrAssign(S3, str);
 53     printf("StrCompare... OK.\n");
 54     StrCompare(S3, S1);
 55     printf("----------------------------------\n");
 56     Concat(S4, S1, S3);
 57     printf("Concat... OK.\n");
 58     printf("S4:");
 59     StrPrint(S4);
 60     printf("Length:%d\n", StrLength(S4));
 61     printf("----------------------------------\n");
 62     printf("Index S4... OK.\n");
 63     printf("Input index str:");
 64     gets(str);
 65     StrAssign(T, str);
 66     Index(T, S4);
 67     printf("----------------------------------\n");
 68     printf("Input Position:");
 69     scanf("%d", &pos);
 70     printf("Insert str to S4... OK.\n");
 71     StrInsert(T, S4, pos);
 72     printf("S4:");
 73     StrPrint(S4);
 74     printf("Length:%d\n", StrLength(S4));
 75     printf("----------------------------------\n");
 76     printf("Input Position and Length:");
 77     scanf("%d %d", &pos, &len);
 78     StrDelete(S4, pos, len);
 79     printf("S4:");
 80     StrPrint(S4);
 81     printf("Length:%d\n", StrLength(S4));
 82     return 0;
 83 }
 84 /* 字符串赋值,当赋值字符串长度超过被赋值字符串时候截断,未超过时先将长度存入T[0],再逐位赋值 */
 85 Status StrAssign(SString T, char *chars)
 86 {
 87     int i;
 88     if (strlen(chars) > MAXSTRLEN)
 89     {
 90         for (i = 1; i <= MAXSTRLEN; ++i)
 91             T[i] = *(chars + i - 1);
 92         T[0] = MAXSTRLEN;
 93     }
 94     else
 95     {
 96         T[0] = strlen(chars); //p.s.此时T[0]存入的是int类型的数据,打印%s时无法显示
 97         for (i = 1; i <= MAXSTRLEN; ++i)
 98             T[i] = *(chars + i - 1);
 99         return OK;
100     }
101 }
102 /* 字符串拷贝,逐个字符拷贝(仅拷贝长度范围内的) */
103 Status StrCopy(SString T, SString S)
104 {
105     int i;
106     //p.s.此处要拷贝长度+1,将S1的\0同时拷贝进去,否则T中没有\0
107     for (i = 1; i <= S[0]; ++i)
108         T[i] = S[i];
109     T[0] = S[0];
110     return OK;
111 }
112 /* 字符串判空,当S[0]==0时为空 */
113 Status StrEmpty(SString S)
114 {
115     if (S[0] == 0)
116     {
117         printf("String is Empty\n");
118         return TRUE;
119     }
120     else
121     {
122         printf("String is not Empty\n");
123         return FALSE;
124     }
125 }
126 /* 返回子串长度 */
127 Status StrLength (SString S)
128 {
129     return S[0];
130 }
131 /* 打印字符串 */
132 Status StrPrint(SString T)
133 {
134     int i;
135     for (i = 1; i <= T[0]; ++i)
136     {
137         printf("%c", T[i]);
138     }
139     printf("\n");
140     return OK;
141 }
142 /* 清空字符串 */
143 Status ClearString(SString S)
144 {
145     S[0] = 0;
146     return OK;
147 }
148 /* 字符串联接,通过T来存储结果,S2连接而成的新串,若未截断则返回TRUE,截断返回FAlSE,注意字符串数组越界问题 */
149 Status Concat(SString T, SString S1, SString S2)
150 {
151     int i;
152     if (S1[0] + S2[0] <= MAXSTRLEN)
153     {
154         for (i = 1; i <= S1[0]; ++i)
155             T[i] = S1[i];
156         for (i = 1; i <= S2[0]; ++i)
157             T[i + S1[0]] = S2[i];
158         T[0] = S1[0] + S2[0];
159         return TRUE;
160     }
161     else //先存完S1中的,再存S2中的内容,条件是不能越界
162     {
163         for (i = 1; i <= S1[0] && i <= MAXSTRLEN - 1; ++i)
164             T[i] = S1[i];
165         for (i = 1; i <= MAXSTRLEN - S1[0]; ++i)
166             T[i + S1[0]] = S2[i];
167         T[0] = MAXSTRLEN;
168         return FALSE;
169     }
170 }
171 /* 索引子串 */
172 Status Index(SString T, SString S)
173 {
174     int i = 1, j = 1;
175     while(j <= T[0] && i <= S[0])
176     {
177         if (T[j] == S[i])
178         {
179             ++i;
180             ++j;
181         }
182         else
183         {
184             i = i - j + 2;
185             j = 1;
186         }
187     }
188     if (j > T[0])
189     {
190         printf("Position:%d\n", i - j + 1);
191         return OK;
192     }
193     else
194     {
195         printf("substring is not exist\n");
196         return ERROR;
197     }
198 }
199 /* 在位置pos处插入子串T */
200 Status StrInsert(SString T, SString S, int pos)
201 {
202     int i;
203     if (pos > S[0])
204         pos = S[0] + 1;
205     if (S[0] + T[0] <= MAXSTRLEN)
206     {
207         for (i = S[0] + T[0]; i >= pos + T[0]; --i)
208             S[i] = S[i - T[0]];
209         for (i = 1; i <= T[0]; ++i)
210             S[pos + i - 1] = T[i];
211         S[0] = S[0] + T[0];
212         return OK;
213     }
214     else
215     {
216         for (i = MAXSTRLEN; i >= pos + T[0]; --i)
217             S[i] = S[i - T[0]];
218         for (i = 1; i <= T[0]; ++i)
219             S[pos + i - 1] = T[i];
220         S[0] = MAXSTRLEN;
221         return ERROR;
222     }
223 }
224 Status StrDelete(SString S, int pos, int len)
225 {
226     int i;
227     if (pos > S[0])
228         return ERROR;
229     else if (pos + len > S[0])
230         len = S[0] - pos + 1;
231     for (i = pos + len; i <= S[0]; ++i)
232         S[i - len] = S[i];
233     S[0] -= len;
234 }
235 /* 字符串比较。比较字符串是否完全相同,如果不同则判断子串所在的位置 */
236 Status StrCompare(SString T, SString S)
237 {
238     int i, j;
239     /* 当两个字符串长度相同时,逐个判断字符是否相同,不相同则退出,相同则继续比较 */
240     if (T[0] == S[0])
241     {
242         for (i = 1; i <= S[0]; ++i)
243         {
244             if (T[i] != S[i])
245             {
246                 printf("A.len==B.len , A!=B \n");
247                 return ERROR;
248             }
249         }
250         printf("A == B\n");
251         return OK;
252     }
253     else if(T[0] < S[0])
254         StrSubString(T, S);
255     else if(T[0] > S[0])
256         StrSubString(S, T);
257 }
258 /* 判断A是否是B的子串。逐个遍历长字符串,当短字符串首字符与长字符串字符相同时,短字符串与长字符串逐个比较,中途有不匹配的情况则重新开始比较,长字符串继续遍历,如果短字符串比对完并且最后一个字符也相同时则是子串 */
259 Status StrSubString(SString shortStr, SString longStr)
260 {
261     int i, j = 1;
262     for (i = 1; i <= longStr[0]; ++i)
263     {
264         if (shortStr[1] == longStr[i])
265         {
266             for (j = 1; j <= shortStr[0] ; ++j)
267             {
268                 if (j == shortStr[0] && shortStr[j] == longStr[j + i - 1])
269                 {
270                     printf("A is substring of B.Location is:%d\n", i);
271                     return OK;
272                 }
273                 if (shortStr[j] != longStr[j + i - 1])
274                     break;
275             }
276         }
277     }
278     printf("A not substring of B\n");
279     return ERROR;
280 }

x(L+1)=x(L)+2y(L),长度为L+1且最终四个字符不一致等的暗黑字符串是由长度为L的x和y衍变而来,且数额分别为x(L)和2y(L)。

y(L+1)=x(L)+y(L),长度为L+1且最终三个字符一样的暗黑字符串是由长度为L的x和y演化而来,且数额分别为x(L)和y(L)。

A(L+1)=x(L+1)+y(L+1)

 

实际代码如下:

997755.com澳门葡京 5997755.com澳门葡京 6

 1 package com.test1;
 2 
 3 import java.util.Scanner;
 4 
 5 public class DarkString {
 6     /*
 7      * 主要想法:长度为L的暗黑字符串可以根据最后两个字符分成两类,最后两个字符是一样的和最后两个不一样的情况。
 8      * 长度为L+1的暗黑字符串可以由长度为L的暗黑字符串生成。
 9      */
10     public static long totalCount(long length){
11         if(length < 1)
12             return 0;
13         if(length == 1)
14             return 3;
15         /*
16          * x1表示长度为L的字符串最后两个字符不一样的暗黑字符串个数(比如*AB,*AC等),
17          * 对于长度为2的暗黑字符串,总个数为6
18          */
19         long x1 = 6;
20         /*
21          * y1表示一个字符串最后连个字符一样的暗黑字符串个数(比如*AA,*BB等),
22          * 对于长度为2的暗黑字符串,总个数为3
23          */
24         long y1 = 3;
25         //start from string with length 2
26         length = length - 2;
27         while(length-- > 0){
28             long x2 = x1 + 2*y1;
29             long y2 = x1 + y1;
30             x1 = x2;
31             y1 = y2;
32         }
33         //长度为length的字符串中,暗黑字符串总个数
34         return x1+y1;
35     }
36     
37     public static void main(String[] args){
38         Scanner scanner = new Scanner(System.in);
39         while(scanner.hasNext()){
40             int len = scanner.nextInt();
41             System.out.println(totalCount((long)len));
42         }
43         scanner.close();
44     }
45 }

View Code

 

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website