salut

qui est k ?

le nombre d' équations

salut

l'enoncé est vraiment mal posé  , mais bon  vois ici :

flight merci , bon je vais essayer de bricoler quelques chose ,

..c'est quasiment une recette de cuisine à programmer

du coup ma fonction au départ doit prendre arg en paramètre n'est ce pas ?

tiens pour m'amuser je vais le faire

pour au moins pouvoir mettre le nombre de paramètre souhaités

la seule petite difficulté réside dans le fait de trouver les Mi tel que  yi = Mi^-1modulo mi  ...mais c'est jouable

mais Euclide étendu le règle très bien , non ?

pas vraiment utile Euclide pour la partie programmation
j'ai pu réaliser un programme qui fait tout ca avec un nombre d'équations à choisir .

je peux pas te donner une solution toute faite sur le site au risque d'etre puni par les modo .
par contre si tu rencontre une étape du type résoudre  a.yi=1[b]   pour rechercher yi
tu peux procéder ainsi : (j'ai fais ça en vba mais le principe est le même dans les autres langages:

Bonsoir,
je crois que l'énoncé suggère une solution récursive.
Si on a une équation de la forme les solutions sont évidentes.

Si on a deux équations on a deux cas possibles

      -- le système a une solution de la forme
      -- le système n'a pas de solution.

Si on a plus de deux équations on résout le système formé par les deux premières ( ou les deux dernières ou deux prises suivant un critère quelconques ) ;
      si ce système n'a pas de solutions, le système de départ n'en a pas non plus,
      si il en a une on remplace les deux équations par leur solution et on résout le nouveau système.

Pour l'algorithme d'Euclide étendu tu peux regarder Wikipédia

bonjour,

// calcul de l'inverse de a modulo m
function inv(a,m) {
  var aa,bb,q,r, x2, x1, xx;
  aa=a; bb=m;
  x2=-1; x1=0;
  while (bb!=0) {
    q=Math.floor(aa/bb); r=aa%bb;
    aa=bb; bb=r
    xx = -q*x1 + x2;
    x2= x1; x1=xx;
    }
  return (m-x2)%m;
}

Merci pour vos retours  , je suis en train de le coder ce programme , je tiens bien compte de vos remarques , je reviendrai vers vous après avoir bien avancé dans le programme pour l'instant je suis dans le cas d'une solutions , .

mathafou pour le calcul de l'inverse modulaire j'ai pu le coder sans utiliser Euclide étendu , je reviens

def InverseModulaire(x,p):
    for n in range(p):
        if (x * n) % p == 1:
            return n
        elif n == p - 1:
            return "Null"
        else:
            continue

en fait pour vous dire je comprend le procédé ou du moins à peu prés sauf que j'ai un problème au niveau des paramètres de ma fonction , puisque c'est appelé à ne pas rester constant c'est à dire que je pourrai avoir un système a un nombre voulu d'équation , que puis je donc mettre en paramètre  cette phase me gène

on peut balayer les entiers un par un comme le propose flight ... ça marche
quant à l'efficacité ...
ça marchera très bien avec des nombres jusqu'à quelques milliers / millions
mais calculer l'inverse de 457896512 modulo 719925474157 ?
ça donne quoi les ≈ 10¹² boucles exécutée avant de le trouver ?
(exemple véridique, l'inverse est 715912543778 obtenu en seulement 13 boucles de Euclide)

pour le nombre variable de paramètres d'une fonction en Python, il faut donner une liste en guise de paramètres.

mathafou concernat le code que j'ai proposé ce que vous me dite c'est que il marche certes pour les petits nombres mais pour de très gros nombres mon code ne serait pas fiable en terme d'efficacité ?

c'est ce que j'ai dit .

maintenant on peut s'en contenter (après tout il n'y a pas que ce bout là à coder ! et ce n'est qu'un exercice)
de toute façon des très grands nombres vont se heurter à des problèmes de débordement de taille des nombres en machine, que ce soit avec une méthode ou une autre.

par contre return soit un nombre soit un texte, ("Null" est un texte !)
ce n'est pas très pratique à utiliser.
pour dire que ce n'est pas possible on pourrait plutôt par exemple renvoyer le nombre 0, vu qu'il ne peut pas être l'inverse de quoi que ce soit.

pour une équation j'y arrive

def InverseModulaire(a,m):
    aa=a; bb=m
    x2=-1; x1=0
    while (bb!=0):
        q=aa//bb; r=aa%bb
        aa=bb ; bb=r
        xx = -q*x1 + x2
        x2= x1; x1=xx 
    return (m-x2)%m

def ChinoixReste1(a,b,mod):

    if pgcd(a,mod)!=1:

        return False
    return (InverseModulaire(a,mod)*b)%mod
print(ChinoixReste1(7,8,9))

pour un système de deux équations je ne comprend pas correctement ce vous me demandez de faire , je pense que j'aurais besoins de 4 paramètres pour ce code .

en fait si vous voulez , il a été demandé de coder le cas d'une équation , le cas de deux équation , ensuite le cas >2 , sachant qu'en pratique on se remmène souvent à résoudre deux équations dans un premier temps et de refaire la même chose

Je crois que ton objectif est mal défini.
C'est pratiquement ce qu'il y a de pire en informatique.

Quand on parle d'utiliser le théorème chinois on a, en principe, une liste d'équations de la forme avec les premiers entre eux deux à deux.

J'ai l'impression que ta fonction "ChinoixReste1" résout une équation du type .
C'est hors sujet.

Pour trouver les solutions de

avec n_0 et n_1 premiers entre eux tu peux  regarder Wikipédia théorème des restes chinois dans la partie algorithme.

Et je crois vraiment que tu devrais préciser ton problème.

je ne disais rien de plus que

def chinois(*T) :
   ici T est un tuple contenant l'ensemble des valeurs lors de l'appel

Salut mathafou.
J'ai écrit une fonction qui marche en passant deux listes comme paramètres : la liste des  restes et la liste des modules.
Ces listes doivent avoir la même longueur.

Un petit défi pour flight : trouver les solutions de