Les scripts BASH AWK SED

Site de reference : http://unstableme.blogspot.com

LA COLONNE

MIN - MAX
  1. Min et Max d'une colonne
  2. Min et Max d'une colonne avec choix des limites de coupe
CUMUL
  1. Cumul d'une colonne en regroupant des patterns semblables (associative array)
  2. Cumul d'une colonne avec limite de coupe manuelle
  3. Cumul d'une colonne avec limite de coupe automatique
CUMUL (la commande "exit" est a l'exterieur de la boucle du script, ce qui permet d'en executer un autre a la suite)
  1. Cumul d'une colonne avec decoupe a une limite definie - METHODE 1
  2. Cumul d'une colonne avec decoupe a une limite definie - METHODE 1B
  3. Cumul d'une colonne avec decoupe a une limite definie - METHODE 4
  4. Cumul d'une colonne avec decoupe a une limite definie - METHODE 5
  5. Cumul d'une colonne avec decoupe a une limite definie - METHODE 8
CUMUL (la commande "exit" est a l'interieur de la boucle du script)
  1. Cumul d'une colonne avec decoupe a une limite definie - METHODE 2
  2. Cumul d'une colonne avec decoupe a une limite definie - METHODE 3
  3. Cumul d'une colonne avec decoupe a une limite definie - METHODE 6
  4. Cumul d'une colonne avec decoupe a une limite definie - METHODE 7
DIVERS
  1. Afficher les elements uniques d'une colonne
  2. Lire les colonnes avec "while read col1 col2 ..."
  3. Repeter un nombre de fois different une valeur qui s'incremente de 1
  4. Modifier une colonne avec l'action : "if(length())"
  5. Decoupe verticale avant ou apres un separateur ( identique a split )
  6. Reperer les doublons d'une colonne en separant les series dont ils sont issus
  7. Decouper un fichier en creant autant de fichiers que de colonnes

LA LIGNE

MIN - MAX - CUMUL
  1. Min et Max de valeurs placées sur une ligne
  2. Cumul de valeurs sur une ligne
MODIFIER LE DEBUT , LA FIN OU TOUT CARACTERE D'UNE LIGNE
  1. Supprimer un debut de fichier avant un pattern
  2. Supprimer une fin de fichier apres un pattern
  3. Modifier les extremites d'une ligne avec "gsub" (bash)
  4. Modifier une fin de ligne en retirant les espaces (sed)
  5. Modifier une fin de ligne en retirant un caractere (bash)
  6. Modifier une fin de ligne en ajoutant un caractere (bash)
  7. Modifier une fin de ligne en changeant un caractere - exemple 1 (awk)
  8. Modifier une fin de ligne en changeant un caractere - exemple 2 (awk)
  9. Modifier tout caractere en maitrisant sa position (awk)
  10. Ajouter un signe dans une colonne qui fera office de separateur (awk)
  11. Un signe en bout de ligne fait joindre la ligne qui suit (awk + getline)
  12. Lire les 3 premiers caracteres de chaque ligne d'un fichier
  13. Lire les 3 derniers caracteres de chaque ligne d'un fichier
  14. Effacer les 3 derniers caracteres de chaque ligne d'un fichier
TESTER LES FINS DE LIGNES
  1. En "AWK" : tester les tabulations cachees en fin de lignes
  2. En "BASH" : tester les derniers caracteres en fin de lignes
DECOUPER UN FICHIER
  1. Decouper un fichier a un pattern precis (le pattern est la fin du fichier decoupe)
  2. Decouper un fichier a un pattern precis (le pattern est le debut du fichier decoupe)
  3. Decouper un fichier a un pattern precis (autre exemple)
  4. Decouper un fichier d'apres la forme de sa fin de ligne
AJOUTER - INSERER
  1. Inserer une ligne avant ou apres un pattern (en AWK et en BASH)
  2. Inserer un trait au changement d'un pattern
  3. Inserer une ligne avant des patterns listes dans un fichier
  4. Ajouter du texte sur une ligne ou apres une ligne
  5. Inserer une ligne blanche selon un critere de longueur de ligne
  6. Memoriser une chaine de caracteres pour l'inserer sur une autre ligne
CAPTURER - MODIFIER
  1. Capturer dans un fichier des patterns listes dans un 2eme fichier (exemple 1)
  2. Capturer dans un fichier des patterns listes dans un 2eme fichier (exemple 2)
  3. Modifier dans un fichier des patterns listes dans un 2eme fichier
  4. Stopper la lecture d'un fichier à un pattern liste dans un 2eme fichier
  5. Capturer un pattern a une position fixe sur une ligne
  6. Capturer un pattern avec un depart, une longueur et une arrivee
  7. Capturer la premiere occurrence d'une serie de lignes ayant meme pattern
  8. Selectionner des lignes d'un fichier par des caracteres d'une colonne
  9. Une seule variable dans une seule boucle suffit pour la source et la cible
  10. Capture de lignes avec pattern de debut et de fin
  11. Maitrise de la ligne et du champ pour reorganiser les champs
COLLER - MARQUER - REMPLACER
  1. Marquer des groupes de patterns semblables (exemple simple)
  2. Marquer des groupes de patterns semblables (exemple plus complique)
  3. Coller des valeurs a un pattern (exemple 1)
  4. Coller des valeurs a un pattern (exemple 2)
  5. Coller des valeurs a un pattern (exemple 3)
  6. Remplacer des patterns par d'autres, contenus dans un 2eme fichier (3 exemples)
  7. Un titre de paragraphe devient marqueur (en utilisant 'split')
  8. Un titre de paragraphe devient marqueur (sans utiliser 'split')
  9. Un champ d'une ligne devient titre de la ligne (sans utiliser 'split')
L'OCCURRENCE D'UN PATTERN
  1. Repeter un nombre de fois (valeur en colonne 2), un pattern situe en colonne 1
  2. Occurrences d'un pattern (syntaxe courte)
  3. Occurrences d'un pattern
  4. Occurrences d'un pattern - precision de sa position (exemple 1)
  5. Occurrences d'un pattern - precision de sa position (exemple 2)
  6. Capturer ou deleter des lignes dont le mot en colonne 1 a une autre occurrence sur la ligne (en BASH et en AWK)
  7. Marquer les numeros des occurrences a partir d'une liste de patterns
  8. Deleter les occurrences repetees dans une colonne, et ne garder que la 1ere
  9. Occurrences d'un caractere dans plusieurs fichiers
  10. Afficher toutes les occurrences d'un titre
ADDITION
  1. Addition d'une constante aux chiffres d'une colonne
LES DOUBLES
  1. Deleter des lignes semblables consecutives
INCREMENTER DES LIGNES CONSECUTIVES DE SYNTAXE IDENTIQUE
  1. Incrementer des lignes consecutives de format identique, le compteur est mis a zero ensuite
JOINDRE
  1. Joindre un signe avec la ligne suivante (exemple 1)
  2. Joindre un signe avec la ligne suivante (exemple 2)
  3. Joindre un signe avec la ligne suivante (exemple 3)(awk + getline)
  4. Joindre un signe au bout de la ligne precedente (exemple 1)
  5. Joindre un signe au bout de la ligne precedente (exemple 2)
  6. Joindre un signe au bout de la ligne precedente sauf si cette derniere se termine par @ (exemple 3)
  7. Un signe en debut de ligne 1, fait joindre la ligne 2 a la suite de la 1
  8. Les lignes qui commencent par un signe collent les suivantes a leur fin si elles ne possedent pas ce signe
COMPARER 2 FICHIERS
  1. Printer les lignes du fichier2 qui manquent dans le fichier1
  2. Comparer 2 fichiers : identiques ou differents
  3. Intersection de 2 fichiers : lignes uniques et communes
DIVERS
  1. Un titre de paragraphe est capture a un pattern
  2. Operations entre lignes 'n+1' et 'n'
  3. Supprimer des caracteres entre 2 bornes connues
  4. Supprimer des lignes doubles

haut

Min et Max d'une colonne


# in.txt
694
1004
438

# methode courte ( min et max )
awk 'min=="" || $1 < min {min=$1}
END {print min}' FS=" " in.txt      # 438

awk 'max=="" || $1 > max {max=$1}
END {print max}' FS=" " in.txt      # 1004

# methode longue ( max )
array=(`cat in.txt`)
max=0
len=${#array[*]}
i=0
while [ $i -lt $len ]
do
val=`echo "${array[$i]}"`
if [ $(echo "$max < $val" | bc) -eq 1 ]
then
max=$val
fi
let i++
done 
echo "max is => $max"     # max is => 1004

haut

Min et Max d'une colonne avec choix des limites de debut de coupe


# in.txt 
70 1001
50 1002
30 1003
20 1005
30 1006
40 1007

# compteur.txt
1001 1003
1005 1007

#!/bin/bash
while read var1 var2
do
if [ -e temp.txt ] ; then rm temp.txt ; fi
   until [ $var1 -gt $var2 ]
   do
   var3=`awk '$2 ~ '$var1' {print $1}' in.txt`
   echo $var3 >> temp.txt
   echo $var3
   
min=`awk 'min=="" || $1 < min {min=$1} END {print min}' temp.txt`
max=`awk 'max=="" || $1 > max {max=$1} END {print max}' temp.txt`

   let var1=var1+1
   done
echo "min= " $min "  ;  max= " $max
done < compteur.txt > temp2.txt

awk '/min/ {print $0}' temp2.txt > temp3.txt
paste compteur.txt temp3.txt

# resultat
1001 1003    min= 30  ;  max= 70
1005 1007    min= 20  ;  max= 40

haut

Cumul d'une colonne en regroupant des patterns semblables (associative array)


# in.txt
100 1001
100 1002
100 1003
101 1004
101 1005

#!/bin/bash
awk '{ arr[$1]+=$2 }
END{ for( i in arr )
{print i, arr[i]}
}' in.txt | sort -n

# resultat
100 3006
101 2009

haut

Cumul d'une colonne avec limite de coupe manuelle


#!/bin/bash

# but du script : cumuler a l'aide d'un compteur.
# La 1ere ligne du compteur (1001 1003) indique
# qu'il y aura cumul de la colonne 1 de 1001 a 1003.

############ parametres:
# fichier depart : in.txt 
#     70 1001
#     50 1002
#     30 1003
#     20 1004
#     30 1005
#     40 1006

# compteur.txt
#     1001 1003
#     1004 1006    # supprimer le dernier retour chariot

IN=in.txt                 # changer ici les noms des fichiers
COMPTEUR=compteur.txt
OUT=out.txt

########### fin des parametres

while read var1 var2
do
sum=0      # desactiver cette ligne pour le cumul de toutes les lignes
   until [ $var1 -gt $var2 ]
   do
   var3=`awk '$2 ~ '$var1' {print $1}' $IN`
   echo $var3
   ((sum+=$var3))
   let var1=var1+1
   done
echo "s= " $sum
done < $COMPTEUR > tmp1.txt

awk '/s=/ {print $2}' tmp1.txt > tmp2.txt
paste $COMPTEUR tmp2.txt > tmp3.txt
awk '{print $1"-"$2," cumul = "$3}' tmp3.txt > $OUT
cat $OUT

# resultat
#     1001-1003  cumul = 150
#     1004-1006  cumul = 90

haut

Cumul d'une colonne avec limite de coupe automatique


#!/bin/bash

#######  parametres  #############
LIMIT=7
IN=stmdepart.txt
OUT=stmresult.txt
###
# stmdepart.txt
#    3
#    2
#    5    # une seule colonne de valeurs (sans compteur)
#    1
#    6
#    4
#    2    # sans retour chariot final

#######  fin des parametres  ############

### script
awk '{print total+=$1}' $IN > inter2.txt
paste $IN inter2.txt > inter3.txt

# si le cumul > $LIMIT
cat inter3.txt | awk '{
# ajouter syntaxe si necessaire :  < '$LIMIT' ? total3 : (total4+=$1) < '$LIMIT' ? total4 : (total5+=$1)    
f[$2] = ($2 < '$LIMIT' ? $2 : (total+=$1) < '$LIMIT' ? total : (total2+=$1) < '$LIMIT' ? total2 : (total3+=$1))
{print f[$2]}
}' > inter4.txt

# mettre les lignes en tableau
awk '{f[NR] = $0}
END {
for (i=1; i<=NR; i++)
if (f[i+1] <= f[i])
{print f[i],"@"}     # ajouter un marqueur
else
{print f[i]}
}' inter4.txt > inter5.txt

# creer un compteur a la repetition d'un pattern
while read line
do echo "$line"
if [[ "$line" =~ "@" ]] ; then echo "------ tape " ; fi
done < inter5.txt | sed -e '1i \------ tape ' | sed '$d' | sed 's/@//g' > inter6.txt 

# habillage final
# marquer les occurrences du pattern "@"  (et effacer les marqueurs inutiles)
awk '/tape/ {i=i+1} {print $0,i}' inter6.txt |
awk '!a[$NF]++ {print $0 ; next} { sub($NF, "") ; print }' > $OUT ; cat $OUT

# resultat
#     --- tape 1
#     3
#     5
#     --- tape 2
#     5
#     6
#     --- tape 3
#     6
#     --- tape 4
#     4
#     6

haut

Afficher les elements uniques d'une colonne


# in.txt
100
100
100
101
101
102
102

awk '{ arr[$1]++ }
END {
for (i in arr) print i}
' in.txt

# resultat
100
101
102

haut

Cumul d'une colonne avec decoupe a une limite definie - METHODE 1


#!/bin/bash

# SCRIPT 1 - METHODE 1
# avantages : court - habillage a l'exterieur de la boucle
# avantages : 1 seule boucle UNTIL 

########## parametres

LIMIT=100
NBOFTAPES=10
ORIG=0-start.txt
OUTMETHODE1=1-result-1A-$LIMIT.txt
SLEEP=0

########### fin des parametres

# ORIG
# 10001 30
# 10002 2
# 10003 30
# 10004 30
# 10005 14
# 10006 30
# 10007 30
# 10008 30
# 10009 17
# 10010 30
# 10011 30

############### ZONE ARRONDIR : pour arrondir des valeurs
# arrondir 0.3 en 0   ///   0.7 en 1 :

#    ATTENTION CHANGER LA VIRGULE EN POINT

# script pour arrondir
# while read col1 col2
# do
# awk -v var2="$col2" -v var1="$col1" 'BEGIN { rounded = sprintf("%.0f", var2) ; print var1,rounded }'
# done < fichier entree > 0-start.txt

# exit   # pour verifier si le fichier ARRONDI a bien ete fait

################## fin de la zone ARRONDIR

# deleter les anciens resultats
rm 1a-in*
rm 1a-tape*

# etat apres la suppression des anciens resultats
echo "apres suppression : nb de 1a-in* : `ls 1a-in* | wc -l`"
echo "apres suppression : nb de 1a-tape* : `ls 1a-tape* | wc -l`"

# exit    # activer pour deleter uniquement (sans faire marcher le script)

echo "les anciens resultats sont deletes"
sleep $SLEEP
##################

# sauvegarde de l'original
cp $ORIG 1a-in1.txt

# boucle sur les tapes
n=1
until [[ $n -gt "$NBOFTAPES" ]]
do

awk '{print $1,$2,x+=$2}' 1a-in$n.txt > 1a-inter$n.txt

# marquer les lignes dont le cumul est < $LIMIT
awk '{
if($3 < '$LIMIT' ) {print $0" @"}
else
{print}
}' 1a-inter$n.txt | grep "@" > 1a-tape$n.txt

# retirer de l'original les lignes de cette tape traitee
awk 'BEGIN{FS=" "}
FNR==NR {ex[$1]; next}
!($1 in ex)
' 1a-tape$n.txt 1a-in$n.txt > 1a-in`expr $n + 1`.txt

######### test si arret
   # tester si fichier 1f-in`expr $counter + 1`.txt   est vide ou non     
   test -s 1a-in`expr $n + 1`.txt      #  Check if file is nonzero size

   var1=`echo $?`   # code retour = 0 -> commande bien executee  -> Check if file is nonzero size
   # echo $var1

   if [ "$var1" -eq "0" ] ; then
   echo "code retour=0 - bien execute - file is nonzero size - ok : 1a-in`expr $n + 1`.txt"  
   echo "----------------"
   else
   echo "code retour=1 - mal execute - file is zero size - pas de 1a-in`expr $n + 1`.txt - arret" ; break
   fi

let n=n+1
done      # fin de la boucle sur les tapes

##############
# habillage
# renommer les fichiers tapes avec 2 digits
for i in `seq 1 9`
do
mv 1a-tape$i.txt 1a-tape0$i.txt
done  2>/dev/null

grep -H "." 1a-tape* | sed 's/@//g' | sed 's/.txt:/ : /g' | sed 's/4-//g' | 
        awk 'BEGIN{OFS=FS=" "}
        {if ($1 != var )
        {var=$1;e="@"
        print $0,e}
        else
        print $0
        }' | sed -e '/@/i\----------------' | sed 's/@//g' | sed 's/1a-//g' > $OUTMETHODE1

echo "resultat ds $OUT : "
cat $OUTMETHODE1

echo "------------------"
echo "---> liste des fichiers generes par ce script"
echo " nb de 1a-in* : `ls 1a-in* | wc -l`"
echo " nb de 1a-tape* : `ls 1a-tape* | wc -l`"
echo "------------------"
echo "total des 1a : `ls 1a* | wc -l`"

echo "---> la fin du script est a l'exterieur de la boucle"
echo "donc un autre script peut etre execute a sa suite"

# resultat
# ----------------
# tape01 : 10001 30 30  
# tape01 : 10002 2 32 
# tape01 : 10003 30 62 
# tape01 : 10004 30 92 
# ----------------
# tape02 : 10005 14 14  
# tape02 : 10006 30 44 
# tape02 : 10007 30 74 
# ----------------
# tape03 : 10008 30 30  
# tape03 : 10009 17 47 
# tape03 : 10010 30 77 
# ----------------
# tape04 : 10011 30 30    

haut

Cumul d'une colonne avec decoupe a une limite definie - METHODE 1B


#!/bin/bash

# SCRIPT 1 - METHODE 1B
# avantages : court - methode de la coupe du dernier cumul jusqu'a une limite
# avantages : on peut executer un autre script a sa suite 

ORIG=0-start.txt
LIMIT=40
SLEEP=0
NBTAPES=10
OUT=1-result-$LIMIT.txt

#####################
# 0-start.txt
# 1001 1
# 2001 2
# 3001 3
# 4001 4
# 5001 5
# 6001 6
# 7001 7
# 8001 8
# 9001 9
# 10001 10
# 11001 11
# 12001 12
# 13001 13
# 14001 14
# 15001 15
# 16001 16
# 17001 17
# 18001 18
# 19001 19
# 20001 20

######################

# deleter les anciens resultats
rm 2-shift*
rm 3-shift*
rm inter*
rm 1-cat-tapes.txt
sleep $SLEEP

# copier l'original pour le 1er fichier
cp $ORIG 0-startcopie.txt
awk '{print $2}' 0-startcopie.txt > 1-shift1.txt

#######################

