Problème Algorithmique ioi france

Version imprimable

Bonjour;

Je suis actuellement bloqué sur un exercice de chez ioi France, mon code passe 18 tests sur 21. Les derniers tests échouent pour dépassement de la limite du temps.

Voici l'ennocée:
Un festival de musique met chaque jour un groupe en scène, un groupe pouvant jouer plusieurs jours différents. En tout, nbGroupes groupes vont jouer pour ce festival et ce dernier durera nbJours jours.

Vous connaissez l'ordre dans lequel les différents groupes vont se succéder au cours du festival à raison d'un par jour, et vous désirez assister au concert de chacun de ces groupes au moins une fois. Vous écrivez donc un programme capable de determiner la longueur de la plus petite séquence contiguë de jours permettant de voir au moins une fois chaque groupe.
Limites de temps et de mémoire (C)

Temps : 1 s sur une machine à 1 GHz.
Mémoire : 32 000 ko.

Contraintes

1 <= nbJours <= 100 000, où nbJours est le nombre de jours du festival.
1 <= nGroupes <= nbJours, le nombre de groupes jouant pour le festival.

Entrée

La première ligne de l'entrée contient deux entiers : nbJours et nbGroupes.

La ligne suivante contient nbJours entiers, le ie entier correspondant à l'identifiant 1 <= groupei <= nbGroupes du groupe jouant le ie jour.
Sortie

Votre programme doit afficher un unique entier : le plus petit nombre de jours consécutifs nécessaires pour voir au moins une fois chaque groupe jouer.
Exemple

entrée :

12 5
1 3 2 2 5 4 3 2 5 5 1 4

sortie :

6

Voici mon code:
Code:

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 #include <stdio.h> #include <stdlib.h> int nbJours, nbGroupes; int *planning = NULL, *dejaVu = NULL; int minDays(int minimum); int main() { int i; scanf("%d%d", &nbJours, &nbGroupes); planning = malloc(sizeof(int) * nbJours); dejaVu = malloc(sizeof(int) * nbJours); for(i = 0; i < nbJours; i++) { scanf("%d", &planning[i]); dejaVu[i] = 0; } printf("%d", minDays(nbJours)); free(dejaVu); free(planning); } int minDays(int minimum) { int debut = 0, iFin = 0, compteur = 0; int iGroup = 0; while(iFin < nbJours) { if(dejaVu[planning[iFin]] == iGroup) { dejaVu[planning[iFin]] = iGroup+1; compteur++; } while(compteur == nbGroupes) { if((iFin+1 - debut) < minimum) minimum = (iFin+1 - debut); iGroup++; debut++; compteur = 0; iFin = debut-1; } iFin++; } return minimum; }
J'utilise un tableau dejaVu pour valider un groupe complet de jours. Je parcours le tableau planning plusieurs fois. Je pense que c'est cela qui plombe la vitesse.
Merci d'avance pour l'aide apportée !

Bonjour,

Tu ne testes pas les éléments d'entrée, je te conseille donc de le faire, c'est une bonne pratique à adopter.
De plus, tu utilises des variables globales, ce qui est déconseillé.

