一个简单的体育彩票模拟机与分析机

/*
* Copyright (C) 2010 Schux
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <stdarg.h>

#define MENU_CHOICE_SIZE 32
#define SIZE 36

/*菜单系统*/
void inlet ( void );/*主菜单，系统接口*/
void menu ( int sub_Num, char *sub_nameSPtr[ ], void ( *sub_codeFunc[ ] )( void ) );/*菜单*/
void subMenu ( int choice_Num, char *name_SPtr );/*菜单子项目名称*/
void subMenuCode ( void ( *code_Func )( void ) );/*菜单子项目执行代码*/

/*功能函数*/
FILE *openFile ( const char *fn, const char *mode );/*打开文件*/
void swap ( int *num_1, int *num_2 );/*数据交换*/
void bubble ( int *array, int array_size );/*冒泡升值排序*/

void randNum ( int *rand_stor, int n, int m );/*m<=n<=SIZE，产生随机数组rand_stor*/
void readNum ( FILE *read_stream, int *storage_fa, int storage_fa_size );/*从文件读出一组数组并存入storage_fa数组*/
void useNum ( int *old_a, int old_a_size, int *new_a );/*去掉old_a第一个元素存入new_a*/
long int assignPos ( FILE *pos_stream );/*获得特定条件的文件指针位置*/
void myScanf ( int *sNum, char *pStr );/*有条件地输入数据*/

/*规则定制*/
int recur ( int *recur_a1, int recur_a1_size, int *recur_a2, int recur_a2_size );/*重码*/
void recurNum ( int same_num, const char *obj_fn, int *obj_a, int obj_n, int obj_m );/*从目标文件读入数据比较，限定重码个数*/
int even ( int *even_a, int even_size );/*奇偶*/
int sum ( int *sum_a, int sum_size );/*总和*/
int difference ( int *diff_a, int diff_a_size );/*最大号与最小号差*/
int connect ( int *conn_a, int conn_a_size );/*连号*/
int finalRecur ( int *finalR_a, int finalR_a_size );/*尾数重号*/

/*所有规则应用*/

/*任选even,sum,difference,connect,finalRecur组合，满足最小界线*/
int rulesMin ( int *min_arg, int min_arg_size, int min_num, ... );

/*任选even,sum,difference,connect,finalRecur组合，满足最大界线*/
int rulesMax ( int *max_arg, int max_arg_size, int max_num, ... );


/*主菜单子项执行代码*/
void choose36 ( void );
void choose31 ( void );
void choose22 ( void );
void extend ( void );/*预留程序扩展功能*/

/*一级子菜单子项执行代码*/
void back ( void );/*返回主菜单*/

void random36 ( void );
void analyze36 ( void );
void import36 ( void );
void manualImport36 ( void );

void random31 ( void );
void analyze31 ( void );
void import31 ( void );
void manualImport31 ( void );

void random22 ( void );
void analyze22 ( void );
void import22 ( void );
void manualImport22 ( void );

void myRand ( const char *random_fn, int random_n, int random_m );/*按照特定条件产生随机数*/
void analyze ( const char *analyze_fn, int analyze_n, int analyze_m );/*分析工具*/
void import ( const char *import_fn, int import_n, int import_m );/*数据采集*/
void manualImport ( const char *manual_fn, int manual_n, int manual_m );/*手动输入参数产生随机数*/

void about ( void );/*程序说明*/
void quit ( void );/*退出程序*/



int main ()
{
    inlet();
    return 0;

}/*end main*/

void inlet ( void )
{
    char *str[ ] = { "/"36/" chooses /"7/".", "/"31/" chooses /"7/".", "/"22/" chooses /"5/".", "Extend.", "About.", "Quit." };/*子菜单名称*/
    void ( *myFunc[ ] )( void ) = { choose36, choose31, choose22, extend, about, quit };/*子菜单执行代码*/

    printf( "/nThe raffle ticket software menu: /n/n" );
    menu( 6, str, myFunc );

}/*end  inlet*/

void menu ( int sub_Num, char *sub_nameSPtr[ ], void ( *sub_codeFunc[ ] )( void ) )
{
    int counts, choice;
    char choice_Str[ MENU_CHOICE_SIZE ];

    for ( counts = 0; counts < sub_Num; counts++ )
        {
            subMenu( counts, sub_nameSPtr[ counts ] );
        }

    printf( "/n/tchoice: " );
    fgets( choice_Str, MENU_CHOICE_SIZE, stdin );
    choice = atoi( choice_Str );

    if ( 0 < choice && choice <= sub_Num )
        {
            subMenuCode( sub_codeFunc[ choice - 1 ] );
        }
    else
        {
            menu( sub_Num, sub_nameSPtr, sub_codeFunc );
        }/*end if*/

}/*end menu*/

