Filter: Difference between revisions

 

 

=={{header|ACL2}}==

(cond ((endp xs) nil)

((evenp (first xs))

(cons (first xs) (filter-evens (rest xs))))

 

=={{header|ActionScript}}==

var evens:Array = new Array();

for (var i:int = 0; i < arr.length(); i++) {

if (arr[i] % 2 == 0)

evens.push(arr[i]);

 

=={{header|Ada}}==

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

end if;

end Evens;

procedure Print(Item : Array_Type) is

begin

end loop;

end Print;

Foo : Array_Type := (1,2,3,4,5,6,7,8,9,10);

begin

Print(Evens(Foo));

Here is a non-recursive solution:

 

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);

return Result (1..Index - 1);

end Evens;

procedure Put (Item : Array_Type) is

begin

Put (Evens ((1,2,3,4,5,6,7,8,9,10)));

New_Line;

=={{header|ALGOL 68}}==

{{works with|ALGOL 68|Standard - no extensions to language used}}

{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386}}

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386}}

 

BEGIN

FLEX[0]TYPE result;

 

# Or as a simple one line query #

<pre>

+2 +4 +6 +8 +10

+4 +16 +36 +64 +100

</pre>

 

=={{header|AmigaE}}==

DEF l : PTR TO LONG, r : PTR TO LONG, x

