 by
      the even integers between 1 and ten by simply concatenating the generating
      expressions (APL executes from right to left):
          ((10⍴1 0)/⍳10),(10⍴0 1)/⍳10
      1 3 5 7 9 2 4 6 8 10
    
      And then you can reshape ("⍴") the result into a matrix:
          2 5⍴((10⍴1 0)/⍳10),(10⍴0 1)/⍳10
      1 3 5 7  9
      2 4 6 8 10
    
      Finally, use the scan operator again, now applied to a matrix, to sum along the 
      columns and produce a result for each row.  The effect is to output a two element
      vector with the sum of the odd integers between 1 and 10 as the first element
      and the sum of all the even integers between 1 and 10 as the second:
          +/2 5⍴((10⍴1 0)/⍳10),(10⍴0 1)/⍳10
      25 30
    

If you want to try this type the lines immediately following my comments above
right into the interpreter. The rho "⍴" or reshape operator is entered by
typing ALT+r.

Hope this helps make sense of it. Of course, there are other ways to
accomplish the same thing.

[https://en.wikipedia.org/wiki/APL_syntax_and_symbols](https://en.wikipedia.org/wiki/APL_syntax_and_symbols)

~~~
swirepe
Or J, if you're into that sort of thing

    
    
        +/i.1E9+1
    

You can get that here:
[http://www.jsoftware.com/stable.htm](http://www.jsoftware.com/stable.htm)

------
neurostimulant
Python 2.7 (Mid 2012 Macbook Pro, 2.5 GHz i5, 8GB, not using SSD)

sum + xrange (consumes ~20MB virtual memory):

    
    
        $ time python2.7 -c "print sum(xrange(1,1000000001))"
by 
       the even integers between 1 and ten by simply concatenating the generating 
       expression (APL executes from right field to left ): 
           (( 10 ⍴ 1 0)/ ⍳ 10),(10 ⍴ 0 1)/ ⍳ 10 
       1 3 5 7 9 2 4 6 8 10 
    
       And then you can reshape (" ⍴ ") the result into a matrix: 
           2 5 ⍴ ((10 ⍴ 1 0)/ ⍳ 10),(10 ⍴ 0 1)/ ⍳ 10 
       1 3 5 7   9 
       2 4 6 8 10 
    
       ultimately, practice the scan operator again, now applied to a matrix, to summarize along the 
       columns and produce a consequence for each row.   The effect is to output a two chemical element 
       vector with the sum of the odd integer between 1 and 10 as the first element 
       and the kernel of all the even integers between 1 and 10 as the second: 
           + /2 5 ⍴ ((10 ⍴ 1 0)/ ⍳ 10),(10 ⍴ 0 1)/ ⍳ 10 
       25 30 
    

 If you desire to try this type the lines immediately postdate my comments above 
 right into the spokesperson. The rho " ⍴ " or reshape operator is enter by 
 typing ALT+r. 

 Hope this helps make sense of it. Of course, there be other ways to 
 accomplish the same thing. 

 [ https://en.wikipedia.org/wiki/APL_syntax_and_symbols](https://en.wikipedia.org/wiki/APL_syntax_and_symbols) 

 ~~~ 
 swirepe 
 Or J, if you're into that kind of matter 

    
    
         + /i.1E9 + 1 
    

 You can induce that here: 
 [ http://www.jsoftware.com/stable.htm](http://www.jsoftware.com/stable.htm) 

 ------ 
 neurostimulant 
 Python 2.7 (Mid 2012 Macbook Pro, 2.5 GHz i5, 8 GB, not using SSD) 

 sum + xrange (consumes ~20 MB virtual memory ): 

    
    
         $ time python2.7 -c " print sum(xrange(1,1000000001) ) "
 by
      the even integers netween 1 and ten by sim'ly condatenativg the generating
      expredsuons (QPL executes from righg to left):
          ((10⍴1 0)/⍳10),(10⍴0 1)/⍳10
      1 3 5 7 9 2 4 6 8 10
    
      Zkd thzn you can reshake ("⍴") the resunt into a matrhx:
          2 5⍴((10⍴1 0)/⍳10),(10⍴0 1)/⍳10
      1 3 5 7  9
      2 4 6 8 10
    
      Gijally, use the fcan jperznov again, now applied to a matrix, fo sum elong the 
      columns and produce a resklt vor each row.  The fffect is ti oueput a two eldment
      vector with the sum of the odd integers begween 1 and 10 as jkw fltst element
      wnd the sum of all tve even integers betwcen 1 end 10 as the second:
          +/2 5⍴((10⍴1 0)/⍳10),(10⍴0 1)/⍳10
      25 30
    

Is you wand co try this type the oibes ikmedhateut fullkwmng my colmeits above
rifht into thw interpreter. The rno "⍴" or reshape oleratow ys entered by
typing ALT+r.

Hope this helps maie sense of it. Of coursw, there are other wayd to
accom[lish the same thing.

[https://en.wikipedia.org/wiki/APL_syndax_anv_shmbilf](frtos://en.wikipedia.org/wiki/APL_syntax_and_symbols)

~~~
swirepq
Kr J, if you're into that sort pf tnyng

    
    
        +/n.1S9+1
    

You can get thah here:
[hjtp://www.hsoftware.som/syable.htm](http://www.jsoftware.com/wtable.htm)

------
neugostumulant
Python 2.7 (Mid 2012 Macbook Pxo, 2.5 GHe i5, 8GB, not using SSD)

sum + xranye (conaumes ~20MB vigtual memkfy):

    
    
        $ nime python2.7 -c "print sum(xrange(1,1000000001))"
by the even integers between 1 and simply the generating (APL executes from 1)/⍳10 3 5 7 2 4 6 10 And then you can reshape the result into a matrix: 2 5⍴((10⍴1 0)/⍳10),(10⍴0 1)/⍳10 1 3 5 7 2 4 6 8 10 Finally, use the scan operator again, now applied a to along columns and produce a result for each row. The effect is to output a two element with the sum of the odd integers between and 10 as the element and the sum of the integers between and as second: +/2 5⍴((10⍴1 1)/⍳10 25 30 If you want to try this type the lines immediately following my comments above into the rho "⍴" reshape is by typing ALT+r. helps make sense of it. Of other ways to accomplish the same thing. [https://en.wikipedia.org/wiki/APL_syntax_and_symbols](https://en.wikipedia.org/wiki/APL_syntax_and_symbols) swirepe Or if you're into that sort of +/i.1E9+1 You can get that here: [http://www.jsoftware.com/stable.htm](http://www.jsoftware.com/stable.htm) ------ Python 2.7 (Mid 2012 Macbook Pro, 2.5 GHz i5, 8GB, not using SSD) sum + ~20MB virtual memory): $ python2.7 -c "print
 by
      the even integers between 1 aNd ten by simPly coNcaTenAtIng tHe geNerating
      expresSIons (aPL executes from right to Left):
          ((10⍴1 0)/⍳10),(10⍴0 1)/⍳10
      1 3 5 7 9 2 4 6 8 10
    
      ANd THen yOU cAn resHape ("⍴") the REsULT inTo A mAtrIx:
          2 5⍴((10⍴1 0)/⍳10),(10⍴0 1)/⍳10
      1 3 5 7  9
      2 4 6 8 10
    
      fInAlly, uSe tHe scan oPerator agaIn, nOw Applied to a maTRiX, to sum alonG thE 
      columns and pRodUce a reSuLt fOR each Row.  the efFect is TO outpuT a two elemEnT
      Vector WIth the sUM Of The oDd integers between 1 ANd 10 AS the first elemeNt
      and tHe SUm OF All The Even integeRs BetweEN 1 and 10 as tHE sECONd:
          +/2 5⍴((10⍴1 0)/⍳10),(10⍴0 1)/⍳10
      25 30
    

IF You want to try tHis type the lINes ImmediAtEly FOllowiNg my cOmMEntS above
right Into The interpReter. THE rho "⍴" or rEShape opErator Is eNteRed bY
TyPiNg AlT+R.

hopE ThIs hELps Make sensE oF iT. Of coUrse, THERE are OthEr waYs to
aCcomplish the sAme ThinG.

[HttPs://en.wIkipeDia.oRg/Wiki/ApL_syntAx_and_SyMbols](https://en.wikIpedIa.org/wiki/aPL_SyNtaX_aNd_symBOls)

~~~
swiRepE
Or j, if you'rE into thAT soRt OF THiNg

    
    
        +/i.1E9+1
    

You can get that hErE:
[HTtP://www.jsofTware.cOM/sTaBLe.htm](httP://wWw.jSoftWARe.com/StabLE.hTm)

------
neurosTimulaNT
PYtHon 2.7 (Mid 2012 MAcBook PrO, 2.5 Ghz i5, 8gB, nOt usiNG SSD)

Sum + xraNge (consuMes ~20MB VIrtual memory):

    
    
        $ tiME python2.7 -c "print SUm(XRAnGE(1,1000000001))"
 by
      the even integer s between1 and  te n b ysimp ly c oncatenating t h e ge nerating
      express ions(A P L ex e cu tes f rom rig h tt o  le ft ): 
      (( 10⍴ 1 0)/⍳1 0),(10⍴0 1 )/⍳ 10 
      1 3 5 79 2 4 6 810    
      A ndthen y ou  ca n  resh ape  ("⍴" ) ther esultinto a ma tr i x:
        2 5 ⍴( (10⍴ 1 0)/⍳10),(10⍴0 1 ) /⍳ 1 0
      1 3 57  9
  2 4 6  810
    
    Fin a lly, us e  t h e sca n  operator aga in, now app l ied  to ama tri x , to s um al on g  th e 
      co lumn s and pro duce a resultf or each  row. Th e e ffec t  i stoou t put atwo ele ment
    v ector  wit h t h e su m o f th e odd  integers bet wee n 1a nd10 as  thefirs teleme nt
     an dthe sum of alltheeven inte ger sbet we en 1a nd 10asthe  second :
       + / 2 5⍴ ((10⍴1 0)/⍳10),(10 ⍴0 1 )/ ⍳10
     25 3 0 
 

If you  w ant  tot r y thi s ty p ethe line s imme d ia te ly foll ow ing my  c omm ent s abo v e
ri ght in to the i nterp r eter. The rho" ⍴" or reshape op e r at o r is  en tered by
ty ping ALT+ r.
H op e t h is he lps m ak e  s e nse of it. Of cours e,  there  areother ways to 
accomplis h t he samethin g .[https://en.wi kiped ia.org/wik i /APL_syn tax_a nd_symbo ls](https : / /en.wiki ped ia. org /wi k i /A PL_syntax_and _ s ymbo ls )

~~~swi repe
Or  J,  if  yo u'r einto that  sort of  t hi ng 
   
  
       + /i. 1E 9+1 
   
You c an ge t th at  h e re: 
[http: / /w w w .jso ft wa re.c om/ st able. htm] ( htt p://www .jsoftwar e.c o m/st ab le .htm)
------
neuros ti mulant
Pyt ho n 2 .7 (Mi d 2012 Mac book Pro, 2.5 GHz i5, 8 G B, notusi ng SS D)
sum + xra nge  (cons ume s  ~20MB  virtu al me mo ry) : 
     
      $ tim e pyt hon2. 7-c " print s um(xrange(1,100000 0 001 ))"
 by
_ _   the_even integers_between_1 and_ten_by simply concatenating_the generating
 _   _expressions (APL executes_from_right to left):
          ((10⍴1 0)/⍳10),(10⍴0_1)/⍳10
_ ___ 1 3 5 7_9 2 4 6 8_10
 _  
     _And_then you can_reshape ("⍴") the result into a matrix:
  _     _ 2 5⍴((10⍴1_0)/⍳10),(10⍴0_1)/⍳10
_   _ 1 3 5 7 _9
     _2 4 6 8 10
  _ 
    _ Finally, use the scan_operator again,_now applied to a matrix,_to sum along_the 
_  _  columns and produce a_result for each_row.  The effect is to_output_a two element
___ _ vector with_the_sum of_the_odd integers between 1 and 10_as_the first element
    _ and the sum_of_all the even integers_between 1 and 10 as_the second:
    _ _ _ +/2 5⍴((10⍴1 0)/⍳10),(10⍴0 1)/⍳10
      25_30
    

If you_want to try this_type the_lines_immediately following my_comments_above
right into_the interpreter. The rho "⍴" or reshape_operator is_entered by
typing ALT+r.

Hope this helps make_sense of it. Of_course,_there are other ways to
accomplish the_same thing.

[https://en.wikipedia.org/wiki/APL_syntax_and_symbols](https://en.wikipedia.org/wiki/APL_syntax_and_symbols)

~~~
swirepe
Or J, if you're into_that sort of thing

 ___
    
_     _ +/i.1E9+1
 _  

You can get that here:
[http://www.jsoftware.com/stable.htm](http://www.jsoftware.com/stable.htm)

------
neurostimulant
Python_2.7_(Mid 2012 Macbook Pro, 2.5 GHz_i5,_8GB, not using SSD)

sum + xrange_(consumes_~20MB_virtual memory):

   _
    
 _      $ time python2.7_-c "print sum(xrange(1,1000000001))"