Effacement d'un tableau d'élément(s) défini(s) - page 18

Nouveau commentaire
 
Vladimir Pastushak:
J'ai compris, c'était le déplacement du champ dans la structure, pas la structure entière...

Si la structure est de type simple, cela devrait fonctionner.

 

Une autre nuance. J'ai prouvé que mon algorithme fonctionne correctement. J'ai imprimé les valeurs que j'ai obtenues après l'exécution de la fonction. Le fonctionnement des autres algorithmes est un mystère.

La somme de contrôle semble pourtant être correcte.

 
Реter Konow:

ZS. Vous avez tout de même fait une erreur en écrivant la fonction selon ma solution :

Ma fonction n'est pas

а

Mais merci quand même.

Non, je n'ai pas fait d'erreur, j'ai corrigé la tienne. Réfléchissez bien, que fait votre ligne ? Essayez de la modifier et vous verrez. Ce sera la mauvaise somme de contrôle et la mauvaise taille.
 
Реter Konow:


ZS. Vous avez tout de même fait une erreur en écrivant la fonction selon ma solution :

Ma fonction n'est pas

а


dans votre code, c'est la même chose que

 
Nikolai Semko:
Non, je n'ai pas fait d'erreur, j'ai corrigé la vôtre. Réfléchissez bien, que fait votre ligne ? Ça ne fait rien. Essaie de le changer et tu verras. Ce sera la mauvaise somme de contrôle et la mauvaise taille.

Le résultat est exactement le même. Il n'y a pas d'erreur.

Oui, ça ne fait rien. Mais ça a plus de sens avec elle. ))

 
Stanislav Dray:

dans votre code, il est égal à

Oui.

 
Реter Konow:

Oui.

Oh oui, désolé.

Je me suis souvenu.
Votre code a été pris d'ici.

Votre ligne n'était pas là et je me souviens de la ligne que j'ai dû ajouter pour que ça fonctionne correctement.

Tag Konow:

Mais ça a plus de sens avec elle. ))

Il y a une opération mathématique supplémentaire. ))

 

Question. Pourquoi dans ce code, après avoir changé la taille du tableau, l'impression reste la même qu'avant le changement ?


//+------------------------------------------------------------------+
//|                                             Erase and Resize.mq5 |
//|                                                      Peter Konow |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Peter Konow"
#property link      "https://www.mql5.com"
#property version   "1.00"
//--------------------------------------------------------------------
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
   int Arr[20] = {1,2,3,1,2,3,1,2,3,1,2,3,1,2,3,1,2,3,1,2};
   ulong q1 = GetMicrosecondCount(); 
   //--------------------------------
   PeterArray(Arr,3);
   //--------------------------------
   ulong q2 = GetMicrosecondCount();
   //--------------------------------
   Print("Array new size  ",ArraySize(Arr),"  Тime of operation  ",q2-q1);
   ArrayPrint(Arr); 
  }
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
int PeterArray(int &Arr[],int val) // вариант Peter Konow
  {
   int deleted=0,q=0;
   for(int a1=0; a1<ArraySize(Arr); a1++)
     {
      if(deleted)Arr[q]=Arr[q+deleted];
      if(Arr[q]==val){deleted++; q--;}
      q++;
     }
   ArrayResize(Arr,ArraySize(Arr) - deleted);
   return (q);
  }
//+------------------------------------------------------------------+

Cela remet en question la validité des algorithmes de vérification des sommes de contrôle. Donc, lorsque nous calculons la somme de contrôle, nous faisons une boucle dans le tableau qui conserve ses éléments précédents ?

Je suggère de vérifier les algorithmes à ma façon. En sortant un tableau de 20 valeurs.

Il s'agit d'une vérification de l'exactitude, et non de la rapidité.
 
Реter Konow:

Question. Pourquoi dans ce code, après avoir changé la taille du tableau, l'impression reste la même qu'avant le changement ?


Cela remet en question la validité des algorithmes de vérification des sommes de contrôle. Donc, lorsque nous calculons la somme de contrôle, nous faisons une boucle dans le tableau qui conserve ses éléments précédents ?

Je suggère de vérifier les algorithmes à ma façon. En sortant un tableau de 20 valeurs.

Il s'agira d'un test d'exactitude, et non de rapidité.
Je suggère un million, comme il y en a un million dans le test. Laissez tout le monde s'asseoir et comparer.))
 
Nikolai Semko:
Je suggère un million, puisqu'il y en a un million dans le test. Laissez-les tous s'asseoir et comparer))).

La somme de contrôle n'est pas calculée correctement.

Vérifiez vous-même. Il compte les éléments qui restent dans la partie supprimée du tableau.

//+------------------------------------------------------------------+
//|                                             Erase and Resize.mq5 |
//|                                                      Peter Konow |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Peter Konow"
#property link      "https://www.mql5.com"
#property version   "1.00"
//--------------------------------------------------------------------
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
   int Arr[20] = {1,2,3,1,2,3,1,2,3,1,2,3,1,2,3,1,2,3,1,2};
   ulong q1 = GetMicrosecondCount(); 
   //--------------------------------
   PeterArray(Arr,3);
   //--------------------------------
   ulong q2 = GetMicrosecondCount();
   //--------------------------------
   Print("Array new size  ",ArraySize(Arr),"  Тime of operation  ",q2-q1,"  Контрольная сумма: ",ControlSumm(Arr));
   
   ArrayPrint(Arr); 
  }
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
int PeterArray(int &Arr[],int val) // вариант Peter Konow
  {
   int deleted=0,q=0;
   for(int a1=0; a1<ArraySize(Arr); a1++)
     {
      if(deleted)Arr[q]=Arr[q+deleted];
      if(Arr[q]==val){deleted++; q--;}
      q++;
     }
   ArrayResize(Arr,ArraySize(Arr) - deleted);
   return (q);
  }
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
long ControlSumm(int &a[]) // суммирование всех элементов массива (контрольная сумма)
  {
   long sum=0;
   for(int i=0; i<ArraySize(a); i++) sum+=a[i];
   return sum;
  }
//+------------------------------------------------------------------+

Bien sûr, ce n'est pas encore la preuve que le chèque est faux, mais il y a déjà un doute.


La somme de contrôle est calculée à partir des éléments de cette ligne :

2018.11.16 14:36:28.456 Erase and Resize (USDJPY,H1)    1 2 1 2 1 2 1 2 1 2 1 2 1 2 3 1 2 3 1 2

Et les 6 derniers éléments ont été précédemment suppriméspar ArrayResize.

Mais la fonction les compte quand même.

1...111213141516171819202122232425...30
Nouveau commentaire
Raison: