Ce site est optimisé pour être consulté depuis un navigateur moderne dans lequel JavaScript est activé.

[ VOS SCRIPTS UTILES ] (et eventuelles demandes de scripts...)

uboops

Plus un compteur pour ne pas avoir a relancer le script à chaque fois ( et la condition: si aujourd'hui) !

#!/bin/bash
# Version 3.0 - Final release
# Donne le jour correspondant à une date donnée.

clear

var=200
while [ $var -ge 0 ]
	do
	  echo "var = $var"

		#Demande la date à rechercher
	echo -e "# Jour recherché #\n##################\n"
	echo -n "    n°    : " ; read num ; [ "$num" -le 31 ] || exit 0
	echo -n "    Mois  : " ; read mois ; [ "$mois" -le 12 ] || exit 0
	echo -n "    Année : " ; read annee ; [ "$annee" -ge 1 ] || exit 0

	#Traitement différentiel selon le numéro du jour
	if [ "$num" -le 9 ]
	then
	  num=`echo $num | sed 's/^0//1'`
	  jour=`ncal "$mois" "$annee" | grep "$num" | sed -n '/.*  '$num'/p' | cut -d " " -f1 | sed '/^$/d'`
	else
	  jour=`ncal "$mois" "$annee" | grep "$num" | cut -d " " -f1 | sed '/^$/d'`
	fi

	#Mise en page
	case "$jour" in
	  lu ) jour="Lundi";;
	  ma ) jour="Mardi";;
	  me ) jour="Mercredi";;
	  je ) jour="Jeudi";;
	  ve ) jour="Vendredi";;
	  sa ) jour="Samedi";;
	  di ) jour="Dimanche";;
	esac

	#Vérification de la cohérence de la date
	verif=`echo $jour | wc -w`
	[ "$verif" = 0 ] && echo -e "\nLe $num/$mois/$annee n'a jamais existé !!\n" && exit 0

	aujourd=$(date +%Y)

	if [ "$annee" -gt "$aujourd" ]
	  then mot="sera"
	  else mot="était"
	fi

	if [ "$annee" -eq "$aujourd" ]
	  then mot="aujourd'hui c'est"
	fi

	#Affichage du jour correspondant
	echo -e "\nLe $num/$mois/$annee $mot un $jour.\n"

var=`expr $var - 1`
done

exit 0

twocats

Fenouille84 a écritMon script dépasse bien l'année 2012 😉

Euh... date aussi, hein !

twocats

Quelques modifications. Je n'ai pas modifié la partie concernant ncal mais celui-ci reste totalement inutile par rapport à date.

#!/bin/bash

# Version 3.0 - Final release
# Donne le jour correspondant à une date donnée.

clear

var=200
while [ $var -ge 0 ]
    do
      echo "var = $var"

        #Demande la date à rechercher
    echo -e "# Jour recherché #\n##################\n"
echo -n "    n°    : "
read num
while [[ $(echo ${num} | grep [^[:digit:]]) || "${num}" -gt 31 || "${num}" = 0 ]]
do
	case ${num} in
		q* | Q*)
			echo -e "Quitte sans erreur."
			exit 0
			;;
	esac
	echo -e "Entrée incorrecte. Veuillez recommencer.
"
	echo -ne "> Entrez le jour de la date à analyser [ ou Quitter ] : "
	read num
done

echo -n "    Mois  : "
read mois
while [[ $(echo ${mois} | grep [^[:digit:]]) || "${mois}" -gt 12 || "${mois}" = 0 ]]
do
	case ${mois} in
		q* | Q*)
			echo -e "Quitte sans erreur."
			exit 0
			;;
	esac
	echo -e "Entrée incorrecte. Veuillez recommencer.
"
	echo -ne "> Entrez le mois de la date à analyser [ ou Quitter ] : "
	read mois
done
echo -n "    Année : "
read annee
while [[ $(echo ${annee} | grep [^[:digit:]]) ]]
do
	case ${annee} in
		q* | Q*)
			echo -e "Quitte sans erreur."
			exit 0
			;;
	esac
	echo -e "Entrée incorrecte. Veuillez recommencer.
"
	echo -ne "> Entrez l'année de la date à analyser [ ou Quitter ] : "
	read annee
done
#Traitement différentiel selon le numéro du jour
    if [ "$num" -le 9 ]
    then
      num=`echo $num | sed 's/^0//1'`
      jour=`ncal "$mois" "$annee" | grep "$num" | sed -n '/.*  '$num'/p' | cut -d " " -f1 | sed '/^$/d'`
    else
      jour=`ncal "$mois" "$annee" | grep "$num" | cut -d " " -f1 | sed '/^$/d'`
    fi

    #Mise en page
    case "$jour" in
      lu ) jour="Lundi";;
      ma ) jour="Mardi";;
      me ) jour="Mercredi";;
      je ) jour="Jeudi";;
      ve ) jour="Vendredi";;
      sa ) jour="Samedi";;
      di ) jour="Dimanche";;
    esac

    #Vérification de la cohérence de la date
    verif=`echo $jour | wc -w`
    [ "$verif" = 0 ] && echo -e "\nLe $num/$mois/$annee n'a jamais existé !!\n" && exit 0

    aujourd=$(date +%Y)

    if [ "$annee" -gt "$aujourd" ]
      then mot="sera"
      else mot="était"
    fi

    if [ "$annee" -eq "$aujourd" ]
      then mot="aujourd'hui c'est"
    fi

    #Affichage du jour correspondant
    echo -e "\nLe $num/$mois/$annee $mot un $jour.\n"

var=`expr $var - 1`
done

exit 0

twocats

Une version utilisant uniquement 'date' :

#!/bin/bash

# Version 3.0 - Final release
# Donne le jour correspondant à une date donnée.

clear

var=200
while [ $var -ge 0 ]
    do
      echo "var = $var"

        #Demande la date à rechercher
    echo -e "# Date recherchée [ ou 'Q'uitter ] #\n###################################\n"
echo -en "> Jour\t: "
read num
while [[ $(echo ${num} | grep [^[:digit:]]) || "${num}" -gt 31 || "${num}" = 0 ]]
do
	case ${num} in
		q* | Q*)
			echo -e "Quitte sans erreur."
			exit 0
			;;
	esac
	echo -e "Entrée incorrecte. Veuillez recommencer.
"
	echo -ne "> Entrez le jour de la date à analyser [ ou Quitter ] : "
	read num
done

echo -en "> Mois\t: "
read mois
while [[ $(echo ${mois} | grep [^[:digit:]]) || "${mois}" -gt 12 || "${mois}" = 0 ]]
do
	case ${mois} in
		q* | Q*)
			echo -e "Quitte sans erreur."
			exit 0
			;;
	esac
	echo -e "Entrée incorrecte. Veuillez recommencer.
"
	echo -ne "> Entrez le mois de la date à analyser [ ou Quitter ] : "
	read mois
done
echo -en "> Année\t: "
read annee
while [[ $(echo ${annee} | grep [^[:digit:]]) ]]
do
	case ${annee} in
		q* | Q*)
			echo -e "Quitte sans erreur."
			exit 0
			;;
	esac
	echo -e "Entrée incorrecte. Veuillez recommencer.
"
	echo -ne "> Entrez l'année de la date à analyser [ ou Quitter ] : "
	read annee
done

    aujourd=$(date +%Y)

    if [ "$annee" -gt "$aujourd" ]
      then mot="sera"
      else mot="était"
    fi

    if [ "$annee" -eq "$aujourd" ]
      then mot="aujourd'hui c'est"
    fi
