Ubuntu-fr

thurston

[RESOLU] Reduire une phrase jusqu'à n mots avec les mots les + longs

Bonjour,

Je souhaite réduire la taille des titres de musique pour adapter à un display limité.
Mon idée est la suivante:
- Trouver les n mots les plus longs de la phrase et les afficher dans l'ordre de la phrase (ne pas les mélanger)
Ainsi
traitement (Je tente de limiter la longueur d'une phrase; 3 mots) = limiter longueur phrase
traitement (Je tente de limiter la longueur d'une phrase; 2 mots) = limiter longueur

Dans le cas où 2 mots auraient la même taille, je souhaiterais conserver le 1er.
Ainsi (longueurs et limiteras font tous les deux 9 char)
traitement (tu limiteras les  longueurs de la phrase; 1 mot) = limiteras

comme je compte utiliser ce script sur des milliers de mp3 (traitement artiste, album, titre), le script doit être assez efficace. J'ai bien réussi à trouver le plus long, mais c'est avec des boucles if et autres, complètement nul quoi.

Je pensais à une boucle while qui supprime tous les mots de longueur incrémentée à chaque boucle, jusqu'à trouver le bon nombre de mots...par sed?.
J'ai deux pb. je connais pas la commande avec sed, et j'ai du mal à savoir comment traiter le cas où plusieurs mots ont la même taille, ce qui fait passer par exemple le nombre de mots corrects de 2 à 4 avec mon idée.
Est ce qu'une ame charitable???
d'avance merci
Thurston

sentence=phrase à traiter
nb=nombre_de_mots_souhaités
while [ `echo -n "$reduced_sentence" | wc -w` = $nb ]
do
  reduced_sentence=`echo "$sentence" | sed ....` # là je peche, y compris le cas d'un saut de n à n+2 si mots de taille identique
   n=$(( n+1 ))
done
echo "$reduced_sentence"

Dernière modification par thurston (Le 13/08/2012, à 23:22)

pingouinux

Re : [RESOLU] Reduire une phrase jusqu'à n mots avec les mots les + longs

Bonsoir,
Voici une proposition :

$ cat limite.sh

#!/bin/bash

traitement() {
   phrase="$1"           # Phrase à traiter
   nmax=$2               # Nombre de mots à conserver
   n=0; resul=""
# On trie les longueurs des mots par valeurs décroissantes, et on ne garde que les "nmax" premières
   longueurs=$(
      for mot in ${phrase[@]}
      do
         echo ${#mot}
      done | sort -rn | head -$nmax
   )  

# Boucle sur les mots de la phrase
# On ne prend que ceux dont la longueur correspond à une de celles conservées dans le tableau "longueurs"
   for mot in ${phrase[@]}
   do
      for lon in ${longueurs}
      do
         if [[ ${#mot} == $lon ]]; then
            resul=$resul"$mot "
          # On enlève du tableau la longueur qui a été utilisée
            longueurs=$(echo $longueurs | sed "s/\b$lon\b//")
            ((++n))
            break
         fi
      done

    # On s'arrête si on a le compte de mots
      ((n >= nmax)) && break
   done

   echo $resul
}

traitement "Je tente de limiter la longueur d'une phrase" 3
traitement "Je tente de limiter la longueur d'une phrase" 2
traitement "tu limiteras les  longueurs de la phrase" 1

$ ./limite.sh
limiter longueur phrase
limiter longueur
limiteras

Édité : Suppression de lignes inutiles

Dernière modification par pingouinux (Le 13/08/2012, à 22:28)

Tycho Brahe

Re : [RESOLU] Reduire une phrase jusqu'à n mots avec les mots les + longs

Salut,

Normalement ceci est fonctionnel :

#!/bin/sh

traitement() {
    num="$1"
    str="$2"
    pos=0;
    for word in `echo $str`; do
	pos=$((pos + 1))
	len=$(echo -n $word | wc -c)
	w=$((len * 10000 - pos))
	if [ $pos -ne 1 ]; then
	    mstr="$mstr\n$w:$pos:$word"
	else
	    mstr="$w:$pos:$word"
	fi
    done
    echo $mstr | sort -g | tail -n $num | cut -d ':' -f2,3 | sort -g | cut -d ':' -f2
}

if [ $# -ne 2 ]; then
    echo "Usage: $0 length string"
    exit 1
fi

traitement "$1" "$2"

Utilisation :

-> ./sort.sh 3 "lol lil qwerty w q q qwertyuasd lulz"
qwerty
qwertyuasd
lulz
-> ./sort.sh 3 "Je tente de limiter la longueur d'une phrase"
limiter
longueur
phrase
-> ./sort.sh 2 "Je tente de limiter la longueur d'une phrase"
limiter
longueur
-> ./sort.sh 1 "tu limiteras les  longueurs de la phrase"
limiteras

Dernière modification par Tycho Brahe (Le 13/08/2012, à 21:27)

---

Loi de Newton :
Si tu restes à glander sous le pommier, tu pourrais bien prendre une pomme sur la gueule.

thurston

Re : [RESOLU] Reduire une phrase jusqu'à n mots avec les mots les + longs

Bonjour les gars

Merci merci!!!
je vais tester vos deux propositions, que je vais insérer dans mon script, et vous dirai le temps le plus rapide de traitement.
Vraiment merci, c'est à mille lieux de ce que j'aurais pu écrire avec mes petits moyens.
A+
T

PS: bon j'ai fait des boucles sur plusieurs essais pour tenter de voir le script le plus rapide, il semble que pingouinux ait l'avantage.
Les 2 scripts marchent en tous les cas à merveille merci
A+
T

Dernière modification par thurston (Le 13/08/2012, à 22:58)

pingouinux

Re : [RESOLU] Reduire une phrase jusqu'à n mots avec les mots les + longs

Voici une version en python, qui semble un peu plus rapide que mon script du #2 :

$ cat limite.py
#! /usr/bin/python
# -*- coding: utf-8 -*-

import sys

phrase=sys.argv[1].split()
nmax  =int(sys.argv[2])
longueurs=map( len, phrase )

longueurs.sort()
longueurs=longueurs[-nmax:]

n=0; resul=""
for mot in phrase :
   if len(mot) in longueurs :
      resul+=mot+" "
      longueurs.remove(len(mot))
      n+=1
   if n>=nmax : break

print(resul)

$ ./limite.py "Je tente de limiter la longueur d'une phrase" 3
limiter longueur phrase 

$ ./limite.py "Je tente de limiter la longueur d'une phrase" 2
limiter longueur 

$ ./limite.py "tu limiteras les  longueurs de la phrase" 1
limiteras 

Dernière modification par pingouinux (Le 14/08/2012, à 07:40)

pingouinux

Re : [RESOLU] Reduire une phrase jusqu'à n mots avec les mots les + longs

Voici une version améliorée de mon script bash du #2 (maintenant plus rapide que mon script python du #5) :

$ cat ./limite.sh

#!/bin/bash

traitement() {
   phrase="$1"           # Phrase à traiter
   nmax=$2               # Nombre de mots à conserver
   n=0; resul=""
# On trie les longueurs des mots par valeurs décroissantes, et on ne garde que les "nmax" premières
   longueurs=( $(
         for mot in ${phrase[@]}
         do
            echo ${#mot}
         done | sort -rn | head -$nmax
   ) )

 # Boucle sur les mots de la phrase
 # On ne prend que ceux dont la longueur correspond à une de celles conservées dans le tableau "longueurs"
   for mot in ${phrase[@]}
   do
      ind=0
      for lon in "${longueurs[@]}"
      do
         if [[ ${#mot} == $lon ]]; then
            resul=$resul"$mot "
          # On enlève du tableau la longueur qui a été utilisée
            longueurs[$ind]=""
            ((++n))
            break
         fi
         ((++ind))
      done
    # On s'arrête si on a le compte de mots
      ((n >= nmax)) && break
   done

   echo $resul
}

traitement "Je tente de limiter la longueur d'une phrase" 3
traitement "Je tente de limiter la longueur d'une phrase" 2
traitement "tu limiteras les  longueurs de la phrase" 1

Édité : Correction du script

Dernière modification par pingouinux (Le 15/08/2012, à 22:04)

grim7reaper

Re : [RESOLU] Reduire une phrase jusqu'à n mots avec les mots les + longs

Ha bah si on fait du Python alors
En plus court (et peut-être plus rapide, j’ai pas fait de bench’) :

#!/usr/bin/env python
#coding: utf-8

import sys

words = sys.argv[1].split()
n = int(sys.argv[2])

items = [(len(w), sys.argv[1].find(w)) for w in words]
items = sorted(items, key=lambda x: (-x[0], x[1]))[:n]
items.sort(key=lambda x: x[1])
print(" ".join([sys.argv[1][idx:idx+size] for (size, idx) in items]))

Comme c’est un peu concis je vais expliquer si ça en intéresse quelques-uns.
D’abord on récupère les paramètres :
    - la phrase à réduire: on la découpe en liste de mots => words
    - le nombre de mots à conserver => n

Ensuite, on va créer un tuple (longueur, position) pour chaque mot de la phrase => items
Cette liste va être triée de manière décroissante sur la longueur, puis de manière croissante sur la position en cas d’égalité sur la longueur. On ne conserve que les n premiers.
Maintenant que l’on a nos mots, il faut restaurer l’ordre de la phrase donc on fait un second et dernier tri sur la position.
Enfin, on extrait les mots de la phrase (facile avec le couple position, longueur ) et on concatène tout ça avec des espaces pour obtenir la chaîne finale que l’on affiche.

@pingouinux  : comment tu bench’ ?

Dernière modification par grim7reaper (Le 14/08/2012, à 08:18)

---

Blog

pingouinux

Re : [RESOLU] Reduire une phrase jusqu'à n mots avec les mots les + longs

@pingouinux  : comment tu bench’ ?

Je me suis fait un fichier i de 16384 lignes (2**14).

time while read lig  ; do ./script_a_tester "$lig" 5; done <i >j

Voilà ce que j'obtiens pour ton script python du #7 :

real	5m35.117s
user	2m1.850s
sys	1m18.400s

pour mon script python du #5 :

real	5m33.159s
user	1m44.900s
sys	1m48.310s

En intégrant la lecture du gros fichier dans le script python, le résultat est quasi-instantané. Avec mon script, par exemple :

real	0m0.173s
user	0m0.160s
sys	0m0.020s

grim7reaper

Re : [RESOLU] Reduire une phrase jusqu'à n mots avec les mots les + longs

Ok.
En effet ton script Python est plus rapide que le mien (ton approche est meilleure aussi).

---

Blog

pingouinux

Re : [RESOLU] Reduire une phrase jusqu'à n mots avec les mots les + longs

@grim7reaper #9 :
Je ne vois pas une grosse différence en temps. En intégrant la lecture du gros fichier dans ton script :

real	0m0.350s
user	0m0.310s
sys	0m0.030s

grim7reaper

Re : [RESOLU] Reduire une phrase jusqu'à n mots avec les mots les + longs

Il y a quand même un presque un facteur 2.
Mais le temps de traitement reste plus que correct, oui.

En tout cas je pense que thurston a de quoi faire maintenant

Dernière modification par grim7reaper (Le 14/08/2012, à 11:42)

---

Blog

Tycho Brahe

Re : [RESOLU] Reduire une phrase jusqu'à n mots avec les mots les + longs

Allez, si on a le droit à d'autres langages, allons-y en C++ !

#include <iostream>
#include <string>
#include <sstream>
#include <algorithm>
#include <iterator>
#include <list>

class Word {
private:
  int pos_;
  std::string str_;
  Word();

public:
  static int cnt;
  Word(int pos, const std::string &str) : pos_(pos), str_(str) {}
  Word(const std::string &str) : pos_(cnt++), str_(str) {}
  ~Word() {}
  Word(const Word &cp) { *this = cp; }
  Word &operator=(const Word &cp) {
    if (&cp != this) {
      this->pos_ = cp.pos_;
      this->str_ = cp.str_;
    }
    return *this;
  }

  unsigned int getLen() const { return str_.length(); }
  int getPos() const { return pos_; }
  std::string getStr() const { return str_; }

  bool cmpLen(const Word &w) const {
    return w.getLen() < str_.length();
  }
  bool cmpPos(const Word &w) const {
    return w.getPos() > pos_;
  }
};

int Word::cnt = 0;

class SortStr {
private:
  int len_;
  std::string str_;
  std::list<Word> words_;
  SortStr();

public:
  SortStr(int len, const std::string &str) : len_(len), str_(str) {}
  void sort() {
    std::istringstream iss(str_);
    copy(std::istream_iterator<std::string>(iss),
	 std::istream_iterator<std::string>(),
	 std::back_inserter<std::list<Word> >(words_));

    words_.sort([](const Word &a, const Word &b)->bool{
	return a.cmpLen(b);
      });
    trim();
    words_.sort([](const Word &a, const Word &b)->bool{
	return a.cmpPos(b);
      });
  }
  void trim() {
    std::list<Word>::iterator beg = words_.begin(), end = words_.end();
    for (; len_ != 0 && beg != end; --len_)
      ++beg;
    words_.erase(beg, end);
  }
  void disp() {
    std::list<Word>::iterator beg = words_.begin(), end = words_.end();
    for (; beg != end; ++beg) {
      std::cout << beg->getStr() << std::endl;
    }
  }
};

int
main(int argc, char *argv[]) {
  if (argc != 3) {
    std::cerr << "Usage: " << argv[0] << " length string" << std::endl;
    return 1;
  }

  std::istringstream iss(argv[1]);
  int len;
  iss >> len;
  SortStr s(len, argv[2]);

  s.sort();
  s.disp();

  return 0;
}

La compilation (sous réserve que le fichier s’appelle sort.cpp) :

g++ sort.cpp -Wall -Wextra -Werror -pedantic -O3 -std=c++0x

Et on test :

-> ./a.out 3 "lol lil qwerty w q q qwertyuasd lulz"
qwerty
qwertyuasd
lulz
-> ./a.out 3 "Je tente de limiter la longueur d'une phrase"
limiter
longueur
phrase
-> ./a.out 2 "Je tente de limiter la longueur d'une phrase"    
limiter
longueur
-> ./a.out 1 "tu limiteras les  longueurs de la phrase"        
limiteras

J'ai pas eu le temps de faire de bench mais ça m'intéresse ^^

---

Loi de Newton :
Si tu restes à glander sous le pommier, tu pourrais bien prendre une pomme sur la gueule.

grim7reaper

Re : [RESOLU] Reduire une phrase jusqu'à n mots avec les mots les + longs

Allez, si on a le droit à d'autres langages, allons-y en C++ !

Je crois pas que thurston s’attendait à lancer un concours ^^

J'ai pas eu le temps de faire de bench mais ça m'intéresse ^^

Si tu as pas codé avec des moufles, ça devrait être plus rapide vu que C++ est compilé (comme si je tentais en C, OCaml ou Haskell).

Édit : bon je vais faire les bench pour le fun ^^

Dernière modification par grim7reaper (Le 14/08/2012, à 13:59)

---

Blog

Tycho Brahe

Re : [RESOLU] Reduire une phrase jusqu'à n mots avec les mots les + longs

Je crois pas que thurston s’attendait à lancer un concours ^^

N'empêche que c'est assez intéressant Un problème et une multitude de solutions, on enrichis tous notre manière de programmer à lire ce qu'ont fait les autres.

Si tu as pas codé avec des moufles, ça devrait être plus rapide vu que C++ est compilé (comme si je tentais en C, OCaml ou Haskell).

Ouais, enfin en général je ne fais pas du tout attention aux performances, je préfère largement la lisibilité. Là j'ai pas trop fais gaffe aux perfs, j'ai pondu le code comme ça me venais sans chercher à bien faire les choses. Si faut vraiment faire un concours de perfs je vais recommencer avec TBB, sur les gros fichiers ça va vraiment faire la différence. Et pourquoi pas aussi utiliser CUDA afin de faire bosser le CG, quand on en a une avec 96 cœurs exploitables faut se faire plaisir (je sais, s'pas le cas de tout le monde, certains ont beaucoup plus et d'autres beaucoup moins).

---

Loi de Newton :
Si tu restes à glander sous le pommier, tu pourrais bien prendre une pomme sur la gueule.

grim7reaper

Re : [RESOLU] Reduire une phrase jusqu'à n mots avec les mots les + longs

Je crois pas que thurston s’attendait à lancer un concours ^^

N'empêche que c'est assez intéressant Un problème et une multitude de solutions, on enrichis tous notre manière de programmer à lire ce qu'ont fait les autres.

Yep

Si tu as pas codé avec des moufles, ça devrait être plus rapide vu que C++ est compilé (comme si je tentais en C, OCaml ou Haskell).

Ouais, enfin en général je ne fais pas du tout attention aux performances, je préfère largement la lisibilité. Là j'ai pas trop fais gaffe aux perfs, j'ai pondu le code comme ça me venais sans chercher à bien faire les choses.

Bah même sans forcer, il y a la compilation qui est la.
Les compilo’ C++ sont de très bon optimiseurs, même si un peu moins bon que les compilo’ C (car C est plus simple que le C++, et plus vieux aussi) ou que les compilos de language fonctionnels (par nature).

Résultats :

$ time ./Tycho_Brahe TEST 5 > /dev/null
real    0m0.081s
user    0m0.076s
sys     0m0.004s
$ time ./grim7reaper.py TEST 5 > /dev/null
real    0m0.240s
user    0m0.232s
sys     0m0.004s
$ time ./pingouinux.py TEST 5 > /dev/null
real    0m0.164s
user    0m0.160s
sys     0m0.000s
$ time ./pingouinux.sh TEST 5 > /dev/null
real    1m38.146s
user    0m33.466s
sys     0m9.585s

Si faut vraiment faire un concours de perfs je vais recommencer avec TBB, sur les gros fichiers ça va vraiment faire la différence. Et pourquoi pas aussi utiliser CUDA afin de faire bosser le CG, quand on en a une avec 96 cœurs exploitables faut se faire plaisir (je sais, s'pas le cas de tout le monde, certains ont beaucoup plus et d'autres beaucoup moins).

Même pas sûr que tu aies un gain très très visible : les traitements sont pas très intensifs, je pense qu’on va être assez vite plus limités pas les I/O qu’autres choses là.

Dernière modification par grim7reaper (Le 14/08/2012, à 14:32)

---

Blog

Tycho Brahe

Re : [RESOLU] Reduire une phrase jusqu'à n mots avec les mots les + longs

Même pas sûr que tu aies un gain très très visible : les traitements sont pas très intensifs, je pense qu’on va être assez vite plus limités pas les I/O qu’autres choses là.

Je te propose de tester ça Pour les IO, tant que l'output ne se fais pas sur le term ya de bonnes perf, donc avec la redirection dans /dev/null ça passe impec.

#include <iostream>
#include <string>
#include <sstream>
#include <algorithm>
#include <iterator>
#include <vector>
#include "tbb/task_scheduler_init.h"
#include "tbb/parallel_sort.h"

class Word {
private:
  int pos_;
  std::string str_;
  Word();

public:
  static int cnt;
  Word(int pos, const std::string &str) : pos_(pos), str_(str) {}
  Word(const std::string &str) : pos_(cnt++), str_(str) {}
  ~Word() {}
  Word(const Word &cp) { *this = cp; }

  Word &operator=(const Word &cp) {
    if (&cp != this) {
      this->pos_ = cp.pos_;
      this->str_ = cp.str_;
    }
    return *this;
  }

  unsigned int getLen() const { return str_.length(); }
  int getPos() const { return pos_; }
  std::string getStr() const { return str_; }

  bool cmpLen(const Word &w) const {
    return w.getLen() < str_.length();
  }
  bool cmpPos(const Word &w) const {
    return w.getPos() > pos_;
  }
};

int Word::cnt = 0;

class SortStr {
private:
  int len_;
  std::string str_;
  std::vector<Word> words_;
  SortStr();

public:
  SortStr(int len, const std::string &str) : len_(len), str_(str) {}
  void sort() {
    std::istringstream iss(str_);
    copy(std::istream_iterator<std::string>(iss),
	 std::istream_iterator<std::string>(),
	 std::back_inserter<std::vector<Word> >(words_));

    tbb::parallel_sort(words_.begin(), words_.end(), [](const Word &a, const Word &b)->bool{
	return a.cmpLen(b);
      });
    trim();
    tbb::parallel_sort(words_.begin(), words_.end(), [](const Word &a, const Word &b)->bool{
	return a.cmpPos(b);
      });
  }
  void trim() {
    std::vector<Word>::iterator beg = words_.begin(), end = words_.end();
    for (; len_ != 0 && beg != end; --len_)
      ++beg;
    words_.erase(beg, end);
  }
  void disp() {
    std::vector<Word>::iterator beg = words_.begin(), end = words_.end();
    for (; beg != end; ++beg) {
      std::cout << beg->getStr() << std::endl;
    }
  }
};

int
main(int argc, char *argv[]) {
  if (argc != 3) {
    std::cerr << "Usage: " << argv[0] << " length string" << std::endl;
    return 1;
  }

  tbb::task_scheduler_init TBBinit;
  std::istringstream iss(argv[1]);
  int len;
  iss >> len;
  SortStr s(len, argv[2]);

  s.sort();
  s.disp();

  return 0;
}

Pour les dépendances :

sudo apt-get install libtbb-dev

Pour la compilation (le fichier étant sort-tbb.cpp) :

g++ sort-tbb.cpp -Wall -Wextra -Werror -pedantic -O3 -std=c++0x -ltbb

---

Loi de Newton :
Si tu restes à glander sous le pommier, tu pourrais bien prendre une pomme sur la gueule.

grim7reaper

Re : [RESOLU] Reduire une phrase jusqu'à n mots avec les mots les + longs

Je te propose de tester ça

Bah ça confirme ce que je dis  : c’est pas CPU bound mais I/O bound.
Du coup, non seulement tu ne gagnes pas, mais en plus tu perds un peu (sûrement dû au scheduling) :

$ time ./Tycho_Brahe TEST 5 > /dev/null
real    0m0.081s
user    0m0.080s
sys     0m0.000s
$ time ./Tycho_Brahe-tbb TEST 5 > /dev/null
real    0m0.097s
user    0m0.088s
sys     0m0.008s

Et j’ai 8 cœurs, donc si ça devait booster ça le ferait hein ;-)

Édit : histoire de, j’ai aussi testé sur un fichier plus gros (163 840 lignes, 7,1 M) et pas de changement : la version TBB est plus lente.

Dernière modification par grim7reaper (Le 14/08/2012, à 15:46)

---

Blog

Tycho Brahe

Re : [RESOLU] Reduire une phrase jusqu'à n mots avec les mots les + longs

Avec quelques petits tests chez moi, le version avec TBB est plus... aléatoire. Elle est parfois plus lente en effet, mais parfois bien plus rapide. Faudrait faire un tri de très gros pour avoir un avantage quoi ^^

---

Loi de Newton :
Si tu restes à glander sous le pommier, tu pourrais bien prendre une pomme sur la gueule.

grim7reaper

Re : [RESOLU] Reduire une phrase jusqu'à n mots avec les mots les + longs

Oui, elle varie beaucoup plus.
J’ai fait une 20aine de tests mais ça n’a jamais été meilleur par contre.

Édit : test avec un fichier de 493M (11 468 800 lignes), pas de changement.
Cela dit, c’est bizarre mais chez moi TBB n’occupe qu’un cœur :-/

Dernière modification par grim7reaper (Le 14/08/2012, à 16:31)

---

Blog

thurston

Re : [RESOLU] Reduire une phrase jusqu'à n mots avec les mots les + longs

Salut à tous les 2

un petit concours en restant courtois, c'est l'effet JO? ;-)
Merci pour toutes les améliorations.
Perso le bash, j'ai déjà du mal, alors python, pas pour moi (en fait j'ai investi déjà pas mal de temps pour comprendre le bash à peu près, complètement en dehors de ma spécialité).
Du coup, en considérant que je souhaite conserver du bash, je prends quoi au final?
celle ci? de 07:38?
Et encore merci du coup de main.
A+
Thurston

pingouinux

Re : [RESOLU] Reduire une phrase jusqu'à n mots avec les mots les + longs

Mon script bash du #6 (8:38) est le plus rapide de ceux que j'ai faits.
Bonne soirée

Tycho Brahe

Re : [RESOLU] Reduire une phrase jusqu'à n mots avec les mots les + longs

Cela dit, c’est bizarre mais chez moi TBB n’occupe qu’un cœur :-/

Ce n'est pas normal, mais ça a le mérite d'expliquer les mauvaises perfs chez toi. Forcément, vu mon processeur j'y gagne pas mal de mon côté !

---

Loi de Newton :
Si tu restes à glander sous le pommier, tu pourrais bien prendre une pomme sur la gueule.

grim7reaper

Re : [RESOLU] Reduire une phrase jusqu'à n mots avec les mots les + longs

Cela dit, c’est bizarre mais chez moi TBB n’occupe qu’un cœur :-/

Ce n'est pas normal, mais ça a le mérite d'expliquer les mauvaises perfs chez toi.

Oui, mais pourquoi ?
Ça vient peut-être de la façon de faire les tests, ou du fichier de tests.

Forcément, vu mon processeur j'y gagne pas mal de mon côté !

J’ai plus ou moins la même bête, juste 200 MHz de moins.

---

Blog

no_spleen

Re : [RESOLU] Reduire une phrase jusqu'à n mots avec les mots les + longs

Bonjour,

une petite version en awk pour varier.

split_titles.awk

{
  for (i=1;i<=NF;i++) 
  {
    if (!(length($i) in taille))
    {   
       taille[length($i)]=$i
       place[$i]=i
    }   
  }
  n = asorti(taille,n_ordre)
  for (i=0;i<nb_max;i++)
  {
    word = taille[n_ordre[n-i]]
    unsorted[place[word]]=word
  }
  m = asorti(unsorted,m_ordre)
  sorted = ""
  for (i=1;i<=m;i++)
  {
    sorted=(i==1)?unsorted[m_ordre[i]]:sorted"_"unsorted[m_ordre[i]]
  }
  print sorted
  delete taille
  delete place
  delete n_ordre
  delete m_ordre
  delete unsorted
}

et pour le lancer

gawk -f split_titles.awk -v nb_max=2 test_file.txt

pingouinux

Re : [RESOLU] Reduire une phrase jusqu'à n mots avec les mots les + longs

Bonjour,
@ no_spleen #24 :
J'ai testé ton script awk. Il est très rapide sur un gros fichier, mais ne semble pas donner le bon résultat :

$ gawk -f split_titles.awk -v nb_max=1  <<<"des phrases à tester pour la performance"
phrases