Un défi par semaine

Juillet 2015, 5e défi

Le 31 juillet 2015  - Ecrit par  Ana Rechtman Voir les commentaires (8)

Nous vous proposons un défi du calendrier mathématique 2015 chaque vendredi et sa solution la semaine suivante.

Semaine 31 :

On considère un nombre à deux chiffres et on multiplie les deux chiffres. Si le résultat est un nombre à un chiffre, on l’appelle l’« image » du nombre de départ. Si le résultat est un nombre à deux chiffres, on répète l’opération jusqu’à obtenir un nombre à un chiffre qui sera son « image ». Combien de nombres à deux chiffres ont pour « image » $8$ ?

Solution du 4ème défi de Juillet :

Enoncé

La somme des neuf nombres est $1+2+\cdots+9=45$. Appelons les nombres dans le tableau comme dans la figure ci-dessous. Alors la moyenne des nombres dans chaque ligne et colonne doit être égale à $i$.

PNG - 13.8 ko

Comme les colonnes ont la même moyenne on a

$a+b+c=d+e+f=\frac{3}{2}(g+h)=3i.$

On a alors

$i = 45-(a+b+c+d+e+f+g+h)$

$ = 45-(3i+3i+2i)$

$ = 45-8i,$

d’où $i=5$. Il nous faut donc deux triplets de nombres $(a,b,c)$ et $(d,e,f)$ disjoints et tels que, pour chaque triplet, la somme de ses éléments soit égale à $3i=15$. Donc $(a,b,c)$ et $(d,e,f)$ sont égaux à $(9,4,2)$ et $(8,6,1)$ dans un certain ordre. Avec ceci nous pouvons remplir le tableau :

PNG - 14.2 ko

Cette solution n’est pas unique.

Post-scriptum :

Calendrier mathématique 2015 - Sous la direction d’Ana Rechtman Bulajich, Anne Alberro Semerena, Radmilla Bulajich Manfrino - Textes : Ian Stewart.
2014, Presses universitaires de Strasbourg. Tous droits réservés.

Partager cet article

Pour citer cet article :

Ana Rechtman — «Juillet 2015, 5e défi» — Images des Mathématiques, CNRS, 2015

Crédits image :

Image à la une - Ievgen Sosnytskyi / SHUTTERSTOCK

