蓝桥杯算法特训第一课【实用性原则】源代码

【内容简介】
本文章内容为【2018蓝桥杯大赛算法特训(软件)系列课程】第一课【实用性原则】中涉及到的课上例题的代码实现,加入赛前特训获取全部课程内容请联系【小蓝】。


【课程中涉及的源代码】
1. 猜年龄
【问题描述】
美国数学家维纳(N.Wiener)智力早熟,11岁就上了大学。
他曾在1935~1936年应邀来中国清华大学讲学。
一次,他参加某个重要会议,年轻的脸孔引人注目。
于是有人询问他的年龄,他回答说:
“我年龄的立方是个4位数。我年龄的4次方是个6位数。这10个数字正好包含了从0到9这10个数字,每个都恰好出现1次。”
请你推算一下,他当时到底有多年轻。
【源代码】
【JAVA:于航】


1
2
3
4
5
6
7
8
9
10
11
public class A{
    public static void main(String[] args){
        for(int i=1; i<100; i++){
            int a = i * i * i;
            int b = a * i;
            if((a+"").length()!=4) continue;
            if((b+"").length()!=6) continue;           
            System.out.println(i + " = " + a + " " + b);
        }
    }
}

【C语言:志愿者】


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//判断数组里面每一个元素是否相同,相同返回1,不同返回0
int ifDiffInArr(char* arr,int num)
{
    for (int x = 0; x < num-1; x++)
    {
        for (int y = x + 1; y < num; y++)
        {
            if (arr[x] == arr[y])
            {
                return 1;
            }
        }
    }
    return 0;
}
//判断数组1和数组2里面每一个元素是否相同,相同返回1,不同返回0
int ifDiffOfArr(char* arr1, int num1,char*arr2,int num2)
{
    for (int x = 0; x < num1; x++)
    {
        for (int y = 0; y < num2; y++)
        {
            if (arr1[x] == arr2[y])
            {
                return 1;
            }
        }
    }
    return 0;
}

void main()
{
    char arr1[4] = { 0 };//保存立方结果4位数的数组
    char arr2[6] = { 0 };//保存4次方结果6位数的数组
    int a, b;//保存立方和4次方的变量
    for (int i = 1; i < 100; i++)//年龄从1到100
    {
        //立方过程
        a= i * i * i;
        //把整形转变为数组类型char*
        itoa(a, arr1, 10);
        //判断arr1数组里面的数字是否重复,重复的话就舍掉i,继续判断下一个i++
        if (ifDiffInArr(arr1, 4) == 1)
        {
            continue;
        }

        //4次方过程
        b = a * i;
        //把整形转变为数组类型char*
        itoa(b, arr2, 10);
        //判断arr2数组里面的数字是否重复,重复的话就舍掉i,继续判断下一个i++
        if (ifDiffInArr(arr2, 6) == 1)
        {
            continue;
        }

        //判断数组arr1和arr2里面的数字是否重复,重复的话就舍掉i,继续判断下一个i++;不重复的话就是我们要找的年龄,并打印出来。
        if (ifDiffOfArr(arr1,4,arr2,6)==1)
        {
            continue;
        }
        else
        {
            printf("计算结果如下:\n\n");
            printf("数学家维纳的年龄是:%d\n\n", i);
            printf("年龄的立方是%d,  \n年龄的4次方是:%d。", a, b);
        }

    }
   
}

2. 罗马数字
【问题描述】
古罗马帝国开创了辉煌的人类文明,但他们的数字表示法的确有些繁琐,尤其在表示大数的时候,现在看起来简直不能忍受,所以在现代很少使用了。
之所以这样,不是因为发明表示法的人的智力的问题,而是因为一个宗教的原因,当时的宗教禁止在数字中出现0的概念!
罗马数字的表示主要依赖以下几个基本符号:

I –> 1
V –> 5
X –> 10
L –> 50
C –> 100
D –> 500
M –> 1000

这里,我们只介绍一下1000以内的数字的表示法。
单个符号重复多少次,就表示多少倍。最多重复3次。
比如:CCC表示300 XX表示20,但150并不用LLL表示,这个规则仅适用于I X C M。

