Tiny File Manager

Back Back Up Advanced Editor

#remplace();
#affiche();
#cherche01();
#cherche02();
#cherche03();
#cherche04();

#compte01();
#compte02();

#compte03();

#test();

bidule();

######################################################################
sub remplace()
{
open(FILEINPUT,"$ARGV[0]");
while ($ligne = <FILEINPUT>){
# on remplace dans chaque ligne le motif recherche par remplacement
$ligne=~s/je/pattttte/g;
print $ligne;
}
close(FILEINPUT) ;
}
######################################################################
sub affiche()
{
open FICHIER,"< lettre.txt" or die "Le fichier n'existe pas !";
while ($ligne = <FICHIER>){
      print $ligne;
}
close FICHIER;
}
######################################################################
sub cherche01()
{
@ARGV =("lettre.txt");
$nf = @ARGV;
print "Mot rechercher ? ";
chop($critere = <stdin>);
$total = $compt = 0;
$fichier = $ARGV[0];
while ($ligne =<>) {
  chop ($ligne);
  @mots = split (/ /,$ligne);
  $w = 0;
  while ($w <= @mots) {
    if ($mots[$w] eq $critere) {
      $compt += 1;
    }
  $w++;
  }
  if (eof) {
    print ("Dans le fichier $fichier\n");
    print ("Il y a $compt occurences du mot $critere\n\n");
    $total += $compt;
    $compt = 0;
    $fichier = $ARGV[0];
  }
}

}
######################################################################
sub cherche02() 
{
print "Quel nom voulez-vous rep�rer ?\n";
$nom = <stdin>;
chomp $nom;
for ($i=0; $i<@tablo; $i++)
    {	if($tablo[$i] =~ /$nom/)
    	{ print "$nom est en position $i\n";
	    }
    }
}
######################################################################
sub cherche03()
{
# ouverture du fichier pass� en argument au script
# et association � un pointeur de fichier
open(FILEINPUT,"$ARGV[0]");
# parcours du fichier associ� au pointeur FILEINPUT
# chaque ligne est stok�e dans la variable $ligne
while ($ligne = <FILEINPUT>)
{ # on v�rifie si la ligne comptient le motif
  if ($ligne=~/folle/)
    {  #si oui, on l'imprime 
       print $ligne;
    }
}
}
######################################################################
sub compte01()
{
# compter le nombre d'occurences de chaque mot d'un texte
# => utiliser un tableau associatif index� par les mots
# compter le nombre de mots diff�rents
# => nombre de cases du tableau
# compter le nombre total de mots
# => solution bis : 
#    compter ce total au fur et � mesure de la lecture
 
my %tab_words = ();
my $nb_words = 0;

# lit chaque ligne du texte
# et remplit le tableau d'occ
# et calcule le nb total de mots
while (<>) {
    chomp;
    my @ligne = split;

# ajoute les mots de la ligne courante 
    $nb_words += $#ligne + 1;

foreach $i (@ligne) {
	# ajoute 1 au nb d'occ du mot $i
	$tab_words{$i}++;
    }
}

# affiche tout le tableau associatif d'occ
print "Nombre d'occurences de chaque mot :\n";
while (($word,$nb) = each(%tab_words)) {
#    print $word, " ", $nb, "\n";
    printf "%3d  %s\n", $nb, $word;
}

# nb mots differents = nb cases tableau
my @listk = keys(%tab_words);
my $nb_unique_words = $#listk +1;

print "Nb total mots : ", $nb_words, "\n";
print "Nb mots diff�rents : ", $nb_unique_words, "\n";
}

######################################################################
sub compte02()
{
$/ = ""; #unit� de travail le paragraphe
$* = 1; #plusieurs lignes � la fois
while (<>){
s/-\n//g; #enlever les tirets
tr/A-Z/a-z/; #minusculiser
@words = split (/\W*\s+\W*/,$_);
foreach $word (@words) {
$wordcount{$word}++;
}
}
foreach $word (sort keys (%wordcount)) {
printf "%20s,%d\n",$word,$wordcount{$word};
}
}
######################################################################
sub cherche04()
{
print("Quel mot voulez-vous rechercher :");
$cherche = <STDIN>;
chop($cherche);
$ligne="0";
$sum="0";
$cond="0";
while(<>){
$cond=$sum;
$ligne +=1;
$sum += (s/\b$cherche\b/$cherche/g);
if($cond != $sum){
print("Ligne $ligne ==> ");
print("$sum\n");
};
};
print("----------------------------------------------------\n");
print("Votre fichier contient $sum fois le mot \'$cherche\'\n");

}
######################################################################
sub compte03()
{
@ARGV =("lettre.txt");
$nbmots = 0;
$nbcar = 0;
while ($ligne = <>) {
  @mots = split(/\s+/,$ligne);
  foreach $mot (@mots) {
    next if ($mot =~/^d+\.?\d+$/);
    $mot =~s/[,.;:]$//;
 $nbmots ++;
    $nbcar += length($mot);
  }
}
print ("Nombre total de mots :$nbmots\n");
print ("Nombre total de caract�res :$nbcar\n");
$moyenne = $nbcar / $nbmots;
print ("Longueur moyenne d'un mot :$moyenne\n");
}

######################################################################
sub test()
{
# Un tableau avec des valeurs dupliquees :
my @t = qw(hello toto hello vous);
# Declaration d'une table de hachage :
my %h;
# On prend la tranche de %h dont les clefs
# sont les valeurs du tableau @t
# et on leur associe la valeur undef

@h{@t} = ();
# Les clefs de %h sont donc constituees des
# valeurs de @t, et on est s^ur de ne les
# retrouver qu'une seule fois :
@t = keys %h;

$x = "chien chat maison"; # 3 mots
@mots = ($x =~ /(\w+)/g); # correspondance,
print  $mots[0];

}
######################################################################

sub bidule()
{

# Initialisation du tableau
my @array=();

open(FILE_HANDLE,"toto.txt") || die ("Erreur d'ouverture de TOTO") ;

#@ligne = <FILE_HANDLE>;

while (<FILE_HANDLE>)
{ # afficher le fichier ligne apr�s ligne
print "$_";
}

print  $ligne[2];

$var = scalar(@ligne);
# Afficher la taille du tableau
 print "on obtient $var";

}

@contenu_fichier = <FILE_HANDLE>;

# $var = scalar(@contenu);
# Afficher la taille du tableau
# print $var;

# supprimer les redondances
@liste = uniq(@contenu_fichier);
# affiche le resultat
print (@liste, "\n");  
# recuprer la taille
$taille = scalar(@liste) ; 
# affiche le resultat
print $taille;

close(FILE_HANDLE);

#print (@fichier, "\n");

#@liste = uniq(@fichier);

#print (@liste, "\n");

#$taille = scalar(@liste) ;

#print $taille;

#print "lulululululul";

#close(FILE_HANDLE);

#@liste = ('un ','deux ','trois ','quatre ','cinq ','un ','six ');

# @liste = uniq(@liste);

#print (@liste, "\n");

#$taille = scalar(@liste) ;

#print $taille;
######################################################################

sub uniq 
{  
my (@liste) = @_; 
 my @double = map {$_, 1} @liste;
# remplace chaque valeur par un couple (valeur, 1) 
 my %hash = (@double); 
#  stocke cela dans une table de hashage 
 return keys %hash; 
# extrait les cl�s (qui sont uniques par d�finition) 
}