j=1
until [[ $j -gt $NBTAPES ]]   # boucle sur les tapes
do
echo
echo "@@@@ nouvelle tape"
echo "   numero de tape : $j"

   ######  test du "non zero file size"
   test -s 1-shift$j.txt       #  Check if file is nonzero size

   var3=`echo $?`   # code retour = 0 -> commande bien executee  
   # echo $var3

   if [ "$var3" -eq "0" ] ; then
   echo "code retour=0 - bien execute - fichier depart n'est pas vide"  
   else
   echo "  ARRET - mal execute - fichier depart vide"
   break
   fi
   ######  fin du test du "non zero file size"

        # nb lignes
        NBLINES=`sed -n -e '$=' 1-shift$j.txt`
        NBLINES2=`expr $NBLINES + 1`
        echo "nb de lignes du fichier a traiter : $NBLINES2"
        sleep $SLEEP

   n=$NBLINES2
   until [[ $n -lt 1 ]]   # boucle sur les lignes cumulees
   do

   awk '{print x+=$0}' 1-shift$j.txt > 2-shift$j.txt

   var1=`sed ''$n','$NBLINES'd' 2-shift$j.txt | tail -1`
   echo "valeur de n : $n  - limite = $LIMIT -   dernier cumul : $var1"
   
   # si le cumul est inferieur a $LIMIT : pause
   if [[ $var1 -lt $LIMIT ]] ; then sed ''$n','$NBLINES'd' 2-shift$j.txt > 3-shift$j.txt 

   # nb lignes de 3-shift$j.txt
   var2=`sed -n -e '$=' 3-shift$j.txt`
   echo "  ---> nb lignes de la tape : 3-shift$j.txt : $var2"
   echo "  ---> fin de l'ecriture ds la tape : $j"

   # deleter les lignes traites : $var2 lignes de 1-shift$j.txt
   sed '1,'$var2'd' 1-shift$j.txt > 1-shift`expr $j + 1`.txt

   break
   fi

   sleep $SLEEP

   let n=n-1
   done         # fin de la boucle sur les lignes cumulees

let j=j+1
done        # fin de la boucle sur les tapes

###############

echo "##################  sortie des 2 boucles"

# assembler les tapes
cat 3-shift* > 1-cat-tapes.txt
paste $ORIG 1-cat-tapes.txt | sed 's/\t/  /g' > inter1.txt 

# ajouter trait si colonne 2 = colonne 3
awk '{if($2 == $3) {print "------------------\n"$1"  "$2"  "$3}
else
print
}' inter1.txt > inter2.txt

# ajouter l'occurence des traits
awk '{
if($1 ~ /^------------------/) {i=i+1 ; print $0" tape "i}
else
{print}
}' inter2.txt > $OUT


# resultat
# ------------------ tape 1
# 1001  1  1
# 2001 2  3
# 3001 3  6
# 4001 4  10
# 5001 5  15
# 6001 6  21
# 7001 7  28
# 8001 8  36
# ------------------ tape 2
# 9001  9  9
# 10001 10  19
# 11001 11  30
# ------------------ tape 3
# 12001  12  12
# 13001 13  25
# 14001 14  39
# ------------------ tape 4
# 15001  15  15
# 16001 16  31
# ------------------ tape 5
# 17001  17  17
# 18001 18  35
# ------------------ tape 6
# 19001  19  19
# 20001 20  39

haut

Cumul d'une colonne avec decoupe a une limite definie - METHODE 2


#!/bin/bash

# SCRIPT 2 - METHODE 2
# Cumul d'une colonne avec decoupe a une limite definie (utilise csplit)

# utilise csplit

########################  parametres

ORIG=0-start.txt
LIMIT=100
NBOFTAPES=10
OUTMETHODE2=1-result-2B-$LIMIT.txt
SLEEP=0

########################  fin des parametres

# ORIG
# 10001 30
# 10002 2
# 10003 30
# 10004 30
# 10005 14
# 10006 30
# 10007 30
# 10008 30
# 10009 17
# 10010 30
# 10011 30

############### ZONE ARRONDIR : pour arrondir des valeurs
# arrondir 0.3 en 0   ///   0.7 en 1 :

#    ATTENTION CHANGER LA VIRGULE EN POINT

# script pour arrondir
# while read col1 col2
# do
# awk -v var2="$col2" -v var1="$col1" 'BEGIN { rounded = sprintf("%.0f", var2) ; print var1,rounded }'
# done < fichier entree > 0-start.txt

# exit   # pour verifier si le fichier ARRONDI a bien ete fait

################## fin de la zone ARRONDIR

# deleter les anciens resultats
rm 1b-y*
rm 1b-z*-file*
rm 1b-tape-*.txt
rm 1b-in-*.txt

# etat apres la suppression des anciens resultats

echo "apres suppression : nb de 1b-in-* : `ls 1b-in* | wc -l`"          
echo "apres suppression : nb de 1b-tape- : `ls 1b-tape-* | wc -l`"      
echo "apres suppression : nb de 1b-y : `ls 1b-y* | wc -l`"              
echo "apres suppression : nb de 1b-z*-file* : `ls 1b-z*-file* | wc -l`"    
                                                                    
# exit    # activer pour deleter uniquement (sans faire marcher le script)

echo "les anciens resultats sont deletes"
sleep $SLEEP

########################
# marquer la fin du fichier a lire
sed -e '$a \END' $ORIG > 1b-in-1.txt    # ne pas changer la destination

# nb lignes du fichier original
LINES=`sed -n -e '$=' $ORIG`

# boucle sur les tapes
tapecount=1
until [[ $tapecount -gt $NBOFTAPES ]]
do
echo "tapecount= $tapecount"

   # boucle sur les lignes
   n=1
   until [[ $n -gt $LINES ]]
   do
   echo "n= $n"
   csplit -k --prefix=1b-z$n-file 1b-in-$tapecount.txt $n {*}  2>/dev/null

   grep "." 1b-z$n-file00 > 1b-y$n
   echo

   var1=`awk '{print x+=$2}' 1b-y$n | tail -1`
   varend=`while read line;do echo $line|grep "END";done < 1b-y$n`
   echo "varend=$varend"

   echo "cumul de `expr $n - 1` lignes : $var1"
   before=`expr $n - 1` ; echo "before= $before"     # pour valider le contenu de la tape
   before2=`expr $n - 2` ; echo "before2= $before2"    # pour un nouveau fichier entree
     if [[ $var1 -gt $LIMIT ]] ; then `awk '{print $0,x+=$2}' 1b-y$before > 1b-tape-$tapecount.txt` ; 
        sed -e '1,'$before2'd' 1b-in-$tapecount.txt > 1b-in-`expr $tapecount + 1`.txt ; break ; fi

     if [[ $varend == "END" ]] ; then `awk '{print $0,x+=$2}' 1b-y$before > 1b-tape-$tapecount.txt` ; 

        # habillage : separer les tapes par un trait
        grep -H "." 1b-tape* | sed 's/.txt:/ : /g' | 
        awk 'BEGIN{OFS=FS=" "}
        {if ($1 != var )
        {var=$1;e="@"
        print $0,e}
        else
        print $0
        }' | sed -e '/@/i\----------------' | sed 's/@//g' | sed 's/1b-//g' > $OUTMETHODE2

        cat $OUTMETHODE2

          echo "------------------"
          echo "----> etat avant de deleter les anciens resultats"
          echo "nb de 1b-in-* : `ls 1b-in* | wc -l`"          
          echo "nb de 1b-tape- : `ls 1b-tape-* | wc -l`"      
          echo "nb de 1b-y : `ls 1b-y* | wc -l`"              
          echo "nb de 1b-z*-file* : `ls 1b-z*-file* | wc -l`"    
          echo "total des 1b = `ls 1b* | wc -l`"
     exit ; fi

   echo "----------------"
   sleep $SLEEP
   let n=n+1
   done    # fin de la boucle sur les lignes

let tapecount=tapecount+1
done    # fin de la boucle sur les tapes

########################

# resultat
# ----------------
# tape-1 : 10001 30 30 
# tape-1 : 10002 2 32
# tape-1 : 10003 30 62
# tape-1 : 10004 30 92
# -------------
# tape-2 : 10005 14 14 
# tape-2 : 10006 30 44
# tape-2 : 10007 30 74
# -------------
# tape-3 : 10008 30 30 
# tape-3 : 10009 17 47
# tape-3 : 10010 30 77
# -------------
# tape-4 : 10011 30 30 

haut

Cumul d'une colonne avec decoupe a une limite definie - METHODE 3


#!/bin/bash

# SCRIPT 3 - METHODE 3
# Cumul d'une colonne avec decoupe a une limite definie
 
# but du script : des que le cumul de la colonne 2 atteint $LIMIT, il est envoye dans un fichier 'tape'

# les fichiers "1c-out" sont les cumuls

########################  parametres

# ATTENTION LE FICHIER ENTREE DOIT AVOIR DES VALEURS ARRONDIES (sans . ni ,)
ORIG=0-start.txt   # fournir ce fichier

LIMIT=100
NBOFTAPES=10   # estimation nombre de tapes
SLEEP=1

PRINTF=50    # regle le nombre de digits necessaires a la colonne 1 pour l'affichage du resultat final

# resultat
OUTMETHODE3=1-result-3C-$LIMIT.txt

###########################  fin des parametres


# fichier entree arrondi
# 10001 30
# 10002 2
# 10003 30
# 10004 30
# 10005 14
# 10006 30
# 10007 30
# 10008 30
# 10009 17
# 10010 30
# 10011 30

############### ZONE ARRONDIR : pour arrondir des valeurs
# arrondir 0.3 en 0   ///   0.7 en 1 :

#    ATTENTION CHANGER LA VIRGULE EN POINT

# script pour arrondir
#   while read col1 col2
#   do
#   awk -v var2="$col2" -v var1="$col1" 'BEGIN { rounded = sprintf("%.0f", var2) ; print var1,rounded }'
#   done < fichier-entree > fichier-sortie

#  exit
################## fin de la zone ARRONDIR

# effacer les anciens resultats de la boucle
rm 1c-cat-tape*
rm 1c-in*
rm 1c-inter*
rm 1c-out*
rm 1c-start-met*
rm 1c-tape*    2>/dev/null

# etat apres la suppression des anciens resultats
echo "apres suppression : nb de 1c-cat-tape* : `ls 1c-cat-tape* | wc -l`" 
echo "apres suppression : nb de 1c-in*  : `ls 1c-in*  | wc -l`" 
echo "apres suppression : nb de 1c-out* : `ls 1c-out* | wc -l`" 
echo "apres suppression : nb de 1c-start-met* : `ls 1c-start-met* | wc -l`" 
echo "apres suppression : nb de 1c-tape* : `ls 1c-tape* | wc -l`" 

# exit    # activer pour deleter uniquement (sans faire marcher le script)

echo "les anciens resultats sont deletes"
sleep $SLEEP

##########################
# retirer les \r et lignes blanches
sed 's/\r//g' $ORIG | grep "." > 1c-start-met5-inter.txt

# ne pas desactiver cette 2eme copie
cp 1c-start-met5-inter.txt 1c-in1.txt     
echo "###################"
echo "ok le fichier entree est pret pour la boucle until : 1c-in1.txt" 
sleep $SLEEP

# nb de lignes
echo "nb lignes du fichier entree : `sed -n -e '$=' 1c-in1.txt`"
sleep $SLEEP

# marquer l'arret sur la derniere valeur de la colonne 1 de ORIG
STOP=`sed -n '$p' 1c-in1.txt | awk '{print $1}'`

echo "arret sur STOP : $STOP"
sleep $SLEEP

############### boucle sur les tapes
counter=1
until [ $counter -gt $NBOFTAPES ]
do

echo "##### start tape nb : $counter/$NBOFTAPES"
sleep $SLEEP

awk '{print $1,x+=$2}' 1c-in$counter.txt > 1c-out$counter.txt

    ##########  boucle sur les lignes cumulees
    count=1
    while read col1 col2
    do
    if [[ `echo $col2` -lt $LIMIT ]] ; then echo $col1 $col2  ; echo $col1 $col2 > 1c-inter$count 
    else
    cat 1c-inter* > 1c-tape$counter ; newcount=`expr $count - 1` ; echo " ---> tape nb  $counter a pris : $newcount idents "
        
    sed '1,'$newcount'd' 1c-in$counter.txt > 1c-in`expr $counter + 1`.txt  ; rm 1c-inter* ; break   
    fi

       if [[ `echo $col1` -eq $STOP ]] ; then cat 1c-inter* > 1c-tape$counter ; echo " ---> tape nb  $counter a pris : $count idents" ; 
            # renommer les fichiers tapes
            for i in `seq 1 9`
            do
            mv 1c-tape$i 1c-tape00$i
            done

            for i in `seq 10 99`
            do
            mv 1c-tape$i 1c-tape0$i
            done

                grep -H "." 1c-tape* | sed 's/:/ /g' > 1c-cat-tape1.txt
              
                # la colonne 2 doit avoir au moins 4 digits
                awk '{
                if(length($2) == 1)
                {print $1" 000"$2,$3}

                if(length($2) == 2)
                {print $1" 00"$2,$3}

                if(length($2) == 3)
                {print $1" 0"$2,$3}

                if(length($2) == 4)
                {print $1,$2,$3}

                if(length($2) == 5)
                {print $1,$2,$3}

                }' 1c-cat-tape1.txt | sort > 1c-cat-tape1b.txt

                awk '{print $1,$2"@",$3"%"}' 1c-cat-tape1b.txt > 1c-cat-tape1c.txt

                # regrouper
                awk 'BEGIN {FS=OFS=" "}
                !a[$1] {a[$1] = $0;next}
                {a[$1] = a[$1] " " $2 " " $3 " " $4 " " $5 " " $6 " " $7 " " $8 " " $9 " " $10}
                END {for(i in a) {print a[i]}
                }' 1c-cat-tape1c.txt | sort > 1c-cat-tape2.txt

                # habillage
                sed 's/[0-9]*%//g' 1c-cat-tape2.txt | sed 's/@[ ]*/-/g' | sed 's/ / : /g' > 1c-cat-tape3a.txt
                sed 's/[0-9]*@//g' 1c-cat-tape2.txt | sed 's/%[ ]*/ /g' | awk '{print $1" : "$NF"  (GB)"}' > 1c-cat-tape3b.txt
                paste 1c-cat-tape3a.txt 1c-cat-tape3b.txt | sed 's/\t/     % /g' | 
                 awk -F"%" '{printf ("%-'$PRINTF's %-'$PRINTF's\n",$1,$2)}' | sed 's/[ ]*$//g' | sed 's/1c-//g' > $OUTMETHODE3

                echo
                echo "##################"
                echo " ---> resultat dans $OUTMETHODE3"
                cat $OUTMETHODE3
                
                 echo "------------------"
                 echo "---> etat avant de deleter les anciens resultats"
                 echo "nb de 1c-cat-tape* : `ls 1c-cat-tape* | wc -l`" 
                 echo "nb de 1c-in*  : `ls 1c-in*  | wc -l`" 
                 echo "nb de 1c-out* : `ls 1c-out* | wc -l`" 
                 echo "nb de 1c-start-met* : `ls 1c-start-met* | wc -l`" 
                 echo "nb de 1c-tape* : `ls 1c-tape* | wc -l`" 
                 echo "------------------"
                 echo "total des 1c : `ls 1c* | wc -l`"
                                
       exit   
       fi
    # sleep $SLEEP
    let count=count+1
    done < 1c-out$counter.txt 

    ##########  fin de la boucle sur les lignes cumulees

let counter=counter+1
done    2>/dev/null                                   

##########  fin de la boucle sur les tapes

# resultat
# tape001 : 10001-10002-10003-10004-                  tape001 : 92  (GB)
# tape002 : 10005-10006-10007-                        tape002 : 74  (GB)
# tape003 : 10008-10009-10010-                        tape003 : 77  (GB)
# tape004 : 10011-                                    tape004 : 30  (GB)

haut

Cumul d'une colonne avec decoupe a une limite definie - METHODE 4


#!/bin/bash

# SCRIPT 4 - METHODE 4
# Cumul d'une colonne avec decoupe a une limite definie

# but du script : coller la syntaxe "chiffre+chiffre" de la ligne N-1 a ligne N
# et faire l'addition

########################  parametres

ORIG=0-start.txt   # fichier entree contenant 2 colonnes

LIMIT=100
NBOFTAPES=10   # estimation nombre de tapes

SLEEP=1

OUTMETHODE4=1-result-4D-$LIMIT.txt   

###########################  fin des parametres

# fichier entree arrondi
# 10001 30
# 10002 2
# 10003 30
# 10004 30
# 10005 14
# 10006 30
# 10007 30
# 10008 30
# 10009 17
# 10010 30
# 10011 30

############### ZONE ARRONDIR : pour arrondir des valeurs
# arrondir 0.3 en 0   ///   0.7 en 1 :

#    ATTENTION CHANGER LA VIRGULE EN POINT

# script pour arrondir
#   while read col1 col2
#   do
#   awk -v AR2="$col2" -v AR1="$col1" 'BEGIN { rounded = sprintf("%.0f", AR2) ; print AR1,rounded }'
#   done < fichier-entree > fichier-sortie

#  exit
################## fin de la zone ARRONDIR

# effacer les anciens resultats
rm 1d-in*.txt
rm 1d-tape*  2>/dev/null
rm 1d-z1d-tape*
rm 1d-cat-tape*
rm 1d-start-met*
rm 1d-temp*

# etat apres la suppression des anciens resultats
echo "apres suppression : nb de 1d-cat-tape* : `ls 1d-cat-tape* | wc -l`" 
echo "apres suppression : nb de 1d-in* : `ls 1d-in* | wc -l`" 
echo "apres suppression : nb de 1d-start-met* : `ls 1d-start-met* | wc -l`"
echo "apres suppression : nb de 1d-tape* : `ls 1d-tape* | wc -l`" 
echo "apres suppression : nb de 1d-temp* : `ls 1d-temp* | wc -l`"
echo "apres suppression : nb de 1d-z1d-tape* : `ls 1d-z1d-tape* | wc -l`" 

# exit    # activer pour deleter uniquement (sans faire marcher le script)

echo "les anciens resultats sont deletes"
sleep $SLEEP

#######################
# retirer les \r et lignes blanches
sed 's/\r//g' $ORIG | grep "." > 1d-start-met4-inter.txt

# copier avec un nom de fichier adapte a la boucle until
cp 1d-start-met4-inter.txt 1d-in1.txt


################## boucle sur les tapes
counter=1
until [[ "$counter" -gt $NBOFTAPES ]]
do
echo "##########"

# code retour de la taille nulle 
test -s 1d-in$counter.txt
var2=`echo $?`
if [ "$var2" -eq "0" ] ; then
echo "code retour=0 - ok le fichier 1d-in$counter.txt a une taille non nulle"
else
echo "code retour=1 - le fichier 1d-in$counter.txt a une taille nulle ---> arret" ; break
fi

total=`sed -n '$=' 1d-in$counter.txt`   
echo "nb lignes de 1d-in$counter.txt : $total"

rm 1d-tempA  2>/dev/null

     # boucle sur les lignes du fichier
     N=1
     until [[ "$N" -gt "$total" ]]
     do
     OPA=$N
     OPB=`expr $N - 1`
     N=`expr $N + 1`

     VALA=`sed -n "$OPA p" 1d-in$counter.txt | awk '{print $2}'`
     VALB=`sed -n "$OPB p" 1d-tempA | awk '{print $1}'`

     line=`echo $VALA+$VALB`
     echo $line  >> 1d-tempA

     add=`cat 1d-tempA | tail -1 | sed 's/+/ + /g'`
     echo $add

     varA=`eval $(echo "expr" $add "0")`
     # echo $varA

     if [[ $varA -lt $LIMIT ]] ; then echo $varA >> 1d-tape$counter
     else
     break
     fi
     
     done
     # fin de la boucle sur les lignes

