数组需求突变,求高手快速处理以下数组问题

zzmmgjj

Interesting - it is the fastest way too. And if you pre allocate the array, it can even be a little bit faster.

1. 
   
2. #!/usr/bin/perl
   
3. use strict;
   
4. use warnings;
   
5. use 5.010;
   
6. 
   
7. use Benchmark;
   
8. 
   
9. our @x = ();
   
10. 
    
11. for (1..1000000) {
    
12.     push @x, int($_ * rand);
    
13. }
    
14. 
    
15. sub my_copy {
    
16.     my @y = @x;
    
17. }
    
18. 
    
19. sub my_return {
    
20.     \@x;
    
21. }
    
22. 
    
23. sub extract1 {
    
24.     my @y = @x;
    
25.     $#y   = 1000000;
    
26.     @y = @y[@y*0.25 .. @y*0.75];
    
27.     return \@y;
    
28. }
    
29. 
    
30. sub extract2 {
    
31.     my @y = @x;
    
32.     $#y  -= 250000;
    
33.     @y    = reverse @y;
    
34.     $#y  -= 250000;
    
35.     @y    = reverse @y;
    
36.     return \@y;
    
37. }
    
38. 
    
39. sub extract3 {
    
40.     my @y = @x;
    
41.     my $count = scalar @y;
    
42.     my $start = int(0.25 * $count);
    
43.     my $end   = int(0.75 * $count);
    
44.     my $len   = $end - $start;
    
45.     @y        = splice(@y, $start, $len);
    
46.     return \@y;
    
47. }
    
48. 
    
49. sub extract4 {
    
50.     my @y = @x;
    
51.     $#y   = 500000;
    
52.     my $count = scalar @y;
    
53.     my $start = int(0.25 * $count);
    
54.     my $end   = int(0.75 * $count);
    
55.     my $len   = $end - $start;
    
56.     @y        = splice(@y, $start, $len);
    
57.     return \@y;
    
58. }
    
59. 
    
60. my $code = {
    
61.     my_copy     => q| my_copy()   |,
    
62.     extract1    => q| extract1()  |,
    
63.     extract2    => q| extract2()  |,
    
64.     extract3    => q| extract3()  |,
    
65.     extract4    => q| extract4()  |,
    
66. };
    
67. 
    
68. timethese( 100, $code );
    
69. 
    
70. 
    
71. #--- Result
    
72. Benchmark: timing 100 iterations of extract1, extract2, extract3, extract4, my_copy...
    
73.   extract1: 20 wallclock secs (17.63 usr +  0.87 sys = 18.50 CPU) @  5.41/s (n=100)
    
74.   extract2: 26 wallclock secs (25.50 usr +  0.42 sys = 25.92 CPU) @  3.86/s (n=100)
    
75.   extract3: 14 wallclock secs (13.74 usr +  0.32 sys = 14.06 CPU) @  7.11/s (n=100)
    
76.   extract4: 12 wallclock secs (10.43 usr +  0.34 sys = 10.77 CPU) @  9.29/s (n=100)
    
77.    my_copy:  7 wallclock secs ( 6.75 usr +  0.07 sys =  6.82 CPU) @ 14.66/s (n=100)
    
78. 
    

复制代码

Perlvim

$#y   = 500000; is pre allocate the array size.
学习了。

zhlong8

才10W条就求什么最优，明显过早优化了。这么简单的需求不行就上C几亿条也没问题

zzmmgjj

just for fun and edification ...

Perlvim

C语言的快速，是长期以来，C语言编译器不断优化的结果。
就算法来说，不同的语言，是相通的。
Go language 的执行效率在X86上，已经和C不相上下。
同样的C代码，在不同的处理器架构上编译的代码，执行效率也不同。

我们比较，是比自己的东西，不是别人给的东西。