【C/C++】银行账户校验程序

【bank_ai.c】

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include "bank_ai.h"

char* guess_one_digit(char led_digit[MAX_LINE][MAX_ROW], char *des);
char check_one_digit(char led_digit[MAX_LINE][MAX_ROW]);
void print_one_line(char *bank_account);
void check_sum_according_to_guess_buf(char *guess_buf, char *bank_account, int char_index);

char bank_account[MAX_BANK_ACCOUNT_BIT] = "";
char bank_account_all_possible[MAX_BANK_ALL_POSSIBLE][MAX_BANK_ACCOUNT_BIT] = {0};
int check_sum_flag = 0;
int illegal_char_count = 0;

/*函数名称：mian*/
int main(void)
{
    return check_one_line();
}

/*函数名称：check_one_line*/
int check_one_line()
{
    FILE *fp;
    char buf[256] = {0};
    int line_count = 0;
    int illegal_char_index = 0;
    int i,j,k,t,q = 0;
    char led_first_bit[MAX_LINE][MAX_ROW]   = {0};
    char led_second_bit[MAX_LINE][MAX_ROW]  = {0};
    char led_third_bit[MAX_LINE][MAX_ROW]   = {0};
    char led_forth_bit[MAX_LINE][MAX_ROW]   = {0};
    char led_fifth_bit[MAX_LINE][MAX_ROW]   = {0};
    char led_sixth_bit[MAX_LINE][MAX_ROW]   = {0};
    char led_seventh_bit[MAX_LINE][MAX_ROW] = {0};
    char led_eighth_bit[MAX_LINE][MAX_ROW]  = {0};
    char led_ninth_bit[MAX_LINE][MAX_ROW]   = {0};
    
    if(NULL == (fp = fopen("one_bank_account.txt", "r")))
    {
        printf("No Such File!\n");
        return 0;
    }
    
    while (!feof(fp))
    {
        char *guess_buf;
        guess_buf = (char*)malloc(sizeof(char));
        char *des;
        des = (char*)malloc(sizeof(char));
        /*检查三行并将检查到的字符分别传入数组*/
        while((line_count < MAX_LINE) && (fgets(buf,sizeof(buf),fp) != NULL))
        {
            for(i = 0;i < MAX_ROW;i ++)
            {
                led_first_bit[line_count][i]   = buf[i];
                led_second_bit[line_count][i]  = buf[i + 3];
                led_third_bit[line_count][i]   = buf[i + 6];
                led_forth_bit[line_count][i]   = buf[i + 9];
                led_fifth_bit[line_count][i]   = buf[i + 12];
                led_sixth_bit[line_count][i]   = buf[i + 15];
                led_seventh_bit[line_count][i] = buf[i + 18];
                led_eighth_bit[line_count][i]  = buf[i + 21];
                led_ninth_bit[line_count][i]   = buf[i + 24];
            }
            line_count ++;
        }
        
        bank_account[0] = check_one_digit(led_first_bit);
        bank_account[1] = check_one_digit(led_second_bit);
        bank_account[2] = check_one_digit(led_third_bit);
        bank_account[3] = check_one_digit(led_forth_bit);
        bank_account[4] = check_one_digit(led_fifth_bit);
        bank_account[5] = check_one_digit(led_sixth_bit);
        bank_account[6] = check_one_digit(led_seventh_bit);
        bank_account[7] = check_one_digit(led_eighth_bit);
        bank_account[8] = check_one_digit(led_ninth_bit);
        
        /*统计每行数据中非法字符的个数*/
        for(j = 0;j < MAX_BANK_ACCOUNT_BIT;j ++)
        {
            if(bank_account[j] == '?')
            {
                illegal_char_index = j;
                illegal_char_count ++;
            }
        }
        
        /*当一行中非法字符数大于1时，直接打印问题行，并输出ILL*/
        if(1 < illegal_char_count)
        {
            print_one_line(bank_account);
            printf("ILL");
        }
        /*当一行中非法字符数等于1时，直接针对该非法字符进行猜测并匹配。若匹配失败，则打印问题行，并输出ILL；反之输出正确行*/
        else if(1 == illegal_char_count)
        {
            switch(illegal_char_index)
            {
                case 0:
                        guess_buf = guess_one_digit(led_first_bit, des);
                        check_sum_according_to_guess_buf(guess_buf, bank_account, illegal_char_index);
                        break;
                case 1:
                        guess_buf = guess_one_digit(led_second_bit, des);
                        check_sum_according_to_guess_buf(guess_buf, bank_account, illegal_char_index);
                        break;
                case 2:
                        guess_buf = guess_one_digit(led_third_bit, des);
                        check_sum_according_to_guess_buf(guess_buf, bank_account, illegal_char_index);
                        break;
                case 3:
                        guess_buf = guess_one_digit(led_forth_bit, des);
                        check_sum_according_to_guess_buf(guess_buf, bank_account, illegal_char_index);
                        break;
                case 4:
                        guess_buf = guess_one_digit(led_fifth_bit, des);
                        check_sum_according_to_guess_buf(guess_buf, bank_account, illegal_char_index);
                        break;
                case 5:
                        guess_buf = guess_one_digit(led_sixth_bit, des);
                        check_sum_according_to_guess_buf(guess_buf, bank_account, illegal_char_index);
                        break;
                case 6:
                        guess_buf = guess_one_digit(led_seventh_bit, des);
                        check_sum_according_to_guess_buf(guess_buf, bank_account, illegal_char_index);
                        break;
                case 7:
                        guess_buf = guess_one_digit(led_eighth_bit, des);
                        check_sum_according_to_guess_buf(guess_buf, bank_account, illegal_char_index);
                        break;
                case 8:
                        guess_buf = guess_one_digit(led_ninth_bit, des);
                        check_sum_according_to_guess_buf(guess_buf, bank_account, illegal_char_index);
                        break;
                default:
                        break;
            }
            
            if(!check_sum_flag)
            {
                print_one_line(bank_account);
                printf("ILL");
            }
            else
            {
                for(t = 0;t < check_sum_flag;t ++)
                {
                    printf("%s", bank_account_all_possible[t]);
                    printf(" ");
                }
            }
        }
        /*当一行中无非法字符数时，循环匹配每一位，若均匹配失败，则打印问题行，并输出ERR；反之输出所有正确可能*/
        else
        {
            for(k = 0;k < MAX_BANK_ACCOUNT_BIT;k ++)
            {
                switch(k)
                {
                    case 0:
                            guess_buf = guess_one_digit(led_first_bit, des);
                            check_sum_according_to_guess_buf(guess_buf, bank_account, k);
                            break;
                    case 1:
                            guess_buf = guess_one_digit(led_second_bit, des);
                            check_sum_according_to_guess_buf(guess_buf, bank_account, k);
                            break;
                    case 2:
                            guess_buf = guess_one_digit(led_third_bit, des);
                            check_sum_according_to_guess_buf(guess_buf, bank_account, k);
                            break;
                    case 3:
                            guess_buf = guess_one_digit(led_forth_bit, des);
                            check_sum_according_to_guess_buf(guess_buf, bank_account, k);
                            break;
                    case 4:
                            guess_buf = guess_one_digit(led_fifth_bit, des);
                            check_sum_according_to_guess_buf(guess_buf, bank_account, k);
                            break;
                    case 5:
                            guess_buf = guess_one_digit(led_sixth_bit, des);
                            check_sum_according_to_guess_buf(guess_buf, bank_account, k);
                            break;
                    case 6:
                            guess_buf = guess_one_digit(led_seventh_bit, des);
                            check_sum_according_to_guess_buf(guess_buf, bank_account, k);
                            break;
                    case 7:
                            guess_buf = guess_one_digit(led_eighth_bit, des);
                            check_sum_according_to_guess_buf(guess_buf, bank_account, k);
                            break;
                    case 8:
                            guess_buf = guess_one_digit(led_ninth_bit, des);
                            check_sum_according_to_guess_buf(guess_buf, bank_account, k);
                            break;
                    default:
                            break;
                }            
            }
            
            if(!check_sum_flag)
            {
                print_one_line(bank_account);
                printf("ERR");
            }
            else if(1 == check_sum_flag)
            {
                printf("%s", bank_account_all_possible[0]);
            }
            else
            {
                for(t = 0;t < MAX_BANK_ACCOUNT_BIT;t ++)
                {
                    printf("%c", bank_account[t]);
                }
                printf(" AMB [");
                for(t = 0;t < check_sum_flag - 1;t ++)
                {
                    printf("'");
                    for(q = 0;q < MAX_BANK_ACCOUNT_BIT;q ++)
                    {
                        printf("%c", bank_account_all_possible[t][q]);
                    }
                    printf("', ");
                }
                printf("'");
                printf("%s", bank_account_all_possible[check_sum_flag - 1]);
                printf("']");
            }
        }
        
        fgets(buf,sizeof(buf),fp);  /*定位到下一行空白行*/
        line_count = 0;
        illegal_char_count = 0;
        illegal_char_index = 0;
        check_sum_flag = 0;
        free(guess_buf);
        memset(bank_account_all_possible, 0, sizeof(bank_account_all_possible));
        //free(des);
        printf("\n");
    }

    fclose(fp);
    return 1;
}