如果相邻级别的大单位在右,小单位在左,表示大单位中扣除小单位。
比如:IX表示9 IV表示4 XL表示40
49 = XLIX

更多的示例参见下表,你找到规律了吗?
I = 1
II = 2
III = 3
IV = 4
V = 5
VI = 6
VII = 7
VIII = 8
IX = 9
X = 10
XI = 11
XII = 12
XIII = 13
XIV = 14
XV = 15
XVI = 16
XVII = 17
XVIII = 18
XIX = 19
XX = 20
XXI = 21
XXII = 22
XXIX = 29
XXX = 30
XXXIV = 34
XXXV = 35
XXXIX = 39
XL = 40
L = 50
LI = 51
LV = 55
LX = 60
LXV = 65
LXXX = 80
XC = 90
XCIII = 93
XCV = 95
XCVIII = 98
XCIX = 99
C = 100
CC = 200
CCC = 300
CD = 400
D = 500
DC = 600
DCC = 700
DCCC = 800
CM = 900
CMXCIX = 999

本题目的要求是:请编写程序,由用户输入若干个罗马数字串,程序输出对应的十进制表示。

输入格式是:第一行是整数n,表示接下来有n个罗马数字(n<100)。
以后每行一个罗马数字。罗马数字大小不超过999。
要求程序输出n行,就是罗马数字对应的十进制数据。

例如,用户输入:
3
LXXX
XCIII
DCCII

则程序应该输出:
80
93
702
【源代码】
【JAVA:于航】


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
//罗马数字的枚举解法
public class A{
   
    public static int romeNum(String s){
        int sum = 0;
        for(int i=0; i<s.length(); i++){ char c = s.charAt(i); if(c=='I') sum += 1; if(c=='V') sum += 5; if(c=='X') sum += 10; if(c=='L') sum += 50; if(c=='C') sum += 100; if(c=='D') sum += 500; if(c=='M') sum += 1000; } // 补偿 if(s.indexOf("IV")>=0) sum -= 2;
        if(s.indexOf("IX")>=0) sum -= 2;
        if(s.indexOf("XL")>=0) sum -= 20;
        if(s.indexOf("XC")>=0) sum -= 20;
        if(s.indexOf("CD")>=0) sum -= 200;
        if(s.indexOf("CM")>=0) sum -= 200;
       
        return sum;
    }
   
    public static void main(String[] args){
        System.out.println(romeNum("MCCCXIV"));
        System.out.println(romeNum("CMXCIX"));
    }
}
//罗马数字的逆向解法
public class NiXiang
{
    static String NumRoman(int x){
        int a = x / 1000;  // 千位
        int b = x % 1000 / 100;  //百位
        int c = x % 100 / 10;  // 十位
        int d = x % 10;
       
        String s = "";
       
        if(a==1) s += "M";
        if(a==2) s += "MM";
        if(a==3) s += "MMM";
       
        if(b==1) s += "C";
        if(b==2) s += "CC";
        if(b==3) s += "CCC";
        if(b==4) s += "CD";
        if(b==5) s += "D";
        if(b==6) s += "DC";
        if(b==7) s += "DCC";
        if(b==8) s += "DCCC";
        if(b==9) s += "CM";
       
        if(c==1) s += "X";
        if(c==2) s += "XX";
        if(c==3) s += "XXX";
        if(c==4) s += "XL";
        if(c==5) s += "L";
        if(c==6) s += "LX";
        if(c==7) s += "LXX";
        if(c==8) s += "LXXX";
        if(c==9) s += "XC";
               
        if(d==1) s += "I";
        if(d==2) s += "II";
        if(d==3) s += "III";
        if(d==4) s += "IV";
        if(d==5) s += "V";
        if(d==6) s += "VI";
        if(d==7) s += "VII";
        if(d==8) s += "VIII";
        if(d==9) s += "IX";
       
        return s;  
    }
     
    static boolean RomanNumOK(String s){
        for(int i=0; i<4000; i++){
            if(s.equals(NumRoman(i))) return true;
        }
        return false;
    }
   
