Bonjour,
il a fallu quelque temps de réflexion, de recherche et le programme n'est pas très propre (je pense qu'on peut améliorer le code) mais il fait le travail demandé.
À bientôt sur sos-math

Merci!
C'est exactement ce qu'il me fallait !

Merci beaucoup :-D

Ulysse

def berger(n):
    table = [[] for i in range(n-1)]
    table[0]=[(i+1,n-i) for i in range(n//2)]
    for i in range(1,n-1):
        if i%2==0:
            table[i].append((table[i-1][-1][1], n))
            for j in range(0,n//2-2):
                table[i].append((table[i-1][n//2-j-2][1],table[i-1][n//2-1-j][0]))
            table[i].append((table[i-1][0][1], table[i-1][1][0]))

        else:
            table[i].append((n,table[i-1][-1][1]))
            for j in range(0,n//2-2):
                table[i].append((table[i-1][n//2-j-2][1],table[i-1][n//2-1-j][0]))
            table[i].append((table[i-1][0][0], table[i-1][1][0]))
    return table
    
def affichage(n):
    for i in range(n-1):
        print(f"Ronde n°{i+1} : {berger(n)[i]}")

Ronde n°1 : [(1, 10), (2, 9), (3, 8), (4, 7), (5, 6)]
Ronde n°2 : [(10, 6), (7, 5), (8, 4), (9, 3), (1, 2)]
Ronde n°3 : [(2, 10), (3, 1), (4, 9), (5, 8), (6, 7)]
Ronde n°4 : [(10, 7), (8, 6), (9, 5), (1, 4), (2, 3)]
Ronde n°5 : [(3, 10), (4, 2), (5, 1), (6, 9), (7, 8)]
Ronde n°6 : [(10, 8), (9, 7), (1, 6), (2, 5), (3, 4)]
Ronde n°7 : [(4, 10), (5, 3), (6, 2), (7, 1), (8, 9)]
Ronde n°8 : [(10, 9), (1, 8), (2, 7), (3, 6), (4, 5)]
Ronde n°9 : [(5, 10), (6, 4), (7, 3), (8, 2), (9, 1)]

Bonjour,
j'ai réfléchi à votre problème qui a des solutions.
Il existe par exemples pour les rencontres d'échecs ou l'organisation de championnat, les tables de Berger qui organisent les rencontres deux à deux de manière simultanée : [URL_B]https://fr.wikipedia.org/wiki/Tournoi_toutes_rondes[/URL_B] et [URL_B]https://fr.wikipedia.org/wiki/Table_de_Berger[/URL_B]
Je vous propose un programme que j'ai rédigé en, Python qui permet d'avoir les rencontres entre n personnes (n pair, si n est impair, on rajoute une personne "repos") : https://repl.it/@rnivelle/tablesberger
Dont voici le code :
[code]def berger(n):
table = [[] for i in range(n-1)]
table[0]=[(i+1,n-i) for i in range(n//2)]
for i in range(1,n-1):
if i%2==0:
table[i].append((table[i-1][-1][1], n))
for j in range(0,n//2-2):
table[i].append((table[i-1][n//2-j-2][1],table[i-1][n//2-1-j][0]))
table[i].append((table[i-1][0][1], table[i-1][1][0]))

else:
table[i].append((n,table[i-1][-1][1]))
for j in range(0,n//2-2):
table[i].append((table[i-1][n//2-j-2][1],table[i-1][n//2-1-j][0]))
table[i].append((table[i-1][0][0], table[i-1][1][0]))
return table

def affichage(n):
for i in range(n-1):
print(f"Ronde n°{i+1} : {berger(n)[i]}")[/code]

Un appel de la fonction pour dix participants donne :
[code]Ronde n°1 : [(1, 10), (2, 9), (3, 8), (4, 7), (5, 6)]
Ronde n°2 : [(10, 6), (7, 5), (8, 4), (9, 3), (1, 2)]
Ronde n°3 : [(2, 10), (3, 1), (4, 9), (5, 8), (6, 7)]
Ronde n°4 : [(10, 7), (8, 6), (9, 5), (1, 4), (2, 3)]
Ronde n°5 : [(3, 10), (4, 2), (5, 1), (6, 9), (7, 8)]
Ronde n°6 : [(10, 8), (9, 7), (1, 6), (2, 5), (3, 4)]
Ronde n°7 : [(4, 10), (5, 3), (6, 2), (7, 1), (8, 9)]
Ronde n°8 : [(10, 9), (1, 8), (2, 7), (3, 6), (4, 5)]
Ronde n°9 : [(5, 10), (6, 4), (7, 3), (8, 2), (9, 1)][/code]
Bonne continuation

Bonjour,

Merci pour votre réponse.

En effet, tout le monde finira par se rencontrer, mais l'idée était de trouver une méthode pour tenter de limiter le nombre de "tours".

Si une idée de piste vous vient à l'esprit, n'hésitez pas à me tenir au courant!

Merci :-)

Bonjour,
chaque personne rencontre \(n-1\) autres personnes donc il y a \(\dfrac{n(n-1)}{2}\) discussions.
En revanche pour organiser des discussions simultanées, c'est plus compliqué.
Si chaque personne se voit attribuer un numéro et une grille de ces numéros et coche au fur et à mesure le numéro des personnes rencontrées.
Il n'y a pas forcément une méthode établie mais tout le monde finira par se rencontrer.
Bonne suite de réflexion

Bonjour!

J'ai un problème de math appliqué et j'ai pensé que vous pourriez m'aider à y répondre :

Comment faire parler des gens deux à deux sans qu’ils ne reviennent jamais avec la même personne?

Je suis facilitateur en intelligence collective et j’aime faire discuter les gens deux par deux. Puis changer les binômes pour que chacun rencontre une nouvelle personne, et ainsi de suite jusqu’à ce que chaque personne ait rencontré toutes les autres personnes.

Mon problème : Quelle méthode suivre pour s’assurer que jamais le même binôme ne se retrouve?

Idéalement, il devrait donc y avoir n-1 tours de discussion.

Une idée? Une piste? Une réponse?

Merci beaucoup!