/*函数名称：check_sum_according_to_guess_buf---->根据猜测值，检查校验和，若匹配则输出*/
void check_sum_according_to_guess_buf(char *guess_buf, char *bank_account, int char_index)
{
    int i = 0;
    for(i = 0;i < strlen(guess_buf);i ++)
    {
        char tmp = bank_account[char_index];
        bank_account[char_index] = guess_buf[i];
        if(check_sum(bank_account))  
        {
            memcpy(bank_account_all_possible[check_sum_flag],bank_account,MAX_BANK_ACCOUNT_BIT);
            //print_one_line(bank_account);
            check_sum_flag ++;
        }
        bank_account[char_index] = tmp;
    }
}

/*函数名称：guess_one_digit---->通过补充/删除_或者|来猜测单个LED数字，再调用check_one_digit进行匹配，返回相对应的值*/
char* guess_one_digit(char led_digit[MAX_LINE][MAX_ROW], char *des)
{
    char *maybe = des;
    int i,j = 0;
    int n = 0;
    
    /*补充_或者|来猜测*/
    for(i = 0;i < MAX_LINE;i ++)
    {
        for(j = 0;j < MAX_ROW;j ++)
        {
            if(led_digit[i][j] == ' ')
            {
                if((led_digit[i][j] = '_') && (check_one_digit(led_digit) != '?'))
                {
                    maybe[n++] = check_one_digit(led_digit);
                    led_digit[i][j] = ' ';
                }
                
                if((led_digit[i][j] = '|') && (check_one_digit(led_digit) != '?'))
                {
                    maybe[n++] = check_one_digit(led_digit);
                    led_digit[i][j] = ' ';
                }
                led_digit[i][j] = ' ';
            }
        }
    }
    
    /*删除_或者|来猜测*/
    for(i = 0;i < MAX_LINE;i ++)
    {
        for(j = 0;j < MAX_ROW;j ++)
        {
            if((led_digit[i][j] == '_') || (led_digit[i][j] == '|'))
            {
                char tmp = led_digit[i][j];
                if((led_digit[i][j] = ' ') && (check_one_digit(led_digit) != '?'))
                {
                    maybe[n++] = check_one_digit(led_digit);
                    led_digit[i][j] = tmp;
                }
                led_digit[i][j] = tmp;
            }
        }
    }
    maybe[n] = '\0';
    n = 0;
    
    return maybe;
}