# creer un nouveau fichier entree pour un nouveau cumul
varB=`cat 1d-tape$counter | wc -l` ; # echo $varB
sed '1,'$varB'd' 1d-in$counter.txt > 1d-in`expr $counter + 1`.txt

let counter=counter+1
done    2>/dev/null      #  fin de la boucle sur les tapes

############################
##############  habillage
# renommer les fichiers tapes avec 3 digits
for i in `seq 1 9`
do
mv 1d-tape$i 1d-tape00$i
done   2>/dev/null

for i in `seq 10 99`
do
mv 1d-tape$i 1d-tape0$i
done     2>/dev/null

###############
# ecrire nom du fichier devant lignes
for i in 1d-tape*
do
seq=`ls $i`
awk '{print seq,$0}' seq=${seq} $i  > 1d-z$i  # ne pas oublier d'ajouter 1d-z
done     2>/dev/null

# rassembler les tapes
cat 1d-z1d-tape* > 1d-cat-tape1.txt

awk '{print $1}' $ORIG > 1d-tempcol1.txt
paste 1d-tempcol1.txt 1d-cat-tape1.txt > 1d-cat-tape2.txt
sed 's/\t/ /g' 1d-cat-tape2.txt | awk '{print $2,$1,$3}' > 1d-cat-tape3.txt

# ajouter 1 trait
awk 'BEGIN{OFS=FS=" "}
{if ($1 != var )
   {var=$1;e="@"
   print $0,e}
   else
   print $0
}' 1d-cat-tape3.txt | sed -e '/@/i\----------------' | sed 's/@//g' | sed 's/1d-//g' > $OUTMETHODE4

echo " ---> resultat dans $OUTMETHODE4" 
cat $OUTMETHODE4

#####################
echo "------------------"
echo "---> etat avant de deleter les anciens resultats"
echo "nb de 1d-cat-tape* : `ls 1d-cat-tape* | wc -l`" 
echo "nb de 1d-in* : `ls 1d-in* | wc -l`" 
echo "nb de 1d-start-met* : `ls 1d-start-met* | wc -l`"
echo "nb de 1d-tape* : `ls 1d-tape* | wc -l`" 
echo "nb de 1d-temp* : `ls 1d-temp* | wc -l`"
echo "nb de 1d-z1d-tape* : `ls 1d-z1d-tape* | wc -l`" 
echo "------------------"
echo "total des 1d : `ls 1d* | wc -l`"

# resultat
# ----------------
# tape001 10001 30 
# tape001 10002 32
# tape001 10003 62
# tape001 10004 92
# ----------------
# tape002 10005 14 
# tape002 10006 44
# tape002 10007 74
# ----------------
# tape003 10008 30 
# tape003 10009 47
# tape003 10010 77
# ----------------
# tape004 10011 30 

haut

Cumul d'une colonne avec decoupe a une limite definie - METHODE 5


#!/bin/bash

# SCRIPT 3 - METHODE 3
# but du script : si le cumul atteint 1 limite
# il est ecrit dans un fichier 'tape'
# utilise le tableau de la ligne f[NR]

###################### parametres
ORIG=0-start.txt

LIMIT=100
NBOFTAPES=10  
SLEEP=1

# resultat
OUTMETHODE5=1-result-5E-$LIMIT.txt

#################### fin des parametres

# fichier entree arrondi
# 10001 30
# 10002 2
# 10003 30
# 10004 30
# 10005 14
# 10006 30
# 10007 30
# 10008 30
# 10009 17
# 10010 30
# 10011 30

############### ZONE ARRONDIR : pour arrondir des valeurs
# arrondir 0.3 en 0   ///   0.7 en 1 :

#    ATTENTION CHANGER LA VIRGULE EN POINT

# script pour arrondir
#   while read col1 col2
#   do
#   awk -v var2="$col2" -v var1="$col1" 'BEGIN { rounded = sprintf("%.0f", var2) ; print var1,rounded }'
#   done < fichier-entree > fichier-sortie

#  exit
################## fin de la zone ARRONDIR

# effacer les anciens resultats de la boucle
rm 1e-in*
rm 1e-incumul*
rm 1e-nbligne*
rm 1e-tape-all*
rm 1e-tape-paste-all*
rm 1e-tape*
rm 1e-z1e-tape*
rm 1e-cat-tape*
rm 1e-start-met*

# etat apres la suppression des anciens resultats
echo "apres suppression : nb de 1e-in* : `ls 1e-in* | wc -l`"              
echo "apres suppression : nb de 1e-nbligne* : `ls 1e-nbligne* | wc -l`"      
echo "apres suppression : nb de 1e-tape* : `ls 1e-tape* | wc -l`"          
echo "apres suppression : nb de 1e-z1e-tape* : `ls 1e-z1e-tape* | wc -l`"             
echo "apres suppression : nb de 1e-cat-tape* : `ls 1e-cat-tape* | wc -l`"          
echo "apres suppression : nb de 1e-start-met* : `ls 1e-start-met* | wc -l`"          
                                                                      
# exit    # activer pour deleter uniquement (sans faire marcher le script)

echo "les anciens resultats sont deletes"
sleep $SLEEP

#######################
# retirer les lignes vides
grep -v "^$" $ORIG > 1e-start-met2-inter.txt

# garder l'original
cp 1e-start-met2-inter.txt 1e-in1.txt
echo "###################"
echo "ok le fichier 'start' est pret pour la boucle until : 1e-in1.txt" 
sleep $SLEEP

############### boucle sur les tapes
counter=1
until [[ $counter -gt $NBOFTAPES ]]
do
   echo "boucle $counter"

   # nb lignes
   sed -n -e '$=' 1e-in$counter.txt > 1e-nbligne$counter
   echo "nb de lignes restant pour faire un nouveau cumul : $(cat 1e-nbligne$counter)"

   # tester si le fichier est de taille non nulle
   test -s 1e-nbligne$counter
   verif=`echo $?`
   if [ "$verif" -eq "0" ] ; then
   echo "code retour=$verif - bien execute - fichier taille non nulle"
   else
   echo "code retour=$verif - mauvais - fichier taille nulle" ; break
   fi

   # la 3eme colonne est le cumul
   awk '
     f[NR]=$0 
     g[NR]=$2
   END { for (i=1;i<=NR;i++) 
   print f[i],x+=g[i] }
   ' 1e-in$counter.txt | tail -$(cat 1e-nbligne$counter) > 1e-incumul$counter

   # arret si cumul > $LIMIT --> creation de la tape
   awk '
    f[NR]=$1 
     g[NR]=($3 < '$LIMIT' ? $3 : "@")
   END { for (i=1;i<=NR;i++) 
   print f[i],g[i] }
   ' 1e-incumul$counter | tail -$(cat 1e-nbligne$counter) | grep -v "@" > 1e-tape$counter.txt

   # all = tape + @
   awk '
     f[NR]=$1 
     g[NR]=($3 < '$LIMIT' ? $3 : "@")
   END { for (i=1;i<=NR;i++) 
   print f[i],g[i] }
   ' 1e-incumul$counter | tail -$(cat 1e-nbligne$counter) > 1e-tape-all$counter

   # paste 1e-in1.txt all
   paste 1e-in$counter.txt 1e-tape-all$counter > 1e-tape-paste-all$counter
   grep "@" 1e-tape-paste-all$counter | awk '{print $1,$2}' > 1e-in`expr $counter + 1`.txt 

   echo "-----"
let counter=counter+1
done

##################  fin de la boucle sur les tapes

# habillage
# renommer les fichiers tapes avec 3 digits
for i in `seq 1 9`
do
mv 1e-tape$i.txt 1e-tape00$i.txt
done  2>/dev/null

for i in `seq 10 99`
do
mv 1e-tape$i.txt 1e-tape0$i.txt
done  2>/dev/null

#################

# ecrire le nom du fichier devant chaque ligne
# cut -c3-9      # <-- attention changer si pas bon
# cut -c4-10

for i in 1e-tape*.txt
do
seq=`ls $i|cut -c4-10`
awk '{print seq,$0}' seq=${seq} $i > 1e-z$i  # ne pas oublier d'ajouter 1e-z
done

cat 1e-z1e-tape*.txt > 1e-cat-tape1.txt

##################

# separer les tapes par un trait
awk 'BEGIN{OFS=FS=" "}
{if ($1 != var )
   {var=$1;e="@"
   print $0,e}
   else
   print $0
}' 1e-cat-tape1.txt | sed -e '/@/i\----------------' | sed 's/@//g' > $OUTMETHODE5

echo "##################"
echo " ---> resultat dans $OUTMETHODE5" 
cat $OUTMETHODE5

#####################
echo "------------------"
echo "---> etat avant de deleter les anciens resultats"
echo "nb de 1e-in* : `ls 1e-in* | wc -l`"              
echo "nb de 1e-nbligne* : `ls 1e-nbligne* | wc -l`"      
echo "nb de 1e-tape* : `ls 1e-tape* | wc -l`"          
echo "nb de 1e-z1e-tape* : `ls 1e-z1e-tape* | wc -l`"             
echo "nb de 1e-cat-tape* : `ls 1e-cat-tape* | wc -l`"          
echo "nb de 1e-start-met* : `ls 1e-start-met* | wc -l`"          
echo "------------------"
echo "total des 1e : `ls 1e* | wc -l`"

# resultat
# ----------------
# tape001 10001 30 
# tape001 10002 32
# tape001 10003 62
# tape001 10004 92
# ----------------
# tape002 10005 14 
# tape002 10006 44
# tape002 10007 74
# ----------------
# tape003 10008 30 
# tape003 10009 47
# tape003 10010 77
# ----------------
# tape004 10011 30 

haut

Cumul d'une colonne avec decoupe a une limite definie - METHODE 6


#!/bin/bash

# SCRIPT 6 - METHODE 6
# Cumul d'une colonne avec decoupe a une limite definie
 
# but du script : des que le cumul de la colonne 2 atteint $LIMIT, il est envoye dans un fichier 'tape'

# les fichiers "out" sont les cumuls

########################  parametres

ORIG=0-start.txt  

LIMIT=100
NBOFTAPES=10
SLEEP=2

OUTMETHODE6=1-result-6F-$LIMIT.txt

#######################  fin des parametres

# ORIG
# 10001 30
# 10002 2
# 10003 30
# 10004 30
# 10005 14
# 10006 30
# 10007 30
# 10008 30
# 10009 17
# 10010 30
# 10011 30

############### ZONE ARRONDIR : pour arrondir des valeurs
# arrondir 0.3 en 0   ///   0.7 en 1 :

#    ATTENTION CHANGER LA VIRGULE EN POINT

# script pour arrondir
#   while read col1 col2
#   do
#   awk -v var2="$col2" -v var1="$col1" 'BEGIN { rounded = sprintf("%.0f", var2) ; print var1,rounded }'
#   done < fichier-entree > fichier-sortie

#  exit
################## fin de la zone ARRONDIR

# exit    # activer pour connaitre l'etat avant la suppression

# deleter les resultats precedents
rm 1f-in*.txt
rm 1f-inter*.txt
rm 1f-pretape*
rm 1f-tape*
rm 1f-cattapes*.txt
rm 1f-start-met*.txt

# etat apres la suppression des anciens resultats
echo "apres suppression : nb de 1f-cattapes* : `ls 1f-cattapes* | wc -l`"          
echo "apres suppression : nb de 1f-in* : `ls 1f-in* | wc -l`"              
echo "apres suppression : nb de 1f-pretape* : `ls 1f-pretape | wc -l`"      
echo "apres suppression : nb de 1f-start-met* : `ls 1f-start-met* | wc -l`"          
echo "apres suppression : nb de 1f-tape* : `ls 1f-tape* | wc -l`"             
                                                                      
# exit    # activer pour deleter uniquement (sans faire marcher le script)

echo "les anciens resultats sont deletes"
sleep $SLEEP

#########################
# retirer le dernier retour chariot
sed 's/\r//g' $ORIG | grep "." > 1f-start-met1-inter.txt

# inverser le fichier (la 1ere ligne devient derniere)
awk '{ arr[NR]=$0 }
END {
for (i=NR; i>=1; i--)
print arr[i]
}' 1f-start-met1-inter.txt | sed 's/\r//g' > 1f-in1.txt    # cette sortie est codee en dur (ne pas changer)


############## boucle sur les tapes

COUNTTAPES=1
until [[ "$COUNTTAPES" -gt "$NBOFTAPES" ]]
do
echo "--> counttapes=$COUNTTAPES"

         ##### test sur existence de  1f-in$COUNTTAPES.txt
         test -e 1f-in$COUNTTAPES.txt
         check=`echo $?` ; echo "code retour = $check"
         if [[ "$check" -eq "0" ]] ; then echo "ok fichier : 1f-in$COUNTTAPES.txt existe" 
         else
         echo "1f-in$COUNTTAPES.txt n'existe pas"
         echo "ok copie du reliquat de 1f-pretapecumul`expr $COUNTTAPES - 1`.txt  dans  1f-tape`expr $COUNTTAPES - 1`.txt"
         cp 1f-pretapecumul`expr $COUNTTAPES - 1`.txt 1f-tape`expr $COUNTTAPES - 1`.txt 

         ############ habillage
            cat 1f-tape*.txt > 1f-cattapes1.txt
            TOTALCAT=`sed -n -e '$=' 1f-cattapes1.txt` ; echo "nombre de lignes : $TOTALCAT"
        
            LINE=1
            until [[ "$LINE" -gt "$TOTALCAT" ]]
            do
            AFTER=`expr $LINE + 1`
            if [[ `awk 'NR == '$AFTER' {print $3}' 1f-cattapes1.txt` -lt `awk 'NR == '$LINE' {print $3}' 1f-cattapes1.txt` ]] ; 
            then echo `awk 'NR == '$LINE' {print $0}' 1f-cattapes1.txt` ; 
            echo "-----------" 
            else
            echo `awk 'NR == '$LINE' {print $0}' 1f-cattapes1.txt`
            fi
            let LINE=LINE+1
            done > 1f-cattapes2.txt

            # retirer le dernier trait
            if [[ `sed -n '$p' 1f-cattapes2.txt` = "-----------" ]] ; then sed '$d' 1f-cattapes2.txt > 1f-cattapes3.txt ; fi
                                              
            # ajouter un trait en ligne 1
            sed -e '1i \-----------' 1f-cattapes3.txt > 1f-cattapes4.txt

            # numeroter les occurrences des tapes
            awk '{
            if($0 ~ /^-----/) {i=i+1 ; print $0" tape "i}
            else
            {print}
            }' 1f-cattapes4.txt > $OUTMETHODE6
            
            echo "################"
            echo "---> resultat dans : $OUTMETHODE6 :"
            cat $OUTMETHODE6

# etat avant de deleter les anciens resultats
echo "------------------"
echo "nb de 1f-cattapes* : `ls 1f-cattapes* | wc -l`"          
echo "nb de 1f-in* : `ls 1f-in* | wc -l`"              
echo "nb de 1f-pretape* : `ls 1f-pretape* | wc -l`"      
echo "nb de 1f-start-met* : `ls 1f-start-met* | wc -l`"          
echo "nb de 1f-tape* : `ls 1f-tape* | wc -l`"             
echo "total = `ls 1f* | wc -l`"

            break
            ##### fin de l'habillage

         fi 
         ##### fin du test sur existence de  1f-in$COUNTTAPES.txt


   NBLINES=`sed -n -e '$=' 1f-in$COUNTTAPES.txt` ; echo "nombre de lignes : $NBLINES"

   ######## boucle sur les lignes du fichier entree
   COUNT=1
   until [[ "$COUNT" -gt "$NBLINES" ]]
   do
   echo "--> count=$COUNT"

         # arret s'il n'y a plus de fichier entree
         test -e 1f-in$COUNTTAPES.txt
         check2=`echo $?`   # ; echo $check2
         if [[ "$check2" -eq "1" ]] ; then exit ; fi


   cat 1f-in$COUNTTAPES.txt | tail -$COUNT | head -1 >> 1f-inter$COUNTTAPES.txt

   cp 1f-inter$COUNTTAPES.txt 1f-pretape$COUNTTAPES.txt

   awk '{print $1,$2,x+=$2}' 1f-pretape$COUNTTAPES.txt > 1f-pretapecumul$COUNTTAPES.txt

   CUMUL=`cat 1f-pretapecumul$COUNTTAPES.txt | tail -1 | awk '{print $3}'` 
   echo "$CUMUL"

   if [[ "$CUMUL" -gt "$LIMIT" ]] ; then cat 1f-pretapecumul$COUNTTAPES.txt | 
     sed '$d' > 1f-tape$COUNTTAPES.txt  ; 
     
     STOP=`expr $COUNT - 1` # ; echo $STOP ; 
     sed -n -e :a -e '1,'$STOP'!{P;N;D;};N;ba' 1f-in$COUNTTAPES.txt > 1f-in`expr $COUNTTAPES + 1`.txt ; break ; fi

   let COUNT=COUNT+1
   done
   ######### fin boucle sur les lignes du fichier entree

echo "############## fin de la tape : $COUNTTAPES"
echo

sleep $SLEEP
let COUNTTAPES=COUNTTAPES+1
done

##### fin de la boucle sur les tapes

# resultat
# ----------- tape 1
# 10001 30 30
# 10002 2 32
# 10003 30 62
# 10004 30 92
# ----------- tape 2
# 10005 14 14
# 10006 30 44
# 10007 30 74
# ----------- tape 3
# 10008 30 30
# 10009 17 47
# 10010 30 77
# ----------- tape 4
# 10011 30 30

haut

Cumul d'une colonne avec decoupe a une limite definie - METHODE 7


#!/bin/bash

# SCRIPT 7 - METHODE 7
# boucle inverse sur les lignes dans une boucle sur les tapes

############ parametres
LIMIT=100
NBOFTAPES=10  
ORIGALL=0-start.txt
ORIGA=0-starta.txt       # colonne 1
ORIGB=0-startb.txt       # colonne 2

OUTMETHODE7=1-result-7G-$LIMIT.txt
SLEEP=0

######################## fin des parametres

# ORIG
# 10001 30
# 10002 2
# 10003 30
# 10004 30
# 10005 14
# 10006 30
# 10007 30
# 10008 30
# 10009 17
# 10010 30
# 10011 30

############### ZONE ARRONDIR : pour arrondir des valeurs
# arrondir 0.3 en 0   ///   0.7 en 1 :

#    ATTENTION CHANGER LA VIRGULE EN POINT

# script pour arrondir
# while read col1 col2
# do
# awk -v var2="$col2" -v var1="$col1" 'BEGIN { rounded = sprintf("%.0f", var2) ; print var1,rounded }'
# done < fichier entree > 0-start.txt

# exit   # pour verifier si le fichier ARRONDI a bien ete fait

################## fin de la zone ARRONDIR

# deleter les anciens resultats
rm 1g-cat-result*
rm 1g-cat-1g-z1g-*
rm 1g-inter*
rm 1g-start*
rm 1g-z1g-inter*