Commentaire sur l'article

  • Juillet 2015, 5ème défi

    le 31 juillet 2015 à 10:45, par ROUX

    8=1*8 ou 2*4.
    Donc 18 a pour image 8.
    Mais, 18 est égal aussi à 2*9.
    8 est donc l’image de 29 par la chaine 29>18>8.
    Et ainsi de suite.
    J’en trouve au total 6.
    Mais, daniate, vous savez bien que si j’ai assez souvent une bonne idée, sa réalisation, entachée de distractions, me conduit à souvent faire des erreurs (ou me conduit souvent à faire des erreurs).

    Tiens, je ne sais pas choisir entre les deux positions du « souvent »...

    Répondre à ce message
    • Juillet 2015, 5ème défi

      le 31 juillet 2015 à 11:05, par Daniate

      Bonjour,

      Vous négligez que la multiplication est commutative et donc que si 18 convient alors 81 aussi. Pour ma part j’obtiens 22 nombres possibles.

      Bon courage

      Répondre à ce message
      • Juillet 2015, 5ème défi

        le 31 juillet 2015 à 11:28, par ROUX

        Ah ah ah !!!
        Mais absolument !!
        Je vous remercie !

        Répondre à ce message
        • Juillet 2015, 5ème défi

          le 31 juillet 2015 à 15:22, par Daniate

          Ou bien ha ha ha !!!

          Répondre à ce message
          • Juillet 2015, 5ème défi

            le 31 juillet 2015 à 16:16, par ROUX

            Oui, tout à fait  :).

            Répondre à ce message
            • Juillet 2015, 5ème défi

              le 2 août 2015 à 13:59, par Lhooq

              J’ai une solution d’informaticien (faite en OCaml, désolé pour ceux qui n’en connaissent pas la syntaxe ou ne comprennent rien à l’informatique) (Pour la validation du commentaire, je me suis permis de chercher quels sont les possibilités html pour intégrer du code mais je n’ai pas réussi à mettre de la coloration syntaxique, vous excuserez cette liberté. Soit dit en passant, serait-il possible d’avoir plus d’options d’édition de texte ? ;-)) :

              Code

              (* L'ensemble qui nous permettra de savoir si on a déjà vu
                   l'entier à étudier *)
              module S = Set.Make (
               struct
                 type t = int
                 let compare = compare
               end
              )

              (* On se permet une fantaisie dans le sens où on peut choisir
                 qu'on veut tous les nombres à 3 chiffres etc. *)
              let sup = int_of_string Sys.argv.(2)
              let inf = sup / 10

              (* Simple fonction permettant de trouver tous les couples de diviseurs *)
              let find_divs n =
               let lim = int_of_float (sqrt (float_of_int n)) in
               let rec fd d acc =
                 if d > lim then acc
                 else
                   let acc =
                      if n mod d = 0 then
                        (d,n/d)::acc
                      else acc
                   in fd (d+1) acc
               in fd 1 []

              (* Fonction principale *)
              let search n =
               (* Oui, on déclare une fonction dans une fonction, pour les non-connaisseurs
                     c'est une des grandes forces d'OCaml *)
               let rec s i vus =
                 (* Si i a plus de chiffres que voulu ou
                       si i a déjà été vu, on ne fait rien *)
                 if (i >= sup || S.mem i vus) then (0, vus)
                 (* Sinon, on commence le traitement *)
                 else
                   (* On enregistre le fait qu'on a maintenant vu i *)
                   let vus = S.add i vus in
                   (* On récupère l'ensemble des diviseurs de i *)
                   let l = find_divs i in
                   (* Si i a le bon nombre de chiffres on le compte *)
                   let r = if i >= inf then 1 else 0 in
                   List.fold_left (
                     fun (res, set') (d1, d2) ->
                       (* Pour chaque couple on crée les deux nombres résultants
                             (par exemple, pour 2 et 4, 24 et 42 *)
                       let i1 = int_of_string ((string_of_int d1)^(string_of_int d2)) in
                       let i2 = int_of_string ((string_of_int d2)^(string_of_int d1)) in
                       (* On rappelle récursivement la fonction sur ces deux nombres
                             et on somme les résultats renvoyés au résultat total *)
                       let r1, set' = s i1 set' in
                       let r2, set' = s i2 set' in
                       (r1 + r2 + res, set')
                   ) (r, vus) l
               in s n S.empty
               
              (* On appelle ici la fonction sur le nombre de notre choix *)
              let () =
               let n = int_of_string Sys.argv.(1) in
               let (res, _) = search n in
               Format.printf "%d -> %d@." n res

              Résultats

              1 -> 1
              2 -> 8
              3 -> 2
              4 -> 9
              5 -> 6
              6 -> 13
              7 -> 2
              8 -> 22
              9 -> 3

              (On comprend donc le choix de 8)

              Pour les sceptiques ou les curieux, je vous invite à copier le code ci-dessous que j’ai rendu exécutable pour le site http://try.ocamlpro.com/ sur lequel je vous invite à copier le code dans le cadre noir.

              Un appui sur Entrée puis vous pouvez vous amuser à écrire (sans le #, évidemment)

              # main 8 100

              Un nouvel appui sur Entrée vous donnera le résultat (8, 22) et vous pouvez vous amuser avec d’autres nombres. (Soit dit en passant, pour rebondir sur cet article, le code sera interprété sans être compilé mais reste du haut niveau :-))

              Code exécutable

              (* L'ensemble qui nous permettra de savoir si on a déjà vu
                   l'entier à étudier *)
              module S = Set.Make (
               struct
                 type t = int
                 let compare = compare
               end
              )

              (* Simple fonction permettant de trouver tous les couples de diviseurs *)
              let find_divs n =
               let lim = int_of_float (sqrt (float_of_int n)) in
               let rec fd d acc =
                 if d > lim then acc
                 else
                   let acc =
                 if n mod d = 0 then
                   (d,n/d)::acc
                 else acc
                   in fd (d+1) acc
               in fd 1 []

              (* Fonction principale *)
              let search n sup =
               let inf = sup/10 in
               (* Oui, on déclare une fonction dans une fonction, pour les non-connaisseurs
                     c'est une des grandes forces d'OCaml *)
               let rec s i vus =
                 (* Si i a plus de chiffres que voulu ou
                       si i a déjà été vu, on ne fait rien *)
                 if (i >= sup || S.mem i vus) then (0, vus)
                 (* Sinon, on commence le traitement *)
                 else
                   (* On enregistre le fait qu'on a maintenant vu i *)
                   let vus = S.add i vus in
                   (* On récupère l'ensemble des diviseurs de i *)
                   let l = find_divs i in
                   (* Si i a le bon nombre de chiffres on le compte *)
                   let r = if i >= inf then 1 else 0 in
                   List.fold_left (
                     fun (res, set') (d1, d2) ->
                       (* Pour chaque couple on crée les deux nombres résultants
                             (par exemple, pour 2 et 4, 24 et 42 *)
                       let i1 = int_of_string ((string_of_int d1)^(string_of_int d2)) in
                       let i2 = int_of_string ((string_of_int d2)^(string_of_int d1)) in
                       (* On rappelle récursivement la fonction sur ces deux nombres
                             et on somme les résultats renvoyés au résultat total *)
                       let r1, set' = s i1 set' in
                       let r2, set' = s i2 set' in
                       (r1 + r2 + res, set')
                   ) (r, vus) l
               in s n S.empty

              (* On appelle ici la fonction sur le nombre de notre choix *)
              let main n sup =
               let (res, _) = search n sup in
               (n, res)
              Répondre à ce message
        • Juillet 2015, 5ème défi

          le 31 juillet 2015 à 19:59, par Bernard Hanquez

          Une petite macro Excel me donne également 22.

          Répondre à ce message
          • Juillet 2015, 5ème défi

            le 2 août 2015 à 09:14, par lafrizi

            Soit xy un entier à deux chiffres.
            Réponse de longueur 1 :
            x*y = 8 donc S1=18, 81, 24, 42,

            Réponse de longueur 2 :(ie : 3*6=18 et 1*8=8)
            x*y = 18 donc S2=29, 92, 36, 63,
            x*y = 81 donc S3=99,
            x*y = 24 donc S4=38, 83, 46, 64,
            x*y = 42 donc S5=67, 76,

            Réponse de longueur 3 :
            x*y = 36 donc S6=49, 94, 66,
            x*y = 63 donc S7=79, 97, :
            x*y = 64 donc S8=88,
            x*y = 49 donc S9=77,

            Finalement la solution du problème est :
            S=S1US2US3US4US5US6US7US8US9
            Card(S)=22

            Répondre à ce message

Laisser un commentaire

Forum sur abonnement

Pour participer à ce forum, vous devez vous enregistrer au préalable. Merci d’indiquer ci-dessous l’identifiant personnel qui vous a été fourni. Si vous n’êtes pas enregistré, vous devez vous inscrire.

Connexions’inscriremot de passe oublié ?

Suivre IDM