[原创] 指针操作程序答案 — 谭浩强C语言习题答案

最新推荐文章于 2022-05-10 23:12:07 发布
最新推荐文章于 2022-05-10 23:12:07 发布
阅读量1.6k 收藏 2
点赞数
文章标签： 语言 c ibm features null 编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eric_liufeng/article/details/6301298
版权

这两天复习RenMian给我留下谭浩强的C语言教程，温故而知新，夯实基础知识，

把谭浩强版C语言的第十章《指针》的书复习后把所有的编程习题做了一遍，贴出来激励自己一下，也希望有用的同学可以参考，时间和水平有限，不足之处，恳请读者批评指正

第十章《指针》答案如下

inc/testPtr.h

#include <string.h>
#include 
  
  
   
   
#include 
   
   
    
    
#include 
    
    


     
     #define SIZE 1024


     
     int a2i(
     
     char *start, 
     
     char *end)
{
    
     
     int size = 0, ret = 0;
    
     
     long 
     
     base = 0;

    size = end - start + 1;
    
     
     base = (
     
     long)pow(10, size - 1);

    
     
     while(size-- > 0)
    {
        ret += (*start++ - 
     
     '0') * 
     
     base;
        
     
     base /= 10;
    }

    
     
     return ret;
}


     
     int extraNum(
     
     char *str, 
     
     int arr[])
{
    
     
     int  ite = 0, counter = 0;
    
     
     char *start = NULL, *end = NULL;

    
     
     while(*str != 
     
     '/0')
    {
        
     
     if(isdigit(*str))
        {
            start = end = str;

            
     
     while( isdigit(*end) && *end != 
     
     '/0')
            {
                ++end;
            }

            arr[ite++] = a2i(start, end-1);

            str = end;
        }
        
     
     else
        {
            str++;
        }
    }

    
     
     return ite;

}


     
     int sortStr(
     
     char *arr[], 
     
     int size)
{
    
     
     int ite1 = 0, ite2 = 0, minPos = 0;
    
     
     char *tmp;

    
     
     for(ite1 = 0; ite1 < size - 1; ite1++)
    {
        minPos = ite1;
        
     
     for(ite2 = ite1 + 1; ite2 < size; ++ite2 )
        {
            
     
     if( strcmp(arr[ite2], arr[minPos]) < 0 )
            {
                minPos = ite2;
            }
        }

        
     
     if(minPos != ite1)
        {
            tmp = arr[minPos];
            arr[minPos] = arr[ite1];
            arr[ite1] = tmp;
        }
    }

    
     
     return 0;
}


     
     int sort(
     
     int arr[], 
     
     int size)
{
    
     
     int minPos = 0, ite1 = 0, ite2 = 0, tmp = 0;

    
     
     for(ite1 = 0; ite1 < size - 1; ite1++)
    {
        minPos = ite1;
        
     
     for(ite2 = ite1 + 1; ite2 < size; ite2++)
        {
            
     
     if( arr[ite2] < arr[minPos] )
            {
                minPos = ite2;
            }
        }

        
     
     if(minPos != ite1)
        {
            tmp = arr[ite1];
            arr[ite1] = arr[minPos];
            arr[minPos] = tmp;
        }
    }

    
     
     return 0;
}


     
     int sortPtr(
     
     int arr[], 
     
     int size)
{
    
     
     int minPos = 0, ite1 = 0, ite2 = 0, tmp = 0;

    
     
     for(ite1 = 0; ite1 < size - 1; ite1++)
    {
        minPos = ite1;
        
     
     for(ite2 = ite1 + 1; ite2 < size; ite2++)
        {
            
     
     if( *(arr + ite2) < *(arr + minPos) )
            {
                minPos = ite2;
            }
        }

        
     
     if(minPos != ite1)
        {
            tmp = *(arr + ite1);
            *(arr + ite1) = *(arr + minPos);
            *(arr + minPos) = tmp;
        }
    }

    
     
     return 0;
}


     
     int getMultiArr(
     
     int arr[][5], 
     
     int n)
{
    
     
     int i = 0, j = 0, min = 0, tmp = 0, size = 5 * n;
    
     
     int *p = NULL, pos[size];

    
     
     /* copy */
    p = (
     
     int *)malloc(size * 
     
     sizeof(
     
     int));
    assert(p != NULL);
    memcpy(p, arr, size * 
     
     sizeof(
     
     int));

    
     
     /* sort */
    
     
     for(i = 0; i < size - 1; i++)
    {
        min = i;

        
     
     for(j = i + 1; j < size; j++)
        {
            
     
     if( *(p + j) < *(p + min))
            {
                min = j;
            }
        }

        
     
     if(min != i)
        {
            tmp = *(p + min);
            *(p + min) = *(p + i);
            *(p + i) = tmp;
        }
    }

    
     
     /* move */
    
     
     for(i = 0; i < n; i++)
    {
        
     
     for(j = 0; j < 5; j++)
        {
            
     
     if( *p == arr[i][j] )
            {
                tmp = arr[i][j];
                arr[i][j] = arr[0][0];
                arr[0][0] = tmp;
                
     
     continue;
            }

            
     
     if( *(p + 1) == arr[i][j] )
            {
                tmp = arr[i][j];
                arr[i][j] = arr[0][4];
                arr[0][4] = tmp;
                
     
     continue;
            }

            
     
     if( *(p + 2) == arr[i][j] )
            {
                tmp = arr[i][j];
                arr[i][j] = arr[n - 1][0];
                arr[n - 1][0] = tmp;
                
     
     continue;
            }

            
     
     if( *(p + 3) == arr[i][j] )
            {
                tmp = arr[i][j];
                arr[i][j] = arr[n - 1][4];
                arr[n - 1][4] = tmp;
                
     
     continue;
            }

            
     
     if( *(p + size - 1) == arr[i][j] )
            {
                tmp = arr[i][j];
                arr[i][j] = arr[n/2][2];
                arr[n/2][2] = tmp;
                
     
     continue;
            }

        }
    }

    free(p);
    p = NULL;

    
     
     return 0;
}


     
     int statStr(
     
     char *str)
{
    
     
     int upper = 0, lower = 0, space = 0, num = 0, other = 0;
    
     
     while(*str != 
     
     '/0')
    {
        
     
     if(isdigit(*str))
        {
            num++;
        }
        
     
     else 
     
     if (isupper(*str))
        {
            upper++;
        }
        
     
     else 
     
     if (islower(*str))
        {
            lower++;
        }
        
     
     else 
     
     if (isspace(*str))
        {
            space++;
        }
        
     
     else
        {
            other++;
        }

        str++;
    }

    assert(3 == upper);
    assert(5 == lower);
    assert(10 == num);
    assert(2 == space);
    assert(6 == other);

    
     
     return 0;
}


     
     int average(
     
     int(*stu)[6], 
     
     int classNum, 
     
     int stuNum)
{
    
     
     int i = 0, ave = 0;

    
     
     for(i = 0; i < stuNum; i++)
    {
        ave += (*(stu + i))[classNum];
    }

    ave /= stuNum;

    
     
     return ave;
}



     
     int searchStu(
     
     int(*stu)[6], 
     
     int stuNum)
{
    
     
     int counter = 0, i = 0, j = 1, stuCounter = 0;

    
     
     for (i = 0; i < stuNum; i++)
    {
        counter  =0;

        
     
     for(j = 1; j < 6; j++)
        {
            
     
     if(  (*(stu + i))[j] < 60  )
            {
                counter++;
            }
        }

        
     
     if(counter >= 2)
        {
            stuCounter++;
        }
    }

    
     
     return stuCounter;
}


     
     int moveInt(
     
     int arr[], 
     
     int n, 
     
     int m)
{
    
     
     int i = 0, *p = NULL;

    p = (
     
     int*)malloc(n * 
     
     sizeof(
     
     int));
    assert(p != NULL);

    memcpy(p + m, arr, (n - m) * 
     
     sizeof(
     
     int));
    memcpy(p, arr + n -m , m * 
     
     sizeof(
     
     int));
    memcpy(arr, p, n * 
     
     sizeof(
     
     int));

    free(p);
    p = NULL;

    
     
     return 0;
}


     
     int myStrcmp(
     
     char *p1, 
     
     char*p2)
{
    
     
     int ret = 0;

    
     
     while((*p1 != 
     
     '/0') && (*p2 != 
     
     '/0') && ( *p1 == *p2 ) )
    {
        p1++;
        p2++;
    }

    
     
     if(*p1 == 
     
     '/0')
    {
        ret = -1;
    }
    
     
     else 
     
     if (*p2 == 
     
     '/0')
    {
        ret = 1;
    }
    
     
     else
    {
        ret = (*p1 - *p2) > 0 ? 1 : -1;
    }

    
     
     return ret;
}


     
     int revArr(
     
     int a[], 
     
     int size)
{
    
     
     int tmp = 0, *start = NULL, *end = NULL;

    start = a;
    end = start + size - 1;
    size = size / 2;

    
     
     while(size >= 0)
    {
        tmp = *(start + size);
        *(start + size) = *(end - size);
        *(end - size) = tmp;

        size--;
    }

    
     
     return 0;
}


     
     char *getMonth(
     
     char *month[], 
     
     int which)
{
    assert(which <= 12);
    
     
     return ( *(month + which - 1));
}


     
     int getStr(
     
     char *dest, 
     
     char* src, 
     
     int m)
{
    
     
     int len = 0;

    len = strlen(src) + 1 - m;
    src = src + m - 1;

    memcpy(dest, src, len * 
     
     sizeof(
     
     char));
    
     
     return 0;
}


     
     int removePer3(
     
     int arr[], 
     
     int size)
{
    
     
     int i = 0;

    
     
     for(i = 0; i < size; i++)
    {
        
     
     if(((arr[i]) % 3) == 0)
        {
            arr[i] = 0;
        }
    }

    
     
     return 0;
}


     
     int getMinMax(
     
     int a[], 
     
     int size)
{
    
     
     int i = 0, min = 0, max = 0, tmp = 0;

    min = max = 0;
    
     
     for(i = 0; i < size; i++)
    {
        
     
     if (a[i] <= a[min])
        {
            min = i;
        }

        
     
     if(a[i] >= a[max])
        {
            max = i;
        }
    }

    tmp = a[0];
    a[0] = a[min];
    a[min] = tmp;

    tmp = a[size - 1];
    a[size - 1] = a[max];
    a[max] = tmp;
}


     
     int test_10_1()
{
    
     
     int ite = 0, iRet = 0, arr[5] = {121, 234, 456456, 543, 23};

    iRet = sortPtr(arr, 5);

    assert (23 == arr[0]);
    assert (121 == arr[1]);
    assert (234 == arr[2]);
    assert (543 == arr[3]);
    assert (456456 == arr[4]);

    printf(
     
     "/r/nTest_10_1 Passed!");

    
     
     return 0;
}


     
     int test_10_2()
{
    
     
     int ite = 0, iRet = 0;

    
     
     char *arr[10] = { 
     
     "In the IBM Rational ClearCase environment", /
                      
     
     "An auditable history of source files and software builds is maintained in your organization", /
                      
     
     "The efforts of your team can be coordinated into a definable"
                    };

    iRet = sortStr(arr, 3);

    assert( strcmp(arr[0], 
     
     "An auditable history of source files and software builds is maintained in your organization") == 0 );
    assert( strcmp(arr[1], 
     
     "In the IBM Rational ClearCase environment") == 0);
    assert( strcmp(arr[2], 
     
     "The efforts of your team can be coordinated into a definable") == 0);

    printf(
     
     "/r/nTest_10_2 Passed!");

    
     
     return 0;
}


     
     int test_10_3()
{
    
     
     int ret = 0, a[10] = {7,2,3,9,1,0,7,6,5,0};

    ret = getMinMax(a, 10);
    assert(a[0] == 0);
    assert(a[9] == 9);

    printf(
     
     "/r/nTest_10_3 Passed!");
    
     
     return 0;
}


     
     int test_10_4()
{
    
     
     int ret = 0, arr[9] = {0, 1, 2, 3, 4, 5, 6, 7, 8};

    ret = moveInt(arr, 9, 3);

    assert(6 == arr[0]);
    assert(7 == arr[1]);
    assert(8 == arr[2]);
    assert(0 == arr[3]);
    assert(1 == arr[4]);
    assert(2 == arr[5]);
    assert(3 == arr[6]);
    assert(4 == arr[7]);
    assert(5 == arr[8]);

    printf(
     
     "/r/nTest_10_4 Passed!");

    
     
     return 0;
}


     
     int test_10_5()
{
    
     
     int ret = 0, i = 0, a[12] = {1,2,3,4,5,6,7,8,9,10,11,12};

    ret = removePer3(a, 12);
    assert(a[2] == 0);
    assert(a[5] == 0);
    assert(a[8] == 0);
    assert(a[11] == 0);

    printf(
     
     "/r/nTest_10_5 Passed!");

    
     
     return 0;
}


     
     int test_10_7()
{
    
     
     int ret = 0;
    
     
     char s2[100] = {0}, *s1 = 
     
     "hello world!";

    getStr(s2, s1, 7);

    assert( strcmp(s2, 
     
     "world!") == 0);
    printf(
     
     "/r/nTest_10_7 Passed!");

    
     
     return 0;
}


     
     int test_10_8()
{
    
     
     int ret = 0;

    
     
     char *str = 
     
     "a123xABC ??#$%^ 302tab5876";

    ret = statStr(str);

    
     
     if(ret == 0)
    {
        printf(
     
     "/r/nTest_10_8 Passed!");
    }


    
     
     return 0;
}


     
     int test_10_10()
{
    
     
     int i = 0, j = 0, ret = 0;

    
     
     int arr[5][5] = { /
        {16, 17, 18, 19, 20}, /
        {11, 12, 13, 14, 15}, /
        {1,  2,  3,  4,  5}, /
        {21, 22, 23, 24, 25}, /
        {6,  7,  8,  9,  10}, /
    };

    ret = getMultiArr(arr, 5);

    assert(1 == arr[0][0] );
    assert(2 == arr[0][4] );
    assert(3 == arr[4][0] );
    assert(4 == arr[4][4] );
    assert(25 == arr[2][2] );

    printf(
     
     "/r/nTest_10_10 Passed!");

    
     
     return 0;
}


     
     int test_10_11()
{
    
     
     int ite = 0, iRet = 0;

    
     
     char *arr[10] = { 
     
     "In the", /
                      
     
     "An aud", /
                      
     
     "The ef", /
                      
     
     "Proces", /
                      
     
     "Sets o", /
                      
     
     "Unifie", /
                      
     
     "Out-of", /
                      
     
     "Practi", /
                      
     
     "Ration", /
                      
     
     "Explor"  /
                    };

    iRet = sortStr(arr, 10);

    assert( strcmp(arr[0], 
     
     "An aud") == 0 );
    assert( strcmp(arr[1], 
     
     "Explor") == 0);
    assert( strcmp(arr[2], 
     
     "In the") == 0);
    assert( strcmp(arr[3], 
     
     "Out-of") == 0);
    assert( strcmp(arr[4], 
     
     "Practi") == 0);
    assert( strcmp(arr[5], 
     
     "Proces") == 0);
    assert( strcmp(arr[6], 
     
     "Ration") == 0);
    assert( strcmp(arr[7], 
     
     "Sets o") == 0);
    assert( strcmp(arr[8], 
     
     "The ef") == 0);
    assert( strcmp(arr[9], 
     
     "Unifie") == 0);

    printf(
     
     "/r/nTest_10_11 Passed!");

    
     
     return 0;
}


     
     int test_10_12()
{
    
     
     int ite = 0, iRet = 0;

    
     
     char *arr[10] = { 
     
     "In the IBM Rational ClearCase environment", /
                      
     
     "An auditable history of source files and software builds is maintained in your organization", /
                      
     
     "The efforts of your team can be coordinated into a definable", /
                      
     
     "Process by using one of the following", /
                      
     
     "Sets of Rational ClearCase features", /
                      
     
     "Unified Change Management (UCM),", /
                      
     
     "Out-of-the-box process that supports best", /
                      
     
     "Practices for change management as described in the IBM", /
                      
     
     "Rational Unified Process. Project managers can configure", /
                      
     
     "Explorer. For more information about Rational ClearCase"
                    };

    iRet = sortStr(arr, 10);

    assert( strcmp(arr[0], 
     
     "An auditable history of source files and software builds is maintained in your organization") == 0 );
    assert( strcmp(arr[1], 
     
     "Explorer. For more information about Rational ClearCase") == 0);
    assert( strcmp(arr[2], 
     
     "In the IBM Rational ClearCase environment") == 0);
    assert( strcmp(arr[3], 
     
     "Out-of-the-box process that supports best") == 0);
    assert( strcmp(arr[4], 
     
     "Practices for change management as described in the IBM") == 0);
    assert( strcmp(arr[5], 
     
     "Process by using one of the following") == 0);
    assert( strcmp(arr[6], 
     
     "Rational Unified Process. Project managers can configure") == 0);
    assert( strcmp(arr[7], 
     
     "Sets of Rational ClearCase features") == 0);
    assert( strcmp(arr[8], 
     
     "The efforts of your team can be coordinated into a definable") == 0);
    assert( strcmp(arr[9], 
     
     "Unified Change Management (UCM),") == 0);

    printf(
     
     "/r/nTest_10_12 Passed!");

    
     
     return 0;
}


     
     int test_10_14()
{
    
     
     int ret = 0, a[11] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    ret = revArr(a, 11);
    assert(10 == a[0]);
    assert(9 == a[1]);
    assert(8 == a[2]);
    assert(7 == a[3]);
    assert(6 == a[4]);
    assert(5 == a[5]);
    assert(4 == a[6]);
    assert(3 == a[7]);
    assert(2 == a[8]);
    assert(1 == a[9]);
    assert(0 == a[10]);

    printf(
     
     "/r/nTest_10_14 Passed!");

    
     
     return 0;
}


     
     int test_10_15()
{
    
     
     int ave = 0, ret = 0;
    
     
     int student[4][6] = { /
        {1, 100, 90, 80, 70, 97}, /
        {2,  34, 45, 56, 78, 97}, /
        {3,  76, 34, 68, 84, 12}, /
        {4,  90, 90, 90, 75, 28}  /
    };

    ave = average(student, 1, 4);
    ret = searchStu(student, 4);

    assert(75 == ave);
    assert(2 == ret);

    printf(
     
     "/r/nTest_10_15 Passed!");

    
     
     return 0;
}


     
     int test_10_16()
{
    
     
     int iRet = 0, ite = 0, arr[SIZE] = {0};
    
     
     char *str = 
     
     "a123x456 17960? 302tab5876";

    iRet = extraNum(str, arr);

    assert(123 == arr[0]);
    assert(456 == arr[1]);
    assert(17960 == arr[2]);
    assert(302 == arr[3]);
    assert(5876 == arr[4]);

    printf(
     
     "/r/nTest_10_16 Passed!");
    
     
     return 0;
}


     
     int test_10_17()
{
    
     
     int ret = 0;

    
     
     char *s1 = 
     
     "abcd", *s2 = 
     
     "abCd";
    ret = myStrcmp(s1, s2);
    assert(ret == 1);

    
     
     char *s3 = 
     
     "aBcd", *s4 = 
     
     "abCd";
    ret = myStrcmp(s3, s4);
    assert(ret == -1);

    
     
     char *s5 = 
     
     "abcde", *s6 = 
     
     "abcd";
    ret = myStrcmp(s5, s6);
    assert(ret == 1);

    
     
     char *s7 = 
     
     "abcd", *s8 = 
     
     "abcde";
    ret = myStrcmp(s7, s8);
    assert(ret == -1);

    
     
     char *s9 = 
     
     "abcd", *s10 = 
     
     "abCde";
    ret = myStrcmp(s9, s10);
    assert(ret == 1);

    printf(
     
     "/r/nTest_10_17 Passed!");

    
     
     return 0;
}


     
     int test_10_18()
{
    
     
     int which = 0;
    
     
     char *month[12] = { /
        
     
     "January", /
        
     
     "February", /
        
     
     "March", /
        
     
     "April", /
        
     
     "May", /
        
     
     "June", /
        
     
     "July", /
        
     
     "August", /
        
     
     "September", /
        
     
     "October", /
        
     
     "November", /
        
     
     "December" /
    };

    which = 11;
    assert( strcmp(
     
     "November", getMonth(month, which)) == 0 );

    which = 7;
    assert( strcmp(
     
     "July", getMonth(month, which)) == 0 );

    printf(
     
     "/r/nTest_10_18 Passed!");
    
     
     return 0;

}


     
     int test_10_20()
{
    
     
     int ite = 0, iRet = 0;

    
     
     char *arr[5] = {  
     
     "In the IBM Rational ClearCase environment", /
                      
     
     "An auditable history of source files and software builds is maintained in your organization", /
                      
     
     "The efforts of your team can be coordinated into a definable", /
                      
     
     "Process by using one of the following", /
                      
     
     "Sets of Rational ClearCase features" /
                    };

    iRet = sortStr(arr, 5);

    assert( strcmp(arr[0], 
     
     "An auditable history of source files and software builds is maintained in your organization") == 0 );
    assert( strcmp(arr[1], 
     
     "In the IBM Rational ClearCase environment") == 0);
    assert( strcmp(arr[2], 
     
     "Process by using one of the following") == 0);
    assert( strcmp(arr[3], 
     
     "Sets of Rational ClearCase features") == 0);
    assert( strcmp(arr[4], 
     
     "The efforts of your team can be coordinated into a definable") == 0);

    printf(
     
     "/r/nTest_10_20 Passed!");

    
     
     return 0;
}


     
     int test_10_21()
{
    
     
     int ite = 0, iRet = 0, arr[5] = {121, 234, 456456, 543, 23};

    iRet = sort(arr, 5);

    assert (23 == arr[0]);
    assert (121 == arr[1]);
    assert (234 == arr[2]);
    assert (543 == arr[3]);
    assert (456456 == arr[4]);

    printf(
     
     "/r/nTest_10_21 Passed!");

    
     
     return 0;
}


     
     int testPtr()
{
    
     
     int iRet = 0;


     
     #if 0


     
     #endif
    iRet += test_10_1();

    iRet += test_10_2();

    iRet += test_10_3();

    iRet += test_10_4();

    iRet += test_10_5();

    iRet += test_10_7();

    iRet += test_10_8();

    iRet += test_10_10();

    iRet += test_10_11();

    iRet += test_10_12();

    iRet += test_10_14();

    iRet += test_10_15();

    iRet += test_10_16();

    iRet += test_10_17();

    iRet += test_10_18();

    iRet += test_10_20();

    iRet += test_10_21();

    
     
     return iRet;
}

 

