ecneuqeStcefreP

C code

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

//2 global parameters. M_suppose for the biggest possible M, m for the smallest element
long long M_suppose;
int m;

void Swap(int A[] ,int a, int b){
//swap two element in an array based on their index
    int Tmp = A[a];
    A[a] = A[b];
    A[b] = Tmp;
    return;
}

void InsertingSort(int A[], int N){
//btw the time complexity is N^2
    int Tmp;
    int P, j;
    for(P=1; P<N; P++){
        Tmp = A[P];
        for(j=P; j>0&&A[j-1]>Tmp; j--){
        //important 1.cmpare with Tmp; start just from P
        //remember j is the place to fit in
            A[j] = A[j-1];  
        }
        A[j] = Tmp;
    }
}

int Median3(int A[], int left, int right){
    int mid = (left+right)/2;
    if(A[left]>A[mid])
        Swap(A, left, mid);
    if(A[left]>A[right])
        Swap(A, left, right);
    if(A[mid]>A[right])
        Swap(A, mid, right);
    Swap(A, mid, right-1);
    //the right item > mid, so hide mid just bufore right, instead of at right
    return A[right-1];
    //simple while complex  
}

void Qsort(int A[], int left, int right){
    //Not as easy as first sight
    if(right - left >10){
        int mid = Median3(A, left, right);
        int i=left;
        int j = right-1;

        for(;;){
            while(A[++i]<mid){};
            //actually i start from left+1, because after running Median3 the item at left must<mid
            while(A[--j]>mid){};
            //j start from right-2
            if(i>j)
                break;
            Swap(A, i, j);
        }
        Swap(A, i, right-1);
        Qsort(A, left, i-1);
        Qsort(A, i+1, right);
    }
    else
        InsertingSort(A+left,  right-left+1);
}

void QuickSort(int A[], int N){
//driver for Qsort
    Qsort(A, 0, N-1);
} 

int BS2(int A[], int N){
    int left=0, right=N;
    int center;
    while(left!=right-1&&left!=right){
        center = (left+right)/2;
        if(M_suppose>=A[center])
            left = center;
        else 
            right = center;
    }
    if(A[left]>=M_suppose)
        return left-1;
    else if(A[right]>=M_suppose)
        return left;
    else
        return right;

}

int BinarySearch2(int A[], int N){
    int Position = BS2(A, N-1);
    while(A[Position+1]==A[Position])
        Position++;
    return Position;
}

int main(){
    int N, p;
    scanf("%d%d", &N, &p);
    int * A = (int*)malloc(N*sizeof(int));  
    for(int i=0; i<N; i++)
        scanf("%d", &A[i]);
    //intitiallizing    

    QuickSort(A, N);
    //sort the array, 

    int MaxNum = 0;
    int length;
    for(int i=0; i<N; i++){
        m = A[i];
        M_suppose = m*p;
        length = BinarySearch2(A, N)-i+1;

        if(length<0)
            continue;
        if(length>MaxNum)
            MaxNum = length;
    }
    printf("%d", MaxNum);
}