Algoritmi, metodi di soluzione, confronto delle loro prestazioni - pagina 11

Nuovo commento
 
Artyom Trishkin:

Il resto di noi finora ha solo l'audacia di ridere e puntare il dito.

Davvero? Ecco un punto di vista alternativo.

Un uomo arrivò su un filo di cui non aveva idea, e gli fu subito chiesto di lasciarlo, e lui ne fece un pasticcio, trascinandolo nella sua zona preferita.

ha finito per spostarsi in un ramo separato ed è venuto fuori con un problema incomprensibile che non ha nulla a che fare con i generici discussi in quel ramo o con la pratica.

In realtà non ha risolto il problema, e per di più è delirante quando cerca di far notare gli errori.

Non è la prima volta che lo fa.

Oh, povero bastardo.

Forse anche tu sei uno di quelli che cercano con l'ordinamento degli array e non capisci cosa sta succedendo?

 
Комбинатор:

Davvero? Ecco un punto di vista alternativo.

Un uomo è arrivato su un filo di cui non aveva idea, e gli è stato subito chiesto di lasciarlo, e lui l'ha portato sul suo argomento preferito.

ha finito per spostarsi in un ramo separato ed è venuto fuori con un problema incomprensibile che non ha nulla a che fare con i generici discussi in quel ramo o con la pratica.

In realtà non ha risolto il problema, e per di più è delirante quando cerca di far notare gli errori.

Non è la prima volta che lo fa.

Oh, povero bastardo.

Forse anche tu sei uno di quelli che cercano con l'ordinamento degli array e non capisci cosa sta succedendo?


Sai, molto tempo fa ho imparato a programmare - e poi ho scoperto che ci sono libri di testo sulla programmazione. È stato lo stesso con la padronanza di OOP e altre cose.

Tuttavia, un fatto è un fatto, nessuno ha fatto un esempio.

Due esempi con e senza l'uso di fogli (cioè senza classi).

Naturalmente, senza alcun uso di array di stringhe (questo è per la variante senza la classe).

 

beh, la questione dell'ordinamento è sempre rilevante - ci sono opzioni per un ordinamento più veloce della funzione standard e in generale qual è il codice? .... se ricordo bene ci sono diversi modi di ordinare a seconda della dimensione dell'array da ordinare - e la possibilità di utilizzare memoria aggiuntiva per accelerare

 

Sarebbe interessante vedere gli algoritmi più performanti in numeri, almeno in termini di tempo di esecuzione.

Finora, sembra che stiamo difendendo la nostra versione come la migliore.

Tuttavia, i criteri per questa autovalutazione non sono chiari.

 
Комбинатор:

Davvero? Ecco un punto di vista alternativo.

Un uomo è arrivato su un filo di cui non aveva idea, e gli è stato subito chiesto di lasciarlo, e lui l'ha portato al suo hobby preferito.

ha finito per spostarsi in un ramo separato ed è venuto fuori con un problema incomprensibile che non ha nulla a che fare con i generici discussi in quel ramo o con la pratica.

Non ha nemmeno risposto ai tentativi di far notare gli errori con delle sciocchezze.

Non è laprima volta che lo fa.

Oh, povero bastardo.

Forse anche tu sei il tipo di persona che fa il massimo dell'ordinamento degli array e semplicemente non capisci cosa sta succedendo?

Sì, sono d'accordo... Era previsto, ma quello che volevo da Peter era molto diverso (se provate ad analizzare quello che gli ho offerto, il mio obiettivo sarà chiaro)

E sono d'accordo con questo. Ma il thread è stato creato per uno scopo diverso - mostrare, discutere.

Ma non per ridere. Cosa c'entra questo con l'essere offesi? È una farsa. Prima Peter ha iniziato da Vasily, io l'ho chiesto qui per una discussione tranquilla, e non solo di Peter. L'idea era diversa - non per prendere in giro le idee sbagliate, ma per raccontare, spiegare... E, cosa più interessante, cercare di trovare algoritmi interessanti. Hai capito? No?