void subMenu ( int choice_Num, char *name_SPtr )
{
    printf( "/t%d. %s/n", choice_Num + 1, name_SPtr );
}

void subMenuCode ( void ( *code_Func )( void ) )
{
    ( *code_Func )();
}


FILE *openFile ( const char *fn, const char *mode )
{
    FILE *streamFPtr;

    if( ( streamFPtr = fopen( fn, mode ) ) == NULL )
        {
            printf( "Error! Can't open the <%s> file!/n", fn );
            exit( 0 );
        }

    return streamFPtr;

}/*end openFile*/

void swap ( int *num_1, int *num_2 )
{
    int temp;

    temp = *num_1;
    *num_1 = *num_2;
    *num_2 = temp;

}/*end swap*/

void bubble ( int *array, int array_size )
{
    int i, j;

    for ( i = 0; i < array_size - 1; i++ )
        {
            for ( j = i + 1; j < array_size; j++ )
                {
                    if ( array[ i ] > array[ j ] )
                        {
                            swap( &array[ j ], &array[ i ] );
                        }
                }/*end for*/
    }/*end for*/

}/*end bubble*/

/*产生m个整数值从1-n的随机数*/
void randNum ( int *rand_stor, int n, int m )
{
    int i, j;
    int logic;

    srand( time( NULL ) );

    for ( i = 0; i < m; i++ )
        {
            do
                {
                    logic = 0;
                    rand_stor[ i ] = rand() % n + 1;/*产生1-n的随机整数*/

                    for ( j = 0; j < i; j++ )
                        {
                            if ( rand_stor[ j ] == rand_stor[ i ] )
                                {
                                    logic = 1;
                                    break;
                                }
                        }/*end for*/
                } while ( logic );
        }/*end for*/

}/*end randNum*/

void readNum ( FILE *read_stream, int *storage_fa, int storage_fa_size )
{
    int i;

    for( i = 0; i < storage_fa_size; i++ )
        {
            if( fscanf( read_stream, "%d", &storage_fa[ i ] ) == EOF )
                {
                    return;
                }
        }/*end for*/

}/*end readNum*/

void useNum ( int *old_a, int old_a_size, int *new_a )
{
    int i;

    for ( i = 0; i < old_a_size; i++ )
        {
            new_a[ i ] = old_a[ i + 1 ];
        }

}/*end useNum*/

long int assignPos ( FILE *pos_stream )
{
    long int pos;
    int i = 0, j = 0;

    /*统计回车个数*/
    rewind( pos_stream );
    while( !feof( pos_stream ) )
        {
            if( fgetc( pos_stream ) == '/n' )
            j = i++;
        }/*end while*/

    /*定位倒数第二个回车的文件指针*/
    i = 0;
    rewind( pos_stream );
    while( !feof( pos_stream ) )
        {
            if( fgetc( pos_stream ) == '/n' )
                {
                    if ( j - 1 == i )
                        pos = ftell( pos_stream );
                    i++;
                }
        }/*end while*/

    return pos;

}/*end assignPos*/

void myScanf ( int *sNum, char *pStr )
{
    char choice_Str[ MENU_CHOICE_SIZE ];

    fprintf( stdout, "%s: ", pStr );
    fgets( choice_Str, MENU_CHOICE_SIZE, stdin );
    *sNum = atoi( choice_Str );

}/*end myScanf*/


int recur ( int *recur_a1, int recur_a1_size, int *recur_a2, int recur_a2_size )
{
    int i, j, counts = 0;

    for ( i = 0; i < recur_a1_size; i++ )
        {
            for ( j = 0; j < recur_a2_size; j++ )
                {
                    if ( recur_a1[ i ] == recur_a2[ j ] )
                    {
                        counts++;
                    }
                }/*end for*/
        }/*end for*/

    return counts;

}/*end recur*/

void recurNum ( int same_num, const char *obj_fn, int *obj_a, int obj_n, int obj_m )
{
    int i;
    int read_num[ SIZE ];
    int use_num[ SIZE ];
    FILE *stream;

    stream = openFile( obj_fn, "rb" );
    fseek( stream, assignPos( stream ), SEEK_SET );
    readNum( stream, read_num, obj_m + 2 );
    useNum( read_num, obj_m + 2, use_num );

    do
        {
            randNum( obj_a, obj_n, obj_m );
        } while ( recur( obj_a, obj_m, use_num, obj_m + 1 ) < same_num );

    printf( "/nthis is <%d> lottery:/n/n/t-- ", read_num[ 0 ] );
    for ( i = 1; i < obj_m + 2; i++ )
        printf( "%d ", read_num[ i ] );

    printf( "--/n/n" );
    fclose( stream );

}/*end recurNum*/

