A-M baby

Task/Filter/0DESCRIPTION

@@ -0,0 +1,3 @@
+Select certain elements from an Array into a new Array in a generic way. To demonstrate, select all even numbers from an Array.
+
+As an option, give a second solution which filters destructively, by modifying the original Array rather than creating a new Array.

Task/Filter/1META.yaml

@@ -0,0 +1,4 @@
+---
+category:
+- Iteration
+note: Basic language learning

Task/Filter/ACL2/filter.acl2

@@ -0,0 +1,5 @@
+(defun filter-evens (xs)
+   (cond ((endp xs) nil)
+         ((evenp (first xs))
+          (cons (first xs) (filter-evens (rest xs))))
+         (t (filter-evens (rest xs)))))

Task/Filter/ALGOL-68/filter.alg

@@ -0,0 +1,23 @@
+MODE TYPE = INT;
+
+PROC select = ([]TYPE from, PROC(TYPE)BOOL where)[]TYPE:
+BEGIN
+  FLEX[0]TYPE result;
+  FOR key FROM LWB from TO UPB from DO
+    IF where(from[key]) THEN
+      [UPB result+1]TYPE new result;
+      new result[:UPB result] := result;
+      new result[UPB new result] := from[key];
+      result := new result
+    FI
+  OD;
+  result
+END;
+
+[]TYPE from values = (1,2,3,4,5,6,7,8,9,10);
+PROC where even = (TYPE value)BOOL: NOT ODD value;
+
+print((select(from values, where even), new line));
+
+# Or as a simple one line query #
+print((select((1,4,9,16,25,36,49,64,81,100), (TYPE x)BOOL: NOT ODD x ), new line))

Task/Filter/AWK/filter.awk

@@ -0,0 +1,2 @@
+$ awk 'BEGIN{split("1 2 3 4 5 6 7 8 9",a);for(i in a)if(!(a[i]%2))r=r" "a[i];print r}'
+4 6 8 2

Task/Filter/ActionScript/filter.as

@@ -0,0 +1,6 @@
+var arr:Array = new Array(1, 2, 3, 4, 5);
+var evens:Array = new Array();
+for (var i:int = 0; i < arr.length(); i++) {
+    if (arr[i] % 2 == 0)
+        evens.push(arr[i]);
+}

Task/Filter/Ada/filter-1.ada

