Bonjour, 

Alors voila je m'amuse un peu avec la suite de Syracuse, en essayant de trouver un contre exemple grâce a un programme en C. Le programme est simple, tant que le résultat trouvé est égal a un, on affiche le nombre et on l'augment d'un. Mais le problème c'est que l'affichage du nombre reste bloqué à 113 383. Mais si je commence à partir de 113 384 la suite reste bloqué à 134 379. Je sais pas d'où vient le problème, j'ai fait le même programme en python et il va beaucoup plus loin (même s'il est beaucoup plus lent que le C).

Voici mon code

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int result = 1;
    int number = 113384;
    int c=0;
    while (result ==1){
        c= number;
        printf(" %d", number);

        while (c != 1){
           if (c%2 ==0){
                c = c /2;
                result= c;
            }
            else{
                c = c*3+1;
                result= c;
            }
        }
        number++;
    }
}

Hello,

Ta première condition d'arrêt est incorrect sauf erreur de ma part.
Pas sur de bien comprendre ce que tu cherches à faire mais s'il s'agit de chercher l'indice n pour tous les entiers naturels alors ce code me semble plus approprié.

Tu peux remplacer 100 par la valeur que tu souhaites et notamment SIZE_MAX en n'oubliant pas d'inclure limits.h.
Ça risque de prendre un peu de temps.

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>



int main()
{
    size_t u0 = 1;
    while ( u0 < 100 )
    {
        size_t n = 0;
        size_t un = u0;
        while ( un != 1 )
        {
            if   ( un%2 == 0 ){ un /= 2     ;}
            else              { un  = un*3+1;}

            n++;
        }
        printf("\n u0 = %10u ; n = %10u", u0, n);
        u0++;
    }
    return 0;
}

Resultat pour les 9 premiers entiers naturels

 u0 =          1 ; n =          0
 u0 =          2 ; n =          1
 u0 =          3 ; n =          7
 u0 =          4 ; n =          2
 u0 =          5 ; n =          5
 u0 =          6 ; n =          8
 u0 =          7 ; n =         16
 u0 =          8 ; n =          3
 u0 =          9 ; n =         19

Je ne sais pas si c'est moi qui suis has been mais je ne comprends vraiment pas ce qu'on vous apprends à l'école concernant l'indentation.
C'est une horreur. ( pour moi ) et ça se propage comme le feu sur la thundra par une journée d'été.
Ce qui ce conçoit bien, s’énonce clairement et me concernant je ne comprends pas qui serait assez sain d'esprit pour trouver que cette façon d'indenter est lisible.

-
Edité par aneonymous 30 avril 2019 à 20:22:36

Merci de ta réponse, désolé pour l'indentation, si tu parles des accolades ça doit être mon habitude à programmer en CSS/JS où on m'a appris à faire comme (mais je te rassure en C/JAVA on nous demande de faire comme toi). Pour ce qui est de ce que je cherche à faire je vais expliquer plus en détail ce qu'ai la suite de Syracuse: En fait quelqu'un à remarquer pendant l'antiquité que si on prenait n’importer quel chiffe strictement positif et que s'il était paire on le diviser par deux, et s'il était impaire on le multiplier par 3 et on ajouter 1, et qu'on faisait répéter le processus avec les résultat obtenues, on finirai toujours par retomber sur 1. Le problème ce que on a jamais réussi à le démontrer, ni à trouver de contre exemple. Et du coup je voulais faire un programme pour voir jusqu’à ou mon pc serai capable de calculer. Je sais pas si j'ai été très claire. 

Du coup je suis pas sûr que ton code correspond à ma recherche

Hello,

Oui, c'est bien ce qu'il me semblait que tu souhaitais faire.
Malheureusement, on est limité par ce que peut calculer la machine. Tu seras déjà limité par ce qu'est capable de stocker une variable.

Un contre exemple signifierait que ta boucle soit infinie n'est-ce pas ?
C'est bien le problème. Comment savoir si une boucle est infinie si on ne sait pas déterminer mathématiquement qu'elle l'est ?

La seule chose que tu pourras faire est supposer.
Tu peux parcourir tous les entiers positifs que la machine te permet de parcourir, de même pour un et l'indice n.
Quand tu arrives à la limite de ce que peux stocker l'une des 3 variables, tu peux alors supposer que pour cette valeur de u0, il se pourrait que Syracuse soit faux mais c'est tout.

En revanche, si le temps et la machine le permet, tu pourras éventuellement prouver que de 0 à N Syracuse est vrai jusqu'à ce que la boucle soit suffisamment longue pour que tu aies le temps de mourir.

Il me semble que unsigned long long int soit le type le plus grand dans la librairie standard.
Tu pourrais aussi compiler en 64bit pour aller plus loin et trouver une bibliothèque qui permet d'utiliser de plus grands nombres et un super calculateur

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>

typedef unsigned long long int ulli_t;

int main()
{
    ulli_t u0 = 1;
    ulli_t un = 0;
    ulli_t  n = 0;
    ulli_t MAX_ODD_ULLI = (LONG_LONG_MAX-1)/3;

    bool overflow = false;
    while ( u0 <= LONG_LONG_MAX )
    {
         n =  0;
        un = u0;
        while ( un != 1 )
        {
            if ( un == LONG_LONG_MAX || n == LONG_LONG_MAX )
            {
                printf("\n LONG_LONG_MAX a ete atteint par un et/ou n pour u0 = %llu", u0);
                overflow = true;
                un=1;
            }

            else
            {
                if ( un%2 == 0 )
                    un /= 2, n++;

                else
                {
                    if ( un <= MAX_ODD_ULLI )
                        un  = un*3+1, n++;

                    else
                    {
                        printf("\n La valeur max pour un impair a ete atteinte avec u0 = %llu", u0);
                        overflow = true;
                        un=1;
                    }
                }
            }
        }

        if ( !overflow )
            printf("\n u0 = %10llu ; n = %10llu", u0, n);

        u0++;
    }

    if ( !overflow )
        printf("\n Tous les entiers positifs du type size_t ont verifies la suite de Syracuse");

    return 0;
}

-
Edité par aneonymous 1 mai 2019 à 15:00:56

Oui apparemment mon programme ne marcher pas parce que les int ne pouvait pas stocker une valeur aussi grande (quelque chose dans l'ordre de 10 chiffres) le sujet est donc clos. Merci de ton aide.

Down.