Discussion :

[mlkgiosn]

Bonjour.

En fait je me pose une question, j'ai vu dans une vidéo que C était soit disons X fois plus rapide que python, mais avec mes minces connaissances, j'ai écrit un programme qui teste la conjecture de syracuse, dans chacun de ces 2 langages, de 1 jusqu'à 50.000, et C est totalement largué, le prog en python finit largement avant, plus de 50 secondes avant le prog en C.

Donc C est-il vraiment plus rapide ? Si oui faut m'expliquer lol.

[dourouc05]

Si tu codes comme un pied en C, Python risque d'être plus rapide. L'inverse est aussi vrai. La vraie différence, c'est que tu peux optimiser autant que tu veux en C : en Python, tu devras sortir du langage pour atteindre le dernier degré de performance.

Dans https://julialang.org/benchmarks/ (temps de calcul normalisés par rapport au C), on voit que, sur les problèmes testés, Python arrive une fois à peu près au niveau de C (de par l'utilisation d'une bibliothèque écrite en Fortran pour la multiplication matricielle), mais est sinon largué.

Donne les deux codes que tu as utilisés pour tes tests : des gens plus avertis pourraient remarquer des problèmes dans le code (ne fût-ce qu'un malloc/free à chaque itération, ça tue la performance en moins de deux…).

[mlkgiosn]

Voici mon code en python :

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def syracuse(n):
    print(n)
    while n != 1:
        if n % 2 == 0:
            n = n / 2
        else:
            n = 3 * n + 1
        print(int(n))
 
nombre = 1
while nombre < 50001:
    syracuse(nombre)
    nombre = nombre + 1
    print("*******************************************************************************************")
    print()

Voici mon code en C :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <stdio.h>
#include <stdlib.h>
 
void syracuse(n) {
    printf("%d\n", n);
    while(n!=1) {
        if (n % 2 == 0) {
            n = n / 2;
        }
        else {
            n = 3 * n + 1;
        }
            printf("%d\n", n);
            }
}
 
int main()
{
    long nombre = 1;
    while (nombre < 50001) {
    syracuse(nombre);
    nombre++;
    printf("**************************************************************\n");
    }
 
    printf("\n");
    return 0;
}

Je suis débutant, alors c'est très possible que les codes soient très très améliorables lol.

[dourouc05]

Que se passe-t-il si tu retires les instructions d'affichage dans la boucle de calcul ? Je suppose que Python n'affiche pas le texte que tu lui demandes immédiatement, mais groupe plusieurs appels, contrairement à l'implémentation de la bibliothèque standard C.

[Canvas]

Bonsoir,

Dans le code C on doit pouvoir remplacer :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
if (n % 2 == 0) {
  n = n / 2;
}
else {
  n = 3 * n + 1;
}

par :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

n = (n & 1) ? (3*n + 1) : (n / 2);

[mlkgiosn]

Canvas : J'ai essayé avec la ligne de code que tu dis mais j'ai une erreur.

Cette erreur : |22|error: expected declaration or statement at end of input|





dourouc05 :Le problème c'est que sans instruction d'affichage je vois rien défiler et ça complique la comparaison.

[yildiz-online]

Pour une boucle incrémentale, for me semble plus indiqué.
Tu peux utiliser des move pour les divisions par 2 (>>1).
Tu peux utiliser un int plutôt qu'un long.
Tu peux utiliser des types non signés.
Tu peux compiler avec les optimisations aggressives (-O3).
Tu peux initialiser "**************************************************************\n" en dehors de la boucle et le réutiliser.
Les print c'est lent, tu peux stocker les résultats, et tout imprimer à la fin, ce ne sera pas plus rapide, mais tu pourras plus facilement isoler le temps de l'algo de calcul.

Disclaimer: je suis javaiste, donc tout ceci n'est peut-être pas totalement valide pour le C et encore moins pour Python, à prendre avec des pincettes donc(mais ça coûte pas grand chose de tester), et d'avance merci à ceux qui me corrigeront.

[Canvas]

Bonsoir,

En tenant compte des différents conseils, voici ce que cela peut donner :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#include <stdio.h>
#include <stdlib.h>
 
#define LONGUEUR 1024
 
int *syracuse(int n, int *size) {
   int *suite = malloc(LONGUEUR * sizeof *suite);
   int i = 0;
   while (n != 1) {
        n = (n & 1) ? (3*n + 1) : (n >> 1);
        suite[i++] = n;
   }
   *size = i;
   return suite;
}
 
int main(void) {
   int nb, i, j, size;
 
   printf("Saisir un entier positif : ");
   scanf("%d",&nb);
   printf("\n");
 
   printf("1 : 1\n");
 
   for (i=2; i <= nb; i++) {
      printf("%d : ", i);
      size = 0;
      int *a = syracuse(i, &size);
      for (j=0; j < size; j++) {
         printf("%d ", *(a + j));
      }
      printf("\n");
   }
   return 0;
}
 
 
# Test
 
Saisir un entier positif : 16
 
1 : 1
2 : 1 
3 : 10 5 16 8 4 2 1 
4 : 2 1 
5 : 16 8 4 2 1 
6 : 3 10 5 16 8 4 2 1 
7 : 22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 1 
8 : 4 2 1 
9 : 28 14 7 22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 1 
10 : 5 16 8 4 2 1 
11 : 34 17 52 26 13 40 20 10 5 16 8 4 2 1 
12 : 6 3 10 5 16 8 4 2 1 
13 : 40 20 10 5 16 8 4 2 1 
14 : 7 22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 1 
15 : 46 23 70 35 106 53 160 80 40 20 10 5 16 8 4 2 1 
16 : 8 4 2 1

Il y a moyen d'améliorer encore plus. Il faudrait poser la question sur le forum du langage C.

[kaitlyn]

Salut,

Et bien comparer deux langages avec des codes qui sont essentiellement dépensés dans des appels systèmes, je ne suis pas sûre que c'est pertinent.
Quoi qu'il en soit, le code C est ici pénalisé par la mémoire tampon qui est en mode ligne par défaut et le nombre excessif de sauts de lignes (\n) à afficher qui tourne en boucle. En effet, à chaque saut de ligne, la mémoire tampon se vide, ce qui consomme de la ressource et du temps. En changeant le mode de ligne à complet (full buffered) grâce à la fonction setvbuf(), il sera possible de rendre l'exécution du code C plus rapide, par exemple avec un if (setvbuf(stdout, 0, _IOFBF, 4096) != 0) return 1; juste après le int main() {.