Cancellare un array di elementi definiti - pagina 18

[Konstantin Nikitin]

Vladimir Pastushak:
L'ho capito, era lo spostamento di campo nella struttura, non l'intera struttura...

Se la struttura è di tipo semplice, dovrebbe funzionare.

[Реter Konow]

Un'altra sfumatura. Ho dimostrato che il mio algoritmo funziona correttamente. Ho stampato i valori che ho ottenuto dopo l'esecuzione della funzione. Quanto bene funzionino gli altri algoritmi è un mistero.

Il checksum sembra però essere corretto.

[Nikolai Semko]

Реter Konow:

ZS. Hai fatto un errore quando hai scritto la funzione secondo la mia soluzione, però:

La mia funzione non è

а

Ma grazie comunque.

No, non ho fatto un errore, ho corretto il tuo. Pensa bene, cosa fa la tua linea, prova a cambiarla e vedrai. Sarà il checksum sbagliato e la dimensione sbagliata.

[Stanislav Dray]

Реter Konow:

ZS. Hai fatto un errore quando hai scritto la funzione secondo la mia soluzione, però:

La mia funzione non è

а

nel tuo codice è lo stesso di

[Реter Konow]

Nikolai Semko:
No, non ho fatto un errore, ho corretto il tuo. Pensa bene, cosa fa la tua linea? Non fa niente, prova a cambiarlo e vedrai. Sarà il checksum sbagliato e la dimensione sbagliata.

Il risultato è esattamente lo stesso. Non c'è nessun errore.

Sì, non fa niente. Ma con questo ha più senso. ))

[Реter Konow]

Stanislav Dray:

nel tuo codice, è uguale a

Sì.

[Nikolai Semko]

Реter Konow:

Sì.

Oh sì, scusate.

Mi sono ricordato.
Il tuo codice è stato preso da qui.

La tua linea non c'era e mi ricordo di quella linea che ho dovuto aggiungere per farla funzionare correttamente.

Tag Konow:

Ma con questo ha più senso. ))

C'è un'operazione matematica in più. ))

[Реter Konow]

Domanda. Perché in questo codice, dopo aver cambiato la dimensione dell'array, stampa ancora lo stesso di prima del cambiamento?

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

Questo mette in discussione la validità degli algoritmi di controllo del checksum. Quindi, quando calcoliamo il checksum, facciamo un ciclo attraverso l'array che mantiene ancora i suoi elementi precedenti?

Suggerisco di controllare gli algoritmi a modo mio. Emettendo un array di 20 valori.

Questo sarà un controllo di correttezza, non di velocità.

[Nikolai Semko]

Реter Konow:

Domanda. Perché in questo codice, dopo aver cambiato la dimensione dell'array, stampa ancora lo stesso di prima del cambiamento?

Questo mette in discussione la validità degli algoritmi di controllo del checksum. Quindi, quando calcoliamo il checksum, facciamo un ciclo attraverso l'array che mantiene ancora i suoi elementi precedenti?

Suggerisco di controllare gli algoritmi a modo mio. Emettendo un array di 20 valori.

Questo sarà un test di correttezza, non di velocità.

Suggerisco un milione, come ce ne sono un milione nel test. Lasciate che tutti si siedano e si confrontino)).

[Реter Konow]

Nikolai Semko:
Suggerisco un milione, visto che ce ne sono un milione nel test. Che tutti si siedano e si confrontino)).

Il checksum non è calcolato correttamente.

Controllate voi stessi. Conta gli elementi che rimangono nella parte cancellata dell'array.

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

Naturalmente, questo non è ancora la prova che il controllo sia sbagliato, ma c'è già qualche dubbio.

Il checksum è calcolato dagli elementi di quella riga:

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

E gli ultimi 6 elementi sono stati precedentemente cancellatida ArrayResize.

Ma la funzione li conta comunque.