src/main.cc

#include 
  
  
   
   
#include 
   
   
    
    
#include 
    
    
     
     

#include 
     
     "../inc/testFile.h"
#include 
     
     "../inc/testBits.h"
#include 
     
     "../inc/testPtr.h"


     
     int main()
{
    
     
     int iRet = 0;


     
     #if 0

    iRet += testFile();
    assert(iRet == 0);

    iRet += testBits();
    assert(iRet == 0);


     
     #endif

    iRet += testPtr();
    assert(iRet == 0);

    
     
     return 0;
}
六六哥
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
谭浩强c语言程序设计练习习题集
03-27
c语言程序设计谭浩强版的练习题集收录
谭浩强C语言程序设计第五版详细答案
11-10
《谭浩强C语言程序设计第五版》是学习C语言的经典教材，旨在帮助初学者掌握C语言编程的基础知识。本书不仅适用于大一学生，也适合自学者。在本章中，我们将深入探讨C语言程序设计的基本概念和核心知识点。 1.1 程序...
谭浩强C-指针（一）
weixin_34268753的博客
06-03 172
一、地址指针的基本概念计算机中所有数据存放在存储器中，一般将一个字节称为一个内存单元。C语言中整型数据占两字节，即两个内存单元；字符型数据占一个内存单元。为准确访问内存单元，须给内存单元编号，这编号也称为地址。指针就是对地址的描述。数据或函数在内存中都是连续存放的，通过指针指向的首地址可以找到数据或函数。二、变量的指针和指向变量的指针变量1、变量的指针就是存放变量的存储单元的首地址。2、C语言中可...
指针习题5（答案版）
成长之路
12-12 253
题目及楼主的方法 只能说答案就是答案，只能说太漂亮了， 代码 #include&lt;stdio.h&gt; int main() {int i,k,m,n,num[50],*p; printf("\ninput number of person:n="); scanf("%d",&amp;n); p=num; for(i=0;i&lt;n;i++) {*(p+i)=i+1; //以1...
《C语言程序设计》(谭浩强第五版) 第8章 善于利用指针 习题解析与答案
hanru723的博客
04-21 5757
你也可以上程序咖(https://meta.chengxuka.com)，打开大学幕题板块，不但有答案，讲解，还可以在线答题。 本章习题均要求用指针方法处理。 题目1：输入3个整数，按由小到大的顺序输出。 解： 答案代码： #include <stdio.h> int main() { void swap(int *p1, int *p2); int n1, n2, n3; int *p1, *p2, *p3; printf("input three integer n1,n2,n3
谭浩强 C语言程序设计 第四版以及课后习题答案
04-29
总之，《谭浩强 C语言程序设计 第四版》是一本非常适合初学者入门的C语言教程，结合其详尽的课后习题答案，能够帮助读者系统、全面地掌握C语言，为后续的软件开发或者进一步学习其他编程语言打下坚实的基础。...
谭浩强c语言程序设计习题集_谭浩强c语言程序设计习题集_
09-29
《谭浩强C语言程序设计习题集》是学习C语言编程的重要参考资料，它由著名计算机教育专家谭浩强教授编写，旨在帮助初学者深入理解和掌握C语言的基础知识及编程技巧。这本书的内容丰富多样，涵盖了C语言的核心概念、...
免费谭浩强C语言程序设计（第五版）习题答案.zip
最新发布
12-22
《谭浩强C语言程序设计》的习题答案，就像是学习过程中的指南，引导学生逐步解开编程的奥秘，提升编程技能。 总结起来，这个压缩包包含的资源是学习C语言的重要辅助材料，它可以帮助初学者检验自己的学习成果，查漏...
谭浩强C语言(第五版)课后习题答案代码
07-09
《谭浩强C语言(第五版)课后习题答案代码》是一份针对谭浩强编著的《C语言程序设计》第五版教材配套的课后习题解答资源。这份资料集包含了书中所有习题的解答，对于学习C语言的学生来说，是极好的辅助材料，可以帮助...
C语言谭浩强第三版第十章例题及课后题：指针
weixin_42072280的博客
02-06 3709
目录 eg10.3输入a和b两个整数，按先大后小的顺序输出a和b eg10.5输出数组中的全部元素 eg10.7将数组a中n个整数按相反顺序存放 eg10.11用指针变量输出二维数组元素的值 eg10.12输出二维数组任一行任一列元素的值 eg10.13有3个学生各学4门课，计算总平均分数以及第n个学生的成绩 eg10.14在上题基础...
C++程序设计谭浩强 第六章（指针）习题答案（部分有改进）
什么都学不会
06-22 9432
6.1输入3个整数，按由小到大的顺序输出 #include <iostream> using namespace std; int main() {void swap(int *p1,int *p2); int n1,n2,n3; int *p1,*p2,*p3; cout<<"input three integers n1,n2,n3:"; cin>>n1>>n2>>n3; p1=&n1; p2=&n
C语言指针练习题
青布衫白少年的博客
04-07 3393
int Strlen(char *p) //字符串长度 void Str_Copy(const char *str1,char *str2) //字符串赋值 char* Str_Connect(const char *str1,const char *str2) //字符串连接 int strcmp(const ...
输出其中最大值
weixin_30569153的博客
12-22 746
时间限制:1 Sec内存限制:128 MB 提交:676解决:377 [提交][状态][讨论版] 题目描述 编写一个程序，输入a、b、c三个值，输出其中最大值。 输入 一行数组，分别为a b c 输出 a b c其中最大的数 样例输入 10 20 30 样例输出 30#include using namespace std; int ...
C程序设计(第五版)第八章指针习题答案(手写系统版)
BraveAsta的博客
05-06 2438
@[T C程序设计(第五版)指针习题答案(自己写的) 以下代码均经过上机测试(编译器为Visual Studio2017) 欢迎相互交流学习！！ // An highlighted block var foo = 'bar'; ...
C语言程序设计第五版谭浩强著 第8章291-292指针系列
qq_42313319的博客
08-06 2万+
1.输入3个整数，按由小到大的顺序输出。 #include&lt;stdio.h&gt; main() { int a,b,c,*p1,*p2,*p3; p1=&amp;a;p2=&amp;b;p3=&amp;c; printf("请输入三位整数：\n"); scanf("%d%d%d",p1,p2,p3); int *p; if(*p1&gt...
C语言程序设计 第五版 谭浩强著 80-82课后习题以及答案
热门推荐
qq_42313319的博客
07-31 4万+
1.假如我国国民生产总值的年增长率为7%，计算10年后我国国民生产总值于现在相比增长多少百分比。计算公式为 p=（1+r）^2, r为年增长率，n为年数，p为于现在相比比的倍数。 #include&lt;stdio.h&gt; #include&lt;math.h&gt;//pow为调用数学函数需要加math.h头文件 int main() { int n; float p...
C语言程序设计-谭浩强第五版习题【答案解析】2022.5.10
@MIKE小助手
05-10 2万+
目录第1章 C语言概述第2章 数据类型及其运算第3章 顺序结构程序设计第4章 选择结构程序设计第5章 循环结构程序设计第7章 函数与指针第8章 结构体与共用体第9章 文件第10章 图形与动画 习题解析与答案 第1章 C语言概述 一． 简答题 1．概述C语言的主要特点。 【解答】 （1）语言简洁、紧凑，使用方便、灵活。 （2）数据类型丰富，表达能力强。 （3）运算符多样。C语言中的运算符包含的范围非常广泛。 （4）具有结构化的控制语句。如if…else语句、while语句、do while语句、switc
谭浩强c语言程序设计习题集.doc
11-29
《谭浩强C语言程序设计习题集》是一本以C语言为主题的习题集。该习题集共分为12个章节，每个章节都包含了选择题、填空题和编程题。 第一章是C语言概述，主要介绍了一个C程序的执行过程。其中1.1节讨论了一个C程序的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值