Donc voici déjà un correctif (je n'ai pas modifié ton algorithme, il y a donc toujours le problème):

Code:

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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
 
typedef struct {
  uint32_t nbJours;
  uint32_t *planning;
 
  uint32_t nbGroupes;
  uint8_t *dejaVu;
} inputStruct;
 
uint32_t minDays(inputStruct *input);
 
int main(){
  uint32_t i;
  uint32_t result;
 
  inputStruct input;
 
  printf("Entrer nbJours et nbGroupes: ");
  scanf("%u%u", &input.nbJours, &input.nbGroupes);
  printf("\nnbJours %u, nbGroupes %u\n", input.nbJours, input.nbGroupes);
  if((input.nbJours < 1) || (input.nbJours > 100)){
    printf("[ERR] 1 <= nbJours(%u) <= 100\n", input.nbJours);
    return -1;
  }
  if((input.nbGroupes < 1) || (input.nbGroupes > input.nbJours)){
    printf("[ERR] 1 <= nbGroupes(%u) <= nbJours(%u)\n", input.nbGroupes, input.nbJours);
    return -1;
  }
 
  input.planning = malloc(sizeof(uint32_t) * input.nbJours);
  input.dejaVu = malloc(sizeof(uint8_t) * input.nbGroupes);
  if((input.planning == NULL) || (input.dejaVu == NULL)){
    printf("[ERR] memory allocation failed\n");
    return -1;
  }
  printf("Init...\n");
  for(i = 0; i < input.nbJours; i++){
    printf("Entrer Groupe pour jour %u: ", i+1);
    int groupe;
    scanf("%u", &groupe);
    if((groupe < 1) || (groupe > input.nbGroupes)){
      printf("[ERR] Le Groupe n'est pas compris entre 1 et %u\n", input.nbGroupes);
      i--;
    } else {
      input.planning[i] = groupe;
    }
  }
  for(i = 0; i < input.nbGroupes; i++){
    input.dejaVu[i] = 0;
  }
 
  printf("Process...\n"); 
  result = minDays(&input);
  if(result >= input.nbGroupes){
    printf("Result: %u\n", result);
  } else {
    printf("[ERR] Result: les groupes n'ont pas tous été plannifiés\n");
  }
 
  free(input.dejaVu);
  free(input.planning);
  printf("End\n");
 
  return 0;
}
 
uint32_t minDays(inputStruct *input){
  uint32_t debut = 0, iFin = 0, compteur = 0;
  uint32_t iGroup = 0;
  uint32_t minimum = input->nbJours;
  while(iFin < input->nbJours){
    if(input->dejaVu[input->planning[iFin]] == iGroup){
      input->dejaVu[input->planning[iFin]] = iGroup+1;
      compteur++;
    } 
    while(compteur == input->nbGroupes){
      if((iFin+1 - debut) < input->nbJours){
        minimum = (iFin+1 - debut);
      }
      iGroup++;
      debut++;
      compteur = 0;
      iFin = debut-1;
    }
    iFin++;
  }
  return minimum;
}

Ton programme ne fonctionne pas :

Code:

1
2
10 5
1 1 2 2 3 4 5 5 1 2

=> retourne 6. Donc je te laisse trouver la solution pour modifier minDays afin que ça fonctionne.

La première piste que je peux te donner : pourquoi ton tableau dejaVu fait la même taille que planning ?
=> le tableau dejaVu devrait indiquer si le groupe a déjà été vu. De plus, tu devrais avoir un compteur qui t'indique le nombre de groupe déja vu : dès que le compteur atteint la valeur du nombre de groupe, c'est que tous les groupes sont passés et si à la fin de l’exécution de la fonction minDays le compteur est inférieur au nombre de groupes, c'est qu'un ou plusieurs groupe n'ont pas été planifiés.

Bonjour,

Le principe d'utiliser pour les groupes vus un tableau d'entier me chagrinait un peu (des booléens suffisent). D'où le remplacement par un entier de 64 bits dont chaque bit à 0 signale que le groupe correspondant a déjà été vu. Quand l'entier vaut 0 c'est bon. Et on tient un prétendant au meilleur score mais la sortie se fait aussi avec la limite de durée. Dans ce cas si l'entier ne vaut pas 0 c'est fini on retourne directement le résultat trouvé (durée + 1 si aucune solution).
On peut dépasser les 64 bits donc 64 groupes en utilisant plusieurs mots mais c'est un peu plus laborieux, genre vus[j >> 6] &= ~(1 << (plan[j] & 63)); etc. En résumé j'ai eu la flemme :oops:

Code:

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
#include <stdio.h>
#include <stdlib.h>
 
int duree;                                       // durée du festival
int *plan;                                       // Groupe de chaque jour
unsigned long long visibles;                     // Ensemble des groupes visibles au festival
 
int minDays() {
   int minimum = duree + 1;
   int i, j;
   for(i = 0; i <= duree; i++) {
      unsigned long long vus = visibles;
      for(j = i; (j < duree) && (vus); j++) vus &= ~(1 << plan[j]);
      if(vus) return minimum;                    // Pas la peine d'insister
      int d = j - i + 1;
      if(d < minimum) minimum = d;
   }
   return minimum;
}
 
int main() {
   int i, result,nbGroupes, nbGrpMax;
   do {
      printf("Entrer duree (1..100) et nb groupes (1..min(64,duree)) : ");
      scanf ("%d%d", &duree, &nbGroupes);
      printf("\n%d jours, %d groupes\n", duree, nbGroupes);
      nbGrpMax = duree > 64 ? 64: duree;
   } while((duree < 1) || (duree > 100) || (nbGroupes < 1) || (nbGroupes > nbGrpMax));
   plan     = malloc(sizeof(int) * duree);
   visibles = (1 << nbGroupes) - 1;              // 5 groupes => b100000 - 1 = b11111
   printf("\nInitialisation\n------------------\n");
   for(i = 0; i < duree; i++) {
      int groupe;
      printf("Groupe du jour %2d ? ", i+1);
      scanf("%d", &groupe);
      if((groupe > 0) && (groupe <= nbGroupes))
         plan[i] = groupe - 1;                   // -1 ramène de 0 à nbGroupes-1
      else {
         printf("Erreur : groupe non entre 1 et %d\n", nbGrpMax);
         i--;
      }
   }
   result = minDays();
   if(result <= duree) printf("------------------\nResultat : %d\n", result);
   else printf("[ERR] Certains groupes non plannifies\n");
   free(plan);
   return 0;
}

Salutations

26/06/2024, 09h28
boboss123

Citation:

Envoyé par Guesset

Bonjour,
On peut dépasser les 64 bits donc 64 groupes en utilisant plusieurs mots mais c'est un peu plus laborieux, genre vus[j >> 6] &= ~(1 << (plan[j] & 63)); etc. En résumé j'ai eu la flemme :oops:

Vu qu'il peut potentiellement y avoir 100 000 groupes, je ne suis pas certains que ça soit la meilleur solution que d'utiliser cette méthode.

Remarque : en langage C le type int n'a pas de taille imposée, ça peut être un nombre de 16bits, ce qui est insuffisant pour enregistrer la valeur 100000. il serait mieux d'utiliser le type uint32_t (4 octets) à la place, ce qui amène une consommation de 4 x 100000 = 400 ko pour la tableau planning et 1 x 100000 = 100 ko pour le tableau dejaVu (il faut ajouter quelques octets pour le stockage des variables tampon pendant les calculs) : on est donc dans les clous, pas besoin d'utiliser cette méthode pour réduire la consommation mémoire.
26/06/2024, 10h39
Guesset

Bonjour Boboss,

Citation:

Envoyé par boboss123

Vu qu'il peut potentiellement y avoir 100 000 groupes, je ne suis pas certains que ça soit la meilleur solution que d'utiliser cette méthode.
Remarque : en langage C le type int n'a pas de taille imposée, ça peut être un nombre de 16bits, ce qui est insuffisant pour enregistrer la valeur 100000. il serait mieux d'utiliser le type uint32_t (4 octets) à la place, ce qui amène une consommation de 4 x 100000 = 400 ko pour la tableau planning et 1 x 100000 = 100 ko pour le tableau dejaVu (il faut ajouter quelques octets pour le stockage des variables tampon pendant les calculs) : on est donc dans les clous, pas besoin d'utiliser cette méthode pour réduire la consommation mémoire.

Un entier int est aujourd'hui au moins du 32 bits sur les ordinateurs (ce qui exclut, mais de moins en moins, les MPU). Mais c'est vrai que je préfère les types explicites.
La forme initiale de gestion des groupes utilise 100 000 int soit 400 000 octets contre 12 500 octets soit 1563 uint64_t pour le mode set.
Mais le gain principal ne réside pas là. Le travail avec un ensemble permet de détecter beaucoup plus rapidement que tous les groupes ont étés vus. Environ 64 fois plus vite et la vérification à 0 n'a statistiquement que la moitié des 1563 uint64_t à parcourir.

Il me semblait que le temps était un critère non satisfait d'où ce type de proposition (en fait je crois que j'utiliserais les instruction AVX512 pour x par 8 encore les performances mais cela nécessite de l'assembleur inline).
Une question : je me demande comment sont vérifiés les temps dans un programme qui fait de la saisie manuelle et n'intègre pas de mesure de temps intrinsèque sur la partie critique ? Automate de saisie ?

Ceci étant, un festival de 100 000 jours durerait à peu près de 273 ans 9 mois 12 jours. Je ne suis pas sûr que ce soit réaliste :D. De même que la distribution des groupes, imagine un groupe qui passe le premier et dernier jour du festival de 100 000 jours :aie:.

Salut

Citation:

Envoyé par Guesset

Une question : je me demande comment sont vérifiés les temps dans un programme qui fait de la saisie manuelle et n'intègre pas de mesure de temps intrinsèque sur la partie critique ? Automate de saisie ?

C'est la question que je me posais aussi : surtout qu'il y a des scanf.

Je serais parti sur cette solution :

Code:

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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
 
typedef struct {
  uint32_t nbJours;
  uint32_t *planning;
 
  uint32_t nbGroupes;
  uint8_t *dejaVu;
} inputStruct;
 
uint32_t minDays(inputStruct *input);
 
int main(){
  uint32_t i;
  uint32_t result;
 
  inputStruct input;
 
  printf("Entrer nbJours et nbGroupes: ");
  scanf("%u%u", &input.nbJours, &input.nbGroupes);
  printf("\nnbJours %u, nbGroupes %u\n", input.nbJours, input.nbGroupes);
  if((input.nbJours < 1) || (input.nbJours > 100)){
    printf("[ERR] 1 <= nbJours(%u) <= 100\n", input.nbJours);
    return -1;
  }
  if((input.nbGroupes < 1) || (input.nbGroupes > input.nbJours)){
    printf("[ERR] 1 <= nbGroupes(%u) <= nbJours(%u)\n", input.nbGroupes, input.nbJours);
    return -1;
  }
 
  input.planning = malloc(sizeof(uint32_t) * input.nbJours);
  input.dejaVu = malloc(sizeof(uint8_t) * input.nbGroupes);
  if((input.planning == NULL) || (input.dejaVu == NULL)){
    printf("[ERR] memory allocation failed\n");
    return -1;
  }
  printf("Init...\n");
  for(i = 0; i < input.nbJours; i++){
    printf("Entrer Groupe pour jour %u: ", i+1);
    int groupe;
    scanf("%u", &groupe);
    if((groupe < 1) || (groupe > input.nbGroupes)){
      printf("[ERR] Le Groupe n'est pas compris entre 1 et %u\n", input.nbGroupes);
      i--;
    } else {
      input.planning[i] = groupe;
    }
  }
  for(i = 0; i < input.nbGroupes; i++){
    input.dejaVu[i] = 0;
  }
 
  printf("Process...\n"); 
  result = minDays(&input);
  if(result >= input.nbGroupes){
    printf("Result: %u\n", result);
  } else {
    printf("[ERR] Result: les groupes n'ont pas tous été plannifiés\n");
  }
 
  free(input.dejaVu);
  free(input.planning);
  printf("End\n");
 
  return 0;
}
 
uint32_t minDays(inputStruct *input){
  uint32_t counter = 0;
  uint32_t indexNbJours = 0;
  uint32_t indexDejaVu;
  uint8_t *ptrDejaVu;
 
  uint32_t *planning = input->planning;
  uint8_t *dejaVu = input->dejaVu;
 
  uint32_t nbJours = input->nbJours;
  uint32_t nbGroupes = input->nbGroupes;
 
  while(indexNbJours < nbJours){
    //printf("indexNbJours: %u\n", indexNbJours);
    indexDejaVu = planning[indexNbJours]-1;
    //printf("indexDejaVu: %u\n", indexDejaVu);
    ptrDejaVu = &dejaVu[indexDejaVu];
    if(*ptrDejaVu == 0){
      *ptrDejaVu = 1;
      counter++;
      if(counter == nbGroupes){
        indexNbJours++;
        //printf("Result: %u [OK]\n", indexNbJours);
        return indexNbJours;
      }
    }
    indexNbJours++;
  }
 
  //printf("[ERR] Result: %u\n", counter);
  return counter; // erreur : retourne le nombre de groupes planfiés
}

=> je me demande quelle est la différence de temps d’exécution avec ta solution

Bonjour Boboss123,

Citation:

Envoyé par boboss123

...=> je me demande quelle est la différence de temps d’exécution avec ta solution

Sauf erreur, elle devrait être meilleure en temps puisqu'elle ne fait qu'une boucle à partir de 0. Mais cet algorithme ne fonctionne pas, même si, par chance, il donne le bon résultat avec la séquence que tu as proposée.

Par exemple, avec la permutation du premier 5 avec le dernier 2, le code proposé donnera 8 alors que la solution est 6 :

0123456789 indice dans la planification
1122342515 permutation
1122342515 soit 8 avec ce dernier algo
1122342515 mais la solution est 6
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 Entrer duree (1..100) et nb groupes (1..min(64,duree)) : 10 5 10 jours, 5 groupes Initialisation ------------------ Groupe du jour 1 ? 1 Groupe du jour 2 ? 1 Groupe du jour 3 ? 2 Groupe du jour 4 ? 2 Groupe du jour 5 ? 3 Groupe du jour 6 ? 4 Groupe du jour 7 ? 2 Groupe du jour 8 ? 5 Groupe du jour 9 ? 1 Groupe du jour 10 ? 5 ------------------ Resultat : 6
Salut

26/06/2024, 17h30
boboss123

Ha oui autant pour moi, j'ai mal interprété la question :)
27/06/2024, 12h32
kaitlyn

Salut,

Citation:

Envoyé par Guesset

Une question : je me demande comment sont vérifiés les temps dans un programme qui fait de la saisie manuelle et n'intègre pas de mesure de temps intrinsèque sur la partie critique ? Automate de saisie ?

Tu fais tes mesures dans une application parent. Concrètement, elle lance le programme à évaluer comme processus enfant, en mode pausé, active le chrono, débloque le processus, Après avoir redirigé les entrée et sortie standards, elle transmet les données par tube (pipe). Dès réception du résultat (toujours par pipe), elle stoppe le chrono. Pour les autres infos, c'est l'OS qui les donne, notamment avec l'identifiant du processus. Voilà pour les grandes lignes, plus augmenter la priorité du processus aussi.
27/06/2024, 13h58
CosmoKnacki

Citation:

Envoyé par Guesset

1122342515 mais la solution est 6

Voire 5.
27/06/2024, 14h09
Guesset

Bonjour kaitlyn,

Citation:

Envoyé par kaitlyn

...Tu fais tes mesures dans une application parent. Concrètement, elle lance le programme à évaluer comme processus enfant, en mode pausé, active le chrono, débloque le processus, Après avoir redirigé les entrée et sortie standards, elle transmet les données par tube (pipe). Dès réception du résultat (toujours par pipe), elle stoppe le chrono...

OK, c'est un automate, donc la précision des mesures est assez faible ce qui doit inciter à travailler avec des forts volumes pour minimiser l'impact des temps système des échanges stdin, stdout. J'espère que le temps de saisie - simulé - n'est pas intégré car il ne caractérise pas l'algorithme.

Le changement de priorité diminue les influences de l'OS sur la tache en court sans les faire complètement disparaître. Cet aspect m'a toujours laisser perplexe : vaut il mieux une mesure la plus intrinsèque possible ou une mesure plus représentative d'une exécution normale ?

Salut
27/06/2024, 14h34
Guesset

Bonjour CosmoKnacki,

Citation:

Envoyé par CosmoKnacki

Voire 5.

Oups ! Tout ça parce que j'ai oublié que j vaut 1 de plus en sortie de boucle puisque le contrôle de sortie de la boucle j a lieu après l'incrémentation (sauf à l'entrée dans la boucle bien sûr).

Donc le d = j - i + 1 doit être remplacé par d = j - i.

Merci.

Salut
27/06/2024, 15h23
kaitlyn

Citation:

Envoyé par Guesset

.../...

Les échanges système, tu peux les estimer et ensuite les déduire du résultat. Tu peux aussi lancer le chrono quand stdin a été vidé, supprimer les caches, etc, donc c'est à toi d'optimiser ton application et ton environnement en fonction de ce que tu veux. Toujours est-il que si tu gères bien les priorités, tu peux aisément atteindre une précision supérieure à la nanoseconde et obtenir des résultats répétables et prédictibles. En exécution normale, s'il y a plein de processus en concurrence, ça sera difficilement possible au regard de la seconde d'exécution impartie.
27/06/2024, 15h56
Guesset

Bonjour kaitlyn,

Citation:

Envoyé par kaitlyn

Les échanges système, tu peux les estimer et ensuite les déduire du résultat. Tu peux aussi lancer le chrono quand stdin a été vidé, supprimer les caches, etc, donc c'est à toi d'optimiser ton application et ton environnement en fonction de ce que tu veux. Toujours est-il que si tu gères bien les priorités, tu peux aisément atteindre une précision supérieure à la nanoseconde et obtenir des résultats répétables et prédictibles. En exécution normale, s'il y a plein de processus en concurrence, ça sera difficilement possible au regard de la seconde d'exécution impartie.

Estimations et mesures précises ne vont pas de pair.

Même en temps réel, le système d'un PC peut interrompre (certes rarement) une application. Par ailleurs l'automate ne peut octroyer une priorité supérieure à la sienne ce qui est assez contraignant. On peut effectivement obtenir des résultats stables si les volumes ou les temps sont très importants (ce qui justifie peut être un festival de 273 ans). La stabilité permet la comparaison mais ne garantit pas une exactitude parfaite : l'OS ne s'efface jamais complètement, on finit par avoir une mesure effective mais additionnée d'un "bruit de fond" moyen.

Salut
27/06/2024, 20h06
kaitlyn

Citation:

Envoyé par Guesset

Estimations et mesures précises ne vont pas de pair.
.../...

C'est même synonyme. Remplace "estimer" par "mesurer à dix puissance moins neuf près" si ça te fait plaisir. Je t'informe que c'est de la statique. Ta mesure n'est qu'une estimation, une approximation d'une certaine réalité. C'est ton protocole expérimental qui dira si tu en es proche (véracité, exactitude) ou pas. Pour le reste de ton message, il y a le 'toutes choses égales par ailleurs", ça te dit quelque chose ?

Citation:

Envoyé par Guesset

Par ailleurs l'automate ne peut octroyer une priorité supérieure à la sienne

T'as vu ça où ?
28/06/2024, 09h36
Guesset

Bonjour kaitlyn,

Citation:

Envoyé par kaitlyn

C'est même synonyme. Remplace "estimer" par "mesurer à dix puissance moins neuf près" si ça te fait plaisir. Je t'informe que c'est de la statique. Ta mesure n'est qu'une estimation, une approximation d'une certaine réalité. C'est ton protocole expérimental qui dira si tu en es proche (véracité, exactitude) ou pas. Pour le reste de ton message, il y a le 'toutes choses égales par ailleurs", ça te dit quelque chose ?

Si une mesure peut être considérée comme une estimation, l'inverse n'est pas vrai. Une estimation prédictive, par exemple une estimation électorale, n'est pas une mesure. Par ailleurs, une estimation peut porter sur des grandeurs non mesurables, il suffit qu'il existe des repères (numéros) sans nécessairement des quantités.

La notion de véracité, exactitude n'existe pas en statistique, on a seulement une probabilité de confiance que la valeur réelle est entre telle et telle valeurs.

L'expression "toutes choses égales par ailleurs" n'est qu'une hypothèse simplificatrice pratique qui n'est pas réaliste. Si elle l'était, les mesures exactes seraient possibles puisqu'on serait capable d'avoir des égalités parfaites. Il faut donc intégrer une incertitude sur la stabilité de l'environnement pour ne pas appliquer l'hypothèse d'ergodicité n'importe comment.

Il y a deux échelles de priorité, une externe et l'autre interne aux applications, la seconde étant subornée à la première.

Salut
28/06/2024, 17h37
kaitlyn

Salut Guesset,

On connait ta propension à sortir un mot de son contexte pour prétexte à blablater, mais tant qu'à faire du HS et avoir le dernier mot, tu aurais pu quand même répondre à la vraie question.