TP4---EXOS2-6

# TP4 --- Exercice 5
#!/bin/bash

easier() {
    # ^ indique le début de la ligne, $ la fin
    debut=$( grep -n "^### BEGIN $2$" $1 | cut -d":" -f1 )
    debut=$((debut+1))
    fin=$( grep -n "^### END $2$" $1 | cut -d":" -f1 )
    fin=$((fin-1))
    head -n $fin $1 | tail -n +$debut | cut -c 3-
}

easier $1 $2

extrait() {
    lecture=0
    while read ligne; do
        if [ "$ligne" = "### END $2" ]; then
            lecture=0
        fi
        if [ $lecture -eq 1 ]; then
            echo "$ligne" | cut -c 3-
        fi
        if [ "$ligne" = "### BEGIN $2" ]; then
            lecture=1
        fi
    done < $1
}

extrait $1 $2 > $2

# TP4 --- Exercice 6
#!/bin/bash

# version alternative
#!/bin/bash
#!/bin/bash
#!/bin/bash
afficherNotes() {
    premiereNote=$(head -n1 $1 |cut -d ';' -f2)
    eleveNote=$premiereNote
    faibleNote=$premiereNote
    # IFS permet de spécifier un nouveau délimiteur pour lire le fichier
    while IFS=";" read etudiant note
    do
        if [[ $(echo "$note < $faibleNote" | bc) -eq 1 ]] ; then
                faibleNote=$note
        fi
        if [[ $(echo "$note > $eleveNote" | bc) -eq 1 ]]; then
                eleveNote=$note
        fi
    done < "$1"
    echo "Note la plus elevé pour '$2': $eleveNote; Note la plus faible: $faibleNote"
}
for nom in $(ls "$1")
do
    fichier="$1/$nom"
    if [ -f $fichier ]; then
        afficherNotes "$fichier" "$nom"
    fi
done

afficherNotes $1

oneliner() {
    for nom in $(ls "$1"); do
        noteMin=$( sort -rn -k2 -t";" "$1/$nom" | tail -n 1 | cut -d";" -f2)
        noteMax=$( sort -rn -k2 -t";" "$1/$nom" | head -n 1 | cut -d";" -f2)
        echo $nom "note max = "$noteMax "note min = "$noteMin
    done
}

oneliner $1

minMax() {
#  Attention : protection des noms de fichiers avec "" pour gérer les espaces
    for nom in $( ls "$1"); do
        nbLignes=$( wc -l < "$1/$nom")
        ligne=$(cat "$1/$nom" | head -n 1 | tail -n 1)
        noteMax=$( echo $ligne | cut -d ';' -f2)
        noteMin=$noteMax
        for i in $( seq 2 $nbLignes); do
            ligne=$(cat "$1/$nom" | head -n $i | tail -n 1)
            note=$( echo $ligne | cut -d ';' -f2)
            if [ $(echo "$note > $noteMax" | bc) -eq 1  ]; then
            # pour des valeurs entières
            #if [ $note -gt $noteMax ]; then
                noteMax=$note
            elif [ $(echo "$note < $noteMin" | bc) -eq 1 ]; then
            # pour des valeurs entières
            # elif [ $note -lt $noteMin ]; then
                noteMin=$note
            fi
        done
        echo $nom "note max = "$noteMax "note min = "$noteMin
    done
}

minMax $1

maxEtud() {
    max=0
    nomMax=""
    for nom in $( ls "$1"); do$
    # si f est un fichier régulier
    if [ -f $nom ]; then
            #nbLignes=$( cat "$1/$nom" | wc - l)
            nbLignes=$( wc -l < "$1/$nom")
            if [ $nbLignes -gt $max ]; then
                max=$nbLignes
                nomMax=$nom
        fi
    fi
    done
    # pour afficher *proprement* le nom du module, il faudrait enlever le ".csv"
    echo $nomMax
}

maxEtud $1

# TP4 --- Exercice 4
#!/bin/bash
fichier=$1

tatin() {
    while read ligne; do
        miroir=""
        # attention : ne pas utiliser "$ligne" (le découpage ne se fera pas sinon)
        for mot in $ligne; do
            miroir="$mot $miroir"
        done
        echo $miroir
    done
}

if [ $# -eq 1 ]; then
    tatin < $1
else
    tatin
fi

# TP4 --- Exercice 3
# la version one-liner
#!/bin/bash
if [ $# -ne 1 ]; then
    echo "Usage : bash $0 nom_fichier"
    exit 1
fi
nombre_doublons=$(sort $1 | uniq -c | sort -rn | head -n 1 | tr -s " " | cut -d" " -f2,3)

if [ $(echo "$nombre_doublons" | cut -c1) -eq 1 ]; then
    echo "Aucun doublon dans le fichier"
else
    echo "Doublon détecté : $nombre_doublons"
fi

# en utilisant des fonctions (cf slide 10 CM scripts)
#!/bin/bash
compter_ligne() {
    # compte et retourne le nb d’occurrences d’un mot dans un fichier
    # $2 est le fichier et $1 le mot à chercher
    n=0
    nblignes=$( cat $2 | wc -l )
    for i in $(seq $nblignes); do
        # récupère la ième ligne du fichier
        ligne=$( head -n $i $2 | tail -n 1 )
        if [ $ligne = $1 ]; then
            n=$((n+1))
        fi
    done
    return $n
}

compter_ligne $1 $2
# $? permet de récupérer la valeur de retour de la fonction appelée précédemment
result=$?
echo $result

compter_max() {
    # cherche le mot avec le nb d’occurrences maximal
    # retourne le 1er n°de ligne d’apparition du mot
    taille=$( cat $1 | wc -l )
    ligneMax=$( cat $1 | head -n 1 | tail -n 1)
    compter_ligne $ligneMax $1
    # $? contient le résultat retourné par chercher_ligne
    max=$?
    for i in $(seq 2 $taille); do
        ligne=$( cat $1 | head -n $i | tail -n 1)
        compter_ligne $ligne $1
        n=$?
        # la valeur de n est-elle plus grande que le max trouvé jusqu'à présent ?
        if [ $max -lt $n ]; then
            max=$n
            ligneMax=$ligne
        fi
    done
    # l'affichage se fait même si $max vaut 1 ; il faudrait une conditionnelle supplémentaire
    echo $max/$ligneMax
}

# l'appel final du script
compter_max $1

# TP4 --- Exercice 2
#!/bin/bash
prix=$1
recette=$2

# on enleve les lignes d'entete et on trie alphabetiquement
# on sauve dans tmp
tail -n +3 $1 | sort > /tmp/prix
#idem
tail -n +3 $2 | sort > /tmp/recette
# on joint les 2 fichiers nettoyés et on ne garde que le prix et la qte

join /tmp/recette /tmp/prix | tr -s " " | cut -d" " -f2,4 > /tmp/rp

somme=0

# on lit /tmp/rp et pour chaque ligne on met le 1er mot dans q et le deuxieme dans p
while read q p; do
    # on utilise bc parce que c'est pas des entiers
    somme=$(echo "$somme+$q*$p" | bc)
done < /tmp/rp

echo $somme