31 juillet 2015

8 messages - Retourner à 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
Pour participer à la discussion merci de vous identifier : Si vous n'avez pas d'identifiant, vous pouvez vous inscrire.