:))) Naturalmente. Non lo so :)))

 
Renat Akhtyamov:

Sarebbe interessante vedere gli algoritmi più performanti in numeri, almeno in termini di tempo di esecuzione.

Finora sembra che si tratti solo di difendere la propria versione come la migliore.

Tuttavia, i criteri di tale autovalutazione non sono chiari.

Ecco - penso che molte persone sarebbero interessate a questo.

Ebbene, tutti sanno che Pietro, ostinatamente nel suo ego, prova la stranezza - e tutti ne sono stufi.

Personalmente, vorrei che Peter dirigesse la sua insistenza in un'altra direzione - non per iniziare un orto, ma per capire cosa gli viene offerto.

 
Artyom Trishkin:

Ecco - penso che molte persone sarebbero interessate a questo.

Ebbene, il fatto che Peter, fissando il proprio io, dimostri la stranezza - qui tutti sanno, e tutti sono stufi.

Personalmente, vorrei che Peter dirigesse la sua persistenza in un'altra direzione - non per iniziare un orto, ma per capire cosa gli viene offerto.

Il tempo di funzionamento di qualsiasi algoritmo è più facile da prevedere/calcolare conoscendo il tempo di esecuzione della funzione, per esempio ripetendola 10 000 volte.

Ma non ho incontrato il problema di non completare il codice fino alla fine, non importa quanto sia complicato.

Come si dice: bravo MQL!
 
Artyom Trishkin:

Ecco - penso che molte persone sarebbero interessate a questo.

Ebbene, il fatto che Pietro, ostinato in se stesso, dimostri la stranezza - qui tutti sanno, e tutti sono già stufi.

Personalmente, vorrei che Peter dirigesse la sua persistenza in un'altra direzione - non per iniziare un orto, ma per capire cosa gli viene offerto.

Nessuno è contrario ad aiutare e spiegare, ecc. Ma Peter in così tanti thread riduce tutto alla stessa cosa che non c'è voglia di spiegare e aiutare.
 
Alexey Oreshkin:
Nessuno è contrario ad aiutare e spiegare ecc. Ma Peter in così tanti thread sta riducendo tutto alla stessa cosa, che non c'è voglia di spiegare e aiutare.

 
Artyom Trishkin:

Finora tutto quello che vedo qui è una presa in giro dell'uomo che ha avuto l'audacia di postare qui la sua soluzione.

Ovviamente, è... Per dirla tutta, è una completa perdita di tempo. Ma l'ha fatto. Gli altri hanno finora solo il coraggio di ridere e puntare il dito.


#include <Generic\ArrayList.mqh>


//+------------------------------------------------------------------+
//|  Defines                                                                |
//+------------------------------------------------------------------+

#define  TEST_LOG true
      
