1. fun：从3个红球，5个白球，6个黑球中任意取出8个球，可以没有黑球，红球和白球必须要有

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
        int  fun()
    {  int  i,j,k,sum=0;
    printf("\nThe result  :\n\n");
    /**************found**************/
    for(i=1; i<=3; i++)
    {  for(j=1; j<=5; j++)
        {  k=8-i-j;
    /**************found**************/
            if(k>=0 &&k<=6)
            {  sum=sum+1;
                printf("red:%4d white:%4d black:%4d\n",i,j,k);
            }
        }
    }
    return  sum;
    }

  2. fun: 为了一个偶数寻找两个素数，这两个素数之和等于该偶数，并将两个素数通过形参指针传回主函数。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
        void  fun(int  a,int  *b,int  *c)
    {  int  i,j,d,y;
    for(i=3;i<=a/2;i=i+2) {
    /**************found**************/
        y=1;
        for(j=2;j<=sqrt((double)i);j++)
            if(i%j==0)  y=0;
        if(y==1) {
    /**************found**************/
            d=a-i;
            for(j=2;j<=sqrt((double)d);j++)
                if(d%j==0)  y=0;
            if(y==1)
            {  *b=i;  *c=d;  }
        }
    }
    }

  3. fun:根据输入的三个数判断是否能组成三角形

  4. fun: 统计substr所指字符串在str所指字符串中出现的次数。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    int fun (char *str,char *substr)
    {  int i,j,k,num=0;
    /************found************/
    for(i = 0; str[i]; i++)
        for(j=i,k=0;substr[k]==str[j];k++,j++)
    /************found************/
        if(substr[k+1]=='\0')
        {  num++;
            break;
        }
    return num;
    }

  5. fun: 将s所指字符串中最后一次出现的与他所指字符串相同的字串替换成t2所指字符串，所形成的新串放在w所指数组。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    void fun (char  *s,  char *t1, char *t2 , char *w)
    {
    char   *p , *r, *a=s;
    strcpy( w, s );
    /************found************/
    while (*w)
    {   p = w;   r = t1;
        while ( *r )
    /************found************/
            if ( *r == *p )
            { r++;  p++; }
            else  break;
        if ( *r == '\0' ) a = w;
            w++;
    }
    r = t2;
    while ( *r ){ *a = *r; a++; r++; }
    }
  1. fun:首先将b所指字符串中的字符按逆序存放，饭后将a所指字符串中的字符和b所指字符串中的字符，按排列的顺序交叉合并到c所指数组中，过长的剩余字符接在c所指数组的尾部 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    void fun( char  *a, char  *b, char  *c )
    {
    int   i , j;     char   ch;
    i = 0;    j = strlen(b)-1;
    /************found************/
    while ( i< j )
    {   ch = b[i]; b[i] = b[j]; b[j] = ch;
        i++;    j--;
    }
    while ( *a || *b ) {
    /************found************/
        if( *a )
        { *c = *a;  c++; a++; }
        if ( *b )
        { *c = *b;  c++; b++; }
    }
    *c = 0;
    }

  1. fun:将1=进制转换为$2<m<9$进制，从高位输出

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    void fun( int m, int k )
    {
    int aa[20], i;
    for( i = 0; m; i++ )
    {
    /**********found**********/
        aa[i] =  m%k;
        m /= k;
    }
    for( ; i; i-- )
    /**********found**********/
        printf( "%d", aa[ i -1] );
    }

  2. fun: 按升序排序字符串

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    void fun( char t[] )
    {
    char c;
    int  i, j;
    /**********found***********/
    for( i = strlen( t )-1; i; i-- )
        for( j = 0; j < i; j++ )
    /**********found***********/
        if( t[j] > t[ j + 1 ] )
        {
            c = t[j];
            t[j] = t[ j + 1 ];
            t[j + 1 ] = c;
        }
    }

  3. fun: 已经知道一个数列从第0项开始的前三项分别为0，0，1，以后的各项都是其相邻的前三项之和，计算输出该数列前n项的平方根之和。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    double fun(int n)
    {  double   sum,  s0, s1, s2, s; int k;
    sum = 1.0;
    if (n <= 2) sum = 0.0;
    s0 = 0.0; s1 = 0.0; s2 = 1.0;
    for (k = 4; k <= n; k++)
    {  s = s0 + s1 + s2;
        sum += sqrt(s);
        s0 = s1; s1 = s2; s2 = s;
    }
    /************found************/
    return sum;
    }

  4. fun: 在p所指字符串中找出ASCII码值最大的字符，将其放在第一个位置上；并将该字符前的原字符向后顺序移动。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    void fun( char *p )
    {   char   max,*q;   int   i=0;
        max=p[i];
        q=p;
        while( p[i]!=0 )
        {   if( max<p[i] )
        {  max=p[i];
    /**********found**********/
        q=p+i;
        }
            i++;
        }
    /**********found**********/
        while( q>p )
        { 
        *q=*(q-1);
        q--;
        }
        p[0]=max;
    }