# Affichage du jour correspondant
echo
date -d ${mois}/${num}/${annee} "+Le %d/%m/%Y ${mot} un %A"
echo
let var--
done

exit 0

BorX

jourDate.sh :

#!/bin/bash

date_demandee="$1"

[ $(date -d "$date_demandee" +%s) -gt $(date +%s) ] && verbe='sera' || verbe='était'
date -d "$date_demandee" "+Le %d %B %Y $verbe un %A"

$ ./jourDate.sh 01/15/1978
Le 15 janvier 1978 était un dimanche
$ ./jourDate.sh 01/15/2078
Le 15 janvier 2078 sera un samedi

Fenouille84

Énorme ta soluce BorX !! 🙂

Mais on peut pas intégrer la demande de date dans le script, avec une petite présentation ? :rolleyes:
Sa éviterait de l'entrer au lancement du script, et sa éviterait les erreurs de saisie je pense :/

Edit : j'ai quelques soucis avec les grandes dates : limite => 20 Janvier 2038 !!

date: date invalide `1/20/2038'
/home/math/Script/b: line 8: [: -gt : opérateur unaire attendu
date: date invalide `1/20/2038'

math@math-laptop:~$ b 1/19/2038
Le 19 janvier 2038 sera un mardi

[/i]
Bon j'avoue, c'est inutile d'aller aussi loin 😛 :lol:
Mais je voudrais bien un truc un peu moins borné si possible 😃

wido

$ sh /home/wido/date.sh 12/31/9999
Le 31 décembre 9999 sera un vendredi

et bien c'est vraiment utile de le savoir :lol:

EDIT: encore plus fort:

sh /home/wido/date.sh 12/31/12157521922
Le 31 décembre -727379966 était un dimanche

la roue tourne...

BorX

Fenouille84 a écritÉnorme ta soluce BorX !! 🙂

Mais on peut pas intégrer la demande de date dans le script, avec une petite présentation ? :rolleyes:
Sa éviterait de l'entrer au lancement du script, et sa éviterait les erreurs de saisie je pense :/

Edit : j'ai quelques soucis avec les grandes dates : limite => 20 Janvier 2038 !!
date: date invalide `1/20/2038'
/home/math/Script/b: line 8: [: -gt : opérateur unaire attendu
date: date invalide `1/20/2038'

math@math-laptop:~$ b 1/19/2038
Le 19 janvier 2038 sera un mardi
[/i]
Bon j'avoue, c'est inutile d'aller aussi loin 😛 :lol:
Mais je voudrais bien un truc un peu moins borné si possible 😃

Désolé pour ma réponse évasive, mais c'est la voie qu'il faut suivre : 😛
La programmation, c'est répondre à un besoin en le découpant en multiples problématiques.
Ne cherche jamais à faire un truc qui fait tout : découpe chaque gros problème en plein de petits problèmes, et apporte une petite solution à chacun d'eux, l'un après l'autre.
Là, je ne t'apporte qu'une petite solution, en substitution à l'usine à gaz que tu étais en train de monter. :lol:
Libre à toi maintenant d'ajouter les modes de saisie et les contrôles que tu souhaites au début du script.

Un dernier conseil : tu peux éventuellement remettre en question les derniers gadgets de Microsoft s'ils ne marchent pas comme tu veux ; mais les GNU, toujours tu réfléchiras avant de les remettre en cause ! 🙂
date est un outil parmi tant d'autres utilisés par des systèmes très très costauds depuis des années.
1/ Tu penses bien qu'ils répondent à ce genre de question depuis longtemps
2/ Tu peux faire confiance à leur fiabilité et considérer que s'ils s'utilisent de telles ou telles façons, c'est pour de bonnes raisons.
D'où un dernier conseil : ne réinvente pas la roue, et cherche plutôt la roue qui correspondra le mieux au carrosse que tu conçois.

Fenouille84

BorX a écritD'où un dernier conseil : ne réinvente pas la roue, et cherche plutôt la roue qui correspondra le mieux au carrosse que tu conçois.

+1 😉

michel_04

Bonjour,

J'ai hésité à poster dans Bureautique ....
Je dois modifier le contenu d'une seule cellule (cellule AMI65536) dans plus d'un millier de fichier.ods (OOo Calc).
Les noms des fichiers sont fichier2009100, fichier2009101, etc...
Les fichiers sont tous dans le même répertoire.
Est ce qu'il y a une possibilité (script ?) sans être obligé d'ouvrir les fichiers un par un et de modifier le contenu de cette cellule à la main ?

Edit :
J'allais oublier :
Comment convertir ce millier de fichiers en PDF (devait être fait, mais ça a été oublié), sans être obligé d'ouvrir chaque fichier pour l'exporter en PDF ?

Merci
A+

epictete

SCRIPT « C'EST DANS L'AIR » ET LOGICIEL « ARTE+7 RECORDER »

Bonjour, au post #99, page 4, à cette adresse :

http://forum.ubuntu-fr.org/viewtopic.php?pid=1698887#p1698887

Beudbeud nous avait fourni un remarquable script pour enregistrer automatiquement l'émission C dans l'air de France5 et la stocker avec la date et le titre.

Malheureusement ce script ne fonctionnait plus. Il a bien voulu se pencher sur la question, trouver le problème (nouveau codage php des pages de France5 et émission du jour disponible seulement à 20 heures) et écrire une nouvelle version.

Voici donc son nouveau script :

#!/bin/bash -x
#script de beudbeud
 
#creation du répertoire
mkdir -p $HOME/Vidéos/c_dans_l_air/

#récupération de l'id
IDART=`wget -O - -q http://www.france5.fr/c-dans-l-air/index-fr.php?page=accueil | grep 'href="index-fr.php?page=resume&id_article=' | awk -F'"' '{print $2}'`

#récupération du titre de l'émission
TITREBASE=`wget -O - -q "http://www.france5.fr/c-dans-l-air/$IDART" | grep 'class="t18 bleuclair bold' | awk -F">" '{print $2}' | awk -F"<" '{print $1}'`
TITRE=`echo $TITREBASE | iconv -c | tr '[àâäéèêëîïôöùûü]' '[aaaeeeeiioouuu]' | sed -e "s/[[:space:]]/_/g" | sed -e "s/\/$//" | sed -e "s/'/_/g" |  sed -e "s/-/_/g" | sed -e "s/__/_/g"`

#récupération de la date de l'émission
DATE=`date +%d%m%Y`

#récupération du lien mms
URL="http://www.france5.fr/c-dans-l-air/$IDART"
FILE1=`wget -O - -q "$URL" | grep mms | awk -F='"' '{print $2}' | awk -F'"' '{print $1}'`

#téléchargement
mimms -c $FILE1 $HOME/Vidéos/c_dans_l_air/"$DATE"_"$TITRE".wmv

#message de fin
echo message:enregistrement de c dans lair terminé| zenity --notification --listen --window-icon="info"

De plus, il faut maintenant paramétrer cron pour 20:10 heures :

crontab -e

et on ajoute les lignes suivantes :

DISPLAY=":0.0"
# m h  dom mon dow   command
10 20 * * 2,3,4,5,6 emplacement/du/script/cdanslair.sh

ou si on utilise fcron

fcrontab -e

et ensuite

	&10 20 * * 2,3,4,5,6 emplacement/du/script/cdanslair.sh

Merci à Beudbeud pour sa disponibilité et sa patience face à un newbie, un nouvel exemple de la belle mentalité qui règne sur ubuntu.fr.

Ne passez pas à côté de son génial soft arte+7recorder qui vous permet de télécharger les émissions mises à disposition sur le site de vidéo à la demande d’Arte pendant 7 jours après la diffusion hertzienne : http://plus7.arte.tv.