/*函数名称：check_one_digit---->检查单个LED数字，如果匹配，返回相对应的值*/
char check_one_digit(char led_digit[MAX_LINE][MAX_ROW])
{
    if(digit_cmp(led_digit, led_digit_zero)){
        return '0';
    }
    if(digit_cmp(led_digit, led_digit_one)){
        return '1';
    }
    if(digit_cmp(led_digit, led_digit_two)){
        return '2';
    }
    if(digit_cmp(led_digit, led_digit_three)){
        return '3';
    }
    if(digit_cmp(led_digit, led_digit_four)){
        return '4';
    }
    if(digit_cmp(led_digit, led_digit_five)){
        return '5';
    }
    if(digit_cmp(led_digit, led_digit_six)){
        return '6';
    }
    if(digit_cmp(led_digit, led_digit_seven)){
        return '7';
    }
    if(digit_cmp(led_digit, led_digit_eight)){
        return '8';
    }
    if(digit_cmp(led_digit, led_digit_nine)){
        return '9';
    }
    return '?';
}

/*函数名称：digit_cmp---->逐位比较输入LED数字与标准的LED数字（1-9），全部匹配返回1*/
int digit_cmp(char led_digit[MAX_LINE][MAX_ROW], char target_digit[MAX_LINE][MAX_ROW])
{
    int i,j = 0;
    for(i = 0;i < MAX_LINE;i ++)
    {
        for(j = 0;j < MAX_ROW;j ++)
        {
            if(led_digit[i][j] != target_digit[i][j])
            {
                return 0;
            }
        }
    }
    return 1;
}

