清除一个定义元素的数组 - 页 15

新评论
 
Sergey Dzyublik:

已经有关于[]运算符的讨论，认为它对于像这样的C++语言来说太慢了。我没想到它这么慢，以至于ArrayCopy 可以把它拆开。

这是另一个关于运算符内部增量的问题。

 
Stanislav Dray:

你为什么要修整自己，把我扔出去？ 不太好。

我没有把任何人扔出去。 的东西，我已经归还了 ))

 
Konstantin Nikitin:

没有把任何人扔出去。 东西，你返回))))

你下载的是第11张，我的是第12张（如下图），你把第11张修好了，并把它作为第13张返回。

 
TheXpert:

已经有关于[]运算符的讨论，认为它对于像这样的C++语言来说太慢了。我没想到它这么慢，以至于ArrayCopy可以把它拆开。

这是另一个关于运算符内部增量的问题。

甚至没有理由在这里进行不必要的操作。如果循环正在进行中。在复制时不需要检查当前项目是否出界。它将在界内。而且，增加一些东西，或者多拉一个变量，都是没有意义的。如果在默认情况下，有一个i。
总之，有各种琐碎的东西。仅供参考

 
Stanislav Dray:

你下载的是第11张，我的是第12张（如下图），你把第11张修好了，并把它作为第13张返回。

没有注意到。替换了该文件。

 

也在这个无情的竞争中写生 :-)

template <typename T>
int copyFilter1(const T &src[],T &dst[],T x)
{
        int i=0,j=0,k;
        int total=ArraySize(src);
        ArrayResize(dst,total);
        for(;;) {
                // считаем сколько копировать
                for(k=0;k<total && src[i]!=x;)
                        k++;
                // копируем
                if (k) {        
                        ArrayCopy(dst,src,j,i,k);
                        i+=k;
                        j+=k;
                        total-=k;
                }
                // пропускаем
                for(k=0;k<total && src[i]==x;) 
                        k++;
                if (k) {
                        i+=k;
                        total-=k;
                } else break;
        }
        ArrayResize(dst,j);
        return j;
}

template <typename T>
int copyFilter2(const T &src[],T &dst[],T x)
{
        int i=0,j=0,k;
        int total=ArraySize(src);
        ArrayResize(dst,total);
        for(;i<total;) {
                // копируем всё что не равно x
                for(;i<total && src[i]!=x;i++,j++)
                        dst[j]=src[i];
                // пропускаем всё что равно x
                for(;i<total && src[i]==x;)
                        i++;
        }
        ArrayResize(dst,j);
        return j;
}

同样，没有检查过:-)应该可以工作...

 
Stanislav Dray:

有推荐含有错误的测试（Semko和Pavlov）。

谢谢，修好了。

Maxim Kuznetsov:

也在这次无情的比赛中写生 :-)

同样，没有检查过:-)应该可以工作...

包括，但第一个变体有问题

2018.11.15 06:19:01.929 ArrayDeleteValue__13 (.BrentCrud,M1)    вариант Pastushak   : Контрольная сумма = 7225.756203; элементов - 998992; время выполнения - 141053 микросекунд
2018.11.15 06:19:01.934 ArrayDeleteValue__13 (.BrentCrud,M1)    вариант Korotky     : Контрольная сумма = 7225.756203; элементов - 998992; время выполнения -   2494 микросекунд
2018.11.15 06:19:01.938 ArrayDeleteValue__13 (.BrentCrud,M1)    вариант Fedoseev    : Контрольная сумма = 7225.756203; элементов - 998992; время выполнения -   1869 микросекунд
2018.11.15 06:19:01.941 ArrayDeleteValue__13 (.BrentCrud,M1)    вариант Semko       : Контрольная сумма = 7225.756203; элементов - 998992; время выполнения -    785 микросекунд
2018.11.15 06:19:01.945 ArrayDeleteValue__13 (.BrentCrud,M1)    вариант Nikitin     : Контрольная сумма = 7225.756203; элементов - 998992; время выполнения -   2039 микросекунд
2018.11.15 06:19:01.952 ArrayDeleteValue__13 (.BrentCrud,M1)    вариант Vladimir    : Контрольная сумма = 7225.756203; элементов - 998992; время выполнения -   4385 микросекунд
2018.11.15 06:19:01.961 ArrayDeleteValue__13 (.BrentCrud,M1)    вариант Peter       : Контрольная сумма = 7225.756203; элементов - 998992; время выполнения -   7476 микросекунд
2018.11.15 06:19:01.965 ArrayDeleteValue__13 (.BrentCrud,M1)    вариант fann95      : Контрольная сумма = 7225.756203; элементов - 998992; время выполнения -   1255 микросекунд
2018.11.15 06:19:01.969 ArrayDeleteValue__13 (.BrentCrud,M1)    вариант Kuznetsov1  : Контрольная сумма = 7219.502578; элементов - 1000000; время выполнения -   2016 микросекунд
2018.11.15 06:19:01.975 ArrayDeleteValue__13 (.BrentCrud,M1)    вариант Kuznetsov2  : Контрольная сумма = 7225.756203; элементов - 998992; время выполнения -   3965 микросекунд
2018.11.15 06:19:01.975 ArrayDeleteValue__13 (.BrentCrud,M1)    
2018.11.15 06:19:01.975 ArrayDeleteValue__13 (.BrentCrud,M1)    === Порядок в массиве не сохраняется ===
2018.11.15 06:19:01.978 ArrayDeleteValue__13 (.BrentCrud,M1)    вариант Kuznetsov3  : Контрольная сумма = 7222.657252; элементов - 998992; время выполнения -    694 микросекунд
附加的文件：
ArrayDeleteValue.mq5  19 kb
 