Vous trouverez ici une présentation du logiciel avec des screenshots démonstratifs :

http://www.generation-linux.fr/index.php?post/2009/02/21/Arte-en-voici-en-voila

Le fil expliquant l'installation sur ubuntu.fr :

http://forum.ubuntu-fr.org/viewtopic.php?id=229961&p=1

L'usage est enfantin : une fenêtre vous présente toutes les émissions disponibles des 7 derniers jours, vous n'avez qu'à choisir celle qui vous intéresse pour que le téléchargement commence ! À ne pas rater.

Bushman02

Retour en arrière (suite aux posts 828-29-30) :
Pour les les scripts qui marchaient jusque-là et qui ne fonctionnent plus avec imagemagick, il suffit de remplacer ce dernier par graphicsmagick-imagemagick : tout rentre dans l'ordre.

Goda

Salut à tous

Si comme moi vous avez été un jour sur W€€ndows et que vous avez ensuite copié certains de vos dossiers sur votre système Linux (Par exemple tout le dossier Musique) il y a fort à parier que celui çi est truffé de fichiers indésirables du genre "Thumbs.db", de fichiers "txt" ou "nfo" vantant les mérites de tel ou tel tracker torrent...

Voiçi donc un petit script pour faire le ménage sans avoir à explorer toute l'arborescence :

ATTENTION ! Ce script fait usage de la commande "rm"... Faites trés attention, je ne saurais ètre responsable de son mauvais usage et d'éventuelles pertes de données. Vous ètes de grands garçons/filles.

#! /bin/bash

echo -e "\033[00;32m";
clear;

########################################################################
#
#
#         Ce script permet de trier/effacer l'arborescence
#           complète d'un dossier par types d'extensions
#
#     Exemple :  Effacer tous les "thumbs.db" produits par W€€ndows
#
########################################################################


read -p "Analyser le dossier courant ? O/n :" REP

if [ "$REP" = o ] || [ "$REP" = O ]
    then
	DIR=$PWD
elif [ "$REP" = n ]
	then
	read -p "Indiquer le chemin du dossier à analyser : " DIR ;
        cd $DIR;
elif  [ -z "$REP" ]
    then
	echo"";
	echo "Indiquez un dossier !";
	sleep 4;
	exit
fi

#liste et compte les extensions
#
CONTENU=`find . -type f | sed 's/.*\.//' | sort | uniq -c`

echo "Ce dossier contient :";
echo"$CONTENU";

echo "indiquez les types de fichiers à effacer en séparant"
echo "les extensions par un espace :";
echo "exemple : mp3 txt db";
echo "";
read -p ":" EXT ;

echo "ATTENTION ! Tous les fichiers dont les extensions sont \"$EXT\" vont ètre" ;
echo "effacés de manière IRREVERSIBLE ! " ;
echo"Pour annuler faite Ctrl+c." ;
read -p "Si vous ètes sur de ce que vous faite tapez \"Entrée\" : " OK ;

#Efface les extensions choisies
#
for FILES in $EXT
    do
	find . -name \*.$FILES -exec rm \-v {} \;
done

#quitte
#
echo ""
read -p "Fin....appuyez sur Entrée pour quitter" QUIT ;
echo -e "\033[00m";
clear;
exit 0;

Shrat

Pourquoi -f?

Goda

C'est vrai....:rolleyes:

BorX

Goda a écrit

for FILES in $EXT
    do
	find . -name \*.$FILES -exec rm \-v {} \;
done

unset FILES
for ext in $EXT; do
  [ -n "$FILES" ] && FILES="$FILES -o"
  FILES="$FILES -iname '*.$ext'"
done
eval "find . \( $FILES \) -ls -delete"

-> On fait qu'une seule passe
-> On évite les erreurs habituelles avec -exec rm -v {} \;

Goda a écrit" Read The F$$$$$ Manual " ---> man man

Goda

Yep
Je comprend pas tout alors je vais reader le F$$$$$ Manual !

A plus

Shrat

Tu fais tout plein de find goda. Brox récupère tout de suite les fichiers à effacer. C'est plus économe.

man test est cool quand on débute.

Sinon je me bas farouchement contre ce réflexe du -f. Çaynul!

draco31.fr