l := [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

SelectList({x}, l, r, `Mod(x,2)=0)

ForAll({x}, r, `WriteF('\d\n', x))

 

=={{header|AppleScript}}==

set evens to {}

repeat with i in array

if (i mod 2 = 0) then set end of evens to i's contents

end repeat

 

Here's how you might implement a more generic filter, passing a script object to represent the test that elements must pass (obviously overkill for this simple example):

 

set outList to {}

repeat with anItem in inList

end script

 

 

=={{header|AutoHotkey}}==

loop, parse, array, `,

{

 

even(s) {

r .= "," A_LoopField

return SubStr(r, 2)

r := []

For k, v in a

r.Insert(v)

return r

s_join(o, a) {

Loop, % a.MaxIndex()

return SubStr(r, StrLen(o) + 1)

}

 

 

 

=={{header|AWK}}==

 

=={{header|BBC BASIC}}==

items% = 1000

DIM array%(items%)

array%(index%) = RND

NEXT

REM Count the number of filtered items:

filtered% = 0

IF FNfilter(array%(index%)) filtered% += 1

NEXT

REM Create a new array containing the filtered items:

DIM new%(filtered%)

ENDIF

NEXT

REM Alternatively modify the original array:

filtered% = 0

NEXT

END

 

=={{header|Bracmat}}==

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

| !odds

)

)

<pre>1 3 5 7 9 25 49 81</pre>

 

=={{header|Brat}}==

 

=={{header|C}}==

#include <stdlib.h>

 

 

return 0;

In-place filtered not multiple of 3: 1 2 4 5 7 8 10</pre>

 

=={{header|C sharp|C#}}==

{{works with|.NET|1.1}}

ArrayList evens = new ArrayList();

foreach( int i in array )

}

foreach( int i in evens )

{{works with|.NET|2.0}}

List<int> evens = array.FindAll( delegate( int i ) { return (i%2)==0; } );

foreach( int i in evens )

{{works with|.NET|3.5}}

IEnumerable<int> evens = array.Where( delegate( int i ) { return (i%2)==0; } );

foreach( int i in evens )

Replacing the delegate with the more concise lambda expression syntax.

int[] evens = array.Where(i => (i % 2) == 0).ToArray();

 

foreach (int i in evens)

 

=={{header|C++}}==

 

#include <algorithm>

#include <functional>

 

return 0;

 

 

{{works with|C++11}}

#include <algorithm>

#include <iterator>

// print result

copy(evens.begin(), evens.end(), ostream_iterator<int>(cout, "\n"));

 

=={{header|Clean}}==

The standard environment is required for list and array comprehensions. We specify the types of the functions because array comprehensions are overloaded. Clean provides lazy, strict, and unboxed arrays.

 

 

 

Create a lazy array where each element comes from the list 1 to 10.

 

 

Create (and print) a strict array where each element (coming from another array) is even.

 

=={{header|Clojure}}==

 

(filter even? (range 0 100))

;; vec will convert any type of seq to an array

 

=={{header|Common Lisp}}==

 

In this example, the goal is to find the even numbers. The most straight-forward function is to use remove-if-not, which removes elements from the list that does ''not'' pass the predicate. The predicate, in this case, tests to see if an element is even. Therefore, the remove-if-not acts like a filter:

 

 

However, this function is non-destructive, meaning the function creates a brand new list. This might be too prohibitive for very large lists.

There is a destructive version that modifies the list in-place:

 

 

 

 

 

assert(evens.equal([2, 4, 6, 8, 10]));

===Tango Version===

{{libheader|Tango}}

 

void main() {

Stdout("Evens - ")( array[0 .. evens] ).newline; // The order of even elements is preserved

Stdout("Odds - ")( array[evens .. $].sort ).newline; // Unlike odd elements

<pre> Evens - [ 2, 4, 6, 8, 10 ]

Odds - [ 1, 3, 5, 7, 9 ]</pre>

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

Write(i:3);

Writeln;

 

=={{header|E}}==

There are several ways this could be done.

 

 

for x ? (x %% 2 <=> 0) in [1,2,3,4,5,6,7,8,9,10] {

result with= x

}

 

 

=={{header|Ela}}==

===Using higher-order function (non-strict version)===

 

 

 

===Using comprehension (non-strict version)===

 

 

=={{header|Erlang}}==

 

Or using a list comprehension:

 

 

=={{header|Euphoria}}==

s = {1, 2, 3, 4, 5, 6}

evens = {}

end if

end for

 

<pre>{2,4,6}

</pre>

 

=={{header|F Sharp|F#}}==

List.filter (fun x -> x % 2 = 0) lst;;

 

 

=={{header|Factor}}==

This code uses ''filter'' on an array.

 

 

 

 

=== Destructive ===

This uses ''filter!'' to modify the original vector.

 

 

To prove that ''filter!'' is destructive but ''filter'' is non-destructive, I assign the original vector to ''v''.

 

v [ even? ] filter drop

v pprint " after filter" print

] call

! V{ 0 1 2 3 4 5 6 7 8 9 } after filter

 

=={{header|Fantom}}==

 

class Main

{

}

}

 

 

=={{header|Forth}}==

cells over + swap do ( dest len test )

i @ over execute if

: even? ( n -- ? ) 1 and 0= ;

 

 

=={{header|Fortran}}==

 

implicit none

contains

iseven = mod(x, 2) == 0

end function iseven

 

use funcs

implicit none

 

contains

function filterwith(ar, testfunc)

integer, dimension(:), pointer :: filterwith

end function filterwith

 

=={{header|GAP}}==

 

# [ 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 ]

 

# [ 2, 4, 6, 8, 10 ]

 

 

=={{header|Go}}==

 

import (

}

*pa = a[:last]

<pre>

[15 1 7 3 4 8 19 0 17 18 14 5 16 9 13 11 12 10 2 6]

 

=={{header|Groovy}}==

 

=={{header|Haskell}}==

In Haskell, a list is often more basic than an array:

 

or

 

To do the same operation on an array, the simplest way it to convert it lazily into a list:

 

 

ary = listArray (1,10) [1..10]

evens = listArray (1,n) l where

n = length l

 

Note that the bounds must be known before creating the array, so the temporary list will be fully evaluated before the array is created.

 

=={{header|Icon}} and {{header|Unicon}}==

 

every put(A := [],1 to 10) # make a list of 1..10

procedure iseven(x) #: return x if x is even or fail

if x % 2 = 0 then return x

 

=={{header|IDL}}==

The <tt>where()</tt> function can select elements on any logical expression. For example

 

 

=={{header|J}}==

'''Solution:'''<br>

With any verb (function) <code>f</code> that returns a boolean for each element of a vector <code>v</code>, the following is the generic solution:

 

'''Examples:'''

63 92 51 92 39 15 43 89 36 69 40 16 23 2 29 91 57 43 55 22

 

v #~ -.2| v

 

Or using the generic form suggested above:

(#~ isEven) v

 

We might decide that we use this pattern so often that it is worthwhile creating a new adverb <code>select</code> that filters an array using the verb to its left.

isPrime=: 1&p:

 

43 89 23 2 29 43

(isEven *. isPrime) select v

 

Destructive example:

 

 

(That said, note that in a highly parallel computing environment the destruction either happens after the filtering or you have to repeatedly stall the filtering to ensure that some sort of partially filtered result has coherency.)

 

=={{header|Java}}==

List<Integer> evensList = new ArrayList<Integer>();

for (int i: array) {

if (i % 2 == 0) evensList.add(i);

}

 

=={{header|JavaFX Script}}==

 

=={{header|JavaScript}}==

The standard way is to use the [https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Global_Objects/Array/filter Array.prototype.filter] function ({{works with|JavaScript|1.6}}):

 

Other ways:

var evens = [];

for (var i=0, ilen=arr.length; i<ilen; i++)

if (arr[i] % 2 == 0)

 

{{works with|Firefox|2.0}}

 

var evens = [i for (i in numbers) if (i % 2 == 0)];

 

}

 

 

{{libheader|Functional}}

 

=={{header|K}}==

even:{0=x!2}

even 1 2 3 4 5

/ as a function

evens:{x@&even'x}

45 5 79 77 44 15 83 88 33 99

evens a

 

Alternative syntax:

 

Destructive:

 

=={{header|Liberty BASIC}}==

' to array1 counting matches as we go

dim array1(100)

for n=1 to count

print array2(n)

 

=={{header|Lisaac}}==

a := ARRAY[INTEGER].create_with_capacity 10 lower 0;

b := ARRAY[INTEGER].create_with_capacity 10 lower 0;

b.add_last item;

};

 

=={{header|Logo}}==

output equal? 0 modulo :n 2

end

show filter "even? [1 2 3 4] ; [2 4]

 

=={{header|Lua}}==

local ret = {}

return ret

end

function even(a) return a % 2 == 0 end

 

 

Check for even integers:

gives:

To check also for approximate number (like 8.0 in the example above) a possible solution is:

gives:

notice that the function returns 8. not 8 (the dot indicates that it is a float number, not an integer).

 

=={{header|MATLAB}}==

 

evens = list( mod(list,2) == 0 );

 

 

 

ans =

 

 

=={{header|Maxima}}==

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

 

 

sublist(a, lambda([n], mod(n, 3) = 0));

 

=={{header|MAXScript}}==

 

=={{header|MUMPS}}==

;NEW I,J,A,B - Not making new, so we can show the values

;Populate array A

;Move even numbers into B

SET J=0 FOR I=1:1:10 SET:A(I)#2=0 B($INCREMENT(J))=A(I)

Testing:<pre>WRITE

 

=={{header|Nemerle}}==

Lists have a built-in method for filtering:

def filtered = original.Filter(fun(n) {n % 2 == 0});

The following would work for arrays:

{

def b = $[x | x in a, (f(x))];

b.ToArray()

 

=={{header|NewLISP}}==

(2 4 6 8 10)

 

=={{header|Nial}}==

 

=={{header|Objeck}}==

use Structure;

 

}

}

 

=={{header|Objective-C}}==

{{works with|Cocoa|Mac OS X 10.6+}}

[NSNumber numberWithInt:2],

[NSNumber numberWithInt:3],

[NSNumber numberWithInt:5], nil];

NSArray *evens = [numbers objectsAtIndexes:[numbers indexesOfObjectsPassingTest:

 

{{works with|Cocoa|Mac OS X 10.5+}}

[NSNumber numberWithInt:2],

[NSNumber numberWithInt:3],

[NSNumber numberWithInt:5], nil];

NSPredicate *isEven = [NSPredicate predicateWithFormat:@"modulus:by:(SELF, 2) == 0"];

 

{{works with|GNUstep}}

 

@interface NSNumber ( ExtFunc )

NSPredicate *isEven = [NSPredicate predicateWithFormat:@"modulo2 == 0"];

NSArray *evens = [numbers filteredArrayUsingPredicate:isEven];

NSLog(@"%@", evens);

 

[pool release];

return 0;

 

=={{header|OCaml}}==

It is easier to do it with a list:

 

=={{header|Octave}}==

evennums = arr( mod(arr, 2) == 0 );

 

=={{header|Oz}}==

It is easier to do it with a list:

Lst = [1 2 3 4 5]

 

=={{header|PARI/GP}}==

 

=={{header|Pascal}}==

{{works with|Delphi}}<br>

{{works with|Turbo Pascal}}

 

numbers:array[0..9] of integer = (0,1,2,3,4,5,6,7,8,9);

writeln( 'The number ',numbers[x],' is odd.');

else

 

The odd() function is a standard library function of pascal as is the function even().

 

=={{header|Perl}}==

 

 

 

 

 

 

 

=={{header|PHP}}==

Using a standard loop

$evens = array();

foreach ($arr as $val){

if ($val % 2 == 0) $evens[] = $val);

}

 

Using a filter function

$arr = range(1,5);

$evens = array_filter($arr, "is_even");

 

=={{header|PicoLisp}}==

<pre>-> (2 4 6 8)</pre>

 

=={{header|Pop11}}==

Most natural solution in Pop11 would probably use list. Below we accumulate filtered elements on the stack and then allocate array for the result:

 

;;; satisfying pred

define filter_array(ar, pred);

;;; Use it

filter_array({1, 2, 3, 4, 5},

 

=={{header|PostScript}}==

{{libheader|initlib}}

[1 2 3 4 5 6 7 8 9 10] {2 mod 0 eq} find

 

=={{header|PowerShell}}==

 

=={{header|Prolog}}==

===findall===

 

Usage:

 

 

===Anonymous functions===

Works with SWI-Prolog and <b>module(lambda)</b> written by <b>Ulrich Neumerkel</b>, "lambda.pl" can be found there : http://www.complang.tuwien.ac.at/ulrich/Prolog-inedit/lambda.pl

true.

 

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

 

===filter and anonymous functions===

Works with SWI-Prolog and <b>module(lambda)</b> written by <b>Ulrich Neumerkel</b>, "lambda.pl" can be found there : http://www.complang.tuwien.ac.at/ulrich/Prolog-inedit/lambda.pl

 

%% filter(Pred, LstIn, LstOut)

filter(Pred, T, L1),

( call(Pred,H) -> L = [H|L1]; L = L1).

Usage :

L = [2,4,6,8] .

 

=={{header|PureBasic}}==

Dim Evens.i(0)

 

For i=0 To ArraySize(Evens())

Print(Str(Evens(i))+" ")

 

List of Randoms

32 35 89 91 11 33 12 22 42 43

List of Even(s)

32 12 22 42

{{works with|Python|2.4}}

 

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:

 

Alternative using the slice syntax with its optional "stride" expression:

 

 

This works for all versions of Python (at least as far back as 1.5). Lists (arrays) can be "sliced" by indexing them with a range (lower and upper bounds). Thus mylist[1:9] evaluates into a list from the second item (excluding the first item which is mylist[0], of course) up to but not including the ninth item. In Python the expression mylist[:] is synonymous with mylist[0:len(mylist)] ... returning a copy of the complete list. also mylist[:x] returns the first x items from the list and negative numbers can be used such that mylist[-x:] returns the last x items from the list. The relatively obscure and optional stride expression can skip items and/or force the evaluation from the end of the list downward towards it's lower elements. Thus mylist[::-1] returns a reversed copy of the list, mylist[::2] returns all even elements, mylist[1::2] returns all odd elements, and so on.

One can also assign to a slice (of a list or other mutable indexed object. Thus the following:

 

values[::2] = [11,13,15,17,19]

print values

 

=={{header|R}}==

evennums <- a[ a%%2 == 0 ]

 

=={{header|Raven}}==

group nums each

dup 1 & if drop

 

=={{header|REBOL}}==

 

evens: [] repeat element a [if even? element [append evens element]]

 

 

78 80 82 84 86 88 90 92 94 96 98 100]</pre>

 

=={{header|REXX}}==

 

 

 

</pre>

 

=={{header|Ruby}}==

 

ary = [1, 2, 3, 4, 5, 6]

even_ary = ary.select {|elem| elem.even?}

range = 1..6

even_ary = range.select {|elem| elem.even?}

 

=== Destructive ===

 

ary.select! {|elem| elem.even?}

 

 

 

 

=={{header|Salmon}}==

In this example, [1...10] is a list of the integers from 1 to 10. The comprehend expression walks over this list and selects only the even elements. The result of the comprehend expression is a new list with only the even elements. Then an iterate statement is used to walk over the list of even elements and print them out.

 

 

Here's a version that walks an array destructively removing the non-even elements:

 

variable write_position := 0;

iterate (read_position; [0...9])

my_array := my_array[0...write_position - 1];

iterate(x; my_array)

 

=={{header|Sather}}==

include ARRAY{T};

 

#OUT + "\n";

end;

 

=={{header|Scala}}==

 

=={{header|Scheme}}==

Or as a function:

(filter even? lst))

 

 

=={{header|Seed7}}==

var array integer: evens is 0 times 0;

var integer: number is 0;

evens &:= [] (number);

end if;

 

=={{header|Slate}}==

 

=={{header|Smalltalk}}==

 

=={{header|SQL}}==

 

{{works with|MS SQL}}

create table #nos (v int)

declare @n int set @n=1

-- Clean up so you can edit and repeat:

drop table #nos

 

'{{works with|MySQL}}

insert into nos values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10);

create temporary table evens (v int);

select * from evens order by v; /*2,4,6,8,10*/

drop table nos;

 

 

 

=={{header|Tcl}}==

 

 

 

 

=={{header|Toka}}==

10 cells is-array even

{

[ swap source ! >r reset r> 0

[ i source @ array.get

] countedLoop

depth 0 swap [ i even array.put ] countedLoop

} is copy-even

10 0 [ i i table array.put ] countedLoop

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

arr="1'4'9'16'25'36'49'64'81'100",even=""

ENDLOOP

PRINT even

<pre>

4'16'36'64'100

{{works with|Bash}}

 

unset e[@]

for ((i=0;i<${#a[@]};i++)); do

[ $((a[$i]%2)) -eq 0 ] && e[$i]="${a[$i]}"

 

<pre>1 2 3 4 5

2 4</pre>

 

=={{header|UnixPipes}}==

 

=={{header|Ursala}}==

 

Ursala doesn't have arrays, except when the run time system

 

=== Unary predicates ===

predicate <code>p</code> is to write <code>p*~</code>, as shown below.