IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Algorithmes et structures de données Discussion :

Calcul des temps de connexion et de déconnexion


Sujet :

Algorithmes et structures de données

  1. #1
    Nouveau Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mai 2013
    Messages
    17
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Algérie

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : Mai 2013
    Messages : 17
    Points : 0
    Points
    0
    Par défaut Calcul des temps de connexion et de déconnexion
    svp esque la déclaration est juste pour la fonction

    Algorithme calcule des temps connexions/déconnexion :
    Code : 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
    Fonction tempsc (tab [i....n , j....k]) {
              temps_c : entier ; 
                temps_c= 0;
                 DernierEtat : char ;  //Afin de garder le dernier état du couple (con,dec)
            DerinerEtat = ‘F’ ; //mettre n’importe  different de C   
    Pour i allant de 1 à n  //Pour les interface I1,I2,.......,In
          Pour j allant de 0 à k  //On parcours à travers les temps
          Si Ii[j]=’D’
                 Si (derniEretat ≠ ‘c’ )
                  DernierEtat   ‘D’
             Sinn 
                DernierEtat   ‘D’
                   Temps_c   temps_c + (Ii[j]- Ii[j-1]) ;
                 Finsi 
            Sinn //Ii[j]= ‘C’
                Si DernierEtat = nul
                    DernierEtat  ‘C’
               Sinn 
                Si DernierEtat = ‘C’
                       DernierEtat  ‘C’
                    Temps_c   temps_c + (Ii[j] – Ii[j-1])
                  Sinn 
                      DernierEtat   ‘C’ 
                Finsinn
           Finsinn
          Finpour
       Finpour
          Return temps_c   }

  2. #2
    Expert éminent sénior Avatar de Flodelarab
    Homme Profil pro
    Inscrit en
    Septembre 2005
    Messages
    5 243
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Charente (Poitou Charente)

    Informations forums :
    Inscription : Septembre 2005
    Messages : 5 243
    Points : 13 458
    Points
    13 458
    Par défaut
    Bonjour

    La déclaration est juste.
    Cette réponse vous apporte quelque chose ? Cliquez sur en bas à droite du message.

  3. #3
    Membre averti
    Avatar de ChipsAlaMenthe
    Homme Profil pro
    Ingénieur en eau chaude et ballon rond
    Inscrit en
    Mai 2015
    Messages
    138
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Puy de Dôme (Auvergne)

    Informations professionnelles :
    Activité : Ingénieur en eau chaude et ballon rond
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Mai 2015
    Messages : 138
    Points : 394
    Points
    394
    Par défaut
    Code : 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
    Fonction tempsc (tab [i....n , j....k]) 
    {
        temps_c : entier ; 
        temps_c= 0;
        DernierEtat : char ;  //Afin de garder le dernier état du couple (con,dec)
        DerinerEtat = ‘F’ ;    //mettre n’importe  different de C
     
        Pour i allant de 1 à n  //Pour les interface I1,I2,.......,In
            Pour j allant de 0 à k  //On parcours à travers les temps
                Si (Ii[j]=’D’) alors
                    Si (derniEretat ≠ ‘c’) alors
                        DernierEtat = ‘D’
                    Sinon 
                        DernierEtat = ‘D’
                        Temps_c = temps_c + (Ii[j]- Ii[j-1]) ;
                    Finsi 
                Sinon //Ii[j]= ‘C’
                    Si (DernierEtat = nul) alors
                        DernierEtat = ‘C’
                    Sinon 
                        Si (DernierEtat = ‘C’) alors
                            DernierEtat = ‘C’
                            Temps_c = temps_c + (Ii[j] – Ii[j-1])
                        Sinon 
                            DernierEtat = ‘C’ 
                        Finsi
                    Finsi
                Finsi
            Finpour
        Finpour
     
        Return temps_c   
    }
    C'est mon côté perfectionniste ^^

  4. #4
    Expert confirmé
    Avatar de anapurna
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Mai 2002
    Messages
    3 419
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Arts - Culture

    Informations forums :
    Inscription : Mai 2002
    Messages : 3 419
    Points : 5 818
    Points
    5 818
    Par défaut
    salut

    il est possible de simplifier ton algorithme

    en voila un exemple
    Code : 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
     
    Fonction tempsc (tab [i....n , j....k]) 
    variable
        l_tpscalc : entier ; 
        l_DernierEtat : char ;  //Afin de garder le dernier état du couple (con,dec)
    Debut
        l_DernierEtat = ‘D’ ;    //mettre n’importe  different de C
        l_tpscalc= 0;
        Pour i allant de 1 à n  Faire //Pour les interface I1,I2,.......,In
            Pour j allant de 0 à k  Faire //On parcours à travers les temps
                Si (Ii[j]=’D’) alors
                    Si (l_DernierEtat = ‘c’) alors
                        l_tpscalc = l_tpscalc + (Ii[j]- Ii[j-1]) ;
                    Finsi 
                    l_DernierEtat = ‘D’
         	     Sinon //Ii[j]= ‘C’
                   Si (l_DernierEtat = ‘C’) alors
                     l_tpscalc = l_tpscalc + (Ii[j] – Ii[j-1])
                   Finsi
                   l_DernierEtat = ‘C’
     	    Finsi
            Finpour
        Finpour
        Return l_tpscalc  
    Fin
    Nous souhaitons la vérité et nous trouvons qu'incertitude. [...]
    Nous sommes incapables de ne pas souhaiter la vérité et le bonheur, et sommes incapables ni de certitude ni de bonheur.
    Blaise Pascal
    PS : n'oubliez pas le tag

Discussions similaires

  1. Calcul sur des temps de fonctionnement
    Par micbett dans le forum Modélisation
    Réponses: 10
    Dernier message: 28/02/2008, 16h44
  2. Réponses: 20
    Dernier message: 30/03/2007, 15h01
  3. Mesurer le temps de calcul des fonctions
    Par dzada dans le forum Caml
    Réponses: 2
    Dernier message: 12/03/2007, 19h54
  4. [9i] Calculer des intervalles de temps
    Par tscoops dans le forum Oracle
    Réponses: 9
    Dernier message: 31/12/2005, 08h38
  5. Réponses: 8
    Dernier message: 18/09/2002, 03h20

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo