彩票兑奖程序问题，题目要求用指针实现，求各位兄弟指点

osinooo

体育彩票由七位数字组成,第七位数字是特别号码,只有在前面六位数都正确的时候才对第七位数。现在体彩中心给出了一个特等奖号码是1234567,程序要求在屏幕上任输入一个号码判断出中了几等奖。(如果七位数字都相同就是特等奖；前六位相同为一等奖，任连续五位相同为二等奖，任连续四位相同为三等，任连续三位相同为四等，任连续两位相同位五等。(注意：除特等奖外都不考虑第七位)

  不按位对奖：也就是说不管是多少位，只要有连续几位相同都可以。比如说给出的号码是：2312345就中了三等奖(因为1234和前面相同，注意，这里的第七位是5，虽然也相同但是不能算)

osinooo

不用指针都做不出来，更别说用指针了...

osinooo

求大佬指点！

osinooo

要做吐血了

刘邦

1. #include<stdio.h>
   
2. int main()
   
3. {
   
4.         int a[7]={1,2,3,4,5,6,7};
   
5.         int b[7]                                                     ;
   
6.         int i,j,k;
   
7.         int (*r)[7]=&a;
   
8.         int (*p)[7]=&b;
   
9.         for(i=0;i<7;i++)
   
10.         {
    
11.                 scanf("%d",&b[i]);
    
12.         }
    
13.         for(j=0;j<6;j++)
    
14.         {
    
15.                 for(k=0;k<6;k++)
    
16.                 {
    
17.                         if(*(*p+j)=*(*r+k))
    
18.                         {
    
19.                                 if(*(*p+j+1)=*(*r+k+1))
    
20.                                 {
    
21.                                         if(k+1<6||j+i<6);
    
22.                                         {
    
23.                                                 printf("五等奖\n");
    
24.                                                 break;
    
25.                                         }
    
26.                                         else
    
27.                                         {
    
28.                                                 if(*(*p+j+2)=*(*r+k+2))
    
29.                                                 {
    
30.                                                         if(k+2=6||j+2=6);
    
31.                                                         {
    
32.                                                                 printf("四等奖\n");
    
33.                                                                 break;
    
34.                                                         }
    
35.                                                         else
    
36.                                                         {
    
37.                                                                 if(*(*p+j+3)=*(*r+k+3))
    
38.                                                                 {
    
39.                                                                         if(j+3=6||k+3=6)
    
40.                                                                         {
    
41.                                                                                 printf("三");
    
42.                                                                                 break;
    
43.                                                                         }
    
44.                                                                         else
    
45.                                                                         {
    
46.                                                                                 if(*(*p+j+4)=*(*r+k+4))
    
47.                                                                                 {
    
48.                                                                                         if(j+4=6||k+4=6)
    
49.                                                                                         {
    
50.                                                                                                 printf("二");
    
51.                                                                                                 break;
    
52.                                                                                         }
    
53.                                                                                         else
    
54.                                                                                         {
    
55.                                                                                                 if(*(*p+j+5)=*(*r+k+5))
    
56.                                                                                                 {
    
57.                                                                                                         if(j+5=6||k+5=6)
    
58.                                                                                                         {
    
59.                                                                                                                 printf("一");
    
60.                                                                                                                 break;
    
61.                                                                                                         }
    
62.                                                                                                         else
    
63.                                                                                                         {
    
64.                                                                                                                 if(a[7]==b[7])
    
65.                                                                                                                 {
    
66.                                                                                                                         printf("特等奖");
    
67.                                                                                                                         break;
    
68. 
    
69.                                                                                                                 }
    
70.                                                                                                                 else
    
71.                                                                                                                 {
    
72.                                                                                                                         printf("一");
    
73.                                                                                                                 }
    
74.                                                                                                         }
    
75.                                                                                                 }
    
76.                                                                                                 else
    
77.                                                                                                 {
    
78.                                                                                                         printf("二");
    
79.                                                                                                 }
    
80.                                                                                         }
    
81.                                                                                 }
    
82.                                                                                 else
    
83.                                                                                 {
    
84.                                                                                         printf("三");
    
85.                                                                                 }
    
86.                                                                         }
    
87.                                                                 }
    
88.                                                                 else
    
89.                                                                 {
    
90.                                                                         printf("四");
    
91.                                                                 }
    
92.                                                         }
    
93.                                                 }
    
94.                                                 else
    
95.                                                 {
    
96.                                                         printf("五等奖\n");
    
97.                                                 }
    
98.                                         }
    
99.                                 }
    
100.                                 else
     
101.                                 {
     
102.                                         printf("无奖\n");
     
103.                                 }
     
104.                         }
     
105.                 }
     
106.         }
     
107.         /*for(j=0;j<7;j++)
     
108.         {
     
109.                 printf("%d",b[j]);
     
110.         }
     
111.         printf("\n");
     
112.         */
     
113.           return 0;
     
114. }

复制代码

尽管有报错，但应该对你有帮助

百里狂生

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. 
   
5. //  123456（最后一位不同）按得奖分析共有 5+4+3+2+1 = 15 种子串
   
6. //  1234567 特等奖
   
7. //  将所有可能的子串（特等奖除外）存入二维数组 np 中
   
8. //  用strstr函数判断用户母串中是否含有子串，若含有，保存所含子串长度
   
9. //  所保存的最大子串长度就是对应获奖等级
   
10. 
    
11. int get_str(char ***np , char *win_Number)//获取所有子串存入np所指向的内存
    
12. {
    
13.         char *p = NULL; //返回某个子串
    
14.         char *temp = NULL;
    
15.         char **_np = NULL; //临时变量储存所有子串 15*7
    
16. 
    
17.         p = (char *)malloc(7 * sizeof(char));
    
18.         if (p == NULL)
    
19.         {
    
20.                 printf("分配内存失败 p = (char *)malloc(7 * sizeof(char));\n\n");
    
21.                 return -1;
    
22.         }
    
23.         _np = (char **)malloc(15 * sizeof(char *));
    
24.         if (_np == NULL)
    
25.         {
    
26.                 printf("分配内存失败 _np = (char **)malloc(5 * sizeof(char *));\n\n");
    
27.                 return -2;
    
28.         }
    
29. 
    
30.         for (int i = 0; i < 15; i++)
    
31.         {
    
32.                 _np[i] = (char *)malloc(7 * sizeof(char));
    
33.                 if (_np[i] == NULL)
    
34.                 {
    
35.                         printf("分配内存失败 _np[i] = (char *)malloc(7 * sizeof(char));\n\n");
    
36.                         return -3;
    
37.                 }
    
38.         }
    
39. 
    
40.         int i = 0,count = 0;
    
41.         for (int k = 2; k <= 6; k++)  //选定子串位数
    
42.         {
    
43.                
    
44.                         temp = win_Number;
    
45.                         for (i = 0; i < 7 - k ; i++) //对该位数下的子串个数(7 - k)进行遍历，复制
    
46.                         {
    
47.                                 strncpy(_np[count], temp, k);
    
48.                                 _np[count][k] = '\0';  //补字符串结尾
    
49.                                 count++;
    
50.                                 temp++; //右移不断获取k长度的子串
    
51.                         }
    
52.         }
    
53.         *np = _np;
    
54. }
    
55. 
    
56. int main()
    
57. {
    
58.         char *win_Number = "1234567"; //中奖号码
    
59.         char *Number = (char *)malloc(8 * sizeof(char)); //储存用户号码
    
60.         char **np = NULL; //保存获奖子串
    
61.         int len[15] = { 0 }; //储存子串长度
    
62.         int max_len = 0; //可能存在多个相同子串，取最大长度的那个。
    
63.         int i = 0, j = 0;
    
64. 
    
65.         printf("输入抽奖号码(7位数): ");
    
66.         scanf("%s", Number);
    
67. 
    
68.         if (strlen(Number) != 7)  //判断用户输入数字位数是否准确
    
69.         {
    
70.                 printf("输入号码位数不对");
    
71.                 return -1;
    
72.         }
    
73.        
    
74.         if (strcmp(Number, win_Number) == 0)
    
75.         {
    
76.                 printf("%s 是特等奖\n", Number);
    
77.                 return 0;
    
78.         }
    
79. 
    
80.         Number[6] = '\0'; //不是特等奖，与第7位数字无关，去除。
    
81. 
    
82.         int ret = get_str(&np,"123456"); //不是特等奖，与第7位数字无关，传前6位数字。
    
83. 
    
84.         for ( i = 0,j = 0; i < 15; i++)
    
85.         {
    
86.                 if (strstr(Number, np[i]))
    
87.                 {
    
88.                         len[j] = strlen(np[i]);  //可能存在多个相同子串，取最大长度的那个。
    
89.                         j++;
    
90.                 }
    
91.         }
    
92. 
    
93.         for ( i = 0; i < j; i++) //取最大长度的那个。
    
94.         {
    
95.                 if (max_len < len[i])
    
96.                         max_len = len[i];
    
97.         }
    
98. 
    
99.         printf("中了%d等奖\n", 7 - max_len);
    
100.         return 0;
     
101. }

复制代码

osinooo

刘邦 发表于 2018-12-11 23:36
尽管有报错，但应该对你有帮助

谢谢啦

Croper

1. //尽量增加了程序的泛用性，可以自己设定号码的位数和特别号的位数
   
2. //思路的核心是计算两个串最大能匹配的子串的长度
   
3. //简单而直接的想法是将两个串错位比较，计算最大能匹配的长度，然后右移一位，再次比较,就像这样
   
4. //-------abcdefg--        -------abcdefg--                 -abcdefg-------
   
5. //-------|--------  ==>   -------||-------  ==>.....==>    -------|-------
   
6. //-abfdefg--------        --abcdefg-------                 -------abcdefg-
   
7. //使用的编译器为VS 2017，其他编译器可能需要酌情修改
   
8. //其他的所有东西都是在犯皮
   
9. 
   
10. #include <iostream>
    
11. 
    
12. const int CNNUM = 6;         //普通位数
    
13. const int CSNUM = 1;         //特等奖位数
    
14. 
    
15. int* CutNum(int i,int l)            //分割数字，把每一位填入长度为l的数组中
    
16. {
    
17.         int *pnum = new int[l];
    
18.         l--;
    
19.         for (l; l >= 0; l--)
    
20.         {
    
21.                 pnum[l] = i % 10;
    
22.                 i = i / 10;
    
23.         }
    
24.         return pnum;
    
25. }
    
26. 
    
27. int GetMaxSameNum(const int* mNum,const int* pNum,int l)  //计算两个数列最大有多少位相同，l为数列长度
    
28. {
    
29.         const int *p, *q;
    
30.         int maxSameNum = 0;
    
31.         int n;
    
32.         for (int i = 1-l; i < l; i++)  //错位进行比较，p的第n位对应q的第n-1位
    
33.         {
    
34.                 if (i<0)
    
35.                 {
    
36.                     p =pNum ;            
    
37.                     q =mNum-i;
    
38.                 }
    
39.                 else
    
40.                 {
    
41.                         p = pNum + i;
    
42.                         q = mNum;
    
43.                 }
    
44. 
    
45.                 n = 0;              //n记录当前相同位数
    
46.                 for (int j = 0; j < l-abs(i); j++)               //错位比较时，只需要比较能对应的l-abs(i)位数
    
47.                 {
    
48.                         if (*p == *q)
    
49.                         {
    
50.                                 n++;                        
    
51.                         }
    
52.                         else
    
53.                         {
    
54.                                 if (n > maxSameNum) maxSameNum = n;    //当p！=q时，如果当前相同位数大于maxSameNum，记录。并重新将当前相同位数设为0
    
55.                                 n = 0;
    
56.                         }
    
57.                         p++;                 
    
58.                         q++;
    
59.                 }
    
60.                 if (n > maxSameNum) maxSameNum = n;  //当一次匹配循环完成时，同样需要记录当前相同位数，并将其设为0
    
61.                 n = 0;
    
62.         }
    
63. 
    
64.         return maxSameNum;
    
65. }
    
66. 
    
67. const char* GetPrizeString(int i)            //根据数字给出几等奖，字符串请自己修改(&#10042;ω&#10042;)
    
68. {
    
69.         switch (i)
    
70.         {
    
71.         case 0:
    
72.                 return "----(0)哇哦,金色传说！-----";
    
73.         case 1:
    
74.                 return "----(1)传说----";
    
75.         case 2:
    
76.                 return "----(2)金色史诗----";
    
77.         case 3:
    
78.                 return "----(3)史诗----";
    
79.         case 4:
    
80.                 return "----(4)金色稀有----";
    
81.         case 5:
    
82.                 return "----(5)稀有----";
    
83.         }
    
84.         return "----抱歉!----";
    
85. }
    
86. 
    
87. inline void PrintArray(int* a, int l)                  //打印一个数组，便于对比
    
88. {
    
89.         for (int i = 0; i < l; i++) std::cout << " " << a[i];
    
90. }
    
91. int main()
    
92. {
    
93.         int mnum, pnum;
    
94.         int *amnum, *apnum;
    
95.         int cnsame, cssame;
    
96.         int pstrnum;
    
97.         std::cout << std::endl << "请输入你的号码：";                                             
    
98.         std::cin >> mnum;
    
99.         std::cout << std::endl << "请输入中奖号码：";
    
100.         std::cin >> pnum;
     
101. 
     
102.         amnum = CutNum(mnum,CNNUM+CSNUM);                        //以数组形式记录你的号码
     
103.         apnum = CutNum(pnum,CNNUM+CSNUM);                        //以数组形式记录开奖号码
     
104.         cnsame = GetMaxSameNum(amnum, apnum, CNNUM);             //计算普通号码最大能匹配的位数   
     
105. 
     
106.         amnum += CNNUM;                                        //作为指针右移CNNUM（普通号码个数）个单位，这样对应的就是特等奖号码
     
107.         apnum += CNNUM;
     
108.         cssame = GetMaxSameNum(amnum, apnum, CSNUM);           //计算特等奖号码最大能匹配的位数        
     
109. 
     
110.         pstrnum = CNNUM + CSNUM - cnsame;                       //pstrnum储存奖次，特等奖为0，一等奖为1,依次类推，如果特等价的位数不止一位，也能正常运行，这样就是特一=0 特二=1 一等奖=3..
     
111.         if (pstrnum == CSNUM) pstrnum -= cssame;               
     
112. 
     
113.         amnum -= CNNUM;                                     //作为指针左移回原位，
     
114.         apnum -= CNNUM;
     
115.         std::cout << std::endl << "您的号码是：";
     
116.         PrintArray(amnum, CNNUM + CSNUM);
     
117.         std::cout << std::endl << "中奖号码是：";
     
118.         PrintArray(apnum, CNNUM + CSNUM);
     
119.         std::cout << std::endl << "开奖结果为：" << std::endl << GetPrizeString(pstrnum) << std::endl << std::endl;
     
120. 
     
121.         system("pause");
     
122. }
     
123. 
     

复制代码