bonjour a tous
Dans le cadre d'un projet j'ai besoin d'un algo de complément a 8 je m'explique
 
je recupere une liste de client ayant chacun un certain nombre de dossiers associés (de 1 a 7 dossiers).  
 
exemple le client 90000 possede 3 dossiers
            le client 90001 possede 6 dossiers  
 
ainsi de suite  
 
je traite ces dossiers en les rengeants dans des emplacements contenant 8 places .Pour les traité je recupere une liste des clients triée par nombre de dossier donc du  plus grand au plus petit  
 
dans mon exemple donc le 90001 et ensuite le 90000
 
Je peux tres bien avoir dans un emplacement le 90000 de ranger il possede 3 dossier il reste donc 5 place (pour arriver aux 8 places par l'emplacement)
j'ai donc besoin d'un algo me permettant de faire le complément a 8 pour avoir des emplacement optimisé et rempli sachant que bien sur un client ne peut etre que dans un seul emplacement.  
 
Par exemple si un client possede 7 dossier il prendra un emplacement et il faudra trouver un client avec 1 seul dossier pour completer voir le laisser tel quel s'il n'y a pas de client avec 1 dossier
 
si quelqu'un peut m'aider sa serait super merci
bye a biento

A/ Disposer de la liste des clients ayant 8 dossiers, de ceux ayant 0 dossier puis 7 puis 1 puis 6 puis 2 ... (classé comme ça ou de 0 à 8 / 8 à 0 peu importe ) Un hash (tableau à 9 entrées menant vers des listes chaînées) serait pas mal, ça dépend un peu de la nature de tes données au départ.

B/ A 8 et 0 dossiers c'est vite traité

C/ Avec "7 dossiers" tu ne peux que placer des "1 dossier". Tu regroupes autant de "1 dossier" que possible avec ceux-ci. S'il y a plus de 7 que de 1, rien à faire de mieux et il y aura de la place perdue.

D/ Avec "6", les "2" puis les "1" si possible.

E/ Avec "5" les 3 puis 2(+1)

F/ Avec "4", je sais pas ce qui est plus efficace entre les réunir par paires ou d'abord mettre les "1", "2", "3" restants. En fait il faut peut-être mettre les "1" puis les "2" aux étapes D et E? Ca dépend peut-être aussi de la nature de tes données (ou pas), est-ce qu'il vaut mieux éviter d'avoir plusieurs "emplacements de 8 cases" pas remplis complètement (mais bien remplis à 6 ou 7 chacun) ou bien éviter au maximum tout trou dans ces emplacements? Dans ce dernier cas, à la fin ils doivent être tous remplis sauf éventuellement un qui sera Si ce qui est important est de minimiser le nombre d'emplacements pris alors le minimum théorique t'es connu: partie entière de la somme des dossiers divisée par 8 + 1 incomplet (dans lequel y a le reste de cette division par 8), m'enfin s'il y a que des "7" tu n'atteindras jamais ce minimum évidemment

C'est un peu le problème de l'optimisation de l'espace sur un CD.
Il y a plusieurs topics à ce sujet. Effectivement, celui-ci est pas mal car très simple à mettre en oeuvre

oui c'est un peu ce probleme en effet magicbuzz  
PhosphoRel oaded je dispose de la liste de mes clients avec pour chacun leur nombre de dossier et ils sont triés par nombre de dossier décroissant  
je suis ok avec toi je stocke toutes les combinaisons
je test quand je part de 6 si j'ai du 4 sinon je descend et ainsi de suite mais je voulais savoir si il y avait d'autres méthodes que stocké toutes les combinaisons dans un tableau et les essayé  
Pour le remplissage je doit avoir aucun trou dans chaque compartiment

Vu que je m'emmerdais beaucoup ce soir, je me suis amusé à adapter l'algo proposé par PhophoReloaded en T-SQL (SQL Server)
 

CREATE TABLE cnt
(
  id tinyint NOT NULL PRIMARY KEY,
  sz tinyint NOT NULL
);
go
CREATE INDEX ix_cnt_sz ON cnt (sz);
go
CREATE FUNCTION show_cnt(@id AS tinyint)
returns varchar(32)
AS
begin
  declare @sz tinyint;
  declare @ret varchar;
  SELECT @sz = sz FROM cnt WHERE id = @id;
  RETURN '[' + replicate('=', (@sz - 1) * 2) + cast(@id AS char(2)) + replicate('=', (@sz - 1) * 2) + ']';
end;
go
CREATE FUNCTION order_cnt()
returns @tmp TABLE
(
  id tinyint PRIMARY KEY NOT NULL,
  sz tinyint NOT NULL,
  ln tinyint NOT NULL
)
AS
begin
  INSERT @tmp
  SELECT id, sz, 0
  FROM cnt;
 
  declare @ln tinyint;
  SET @ln = 1;
  while EXISTS (SELECT NULL FROM @tmp WHERE ln = 0)
  begin
  UPDATE @tmp
    SET ln = @ln
    WHERE ln = 0
    AND id = (SELECT top 1 id FROM @tmp WHERE ln = 0 ORDER BY sz DESC, id);
 
    while EXISTS (SELECT NULL FROM @tmp WHERE ln = 0 AND sz <= (8 - (SELECT sum(sz) FROM @tmp WHERE ln = @ln)))
    begin
      UPDATE @tmp
      SET ln = @ln
      WHERE ln = 0
      AND id = (SELECT top 1 id FROM @tmp WHERE ln = 0 AND sz <= (8 - (SELECT sum(sz) FROM @tmp WHERE ln = @ln)) ORDER BY sz DESC, id);
    end;
    SET @ln = @ln + 1;
  end;
  RETURN;
end;
go
CREATE FUNCTION display_ordered_cnt()
returns @tmp TABLE
(
  dsp varchar(32)
)
AS
begin
  declare @cln tinyint;
  declare @oln tinyint;
  declare @dsp varchar(32);
  declare @dln varchar(32);
 
  declare cur cursor LOCAL fast_forward
  FOR
  SELECT ln, dbo.show_cnt(id)
  FROM order_cnt()
  ORDER BY ln, id;
 
  open cur;
 
  fetch next FROM cur
  INTO @cln, @dsp;
  SET @dln = '';
  SET @oln = @cln;
 
  while @@FETCH_STATUS = 0
  begin
    IF @oln <> @cln
    begin
      INSERT @tmp SELECT @dln;
      SET @dln = '';
      SET @oln = @cln;
    end;
    SELECT @dln = @dln + @dsp;
    fetch next FROM cur
    INTO @cln, @dsp;
  end;
 
  IF @oln <> @cln
  begin
    INSERT @tmp SELECT @dln;
  end;
 
  close cur;
 
  deallocate cur;
 
  RETURN;
end;
go
print 'Initialisation de la table';
declare @id AS tinyint;
SET @id = 0
while @id < 100
begin
  INSERT INTO cnt (id, sz) VALUES (@id, cast(rand() * 8 AS tinyint) + 1);
  SELECT @id = @id + 1;
end;
 
print 'Tests';
SELECT * FROM display_ordered_cnt();

 
Et ça marche
 

PS : Ceci dit, l'algo est améliorable. Il faudrait faire une seconde passe pour tenter de boucher mieux les trous.
 
Exemple :

 
L'algo donne :

=> 8 places perdues et 3 lignes
 
Alors qu'à la main, on arrive à ça :

=> 0 place perdue et 2 lignes

c bon me suis debrouillé et je perd aucune place tant que c'est possible merci en tout cas de t'etre impliqué :-)