我又回到了我被 误解的执行时间上的差异，两个循环的逻辑和检查数量几乎100%相同。

因此，再次强调，为什么要从库兹涅佐夫的代码中找出这样一个变体。

    for(;;)
     {
      while(arr[i]!=x && i<j) i++;
      while(arr[j]==x && i<j) j--;
      if(i<j)
        {
         arr[i++]=arr[j--];
        }
      else break;
     }

工作速度是做完全相同事情的两倍以上。

   while(i<j)
     {
      if(arr[i]==x)
         if(arr[j]!=x) arr[i++]=arr[j--];
      else j--;
      else i++;
     }

编译器的奇妙之处在于什么？
这样的设计真的可能吗。

while(arr[i]!=x && i<j) i++;

编译器为处理器找到一些特殊的汇编器的搜索命令？但里面有一个额外的检查i<j，不是吗？

因为同样的事情通过为执行起来要慢得多。

for (;;) if (arr[i]!=x && i<j) i++; else break;

我附上示范脚本的代码

2018.11.15 13:30:51.354 TestLoop (EURUSD,D1)    вариант while:    Контрольная сумма = 7697.499145747599; элементов - 998975; время выполнения = 771 микросекунд
2018.11.15 13:30:51.357 TestLoop (EURUSD,D1)    вариант for:      Контрольная сумма = 7697.499145747599; элементов - 998975; время выполнения = 1051 микросекунд
2018.11.15 13:30:51.360 TestLoop (EURUSD,D1)    вариант slow:     Контрольная сумма = 7697.499145747599; элементов - 998975; время выполнения = 1531 микросекунд

这就是经常发生的情况。你正忙于处理一些不必要的垃圾，发现了一些相当有趣的事情。

开发人员，你能不能看一下可执行代码，看看是什么造成了这种差异？

你需要了解编译器的逻辑，以便在未来创建更多的最优算法。

附加的文件：
TestLoop.mq5  10 kb
 
尼古拉-森科

有趣的观察。为了感兴趣，运行了代码

void OnStart()
{
     int array[], arr[];
     ArrayResize(arr,1000000);
     for(int i=0; i<1000000;i++)
          arr[i] = rand()%1000;

     int i=0;
     ulong t=GetMicrosecondCount();
     for(; i<1000000; i++)
          int j = arr[i];
     t = GetMicrosecondCount()-t;
     Print("FOR: ", t);
     
     t=GetMicrosecondCount();
     i=0;
     for(;;)
     {
          if( i>=1000000 )
               break;
          int j = arr[i];
          i++;
     }
     t = GetMicrosecondCount()-t;
     Print("FOR-1: ", t);
     
     t=GetMicrosecondCount();
     i=0;
     while(i<1000000)
     {
          int j = arr[i];
          i++;
     }
     t = GetMicrosecondCount()-t;
     Print("WHILE: ", t);
     
     t=GetMicrosecondCount();
     i=0;
     while(true)
     {
          if( i>=1000000 )
               break;
          int j = arr[i];
          i++;
     }
     t = GetMicrosecondCount()-t;
     Print("WHILE-1: ", t);
}


 
Nikolai Semko:

我又回到了我被 误解的执行时间上的差异，两个循环的逻辑和检查数量几乎100%相同。

因此，再次强调，为什么要从库兹涅佐夫的代码中找出这样一个变体。

工作速度是做同样事情的两倍以上。

编译器的奇妙之处在于什么？
像这样的结构，真的有可能吗。

编译器为处理器找到一些特殊的汇编器的搜索命令？但里面有一个额外的检查i<j，不是吗？

因为同样的事情通过为执行起来要慢得多。

我附上演示脚本的代码

这就是经常发生的情况。你正忙于处理一些不必要的垃圾，发现了一些相当有趣的事情。

开发人员，你能不能看一下可执行代码，看看是什么造成了这种差异？

你需要了解编译器的逻辑，以便在未来创建更多的最优算法。

我认为这对旗帜来说是一个很好的匹配。
http://osinavi.ru/asm/4.php

而对于对于不必要的运营商/比较...

1...8910111213141516171819202122...30
新评论