#define  TEST_START(NAME) string TEST_START_STRING_INFO_##NAME = StringFormat("%s, Step:%s, Test was started....", __FUNCTION__, string(NAME));  \
                         if (TEST_LOG) Print(TEST_START_STRING_INFO_##NAME);                                                                                  \
                         ulong TEST_TIMER_##NAME = GetMicrosecondCount();                                                                 
                          
#define  TEST_END(NAME)   ulong TEST_DURATION##NAME = GetMicrosecondCount() - TEST_TIMER_##NAME;                                                                                \
                         string TEST_END_STRING_INFO_##NAME = StringFormat("%s, Step:%s, Test has been finished. Duration: %I64i.", __FUNCTION__, string(NAME), TEST_DURATION##NAME);  \
                         if (TEST_LOG) Print(TEST_END_STRING_INFO_##NAME);
                         
#define  TEST_DURATION(NAME)  TEST_DURATION##NAME


#define  TEST_ERROR_INVALID_VALUE(NAME) string TEST_ERROR_STRING_INFO_##NAME = StringFormat("%s, Step:%s, Getting value does not match the original one.", __FUNCTION__, string(NAME));    \
                                 if (TEST_LOG) Print(TEST_ERROR_STRING_INFO_##NAME);                                                                                                              \
                                 DebugBreak();                                                                                                                                      \
                                 break;                                                                                          
                                 
#define  TEST_ERROR_NULL_GENERATOR(NAME) string TEST_ERROR_STRING_INFO_##NAME = StringFormat("%s, Was not found correspond Generator class - %s. Please implement it.", __FUNCTION__, string(NAME));  \
                                 if (TEST_LOG) Print(TEST_ERROR_STRING_INFO_##NAME);




//+------------------------------------------------------------------+
//|   Generators                                                               |
//+------------------------------------------------------------------+

template<typename T>
interface IGenerator{
   T GetNext(int index);
};

class IntGenerator : public IGenerator<int>{
   int GetNext(int index){return index;}
};


// TODO bypass the problem with explicit template specialization
template<typename T>
IGenerator<T>* CreateGenerator(){
   string generatorName = typename(T);
   StringToUpper(generatorName);
   
   if (generatorName == "INT"){
      return new IntGenerator();
   }
    
   return NULL;
}

//template<>
//IGenerator<int>* CreateGenerator<int>(){
//   return NULL;
//};




//+------------------------------------------------------------------+
//|    TestCollection Interfaces                                                              |
//+------------------------------------------------------------------+

template<typename T>
interface ITestRandomAccessCollection{
   bool Add(T value);
   T GetValue(int index);
};



//+------------------------------------------------------------------+
//|    TestCollection Implementations                                                   |
//+------------------------------------------------------------------+

template<typename T>
class TestRandomAccessCollectionCArrayList : public ITestRandomAccessCollection<T>{
   CArrayList<T> collection;

public:
   TestRandomAccessCollectionCArrayList(){};
   TestRandomAccessCollectionCArrayList(int capacity):collection(capacity){};
   
   bool Add(T value){
      return collection.Add(value);
   };
   T GetValue(int index){
      int value = -1; 
      collection.TryGetValue(index,value); 
      return value;
   };
};




//+------------------------------------------------------------------+
//|    Test Functions                                                              |
//+------------------------------------------------------------------+

template<typename T>
ulong TestRandomAccessCollectionAfterAdding(ITestRandomAccessCollection<T> &testCollection, const int iterationCount = 1000, int srandValue = 0){
      //TODO add shared_ptr / move out generator (Dependency Injection)
      IGenerator<T>* generator = CreateGenerator<T>();
      if (generator == NULL){
TEST_ERROR_NULL_GENERATOR("FirstGenerator")
         return 0;
      }

      if (srandValue == 0)
         srandValue = int(TimeCurrent());
         
      T validationArray [];
      ArrayResize(validationArray,iterationCount);
      

      for(int i = 0; i < iterationCount; i++){
         T value = generator.GetNext(rand());
         testCollection.Add(value);
         validationArray[i] = value;
      }
      
TEST_START ("GetValue")
      for(int i = 0; i < iterationCount; i++){
         int index = rand() % iterationCount;
         
         T value = testCollection.GetValue(index);
         T originalValue = validationArray[index];
         if (value != originalValue){
TEST_ERROR_INVALID_VALUE("Validate")
         }
      }
TEST_END ("GetValue")
      return TEST_DURATION("GetValue");
}




int OnInit()
{
  ulong result;
  
  // TODO average result
  {
     printf ("TestRandomAccessCollectionAfterAdding: Started.", result);
     TestRandomAccessCollectionCArrayList<int> testCollection();
     result = TestRandomAccessCollectionAfterAdding(testCollection, 10000, 1);
     printf ("TestRandomAccessCollectionAfterAdding: Fineshed. Total result: %I64i\n", result);
  }
  
  
  //TestArrayListRandomAccessDuringAdding(10000);
  return INIT_FAILED;
}
1...456789101112131415161718...23
Nuovo commento