# etat apres la suppression des anciens resultats
echo "apres suppression : nb de 1g-cat-result* : `ls 1g-cat-result* | wc -l`"
echo "apres suppression : nb de 1g-cat-1g-z1g-* : `ls 1g-cat-z1g-* | wc -l`"
echo "apres suppression : nb de 1g-inter* : `ls 1g-inter* | wc -l`"
echo "apres suppression : nb de 1g-start* : `ls 1g-start* | wc -l`"
echo "apres suppression : nb de 1g-z1g-inter* : `ls 1g-z1g-inter* | wc -l`"

# exit    # activer pour deleter uniquement (sans faire marcher le script)

echo "les anciens resultats sont deletes"
sleep $SLEEP
##################

# separer les colonnes
awk '{print $1}' $ORIGALL > $ORIGA
awk '{print $2}' $ORIGALL > $ORIGB

cp $ORIGB 0-sauv-orig.txt
cp 0-sauv-orig.txt 1g-start1.txt

# boucle sur le numero de tape (start 1 2 ..)
g=1
until [[ $g -gt "$NBOFTAPES" ]]
do
echo 
echo "%%%%%%%%%%%%%%"
echo "numero de tape : $g"

NBLINES=`cat 1g-start$g.txt | wc -l`
echo "     nb lignes du fichier depart : 1g-start$g.txt : $NBLINES (ce nb est copie pour le conserver)"

# conserver l'original du nb de lignes de depart (voir a la fin : 1g-start2 , 3 , ...
NEWNBLINES=$NBLINES
sleep $SLEEP

# renommer 1g-start$g.txt en 1g-start$g-$NBLINES.txt
mv 1g-start$g.txt 1g-start$g-$NBLINES.txt

echo "     fichier depart renomme (nb lignes colle au nom du fichier) : 1g-start$g.txt -> 1g-start$g-$NBLINES.txt"
sleep $SLEEP


####################
# boucle inverse sur le nombre de lignes

n=$NBLINES
until [[ $n -lt "1" ]]
do
echo "    boucle inverse : ligne $n/$NEWNBLINES "
echo "     fichier traite : 1g-start$g-$n.txt"
echo "     g = $g (boucle sur les tapes)"
echo "     n = $n (boucle inverse sur les lignes)"

   awk '{ arr[NR]=$1 ; sum+=$1}
   END {
   for (i=1; i<=NR; i++)
   print arr[i],sum
   }' 1g-start$g-$n.txt > 1g-inter$g-$n.txt  # | sed '10,$d'
     echo " resultat du traitement (fichier : 1g-inter$g-$n.txt : (a droite: cumul total des lignes colonne 1)"
     cat 1g-inter$g-$n.txt
sleep $SLEEP

   sed ''$n',$d' 1g-inter$g-$n.txt | awk '{print $1}' > 1g-start$g-`expr $n - 1`.txt
#       echo "fin boucle nb lignes - fichier suivant : 1g-start$g-`expr $n - 1`.txt"
# sleep $SLEEP
let n=n-1
done    # fin boucle sur le nombre de lignes

#####################
# ajouter "0" si 1 digit ds noms fichiers : 1g-inter$g-*
for i in `seq 1 9`
do
mv 1g-inter$g-$i.txt 1g-inter$g-0$i.txt   2>/dev/null
done

echo "--------  habillage de la tape : $g"
echo "      ok ajout de '0' aux noms de fichiers (de 1 a 9) : 1g-inter$g -> 1g-inter0$g"
sleep $SLEEP

####################
# avant d'assembler les fichiers : marquer les lignes (avec @)
for i in `ls 1g-inter$g-*`
do
awk '{
if($2 < '$LIMIT') {print $0" @"}
else
{print}
}' $i > 1g-z$i
done

echo " ajout de @ a la fin des lignes de : 1g-inter$g-* ds 1g-z1g-inter$g-* si le cumul est < $LIMIT"
echo "creation de fichiers 1g-z1g-inter$g-*"
sleep $SLEEP

grep -H "." 1g-z1g-inter$g-* | grep "@" > 1g-cat-1g-z1g-inter$g-a.txt
echo " ok les fichiers 1g-z1g-inter$g-* contenant @ sont ds : 1g-cat-1g-z1g-inter$g-a.txt"
sleep $SLEEP

##################
# isoler le dernier 1g-inter$g avant $LIMIT
# marquer les occurrences de la colonne 2
awk 'BEGIN{OFS=FS=" "}
{if ($2 != var )
{var=$2;count++};print $0,count}
' 1g-cat-1g-z1g-inter$g-a.txt | sed 's/:/ /g' > 1g-cat-1g-z1g-inter$g-b.txt 
##################

echo " ok les occurrences sont marquees pour capturer la maxi"
sleep $SLEEP

# capturer le dernier champ et prendre le maxi
dern=`cat 1g-cat-1g-z1g-inter$g-b.txt | tail -1 | awk '{print $NF}'`     # echo $dern
awk '$NF == '$dern' {print}' 1g-cat-1g-z1g-inter$g-b.txt | awk -F"@" '{print $1}' > 1g-cat-1g-z1g-inter$g-c.txt

echo " ok l'occurrence maxi est capturee ds : 1g-cat-1g-z1g-inter$g-c.txt :"
cat 1g-cat-1g-z1g-inter$g-c.txt
sleep $SLEEP

# echo $dern   # correspond au nb lignes a deleter ds $ORIGIN
# deleter le nb lignes ($dern) dans 1g-start$g-$NBLINES.txt
sed '1,'$dern'd' 1g-start$g-$NEWNBLINES.txt > 1g-start`expr $g + 1`.txt


##################
#  Check if file is nonzero size
test -s 1g-start`expr $g + 1`.txt       #  Check if file is nonzero size

var2=`echo $?`   # code retour = 0 -> commande bien executee  -> Check if file is nonzero size
      echo "       --> test sur nonzero size du fichier suivant a lire : code retour=  $var2"

if [ "$var2" -eq "0" ] ; then
echo "     code retour=0 - bien execute - file '1g-start`expr $g + 1`.txt' is nonzero size"  
else
echo "     code retour=1 - mal execute - file is zero size - ARRET"

cat 1g-cat-1g-z1g-inter*-c.txt > 1g-cat-result1.txt
####################
# habillage
sed 's/1g-z1g-inter/tape /g' 1g-cat-result1.txt | sed 's/[.-]/ /g' | awk '{$3=$4=""} {print $0}' > 1g-cat-result2a.txt
paste $ORIGA 1g-cat-result2a.txt | awk '{print $2,$3,$1,$4,$5}' > 1g-cat-result2b.txt

      # prendre un marqueur different de @ : %
        awk 'BEGIN{OFS=FS=" "}
        {if ($2 != var )
        {var=$2;e="%"
        print $0,e}
        else
        print $0
        }' 1g-cat-result2b.txt | sed -e '/%/i\----------------' | sed 's/%//g' > $OUTMETHODE7
              echo "resultat ds : $OUTMETHODE7"
              cat $OUTMETHODE7

echo "------------------"
echo "---> etat avant de deleter les anciens resultats"
echo " nb de 1g-cat-result* : `ls 1g-cat-result* | wc -l`"
echo " nb de 1g-cat-1g-z1g-* : `ls 1g-cat-1g-z1g-* | wc -l`"
echo " nb de 1g-inter* : `ls 1g-inter* | wc -l`"
echo " nb de 1g-start* : `ls 1g-start* | wc -l`"
echo " nb de 1g-z1g-inter* : `ls 1g-z1g-inter* | wc -l`"
echo "------------------"
echo "total des 1g : `ls 1g* | wc -l`"

exit   # sortie si fichier 1g-start vide
fi

sleep $SLEEP
#################

# info
echo "boucle numero de tape - fichier a lire : 1g-start`expr $g + 1`.txt"

let g=g+1
done      # fin de la boucle sur le numero de tape (start 1 2 ..)

# resultat
# tape 1 10001 30 92 
# tape 1 10002 2 92
# tape 1 10003 30 92
# tape 1 10004 30 92
# ----------------
# tape 2 10005 14 74 
# tape 2 10006 30 74
# tape 2 10007 30 74
# ----------------
# tape 3 10008 30 77 
# tape 3 10009 17 77
# tape 3 10010 30 77
# ----------------
# tape 4 10011 30 30 

haut

Cumul d'une colonne avec decoupe a une limite definie - METHODE 8


#!/bin/bash

# SCRIPT 8 - METHODE 8
# but du script : une colonne mise sur une ligne
# addition des colonnes , arret jusqu'a une limite

############## parametres
# entree
ORIG=0-start.txt   # fichier entree contenant 2 colonnes

LIMIT=100
NBOFTAPES=10  
SLEEP=1

# sortie
OUTMETHODE8=1-result-8H-$LIMIT.txt

############## fin des parametres

# fichier entree arrondi
# 10001 30
# 10002 2
# 10003 30
# 10004 30
# 10005 14
# 10006 30
# 10007 30
# 10008 30
# 10009 17
# 10010 30
# 10011 30

############### ZONE ARRONDIR : pour arrondir des valeurs
# arrondir 0.3 en 0   ///   0.7 en 1 :

#    ATTENTION CHANGER LA VIRGULE EN POINT

# script pour arrondir
#   while read col1 col2
#   do
#   awk -v AR2="$col2" -v AR1="$col1" 'BEGIN { rounded = sprintf("%.0f", AR2) ; print AR1,rounded }'
#   done < fichier-entree > fichier-sortie

#  exit
################## fin de la zone ARRONDIR

# deleter les anciens resultats (avant de creer le fichier de demarrage : in1.txt)
rm 1h-in*
rm 1h-copietape*
rm 1h-lignetape*
rm 1h-nbcolpassage*
rm 1h-prein*
rm 1h-start-met*
rm 1h-tape*

# etat apres la suppression des anciens resultats
echo "apres suppression : nb de 1h-copietape* : `ls 1h-copietape* | wc -l`" 
echo "apres suppression : nb de 1h-in* : `ls 1h-in* | wc -l`" 
echo "apres suppression : nb de 1h-lignetape* : `ls 1h-lignetape* | wc -l`" 
echo "apres suppression : nb de 1h-nbcolpassage* : `ls 1h-nbcolpassage* | wc -l`" 
echo "apres suppression : nb de 1h-prein* : `ls 1h-prein* | wc -l`" 
echo "apres suppression : nb de 1h-start-met* : `ls 1h-start-met* | wc -l`" 
echo "apres suppression : nb de 1h-tape* : `ls 1f-tap* | wc -l`" 

# exit    # activer pour deleter uniquement (sans faire marcher le script)

echo "les anciens resultats sont deletes"
sleep $SLEEP
##################

###################
# transformer le "fichier-entree" pour mettre la colonne 2 sur une ligne
awk '{print $2}' $ORIG > 1h-start-met6-inter1.txt

sed '{:a;$!N;s_\n_ _;ta}' 1h-start-met6-inter1.txt > 1h-start-met6-inter2.txt   # fichier entree ok (sur une ligne)

# nb de champs
echo "nb de champs : `awk '{print NF}' 1h-start-met6-inter2.txt`"
echo $SLEEP

###############

# garder l'original et creer le fichier de demarrage : 1h-in1.txt
cp 1h-start-met6-inter2.txt 1h-in1.txt
echo "###################"
echo "ok copie de l'original ds 1h-in1.txt" 
echo "###################"
sleep $SLEEP

#############  boucle sur le nombre de tapes

counter=1
until [ $counter -gt $NBOFTAPES ]
do
  echo "boucle $counter"
  echo "lecture de 1h-in$counter.txt : "
  cat 1h-in$counter.txt
    
  # nb de colonnes
  awk '{print NF}' 1h-in$counter.txt > 1h-nbcolpassage$counter.txt
  echo "nb de colonnes du passage $counter : `cat 1h-nbcolpassage$counter.txt`"
     sleep $SLEEP

  1h-nbcolpassage$counter=$(cat 1h-nbcolpassage$counter.txt)    2>/dev/null

     ########  boucle sur le nombre total de colonnes

     n=1
     until [ $n -gt `cat 1h-nbcolpassage$counter.txt` ]  
     do

        # boucle pour creer des tapes
        while read line
        do
        echo $line  | cut -d" " -f$n >> 1h-inter$counter
        if [[ `cat 1h-inter$counter | awk '{print $0,x+=$0}' | awk '{print $2}' | tail -n1` -lt $LIMIT ]] ; 
           then echo `cat 1h-inter$counter | 
           awk '{print $0,x+=$0}' | awk '{print $2}' | tail -n1`  >> 1h-tape$counter ; fi

        cp 1h-tape$counter 1h-copietape$counter
        cat 1h-copietape$counter | wc -l > 1h-lignetape$counter                
        varcolues$counter=$(cat 1h-lignetape$counter)    2>/dev/null                  
 
        echo `echo $line  | awk '{for(n=1;n<='$varcolues$(cat 1h-lignetape$counter)';n++) $n="" ; print}' | cut -d" " -f$n` >> 1h-prein`expr $counter + 1`.txt  
        done < 1h-in$counter.txt   
        # fin de la boucle pour creer des tapes

     let n=n+1
     done

     ########  fin de la boucle sur le nombre total de colonnes

# la colonne devient ligne
grep "." 1h-prein`expr $counter + 1`.txt | sed '{:a;$!N;s_\n_ _;ta}' > 1h-in`expr $counter + 1`.txt
echo "creation de 1h-in`expr $counter + 1`.txt : `cat 1h-in$(expr $counter + 1).txt | sed '/./!d'`"    2>/dev/null

######### test si arret
# tester si fichier 1h-in`expr $counter + 1`.txt   est vide ou non     
test -s 1h-in`expr $counter + 1`.txt       #  Check if file is nonzero size

var1=`echo $?`   # code retour = 0 -> commande bien executee  -> Check if file is nonzero size
# echo $var1

if [ "$var1" -eq "0" ] ; then
echo "code retour=0 - bien execute - file is nonzero size - ok 1h-in`expr $counter + 1`.txt"  
echo "----------------"
else
echo "code retour=1 - mal execute - file is zero size - pas de 1h-in`expr $counter + 1`.txt - arret" ; break
fi

let counter=counter+1
done

#############  fin de la boucle sur le nombre de tapes
###################### 
# habillage

# mettre 3 digits dans les noms des fichiers tapes
for i in `seq 1 9`
do
mv 1h-tape$i 1h-tape00$i    2>/dev/null
done

for i in `seq 10 99`
do
mv 1h-tape$i 1h-tape0$i     2>/dev/null
done

# rassembler toutes les tapes
cat 1h-tape* > 1h-inter1-met5.txt

# coller la colonne 1 originale a 1h-inter1-met5.txt
cat $ORIG | awk '{print $1}' > 1h-inter1b-met5.txt
paste 1h-inter1b-met5.txt 1h-inter1-met5.txt > 1h-inter2-met5.txt

# nettoyer et ajouter 1 retour chariot a la fin de 1h-inter2-met5.txt
sed 's/\t/ /g' 1h-inter2-met5.txt | sed 's/^ //g' | grep "." | sed -e '$a \\r' > 1h-inter3-met5.txt
total=`sed -n '$=' 1h-inter3-met5.txt`

######## boucle sur le fichier du resultat
# separer les tapes par 1 trait
   N=1
   until [ $N -eq $total ]
   do
      S1=$N
      S2=`expr $N + 1`
      N=$S2

      VAL1A=`sed -n "$S1 p" 1h-inter3-met5.txt`    
      VAL1B=`sed -n "$S1 p" 1h-inter3-met5.txt | awk '{print $2}'`
      VAL2A=`sed -n "$S2 p" 1h-inter3-met5.txt`
      VAL2B=`sed -n "$S2 p" 1h-inter3-met5.txt | awk '{print $2}'`

      if [[ $VAL2B -lt $VAL1B ]] ; then echo $VAL1A ; echo "----------"
      else
      echo $VAL1A
      fi

   done > 1h-inter4-met5.txt
######## fin de la boucle sur le fichier du resultat

# deleter le trait de la derniere ligne
if [[ `sed -n '$p' 1h-inter4-met5.txt` = "----------" ]] ; then sed '$d' 1h-inter4-met5.txt > 1h-inter5-met5.txt ; fi

# ajouter un trait en ligne 1
sed -e '1i \---------' 1h-inter5-met5.txt > 1h-inter6-met5.txt

# numeroter les occurrences des tapes
awk '{
if($0 ~ /^-----/) {i=i+1 ; print $0"tape "i}
else
{print}
}' 1h-inter6-met5.txt > 1h-inter7-met5.txt

# nombre de tapes 
info3=`grep "tape" 1h-inter7-met5.txt | tail -1 | cut -d" " -f2`

echo "##################"
echo "nombre total de tapes : $info3"

# copie du resultat
cp 1h-inter7-met5.txt $OUTMETHODE8

echo "##################"
echo " ---> resultat dans $OUTMETHODE8" 
cat $OUTMETHODE8

echo "------------------"
echo "---> etat avant de deleter les anciens resultats"
echo "nb de 1h-copietape* : `ls 1h-copietape* | wc -l`" 
echo "nb de 1h-in* : `ls 1h-in* | wc -l`" 
echo "nb de 1h-lignetape* : `ls 1h-lignetape* | wc -l`" 
echo "nb de 1h-nbcolpassage* : `ls 1h-nbcolpassage* | wc -l`" 
echo "nb de 1h-prein* : `ls 1h-prein* | wc -l`" 
echo "nb de 1h-start-met* : `ls 1h-start-met* | wc -l`" 
echo "nb de 1h-tape* : `ls 1h-tape* | wc -l`" 
echo "------------------"
echo "total des 1h : `ls 1h* | wc -l`"


# resultat
# ---------tape 1
# 10001 30
# 10002 32
# 10003 62
# 10004 92
# ----------tape 2
# 10005 14
# 10006 44
# 10007 74
# ----------tape 3
# 10008 30
# 10009 47
# 10010 77
# ----------tape 4
# 10011 30

haut

Lire les colonnes avec "while read col1 col2 ..."


# in.txt
line1 col2 data1
line2 col2 data2
line3 col2 data3

#!/bin/bash
while read col1 col2    # col2 se voit attribuer tout le reste des colonnes
do
echo $col2
done < in.txt

# resultat
col2 data1
col2 data2
col2 data3

haut

Repeter un nombre de fois different une valeur qui s'incremente de 1


#!/bin/bash

################  parametres

# valeurs de debut et de fin du compteur incremente de 1 :
first=810828     # 1ere valeur 
last=810830      # derniere valeur

OCCUR=in-occur.txt   # le dernier retour chariot sera delete automatiquement
OUT=out.txt

# contenu de OCCUR ( occurrence de chaque valeur )
# 3     # 1ere valeur repetee 3 fois
# 2     # 2eme valeur repetee 2 fois
# 4     # 3eme valeur repetee 4 fois

################  fin des parametres

# deleter le dernier retoue chariot
cat $OCCUR | grep "." > temp-occur.txt

# creation du compteur qui s'incremente de 1
seq $first $last > temp1.txt

# temp1.txt
# 810828
# 810829
# 810830

# fichier de base 
paste temp1.txt temp-occur.txt > temp2.txt

# temp2.txt
# 810828	3
# 810829	2
# 810830	4

# creation du compteur des occurrences
while read line
do
seq 1 $line
done < temp-occur.txt > temp3.txt

# temp3.txt
# 1
# 2
# 3
# 1
# 2
# 1
# 2
# 3
# 4

###############
          
# boucle
while read col1 col2
do

   COUNTER=1
   until [  $COUNTER -gt $col2 ]
   do          
   echo $col1 
   let COUNTER=COUNTER+1               
   done                                    