int even ( int *even_a, int even_size )
{
    int i, counts = 0;

    for ( i = 0; i < even_size; i++ )
        {
            if ( even_a[ i ] % 2 == 0 )
            {
                counts++;
            }
        }/*end for*/

    return counts;

}/*end even*/

int sum ( int *sum_a, int sum_size )
{
    int i, array_sum = 0;

    for ( i = 0; i < sum_size; i++ )
        {
            array_sum += sum_a[ i ];
        }/*end for*/

    return array_sum;

}/*end sum*/

int difference ( int *diff_a, int diff_a_size )
{
    bubble( diff_a, diff_a_size );
    return diff_a[ diff_a_size - 1 ] - diff_a[ 0 ];

}/*end difference*/

int connect ( int *conn_a, int conn_a_size )
{
    int i, counts = 0;

    bubble( conn_a, conn_a_size );

    for ( i = 0; i < conn_a_size - 1; i++ )
        {
            if ( conn_a[ i + 1 ] - conn_a[ i ] == 1 )
                {
                    counts++;
                }
        }/*end for*/

    return counts;

}/*end connect*/

int finalRecur ( int *finalR_a, int finalR_a_size )
{
    int i, j, counts = 0;

    for ( i = 0; i < finalR_a_size - 1; i++ )
        {
            for ( j = i + 1; j < finalR_a_size; j++ )
                {
                    if ( finalR_a[ i ] % 10  == finalR_a[ j ] % 10 )
                        {
                            counts++;
                        }
                }
        }/*end for*/

    return counts;

}/*end finalRecur*/


int rulesMin ( int *min_arg, int min_arg_size, int min_num, ... )
{
    int i, logic = 0, min_first;
    va_list argument_list;
    va_start( argument_list, min_num );

    for ( i = 0; i < min_num; i++ )
        {
            logic = 0;
            min_first = va_arg( argument_list, int );

            switch ( i )
                {
                    case 0:
                        if ( even( min_arg, min_arg_size ) >= min_first )  logic = 1;
                        break;
                    case 1:
                        if ( sum( min_arg, min_arg_size ) >= min_first )  logic = 1;
                        break;
                    case 2:
                        if ( difference( min_arg, min_arg_size ) >= min_first )  logic = 1;
                        break;
                    case 3:
                        if ( connect( min_arg, min_arg_size ) >= min_first )  logic = 1;
                        break;
                    case 4:
                        if ( finalRecur( min_arg, min_arg_size ) >= min_first )  logic = 1;
                        break;
                    default:
                        logic = 0;
                        break;
                }/*end switch*/

            if ( 0 == logic )
            break;

        }/*end for */

    va_end( argument_list );

    return logic;

}/*end rulesMin*/

int rulesMax ( int *max_arg, int max_arg_size, int max_num, ... )
{
    int i, logic = 0, max_first;
    va_list argument_list;
    va_start( argument_list, max_num );

    for ( i = 0; i < max_num; i++ )
        {
        logic = 0;
        max_first = va_arg( argument_list, int );

        switch ( i )
            {
                case 0:
                    if ( even( max_arg, max_arg_size ) <= max_first )  logic = 1;
                    break;
                case 1:
                    if ( sum( max_arg, max_arg_size ) <= max_first )  logic = 1;
                    break;
                case 2:
                    if ( difference( max_arg, max_arg_size ) <= max_first )  logic = 1;
                    break;
                case 3:
                    if ( connect( max_arg, max_arg_size ) <= max_first )  logic = 1;
                    break;
                case 4:
                    if ( finalRecur( max_arg, max_arg_size ) <= max_first )  logic = 1;
                    break;
                default:
                    logic = 0;
                    break;
            }/*end switch*/

        if ( 0 == logic )
        break;

    }/*end for */

va_end( argument_list );

return logic;
}/*end rulesMax*/


void choose36 ( void )
{
    char *str[ ] = { "Random new data.", "Analyse an implement.", "Manual Import argument.", "Import history data.", "Back.", "Quit." };
    void ( *myFunc[ ] )( void ) = { random36, analyze36, manualImport36, import36, back, quit };

    printf( "/n/"36/" chooses /"7/" menu: /n/n" );
    menu( 6, str, myFunc );
}/*end choose36*/