/*函数名称：check_sum---->将已经解析好的银行账号进行校验和处理，若满足要求，则返回1*/
int check_sum(char *bank_account)
{
    int check_sum = 0;
    int i = 0;
    for(i = 0;i < 9;i ++)
    {
        check_sum += (bank_account[i] - '0') * (9 - i);
    }
    return (check_sum % 11 ? 0 : 1);
}

/*函数名称：print_one_line---->打印银行账号*/
void print_one_line(char *bank_account)
{
    int m = 0;
    for(m = 0;m < MAX_BANK_ACCOUNT_BIT;m ++)
    {
        printf("%c", bank_account[m]);
    }
    printf(" ");
}

【bank_ai.h】

#ifndef BANK_AI_SYS_H_INC
#define BANK_AI_SYS_H_INC

#define MAX_LINE 3
#define MAX_ROW  3
#define MAX_BANK_ACCOUNT_BIT 9
#define MAX_BANK_ALL_POSSIBLE 32
#define MAX_PATH_LENTH 100
#define SRC_FILE_PATH "one_bank_account.txt"

const char led_digit_zero[MAX_LINE][MAX_ROW]  = { {' ','_',' '},{'|',' ','|'},{'|','_','|'}};
const char led_digit_one[MAX_LINE][MAX_ROW]   = { {' ',' ',' '},{' ',' ','|'},{' ',' ','|'}};
const char led_digit_two[MAX_LINE][MAX_ROW]   = { {' ','_',' '},{' ','_','|'},{'|','_',' '}};
const char led_digit_three[MAX_LINE][MAX_ROW] = { {' ','_',' '},{' ','_','|'},{' ','_','|'}};
const char led_digit_four[MAX_LINE][MAX_ROW]  = { {' ',' ',' '},{'|','_','|'},{' ',' ','|'}};
const char led_digit_five[MAX_LINE][MAX_ROW]  = { {' ','_',' '},{'|','_',' '},{' ','_','|'}};
const char led_digit_six[MAX_LINE][MAX_ROW]   = { {' ','_',' '},{'|','_',' '},{'|','_','|'}};
const char led_digit_seven[MAX_LINE][MAX_ROW] = { {' ','_',' '},{' ',' ','|'},{' ',' ','|'}};
const char led_digit_eight[MAX_LINE][MAX_ROW] = { {' ','_',' '},{'|','_','|'},{'|','_','|'}};
const char led_digit_nine[MAX_LINE][MAX_ROW]  = { {' ','_',' '},{'|','_','|'},{' ','_','|'}};

#endif

【BankAI_FT_test.cpp】