done < temp2.txt > temp4.txt

# temp4.txt
810828
810828
810828
810829
810829
810830
810830
810830
810830

# habillage final
paste temp4.txt temp3.txt > $OUT 
# fin du script

# resultat
810828	1
810828	2
810828	3
810829	1
810829	2
810830	1
810830	2
810830	3
810830	4

haut

Modifier une colonne avec l'action : "if(length())"


# in.txt
line1 1field data1
line2 data2

line3 3field data3

#!/bin/bash
awk 'BEGIN{FS=" "; OFS=" "}
{ if ( length($0) )
{ $0 = substr($0, 0, 5) }
else { $0 = "NA" }
print
}' in.txt

# resultat
line1
line2
NA
line3

haut

Decoupe verticale avant ou apres un separateur ( identique a split )


# in.txt
col1data1,a,col3new1
col1data2,b,col3new2
col1data3,c,col3new3

#!/bin/bash
while read line
do
# le separateur est ici: ','
echo ${line%%,*}     # (la fin du fichier est supprimee)
done < in.txt

# resultat:
col1data1
col1data2
col1data3

#!/bin/bash
while read line
do
# le separateur est ici: ','
echo ${line##*,}     # (le debut du fichier est supprime)
done < in.txt

# resultat:
col3new1
col3new2
col3new3

haut

Reperer les doublons d'une colonne en separant les series dont ils sont issus


#in.txt
10 4000
10 3400
10 4000
10 2800
11 300
11 300
11 200
11 100
11 100
11 100
###############  parametres   ####################

IN=in.txt     # fichier de depart  (changer ici le nom du fichier)

###############  fin des parametres  ##################

#creation d'un compteur
awk '{print $1}' $IN > in-count.txt

#elements uniques de la colonne 1
awk '{a[$1]++} END {for(k in a) print k}' in-count.txt > in-count2.txt

#ajout d'un marqueur devant la colonne 1
awk '{print "@"$1,$2}' $IN > in2.txt

if [ -e in3.txt ] ; then rm in3.txt ; fi
while read line
do
awk '
$1 ~ /'$line'/ && a[$2]++
END {
for (i in a)   
   print a[i],i
}' in2.txt >> in3.txt
done < in-count2.txt

awk '{if( $1 ~ /^@/ ) {e = $1}
else
{split( $0, d, " " ) ; print e, d[1], d[2], d[3], d[4]}
}' in3.txt | awk '$2 == "1" {next} {print}' > in4.txt

#habillage
awk '{print $1,$2" fois "$3}' in4.txt | sed 's/@//g' | sort -r > in5.txt

#regrouper
awk 'BEGIN{FS=OFS=" "}
{a[$1]++ ; b[$1] = b[$1] " "$2" "$3" "$4" "$5" "$6}
END{ for( i in a )
print i,b[i]}
' in5.txt

#resultat
10  2 fois 4000  
11  3 fois 100   2 fois 300  

haut

Decouper un fichier en creant autant de fichiers que de colonnes


# in.txt
11 colonnes
2 lignes

#!/bin/bash
# nb caracteres maximum pour toutes les lignes
while read caract
do
echo ${#caract}
done < in.txt | sort -n | sed -n '$p' > out.txt

# lit tous les caracteres
limit=`cat out.txt`    
counter=1
until [ $counter -gt "$limit" ]
do
cat in.txt | cut -c ''$counter'-'$counter'' > cut-$counter  
let counter=counter+1
done

# resultat
fichier out.txt  ---> 11
# creation de 11 fichiers: cut-1 ; cut-2 ... cut-11
# contenu de cut-1
1
2

# contenu de cut-4
c
i

haut

Min et Max de valeurs placées sur une ligne


# in.txt                     # compteur.txt
1 902 993                    1
2 1003 1256 899 1000         2

# degrouper tous les champs (de 2 a 5) sur 1 seule colonne
awk '{
key=$1 ; $1="" ; n=split( $0, parties, "[ ]" );
for ( i=1; i<=n; i++ )
{if( length( parties[i] ) == 3 )
print ""key" 0"parties[i] ""      # valeurs a 4 digits
else
print ""key" "parties[i] ""}
}' in.txt | awk '{if ($2>0) print $0}' | sort > out1.txt

# out1.txt
1 0902
1 0993
2 0899
2 1000
2 1003
2 1256

# 1_script du minimum
if [ -e out-min.txt ] ; then rm out-min.txt ; fi
for i in `cat compteur.txt`
do
awk '{if( $1 == "'$i'" ) print $0}' out1.txt | head -1 >> out-min.txt
done

# resultat du minimum
1 0902
2 0899

# 2_script du maximum
if [ -e out-max.txt ] ; then rm out-max.txt ; fi
for i in `cat compteur.txt`
do
awk '{if( $1 == "'$i'" ) print $0}' out1.txt | tail -1 >> out-max.txt
done

# resultat du maximum
1 0993
2 1256

haut

Cumul de valeurs sur une ligne


# in.txt
line1 1 2 3
line2 4 5 6 7
line3 8 9 10

#!/bin/bash
awk 'BEGIN {FS=OFS=" "}
{ sum=0 ; n=0
for ( i=2; i<=NF; i++ )
{sum+=$i ; n++}
print $0,"sum:"sum," count:"n," avg:" sum/n
}' in.txt

# resultat
line1 1 2 3 sum:6 count:3 avg:2
line2 4 5 6 7 sum:22 count:4 avg:5.5
line3 8 9 10 sum:27 count:3 avg:9

haut

Supprimer un debut de fichier avant un pattern


# in.txt
1 fief toit
etre ville
toit eau

# supprimer le plus court 'debut-pattern'
#!/bin/bash
string=`cat in.txt`
echo "${string#*toit}"

# resultat
etre ville
toit eau

# supprimer le plus long 'debut-pattern'
#!/bin/bash
string=`cat in.txt`
echo "${string##*toit}"

# resultat
eau

haut

Supprimer une fin de fichier apres un pattern


# in.txt
1 fief toit
etre ville
toit eau

# supprimer le plus court 'pattern-fin'
#!/bin/bash
string=`cat in.txt`
echo "${string%toit*}"

# resultat
1 fief toit
etre ville

# supprimer le plus long 'pattern-fin'
#!/bin/bash
string=`cat in.txt`
echo "${string%%toit*}"

# resultat
1 fief

haut

Modifier les extremites d'une ligne avec "gsub" (bash)


# in.txt
data1 line1"
"data2 line2
"data3 line3"

#!/bin/bash
# deleter le debut des lignes
awk '{gsub( /^"/, "",$0 ) ; print}' in.txt |
# deleter la fin des lignes
awk '{gsub( /"$/, "",$0 ) ; print}'

# resultat
data1 line1
data2 line2
data3 line3

haut

Modifier une fin de ligne en retirant les espaces (sed)


# in.txt
# data1   colonne2a     
# data2              
# data3   colonne2b        

sed 's/[ ]*$//g' in.txt > out.txt

# resultat : out.txt (sans les blancs en fin de ligne)
# data1   colonne2a     
# data2              
# data3   colonne2b        

haut

Modifier une fin de ligne en retirant un caractere (bash)


#in.txt
123 data1@ data2 456@
789 data3@ 10 11
123 data4 data5 14@

#methode courte
#!/bin/bash
while read line ; do echo "${line%@}" ; done < in.txt  #delete la derniere occurrence

#methode longue
#!/bin/bash
while read line
do
#definir le dernier caractere comme pattern
a=`expr "$line" : '.*\(.\)'`
#condition sur le pattern
if [[ $a = "@" ]] ; then
#creer une variable = nombre de caracteres de la ligne -1 caractere
var=`expr ${#line} - 1`
#lire la ligne avec ce nouveau nombre de caracteres
b=`expr substr "$line" 1 $var`
echo $b
else
echo "$line"
fi
done < in.txt

#resultat
123 data1@ data2 456
789 data3@ 10 11
123 data4 data5 14

haut

Modifier une fin de ligne en ajoutant un caractere (bash)


#in.txt
123 data1@ data2 456@
789 data3@ 10 11
123 data4 data5 14@

#!/bin/bash
while read line
do
#definir le dernier caractere comme pattern
a=`expr "$line" : '.*\(.\)'`
#condition sur le pattern
if [[ $a = "@" ]] ; then
#creer la nouvelle ligne
echo $line"%"
else
echo "$line"
fi
done < in.txt

#resultat
123 data1@ data2 456@%
789 data3@ 10 11
123 data4 data5 14@%

haut

Modifier une fin de ligne en changeant un caractere - exemple 1 (awk)


#in.txt
H0104 STREAMER DETAILS          MAL PORT STREAMER                
H0105 OTHER DETAILS             OEX Outer STBD TAILBUOY             
R 283 487217.26818026.9     284 487229.76818026.3     285 487242.26818025.6   
R 286 487254.66818025.0     287 487267.16818024.3     288 487279.66818023.7   
R   1 483732.86818401.6       2 483745.26818400.0       3 483757.66818398.4   
R   4 483770.06818396.8       5 483782.46818395.3       6 483794.86818393.9   

# script

awk '{
if(substr($0,1,1) == "R")
{print substr($0,1,79)"1"}
else
{print $0}
}' in.txt > out.txt

# resultat
H0104 STREAMER DETAILS          MAL PORT STREAMER                
H0105 OTHER DETAILS             OEX Outer STBD TAILBUOY             
R 283 487217.26818026.9     284 487229.76818026.3     285 487242.26818025.6   1
R 286 487254.66818025.0     287 487267.16818024.3     288 487279.66818023.7   1
R   1 483732.86818401.6       2 483745.26818400.0       3 483757.66818398.4   1
R   4 483770.06818396.8       5 483782.46818395.3       6 483794.86818393.9   1

haut

Modifier une fin de ligne en changeant un caractere - exemple 2 (awk)


#in.txt
H0104 STREAMER DETAILS          MAL PORT STREAMER            1       0
H0105 OTHER DETAILS             OEX Outer STBD TAILBUOY      1           0
R 283 487217.26818026.9     284 487229.76818026.3     285 487242.26818025.6    9
R 286 487254.66818025.0     287 487267.16818024.3     288 487279.66818023.7    9
R   1 483732.86818401.6       2 483745.26818400.0       3 483757.66818398.4    0
R   4 483770.06818396.8       5 483782.46818395.3       6 483794.86818393.9    0
T                                                            1

#####  1ere solution : utiliser "if"

awk '{
if(substr($0,80,1) == "0") {sub( ".$", "A" )} {print}
}' in.txt

#####  2eme solution : utiliser "la selection d'un pattern et sa negation"

awk '
$0 ~ /^R/  {gsub( /0$/, "A",$0 ) ; print}
$0 !~ /^R/ {print $0}
' in.txt

#####  3eme solution : utiliser "le tableau"

awk '{ f[NR]=$0 }
END {
for (i=1; i<=NR; i++)
if (length(f[i]) == 80)
{print f[i]"@"}
else
{print f[i]}
}' in.txt | sed 's/9@/9/g' | sed 's/0@/A/g'

# resultat des 3 solutions
H0104 STREAMER DETAILS          MAL PORT STREAMER            1       0
H0105 OTHER DETAILS             OEX Outer STBD TAILBUOY      1           0
R 283 487217.26818026.9     284 487229.76818026.3     285 487242.26818025.6    9
R 286 487254.66818025.0     287 487267.16818024.3     288 487279.66818023.7    9
R   1 483732.86818401.6       2 483745.26818400.0       3 483757.66818398.4    A
R   4 483770.06818396.8       5 483782.46818395.3       6 483794.86818393.9    A
T                                                            1

haut

Modifier tout caractere en maitrisant sa position (awk)


# Technique de capture : if - else if - else

# in.txt
H0104 STREAMER DETAILS          MAL PORT STREAMER            1       0
H0105 OTHER DETAILS             OEX Outer STBD TAILBUOY      1           1
R 283 487217.26818026.9     284 487229.76818026.3     285 487242.26818025.6    9
R 286 487254.66818025.0     287 487267.16818024.3     288 487279.66818023.7    9
R   1 483732.86818401.6       2 483745.26818400.0       3 483757.66818398.4    0
R   4 483770.06818396.8       5 483782.46818395.3       6 483794.86818393.9    0
T                                                            1

awk '
{
# if ((length($0) != 80) && ($NF == 0)) {sub( ".$", "A" ) ; print}

if(substr($0,80,1) == "0") {sub( ".$", "A" ) ; print}
else if(substr($0,80,1) == "9") {a=substr($0,1,79) ; b=substr($0,80,1) ; b="J" ; print a""b}
else if((substr($0,62,1) == "1") && (substr($0,1,1) == "H")) {e=substr($0,1,61) ; f=substr($0,62,1) ; f="C" ; g=substr($0,63,17) ; print e""f""g}
# else if((substr($0,62,1) == "1") && ($0 ~ /^H/)) {e=substr($0,1,61) ; f=substr($0,62,1) ; f="C" ; g=substr($0,63,17) ; print e""f""g}
else
{print}
}

' in.txt

# resultat
H0104 STREAMER DETAILS          MAL PORT STREAMER            C       0
H0105 OTHER DETAILS             OEX Outer STBD TAILBUOY      C           1
R 283 487217.26818026.9     284 487229.76818026.3     285 487242.26818025.6    J
R 286 487254.66818025.0     287 487267.16818024.3     288 487279.66818023.7    J
R   1 483732.86818401.6       2 483745.26818400.0       3 483757.66818398.4    A
R   4 483770.06818396.8       5 483782.46818395.3       6 483794.86818393.9    A
T                                                            1

haut

Ajouter un signe dans une colonne qui fera office de separateur (awk)


# in.txt
H0104 STREAMER DETAILS          MAL PORT STREAMER            1       0
H0105 OTHER DETAILS             OEX Outer STBD TAILBUOY      1           1
R 283 487217.26818026.9     284 487229.76818026.3     285 487242.26818025.6    9
R 286 487254.66818025.0     287 487267.16818024.3     288 487279.66818023.7    9
R   1 483732.86818401.6       2 483745.26818400.0       3 483757.66818398.4    0
R   4 483770.06818396.8       5 483782.46818395.3       6 483794.86818393.9    0
T                                                            1

#!/bin/bash

# verifier la longueur des lignes 
awk '{
if(length($0) == 80)  {print "ok ligne a 80 colonnes"}
else
{print "attention cette ligne n a pas a 80 colonnes"}
}' test1.txt > verif-colonnes.txt

# chiffrer le nombre de lignes ayant 80 colonnes
# et celles qui n ont pas 80 colonnes
var1=`awk '$1 ~ /^ok/ {print $0}' verif-colonnes.txt | wc -l`
echo "nombre de lignes a 80 colonnes : " $var1
var2=`awk '$1 ~ /^attention/ {print $0}' verif-colonnes.txt | wc -l`
echo "nombre de lignes a moins de 80 colonnes : " $var2

# ajouter 1 blanc a chaque fin de ligne 
awk '{
if(length($0) == 80) {print}
else
{print $0"                                                                                 "}

}' test1.txt | awk '{print substr($0,1,80)}' > test2.txt

# ajouter 1 separateur en colonne 78
awk '{
if ( length($0) ) {a=substr($0,1,77) ; b=substr($0,78,1) ; b="@" ; c=substr($0,79,2) ; print a""b""c}
else
{print}
}' test2.txt > test3.txt

# isoler les 2 parties de chaque cote du separateur
awk -F"@" '{print $2}' test3.txt | sed 's/0/B/g' > test3d.txt
awk -F"@" '{print $1}' test3.txt > test3g.txt

# recoller les 2 parties
paste test3g.txt test3d.txt | sed 's/\t/ /g' > test3gd.txt

# resultat
H0104 STREAMER DETAILS          MAL PORT STREAMER            1       0
H0105 OTHER DETAILS             OEX Outer STBD TAILBUOY      1           1
R 283 487217.26818026.9     284 487229.76818026.3     285 487242.26818025.6    9
R 286 487254.66818025.0     287 487267.16818024.3     288 487279.66818023.7    9
R   1 483732.86818401.6       2 483745.26818400.0       3 483757.66818398.4    B
R   4 483770.06818396.8       5 483782.46818395.3       6 483794.86818393.9    B
T                                                            1

haut

Un signe en bout de ligne fait joindre la ligne qui suit (awk + getline)


#in.txt
data4
data5
data6\
data7

awk '{
line = $0
#print line
#print substr(line, length(line),1)
#print substr(line, 1, length(line)-1)

if (substr(line, length(line),1) == "\\")   # choisir ici le signe
i=getline
if (i > 0)
         {line = line" "$0}
         else
          {printf("missing continuation on line %d\n" , NR)}
     print line

}' in.txt | grep -v "missing continuation"

# resultat
data4
data5
data6\ data7

haut

Lire les 3 premiers caracteres de chaque ligne d'un fichier


# in.txt
123456
abcdef

#!/bin/bash
1_ methode en Bash
while read line
do
echo `expr "$line" : '\(...\)'`
done < in.txt

2_ methode en Awk
awk 'BEGIN{ FS=" "; OFS=" "}
{ if ( length($0) )
{ $0 = substr($0, 0, 3) }
else { $0 = "NA" }
print
}' in.txt

# resultat
123
abc

haut

Lire les 3 derniers caracteres de chaque ligne d'un fichier


# in.txt
123456
abcdef

#!/bin/bash
awk '{print substr( $0, length($0) - 2, length($0))}' in.txt

# resultat
456
def

haut

Effacer les 3 derniers caracteres de chaque ligne d'un fichier


# in.txt
123456789
abcdefghijk
line3 data123

