Makefile

# build an executable named array_sort from array_sort.c
  
all: array_sort.c
  gcc -ansi -g -Wall -o array_sort array_sort.c

run: 
	./array_sort
     

shairon-array-sort.c

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

#define MAX_NUM 65536

int to_value(char *original_string);
int compare(const void* a, const void* b);
void exit_if_file_doest_exist( FILE *file );
void check_array_size( int array_size );
void check_array_size_versus_read(int array_size, int read);
void print_array(int * array, int size);

int main(int argc, char *argv[]){

  FILE * f = fopen( argv[1], "r" );
  char * line = NULL;
  size_t len = 0;
  ssize_t read;
  int array_size;
  int * array;
  int read_line = 0;
  int * original;

  exit_if_file_doest_exist(f);
  
  getline(&line, &len, f);
  array_size = atoi(line);
  
  check_array_size(array_size);
  array = malloc(array_size * sizeof(int));

  while ((read = getline(&line, &len, f)) != -1) {
    if (read_line-1 > array_size){
      fprintf(stderr,"Array maior que o limite permitido %d\n",MAX_NUM );
      exit(1);
    }
    array[read_line] = to_value(line);
    read_line++;
  }

  check_array_size_versus_read(array_size, read_line);

  original = malloc(array_size * sizeof(int));
  memcpy(original, array, array_size * sizeof(int));

  qsort(array, array_size, sizeof(int), compare);
  print_array(original,array_size);
  print_array(array,array_size);
  
  free(array);
  free(original);
  fclose(f);
  
  exit(0);
}

int to_value(char *original_string){
  
  int copy_len = 0;
  char * string;
  int value = 0;
  char *converted;

  if (original_string[strlen(original_string)-1] == '\n'){
    copy_len = 1;
  }
  
  string = malloc(strlen(original_string)-copy_len);
  strncpy(string,original_string,strlen(original_string)-copy_len);
  
  value = atoi(string);
  converted = malloc(strlen(string));
    
  sprintf(converted, "%d", value);
  
  if(value < 0){
    fprintf(stderr,"Conteudo invalido do arquivo\n");
    exit(1);
  }

  if (strncmp(string,converted, strlen(string)) == 0){
    return value;
  } else {
    fprintf(stderr,"Conteudo invalido do arquivo\n");
    exit(1);
  }
}

int compare(const void* a, const void* b){
  int va = *(const int*) a;
  int vb = *(const int*) b;
  return (va > vb) - (va < vb);
}

void exit_if_file_doest_exist( FILE *file ){
  if (file == NULL){
    fprintf(stderr,"Arquivo nao existe\n");
    exit(1);
  }  
}

void check_array_size( int array_size ){
  if (array_size > MAX_NUM || array_size < 1){
    fprintf(stderr,"Tamanho invalido do vetor\n");
    exit(1);
  }
}

void check_array_size_versus_read(int array_size, int read){
  if (array_size != read ){
    fprintf(stderr,"Numero de elementos divergente do informado\n" );
    exit(1);
  }
}

void print_array(int * array, int size){
  int i=0;
  for(i=0; i < size; i++){
    printf("%d", array[i]);
    printf("%s", (size != i+1) ? "," : "\n");
  }
}