void choose31 ( void )
{
    char *str[ ] = { "Random new data.", "Analyse an implement.", "Manual Import argument.", "Import history data.", "Back.", "Quit." };
    void ( *myFunc[ ] )( void ) = { random31, analyze31, manualImport31, import31, back, quit };

    printf( "/n/"31/" chooses /"7/" menu: /n/n" );
    menu( 6, str, myFunc );
}/*end choos31*/

void choose22 ( void )
{
    char *str[ ] = { "Random new data.", "Analyse an implement.", "Manual Import argument.", "Import history data.", "Back.", "Quit." };
    void ( *myFunc[ ] )( void ) = { random22, analyze22, manualImport22, import22, back, quit };

    printf( "/n/"22/" chooses /"5/" menu: /n/n" );
    menu( 6, str, myFunc );
}/*end choose22*/

void extend ( void )
{
    printf( "this is a extend of software./n" );
    inlet();
}/*end extend*/

void back ( void )
{
    inlet();
}


void random36 ( void )
{
    myRand( "lottery36.dat", 36, 7 );
    choose36();
}/*end myRand*/

void analyze36 ( void )
{
    analyze( "lottery36.dat", 36, 7 );
    choose36();
}/*end analyze36*/

void import36 ( void )
{
    import( "lottery36.dat", 36, 7 );
    choose36();
}/*end import36*/

void manualImport36 ( void )
{
    manualImport( "lottery36.dat", 36, 7 );
    choose36();
}/*end manualImport36*/


void random31 ( void )
{
    myRand( "lottery31.dat", 31, 7 );
    choose31();
}/*end random31*/

void analyze31 ( void )
{
    analyze( "lottery31.dat", 31, 7 );
    choose31();
}/*end analyze31*/

void import31 ( void )
{
    import( "lottery31.dat", 31, 7 );
    choose31();
}/*end import31*/

void manualImport31 ( void )
{
    manualImport( "lottery36.dat", 31, 7 );
    choose31();
}/*end manualImport31*/


void random22 ( void )
{
    myRand( "lottery22.dat", 22, 5 );
    choose22();
}/*end randmo22*/

void analyze22 ( void )
{
    analyze( "lottery22.dat", 22, 5 );
    choose22();
}/*end analyze22*/

void import22 ( void )
{
    import( "lottery22.dat", 22, 5 );
    choose22();
}/*end import22*/

void manualImport22 ( void )
{
    manualImport( "lottery22.dat", 22, 5 );
    choose22();
}/*end manualImport22*/


void myRand ( const char *random_fn, int random_n, int random_m )
{
    int i;
    int rulesMin_num = 0, rulesMax_num = 0;
    int random_a[ SIZE ];
    clock_t endtime;

    do
        {
            recurNum( 1, random_fn, random_a, random_n, random_m );
            for( i = 0; i < random_m; i++ )
            printf( "%d ", random_a[ i ] );
            printf( "/n/n" );
            endtime = clock() + CLOCKS_PER_SEC / 1000;/*CLOCKS_PER_SEC = one second*/
            while( endtime > clock() );

            rulesMin_num = rulesMin( random_a, random_m, 5, 2, random_n * 3, random_n / 3, 1, 1 );
            rulesMax_num = rulesMax( random_a, random_m, 5, 6, random_n * 5, random_n - 1, 3, 2 );
        } while ( rulesMin_num == 0 || rulesMax_num == 0 );

    printf( "/nThe result of /"%d/" chooses /"%d/" :/n/n/n/t---/t", random_n, random_m );
    for ( i = 0; i < random_m; i++ )
    printf( " %d ", random_a[ i ] );
    printf( "/t---/n/n" );

}/*end myRand*/

