question du jour 2 - le retour

[Booster2ooo]

Node.JS

/!\ remplacez le path C:/Users/Booster/

Code JAVASCRIPT :


var fs = require('fs');
var os = require('os');
fs.readFile('C:/Users/Booster/inputFile.txt', 'ascii', function(err, data) {
        if (err) {
            return console.log(err);
        }
        var EOL = os.EOL
          , groups = data.split(EOL+EOL)
          , result = []
          ;
        for(var i = 0,c=groups.length;i<c;i++) {
            var values = groups[i].split(EOL);
            values = values.sort(function(a,b) {
                return a - b;
            });
            result = result.concat(values);
            result.push(EOL);
        }
        console.log(result.join(EOL));
        return;
    }
);
 

---

Autre sample C#, sans l'utilisation de la lib LINQ

Code CSHARP :


using System;
using System.Text;
using System.IO;
using System.Collections;

namespace NPNQDJ
{
    class Program
    {
        public class StringAsIntComparer : IComparer
        {
            public int Compare(object l, object r)
            {
                return Int32.Parse((string)l).CompareTo(Int32.Parse((string)r));
            }
        }

        static void Main()
        {
            string fileName = "inputFile.txt";
            string fullPath = AppDomain.CurrentDomain.BaseDirectory + fileName;
            if (File.Exists(fullPath))
            {
                string fileContent = File.ReadAllText(fullPath, Encoding.UTF8);
                string[] groups = fileContent.Split(new string[] { System.Environment.NewLine + System.Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
                foreach (string group in groups)
                {
                    string[] values = group.Split(new string[] { System.Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
                    Array.Sort(values, new StringAsIntComparer());
                    foreach (var val in values)
                    {
                        Console.WriteLine(val);
                    }
                    Console.WriteLine();
                }
            }
        }
    }
}
 

[balis]

Désolé pour le retard , je n'ai pas eu le temps et une petite flemmingite
Les paragraphes sont séparés par une étoile et non des sauts de lignes et ce termine par étoile. tu peux modifier ça facilement dans le if.

Code :

12
4
*
12
45
*

Code C :

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

static int compare ( void const *a , void const *b){
    /* on cast */
    int const *aa=a;
    int const *bb=b;
    return *aa-*bb;
}

void ecrit(int *tab, int taille_n){
    FILE *ecriture;
    int cpt;
    ecriture=fopen("output.tralala","a");
    /* ou utilises un scanf */
    for( cpt=0; cpt < taille_n ; ++cpt)
        fprintf(ecriture,"%d\n",tab[cpt]);
   
    fprintf(ecriture,"\n");
    fclose(ecriture);
}

void range_paragraphe(char *nom_fichier){
    FILE *lecture;
    int *tab=(int*)malloc(sizeof(int));
    int *tmp=NULL;
    char recup[100];
    int rec=0, i=0 , cpt=0;

    tab[0]=0;

    lecture=fopen(nom_fichier,"r");

    if( lecture == NULL){
        printf("Fichier inexistant \n");
        exit(EXIT_FAILURE);
    }

   while( fscanf(lecture,"%s\n",recup) > 0){        
      sscanf(recup,"%d",&rec);
        if( strcmp(recup,"*") == 0 ){
            qsort(tab, i, sizeof(int), compare);
            ecrit(tab,i);
          free(tab);
          tab=NULL;
          tab=(int *)malloc(sizeof(int));
          i=0;
      }
      else{
      /* on met dans le tableau */
      if( i != 0){
          tab= realloc(tab, (i+1) * sizeof(int));
      }
      tab[i]=rec;
      ++i;
      }
   }
    free(tab);
    fclose(lecture);
}

int main(void){
    /* remplace le ici ou utilise le scanf */
    char file[100]="liste.tralalala";

    printf("Nom du fichier ==> ");
    /*scanf("%s",file);*/
    range_paragraphe(file);
    printf("Done \n");

    return 0;
}

[Dobry]

Bon on s'est rendu compte avec gruik que le solution ruby n'allait définitivement pas, en fait IO.readlines charge tout le fichier en mémoire, et voici donc une solution alternative (écrite par gruik, un peu modifiée par mes soins), qui permet au moins de charger le gros fichier, cependant le temps d'execution reste assez élevé (13-14s si je me souviens bien).

Code RUBY :


#!/usr/bin/env ruby
arr = []
File.open(ARGV[0]).each_line do |line|
        if line.length != 1
                arr << line.to_i
        else
                if arr.length != 0
                        puts arr.sort
                        puts
                        arr.clear
                end
        end
end
 

[Booster2ooo]

Encore un, PHP:

Note: le file_get_contents est peu être un peu violent, ça peut être remplacé par du fopen

Code PHP :


<?php
        $EOL = PHP_EOL;
        $fileContent = file_get_contents('inputFile.txt');
        $groups = explode($EOL.$EOL,$fileContent);
        unset($fileContent);
        for($i = 0, $c = count($groups); $i<$c; ++$i)
        {
                $values = explode($EOL, $groups[$i]);
                sort($values,SORT_NUMERIC);
                for($j =0,$k = count($values);$j<$k;++$j)
                {
                        echo $values[$j].PHP_EOL;
                }
                echo PHP_EOL;
        }
?>
 

[notfound]

En parlant de ruby sur un autre channel, j'en suis venu à montrer ce thread.

TsT a proposé son code en LUA, que je poste à son nom :

Code LUA :


local f = arg[1]
local fd = assert(io.open(f, 'r'))
local res = {}
local b = {}
while true do
        local line = fd:read('*l')
        if not line or line == "" then
                if #b > 0 then
                        table.sort(b)
                        res[#res+1] = b
                        b = {}
                end
                if not line then break end
        else
                b[#b+1] = tonumber(line)
        end
end
fd:close()
 
for i,v in ipairs(res) do
        res[i] = table.concat(v, "\n")
end
print(table.concat(res, "\n\n"))

 
-- En minimisé oneliner

fd=io.open(arg[1],"r");res,b={},{};while true do local line=fd:read("*l");if not line or line=="" then if #b>0 then table.sort(b);res[#res+1]=b;b={} end if not line then break end else b[#b+1]=tonumber(line) end end;fd:close();for i,v in ipairs(res) do res[i]=table.concat(v,"\n") end;print(table.concat(res,"\n\n"))


-- Et avec un module

local strong = require("strong") -- https://github.com/BlackBulletIV/strong
local powertable = require("powertable") -- TsT small module
 
local function tprint(t) for aa,bb in ipairs(t) do print("      ", aa,bb) end end
 
local f = arg[1]
local fd = assert(io.open(f, "r"))
local res = {}
for elem in fd:read("*a"):lines("\n\n") do
        res[#res+1] = powertable( elem:chomp()plit("\n", true) ):tsort( function(x,y) return tonumber(x) < tonumber(y) end ):concat("\n")
end
print(table.concat(res, "\n\n"))


-- Optimisé performance

local function process_data(fd, para_handler)
        local buf = {} -- buffer for each lines of the current paragraph
        while true do
                local line = fd:read("*l") -- read one line
                if not line then break end -- stop if the end of file is reached
                if line == "" then -- a empty line = end of paragraph
                        para_handler(buf)
                        buf = {} -- reset buffer
                else
                        table.insert(buf, tonumber(line))
                end
        end      
        para_handler(buf)
end
 
local function para_handler(buf, eof)
        -- new paragraph ready
        table.sort(buf)
        print(table.concat(buf, "\n").."\n")
end
           
local f = arg[1]
local fd = assert(io.open(f, "r"))
process_data(fd, para_handler)
fd:close()
 

Voilà.
Temps et conso dernier code (d'après gruik):
Time : 8,80s
Conso : < 5k

[wapiflapi]

Yop.

Voilà mon code en C: http://pastebin.com/9y6nNV3M

Features principales:
- utilisations mmap & stdio pour minimiser les temps d'accès en lecture/écriture.
- trie par insertion au lieu de quick sort, ce qui est plus efficace sur de petites listes.
- pas de copie des data dans des buffers temporaires.

Code C :


/*
** sort.c in /home/wapiflapi/Projects/misc/gruik/
**
** Made by Wannes Rombouts
** Login   <rombou_w@epitech.eu>
**
** Started on  Wed Jun  4 15:12:23 2014 Wannes Rombouts
** Last update Wed Jun  4 17:55:28 2014 Wannes Rombouts
*/
 
#include        <unistd.h>
#include        <stdlib.h>
#include        <stdio.h>
#include        <string.h>
#include        <fcntl.h>
#include        <err.h>
#include        <sys/mman.h>
#include        <sys/stat.h>
 
struct entry {
  char const    *text;
  size_t        size;
  unsigned int  val;
};
 
static void process_file(char const *data, size_t size)
{
  struct entry  *array;
  size_t        asize;
  size_t        afill;
 
  afill = 0;
  asize = 32;
  if (!(array = calloc(asize, sizeof *array)))
    err(EXIT_FAILURE, "malloc");
 
  data = data;
  size = size;
 
  while (size > 0)
    {
      char const *nextn;
      unsigned int nb;
 
      if (!(nextn = memchr(data, '\n', size)))
        nextn = data + size;
      size -= nextn - data;
 
      /*
      ** Carefull, nextn might not be mapped if no terminating \n.
      */
 
      if (nextn > data)
        {
          if (afill == asize)
            {
              /*
              ** Should check overflows here but I'm lazy.
              */
              asize *= 2;
              if (!(array = realloc(array, asize * sizeof *array)))
                err(EXIT_FAILURE, "realloc");
            }
 
          array[afill].text = data;
          array[afill].size = nextn - data;
 
          /*
          ** Assume positive numbers.
          */
 
          for (nb = 0; '0' <= *data && *data <= '9'; ++data)
            nb = nb * 10 + *data - '0';
          array[afill].val = nb;
 
          afill += 1;
        }
      else
        {
          /*
          ** Group change: sort & print.
          ** Not using quick sort because it is not faster
          ** than insertion sort for sorting small sets.
          ** libc's implementation is slow anyway, probably
          ** due to all the function calls that can't be inlined.
          */
 
          int i, j;
          struct entry x;
 
          for (i = 1; i < afill; ++i)
            {
              x = array[i];
              for (j = i; j > 0 && array[j-1].val > x.val; --j)
                array[j] = array[j-1];
              array[j] = x;
            }
 
          for (i = 0; i < afill; ++i)
            fwrite(array[i].text, 1, array[i].size + 1, stdout);
          fputc('\n', stdout);
 
          afill = 0;
        }
 
      data = nextn + 1;
      size -= 1;
    }
 
  free(array);
}
 
int             main(int argc, char **argv)
{
  int           fd;
  void          *data;
  struct stat   sbuf;
 
  if (argc < 2)
    errx(EXIT_FAILURE, "Usage: %s data_file", argv[0]);
 
  if ((fd = open(argv[1], O_RDONLY)) < 0)
    err(EXIT_FAILURE, "open");
 
  if (fstat(fd, &sbuf) < 0)
    err(EXIT_FAILURE, "fstat");
 
  if (sbuf.st_size)
    {
      if ((data = mmap(NULL, sbuf.st_size, PROT_READ, MAP_PRIVATE,
                       fd, 0)) == MAP_FAILED)
        err(EXIT_FAILURE, "mmap");
 
      process_file(data, sbuf.st_size);
 
      munmap(data, sbuf.st_size);
    }
 
  close(fd);
 
  return 0;
}