salut

 Cliquez pour afficher

évidemment x est rationnel

posons alors x = p/q avec p et q irréductible

car 4m - 3 est impair

donc


  donc p divise 24

or  p = 1 + 4k donc p € {-3, 1}

donc x = -3/8

Bravo bonne réponse

carpediem

 Cliquez pour afficher

Citation :
car 4m - 3 est impair

est un peu rapide commme justification

1) 8 divise 8p = (4m-3)q et 4m-3 est imapir donc q = 8r avec r un entier
2) donc p = (4m-3)r, donc r est un diviseur commun de p et q, donc r = 1
3) donc q = 8

 Cliquez pour afficher

Supposons que x soit solution du système annoncé. Alors en isolant x de chaque côté, on a . Ce qui s'écrit encore .
Cela limite fortement les possibilités pour m et n :

1)  3n-5 est congru à 1 modulo 3 donc 4m est congru à 0 modulo 3 donc m est multiple de 3 (car 4 = 1 mod 3 et Z/3Z est un corps)
2)  4m-3 doit diviser 24 tout en étant un multiple de 3 donc appartient à {-24,-3,3,24}. Comme 24 + 3 = 27, 3+3 = 6, -24+3 = 21 ne sont pas divisibles par 4, il ne reste plus que 4m-3 = -3, ie m = 0
3)  On en déduit  que 3n-5 = 24/(-3) = -8 , i.e n = -1

Il n'y a donc qu'une seule possibilité qui est (m,n) = (0,-1), ce qui correspond à


Voici un petit bruteforce en Haskell (volontairement impératif et vilain) qui trouve toutes les possibilités

import Data.Ratio

main = do
  let divisors_of_24 = neg_divisors ++ pos_divisors
        where
          pos_divisors = [1,2,3,4,6,8,12,24]
          neg_divisors = reverse $ map negate pos_divisors

  let ns = [n | n <- [-100..100], (24 `mod` (3*n-5)) == 0]
  let ms = [m | m <- [-100..100], (24 `mod` (4*m-3)) == 0]

  let pairs = [(m,n) | m <- ms, n <- ns, (4*m-3)*(3*n-5) == 24]       
  putStrLn $ concat ["pairs: ", show pairs]

  -- verif
  let (m, n) = head pairs
  let x = (4*m-3) % 8
  let x' = 3 % (3*n-5)
  putStrLn $ show (x == x')
  putStrLn $ show x

dont la sortie est

Citation :

pairs: [(0,-1)]
True
(-3) % 8

Ulmiere : on est entre nous ... pour mes math experte je le rédigerai comme toi

que je n'aime pas ce langage ... même s'il semble posséder des propriétés intéressantes (je viens de voir sur internet)

C'est un langage de programmation fonctionnelle, un truc de chercheurs, donc normal que ça rebute certaines personnes au premier abord

Mais j'aime sa syntaxe proche des maths (très proche du lambda calcul) et quand tu sais l'utiliser comme il faut, c'est fun comme langage et très expressif  

Par exemple pour coder un arbre binaire avec des feuilles et noeuds pouvant contenir une valeur de type quelconque (mais toujours le même)

data Arbre a = ArbreVide | Feuille a | Noeud a (Arbre a) (Arbre a) deriving (Show, Eq)


insert :: (Ord a) => a -> Arbre a -> Arbre a
insert x ArbreVide = Feuille x
insert x t@(Feuille r)
 | x == r = t
 | x < r = Noeud r (Feuille x) ArbreVide
 | otherwise = Noeud r ArbreVide (Feuille x)
insert x t@(Noeud r gauche droit)
 | x == r = t
 | x < r = Noeud r (insert x gauche) droit
 | otherwise = Noeud r gauche (insert x droit)

treeFromList :: (Ord a) => [a] -> Arbre a
treeFromList [] = ArbreVide
treeFromList (x:xs) = insert x $ treeFromList xs



main = do
  let arbre = Noeud 12 (Noeud 10 (Feuille 7) (Feuille 11)) (Noeud 18 (Feuille 13) ArbreVide)
  let nouvel_arbre = insert 15 arbre

  putStrLn $ show nouvel_arbre