#!/bin/bash
while read line
do
echo ${line::$((${#line}-3))}
done < in.txt

# resultat
123456
abcdefgh
line3 data

haut

En "AWK" : tester les tabulations cachees en fin de lignes


# tester les fins de lignes en "awk"
# tres utile pour deceler des tabulations cachees

# in.txt
data1
data2
data3/
data4	    # une tabulation se trouve ici

#!/bin/bash
pattern="\t"

awk '{
line = $0
{e = substr(line, length(line), 1)}
#print e
if(e == "'"$pattern"'") {print e,"<-- ok pattern ici"}
else
{print "no"}

}' in.txt > out.txt   # it's better to check the pattern in the file "out.txt"

# resultat
no
no
no
	 <-- ok pattern ici

haut

En "BASH" : tester les derniers caracteres en fin de lignes


# tester les fins de lignes en "bash"
# voit les derniers caracteres mais pas les tabulations de fin de lignes
# preferer employer "length" avec "awk"

#in.txt
data1
data2
data3/
data4	

#!/bin/bash
pattern="/"
n=1
while read line
do
   a=`expr "$line" : '.*\(.\)'`
   echo $a > tmp.txt

   if grep -q "$pattern" tmp.txt
      then echo "line : " $n " : ok pattern"
      else
      echo "line : " $n " : no pattern - code retour = " $?
   fi
let n=n+1
sleep 1
done < in.txt

# resultat
line :  1  : no pattern - code retour =  1
line :  2  : no pattern - code retour =  1
line :  3  : ok pattern
line :  4  : no pattern - code retour =  1

haut

Decouper un fichier a un pattern precis (le pattern est la fin du fichier decoupe)


# in.txt
Mr X
HSD
PIN = 12345
Mr Y
NGV
PIN = 45678

#!/bin/bash
awk 'BEGIN{ fn = "in1.txt" ; n = 1 }
{
print > fn
if ( substr($0, 1, 3) == "PIN" )   # "PIN" est la fin des fichiers
  { close (fn)
    n++
    fn = "in"n".txt"
  }
}' in.txt

# resultat
# in1.txt           # in2.txt
Mr X                Mr Y
HSD                 NGV
PIN = 12345         PIN = 45678

haut

Decouper un fichier a un pattern precis (le pattern est le debut du fichier decoupe)


# in.txt
Mr X
HSD
PIN = 12345
Mr Y
NGV
PIN = 45678

#!/bin/bash
awk '/^Mr X|^Mr Y/ {close("add_"f) ; f++}    # ecriture manuelle de tous les debuts de fichiers
{print $0 > "add_"f}' in.txt

# resultat
# add_1           # add_2
Mr X                Mr Y
HSD                 NGV
PIN = 12345         PIN = 45678

haut

Decouper un fichier a un pattern precis (autre exemple)


# in.txt
100 a b
200 c d
300 e f
400 g h

#!/bin/bash
# 1_ diviser automatiquement toutes les 3 lignes
awk '{ print > ("std_" int((NR+2)/3)) ".txt"}' in.txt

#resultat : 2 fichiers crees: std_1.txt ; std_2.txt

# 2_ diviser en triant sur le 1er digit d'une colonne:
awk '{print > substr($1,1,1)".txt"}' in.txt

#oubien :
cat in.txt | while read line
do
echo "$line" >> std_`echo $line | cut -c1`.txt
done

#resultat : 4 fichiers crees: std_1.txt ; std_2.txt ; std_3.txt ; std_4.txt

haut

Decouper un fichier d'apres la forme de sa fin de ligne


# in.txt
z-0061 5172-821 3665 
z-0061 5172-821 4754 
z-0061 @@@ @@@ 810, 942,
z-0061 1860, 2428,
z-0061 2813 
z-0061 @@@ @@@ 299, 303,
z-0061 515, 3880,
z-0061 4306 

# le but est de creer un fichier a chaque fois que la ligne ne se termine pas par une virgule
# donc dans cet exemple il y aura creation de 4 fichiers

#!/bin/bash
# toutes les lignes ne se terminant pas par une virgule, y coller le signe %% 
awk '$0 !~ /,$/ {print $0"%%"}
$0 ~ /,$/ {print}
' in.txt > inter1.txt

# preceder ce signe %% par un saut de ligne pour l'ecrire sur la ligne d'apres
sed 's/%%/\n%%/g' inter1.txt > inter2.txt

# supprimer le saut de ligne qui suit ce signe %%
sed -e :a -e '/%%$/N ; s_\n__ ; ta' inter2.txt > inter3.txt

# ajouter ce signe devant la 1ere ligne
awk 'NR==1 {print "%%"$0}
NR!=1 {print}' inter3.txt > inter4.txt

# coupe le fichier a la rencontre du signe %%
awk '
/^%%/{close("add_"f);f++}   # ne pas separer
{print $0 > "add_"f}
' inter4.txt

# resultat
add_1
%%z-0061 5172-821 3665

# add_2
%%z-0061 5172-821 4754

# add_3
%%z-0061 @@@ @@@ 810, 942,
z-0061 1860, 2428,
z-0061 2813

# add_4
%%z-0061 @@@ @@@ 299, 303,
z-0061 515, 3880,
z-0061 4306

haut

Inserer une ligne avant ou apres un pattern (en AWK et en BASH)



# in.txt
data1
data2
pattern1
data3
data4
pattern2
data5
data6

# 1_ en AWK

# 1a_ marquer 1 trait avant le pattern

awk '{
if ($1 ~ /pattern/) {print "-----------\n"$0}
else
print

}' in.txt

# resultat
data1
data2
-----------
pattern1
data3
data4
-----------
pattern2
data5
data6

###################

# 1b_ marquer 1 trait apres le pattern

awk '{
if ($1 ~ /pattern/) {print $1"\n-----------"}
else
print

}' in.txt

# resultat
data1
data2
pattern1
-----------
data3
data4
pattern2
-----------
data5
data6

#######################
#######################

# 2_ en BASH

# 2a_ marquer 1 trait avant le pattern

word="pattern"
while read line
do

if [[ "$line" =~ "$word" ]]
then echo $line | sed '/'$word'/{

h;s//%%%/ ;H;x

}' | sed 's/'$word'./----------/g' | sed 's/%%%/'$word'/g'

else
echo "$line"
fi
done < in.txt

# resultat
data1
data2
----------
pattern1
data3
data4
----------
pattern2
data5
data6

# 2b_ marquer 1 trait apres le pattern
                                            
word="pattern"
while read line
do
echo "$line"
if [[ "$line" =~ "$word" ]]
then echo "----------"
fi
done < in.txt

# resultat
data1
data2
pattern1
----------
data3
data4
pattern2
----------
data5
data6

haut

Inserer un trait au changement d'un pattern


# in.txt
10 data1
10
11 data2
11
12 data3
12

# 1- methode courte (en awk)

awk 'BEGIN{OFS=FS=" "}
{if ($1 != var )
   {var=$1;e="@"
   print $0,e}
   else
   print $0
}' in.txt | sed -e '/@/i\----------------' | sed 's/@//g'

###########################

# 2- methode longue (avec un tableau) (en awk)

awk '{ f[NR]=$1 ; g[NR]=$0 }
END {
for (i=1; i<=NR; i++)
if (f[i+1] != f[i])
{print "@"f[i],g[i]}
else
{print f[i],g[i]}
}' in.txt | sed '/@/G' | 
awk '
$0 ~ /^$/ {print "- ------------------"}
$0 !~ /^$/ {print $0}' | awk '{$1 = "" ; print $0}' | sed 's/^ //g'

###########################

# 3- avec une boucle while (en bash)

id2="z"
while read line
do
id=`echo $line | cut -d " " -f1`
[[ $id != $id2 ]] && id2=$id && echo "$line @" && continue
[[ $id == $id2 ]] && echo $line
done < in.txt | sed -e '/@/i\----------------' | sed 's/@//g'

###########################

# 4- avec une boucle for (en bash)

OLD_IFS=$IFS
IFS=$'\n'
id2="z"
for line in `cat in.txt`
do
id=`echo $line | cut -d " " -f1`
[[ $id != $id2 ]] && id2=$id && echo "$line @" && continue
[[ $id == $id2 ]] && echo $line
done | sed -e '/@/i\----------------' | sed 's/@//g'
IFS=$OLD_IFS

# resultat
10 data1
10
------------------
11 data2
11
------------------
12 data3
12
------------------

haut

Inserer une ligne avant des patterns listes dans un fichier


# fichier depart : FILE
data1
data2
pattern1
data3
data4
data5
pattern2
data6
data7
pattern3
data8
data9
pattern4
data10
data11

# fichier des patterns : PATTERN 
pattern1
pattern2
pattern3
pattern4

#!/bin/bash

############ 
############  parametres pour la marche manuelle
FILE=z-test-add-before.txt   # fichier depart

PATTERN=patterns.txt     # fichier des patterns

insert="@@@@@@@@"      # # ligne a inserer avant les patterns

AUTO=auto.sh

# changer 2 lignes (voir plus loin) dans la creation de $AUTO

############  fin des parametres pour la marche manuelle
############

variable=`cat $PATTERN`
set -- $variable
# nombre de mots dans le fichier: variable speciale $#
for i in `seq 1 $#`
do
t=`echo var$i="\$"{$i} "; echo \$"var$i`
echo $t
done > tempw.txt  # fichier temporaire

# rendre visibles les variables a l'exterieur
while read line;do eval $line;done < tempw.txt > /dev/null

# nombre de lignes du fichier
total=`sed -n '$=' $FILE`
echo "nb lignes du fichier de depart : " $total

# deleter l'ancien script de commande
rm $AUTO
############################

# creation du script de commande : $AUTO
echo "#!/bin/bash" >> $AUTO
echo ""  >> $AUTO

echo "FILE=z-test-add-before.txt"  >> $AUTO          # changer ici manuellement
echo insert=\"@@@@@@@@\"  >> $AUTO                   # changer ici manuellement
echo "total=\"`sed -n '$=' $FILE`\"" >> $AUTO
echo "N=1" >> $AUTO
echo ""  >> $AUTO

echo "until [[ "\$N" -eq \$total ]]"  >> $AUTO
echo "do"  >> $AUTO
echo   "S1="\$N""  >> $AUTO
echo   "S2=\$(expr "\$N" + 1)"  >> $AUTO
echo   "N="\$S2""  >> $AUTO
echo   "VAL1=\$(sed -n \"\$S1 p\" \$FILE)"  >> $AUTO
echo   "VAL2=\$(sed -n \"\$S2 p\" \$FILE)"  >> $AUTO

# utilise le fichier des patterns comme ossature ($0) (et colle du texte avant et apres $0)
awk '
NR==1 {print "if [[ '\$VAL2' =~ \""$0"\" ]] ; then echo '\$VAL1'  ; echo $insert "} 
NR!=1 {print "elif [[ '\$VAL2' =~ \""$0"\" ]] ; then echo '\$VAL1'  ; echo $insert "}

' $PATTERN >> $AUTO

echo "else" >> $AUTO
echo "echo "\$VAL1"" >> $AUTO      # ne pas changer
echo "fi" >> $AUTO
echo  "sleep 1" >> $AUTO
echo "done" >> $AUTO

#################  fin de la creation de : $AUTO

# desactiver la commande suivante 'auto' pour executer la marche manuelle
bash $AUTO && exit

####################################

# marche manuelle :

N=1
until [ "$N" -eq $total ]
do

    S1=$N
    S2=`expr $N + 1`
    N=$S2
    VAL1=`sed -n "$S1 p" $FILE`
    VAL2=`sed -n "$S2 p" $FILE`

    if [[ $VAL2 =~ "$var1" ]] ; then echo $VAL1  ; echo $insert 
       elif [[ $VAL2 =~ "$var2" ]] ; then echo $VAL1 ; echo $insert 
       elif [[ $VAL2 =~ "$var3" ]] ; then echo $VAL1 ; echo $insert 
      elif [[ $VAL2 =~ "$var4" ]] ; then echo $VAL1 ; echo $insert 

    else
    echo $VAL1
    fi

    sleep 1
done 

# resultat :
data1
data2
@@@@@@@@
pattern1
data3
data4
data5
@@@@@@@@
pattern2
data6
data7
@@@@@@@@
pattern3
data8
data9
@@@@@@@@
pattern4
data10
data11

haut

Ajouter du texte sur une ligne ou apres une ligne


# in.txt
pattern
title1
data1
pattern
title2
data2

#!/bin/bash
# remplacer 'pattern' par '----------'
sed -e '/^pattern/ c\----------' in.txt > out1.txt
# ajouter '&&&' apres la ligne '---------'
sed -e '/----------/ a\&&& ' out1.txt > out2.txt
# supprimer le saut de ligne apres &&& pour coller les 2 lignes
sed '
/&&& /{
N
s/\n//
}' out2.txt > out3.txt

# resultat
----------
&&& title1
data1
----------
&&& title2
data2

haut

Inserer une ligne blanche selon un critere de longueur de ligne


# in.txt
data1 something1
data2

#!/bin/bash
maxlen=7
while read line
do
echo "$line"
len=${#line}
if [[ "$len" -gt "$maxlen" ]]
then echo      # insertion d'une ligne blanche
fi
done < in.txt
exit

# resultat
data1 something1

data2

haut

Memoriser une chaine de caracteres pour l'inserer sur une autre ligne


in.txt
@0066),(3063) 3201,3217,3233,3249,3265,3281,3297,3313,3329,3345
@0066),(3063) 3361,3377,3393,3409,3425,3441,3457,3473,3489,3505 
3521,3537,3553,3569,3585,3601,3617,3633,3649,3665,3681,3697,3713,3729,3745,3761,3777,3793,3809,3825)F
@0066),(2101) 2878,2894,2910,2926,2942,2958,2974,2990,3006,3022
@0066),(2101) 3038,3054,3070,3086,3102,3118,3134,3150,3166,3182 
3198)F

#!/bin/bash
awk -F " " '
$0 ~ /^@/  {e=$1} {print}
$0 !~ /^@/ {print e,$0}
' in.txt | grep "@" | sed 's/@/(/1' | sed 's/) /),(/1' 

#resultat
(0066),(3063) 3201,3217,3233,3249,3265,3281,3297,3313,3329,3345
(0066),(3063) 3361,3377,3393,3409,3425,3441,3457,3473,3489,3505 
(0066),(3063) 3521,3537,3553,3569,3585,3601,3617,3633,3649,3665,3681,3697,3713,3729,3745,3761,3777,3793,3809,3825)F
(0066),(2101) 2878,2894,2910,2926,2942,2958,2974,2990,3006,3022
(0066),(2101) 3038,3054,3070,3086,3102,3118,3134,3150,3166,3182 
(0066),(2101) 3198)F

haut

Capturer dans un fichier des patterns listes dans un 2eme fichier (exemple 1)


# file1    # =liste des patterns a capturer
capture1
capture3

# file2
line1 capture1 data1
line2 data2 1234 capture2
line3 data3 capture3
line4 capture4 data4

#!/bin/bash
if [ -e file3 ] ; then rm file3 ; fi
for i in `cat file1`
do
   while read col1 reste
   do
   var=`echo $reste | awk '$0 ~ /'$i'/ { print }'`
   echo $col1 $var
   done < file2 >> file3
done

# regroupement des lignes
awk 'BEGIN{FS=OFS=" "}
!arr[$1] {arr[$1] = $0 ; next}
{arr[$1] = arr[$1] " " $2 " " $3 " " $4}
END {for (i in arr) {print arr[i]}
}' file3

# resultat
line1 capture1 data1
line2 
line3 data3 capture3
line4 

haut

Capturer dans un fichier des patterns listes dans un 2eme fichier (exemple 2)


# file1    # =liste des patterns a capturer
capture1
capture3

# file2
line1 capture1 data1
line2 data2 1234 capture2
line3 data3 capture3
line4 capture4 data4

# 1 ere methode (en bash)

#!/bin/bash
for i in `cat file1`
do
awk -F" " -v x=$i '
{ for ( j=1; j<=NF; j++ )
if ( $j == x ) print}' file2
done

# 2 eme methode (en awk)

#!/bin/bash
awk '{ if (NF == 1)
arr[$0]=$0
else
for ( i in arr )
for ( j=1; j<=NF; j++ )
if ( $j == i )
print
}' FS=" " file1 file2

# resultat
line1 capture1 data1
line3 data3 capture3

haut

Modifier dans un fichier des patterns listes dans un 2eme fichier


# file.txt
a data1
b data2
c data3
d data4

# except.txt
a
c

# 1_ MODIFIER

#!/bin/bash
awk 'BEGIN{FS=" "}
FNR==NR {ex[$1]; next}
{ $2 = ($1 in ex) ? "0" : $2; print }
' except.txt file.txt

# resultat
a 0
b data2
c 0
d data4

# 2_ DELETER

#!/bin/bash
awk 'BEGIN{FS=" "}
FNR==NR {ex[$1]; next}
!($1 in ex)
' except.txt file.txt

# resultat
b data2
d data4

haut

Stopper la lecture d'un fichier à un pattern liste dans un 2eme fichier


# break.txt
STOP

# in.txt
line1 data1
line2 data2
STOP
line3 data3
line4 data4

#!/bin/bash
for i in `cat break.txt`
do
while read line ; do [[ "$line" =~ "$i" ]] && break ; echo $line ; done < in.txt
done

# resultat
line1 data1
line2 data2

haut

Capturer un pattern a une position fixe sur une ligne


# in.txt
123 data
12345 data

#!/bin/bash
egrep '^.{4}data' in.txt

# resultat
123 data

haut

Capturer un pattern avec un depart, une longueur et une arrivee


# file.txt
go beyond finishing line
what do you say ?
to have a share in doing something = contribuer a faire qqch

#!/bin/bash
sed -n '/in.\{3\}ing/p' file.txt

# resultat
go beyond finishing line
to have a share in doing something = contribuer a faire qqch

haut

Capturer la premiere occurrence d'une serie de lignes ayant meme pattern


# in.txt
100 first line data1
100 second line data2
101 first line data3
101 second line data4

#!/bin/bash
cat in.txt | sort -k1 | awk 'x !~ $1 ; {x = $1}'

# 2eme syntaxe
cat in.txt | sort -k1 | awk 'x[$1]++ {next} {print}'

# 3eme syntaxe
cat in.txt | sort -k1 | awk '!_[$1]++ {print $0; next} {next}'

# resultat
100 first line data1
101 first line data3

haut

Selectionner des lignes d'un fichier par des caracteres d'une colonne


# in.txt
"I came to realize the true meaning of life" 74
"The shoes came untied" 76
"his face went red" 80
"your wish will come true" 82
"Melons come from a vine" 97
"Understanding comes from experience" 99

#!bin/bash
# 1_selection des patterns
while read special
do
# selection de 2 caracteres et prendre le dernier a droite
var1=`echo ${special::2} | sed 's/.*\(.\)$/\1/' | awk '$0 ~ /[a-z]/ {print}'`  
echo $var1 
done < in.txt | grep "." > in-patterns.txt

# 2_lecture des patterns qui selectionneront les lignes
while read special
do
    while read minus
    do
    var2=`echo ${special::2} | sed 's/.*\(.\)$/\1/' | awk '$0 ~ /[a-z]/ {print}'`  
    if [[ $var2 = "$minus" ]] ; then echo $special ; fi
    done < in-patterns.txt
done < in.txt

# resultat
"his face went red" 80
"your wish will come true" 82

haut

Une seule variable dans une seule boucle suffit pour la source et la cible


# une seule variable est necessaire pour capturer des patterns 
# qui vont selectionner des lignes dans des fichiers dont les noms ne 
# different que d'une lettre des noms des fichiers des patterns

#####
# les 2 fichiers sources (patterns)
# wyz1
pattern1

# wyz2
pattern2

#####
# les 2 fichiers cibles
# swyz1 (premier fichier)
data1
pattern1 line1 selected from swyz1
inter first
pattern1 line2 selected from swyz1
data

# swyz2 (deuxieme fichier)
data3
pattern2 line1 selected from swyz2
inter second
pattern2 line2 selected from swyz2
data

#####
# marquer les lignes contenant le pattern
for k in wyz*
do
vark=`cat $k`
awk '
$0 ~ /'$vark'/ {print $0" @@"}
$0 !~ /'$vark'/ {print $0}
' s$k > m$k       # la lettre qui differe est le "s"
done

#####
# numeroter l'occurrence du marquage @@
for j in m*
do
awk '$0 ~ /@/ {i=i+1} {print $0,i}' $j |
awk '!f[$NF]++ {print $0 ; next} {sub($NF, "") ; print}' > n$j 
done

#####
# selectionner la premiere occurrence @@
for k in nm*
do
grep -H -A1 "@@ 1" $k | sed 's/[:-]/    /g'
echo
done

# resultat
nmwyz1    pattern1 line1 selected from swyz1 @@ 1
nmwyz1    inter first 

nmwyz2    pattern2 line1 selected from swyz2 @@ 1
nmwyz2    inter second 

haut

Capture de lignes avec pattern de debut et de fin


in.txt
line1
data1
_start
data2
line5
_end
data3
line8
data4