Bonsoir à tous,
Un petit script qui permet de classer les éléments du dossier courant en vu de les graver sur un minimum de DVD.
Tout les sous-dossiers sont considérés comme insécables, l'idée étant qu'il représentent un album ogg ou tout les épisodes d'une série, ou tout les fichiers d'un projet ... donc à ne pas éparpiller sur plusieurs supports.
Si jamais un sous-dossier est trop gros pour le DVD, on splitte le dossier en respectant l'ordre alphabétique en autant de DVD/CD que le minimum nécessaire.
J'ai mis plusieurs contrôles pour ne pas créer des DVD à moitié vide, donc le script est à adapter à vos besoins.
Bien entendu, rien n'est optimisé, et c'est codé avec les pieds (les miens en l'occurence :lol: )

Si quelqu'un veut le rendre plus propre et plus "professionnel", qu'il s'en donne à coeur joie.
Mais obligation de rendre publique le code modifié pour en faire profiter tout le monde !!

EDIT : J'allais oublier : à la fin du script, il vous indique la commande à lancer pour restaurer les fichiers comme à l'origine.
Donc pas de soucis, si vous êtes pas content du résultat, la commande est même ajoutée à l'historique bash 😛

#!/bin/bash
echo "Traitement de $PWD"
# Constantes (calcul en octets)
declare -i tailleDVD=4700000000
declare -t tailleCD=700000000

# Normal
BLK='\e[0;30m' # Black - Regular
RED='\e[0;31m' # Red
GRN='\e[0;32m' # Green
YLW='\e[0;33m' # Yellow
BLU='\e[0;34m' # Blue
PUR='\e[0;35m' # Purple
CYN='\e[0;36m' # Cyan
WHT='\e[0;37m' # White

# Bold
BLDBLK='\e[1;30m' # Black - Bold
BLDRED='\e[1;31m' # Red
BLDGRN='\e[1;32m' # Green
BLDYLW='\e[1;33m' # Yellow
BLDBLU='\e[1;34m' # Blue
BLDPUR='\e[1;35m' # Purple
BLDCYN='\e[1;36m' # Cyan
BLDWHT='\e[1;37m' # White

# Underline
UNDBLK='\e[4;30m' # Black - Underline
UNDRED='\e[4;31m' # Red
UNDGRN='\e[4;32m' # Green
UNDYLW='\e[4;33m' # Yellow
UNDBLU='\e[4;34m' # Blue
UNDPUR='\e[4;35m' # Purple
UNDCYN='\e[4;36m' # Cyan
UNDWHT='\e[4;37m' # White

# Background
BAKBLK='\e[40m'   # Black - Background
BAKRED='\e[41m'   # Red
BAKGRN='\e[42m'   # Green
BAKYLW='\e[43m'   # Yellow
BAKBLU='\e[44m'   # Blue
BAKPUR='\e[45m'   # Purple
BAKCYN='\e[46m'   # Cyan
BAKWHT='\e[47m'   # White

# Text Reset
NC='\e[0m'    # Text Reset - No Color

# pourcentage minimum pour graver un support
declare -i taux_remplissage=51

declare -i tailleDVD_min=$(( $tailleDVD * $taux_remplissage / 100 ))

# Variables diverses
declare -i ligne_max=0
declare -i ligne_min=1
declare -i ligne_sep=0
declare -i num_ligne=0

# libellé du type de support en court d'utilisation
declare support="DVD"

# Sauvegarde du dernier fichier de restoration existant dans le répertoire de travail
rm -v ".$(basename $0).restore.*"
cp ".$(basename $0).restore" ".$(basename $0).restore.$(date -r .$(basename $0).restore --rfc-3339=seconds -u)" 2>/dev/null

# Nettoyage des fichiers temporaires du précédent run
rm ".$(basename $0).restore" .liste_taille2 .liste_taille .liste_a_regrouper .liste_trt_differe .liste_combinaison .liste_combinaison2 2>/dev/null

#-----
echo "rm -v \".$(basename $0).restore\"" >> ".$(basename $0).restore"
echo "echo -e \"Suppression du fichier de restauration\"" >> ".$(basename $0).restore"
#-----

#####################################################
# Listing des éléments du dossier et de leur taille
#####################################################
du -B 1 -s * | sort -n > .liste_taille
fgrep -v "_$(basename $0)" .liste_taille > .liste_taille2 && mv .liste_taille2 .liste_taille
echo -e "${RED}================================$NC"
echo -e "    n°\ttaille\t\tlibellé"
echo -e "${RED}--------------------------------$NC"
cat -n .liste_taille
echo -e "${RED}================================$NC"

# Parcours de la liste, Analyse des éléments pour trouver la limite dû à la taille du support
OLD_IFS="$IFS"
while read ligne
do
    if [ ${ligne%$'\t'*} -gt $tailleDVD ]
    then
        echo "W: \"${ligne#*$'\t'}\" est plus grand qu'un DVD !"
    else
        num_ligne+=1
        if [ ${ligne%$'\t'*} -le 4096 ]
        then
            ligne_min+=1
        fi
    fi
done < .liste_taille
echo "================================"

# Récapitulatif de l'analyse
ligne_sep=$((num_ligne+1))
echo "I: Traitement de la liste à partir de la ligne n°$ligne_min"
echo "I: Traitement différé à partir de la ligne n°$ligne_sep"

# liste des éléments inférieurs à la taille max
tail -n +$ligne_min .liste_taille | head -n $((ligne_sep - ligne_min)) > .liste_a_regrouper
# liste des éléments supérieurs à la taille max
tail -n +$ligne_min .liste_taille | tail -n +$((ligne_sep - ligne_min +1)) > .liste_trt_differe

########################################
# Liste à regrouper
########################################
function regrouper_element()
{
#=======================================
# Traitement dossier courant
#=======================================
declare -a tab_taille
declare -a tab_element
declare -i index_max=0
declare -i index=0
declare -i nb_element_max=0
declare -i taille=0
declare stt_compare_min_max="false"
declare stt_calcul_nb_element_max="false"

# Charger la liste des élements à regrouper dans un tableau
while read ligne
do
    tab_taille+=( "${ligne%$'\t'*}" )
    tab_element+=( "${ligne#*$'\t'}" )
done < .liste_a_regrouper

echo "I: Création du dossier : _$(basename $0)"
mkdir "_$(basename $0)" 2>/dev/null
#-----
echo "rmdir -v \"_$(basename $0)\"" >> ".$(basename $0).restore"
echo "echo -e \"I: Suppression du dossier : _$(basename $0)\"" >> ".$(basename $0).restore"
#-----
# Si la somme "plus petit élement" + "plus grand élément" dépasse un DVD, on peut classer le plus grand (pas de combinaison possible)
echo -e "${GRN}Traitement des éléments non regroupables ...$NC"
while [ $stt_compare_min_max == "false" ]
do
    index_max=$((${#tab_taille[*]} - 1))
    if [ $index_max -le 0 ]
    then
        stt_compare_min_max="true"
    else
        taille=$((${tab_taille[0]} + ${tab_taille[$index_max]} ))
        if [ $taille -gt $tailleDVD ]
        then
            # Script/log pour restorer à l'état initial
            #-----
            echo "mv -v \"./_$(basename $0)/${tab_element[$index_max]}\" \"./${tab_element[$index_max]}\"" >> ".$(basename $0).restore"
            echo "echo -e \"> Restauration de l'élément n°$index_max : \"" >> ".$(basename $0).restore"
            #-----
            echo -e -n "> Déplacement du n°$index_max : "
            mv -v "${tab_element[$index_max]}" "./_$(basename $0)/${tab_element[$index_max]}"
            unset tab_element[$index_max]
            unset tab_taille[$index_max]
        else
            stt_compare_min_max="true"
            #echo "Index max final = $index_max"
        fi
    fi
done

# On cherche le nombre d'éléments maximum que l'on peut ajouter sans dépasser la taille du support
# On part du plus petit élément vers le plus gros.
taille=0
index=0
index_max=$((${#tab_taille[*]} - 1))
while [ $stt_calcul_nb_element_max == "false" ]
do
    if [ $index -gt $index_max ]
    then
        stt_calcul_nb_element_max="true"
        nb_element_max=$index_max
    else
        taille+=${tab_taille[$index]}
        if [ $taille -gt $tailleDVD ]
        then
            nb_element_max=$(($index - 1))
            stt_calcul_nb_element_max="true"
        fi
    fi
    index+=1
done

# la somme des 2 plus petits éléments dépasse la taille d'un DVD, aucune combinaison ne sera possible !
# En théorie, index_max ne devrait pas dépasser 1
if [ $nb_element_max -le 0 ]
then
    echo "W: Aucune combinaison possible, classement en cours des éléments restants ..."
    #-----
    echo "echo -e \"I: $(basename $0) > Restauration terminée\"" >> ".$(basename $0).restore"
    #-----
    index=0
    while [ $index -le $index_max ]
    do
        # Script/log pour restorer à l'état initial
        #-----
        echo -e "mv -v \"./_$(basename $0)/${tab_element[$index]}\" \"./${tab_element[$index]}\"" >> ".$(basename $0).restore"
        #-----
        mv -v "./${tab_element[$index]}" "./_$(basename $0)/${tab_element[$index]}"
        index+=1
    done
    # Quitte le script
    echo "I: Regroupement des éléments terminé"
    #-----
    echo "echo \"W: Restauration des éléments restants ...\"" >> ".$(basename $0).restore"
    #-----
    return 0
fi

declare -i nb_element=$nb_element_max
declare -i taille_temp=0
declare -i index_base=0
declare -i index_max=$((${#tab_taille[*]} - 1))
declare lib_index=""
# Parcours de tout l'index pour toutes les combinaisons
while [ $index_base -le $index_max ]
do
    taille=0
    nb_element=1

    # Recherche du nombre d'éléments maxi pour cette base
    index=$index_base
    while [ $index -le $index_max ]
    do
        taille+=${tab_taille[$index]}
        if [ $taille -gt $tailleDVD ]
        then
            nb_element_max=$(($index - $index_base))
            break
        fi
        index+=1
    done

    # Parcours des combinaisons en partant de la plus longue petite suite vers la plus courte petite suite pour cette base
    nb_element=$(($nb_element_max + $index_base -1))
    while [ $nb_element -ge $index_base ]
    do
        # Somme des N éléments depuis la base (on ne dépasse pas le nombre d'élément max pour cette base)
        taille=0
        lib_index="_"
        index=$index_base
        while [ $index -lt $nb_element ]
        do
            taille+=${tab_taille[$index]}
            lib_index+=${index}_
            index+=1
        done

        # Recherche des combinaisons possibles à partir de cette base + 1 élément sans dépasser la taille max
        while [ $index -le $index_max ]
        do
            taille_temp=$(($taille + ${tab_taille[$index]}))
            if [ $taille_temp -le $tailleDVD ]
            then
                echo -e "$taille_temp\t${lib_index}${index}_" >> .liste_combinaison
            else
                break
            fi
            index+=1
        done
        nb_element=$(($nb_element - 1))
    done
    index_base+=1
done

# trier la liste des combinaisons par taille décroissante / enlever les doublons
sort -nru .liste_combinaison > .liste_combinaison2 && mv .liste_combinaison2 .liste_combinaison

# Affichage de la liste triée (peut-être long ...) : Est-ce utile à l'utilisateur ?
echo -e "${RED}================================$NC"
echo -e "    n°\ttaille\t\tcombinaison"
echo -e "${RED}--------------------------------${WHT}"
cat -n .liste_combinaison | head -n 20
echo -e "${RED}================================$NC"

# Sauvegarde de la liste pour débugging
#cp -v .liste_combinaison .liste_combinaison.bak

# Lecture du fichier des combinaisons, regroupement des éléments dans des dossiers
IFS="$OLD_IFS"
declare stt_fin_fichier_combinaison="false"
declare old_ligne=""
declare -a combinaison
declare -a ligne
while [ $stt_fin_fichier_combinaison == "false" ]
do
    read -a ligne < .liste_combinaison || break
    if [ "${ligne[1]}" == "$old_ligne" ]
    then
        # Debug : Arrêt de la boucle dans le cas où read lirait toujours la même ligne (pb de remplassement/mv ...)
        #echo "Fin de fichier détectée"
        stt_fin_fichier_combinaison="true"
    else        
        echo "Traitement de la combinaison ${ligne[1]} / Taille ${ligne[0]}"
        combinaison=( ${ligne[1]//_/ } )
        # S'il y a plus d'un élément, il faut les regrouper dans un dossier !
        if [ ${#combinaison[@]} -gt 1 ]
        then
            cible="DVD${ligne[1]}/"
            mkdir -p "./_$(basename $0)/$cible"
            #-----
            # En cas de restore, il faudra supprimer le dossier créé
            echo "rmdir -v \"./_$(basename $0)/$cible\"" >> ".$(basename $0).restore"
            #-----            
        else
            cible=""
        fi

        for index in ${combinaison[@]}
        do
            echo -e -n "> Déplacement du n°$index : "
            #-----
            echo "mv -v \"./_$(basename $0)/$cible${tab_element[$index]}\" \"./${tab_element[$index]}\"" >> ".$(basename $0).restore"
            echo "echo -e \"> Restauration de l'élément n°$index\"" >> ".$(basename $0).restore"
            #-----
            mv -v "./${tab_element[$index]}" "./_$(basename $0)/$cible${tab_element[$index]}"
            fgrep -v "_${index}_" .liste_combinaison > .liste_combinaison2
            mv .liste_combinaison2 .liste_combinaison
        done

        # Pour gérer la fin de fichier si ça merdois :D
        old_ligne=${ligne[1]}
    fi
done
}

########################################
# Liste à traitement différé
########################################
function partitionner_element()
{
declare -ai tab_taille_max
declare -a  tab_dossier
declare -ai tab_taille tab_index_max tab_index_moyen
declare -a  tab_element
declare -i  somme_max somme_moyenne nb_DVD_max taille_moyenne taille

echo "I: Partitionnement des éléments plus grand qu'un DVD."

while read ligne
do
    tab_taille_max+=( "${ligne%$'\t'*}" )
    tab_dossier+=( "${ligne#*$'\t'}" )
done < .liste_trt_differe

#echo "tab_taille_max=${tab_taille_max[*]}"
#echo "tab_dossier=${tab_dossier[*]}"

## Pour chaque élément plus grand que le support
for i in ${!tab_dossier[*]}
do
	declare -a  tab_element
	declare -ai tab_taille tab_index_max tab_index_moyenne	
	element="${tab_dossier[$i]}"	
	echo -e "\n${BLDGRN}Traitement de l'élément ${BLDCYN}$element${NC}"
	if ! [ -d "$element" ]
	then
		echo "W: $element ne peut pas être divisé."
		break
	fi

	# On peut traiter le dossier
	#-----
	echo "cd .." >> ".$(basename $0).restore"
	#-----
	cd "$element"

	# Taille et nom de chaque élément du dossier
#	echo -e "Liste à traiter :\n$(du -B 1 -s *)"
	du -B 1 -s * > .tmp
	
	echo -e "$RED================================$NC"
    echo -e "    n°\ttaille\t\tlibellé"
    echo -e "$RED--------------------------------${WHT}"
    cat -n .tmp
    echo -e "$RED--------------------------------$NC"
    echo -e "${CYN} Total\t${tab_taille_max[$i]}\t${tab_dossier[$i]}$NC"
    echo -e "$RED================================$NC"

	
	while read ligne 
	do
		#echo "ligne=$ligne"
		taille="${ligne%$'\t'*}"
		element="${ligne#*$'\t'}"
		# Tout les éléments doivent faire moins qu'un DVD
		if [ $taille -le $tailleDVD ]
		then
			tab_taille+=( "$taille" )
			tab_element+=( "$element" )
		else
			echo "${tab_dossier[$i]} contient des éléments plus grand qu'un DVD, pas de partitionnement possible !"
			break 2 # sortir du while et du for ?
		fi
	done < .tmp
	rm .tmp

#    echo "tab_taille=${tab_taille[*]}"
#    echo "tab_element=${tab_element[*]}"

	# Parcours des éléments pour trouver la meilleure méthode de partitionnement
	# NB : On préfèrera répartir le poids sur l'ensemble des supports, plutôt que de graver le dernier avec presque rien.	

	# Nombre de DVD si rempli au max (ne tient pas compte de la taille des éléments)
	declare -i nb_DVD_min=$(( ${tab_taille_max[$i]} / $tailleDVD ))

	# Taille moyenne de chaque élément
	declare -i taille_moyenne_element=$((${tab_taille_max[$i]} / (${#tab_element[*]} + 1) ))
	
	# Si taille homogène, nombre d'élément à mettre par DVD
	declare -i nb_element_par_DVD=$(( $tailleDVD / $taille_moyenne_element ))
	
	# Si DVD rempli avec nombre d'élément moyen au max 
	declare -i nb_DVD_max=$(( $((${#tab_element[*]})) / $nb_element_par_DVD +1))
	declare -i taille_max_DVD=$(( $taille_moyenne_element * $nb_element_par_DVD ))
	
	# Si élément réparti sur max DVD
	declare -i taille_moyenne=$(( ${tab_taille_max[$i]} / $nb_DVD_max ))
    declare -i nb_element_par_DVD_reparti=$(( $taille_moyenne / $taille_moyenne_element ))

    echo
    echo -e "${GRN}I: Répartition prévisionnelle :\n"
    echo -e "$CYN\t--- Récap ---$NC"
    echo -e "\tTaille totale :                   $(converti_unite ${tab_taille_max[$i]})"
	echo -e "\tNombre d'éléments à répartir :    ${#tab_element[*]}"
	echo -e "\tTaille moyenne d'un élément :     $(converti_unite $taille_moyenne_element)"
	echo
	echo -e "$PUR\t--- Configuration DVD min ---$NC"
    echo -e "\tNombre de DVD minimum requis :    $nb_DVD_min"
	echo -e "\tNombre max d'éléments par DVD :   $nb_element_par_DVD"
	echo -e "\tRemplissage max par DVD :         $(converti_unite $taille_max_DVD) / $(( 100 * $taille_max_DVD / $tailleDVD))%"
    echo
    echo -e "$YLW\t--- Configuration DVD homogène ---$NC"
	echo -e "\tNombre de DVD maximum supposé :   $nb_DVD_max"
	echo -e "\tNombre moyen d'éléments par DVD : $nb_element_par_DVD_reparti"  
	echo -e "\tRemplissage min par DVD :         $(converti_unite $taille_moyenne) / $(( 100 * $taille_moyenne / $tailleDVD))%"
    echo

    #read

	#taille_DVD_max=$(( $tab_taille_max[$i] / $nb_DVD_min ))   # Poids moyen de chaque DVD si réparti uniquement sur DVD

	declare -i somme_max=0
	declare -i somme_moyenne=0
	declare -i nb_DVD=0	
	
	# Balayer l'index pour chaque élément
	for index in ${!tab_element[*]}
	do
		somme_max+=${tab_taille[$index]}
		somme_moyenne+=${tab_taille[$index]}
		#echo -e "$index Ajout: ${tab_taille[$index]}\tTotal: somme_max=$somme_max\tsomme_moyenne=$somme_moyenne"
		# On a dépassé la taille d'un DVD complet !
		if [ $somme_max -gt $tailleDVD ]
		then	
			#echo "somme_max dépasse la taille d'un DVD"
			tab_index_max+=( $(( $index - 1 )) )
			nb_DVD+=1
			somme_max=${tab_taille[$index]}
		fi
		# On a dépassé la moyenne, on garde la position si ça rentre sur un DVD (sinon on prend moyenne basse).		
		if [ $somme_moyenne -gt $taille_moyenne ]
		then
			#echo "somme_moyenne dépasse le remplissage moyen : $taille_moyenne"
			if [ $somme_moyenne -gt $tailleDVD ]
			then
				tab_index_moyenne+=( $(($index - 1)) )
				somme_moyenne=${tab_taille[$index]}			
			else
				somme=$somme_moyenne				
				tab_index_moyenne+=( $index )
				somme_moyenne=0
			fi
		fi		
	done

### DEBUG
#    echo "finale somme_max=$(converti_unite $somme_max)"
#    echo "finale somme_moyenne=$(converti_unite $somme_moyenne)"
#    echo "tab_index_max=${tab_index_max[*]}"
#    echo "nb_DVD=$nb_DVD"
#    echo "tab_index_moyenne=${tab_index_moyenne[*]}"
#    read
### DEBUG


	declare -i DVD_max=0 DVD_reparti=0 multi_CD # balises pour orienter les traitements ...
	declare -i index_max somme nb_CD nb_DVD_full nb_DVD_moyenne index
	declare support dest cas_DVDmax cas_DVDmoyen lib_DVDmax lib_DVDmoyen

	nb_DVD_full=${#tab_index_max[*]}
	nb_DVD_moyen=${#tab_index_moyenne[*]}
	nb_CD=0

	# Si le dernier élément termine un DVD dans la moyenne, on ne compte pas le dernier DVD (cf. comparaison taille_max)
	if [ $somme_moyenne -eq 0 ]
	then
		nb_DVD_moyen=$(( $nb_DVD_moyen - 1 ))
		somme_moyenne=$somme
	fi 	
	
	# Si le reste rentre sur 1 CD, on garde le remplissage max	
	if [ $somme_max -le $tailleCD ]
	then
		echo -e "${PUR}I: Configuration DVD min : restant sur 1 CD.$NC"
		nb_CD=1
		multi_CD=0
		#DVD_max=1
	# Si le reste ne rempli pas un DVD au minimum demandé, étudier la répartition en plusieurs CD.
	elif [ $somme_max -lt $tailleDVD_min ]
	then
		echo -e "${PUR}I: Configuration DVD min :\tcalcul répartition restant sur plusieurs CD..."				
		# Premier index désignant l'élément qui suit le dernier élément dans un DVD :
		#echo -e "tab_index_max=${tab_index_max[*]}\tnb_DVD_full=$nb_DVD_full"
		index=${tab_index_max[$(($nb_DVD_full - 1))]}
		index+=1 # index départ
		#echo "index_depart=$index"
		
		# Nombre max d'éléments dans le dossier (Attention : 1 de + que le nombre d'entrée dans tab_element !!)
		index_max=${#tab_element[*]}
		#echo "index_max=$index_max"
		
		nb_CD=0
		multi_CD=1	
		while [ $index -lt $index_max ]
		do			
			# Si un des éléments restants dépasse la taille d'un CD, pas la peine de continuer !
			if [ ${tab_taille[$index]} -gt $tailleCD ]
			then
			    echo -e "\n${RED}W: Configuration DVD min :\tun des éléments restant dépasse la taille d'un CD.$NC"
				# Pas de CD supplémentaire
				nb_CD=0
				multi_CD=0
				
				# Remettre à zero le tableau des index max
				index=$index_max
				index_max=${#tab_index_max[*]}			
				while [ $index -lt $index_max ]
				do
					unset ${tab_index_max[$index]}
					index+=1
				done 
				break
			fi						

            #echo -e "n°$index\t${tab_taille[$index]}\t${tab_element[$index]} rentre sur un CD."

			# L'élément rentre dans un CD ... essayons de l'ajouter aux précédents.			
			somme+=${tab_taille[$index]}
			
			# Si ça dépasse du CD, on complète le tableau d'index
			if [ $somme -gt $tailleCD ]
			then
				#echo "Besoin d'un CD supplémentaire ..."
				nb_CD+=1
				tab_index_max+=( $(( $index -1)) )
				somme=${tab_taille[$index]}
			fi
			index+=1
		done
		if [ $multi_CD -gt 0 ]
		then
			#DVD_max=1
			nb_CD+=1
			echo -e "\t\t\t\t---> Mode multiCD sur $nb_CD CDs.$NC"
		fi
	fi

    echo -e "${RED}--------------------------------$NC"
    if [ $nb_CD -gt 0 ]
    then
        echo -e "${PUR}Configuration DVD min :\n${WHT} > Remplissage de $nb_DVD_full DVD complet, restant sur $nb_CD CD(s) ou 1 DVD.$NC"
    else
        echo -e "${PUR}Configuration DVD min :\n${WHT} > Remplissage de $nb_DVD_full DVD complet, restant sur 1 DVD.$NC"
    fi

    if [ $somme_moyenne -gt $tailleCD ]
    then
        echo -e "${YLW}Configuration DVD homogène :\n${WHT} > Remplissage de $(($nb_DVD_moyen+1)) DVD."
    else
        echo -e "${YLW}Configuration DVD homogène :\n${WHT} > Remplissage de $nb_DVD_moyen DVD et 1 CD."
    fi
    echo -e "${RED}--------------------------------$NC"

### DEBUG
#    read
### DEBUG

	# On a le choix entre :
	#  - soit :
	#  		A.    DVD au max + 1DVD_maxi	<=> DVD_max=0
	#  		B1    DVD au max + 1DVD_mini	<=> DVD_max=1
	#  		B2 ou DVD au max + nCD + 1CD	<=> DVD_max=1 + multi_CD=1 / nb_CD>1
	#  		C. ou DVD au max + 1CD			<=> DVD_max=1 + multi_CD=0 / nb_CD=1
	#  - soit :
	#		D.    DVD moyenne + 1DVD
	#		E. ou DVD moyenne + 1CD
				
	# Comparaison du nombre de CD/DVD nécessaire, on prend le moins couteux :
	#------------------------------------------------------------------------*

    if [ $somme_max -gt $tailleDVD_min ]
    then
        cas_DVDmax="A"
        lib_DVDmax="1 DVD\t"
    elif [ $somme_max -gt $tailleCD ]
    then
        cas_DVDmax="B"
        lib_DVDmax="$nb_CD CD ou 1 DVD"
    else
        cas_DVDmax="C"
        lib_DVDmax="1 CD\t"
    fi
    
    if [ $somme_moyenne -gt $tailleCD ]
    then
        cas_DVDmoyen="D"
        lib_DVDmoyen="1 DVD"
    else
        cas_DVDmoyen="E"
        lib_DVDmoyen="1 CD"
    fi

	echo -e "\n${GRN}Choix de la configuration :$NC"
    echo -e "${RED}================================================$NC"	
	echo -e "\t\t${PUR}DVD min\t\t${YLW}DVD homogène$NC"
    echo -e "${RED}------------------------------------------------$NC"
	echo -e "Nb support max\t${PUR}$((${#tab_index_max[*]}+1))\t\t${YLW}$(($nb_DVD_moyen+1))$NC"
	echo -e "Nb support min\t${PUR}$(($nb_DVD_full+1))\t\t${YLW}$(($nb_DVD_moyen+1))$NC"
	echo -e "Configuration\t${PUR}$cas_DVDmax\t\t${YLW}$cas_DVDmoyen$NC"
	echo -e "Reste\t\t${PUR}$(converti_unite $somme_max)\t${YLW}$(converti_unite $somme_moyenne)$NC"
	echo -e "soit\t\t${PUR}$lib_DVDmax\t${YLW}$lib_DVDmoyen$NC"
    echo -e "${RED}------------------------------------------------$NC"
		
	# moins de DVD_max (CD inclus) que de DVD_moyenne
	if [ ${#tab_index_max[*]} -lt $nb_DVD_moyen ]  # Cas A, B2, C
	then
		echo "> Configuration DVD min prends moins de support (mode max)."
        echo -e "${PUR}I: Configuration DVD min retenue.$NC"
		DVD_max=1
		DVD_reparti=0
	# moins de DVD_max (CD exclus, avec 1DVD_mini) que de DVD_moyenne
	elif [ $nb_DVD_full -lt $nb_DVD_moyen ]  # Cas B1
	then
	    echo "> Configuration DVD min prends moins de support (mode min)."
        echo -e "${PUR}I: Configuration DVD min retenue.$NC"
		DVD_max=1
		DVD_reparti=0
		multi_CD=0
		# Remettre à zero le tableau des index max
		index=$nb_DVD_full
		index_max=${#tab_index_max[*]}			
		while [ $index -lt $index_max ]
		do
			unset ${tab_index_max[$index]}
			index+=1
		done
		nb_CD=0
	fi

	# moins de DVD_moyenne que de DVD_max (???)	
	if [ $nb_DVD_moyen -lt $nb_DVD_full ]  # Cas D ou E
	then
		echo "> Configuration DVD homogène prends moins de support."
        echo -e "${PUR}I: Configuration DVD min retenue.$NC"
		DVD_max=0
		DVD_reparti=1
	fi

	# On a le choix entre :
	#  - soit :
	#  		A.    DVD au max + 1DVD_maxi	<=> DVD_max=0
	#  		B1    DVD au max + 1DVD_mini	<=> DVD_max=1
	#  		B2 ou DVD au max + nCD + 1CD	<=> DVD_max=1 + multi_CD=1 / nb_CD>1
	#  		C. ou DVD au max + 1CD			<=> DVD_max=1 + multi_CD=0 / nb_CD=1
	#  - soit :
	#		D.    DVD moyenne + 1DVD
	#		E. ou DVD moyenne + 1CD

	# Pour le même nombre de support, on préfère :
	#---------------------------------------------*

	#        	 .----+----. 
	#	     	 | D  | E  |	   
	#	.--------+----+----+
	#	| 1	: A  | D  | E  | => toujours moyenne
	#	| 2	: B1 | D  | E  | => toujours moyenne    
	#	| 3	: B2 | B2 | E* | => Cas particulier
	#	| 4	: C  | C  | E  | => Cas particulier
	#	°--------+----+----°
	# 	 (*) uniquement si taille_moyenne > tailleDVD_min ; sinon B2	



    if [ $cas_DVDmax == "A" ] && [ $nb_DVD_full -eq $nb_DVD_moyen ]
    then
        echo "> Même nombre de support max pour les 2 configurations."
        echo -e "> Configuration DVD min utilise un DVD en dernier rempli à ${GRN}plus de $taux_remplissage%.$NC"
        echo -e "${YLW}I: Configuration DVD homogène retenue.$NC"
        DVD_max=0
        DVD_reparti=1
    fi

    if [ $cas_DVDmax == "C" ] && [ $nb_DVD_full -eq $nb_DVD_moyen ] && [ $cas_DVDmoyen == "D" ]
    then
        echo "> Même nombre de support max pour les 2 configurations."
        echo "> Configuration DVD min utilise un CD en dernier."
        echo "> Configuration DVD homogène utilise un DVD en dernier."
        echo -e "${PUR}I: Configuration DVD min retenue.$NC"
        DVD_max=1
        DVD_reparti=0        
    fi 

    if [ $cas_DVDmax == "C" ] && [ $nb_DVD_full -eq $nb_DVD_moyen ] && [ $cas_DVDmoyen == "E" ]
    then
        echo "> Même nombre de support max pour les 2 configurations."
        echo "> Configuration DVD min utilise un CD en dernier."
        echo "> Configuration DVD homogène utilise un CD en dernier."
        echo -e "${YLW}I: Configuration DVD homogène retenue.$NC"
        DVD_max=0
        DVD_reparti=1        
    fi 

    # Cas B1
    if [ $cas_DVDmax == "B" ] && [ $nb_DVD_full -eq $nb_DVD_moyen ]
    then
        echo "> Même nombre de support max pour les 2 configurations."
        echo -e "> Configuration DVD min utilise un DVD en dernier rempli à ${RED}moins de $taux_remplissage%.$NC"
        echo -e "${YLW}I: Configuration DVD homogène retenue.$NC"
        DVD_max=0
        DVD_reparti=1        
    fi

    # Cas B2
    if [ $cas_DVDmax == "B" ] && [ ${#tab_index_max[*]} -eq $nb_DVD_moyen ]
    then
        echo "> Même nombre de support max pour les 2 configurations."
        echo "> Configuration DVD min utilise plusieurs CDs."
        # Cas D
        if [ $cas_DVDmoyen == "D" ]
        then
            echo "> Configuration DVD homogène utilise un DVD en dernier."
            echo -e "${PUR}I: Configuration DVD min retenue.$NC"
            DVD_max=1
            DVD_reparti=0
        # Cas E avec DVD moyen > DVD min
        elif [ $taille_moyenne -gt $tailleDVD_min ]
        then
            echo "> Configuration DVD homogène utilise un CD en dernier."
            echo -e "> Configuration DVD homogène utilise un DVD rempli à ${GRN}plus de $taux_remplissage%.$NC"       
            echo -e "${YLW}I: Configuration DVD homogène retenue.$NC"
            DVD_max=0
            DVD_reparti=1        
        # Cas E avec DVD moyen < DVD min
        else
            echo "> Configuration DVD homogène utilise un CD en dernier."
            echo -e "> Configuration DVD homogène utilise un DVD rempli à ${RED}moins de $taux_remplissage%.$NC"
            echo -e "${PUR}I: Configuration DVD min retenue.$NC"
            DVD_max=1
            DVD_reparti=0
        fi
    fi 


	support="DVD"
	index=0
	
#	echo -e "DVD_max=$DVD_max\tDVD_reparti=$DVD_reparti"
	
	# Traitement DVD max + reste
	if [ $DVD_max -eq 1 ]
	then
		echo
        echo -e "${RED}================================$NC"	
		echo -e "${GRN}Traitement configuration DVD min$NC"
        echo -e "${RED}--------------------------------$NC"

		if [ ${tab_index_max[ $(( ${#tab_index_max[*]} - 1 )) ]} -lt $(( ${#tab_element[*]} -1 )) ]
		then
		    tab_index_max+=( $(( ${#tab_element[*]} - 1 )) )
		fi

		for j in ${!tab_index_max[*]}
		do
			# On a dépassé le nombre d'éléments sur DVD full, et il reste des CD.
			if [ $j -gt $nb_DVD_full ] && [ $nb_CD -gt 0 ]
			then
				support="CD"
			fi
			
			# Création du dossier de destination dans le dossier courant
			dest="Part_$(( $j + 1 ))_$support"			
			echo -e "\n${CYN}>> Création du dossier $NC$dest"
			mkdir "$dest"
			#-----
			echo "rmdir -v \"$dest\"" >> "../.$(basename $0).restore"
			echo "echo -e \">> Suppresion du dossier $dest\"" >> "../.$(basename $0).restore"
			echo "echo" >> "../.$(basename $0).restore"
			#-----
			while [ $index -le ${tab_index_max[$j]} ]
			do
			    echo -e "${WHT} > Déplacement élément n°$(($index +1)) :\n   $PUR${tab_element[$index]}$NC" 
				mv "${tab_element[$index]}" "./$dest/${tab_element[$index]}"
                #-----
			    echo "mv -v \"./$dest/${tab_element[$index]}\" \"./${tab_element[$index]}\"" >> "../.$(basename $0).restore" 
			    echo "echo -e \"   ${tab_element[$index]}\"" >> "../.$(basename $0).restore" 
			    echo "echo -e \" > Restauration élément n°$(($index +1)) :\"" >> "../.$(basename $0).restore" 
			    #-----
				index+=1
			done
			index=$(( ${tab_index_max[$j]} + 1 ))
		done
	fi

	if [ $DVD_reparti -eq 1 ] 
	then
		if [ $somme_moyenne -le $tailleCD ]
		then	
			nb_CD=1
		else
			nb_CD=0
		fi
	fi
	
	# Traitement DVD moyenne + reste
	if [ $DVD_reparti -eq 1 ]
	then
		echo
        echo -e "${RED}================================$NC"	
		echo -e "${GRN}Traitement configuration DVD homogène$NC"
        echo -e "${RED}--------------------------------$NC"

### DEBUG		
#		echo "tab_index_moyenne max : ${tab_index_moyenne[$((${#tab_index_moyenne[*]} - 1))]}"
#		echo "tab element max : $(( ${#tab_element[*]} -1 ))"
### DEBUG
		
		if [ ${tab_index_moyenne[ $(( ${#tab_index_moyenne[*]} - 1 )) ]} -lt $(( ${#tab_element[*]} -1 )) ]
		then
		    tab_index_moyenne+=( $(( ${#tab_element[*]} - 1 )) )
		fi
		
		for j in ${!tab_index_moyenne[*]}
		do
			# On a dépassé le nombre d'éléments sur DVD full, et il reste des CD.
			if [ $j -gt $nb_DVD_moyen ] && [ $nb_CD -gt 0 ]
			then
				support="CD"
			fi
			# Création du dossier de destination dans le dossier courant
			dest="Part_$(( $j + 1 ))_$support"			
			echo -e "\n${CYN}>> Création du dossier $NC$dest"
			mkdir "$dest"
			#------
			echo "rmdir -v \"$dest\"" >> "../.$(basename $0).restore"
			echo "echo -e \"\\n>> Suppression du dossier $dest\""  >> "../.$(basename $0).restore"
			#------
			while [ $index -le ${tab_index_moyenne[$j]} ]
			do
			    echo -e "${WHT} > Déplacement élément n°$(($index +1)) :\n   $YLW${tab_element[$index]}$NC"
				mv "${tab_element[$index]}" "./$dest/${tab_element[$index]}"
                #-----
			    echo "mv -v \"./$dest/${tab_element[$index]}\" \"./${tab_element[$index]}\"" >> "../.$(basename $0).restore" 
			    echo "echo -e \"   ${tab_element[$index]}\"" >> "../.$(basename $0).restore" 
			    echo "echo -e \" > Restauration élément n°$(($index +1)) :\"" >> "../.$(basename $0).restore" 
			    #-----
				index+=1
			done
			index=$(( ${tab_index_moyenne[$j]} + 1 ))
		done
	fi	

### DEBUG	
#	read
### DEBUG	
	
	unset tab_element tab_taille tab_index_max tab_index_moyenne
	cd ..
	#-----
	echo "cd \"${tab_dossier[$i]}\"" >> ".$(basename $0).restore"
	echo "echo -e \"Restauration dossier : ${tab_dossier[$i]}\"" >> ".$(basename $0).restore"
	#-----
	
done	
}

function converti_unite()
{
    declare -i taille=$1
    declare -i major=0
    declare -i minor=0
    declare dec
    declare -i index=0
    declare -a tab_unite=( "o" "kio" "Mio" "Gio" "Tio" )
    major=$taille
    while [ $major -ge 1024 ]
    do
        taille=$major
        major=$(( $taille / 1024 ))
        minor=$(( $taille % 1024 ))
        index+=1
    done
    dec=$minor
    while [ ${#dec} -lt 3 ]
    do
        dec="0$dec"
    done
    echo -n "$major,$dec ${tab_unite[$index]}"
}

regrouper_element
partitionner_element

declare -a tab_restore
declare -i index

echo -E "#!/bin/bash" >> ".$(basename $0).restore"

# Remettre les actions de restoration dans l'ordre pour supprimer les dossiers créés APRES avoir replacé le contenu !!
echo -e "\n${BLDRED}I: Création du script pour restauration...$NC"
while read ligne
do
    tab_restore+=( "$ligne" )
done < ".$(basename $0).restore"
index=${#tab_restore[*]}
while [ $index -gt 0 ]
do
    echo "${tab_restore[$(( $index - 1))]}" >> ".$(basename $0).restore2"
    index=$(( $index - 1))
done
#sort -r ".$(basename $0).restore" > ".$(basename $0).restore2"
mv ".$(basename $0).restore2" ".$(basename $0).restore"

# Nettoyage des fichiers temporaires du run
rm .liste_taille2 .liste_taille .liste_a_regrouper .liste_trt_differe .liste_combinaison .liste_combinaison2 2>/dev/null

echo -e "\n${BLDGRN}I: Pour restaurer les élements dans leurs chemins initiaux, lancer la commande suivante :$NC"
echo "  source .$(basename $0).restore" | tee -a $HISTFILE

exit 0

Goda

@ Shrat

Rhaaaaaaaa j'avais pas percuté qu'il y avais une page de man pour test...à chaque fois que je doute je cherche dans http://abs.traduc.org/abs-fr/index.html mais c'est pas toujours facile de s'y retrouver. Et puis des fois on à tendance à chercher une solution en utilisant les cmd que l'on connais alors qu'il y en à des plus efficaces et directes. Dur dur d'optimiser son code...

PS: Shrat : Tu écrit souvent au Pape ? ;-)

@ BorX

Désolé mais je suis débutant, y'a des trucs que je comprend pas dans ta solution.

--> Si on remplace mon bout de code par le tien, à quoi sert le "unset FILES" au début vu que la variable n'est pas initialisée ?

--> C'est quoi "-iname" ? J'ai pas du bien chercher car je trouve rien la dessus :-(

--> Juste pour confirmation : "eval" sert à considérer le contenu de la variable (en l'occurence des extensions séparées par des espaces) comme des paramètres distincts (autrement dit ça tient compte des espaces)...j'ai bon ?

Merci pour les conseils

« Page précédente Page suivante »