void analyze ( const char *analyze_fn, int analyze_n, int analyze_m )
{
    int i;
    int read_num_0[ SIZE ], use_num_0[ SIZE ];
    int read_num_1[ SIZE ], use_num_1[ SIZE ];
    fpos_t pos;

    FILE *stream;

    stream = openFile( analyze_fn, "rb" );
    rewind( stream );

    while( !feof( stream ) )
        {
            readNum( stream, read_num_0, analyze_m + 2 );/*涉及文件指针移动函数*/
            useNum( read_num_0, analyze_m + 2, use_num_0 );

            fgetpos( stream, &pos );/*取当前文件指针位置*/
            if ( !feof(stream) )
                {
                    readNum( stream, read_num_1, analyze_m + 2 );
                    useNum( read_num_1, analyze_m + 2, use_num_1 );

                    fsetpos( stream, &pos );/*置当前指针位置，指针后退*/

                    printf( "/n%d: ", read_num_1[ 0 ] );
                    for( i = 1; i < analyze_m + 2; i++ )
                        {
                            printf( "%02d ", read_num_1[ i ] );
                        }
                    printf( "rec(%d) ", recur( use_num_0, analyze_m + 1, use_num_1, analyze_m + 1 ) );
                    printf( "eve(%d) ", even( use_num_1, analyze_m + 1 ) );
                    printf( "sum(%03d) ", sum( use_num_1, analyze_m + 1 ) );
                    printf( "dif(%02d) ", difference( use_num_1, analyze_m + 1 ) );
                    printf( "con(%d) ", connect( use_num_1, analyze_m + 1 ) );
                    printf( "fin(%d) ", finalRecur( use_num_1, analyze_m + 1 ) );
                }

        }/*end while*/

    fclose( stream );
    printf( "/n" );

}/*end analyze*/

void import ( const char *import_fn, int import_n, int import_m )
{
    char write_Str[ MENU_CHOICE_SIZE ];
    int i, write_num;
    FILE *write_stream;

    write_stream = openFile( import_fn, "ab" );

    printf( "Please input the date: " );
    fgets( write_Str, MENU_CHOICE_SIZE, stdin );
    write_num = atoi( write_Str );
    fprintf( write_stream, "%d ", write_num );

    for( i = 0; i <= import_m; i++ )
        {
            printf( "Please input the lottery <%d> num: ", i + 1 );
            do
                {
                    fgets( write_Str, MENU_CHOICE_SIZE, stdin );
                    write_num = atoi( write_Str );

                    if ( write_num > import_n || write_num < 0 )
                    printf( "please input again: " );
                } while ( write_num > import_n || write_num < 0 );

            fprintf( write_stream, "%d ", write_num );

        }/*end for*/

    fprintf( write_stream, "/n" );
    fclose( write_stream );

}/*end import*/

void manualImport ( const char *manual_fn, int manual_n, int manual_m )
{
    int i;
    int rulesMin_num = 0, rulesMax_num = 0;
    int random_a[ SIZE ];
    clock_t endtime;

    int same_num = 0;
    int even_min = 0, sum_min = 0, diff_min = 0, conn_min = 0, recur_min = 0;
    int even_max = 5, sum_max = 231, diff_max = 35, conn_max = 6, recur_max = 5;

    myScanf( &same_num, "Please inmport same_num" );
    myScanf( &even_min, "Please inmport even_min" );
    myScanf( &even_max, "Please inmport even_max" );
    myScanf( &sum_min, "Please inmport sum_min" );
    myScanf( &sum_max, "Please inmport sum_max" );
    myScanf( &diff_min, "Please inmport difference_min" );
    myScanf( &diff_max, "Please inmport difference_max" );
    myScanf( &conn_min, "Please inmport connect_min" );
    myScanf( &conn_max, "Please inmport connect_max" );
    myScanf( &recur_min, "Please inmport finalRecur_min" );
    myScanf( &recur_max, "Please inmport finalRecur_max" );

    do
        {
            recurNum( same_num, manual_fn, random_a, manual_n, manual_m );
            for( i = 0; i < manual_m; i++ )
            printf( "%d ", random_a[ i ] );
            printf( "/n/n" );
            endtime = clock() + CLOCKS_PER_SEC / 1000;/*CLOCKS_PER_SEC = one second*/
            while( endtime > clock() );

            rulesMin_num = rulesMin( random_a, manual_m, 5, even_min, sum_min, diff_min, conn_min, recur_min );
            rulesMax_num = rulesMax( random_a, manual_m, 5, even_max, sum_max, diff_max, conn_max, recur_max );
        } while ( rulesMin_num == 0 || rulesMax_num == 0 );

    printf( "/nThe result of /"%d/" chooses /"%d/" :/n/n/n/t---/t", manual_n, manual_m );
    for ( i = 0; i < manual_m; i++ )
    printf( " %d ", random_a[ i ] );
    printf( "/t---/n/n" );

}/*end manualImport*/

void about ( void )
{
    printf( "/n  The software copyright belongs to /"schux/" company. Authorize the approach not to at will, spreading or applying to commerce without our company./n" );

    inlet();

}/*end about*/

void quit ( void )
{
    exit( 0 );
}/*end quit*/