Löschen eines Arrays mit definierten Element(en) - Seite 18

Neuer Kommentar
 
Vladimir Pastushak:
Ich habe es herausgefunden, es war die Feldverschiebung in der Struktur, nicht die ganze Struktur...

Wenn die Struktur ein einfacher Typ ist, sollte es funktionieren.

 

Eine weitere Nuance. Ich habe bewiesen, dass mein Algorithmus korrekt funktioniert. Ich habe die Werte ausgedruckt, die ich nach Ausführung der Funktion erhalten habe. Wie gut die anderen Algorithmen funktionieren, ist ein Rätsel.

Die Prüfsumme scheint jedoch korrekt zu sein.

 
Реter Konow:

ZS: Sie haben allerdings einen Fehler gemacht, als Sie die Funktion nach meiner Lösung geschrieben haben:

Meine Funktion ist nicht

а

Aber trotzdem danke.

Nein, ich habe keinen Fehler gemacht, ich habe Ihren Fehler korrigiert. Überlegen Sie sich, was Ihr Text bewirkt, und versuchen Sie, ihn zu ändern, dann werden Sie es sehen. Es wird die falsche Prüfsumme und die falsche Größe haben.
 
Реter Konow:


ZS: Sie haben allerdings einen Fehler gemacht, als Sie die Funktion nach meiner Lösung geschrieben haben:

Meine Funktion ist nicht

а


in Ihrem Code ist es dasselbe wie

 
Nikolai Semko:
Nein, ich habe keinen Fehler gemacht, ich habe Ihren Fehler korrigiert. Überlegen Sie gut, was Ihre Linie macht? Versuchen Sie einfach, es zu ändern, und Sie werden sehen. Es wird die falsche Prüfsumme und die falsche Größe haben.

Das Ergebnis ist genau dasselbe. Es liegt kein Fehler vor.

Ja, es bewirkt nichts. Aber es macht damit mehr Sinn. ))

 
Stanislav Dray:

in Ihrem Code ist es gleich

Ja.

 
Реter Konow:

Ja.

Oh ja, Entschuldigung.

Ich erinnerte mich.
Ihr Code wurde von hier übernommen.

Deine Zeile war nicht da, und ich erinnere mich an die Zeile, die ich hinzufügen musste, damit es richtig funktioniert.

Tag Konow:

Aber es macht damit mehr Sinn. ))

Es ist eine zusätzliche mathematische Operation enthalten. ))

 

Frage. Warum wird in diesem Code nach der Änderung der Größe des Arrays immer noch dasselbe gedruckt wie vor der Änderung?


//+------------------------------------------------------------------+
//|                                             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);
  }
//+------------------------------------------------------------------+

Dies stellt die Gültigkeit der Prüfsummenprüfungsalgorithmen in Frage. Wenn wir also die Prüfsumme berechnen, machen wir eine Schleife durch das Array, das seine vorherigen Elemente beibehält?

Ich schlage vor, die Algorithmen auf meine Weise zu überprüfen. Durch die Ausgabe eines Arrays von 20 Werten.

Dies dient der Überprüfung der Korrektheit, nicht der Geschwindigkeit.
 
Реter Konow:

Frage. Warum wird in diesem Code nach der Änderung der Größe des Arrays immer noch dasselbe gedruckt wie vor der Änderung?


Dies stellt die Gültigkeit der Prüfsummenprüfungsalgorithmen in Frage. Wenn wir also die Prüfsumme berechnen, machen wir eine Schleife durch das Array, das seine vorherigen Elemente beibehält?

Ich schlage vor, die Algorithmen auf meine Weise zu überprüfen. Durch die Ausgabe eines Arrays von 20 Werten.

Dies ist ein Test der Korrektheit, nicht der Geschwindigkeit.
Ich schlage eine Million vor, denn es gibt eine Million in dem Test. Jeder soll sich hinsetzen und vergleichen.))
 
Nikolai Semko:
Ich schlage eine Million vor, denn es gibt eine Million in dem Test. Lasst alle sitzen und vergleichen))).

Die Prüfsumme ist nicht korrekt berechnet.

Überprüfen Sie es selbst. Sie zählt die Elemente, die im gelöschten Teil des Arrays verbleiben.

//+------------------------------------------------------------------+
//|                                             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;
  }
//+------------------------------------------------------------------+

Natürlich ist das noch kein Beweis dafür, dass die Prüfung falsch ist, aber es gibt schon einige Zweifel.


Die Prüfsumme wird aus den Elementen dieser Zeile berechnet:

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

Und die letzten 6 Elemente wurden zuvorvon ArrayResize gelöscht.

Aber die Funktion zählt sie trotzdem.

1...111213141516171819202122232425...30
Neuer Kommentar