顺便讲一句，没必要“a[N]=0”，因为你马上就要给a数组赋值了。你给每个位置上赋的0又要被覆盖掉。。不是多此一举吗？

首先，这个题目本身就不是很严谨，那个输入的时候用空格隔开的要求，你怎么实现。总之，这个题目如果要较真，用数组肯定是不行的。

[此贴子已经被作者于2016-2-21 10:52编辑过]

版主说的是对的，数组只能在建立的时候确定大小，无法在后期扩充。
如果要能扩充的，就要用动态内存分配malloc（sizeof（int）*n）。
我也没写过这种程序，只是知道有这么个东西。

int main()
{  

    int n,i;
    scanf("%d",&n);
    int a[n]={0};
    for(i=0;i<n;i++)  scanf("%d",&a[i]);
    A(a,n);
    return 0;
}  

我的主函数是这样的，首先接收一个数，这个数传递给n，所以n就有了一个确定的数值，可以用来创建数组了。
并不是直接用没有数值的变量n来创建数组，而且我也再次试验过了，这样是可以的。
如：

#include<stdio.h>
int main()
{
    int n,i;
    scanf("%d",&n);
    int a[n];
    for(i=0;i<n;i++)     scanf("%d",&a[i]);
    for(i=0;i<n;i++)    printf("%d ",a[i]);
    return 0;
}

输入：
4
1 2 3 4
输出：
1 2 3 4

第一次输入的数赋值给了n，所以n作为一个确定的数可以用来创建数组。

我将数组a赋初值为0，是因为之前不初始化，导致容易数据出错。
特别是处理数组内元素都为正整数且元素数量未知时，喜欢用for(i=0;a[i]!=0;i++)来判断，结果有时候没有初始化数组，导致判断出错。
所以我现在碰到数组都初始化为0.

你理解错了，但我不知道你怎么通过的。所谓常量是不可以再更改的量，你的n是确定了，但在后面可以随时赋值变更，但定义Const int n=10，后面再做n=1的操作是不行的。

如你所说，可以用链表实现，下面我写的代码测试题目中的样例测试通过。

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

struct num
{
    int data;
    struct num *next;
};

struct num *create(int n);
void display(struct num *head);
void destory(struct num *head);
void calAnddisplay(struct num *head);

int main()
{
    struct num *head;
    int n;
    scanf("%d",&n);

    head=create(n);
    //display(head);
    calAnddisplay(head);

    destory(head);

    return 0;
}

struct num *create(int n)
{
    struct num *head,*p,*q;
    head=(struct num *)malloc(sizeof(struct num));
    p=(struct num *)malloc(sizeof(struct num));
    head->next=p;

    scanf("%d",&head->data);
    int i;
    for(i=1;i<n;i++)
    {
        scanf("%d",&p->data);
        q=(struct num *)malloc(sizeof(struct num));
        p->next=q;
        p=q;

        if(i==(n-1))
        {
            p->next=NULL;
        }
    }

    return head;
}

void display(struct num *head)
{
    struct num *p=head;
    do
    {
        printf("%d ",p->data);
        p=p->next;
    }while(p->next!=NULL);
}

void destory(struct num *head)
{
    struct num *p=head,*q;
    do
    {
        q=p->next;
        free(p);
        p=q;
    }while(p->next!=NULL);
    free(p);
}

void calAnddisplay(struct num *head)
{
    struct num *p=head;

    //A1
    int A1=0;
    do
    {
        if(p->data%10==0)
        {
            A1+=p->data;
        }
        p=p->next;
    }while(p->next!=NULL);

    //A2
    p=head;
    int A2=0,countA2=0;
    do
    {
        if(p->data%5==1)
        {
            countA2++;
            if(countA2%2==0)
            {
                A2-=p->data;
            }
            else
            {
                A2+=p->data;
            }
        }
        p=p->next;
    }while(p->next!=NULL);

    //A3
    p=head;
    int A3=0;
    do
    {
        if(p->data%5==2)
        {
            A3++;
        }
        p=p->next;
    }while(p->next!=NULL);

    //A4
    p=head;
    float A4=0,sum=0;
    int countA4=0;
    do
    {
        if(p->data%5==3)
        {
            countA4++;
            sum+=p->data;
        }
        p=p->next;
    }while(p->next!=NULL);
    if(countA4!=0)
    {
        A4=sum/countA4;
    }

    //A5
    p=head;
    int A5=0,flag=0,tmp=0;
    do
    {
        if(p->data%5==4)
        {
            if(flag==0)
            {
                A5=p->data;
                flag=1;
            }
            else
            {
                tmp=p->data;
                if(tmp>A5)
                {
                    A5=tmp;
                }
            }
        }
        p=p->next;
    }while(p->next!=NULL);

    //output
    if(A1==0)
    {
        printf("N ");
    }
    else
    {
        printf("%d ",A1);
    }

    if(countA2==0)
    {
        printf("N ");
    }
    else
    {
        printf("%d ",A2);
    }

    if(A3==0)
    {
        printf("N ");
    }
    else
    {
        printf("%d ",A3);
    }

    if(countA4==0)
    {
        printf("N ");
    }
    else
    {
        printf("%.1f ",A4);
    }

    if(A5==0)
    {
        printf("N");
    }
    else
    {
        printf("%d",A5);
    }
}

根据题意，根本不需要用数组即可解决。

  
以变量分配数组有些编译器是支持的，不支持的也很多，所以尽量不要用，楼主的代码中这一句肯定有问题，  if(!M[i]) printf("N");
交错正负求和有为0的可能，如何判断求和为0与没有此类数是个问题，有必要对计数值k做一判断。
另外交错求和在第一此遍历时就可求出，
     M[1]+=pow((-1),i)*b[i];
把上句中的i换为k就行了
这样数组b可以省略，同样，数组a也是可以不用，每输入一个数字直接计算，然后舍弃，没有保存的必要，另外，输出语句建议不用循环，因为输出条件各异，很难用一个语句输出。

发现新大陆啊！！

我一直以为int a[n]这种事是在程序编译的时候就把数组空间分配好了的。。。

今天亲测，整个颠覆世界观了。。。
以前我的代码都是这样的

#include "stdio.h"
#define N 10001

int main(void)

 {
     int a[N];
     int n;
     scanf("%d",&n);
     for(int i=0;i<n;i++)
     ...
     
     return 0;

 }

学了malloc/calloc的时候我还激动了一把这是动态分配的节奏啊！所以我的代码全都是这样的

#include "stdio.h"
int main(void)

 {
     
     int n;
     scanf("%d",&n);
     int*a=(int*)malloc(sizeof(int)*n);
     
     
     for(int i=0;i<n;i++)
     ...
     
     return 0;

 }