#include <iostream>
#include <algorithm>

bool cmp(int* s1, int* s2){ return *s1 < *s2; };

template <typename T, typename N, typename C>

 N func(T s, N m, N n, C cm){
  T mas[n], tmp;
  N p, sum, count=0;
  
 while( m-- > 0){
  p=0; sum=0; 
 while( p < n){ tmp=s+m+p; sum+=*tmp; mas[p++]=tmp; };
  --p;
  std::sort(mas, mas+n, cm );

 if( **(mas+p) > sum/2 ) ++count;

 };

 return count;

 };

int main()
{
int s[50];
int i=50;
while(i>0){ s[--i]=random(); };

std::cout<<"Res "<<func(s, 5, 10, cmp)<<std::endl; 
}

struct randm{
 randm(): s(std::chrono::system_clock::now().time_since_epoch().count()), gn(s){};
 unsigned s;
  std::mt19937 gn;
 long unsigned operator()(){ return gn(); }; 
 };

int main(){

 int s[50];
int i=50;
randm rndm;

while(i>0){ s[--i]=rndm(); };

std::cout<<"Res "<<func(s, 5, 10, cmp)<<std::endl; };

#include <random>
#include <chrono>

 #include <iostream>
#include <algorithm>
#include <random>
#include <chrono>
bool cmp(int* s1, int* s2){ return *s1 < *s2; };
template <typename T, typename C>
 size_t func(T s, size_t m, size_t n, C cm){
  T mas[n], tmp;
  size_t p, count=0, sum;
  
 while( m-- > 0){
  p=0; sum=0; 
 while( p < n){ tmp=s+m+p; sum+=*tmp; mas[p++]=tmp; };
  
  std::sort(mas, mas+n, cm );
  sum/=2;
 while(p-- > 0){ 
      
 if( **(mas+p) < sum ) break;
  
 ++count;
     }
   };

 return count;

 };

 struct randm{
 randm(): s(std::chrono::system_clock::now().time_since_epoch().count()), gn(s){};
 unsigned s;
  std::mt19937 gn;
 long unsigned operator()(){ return gn(); }; 
 };

int main(int c, char** arg){
if(c<3) return -1;
 size_t n=std::stoi(arg[1]), m=std::stoi(arg[2]), i=n*m;
  int *s;
try{
  s=new int[i]; }
catch(std::bad_alloc& c){ return -1; };
randm rnd;
while(i>0){ s[--i]=rnd(); };

std::cout<<"Res "<<func(s, n, m, cmp)<<std::endl; 
delete [] s;};

struct node{
   struct node * prev;
   void* ptr;
  struct node* next;

 }; 

struct dequeue{

  struct node* front;
  struct node* back;

  };

typedef struct dequeue ptq;
typedef struct node ndq;

ndq* push_front(ptq*, void*);
ndq* push_back(ptq*, void*);
void* pop_front(ptq*);
void* pop_back(ptq*);
void dequeue_init(ptq*);
void dequeue_erase(ptq*);
void dequeue_clear(ptq*);
ndq* front_iterator(ptq*, ndq*);
ndq* back_iterator(ptq*, ndq*);

ndq*  push_front(ptq* q, void* ptr){

 ndq* p=malloc(sizeof(ndq)); if(!p) return NULL; 
                                                         
 if(!q->front) { q->front=q->back=p;}else{  p->next=q->front;  q->front->prev=p; };
 p->ptr=ptr;
 q->front=p; p->prev=NULL; 
 return p; 

  };

ndq* push_back(ptq* q, void* ptr){  
  
 ndq *tmp, *p=malloc(sizeof(ndq)); if(!p) return NULL; 
                                                         
if( ! q->back ){ q->front=q->back=p; }else{ p->prev=q->back; q->back->next=p; };
 p->ptr=ptr;
  q->back=p; p->next=NULL; 
 return p; 

 };

void* pop_front(ptq* q){  
 
if(! q->front ) return NULL; void* ptr; 
                                                             
 ndq* p=q->front; q->front=q->front->next; 
  
if(q->front) q->front->prev=NULL; 
                                                                
 ptr=p->ptr; free( p ); 
 return ptr; 
 
}; 
 
void* pop_back(ptq* q){  
 if(! q->back ) return NULL; 
 void* ptr; 
                                                  
          
  ndq* p=q->back; q->back=q->back->prev;
 if(q->back) q->back->next=NULL; 
                                                               
  ptr=p->ptr; free( p ); 

 return ptr; 
 
  }; 

ndq*  front_iterator(ptq* q, ndq* p){  ndq* ptr=p; if( !ptr ) ptr=q->back;  return ptr->prev; };

ndq*  back_iterator(ptq* q, ndq* p){  ndq* ptr=p; if( !ptr ) ptr=q->front;  return ptr->next; };
 

void dequeue_init(ptq* q){ q->front=q->back=NULL;  };
 
void dequeue_clear(ptq* q){ 
ndq* p=q->front; 
 if( ! p )  return; 
                                                                          
  while( p ) {  free(p->prev); p=p->next;  };
                                                                                              
  q->front=NULL; q->back=NULL;

  };

void dequeue_erase(ptq* q){ 
ndq* p=q->front; 
 if( ! p ) return; 
                                                                          
  while( p ) { free( p->ptr); free(p->prev); p=p->next;  };
                                                                                              
  q->front=NULL; q->back=NULL;

  };

.....................................................................................................................................................

struct dequeue dqt;
dequeue_init(&dqt);

...............................................................................................................................


fgets(tek->FIO.Otch, Lmax, f);
            tek->FIO.Otch[strlen(tek->FIO.Otch)-1]='\0';
            
            CLR;
 
            fscanf(f,"%d %d %d %d /n",&tek->uspevaemost.B[0],&tek->uspevaemost.B[1],&tek->uspevaemost.B[2],&tek->uspevaemost.B[3]);
 
            puts("File schitan vec");
 
          if (! insert_front(&dqt, (struct Student*) tek)) error_hand();
            }
        }

struct node ndq=NULL;
int count=0;
while((ndq=back_iterator(&dqt, &ndq)!=NULL){ printf(" Group Num %d  Is %s\n", ndq->ptr->Group); };