PTA基础编程题目集(函数题13)

1、简单输出整数

本题要求实现一个函数，对给定的正整数N，打印从1到N的全部正整数。

#include <stdio.h>
void PrintN ( int N );
int main ()
{
    int N;
    scanf("%d", &N);
    PrintN( N );
    return 0;
}
void PrintN ( int N ){
    for(int i=1; i<=N; ++i)
        printf("%d
",i);
}

2、多项式求值

本题要求实现一个函数，计算阶数为n，系数为a[0] ... a[n]的多项式f(x)=∑​i=0​n​​(a[i]×x​i​​) 在x点的值。

#include <stdio.h>

#define MAXN 10

double f( int n, double a[], double x );

int main()
{
    int n, i;
    double a[MAXN], x;
    
    scanf("%d %lf", &n, &x);
    for ( i=0; i<=n; i++ )
        scanf(“%lf”, &a[i]);
    printf("%.1f
", f(n, a, x));
    return 0;
}
double f( int n, double a[], double x ){
    double sum = 0;
    for(int i=0; i<=n; ++i){
        sum += a[i]*pow(x,i);
    }
    return sum;
}

3、简单求和

本题要求实现一个函数，求给定的N个整数的和。

#include <stdio.h>

#define MAXN 10

int Sum ( int List[], int N );

int main ()
{
    int List[MAXN], N, i;

    scanf("%d", &N);
    for ( i=0; i<N; i++ )
        scanf("%d", &List[i]);
    printf("%d
", Sum(List, N));

    return 0;
}
int Sum ( int List[], int N ){
    int sum=0;
    for(int i=0; i<N; ++i)
        sum += List[i];
    return sum;
}

4、求自定类型元素的平均

本题要求实现一个函数，求N个集合元素S[]的平均值，其中集合元素的类型为自定义的ElementType。

#include <stdio.h>

#define MAXN 10
typedef float ElementType;

ElementType Average( ElementType S[], int N );

int main ()
{
    ElementType S[MAXN];
    int N, i;

    scanf("%d", &N);
    for ( i=0; i<N; i++ )
        scanf("%f", &S[i]);
    printf("%.2f
", Average(S, N));

    return 0;
}
ElementType Average( ElementType S[], int N ){
    ElementType sum = 0;
    for(int i=0; i<N; ++i)
        sum +=S[i];
    return sum/N;
}

5、求自定类型元素的最大值

本题要求实现一个函数，求N个集合元素S[]中的最大值，其中集合元素的类型为自定义的ElementType。

#include <stdio.h>

#define MAXN 10
typedef float ElementType;

ElementType Max( ElementType S[], int N );

int main ()
{
    ElementType S[MAXN];
    int N, i;

    scanf("%d", &N);
    for ( i=0; i<N; i++ )
        scanf("%f", &S[i]);
    printf("%.2f
", Max(S, N));

    return 0;
}
ElementType Max( ElementType S[], int N ){
    ElementType max = S[0];
    for(int i=1; i<N; ++i)
        if(max < S[i])
            max = S[i];
    return max;
}

6、求单链表结点的阶乘和

本题要求实现一个函数，求单链表L结点的阶乘和。这里默认所有结点的值非负，且题目保证结果在int范围内。

#include <stdio.h>
#include <stdlib.h>

typedef struct Node *PtrToNode;
struct Node {
    int Data; /* 存储结点数据 */
    PtrToNode Next; /* 指向下一个结点的指针 */
};
typedef PtrToNode List; /* 定义单链表类型 */

int FactorialSum( List L );

int main()
{
    int N, i;
    List L, p;

    scanf("%d", &N);
    L = NULL;
    for ( i=0; i<N; i++ ) {
        p = (List)malloc(sizeof(struct Node));
        scanf("%d", &p->Data);
        p->Next = L;  L = p;
    }
    printf("%d
", FactorialSum(L));

    return 0;
}
int FactorialSum( List L ){
    int sum = 0;
    while(L)
    { 
        int fac=1;
        for(int i=1; i<=L->Data; ++i) fac *= i;
        sum += fac;
        L = L->Next;
    }
    return sum;
}

7、 统计某类完全平方数 

本题要求实现一个函数，判断任一给定整数N是否满足条件：它是完全平方数，又至少有两位数字相同，如144、676等。

#include <stdio.h>
#include <math.h>

int IsTheNumber ( const int N );

int main()
{
    int n1, n2, i, cnt;
    
    scanf("%d %d", &n1, &n2);
    cnt = 0;
    for ( i=n1; i<=n2; i++ ) {
        if ( IsTheNumber(i) )
            cnt++;
    }
    printf("cnt = %d
", cnt);

    return 0;
}
int IsTheNumber ( const int N ){
    int i,ret=0;
    for (i = 0; i <= N / 2; i++) 
        if (i*i == N){
            ret++;
            break;
        }
    int key[10] = {0};
    int t = N;
    while(t)
    {
        key[t%10]++;
        t /= 10;
    }
    for(int j=0; j<=9; ++j)
        if(key[j]>=2){
            ret++;
            break;
        }        
    return ret == 2;
}

8、简单阶乘计算

本题要求实现一个计算非负整数阶乘的简单函数。

#include <stdio.h>

int Factorial( const int N );

int main()
{
    int N, NF;
    
    scanf("%d", &N);
    NF = Factorial(N);
    if (NF)  printf("%d! = %d
", N, NF);
    else printf("Invalid input
");

    return 0;
}
int Factorial( const int N ){
    if(N<0) return 0;
    int fac=1;
    for(int i=1; i<=N; ++i)
        fac *=i;
    return fac;
}

9、统计个位数字

本题要求实现一个函数，可统计任一整数中某个位数出现的次数。例如-21252中，2出现了3次，则该函数应该返回3。

#include <stdio.h>

int Count_Digit ( const int N, const int D );

int main()
{
    int N, D;
    
    scanf("%d %d", &N, &D);
    printf("%d
", Count_Digit(N, D));
    return 0;
}
int Count_Digit ( const int N, const int D ){
    if(!N&&!D) return 1;
    int count=0,t = N;
    if(t<0) t = -t;
    while(t)
    {
        if(t%10==D)
            count++;
        t /= 10;
    }
    return count;
}

10、阶乘计算升级版

本题要求实现一个打印非负整数阶乘的函数。

#include <stdio.h>

void Print_Factorial ( const int N );

int main()
{
    int N;
    
    scanf("%d", &N);
    Print_Factorial(N);
    return 0;
}
void Print_Factorial ( const int N ){
    if(N<0){
        printf("Invalid input");
        return;
    }
    int a[100000] = {0,1},index=1;
    for(int n = 1; n<=N; ++n)
    {
        int carry = 0;/**< 进位数 */
        for(int j=1; j<=index; j++)/**< 乘数与被乘数，从第一位开始，逐位相乘 */
        {
            int temp = n*a[j] + carry;/**< 乘积 + 进位数 */
            a[j] = temp%10;/**< 乘积 + 进位数,保留个位 */
            carry = temp/10;/**< 进位 */
        }
        while(carry > 0)/**< 进位数大于0，最高位++，最高位保留进位数个位 */
        {
            a[++index] = carry%10;
            carry /= 10;
        }
    }
    for(int i=index; i>0;--i)
        printf("%d",a[i]);
}

11、求自定类型元素序列的中位数

本题要求实现一个函数，求N个集合元素A[]的中位数，即序列中第⌊N/2+1⌋大的元素。其中集合元素的类型为自定义的ElementType

#include <stdio.h>

#define MAXN 10
typedef float ElementType;

ElementType Median( ElementType A[], int N );

int main ()
{
    ElementType A[MAXN];
    int N, i;

    scanf("%d", &N);
    for ( i=0; i<N; i++ )
        scanf("%f", &A[i]);
    printf("%.2f
", Median(A, N));

    return 0;
}
void HeapAdjust(ElementType array[], int i, int nlength)
{    
    ElementType nTemp;
    for (int nChild; 2 * i + 1 < nlength; i = nChild)
    {
        nChild = 2 * i + 1;
        //得到子节点中较大的节点
        if (nChild < nlength - 1 && array[nChild + 1] > array[nChild])
            nChild++;
        //如果较大的子节点大于父节点那么把较大的子节点往上移动，替换它的父节点
        if (array[i] < array[nChild])
        {
            nTemp = array[i];
            array[i] = array[nChild];
            array[nChild] = nTemp;
        }
        else
            break;
    }
}
void Heapsort(ElementType array[], int length)
{
    int i;//调整序列的前半部分元素，调整完之后第一个元素是序列的最大元素
    ElementType temp;
    for (i = length/2 - 1; i >= 0; i--)
        HeapAdjust(array, i, length);
    //从最后一个元素开始对序列进行调整，不断的缩小调整的范围直到第一个元素
    for (i = length - 1; i >= 0; i--)
    {
        //把第一个元素和当前的最后一个元素交换
        //保证当前的最后一个位置的元素都是现在这个序列中最大的
        temp = array[0];
        array[0] = array[i];
        array[i] = temp;
        //不断缩小调整heap的范围，每一次调整完毕保证第一个元素是当前序列的最大值
        HeapAdjust(array, 0, i);
    }
}
ElementType Median(ElementType A[], int N)
{
    Heapsort(A, N);
    return A[N / 2];
}

12、判断奇偶性

本题要求实现判断给定整数奇偶性的函数。

#include <stdio.h>

int even( int n );

int main()
{    
    int n;

    scanf("%d", &n);
    if (even(n))
        printf("%d is even.
", n);
    else
        printf("%d is odd.
", n);

    return 0;
}
int even( int n ){
    if(n%2)
        return 0;
    return 1;
}

13、折半查找 

给一个严格递增数列，函数int Search_Bin(SSTable T, KeyType k)用来二分地查找k在数列中的位置。

#include <iostream>
using namespace std;

#define MAXSIZE 50
typedef int KeyType;

typedef  struct                     
{ 
    KeyType  key;                                             
} ElemType;  

typedef  struct
{ 
    ElemType  *R; 
    int  length;
} SSTable;                      

void  Create(SSTable &T)
{ 
    int i;
    T.R=new ElemType[MAXSIZE+1];
    cin>>T.length;
    for(i=1;i<=T.length;i++)
        cin>>T.R[i].key;   
}

int  Search_Bin(SSTable T, KeyType k);

int main () 
{  
    SSTable T;  KeyType k;
    Create(T);
    cin>>k;
    int pos=Search_Bin(T,k);
    if(pos==0) cout<<"NOT FOUND"<<endl;
    else cout<<pos<<endl;
    return 0;
}
int  Search_Bin(SSTable T, KeyType k){
    int left, right, mid, NotFound=0;
    left = 1; /*初始左边界*/
    right = T.length; /*初始右边界*/
    while ( left <= right )
    {        
        mid = (left+right)/2; /*计算中间元素坐标*/
        if( k < T.R[mid].key) right = mid-1; /*调整右边界*/
        else if( k > T.R[mid].key) left = mid+1; /*调整左边界*/
        else return mid; /*查找成功，返回数据元素的下标*/
    }
    return NotFound; /*查找不成功，返回-1*/
}