@@ -0,0 +1,32 @@
+with Ada.Integer_Text_Io; use Ada.Integer_Text_Io;
+with Ada.Text_Io; use Ada.Text_Io;
+
+procedure Array_Selection is
+   type Array_Type is array (Positive range <>) of Integer;
+   Null_Array : Array_Type(1..0);
+
+   function Evens (Item : Array_Type) return Array_Type is
+   begin
+      if Item'Length > 0 then
+         if Item(Item'First) mod 2 = 0 then
+            return Item(Item'First) & Evens(Item((Item'First + 1)..Item'Last));
+         else
+            return Evens(Item((Item'First + 1)..Item'Last));
+         end if;
+      else
+         return Null_Array;
+      end if;
+   end Evens;
+
+   procedure Print(Item : Array_Type) is
+   begin
+      for I in Item'range loop
+         Put(Item(I));
+         New_Line;
+      end loop;
+   end Print;
+
+   Foo : Array_Type := (1,2,3,4,5,6,7,8,9,10);
+begin
+   Print(Evens(Foo));
+end Array_Selection;

Task/Filter/Ada/filter-2.ada

@@ -0,0 +1,28 @@
+with Ada.Text_IO;  use Ada.Text_IO;
+
+procedure Array_Selection is
+   type Array_Type is array (Positive range <>) of Integer;
+
+   function Evens (Item : Array_Type) return Array_Type is
+      Result : Array_Type (1..Item'Length);
+      Index  : Positive := 1;
+   begin
+      for I in Item'Range loop
+         if Item (I) mod 2 = 0 then
+            Result (Index) := Item (I);
+            Index := Index + 1;
+         end if;
+      end loop;
+      return Result (1..Index - 1);
+   end Evens;
+
+   procedure Put (Item : Array_Type) is
+   begin
+      for I in Item'range loop
+         Put (Integer'Image (Item (I)));
+      end loop;
+   end Put;
+begin
+   Put (Evens ((1,2,3,4,5,6,7,8,9,10)));
+   New_Line;
+end Array_Selection;

Task/Filter/AmigaE/filter.amiga

@@ -0,0 +1,7 @@
+PROC main()
+  DEF l : PTR TO LONG, r : PTR TO LONG, x
+  l := [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  r := List(ListLen(l))
+  SelectList({x}, l, r, `Mod(x,2)=0)
+  ForAll({x}, r, `WriteF('\d\n', x))
+ENDPROC

Task/Filter/AppleScript/filter-1.applescript

@@ -0,0 +1,6 @@
+set array to {1, 2, 3, 4, 5, 6}
+set evens to {}
+repeat with i in array
+	if (i mod 2 = 0) then set end of evens to i's contents
+end repeat
+return evens

Task/Filter/AppleScript/filter-2.applescript

@@ -0,0 +1,17 @@
+to filter(inList, acceptor)
+  set outList to {}
+  repeat with anItem in inList
+    if acceptor's accept(anItem) then
+      set end of outList to contents of anItem
+    end
+  end
+  return outList
+end
+
+script isEven
+  to accept(aNumber)
+    aNumber mod 2 = 0
+  end accept
+end script
+
+filter({1,2,3,4,5,6}, isEven)

Task/Filter/AutoHotkey/filter.ahk

@@ -0,0 +1,49 @@
+array = 1,2,3,4,5,6,7
+loop, parse, array, `,
+{
+    if IsEven(A_LoopField)
+        evens = %evens%,%A_LoopField%
+}
+stringtrimleft, evens, evens, 1
+msgbox % evens
+return
+
+IsEven(number)
+{
+    return !mod(number, 2)
+}
+
+
+; ----- Another version: always with csv string ------
+array = 1,2,3,4,5,6,7
+
+even(s) {
+	loop, parse, s, `,
+		if !mod(A_LoopField, 2)
+			r .= "," A_LoopField
+	return SubStr(r, 2)
+}
+
+MsgBox % "Array => " array "`n" "Result => " even(array)
+
+
+; ----- Yet another version: with array (requires AutoHotKey_L) ------
+array2 := [1,2,3,4,5,6,7]
+
+even2(a) {
+	r := []
+	For k, v in a
+		if !mod(v, 2)
+			r.Insert(v)
+	return r
+}
+
+; Add "join" method to string object (just like python)
+s_join(o, a) {
+	Loop, % a.MaxIndex()
+		r .= o a[A_Index]
+	return SubStr(r, StrLen(o) + 1)
+}
+"".base.join := Func("s_join")
+
+MsgBox % "Array => " ",".join(array2) "`n"  "Result => " ",".join(even2(array2))

Task/Filter/BBC-BASIC/filter.bbc

@@ -0,0 +1,34 @@
+      REM Create the test array:
+      items% = 1000
+      DIM array%(items%)
+      FOR index% = 1 TO items%
+        array%(index%) = RND
+      NEXT
+
+      REM Count the number of filtered items:
+      filtered% = 0
+      FOR index% = 1 TO items%
+        IF FNfilter(array%(index%)) filtered% += 1
+      NEXT
+
+      REM Create a new array containing the filtered items:
+      DIM new%(filtered%)
+      filtered% = 0
+      FOR index% = 1 TO items%
+        IF FNfilter(array%(index%)) THEN
+          filtered% += 1
+          new%(filtered%) = array%(index%)
+        ENDIF
+      NEXT
+
+      REM Alternatively modify the original array:
+      filtered% = 0
+      FOR index% = 1 TO items%
+        IF FNfilter(array%(index%)) THEN
+          filtered% += 1
+          array%(filtered%) = array%(index%)
+        ENDIF
+      NEXT
+      END
+
+      DEF FNfilter(A%) = ((A% AND 1) = 0)

Task/Filter/Bracmat/filter.bracmat

@@ -0,0 +1,5 @@
+( :?odds
+& ( 1 2 3 4 5 6 7 8 9 10 16 25 36 49 64 81 100:? (=.!sjt*1/2:/&!odds !sjt:?odds)$() ()
+  | !odds
+  )
+)

Task/Filter/Brat/filter.brat

@@ -0,0 +1,2 @@
+#Prints [2, 4, 6, 8, 10]
+p 1.to(10).select { x | x % 2 == 0 }

Task/Filter/Burlesque/filter.blq

@@ -0,0 +1,2 @@
+blsq ) 1 13r@{2.%n!}f[
+{2 4 6 8 10 12}

Task/Filter/C++/filter-1.cpp

@@ -0,0 +1,18 @@
+#include <vector>
+#include <algorithm>
+#include <functional>
+#include <iterator>
+#include <iostream>
+
+int main() {
+  std::vector<int> ary;
+  for (int i = 0; i < 10; i++)
+    ary.push_back(i);
+  std::vector<int> evens;
+  std::remove_copy_if(ary.begin(), ary.end(), back_inserter(evens),
+                      std::bind2nd(std::modulus<int>(), 2)); // filter copy
+  std::copy(evens.begin(), evens.end(),
+            std::ostream_iterator<int>(std::cout, "\n"));
+
+  return 0;
+}

Task/Filter/C++/filter-2.cpp

@@ -0,0 +1,17 @@
+#include <vector>
+#include <algorithm>
+#include <iterator>
+#include <iostream>
+
+using namespace std;
+
+int main() {
+  vector<int> ary = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+  vector<int> evens;
+
+  copy_if(ary.begin(), ary.end(), back_inserter(evens),
+      [](int i) { return i % 2 == 0; });
+
+  // print result
+  copy(evens.begin(), evens.end(), ostream_iterator<int>(cout, "\n"));
+}

Task/Filter/C/filter.c

@@ -0,0 +1,43 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int even_sel(int x) { return !(x & 1); }
+int tri_sel(int x) { return x % 3; }
+
+/* using a predicate function sel() to select elements */
+int* grep(int *in, int len, int *outlen, int (*sel)(int), int inplace)
+{
+	int i, j, *out;
+
+	if (inplace)	out = in;
+	else		out = malloc(sizeof(int) * len);
+
+	for (i = j = 0; i < len; i++)
+		if (sel(in[i]))
+			out[j++] = in[i];
+
+	if (!inplace && j < len)
+		out = realloc(out, sizeof(int) * j);
+
+	*outlen = j;
+	return out;
+}
+
+int main()
+{
+	int in[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+	int i, len;
+
+	int *even = grep(in, 10, &len, even_sel, 0);
+	printf("Filtered even:");
+	for (i = 0; i < len; i++) printf(" %d", even[i]);
+	printf("\n");
+
+	grep(in, 8, &len, tri_sel, 1);
+	printf("In-place filtered not multiple of 3:");
+	for (i = 0; i < len; i++) printf(" %d", in[i]);
+
+	printf("\n");
+
+	return 0;
+}

Task/Filter/Clean/filter-1.clean

@@ -0,0 +1,3 @@
+module SelectFromArray
+
+import StdEnv

Task/Filter/Clean/filter-2.clean

@@ -0,0 +1,2 @@
+array :: {Int}
+array = {x \\ x <- [1 .. 10]}

Task/Filter/Clean/filter-3.clean

@@ -0,0 +1,2 @@
+Start :: {!Int}
+Start = {x \\ x <-: array | isEven x}

Task/Filter/Clojure/filter.clj

@@ -0,0 +1,4 @@
+;; range and filter create lazy seq's
+(filter even? (range 0 100))
+;; vec will convert any type of seq to an array
+(vec (filter even? (vec (range 0 100))))

Task/Filter/Common-Lisp/filter-1.lisp

@@ -0,0 +1,2 @@
+(remove-if-not #'evenp '(1 2 3 4 5 6 7 8 9 10))
+> (2 4 6 8 10)

Task/Filter/Common-Lisp/filter-2.lisp

@@ -0,0 +1,2 @@
+(delete-if-not #'evenp '(1 2 3 4 5 6 7 8 9 10))
+> (2 4 6 8 10)

Task/Filter/D/filter-1.d

@@ -0,0 +1,9 @@
+import std.algorithm;
+
+void main() {
+    immutable data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+
+    auto evens = data.filter!(x => x % 2 == 0)(); // lazy
+
+    assert(evens.equal([2, 4, 6, 8, 10]));
+}

Task/Filter/D/filter-2.d

@@ -0,0 +1,10 @@
+import tango.core.Array, tango.io.Stdout;
+
+void main() {
+    auto array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+
+    // removeIf places even elements at the beginnig of the array and returns number of found evens
+    auto evens = array.removeIf( ( typeof(array[0]) i ) { return (i % 2) == 1; } );
+    Stdout("Evens - ")( array[0 .. evens] ).newline; // The order of even elements is preserved
+    Stdout("Odds - ")( array[evens .. $].sort ).newline; // Unlike odd elements
+}

Task/Filter/Delphi/filter.delphi

@@ -0,0 +1,25 @@
+program FilterEven;
+
+{$APPTYPE CONSOLE}
+
+uses SysUtils, Types;
+
+const
+  SOURCE_ARRAY: array[0..9] of Integer = (0,1,2,3,4,5,6,7,8,9);
+var
+  i: Integer;
+  lEvenArray: TIntegerDynArray;
+begin
+  for i in SOURCE_ARRAY do
+  begin
+    if not Odd(i) then
+    begin
+      SetLength(lEvenArray, Length(lEvenArray) + 1);
+      lEvenArray[Length(lEvenArray) - 1] := i;
+    end;
+  end;
+
+  for i in lEvenArray do
+    Write(i:3);
+  Writeln;
+end.

Task/Filter/E/filter-1.e

@@ -0,0 +1,2 @@
+pragma.enable("accumulator")
+accum [] for x ? (x %% 2 <=> 0) in [1,2,3,4,5,6,7,8,9,10] { _.with(x) }

Task/Filter/E/filter-2.e

@@ -0,0 +1,5 @@
+var result := []
+for x ? (x %% 2 <=> 0) in [1,2,3,4,5,6,7,8,9,10] {
+    result with= x
+}
+result

Task/Filter/E/filter-3.e

@@ -0,0 +1,2 @@
+def makeSeries := <elang:control.makeSeries>
+makeSeries([1,2,3,4,5,6,7,8,9,10]).filter(fn x,_{x %% 2 <=> 0}).asList()

Task/Filter/Ela/filter-1.ela

@@ -0,0 +1,3 @@
+open list
+
+evenList = filter' (\x -> x % 2 == 0) [1..]

Task/Filter/Ela/filter-2.ela

@@ -0,0 +1 @@
+evenList = [& x \\ x <- [1..] | x % 2 == 0]

Task/Filter/Erlang/filter-1.erl

@@ -0,0 +1,2 @@
+Numbers = lists:seq(1, 5).
+EvenNumbers = lists:filter(fun (X) -> X rem 2 == 0 end, Numbers).

Task/Filter/Erlang/filter-2.erl

@@ -0,0 +1 @@
+EvenNumbers = [X || X <- Numbers, X rem 2 == 0].

Task/Filter/Euphoria/filter.euphoria

@@ -0,0 +1,9 @@
+sequence s, evens
+s = {1, 2, 3, 4, 5, 6}
+evens = {}
+for i = 1 to length(s) do
+    if remainder(s[i], 2) = 0 then
+        evens = append(evens, s[i])
+    end if
+end for
+? evens

Task/Filter/Factor/filter-1.factor

@@ -0,0 +1,2 @@
+10 iota >array [ even? ] filter .
+! prints { 0 2 4 6 8 }

Task/Filter/Factor/filter-2.factor

@@ -0,0 +1,2 @@
+10 iota [ even? ] filter .
+! prints V{ 0 2 4 5 8 }

Task/Filter/Factor/filter-3.factor

@@ -0,0 +1,3 @@
+USE: vectors
+10 iota >vector [ even? ] filter! .
+! prints V{ 0 2 4 5 8 }

Task/Filter/Factor/filter-4.factor

@@ -0,0 +1,9 @@
+USE: locals
+10 iota >vector [| v |
+    v [ even? ] filter drop
+    v pprint " after filter" print
+    v [ even? ] filter! drop
+    v pprint " after filter!" print
+] call
+! V{ 0 1 2 3 4 5 6 7 8 9 } after filter
+! V{ 0 2 4 6 8 } after filter!

Task/Filter/Fantom/filter.fantom

@@ -0,0 +1,11 @@
+class Main
+{
+  Void main ()
+  {
+    items := [1, 2, 3, 4, 5, 6, 7, 8]
+    // create a new list with just the even numbers
+    evens := items.findAll |i| { i.isEven }
+    // display the result
+    echo (evens.join(","))
+  }
+}

Task/Filter/Forth/filter.fth

@@ -0,0 +1,16 @@
+: sel ( dest 0 test src len -- dest len )
+  cells over + swap do   ( dest len test )
+    i @ over execute if
+      i @ 2over cells + !
+      >r 1+ r>
+    then
+  cell +loop drop ;
+
+create nums 1 , 2 , 3 , 4 , 5 , 6 ,
+create evens 6 cells allot
+
+: .array  0 ?do dup i cells + @ . loop drop ;
+
+: even? ( n -- ? ) 1 and 0= ;
+
+evens 0 ' even? nums 6 sel .array        \ 2 4 6

Task/Filter/Fortran/filter-1.f

@@ -0,0 +1,9 @@
+module funcs
+  implicit none
+contains
+  pure function iseven(x)
+    logical :: iseven
+    integer, intent(in) :: x
+    iseven = mod(x, 2) == 0
+  end function iseven
+end module funcs

Task/Filter/Fortran/filter-2.f

@@ -0,0 +1,43 @@
+program Filter
+  use funcs
+  implicit none
+
+  integer, parameter                 :: N = 100
+  integer, dimension(N)              :: array
+  integer, dimension(:), pointer     :: filtered
+
+  integer :: i
+
+  forall(i=1:N) array(i) = i
+
+  filtered => filterwith(array, iseven)
+  print *, filtered
+
+contains
+
+  function filterwith(ar, testfunc)
+    integer, dimension(:), pointer        :: filterwith
+    integer, dimension(:), intent(in)     :: ar
+    interface
+       elemental function testfunc(x)
+         logical :: testfunc
+         integer, intent(in) :: x
+       end function testfunc
+    end interface
+
+    integer :: i, j, n
+
+    n = count( testfunc(ar) )
+    allocate( filterwith(n) )
+
+    j = 1
+    do i = lbound(ar, dim=1), ubound(ar, dim=1)
+       if ( testfunc(ar(i)) ) then
+          filterwith(j) = ar(i)
+          j = j + 1
+       end if
+    end do
+
+  end function filterwith
+
+end program Filter

Task/Filter/GAP/filter.gap

@@ -0,0 +1,10 @@
+# Built-in
+
+Filtered([1 .. 100], IsPrime);
+# [ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97 ]
+
+Filtered([1 .. 10], IsEvenInt);
+# [ 2, 4, 6, 8, 10 ]
+
+Filtered([1 .. 10], IsOddInt);
+# [ 1, 3, 5, 7, 9 ]

Task/Filter/Go/filter.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+    "fmt"
+    "math/rand"
+)
+
+func main() {
+    a := rand.Perm(20)
+    fmt.Println(a)       // show array to filter
+    fmt.Println(even(a)) // show result of non-destructive filter
+    fmt.Println(a)       // show that original array is unchanged
+    reduceToEven(&a)     // destructive filter
+    fmt.Println(a)       // show that a is now changed
+    // a is not only changed, it is changed in place.  length and capacity
+    // show that it still has its original allocated capacity but has now
+    // been reduced in length.
+    fmt.Println("a len:", len(a), "cap:", cap(a))
+}
+
+func even(a []int) (r []int) {
+    for _, e := range a {
+        if e%2 == 0 {
+            r = append(r, e)
+        }
+    }
+    return
+}
+
+func reduceToEven(pa *[]int) {
+    a := *pa
+    var last int
+    for _, e := range a {
+        if e%2 == 0 {
+            a[last] = e
+            last++
+        }
+    }
+    *pa = a[:last]
+}

Task/Filter/Groovy/filter.groovy

@@ -0,0 +1 @@
+ def evens = [1, 2, 3, 4, 5].findAll{it % 2 == 0}

Task/Filter/Haskell/filter-1.hs

@@ -0,0 +1,2 @@
+ary = [1..10]
+evens = [x | x <- ary, even x]

Task/Filter/Haskell/filter-2.hs

@@ -0,0 +1 @@
+evens = filter even ary

Task/Filter/Haskell/filter-3.hs

@@ -0,0 +1,6 @@
+import Data.Array
+
+ary = listArray (1,10) [1..10]
+evens = listArray (1,n) l where
+  n = length l
+  l = [x | x <- elems ary, even x]

Task/Filter/IDL/filter.idl

@@ -0,0 +1 @@
+result = array[where(NOT array AND 1)]

Task/Filter/Icon/filter.icon

@@ -0,0 +1,10 @@
+procedure main()
+
+every put(A := [],1 to 10)              # make a list of 1..10
+every put(B := [],iseven(!A))           # make a second list and filter out odd numbers
+every writes(!B," ") | write()          # show
+end
+
+procedure iseven(x)                     #: return x if x is even or fail
+if x % 2 = 0 then return x
+end

Task/Filter/J/filter-1.j

@@ -0,0 +1 @@
+   (#~ f) v

Task/Filter/J/filter-2.j

@@ -0,0 +1,5 @@
+   ] v=: 20 ?@$ 100   NB. vector of 20 random integers between 0 and 99
+63 92 51 92 39 15 43 89 36 69 40 16 23 2 29 91 57 43 55 22
+
+   v #~ -.2| v
+92 92 36 40 16 2 22

Task/Filter/J/filter-3.j

@@ -0,0 +1,3 @@
+   isEven=: 0 = 2&|    NB. verb testing for even numbers
+   (#~ isEven) v
+92 92 36 40 16 2 22

Task/Filter/J/filter-4.j

@@ -0,0 +1,9 @@
+   select=: adverb def '(#~ u)'
+   isPrime=: 1&p:
+
+   isEven select v
+92 92 36 40 16 2 22
+   isPrime select v
+43 89 23 2 29 43
+   (isEven *. isPrime) select v
+2

Task/Filter/J/filter-5.j

@@ -0,0 +1 @@
+   v=: isEven select v

Task/Filter/Java/filter.java

@@ -0,0 +1,6 @@
+int[] array = {1, 2, 3, 4, 5 };
+List<Integer> evensList = new ArrayList<Integer>();
+for (int  i: array) {
+    if (i % 2 == 0) evensList.add(i);
+}
+int[] evens = evensList.toArray(new int[0]);

Task/Filter/JavaFX-Script/filter.javafx

@@ -0,0 +1,2 @@
+def array = [1..100];
+def evens = array[n | n mod 2 == 0];

Task/Filter/JavaScript/filter-1.js

@@ -0,0 +1,2 @@
+var arr = [1,2,3,4,5];
+var evens = arr.filter(function(a) {return a % 2 == 0});

Task/Filter/JavaScript/filter-2.js

@@ -0,0 +1,5 @@
+var arr = [1,2,3,4,5];
+var evens = [];
+for (var i=0, ilen=arr.length; i<ilen; i++)
+      if (arr[i] % 2 == 0)
+              evens.push(arr[i]);

Task/Filter/JavaScript/filter-3.js

@@ -0,0 +1,10 @@
+var numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+var evens = [i for (i in numbers) if (i % 2 == 0)];
+
+function range(limit) {
+  for(var i = 0; i < limit; i++) {
+    yield i;
+  }
+}
+
+var evens2 = [i for (i in range(100)) if (i % 2 == 0)];

Task/Filter/JavaScript/filter-4.js

@@ -0,0 +1 @@
+Functional.select("+1&1", [1,2,3,4])   // [2, 4]

Task/Filter/K/filter-1.k

@@ -0,0 +1,15 @@
+   / even is a boolean function
+   even:{0=x!2}
+   even 1 2 3 4 5
+0 1 0 1 0
+
+   / filtering the even numbers
+   a@&even'a:1+!10
+2 4 6 8 10
+
+   / as a function
+   evens:{x@&even'x}
+   a:10?100
+45 5 79 77 44 15 83 88 33 99
+   evens a
+44 88

Task/Filter/K/filter-2.k

@@ -0,0 +1,2 @@
+   {x[&0=x!2]}
+   {x[&even x]}

Task/Filter/K/filter-3.k

@@ -0,0 +1,2 @@
+   a:evens a
+44 88

Task/Filter/Lang5/filter.lang5

@@ -0,0 +1,4 @@
+: filter  over swap execute select ;
+10 iota "2 % not" filter . "\n" .
+
+# [    0     2     4     6     8  ]

Task/Filter/Liberty-BASIC/filter.liberty

@@ -0,0 +1,21 @@
+' write random nos between 1 and 100
+' to array1 counting matches as we go
+dim array1(100)
+count=100
+for i = 1 to 100
+    array1(i) = int(rnd(0)*100)+1
+    count=count-(array1(i) mod 2)
+next
+
+'dim the extract and fill it
+dim array2(count)
+for i = 1 to 100
+    if not(array1(i) mod 2) then
+        n=n+1
+        array2(n)=array1(i)
+    end if
+next
+
+for n=1 to count
+    print array2(n)
+next

Task/Filter/Lisaac/filter.lisaac

@@ -0,0 +1,11 @@
++ a, b : ARRAY[INTEGER];
+a := ARRAY[INTEGER].create_with_capacity 10 lower 0;
+b := ARRAY[INTEGER].create_with_capacity 10 lower 0;
+1.to 10 do { i : INTEGER;
+  a.add_last i;
+};
+a.foreach { item : INTEGER;
+  (item % 2 = 0).if {
+    b.add_last item;
+  };
+};

Task/Filter/Logo/filter.logo

@@ -0,0 +1,6 @@
+to even? :n
+  output equal? 0 modulo :n 2
+end
+show filter "even? [1 2 3 4]    ; [2 4]
+
+show filter [equal? 0 modulo ? 2] [1 2 3 4]

Task/Filter/Lua/filter.lua

@@ -0,0 +1,9 @@
+function filter(t, func)
+  local ret = {}
+  for i, v in ipairs(t) do ret[#ret+1] = func(v) and v or nil end
+  return ret
+end
+
+function even(a) return a % 2 == 0 end
+
+print(unpack(filter({1,2,3,4,5,6,7,8,9,10},even)))

Task/Filter/MATLAB/filter-1.m

@@ -0,0 +1,5 @@
+function evens = selectEvenNumbers(list)
+
+    evens = list( mod(list,2) == 0 );
+
+end

Task/Filter/MATLAB/filter-2.m

@@ -0,0 +1,5 @@
+>> selectEvenNumbers([0 1 2 3 4 5 6 7 8 9 10])
+
+ans =
+
+     0     2     4     6     8    10

Task/Filter/MAXScript/filter.max

@@ -0,0 +1,2 @@
+arr = #(1, 2, 3, 4, 5, 6, 7, 8, 9)
+newArr = for i in arr where (mod i 2 == 0) collect i

Task/Filter/MUMPS/filter.mumps

@@ -0,0 +1,7 @@
+FILTERARRAY
+ ;NEW I,J,A,B - Not making new, so we can show the values
+ ;Populate array A
+ FOR I=1:1:10 SET A(I)=I
+ ;Move even numbers into B
+ SET J=0 FOR I=1:1:10 SET:A(I)#2=0 B($INCREMENT(J))=A(I)
+ QUIT

Task/Filter/Mathematica/filter-1.mathematica

@@ -0,0 +1 @@
+Select[{4, 5, Pi, 2, 1.3, 7, 6, 8.0}, EvenQ]

Task/Filter/Mathematica/filter-2.mathematica

@@ -0,0 +1 @@
+{4, 2, 6}

Task/Filter/Mathematica/filter-3.mathematica

@@ -0,0 +1 @@
+Select[{4, 5, Pi, 2, 1.3, 7, 6, 8.0}, Mod[#, 2] == 0 &]

Task/Filter/Mathematica/filter-4.mathematica

@@ -0,0 +1 @@
+{4, 2, 6, 8.}

Task/Filter/Maxima/filter.maxima

@@ -0,0 +1,8 @@
+a: makelist(i, i, 1, 20);
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
+
+sublist(a, evenp);
+[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
+
+sublist(a, lambda([n], mod(n, 3) = 0));
+[3, 6, 9, 12, 15, 18]

Task/Filter/PHP/filter-1.php

@@ -0,0 +1,6 @@
+$arr = range(1,5);
+$evens = array();
+foreach ($arr as $val){
+      if ($val % 2 == 0) $evens[] = $val);
+}
+print_r($evens);

Task/Filter/PHP/filter-2.php

@@ -0,0 +1,4 @@
+function is_even($var) { return(!($var & 1)); }
+$arr = range(1,5);
+$evens = array_filter($arr, "is_even");
+print_r($evens);

Task/Filter/Perl/filter.pl

@@ -0,0 +1,2 @@
+my @a = (1, 2, 3, 4, 5, 6);
+my @even = grep { $_%2 == 0 } @a;

Task/Filter/PicoLisp/filter.l

@@ -0,0 +1,2 @@
+(filter '((N) (not (bit? 1 N)))
+   (1 2 3 4 5 6 7 8 9) )

Task/Filter/Prolog/filter-1.pro

@@ -0,0 +1 @@
+evens(D, Es) :- findall(E, (member(E, D), E mod 2 =:= 0), Es).

Task/Filter/Prolog/filter-2.pro

@@ -0,0 +1,2 @@
+?- evens([1,2,3,4,5,6,7,8,9,10],E).
+E = [2, 4, 6, 8, 10]

Task/Filter/Prolog/filter-3.pro

@@ -0,0 +1,5 @@
+?- use_module(library(lambda)).
+true.
+
+?- include((\X^(X mod 2 =:= 0)), [1,2,3,4,5,6,7,8,9], L).
+L = [2,4,6,8].

Task/Filter/Prolog/filter-4.pro

@@ -0,0 +1,9 @@
+:- use_module(lambda).
+
+%% filter(Pred, LstIn, LstOut)
+%%
+filter(_Pre, [], []).
+
+filter(Pred, [H|T], L) :-
+	filter(Pred, T, L1),
+	(   call(Pred,H) -> L = [H|L1]; L = L1).

Task/Filter/Prolog/filter-5.pro

@@ -0,0 +1,2 @@
+ ?- filter(\X^(X mod 2 =:= 0), [1,2,3,4,5,6,7,8,9], L).
+L = [2,4,6,8] .

Task/Filter/Python/filter-1.py

@@ -0,0 +1,5 @@
+values = range(10)
+evens = [x for x in values if not x & 1]
+ievens = (x for x in values if not x & 1) # lazy
+# alternately but less idiomatic:
+evens = filter(lambda x: not x & 1, values)

Task/Filter/Python/filter-2.py

@@ -0,0 +1,2 @@
+values = range(10)
+evens = values[::2]

Task/Filter/Python/filter-3.py

@@ -0,0 +1,4 @@
+values = range(10)
+values[::2] = [11,13,15,17,19]
+print values
+11, 1, 13, 3, 15, 5, 17, 7, 19, 9

Task/Filter/R/filter.r

@@ -0,0 +1,3 @@
+a <- 1:100
+evennums <- a[ a%%2 == 0 ]
+print(evennums)

Task/Filter/REXX/filter.rexx

@@ -0,0 +1,26 @@
+/*REXX program selects all even numbers from an array  ──► a new array. */
+numeric digits 210000                  /*handle past  1m  for Fibonacci.*/
+old.=                                  /*the OLD array, all null so far.*/
+new.=                                  /*the NEW array, all null so far.*/
+  do j=-40 to 40;  old.j=fib(j);  end  /*put 81 Fibonacci numbs ==> OLD */
+news=0                                 /*numb. of elements in NEW so far*/
+
+/*══════════════════════════════════════════════════════════════════════*/
+      do k=-40  while old.k\==''       /*process the OLD array elements.*/
+      if old.k//2 \== 0 then iterate   /*if element isn't even, skip it.*/
+      news=news+1                      /*bump the number of NEW elements*/
+      new.news=old.k                   /*assign it to the NEW array.    */
+      end
+/*══════════════════════════════════════════════════════════════════════*/
+
+      do j=1  for news                 /*display all the NEW  numbers.  */
+      say 'new.'j "=" new.j
+      end
+exit                                   /*stick a fork in it, we're done.*/
+/*─────────────────────────────────────FIB subroutine (non-recursive)───*/
+fib: procedure; parse arg n; na=abs(n); if na<2 then return na /*special*/
+a=0;  b=1
+                do j=2 to na; s=a+b; a=b; b=s; end
+
+if n>0 | na//2==1  then return  s      /*if positive or odd negative... */
+                   else return -s      /*return a negative Fib number.  */

Task/Filter/Ruby/filter-1.rb

@@ -0,0 +1,9 @@
+# Enumerable#select returns a new array.
+ary = [1, 2, 3, 4, 5, 6]
+even_ary = ary.select {|elem| elem.even?}
+p even_ary # => [2, 4, 6]
+
+# Enumerable#select also works with Range.
+range = 1..6
+even_ary = range.select {|elem| elem.even?}
+p even_ary # => [2, 4, 6]

Task/Filter/Ruby/filter-2.rb

@@ -0,0 +1,9 @@
+# Integer#even? is new to Ruby 1.8.7.
+# Define it for older Ruby.
+unless Integer.method_defined? :even?
+  class Integer
+    def even?
+      self % 2 == 0
+    end
+  end
+end

Task/Filter/Ruby/filter-3.rb

@@ -0,0 +1,3 @@
+ary = [1, 2, 3, 4, 5, 6]
+ary.select! {|elem| elem.even?}
+p ary # => [2, 4, 6]

Task/Filter/Ruby/filter-4.rb

@@ -0,0 +1,11 @@
+# Array#select! is new to Ruby 1.9.2.
+# Define it for older Ruby.
+unless Array.method_defined? :select!
+  class Array
+    def select!
+      enum_for(:select!) unless block_given?
+      delete_if { |elem| not yield elem }
+      self
+    end
+  end
+end

Task/Filter/Sather/filter.sa

@@ -0,0 +1,23 @@
+class MARRAY{T} < $ARR{T} is
+  include ARRAY{T};
+
+  filter_by(r:ROUT{T}:BOOL):SAME is
+    o:MARRAY{T} := #;
+    loop e ::= elt!;
+      if r.call(e) then
+        o := o.append(#MARRAY{T}(|e|));
+      end;
+    end;
+    return o;
+  end;
+
+end;
+
+class MAIN is
+  main is
+    a ::= #MARRAY{INT}(|5, 6, 7, 8, 9, 10, 11|);
+    sel ::= a.filter_by( bind(_.is_even) );
+    loop #OUT + sel.elt! + " "; end;
+    #OUT + "\n";
+  end;
+end;

Task/Filter/Scala/filter.scala

@@ -0,0 +1 @@
+(1 to 100).filter(_ % 2 == 0)