#!/bin/bash
i=1
until [ $i -gt "10" ]
do
S=`grep -n "start" in.txt | awk -F":" '{print $1}'`
S=`expr $S + $i`
var=`sed -n "$S p" in.txt`
echo $var
if [[ $var =~ "end" ]] ; then break ; fi
let i=i+1
done

# resultat
data2
line5
_end

haut

Maitrise de la ligne et du champ pour reorganiser les champs


# in.txt
there's no harm in trying   il n'y a pas de mal a  essayer, on ne perd rien a essayer 
he got into trouble for stealing apples   il s'est fait attraper pour avoir vole des pommes 
the strain of making polite conversation   l'effort que ca demande de faire la conversation a  quelqu'un 
death finally released her from her suffering   la mort a mis un terme a ses souffrances 
they'll respond to the crisis by raising taxes   ils repondront a la crise en augmentant les impots 

##########################   parametres
LISTE=in.txt    # fichier entree a lire

##########################   fin des parametres

# deleter resultats precedents
rm out-*.txt

# nombre de lignes a lire
nbline=`awk '{print NR}' $LISTE | sed -n '$p'`   

# boucle sur les lignes
count=1    
until [ "$count" -gt $nbline ]
do
     # nb maxi de champs
     nbchampsmax=`awk '{print NF}' $LISTE | sort -n | sed -n '$p'`  # ;  echo $nbchampsmax

     # boucle sur les champs
     field=1
     until [ "$field" -gt "$nbchampsmax" ]
     do
     acount=`awk 'NR=='$count' {split( $0, d, " " ) ; if((d['$field'] ~ "ing") || (d['$field'] == "in") || (d['$field'] == "for") 
     || (d['$field'] == "before") || (d['$field'] == "of") || (d['$field'] == "by") || (d['$field'] == "from")) print NR" " d['$field']}' $LISTE | grep -v "something"`  
     echo $acount   >> out-"$count".txt     
     let field=field+1
     done     # fin boucle sur les champs

##################################
# info compteur de ligne
echo "line: " $count " / " $nbline
##################################

let count=count+1
done      # fin boucle sur les lignes

# ajouter zeros aux noms < 10
for i in `seq 1 9`
do
mv out-$i.txt out-00$i.txt
done   2>dev>null 

# ajouter zeros aux noms entre 10 et 99
for i in `seq 10 99`
do
mv out-$i.txt out-0$i.txt
done   2>dev>null 

# supprimer lignes vides
cat out-*.txt | grep "." > result1.txt

# reorganiser les champs de chaque ligne
# regrouper
awk 'BEGIN {FS=OFS=" "}
!a[$1] {a[$1] = $0;next}
{a[$1] = a[$1] " " $2 " " $3 " " $4}
END {for(i in a) {print a[i]}
}' result1.txt | sort -n | awk '{print $1,$2,$3}' > result2.txt

# classement par ordre alphabetique des verbes
cat result2.txt | awk '{print $0" @"}' > result3.txt

paste result3.txt $LISTE > result4.txt

# nettoyer
cat result4.txt | sort -k3 | awk '$0 ~ $3 {sub( /[),?!(]/, "" ) ; print}' > result5.txt

# retirer des parentheses
awk '$0 ~ $3 {sub( /[)]/, "" ) ; print}' result5.txt > result5a.txt

# separer les verbes par des traits (sed '/@/G' --> ajoute 1 ligne blanche)
awk '{ f[NR]=$3 ; g[NR]=$0 }
END {
for (i=1; i<=NR; i++)
if (f[i+1] != f[i])
{print "%"f[i],g[i]}
else
{print f[i],g[i]}
}' result5a.txt | sed '/%/G' | 
awk '
$0 ~ /^$/ {print "- - -------------------------------------"}    # noter les 2 espaces au debut des pointilles
$0 !~ /^$/ {print $0}' | awk '{$1 = "" ; print $0}' > result6.txt

# habillage
awk '{$1 = "" ; print $0}' result6.txt > result6a.txt
awk -F"@" '{printf ("%-23s %-23s\n",$1,$2)}' result6a.txt > result7.txt

# resultat: result7.txt
of making               the strain of making polite conversation   l'effort que ca demande de faire la conversation a  quelqu'un
-------------------------------------                        
by raising              they'll respond to the crisis by raising taxes   ils repondront a la crise en augmentant les impots
-------------------------------------                        
for stealing            he got into trouble for stealing apples   il s'est fait attraper pour avoir vole des pommes
-------------------------------------                        
from suffering          death finally released her from her suffering   la mort a mis un terme a ses souffrances
-------------------------------------                        
in trying               there's no harm in trying   il n'y a pas de mal a essayer ; on ne perd rien a essayer
-------------------------------------                        

haut

Marquer des groupes de patterns semblables (exemple simple)


# in.txt                      # in2.txt
100 first line data1          100 1
100 second line data2         101 2
101 first line data3
101 second line data4

# 1ere methode (avec 1 seul fichier)
awk '{if( $1 != var )
{var = $1 ; count++}
print $0, count}
' in.txt

# 2eme methode (avec 2 fichiers)
awk 'NR==FNR {arr[$1]=$2 ; next}
{print $0, arr[$1]}
' in2.txt in.txt

# resultat
100 first line data1 1
100 second line data2 1
101 first line data3 2
101 second line data4 2

haut

Marquer des groupes de patterns semblables (exemple plus complique)


# test.txt
#100 data 33 11
#100 data 33 11
#100 data 33 12
#100 data 33 12
#100 data 34 13
#100 data 34 13
#100 data 34 14
#100 data 34 14
#100 data 34 14
#101 data 74 15
#101 data 74 15
#101 data 74 16
#101 data 74 16
#2 data2

awk '{
if ( substr($0,1,1) == "1" ) 
      {
          if (substr($0,1,3)  != first)  {n = 0 }
          if (substr($0,10,2)  != second)     {n = 0 }
          if (substr($0,13,2)  != third) {n++}
              
          {
          first = substr($0,1,3) 
          second = substr($0,10,2)
          third = substr($0,13,2)
          }
          
          { print $0,n }
           
      }
else
{
if (substr($0,1,1) == "2")  {print $0} 
}
}' test.txt
# resultat
#100 data 33 11 1
#100 data 33 11 1
#100 data 33 12 2
#100 data 33 12 2
#100 data 34 13 1
#100 data 34 13 1
#100 data 34 14 2
#100 data 34 14 2
#101 data 74 15 1
#101 data 74 15 1
#101 data 74 16 2
#101 data 74 16 2
#2 data2

haut

Coller des valeurs a un pattern (exemple 1)


# a.txt
ALL   001  3  4
5     001  6  7
ALL   002  8  9
10    002  11 12

# b.txt
001   2027-2145
002   1820-1967

#!/bin/bash
awk 'NR==FNR { f[$1]=$2 ; next } /^ALL/ { print f[$2],$2,$3,$4 ; next }1' b.txt a.txt

# resultat
2027-2145   001  3  4
5           001  6  7
1820-1967   002  8  9
10          002  11 12

haut

Coller des valeurs a un pattern (exemple 2)


# filea.txt
5:John
4:Michel
9:Rachel

# fileb.txt
9
4
5
4
22

#!/bin/bash
cat fileb.txt | while read num
do
NAME=`awk -F ":" '$1=="'"$num"'" {print '$num' FS $2}' filea.txt`
[ -z $NAME ] && echo "$num":"NO MATCH FOUND" || echo $NAME
done

# resultat
9:Rachel
4:Michel
5:John
4:Michel
22:NO MATCH FOUND

haut

Coller des valeurs a un pattern (exemple 3)


# file1.txt
alex id23
aina id12
ciam id13
alot id34
brian id64

# file2.txt
id13 new1
id12 new2
id64 new3

# 1ere methode
#!/bin/bash
awk 'BEGIN{FS=" "}
NR==FNR{arr[$2]=$0 ; next}
$1 in arr && $0=arr[$1] FS $2
' file1.txt file2.txt

# 2eme methode
#!/bin/bash
awk 'BEGIN{FS=" "}
NR==FNR{arr[$1]=$2 ; next}
$2 in arr{print $0, arr[$2]}
' file2.txt file1.txt

# resultat
ciam id13 new1
aina id12 new2
brian id64 new3

haut

Remplacer des patterns par d'autres, contenus dans un 2eme fichier


# SOURCE
debitadsl link1
dslvalley link2
onelook link3
esl link4
breaking link5
larousse link6
merriam link7

# TARGET
To learn English :        0               0
a href=" esl "ESL Cyber Listening Lab ;     0         0
Tester DEBIT ADSL :  
a href=" debitadsl "ici ;  
Dictionary Search : OneLook (around 40 matching dictionaries) :  
a href=" onelook "onelook.com
a href=" breaking "Breaking News English
Making English easily for learning :  
a href=" dslvalley "ici
Dictionnaires anglais de mots - Traductions
a href=" larousse "Larousse English / French
Tester DSLvalley :  
a href=" dslvalley "ici
Dictionnaires anglais de mots - Traductions 

#!/bin/bash

###########  parametres
# retirer le dernier retour chariot de SOURCE
# il faut detacher le code (l'entourer d' un espace) pour qu'il soit un champ
SOURCE=source.txt
TARGET=target.txt
OUT=result.txt
############   fin des parametres

# 1ere methode (la plus courte)
#-------------
awk 'NR==FNR {arr[$1]=$2 ; next}
{print $1,$2,arr[$3],$4,$5,$6,$7,$8,$9}
' $SOURCE $TARGET

-----------------------------

# 2eme methode
#-------------
while read line
do

if [[ $line =~ "href=" ]] ; then 

            var1=`echo $line | sed 's/\(.*"\)\( \)\(.*\)\( \)\(".*\)/\3/'`  # ; echo $var1
            var2=`grep "$var1" $SOURCE | cut -d" " -f2`    #  ; echo $var2
            echo $line | sed 's/'$var1'/'$var2'/g'
            
else
echo $line 
fi
sleep 1
done < $TARGET

-----------------------------

# 3eme methode
#-------------
while read line
do

if ! [[ $line =~ "href=" ]] ; then echo $line
else
     while read col1 col2
     do
     if [[ $line =~ "href=" ]] ; then echo $line |
        awk '$0 ~ /'$col1'/ {sub( "'$col1'", "'$col2'" ) ; print}'
     else
     echo
     fi
     done < $SOURCE   

fi

sleep 1
done < $TARGET # > $OUT 

# resultat    (syntaxe detruite : les "0" ne sont pas aux bonnes colonnes)
To learn English : 0 0
a href=" link4 "ESL Cyber Listening Lab ; 0 0
Tester DEBIT ADSL :
a href=" link1 "ici ;
Dictionary Search : OneLook (around 40 matching dictionaries) :
a href=" link3 "onelook.com
a href=" link5 "Breaking News English
Making English easily for learning :
a href=" link2 "ici
Dictionnaires anglais de mots - Traductions
a href=" link6 "Larousse English / French
Tester DSLvalley :
a href=" link2 "ici
Dictionnaires anglais de mots - Traductions

haut

Un titre de paragraphe devient marqueur (en utilisant 'split')


# in.txt
entry one
100 first line data1
100 second line data2
entry two
101 first line data3
101 second line data4

#!/bin/bash
awk '{if( $1 == "entry" ) {e = $2}
else
{split( $0, d, " " ) ; print e, d[1], d[2], d[3], d[4]}
}' in.txt

# resultat
one 100 first line data1
one 100 second line data2
two 101 first line data3
two 101 second line data4

haut

Un titre de paragraphe devient marqueur (sans utiliser 'split')


# in.txt
@ accept
data
3line
@ agree
data
line6
@ believe
3data
9line

#!/bin/bash
awk '{
if($0 ~ /^@/) {e=$0 ; print substr(e,1,3),e}
else
{print}
}' in.txt | sed 's/@ /@/1' | sed 's/@/***/1' > inter.txt

awk '$1 ~ /\*\*\*a/ {i=i+1} {print $0,i}' inter.txt  |
awk '!a[$NF]++  {print $0 ; next} { sub($NF, "") ; print }' | sed 's/^ //g'

# resultat
***a @ accept 1
data
3line
***a @ agree 2
data
line6
***b @ believe
3data
9line

haut

Un champ d'une ligne devient titre de la ligne (sans utiliser 'split')


# FILE :
line1 data1 string
line2
line3 data2
line4 data3 pattern
line5
line6 data4
line7 data5 data
line8
line9 data6
end end end

#!/bin/bash
###################### parametres

FILE=in.txt
OUT=out.txt
# ajouter 1 ligne a la fin (manuellement) : end end end
# faire manuellement si pas possible en automatique
PATTERNS=in-patterns.txt   

############################# fin des parametres
# fichiers des patterns en automatique
awk '{print $3}' $FILE | grep "." > $PATTERNS

# deleter actions precedentes
rm $OUT

# script
N=1
# nombre de lignes du fichier des patterns
total=`sed -n '$=' $PATTERNS`
until [ "$N" -eq $total ]
do
S1=$N
S2=`expr $N + 1`
N=$S2
VAL1=`sed -n "$S1 p" $PATTERNS`
VAL2=`sed -n "$S2 p" $PATTERNS`
echo $VAL1 ; echo $VAL2 ; echo

   while read line
   do
   set -- $line

   if [[ "$3" == "$VAL1" ]] ; then w1=`echo $3` ; echo $w1 $line | awk '{if($NF = "$VAL1") {$NF=""} {print}}'  ; fi

   if [[ "$3" != "$VAL1" ]] && [[ "$3" != "$VAL2" ]] ; then echo $w1 $line  ;   fi

   if [[ "$3" == "$VAL2" ]] ; then  exit ; fi

   done < $FILE | grep "^$VAL1"  >> $OUT       # boucle dans $FILE

done     # boucle dans $PATTERNS

# resultat : $OUT
string line1 data1 
string line2
string line3 data2
pattern line4 data3 
pattern line5
pattern line6 data4
data line7 data5 
data line8
data line9 data6

haut

Repeter un nombre de fois (valeur en colonne 2), un pattern situe en colonne 1


#!/bin/bash

####### parametres

IN=in.txt

SLEEP=0

OUT=out.txt

############ fin des parametres

# IN
# a 2
# b 4
# c 3

while read col1 col2
do

    counter=1
    until [ $counter -gt $col2 ]
    do
    echo $col1 "$counter"
    let counter=counter+1
    done

sleep $SLEEP
done < $IN > $OUT

# OUT
# a 1
# a 2
# b 1
# b 2
# b 3
# b 4
# c 1
# c 2
# c 3

haut

Occurrences d'un pattern (syntaxe courte)


#!/bin/bash

# fichier in.txt
# -----
# 1001 1
# 2001 2
# 3001 3
# -----
# 4001 4
# 5001 5
# 6001 6
# 7001 7
# -----
# 8001 8
# 9001 9
# 10001 10

# marquer l'occurence d'un pattern
awk '{
if($1 ~ /^-----/) {i=i+1 ; print $0" tape "i}
else
{print}
}' in.txt

# resultat
# ----- tape 1
# 1001 1
# 2001 2
# 3001 3
# ----- tape 2
# 4001 4
# 5001 5
# 6001 6
# 7001 7
# ----- tape 3
# 8001 8
# 9001 9
# 10001 10

haut

Occurrences d'un pattern


Recherche sur la lettre "a"

# in.txt
a data-one.txt
a data-two.txt
a data-three.txt
b data-four.txt
b data-five.txt

#!/bin/bash
awk '$1 ~ /a/ { i=i+1 } END {print i}' in.txt

# resultat
3

haut

Occurrences d'un pattern - precision de sa position (exemple 1)


# $IN
@ heighten
transitive verb conjugaison
1.	 [make higher - building, ceiling, shelf]   conjugaison relever, conjugaison rehausser
2.	 [increase - effect, fear, pleasure]   conjugaison augmenter, conjugaison intensifier

@ heighten
intransitive verb conjugaison 
[fear, pleasure]   conjugaison augmenter, conjugaison monter 

######### parametres

pattern="conjugaison"
IN=in.txt

######### fin des parametres

awk 'BEGIN{count=0}
{
for(i=1;i<=NF;i++)
   {
   if($i == "'$pattern'")
      {print "line " NR " in field " i " data : "$0
      count++
      }   
   }
}
END {

print "\n Found " count " instances of : " "'$pattern'"
}' $IN

# resultat
line 2 in field 3 data : transitive verb conjugaison
line 3 in field 8 data : 1.	 [make higher - building, ceiling, shelf]   conjugaison relever, conjugaison rehausser
line 3 in field 10 data : 1.	 [make higher - building, ceiling, shelf]   conjugaison relever, conjugaison rehausser
line 4 in field 7 data : 2.	 [increase - effect, fear, pleasure]   conjugaison augmenter, conjugaison intensifier
line 4 in field 9 data : 2.	 [increase - effect, fear, pleasure]   conjugaison augmenter, conjugaison intensifier
line 7 in field 3 data : intransitive verb conjugaison 
line 8 in field 3 data : [fear, pleasure]   conjugaison augmenter, conjugaison monter 
line 8 in field 5 data : [fear, pleasure]   conjugaison augmenter, conjugaison monter 
Found 8 instances of : conjugaison

haut

Occurrences d'un pattern - precision de sa position (exemple 2)


Recherche sur le chiffre "0" en colonne 80

# in.txt
H0104 STREAMER DETAILS          MAL PORT STREAMER            1       0
H0105 OTHER DETAILS             OEX Outer STBD TAILBUOY      1           1
R 283 487217.26818026.9     284 487229.76818026.3     285 487242.26818025.6    9
R 286 487254.66818025.0     287 487267.16818024.3     288 487279.66818023.7    9
R   1 483732.86818401.6       2 483745.26818400.0       3 483757.66818398.4    0
R   4 483770.06818396.8       5 483782.46818395.3       6 483794.86818393.9    0
T                                                            1

#!/bin/bash
awk 'BEGIN{count=0}
{
for(i=1;i<=NF;i++)
   {
   if((substr($i,1,1) == "0") && (substr($0,80,1) == "0"))
      {print "line " NR " in field " i " colonne 80"
      count++
      }   
   }
}
END {
print
print "Found " count " instances of it"
}' in.txt 

# resultat
line 5 in field 8 colonne 80
line 6 in field 8 colonne 80

Found 2 instances of it

haut

Capturer ou deleter des lignes dont le mot en colonne 1 a une autre occurrence sur la ligne


# in.txt
hang let drop or droop
hang example: hang one's head in shame
hang of meat, in order to get a gamey taste
happen example: i happen to have just what you need!
happen come to pass
hold be pertinent or relevant or applicable
hold have room for; hold without crowding
hold keep in mind or convey as a conviction or view

# in-verbe.txt
hang
happen
hold

# 1_ en BASH (utilise 2 fichiers)
# but du script : deleter les lignes ayant 2 occurrences


# un fichier resultat est cree : out.txt  (a cause de la double redirection)

# deleter les anciennes actions
rm out.txt

# script
while read line
do

   while read verb
   do

   var1=`echo $line | awk '{f[j]=$0} {for(i=1;i<=NF;i++) if($i ~ /'$verb'/) {j++}} END {print $1,j}'` 

   # printer la ligne si l'occurrence du pattern est egal a 1
   if [[ `echo $var1 | cut -d" " -f2` == "1" ]] ; then echo $line  >> out.txt ; fi

   done < in-verbe.txt

done < in.txt

# out.txt
hang let drop or droop
hang of meat, in order to get a gamey taste
happen come to pass
hold be pertinent or relevant or applicable
hold keep in mind or convey as a conviction or view