    public static void main(String[] args){
        System.out.println(RomanNumOK("CCXLIX"));
        System.out.println(RomanNumOK("CCXXLIX"));
        //System.out.println(NumRoman(3009));
    }
}

【C语言:志愿者】


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 罗马数字的枚举解法
int romeNum(char* s,int num)
{
        int sum = 0;
        for (int i = 0; i < num; i++)
        {
            char c = s[i];
            if (c == 'I')
                sum += 1;
            if (c == 'V')
                sum += 5;
            if (c == 'X')
                sum += 10;
            if (c == 'L')
                sum += 50;
            if (c == 'C')
                sum += 100;
            if (c == 'D')
                sum += 500;
            if (c == 'M')
                sum += 1000;
        }

        // 补偿
        if (strstr(s,"IV") != NULL)
            sum -= 2;
        if (strstr(s, "IX") != NULL)
            sum -= 2;
        if (strstr(s, "XL") != NULL)
            sum -= 20;
        if (strstr(s, "XC") != NULL)
            sum -= 20;
        if (strstr(s, "CD") != NULL)
            sum -= 200;
        if (strstr(s, "CM") != NULL)
            sum -= 200;

        return sum;
}

void main()
{
   

        printf("%d\n",romeNum("MCCCXIV",7));
        printf("%d\n", romeNum("CMXCIX", 6));

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char* NumRoman(int x)
{
        char* s = malloc(10);
        memset(s, 0, 10);


        int a = x / 1000;  //
        int b = x % 1000 / 100;  //
        int c = x % 100 / 10;  //
        int d = x % 10;

       

        switch (a)
        {
        case 1:
            strcpy(s, "M");
            break;
        case 2:
            strcpy(s, "MM");
            break;
        case 3:
            strcpy(s, "MMM");
            break;
        default:
            break;
        }
   
        switch (b)
        {
        case 1:
            strcat(s, "C");
            break;
        case 2:
            strcat(s, "CC");
            break;
        case 3:
            strcat(s, "CCC");
            break;
        case 4:
            strcat(s, "CD");
            break;
        case 5:
            strcat(s, "D");
            break;
        case 6:
            strcat(s, "DC");
            break;
        case 7:
            strcat(s, "DCC");
            break;
        case 8:
            strcat(s, "DCCC");
            break;
        case 9:
            strcat(s, "CM");
            break;
        default:
            break;
        }

        switch (c)
        {
        case 1:
            strcat(s, "X");
            break;
        case 2:
            strcat(s, "XX");
            break;
        case 3:
            strcat(s, "XXX");
            break;
        case 4:
            strcat(s, "XL");
            break;
        case 5:
            strcat(s, "L");
            break;
        case 6:
            strcat(s, "LX");
            break;
        case 7:
            strcat(s, "LXX");
            break;
        case 8:
            strcat(s, "LXXX");
            break;
        case 9:
            strcat(s, "XC");
            break;
        default:
            break;
        }

   
        switch (d)
        {
        case 1:
            strcat(s, "I");
            break;
        case 2:
            strcat(s, "II");
            break;
        case 3:
            strcat(s, "III");
            break;
        case 4:
            strcat(s, "IV");
            break;
        case 5:
            strcat(s, "V");
            break;
        case 6:
            strcat(s, "VI");
            break;
        case 7:
            strcat(s, "VII");
            break;
        case 8:
            strcat(s, "VIII");
        case 9:
            strcat(s, "IX");
        default:
            break;
        }
       
        return s;
}

int  RomanNumOK(char * s)
{
        for (int i = 0; i < 1000; i++)
        {
            char *p = NumRoman(i);
            int x = strcmp(p, s);
               
            if (!x)
                return 1;
        }
        return 0;
}




void main()
{
        int num1=RomanNumOK("CCXLIX");
        if (num1==1)
        {
            printf("true");
        }
        else
        {
            printf("false");

            int num2 = RomanNumOK("CCXXLIX");
            if (num2 == 1)
            {
                printf("true");
            }
            else
            {
                printf("false");
            }

            printf("%d   %d", num1, num2);
            //System.out.println(NumRoman(3009));
        }
}

3. 九宫幻方
【问题描述】

小明最近在教邻居家的小朋友小学奥数,而最近正好讲述到了三阶幻方这个部分。
三阶幻方指的是将1~9不重复的填入一个3*3的矩阵当中,使得每一行、每一列和每一条对角线的和都是相同的。
三阶幻方又被称作九宫格,在小学奥数里有一句非常有名的口诀:
“二四为肩,六八为足,左三右七,戴九履一,五居其中”,
通过这样的一句口诀就能够非常完美的构造出一个九宫格来。
4 9 2
3 5 7
8 1 6
有意思的是,所有的三阶幻方,都可以通过这样一个九宫格进行若干镜像和旋转操作之后得到。
现在小明准备将一个三阶幻方(不一定是上图中的那个)中的一些数抹掉,交给邻居家的小朋友来进行还原,并且希望她能够判断出究竟是不是只有一个解。

而你呢,也被小明交付了同样的任务,但是不同的是,你需要写一个程序~

输入格式:
输入仅包含单组测试数据。
每组测试数据为一个3*3的矩阵,其中为0的部分表示被小明抹去的部分。
对于100%的数据,满足给出的矩阵至少能还原出一组可行的三阶幻方。

输出格式:
如果仅能还原出一组可行的三阶幻方,则将其输出,否则输出“Too Many”(不包含引号)。

样例输入
0 7 2
0 5 0
0 3 0

样例输出
6 7 2
1 5 9
8 3 4
【源代码】
【JAVA:于航】


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
/*
4 9 2
3 5 7
8 1 6
"492357816"

8 3 4
1 5 9
6 7 2
"834159672"

0 7 2
0 5 0
0 3 0

*/

public class A
{
    static boolean test(String std, String s){
        for(int i=0; i<std.length(); i++){
            if(std.charAt(i) == s.charAt(i)) continue;
            if(s.charAt(i)=='0') continue;
            return false;
        }
       
        return true;
    }
   
    public static void main(String[] args){
       
        String s = "072050030";
       
        String[] ss = {
            "492357816",
            "834159672",
            "618753294",
            "276951438",
            "294753618",
            "438951276",
            "816357492",
            "672159834"
        };
       
        for(int i=0; i<ss.length; i++){
            if(test(ss[i],s)){
                System.out.println(ss[i].substring(0,3));
                System.out.println(ss[i].substring(3,6));
                System.out.println(ss[i].substring(6,9));              
            }
        }
    }
}

【C语言:志愿者】


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int test(char* std, int num1, char* s, int num2)
{
    for (int i = 0; i < num1; i++)
    {
        if (std[i] == s[i])
            continue;
        if (s[i] == '0')
            continue;
        return 0;
    }
    return 1;
}

char * myItoa(int num)
{
    char * p = malloc(1024 * 1);
    itoa(num,p, 10);
    return p;
}

void main3()
{
    char* arr1 = myItoa(172050030);
    arr1[0] = '0';

    char *  p0 = myItoa(492357816);
    char *  p1 = myItoa(834159672);
    char *  p2 = myItoa(618753294);
    char *  p3 = myItoa(276951438);
    char *  p4 = myItoa(294753618);
    char *  p5 = myItoa(438951276);
    char *  p6 = myItoa(816357492);
    char *  p7 = myItoa(672159834);
    char *  pp[8] = { p0, p1, p2, p3, p4, p5, p6, p7 };


    for (int i = 0; i < 8; i++)
    {
        if (test(pp[i], 7, arr1,7))
        {
            for (int x = 0; x < 3;x++)
            {
                printf("%c ", pp[i][x]);
            }
            printf("\n");
            for (int x = 3; x < 6; x++)
            {
                printf("%c ", pp[i][x]);
            }
            printf("\n");
            for (int x = 6; x < 9; x++)
            {
                printf("%c ", pp[i][x]);
            }
            printf("\n");

        }
    }
    for (int i = 0; i < 8; i++)
    {
        if (pp[i] != NULL)
        {
            free(pp[i]);
        }
    }
}

4. 魔方旋转
【问题描述】
魔方可以对它的6个面自由旋转。

我们来操作一个2阶魔方(如图1所示):
为了描述方便,我们为它建立了坐标系。

各个面的初始状态如下:
x轴正向:绿
x轴反向:蓝
y轴正向:红
y轴反向:橙
z轴正向:白
z轴反向:黄

假设我们规定,只能对该魔方进行3种操作。分别标记为:
x 表示在x轴正向做顺时针旋转
y 表示在y轴正向做顺时针旋转
z 表示在z轴正向做顺时针旋转

xyz 则表示顺序执行x,y,z 3个操作

题目的要求是:
用户从键盘输入一个串,表示操作序列。
程序输出:距离我们最近的那个小方块的3个面的颜色。
顺序是:x面,y面,z面。

例如:在初始状态,应该输出:
绿红白

初始状态下,如果用户输入:
x
则应该输出:
绿白橙

初始状态下,如果用户输入:
zyx
则应该输出:
红白绿

面的标号

模仿旋转示意图

【源代码】
【JAVA:于航】


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
/*
  二阶魔方的各个面给一个唯一编号:
 
         16 17
         19 18
        -------
 12 13 |  0  1 |  4  5 |  8  9
 15 14 |  3  2 |  7  6 | 11 10
        -------
         20 21
         23 22
         
         上
       左前右后
         下
         
x操作:(0,1,2,3)  (4,21,14,19)  (7,20,13,18)
y操作:(4,5,6,7)  (1,17,11,21)  (2,18,8,22)
z操作:(16,17,18,19) (0,12,8,4)  (1,13,9,5)        
*/


public class A
{
    static int[][] transx={{0,1,2,3},{4,21,14,19},{7,20,13,18}};
    static int[][] transy={{4,5,6,7},{1,17,11,21},{2,18,8,22}};
    static int[][] transz={{16,17,18,19},{0,12,8,4},{1,13,9,5}};
   
    static char[] op(char[] a,int[][] trans){
        char[] b = java.util.Arrays.copyOf(a,a.length);
       
        for(int i=0; i<trans.length; i++){
            b[trans[i][1]] = a[trans[i][0]];
            b[trans[i][2]] = a[trans[i][1]];
            b[trans[i][3]] = a[trans[i][2]];
            b[trans[i][0]] = a[trans[i][3]];
        }
        return b;
    }
   
    static char[] op(char[] a, String s){
        char[] b = java.util.Arrays.copyOf(a, a.length);
        for(int i=0; i<s.length(); i++){
            if(s.charAt(i)=='x') b = op(b, transx);
            if(s.charAt(i)=='y') b = op(b, transy);
            if(s.charAt(i)=='z') b = op(b, transz);
        }
        return b;
    }
   
    public static void main(String[] args){
        char[] init =  {'绿','绿','绿','绿',
                        '红','红','红','红',
                        '蓝','蓝','蓝','蓝',
                        '橙','橙','橙','橙',
                        '白','白','白','白',
                        '黄','黄','黄','黄',};
                       
        //char[] b = op(init, "xyxyzzxyxyzz");
        char[] b = op(init, "x");
        System.out.println(""+b[1]+b[4]+b[18]);
       
    }
}

【C语言:志愿者】


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int transx[4][4] = { { 0, 1, 2, 3 }, { 4, 21, 14, 19 }, { 7, 20, 13, 18 } };
int transy[4][4] = { { 4, 5, 6, 7 }, { 1, 17, 11, 21 }, { 2, 18, 8, 22 } };
int transz[4][4] = { { 16, 17, 18, 19 }, { 0, 12, 8, 4 }, { 1, 13, 9, 5 } };

char * op(char *p,int num1,int pp[4][4],int num2)
{
    char * arrb = malloc(num1*sizeof(char));
    strncpy(arrb, p, num1);

    for (int i = 0; i < num2; i++)
    {
        arrb[pp[i][1]] = p[pp[i][0]];
        arrb[pp[i][2]] = p[pp[i][1]];
        arrb[pp[i][3]] = p[pp[i][2]];
        arrb[pp[i][0]] = p[pp[i][3]];
    }
    return arrb;
}
void printfCh(char a)
{
    switch (a)
    {
    case '0':
        printf("绿");
        break;
    case '1':
        printf("红");
        break;
    case '2':
        printf("蓝");
        break;
    case '3':
        printf("橙");
        break;
    case '4':
        printf("白");
        break;
    case '5':
        printf("黄");
        break;
    default:
        break;
    }

}

char * op1(char *a, int num1, char *s,int num2)
{
    char * arrb = malloc(num1*sizeof(char));
    strncpy(arrb, a, num1);

    for (int i = 0; i < num2; i++)
    {
        if (s[i] == 'x')
            arrb = op(arrb, num1, transx, 3);
        if (s[i] == 'y')
            arrb = op(arrb, num1, transy, 3);
        if (s[i] == 'z')
            arrb = op(arrb, num1, transz, 3);
    }
    return arrb;
}

void main(){
    char init[] = { '0', '0', '0', '0',
        '1', '1', '1', '1',
        '2', '2', '2', '2',
        '3', '3', '3', '3',
        '4', '4', '4', '4',
        '5', '5', '5', '5', };
   
        //char[] b = op(init, "xyxyzzxyxyzz");
        char* b = op1(init, 24, "x", 1);
        printfCh(b[1]);
        printfCh(b[4]);
        printfCh(b[18]);
;

    }

【课后作业】
【信用卡号的验证】

当你输入信用卡号码的时候,有没有担心输错了而造成损失呢?其实可以不必这么担心,因为并不是一个随便的信用卡号码都是合法的,它必须通过Luhn算法来验证通过。
该校验的过程:
1、从卡号最后一位数字开始,逆向将奇数位(1、3、5等等)相加。
2、从卡号最后一位数字开始,逆向将偶数位数字,先乘以2(如果乘积为两位数,则将其减去9),再求和。
3、将奇数位总和加上偶数位总和,结果应该可以被10整除。
例如,卡号是:5432123456788881

则,奇数位和=35
偶数位乘以2(有些要减去9)的结果:1 6 2 6 1 5 7 7,求和=35。
最后35+35=70 可以被10整除,认定校验通过。

请编写一个程序,从键盘输入卡号,然后判断是否校验通过。通过显示:“成功”,否则显示“失败”。
比如,用户输入:356827027232780
程序输出:成功

【参考测试用例】
356406010024817 成功
358973017867744 成功
356827027232781 失败
306406010024817 失败
358973017867754 失败

【代码示例】


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
public class A
{
    // s: 待验证的卡号
    static boolean f(String s){
        int sum = 0;
        for(int i=0; i<s.length(); i++){ int x = s.charAt(s.length()-i-1)-'0'; if(i%2==1){ x = x * 2; if(x>=10) x -= 9;
            }
            sum += x;
        }
        return sum % 10 == 0;
    }
   
    public static void main(String[] args){
        System.out.println(f("356827027232780"));
        System.out.println(f("356406010024817"));
        System.out.println(f("358973017867744"));
        System.out.println(f("356827027232781"));
        System.out.println(f("306406010024817"));
        System.out.println(f("358973017867754"));      
    }
}

public class B
{
    // s: 待验证的卡号
    static boolean f(String s){
        int[] EV = {0,2,4,6,8,1,3,5,7,9};
        int sum = 0;
        for(int i=0; i>s.length(); i++){
            int x = s.charAt(s.length()-i-1)-'0';
            if(i%2==1) x = EV[x];
            sum += x;
        }
        return sum % 10 == 0;
    }
   
    public static void main(String[] args){
        System.out.println(f("356827027232780"));
        System.out.println(f("356406010024817"));
        System.out.println(f("358973017867744"));
        System.out.println(f("356827027232781"));
        System.out.println(f("306406010024817"));
        System.out.println(f("358973017867754"));      
    }
}

如果您需要更多课程内容和讲解视频,请联系小蓝

Spread the word. Share this post!

Leave Comment

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