###########################
###########################

# 2_ en AWK (utilise 1 fichier)
# but du script : capturer les lignes ayant 2 occurrences

# in.txt
hang    let drop or droop
hang    example: hang one's head in shame
hang    of meat, in order to get a gamey taste
------------------
happen  example: i happen to have just what you need!
happen  come to pass
------------------
hold    be pertinent or relevant or applicable
hold    have room for; hold without crowding
hold    keep in mind or convey as a conviction or view

# script
awk '{
if (length($0) > 0) {e=$1}
if (e ~ /-/) {next} {f=$1} {$1=""} {h=$0}

n=split (h, tab, " ")
for (k=1; k<=n; k++)

{if (f == tab[k]) print f" "h}

}' in.txt

# resultat
hang  example: hang one's head in shame
happen  example: i happen to have just what you need!
hold  have room for; hold without crowding

haut

Marquer les numeros des occurrences a partir d'une liste de patterns


# pattern.txt
a
b

# in.txt
a data-one.txt
a data-two.txt
a data-three.txt
b data-four.txt
b data-five.txt

#!/bin/bash
# deleter les actions precedentes
if [ -e out.txt ] ; then rm out.txt ; fi

for j in `cat pattern.txt`
do
awk '$1 ~ /'$j'/ {i=i+1} {print $0,i}' in.txt |
awk '!f[$NF]++ {print $0 ; next} {sub($NF, "") ; print}' |
awk '$NF !~ /t/ {print}' >> out.txt
done

# out.txt
a data-one.txt 1
a data-two.txt 2
a data-three.txt 3
b data-four.txt 1
b data-five.txt 2

haut

Deleter les occurrences repetees dans une colonne, et ne garder que la 1ere


# in.txt
a data-one.txt
a data-two.txt
a data-three.txt
b data-four.txt
b data-five.txt

#!/bin/bash
awk -F" " '!f[$1]++ {print $0 ; next}
{sub( $1, "" ) ; print}' in.txt

# resultat
a data-one.txt
  data-two.txt
  data-three.txt
b data-four.txt
  data-five.txt

haut

Occurrences d'un caractere dans plusieurs fichiers


# fichier  z1.txt
data1
data2
123 234 3451 456 567 678 7891
123 234 0001 456 567 555 7891
123 234 9991 456 567 666 7891
123 234 8881 456 567 777 7891
123 234 7771 456 567 888 7891
123 234 6661 456 567 999 7891

# fichier  z2.txt
data3
data4
124 234 3452 457 567 672 7890
124 234 0002 457 567 552 7890
124 234 9992 457 567 662 7890
124 234 8881 457 567 772 7890
124 234 7771 457 567 882 7890
124 234 6661 457 567 992 7890
 
# capture du 4eme caractere de la colonne 3
for i in `ls z*.txt`
do
awk '{print substr($3,4,1)}' $i>y-$i
done

# supprimer les lignes vides
for i in `ls y-z*.txt`
do
sed '/^$/d' $i > x$i
done

# frequence du caractere
for j in `ls xy-z*.txt`
do
   awk '{
   for (i=1; i<=NF; i++)
   mot[$i]++        # mot[$i]=mot[$i]+1
   }
   END {
   for (i in mot)
   print i " -->",mot[i]" occurrences"
   }' $j > v$j
done

# marquer nom du fichier devant chaque ligne
for i in vxy-z*.txt
do
seq=`ls $i  | cut -c5-10`
awk '{print seq" : ",$0}' seq=${seq} $i
echo "----"
done

# resultat

z1.txt :  1 --> 6 occurrences
----
z2.txt :  1 --> 3 occurrences
z2.txt :  2 --> 3 occurrences
----

haut

Afficher toutes les occurrences d'un titre


# but : afficher toutes les occurrences d'un titre (vtr oubien vi)

# in.txt
acquaint     LAR  vtr      @  acquaint  transitive      verb
acquaint     LAR           1. [ inform ] aviser, renseigner
acquaint     LAR           2. [ familiarize ]
act     LAR      vi   @   act  intransitive      verb
act     LAR           1. [ take action ] agir
act     LAR           2. [ serve ]
act     LAR           3. [ behave ] agir, se comporter
adapt         LAR    vtr    @ adapt transitive verb
adapt         LAR           1. [ adjust ] adapter, ajuster
adapt         LAR           2. [ book, play ] adapter
adapt      WR     vi      (change) s'adapter
adapt      WR             (to situation) s'adapter

#!/bin/bash

while read line
do
if [[ `echo $line|awk '{print $3}'` =~  "vtr"  ]] ; then e=`echo $line|awk '{print $3}'` ; echo $line
  elif [[ `echo $line|awk '{print $3}'` != "vtr" ]] && [[ `echo $line|awk '{print $3}'` != "vi" ]]
    then f=`echo $line|awk -F"LAR" '{print $1}'` ; g=`echo $line|awk -F"LAR" '{print $2}'` ; echo $f"   LAR   "$e  $g 
if [[ `echo $line|awk '{print $3}'` =~  "vi"  ]] ; then  $e="" ; break ; fi 
  elif [[ `echo $line|awk '{print $3}'` =~  "vi" ]]
    then e=`echo $line|awk '{print $3}'` ; echo $line 

else
echo "no"
fi
done < in.txt | awk '{a=$1 ; b=$2 ; c=$3 ; $1=$2=$3="" ; m=$0 ; printf ("%-12s %-5s %-5s %-15s\n",a,b,c,m)}'

# resultat
acquaint     LAR   vtr      @ acquaint transitive verb
acquaint     LAR   vtr      1. [ inform ] aviser, renseigner
acquaint     LAR   vtr      2. [ familiarize ]
act          LAR   vi       @ act intransitive verb
act          LAR   vi       1. [ take action ] agir
act          LAR   vi       2. [ serve ]
act          LAR   vi       3. [ behave ] agir, se comporter
adapt        LAR   vtr      @ adapt transitive verb
adapt        LAR   vtr      1. [ adjust ] adapter, ajuster
adapt        LAR   vtr      2. [ book, play ] adapter
adapt        WR    vi       (change) s'adapter
adapt        WR    vi       (to situation) s'adapter

haut

Addition d'une constante aux chiffres d'une colonne


# But du script : ajouter une constante (=480) aux 2 colonnes de droites
# on estime a 8 le nombre maxi de valeurs par ligne
# intervention manuelle au paste3.txt (ajout de zero a 1 champ vide)

# in.txt
a  @   67,132         @    0           @     102,230    @     0                        
b  @   67,227         @    0           @     102,230    @     439                      
c  @   67,132,227     @    0           @     102,230    @     439,469                  
d  @   132            @    0           @     102,230    @     0                        
e  @   0              @    352         @     102,230    @     259,439                  


#!/bin/bash

########## parametres

ADD=480

########## fin des parametres

# separer par @@ les 2 colonnes de droite ou sera ajoute 480
awk -F"@" '{printf ("%-10s %-30s %-30s %-30s %-30s\n",$1,$2,$3," @@ "$4,$5)}' in.txt > inter1.txt

# conserver les 3 colonnes de gauche
awk -F"@@" '{print $1}' inter1.txt > inter2-col1.txt


# traitement sur les 2 colonnes de droite
awk -F"@@" '{print $2}' inter1.txt > inter2-col2.txt

###################
# 1ere colonne de droite
awk '{print $1}' inter2-col2.txt > inter2-col2a.txt

# ajouter 480 a toutes les valeurs (on estime a 8 le nombre maxi de valeurs par ligne)
awk -F"," '{print $1+'$ADD',$2+'$ADD',$3+'$ADD',$4+'$ADD',$5+'$ADD',$6+'$ADD',$7+'$ADD',$8+'$ADD'}' inter2-col2a.txt | sed 's/480//g' | sed 's/ /,/g' | sed 's/[,]*$//g' > inter2-col2a2.txt

###################
# 2eme colonne de droite
awk '{print $2}' inter2-col2.txt > inter2-col2b.txt

# ajouter 480 a toutes les colonnes
awk -F"," '{print $1+'$ADD',$2+'$ADD',$3+'$ADD',$4+'$ADD',$5+'$ADD',$6+'$ADD',$7+'$ADD',$8+'$ADD'}' inter2-col2b.txt | sed 's/480//g' | sed 's/ /,/g' | sed 's/[,]*$//g' > inter2-col2b2.txt

########################
paste inter2-col1.txt inter2-col2a2.txt inter2-col2b2.txt > paste1.txt

# habillage
sed 's/\t/      /g' paste1.txt | awk '{printf ("%-10s %-30s %-30s %-30s %-30s\n",$1,$2,$3,$4,$5)}'> paste2.txt

# paste3 fait manuellement (ajouter zero a un champ vide)
awk '{print "     ("$1"),("$2","$3","$4","$5"),F1.0,"}' paste3.txt > paste4.txt

# resultat
     (a),(67,132,0,582,710,0),F1.0,
     (b),(67,227,0,582,710,919),F1.0,
     (c),(67,132,227,0,582,710,919,949),F1.0,
     (d),(132,0,582,710,0),F1.0,
     (e),(0,352,582,710,739,919),F1.0,

haut

Deleter des lignes semblables consecutives


# in.txt
Apercu complet du demarrage de Windows
Apercu complet du demarrage de Windows
Apercu complet du demarrage de Windows
Apercu complet du demarrage de Windows
background-color: #e1ddc3
background-color: #e1ddc3
background-color: #e1ddc3

#!/bin/bash
awk '{
#lignes mises en tableau
f[NR] = $0}
END {
for(i=1;i<=NR;i++)
#si ligne 'i+1' est egale a 'i' :
if (f[i+1] == f[i])
#ajouter 1 marqueur
{print f[i],"  %%"}
else
#sinon lire la ligne sans marqueur
{print f[i]}
}' in.txt | grep -v "%%$"

# resultat
Apercu complet du demarrage de Windows
background-color: #e1ddc3

haut

Incrementer des lignes consecutives de format identique, le compteur est mis a zero ensuite


# in.txt
title1
 sentence one
 sentence two
 sentence three
   [example 1]
title2
 sentence four
 sentence five
title3
   [example 2]

#!/bin/bash
# ajouter un signe devant les lignes qu'on veut incrementer
sed 's/^ [a-z]/%% &/g' in.txt > inter1.txt

# incrementer les consecutives ; remettre a zero ensuite
awk '{
if($0 ~ /^%%/) {i=i+1} {print i,$0}
if($0 !~ /^%%/) {i=""}
}' inter1.txt | awk '($0 ~ /^[1-9]/) && ($1 ~ /[1-9]/) && ($2 !~ /%%/) {$1=""} {print}'

# resultat 
 title1
1 %%  sentence one
2 %%  sentence two
3 %%  sentence three
 [example 1]
 title2
1 %%  sentence four
2 %%  sentence five
 title3
    [example 2]

haut

Joindre un signe avec la ligne suivante (exemple 1)


# in.txt
data 123:
line2
data 456:
line4

sed -e :a -e '/:$/N ; s_\n__ ; ta' in.txt | sed 's/:/ /g'

# resultat
data 123 line2
data 456 line4

haut

Joindre un signe avec la ligne suivante (exemple 2)


# in.txt
data 123:
line2
data 456:
line4

awk '{
while ( $0 ~ /\:$/ )
{getline record
$0 = $0 " " record}
print $0
}' in.txt | sed 's/://g'

# resultat
data 123 line2
data 456 line4

haut

Joindre un signe avec la ligne suivante (exemple 3)(awk + getline)


#in.txt
data4
data5
data6\
data7

awk '{
line = $0
#print line
#print substr(line, length(line),1)
#print substr(line, 1, length(line)-1)

if (substr(line, length(line),1) == "\\")    # choisir ici le signe
i=getline
if (i > 0)
         {line = line" "$0}
         else
          {printf("missing continuation on line %d\n" , NR)}
     print line

}' in.txt | grep -v "missing continuation"

# resultat
data4
data5
data6\ data7

haut

Joindre un signe au bout de la ligne precedente (exemple 1)


# in.txt
data 123
=line2
data 456
=line4
=line5

sed -e :a -e '$!N ; s/\n=/ / ; ta' -e 'P;D' in.txt

# resultat
data 123 line2
data 456 line4 line5

haut

Joindre un signe au bout de la ligne precedente (exemple 2)


# in.txt
data 123
=line2
data 456
=line4
=line5

awk 'END { print r }
r && !/^=/ { print r ; r = "" }
{ r = r ? r $0 : $0 }
' in.txt | sed 's/=/ /g'

# resultat
data 123 line2
data 456 line4 line5

haut

Joindre un signe au bout de la ligne precedente sauf si cette derniere se termine par @ (exemple 3)


# in.txt
data 123
=line2
data 456@
=line4
=line5

awk 'END { print r }
r ~ /@$/ || !/^=/ { print r ; r = "" }
{ r = r ? r $0 : $0 }
' in.txt | sed 's/=/ /g' | sed 's/^ //g'

# resultat
data 123 line2
data 456@
line4 line5

haut

Un signe en debut de ligne 1, fait joindre la ligne 2 a la suite de la 1


# in.txt
@ arise
intransitive verb  
1.	 [appear, happen]     survenir,   se presenter 
2.	 [result]   resulter 

###### parametres
SIGNE="@"
###### fin des parametres

awk '
$0 ~ /^'$SIGNE'/ {e=$0 ; getline record ; f=e" "record}
{if( $1 == "'$SIGNE'" ) 
print f

else
print

}' in.txt

# resultat
@ arise intransitive verb  
1.	 [appear, happen]     survenir,   se presenter 
2.	 [result]   resulter 

haut

Les lignes qui commencent par un signe collent les suivantes a leur fin si elles ne possedent pas ce signe


# in.txt (ajouter un blanc a la fin des lignes)
data 123
@line2
@data 456
line4
line5

awk 'NR > 1 && /^@/ {print ""}
{printf $0}
END {print ""}
' in.txt

# resultat
data 123 
@line2 
@data 456 line4 line5 

haut

Printer les lignes du fichier2 qui manquent dans le fichier1


# ina.txt
accept
access
accomplish
accumulate

# inb.txt
accept
access
accommodate
accomplish
accord
accumulate

#!/bin/bash
comm -23 inb.txt ina.txt  2>dev

# resultat
accommodate
accord

haut

Comparer 2 fichiers : identiques ou differents


#!/bin/bash

# a.txt
data1
data2

# b.txt
data1
data2
data3

if cmp a.txt b.txt  &> /dev/null
then echo "a et b identiques"
else echo "a et b differents"
fi

# resultat
a et b differents

haut

Intersection de 2 fichiers : lignes uniques et communes



# PREREQUIS : verifier que les fichiers a comparer ne comportent pas
# la sequence suivante : "      >" car elle provoquera une erreur dans le script.

# in1.txt
keep me advised of your progress
these problems are currently being investigated
until further notice
i visit him less than i should

# in2.txt
keep me advised of your progress
a lot of people are addicted to sugar
until further notice
the hectic pace of everyday life
we are relying on good weather

#!/bin/bash
ARGS=2    # 2 arguments attendus par le script
E_MAUVAISARGS=65
E_ILLISIBLE=66

if [ $# -ne "$ARGS" ]
then
echo "usage: `basename $0` fichier1 fichier2"
exit $E_MAUVAISARGS
fi

if [[ ! -r "$1" || ! -r "$2" ]]
then
echo "les 2 fichiers a comparer doivent etre lisibles"
exit $E_ILLISIBLE
fi

# lignes uniques de chaque fichier
diff --side-by-side <(sort $2) <(sort $1) | egrep "      >|     \|" | sed 's_      >_@@@@@_g' | 
sed 's_      |_@@@@@_g' | sed 's_\(.*\)\(@@@@@\)\(.*\)_\3_g' | sed 's/\t//g' | awk '{print "lignes uniques a '$1': "$0}' > tmp1.txt
diff --side-by-side <(sort $1) <(sort $2) | egrep "      >|     \|" | sed 's_      >_@@@@@_g' | 
sed 's_      |_@@@@@_g' | sed 's_\(.*\)\(@@@@@\)\(.*\)_\3_g' | sed 's/\t//g' | awk '{print "lignes uniques a '$2': "$0}' >> tmp1.txt

# lignes communes
comm <(sort $1) <(sort $2) | awk '$0 ~ /^\t\t/ {print}' | sed 's/\t\t/lignes communes: /g' >> tmp1.txt

# habillage
grep "lignes uniques a "$1":" tmp1.txt | wc -l | awk '{print "    _ "$0" lignes uniques a '$1':"}' > tmp2.txt
cat tmp1.txt | grep "lignes uniques a "$1":" | sed 's/lignes uniques a '$1': //g' >> tmp2.txt
echo >> tmp2.txt
grep "lignes uniques a "$2":" tmp1.txt | wc -l | awk '{print "    _ "$0" lignes uniques a '$2':"}' >> tmp2.txt
cat tmp1.txt | grep "lignes uniques a "$2":" | sed 's/lignes uniques a '$2': //g' >> tmp2.txt
echo >> tmp2.txt
grep "lignes communes:" tmp1.txt | wc -l | awk '{print "    _ "$0" lignes communes:"}' >> tmp2.txt
cat tmp1.txt | grep "lignes communes:" | sed 's/lignes communes: //g' >> tmp2.txt
cat temp2.txt

# resultat
    _ 2 lignes uniques a in1.txt
i visit him less than i should
these problems are currently being investigated

    _ 3 lignes uniques a in2.txt
a lot of people are addicted to sugar
the hectic pace of everyday life
we are relying on good weather

    _ 2 lignes communes
keep me advised of your progress
until further notice

haut

Un titre de paragraphe est capture a un pattern


# in.txt
entry 1
data1

entry 2
data2

#!/bin/bash
# 1ere syntaxe  ( capture du titre de paragraphe )
awk '/^entry/ {cnt=1} cnt -- > 0' in.txt

# 2eme syntaxe  ( capture de la ligne blanche avant le titre )
awk 'NR==1 || cnt -- > 0 ; /^$/ {cnt=1}' in.txt

# resultat
entry 1
entry 2

haut

Operations entre lignes 'n+1' et 'n'


# in.txt
10
30
100
10

#!/bin/bash
FILE=in.txt
N=1
# nombre de lignes du fichier
total=`sed -n '$=' $FILE`
until [ "$N" -eq $total ]
do
S1=$N
S2=`expr $N + 1`
N=$S2
VAL1=`sed -n "$S1 p" $FILE`
VAL2=`sed -n "$S2 p" $FILE`
expr $VAL2 - $VAL1
done

# resultat
20
70
-90

haut

Supprimer des caracteres entre 2 bornes connues


# in.txt
<gpx>123<cmp>data1</cmp></gpx>
<gpx>456<cmp>data2</cmp></gpx>
#       ^^^^^^^^^^^^^^^^        partie a supprimer

while read line
do
echo $line | sed 's_\(.*\)\(<cmp>\)\(.*\)\(</cmp>\)\(.*\)_\1\5_'
#                           ^^^^^          ^^^^^^
#                      1      2       3       4       5
done < in.txt

#resultat
<gpx>123</gpx>
<gpx>456</gpx>

haut

Suppression de lignes doubles


# in.txt
data1
line
data2
line

#!/bin/bash
awk '!x[$0]++' in.txt

# resultat
data1
line
data2

haut

Derniere modification : Octobre 2014