Filter: Difference between revisions

 

;Task:

 

 

To demonstrate, select all even numbers from an Array.

 

by modifying the original Array rather than creating a new Array.

<br><br>

=={{header|11l}}==

 

V even = array.filter(n -> n % 2 == 0)

 

{{out}}

<pre>

[2, 4, 6, 8, 10]

</pre>

 

=={{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]);

 

'''Actionscript 3'''

arr = arr.filter(function(item:int, index:int, array:Array) {

return item % 2 == 0;

});

 

=={{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|Aime}}==

even(integer e)

{

 

return 0;

{{out}}

<pre> 0 2 4 6 8</pre>

{{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 #

{{out}}

<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|AntLang}}==

 

=={{header|Apex}}==

Set<Integer> evenIntegers = new Set<Integer>();

for(Integer i : integers)

system.assert(!evenIntegers.contains(3), '3 should not be a number in the set');

system.assert(evenIntegers.contains(4), '4 should be a number in the set');

 

=={{header|APL}}==

 

=={{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

 

 

 

This allows for context-sensitive filters, which can take account of following or preceding elements in a sequence.

 

on filter(f, xs)

tell mReturn(f)

end filter

 

 

on run

end run

 

 

-- mReturn :: Handler -> Script

on mReturn(f)

end script

end if

{{Out}}

<pre>{0, 2, 4, 6, 8, 10}</pre>

 

=={{header|Arturo}}==

 

 

{{out}}

 

=={{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}}==

Note that sequence is not necessarily maintained.

 

'''One-liner:'''

{{out}}

<pre>4 6 8 2</pre>

 

'''Regular script:'''

BEGIN {

split("1 2 3 4 5 6 7 8 9",a);

print r

}

Same output.

 

=={{header|Batch File}}==

@echo off

setlocal enabledelayedexpansion

set /a length+=1

goto lengthloop

{{out}}

<pre>

numberarray - 2 4 6 8 10

</pre>

 

=={{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|Burlesque}}==

 

blsq ) 1 13r@{2.%n!}f[

{2 4 6 8 10 12}

 

 

 

=={{header|C}}==

#include <stdlib.h>

 

 

return 0;

{{out}}

<pre>Filtered even: 2 4 6 8 10

=={{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|CoffeeScript}}==

 

{{out}}

 

=={{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:

 

 

=={{header|D}}==

import std.algorithm: filter, equal;

 

auto evens = data.filter!(x => x % 2 == 0); // Lazy.

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

{{out}}

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

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

Write(i:3);

Writeln;

 

 

 

 

 

 

 

 

 

 

 

{{out}}

 

=={{header|Dyalect}}==

 

===Non-destructively===

var arr = []

for x in this when pred(x) {

}

arr

}

 

 

{{out}}

 

===Destructively===

var i = 0

if !pred(this[i]) {

}

i += 1

 

var arr = [1..20]

 

{{out}}

Idiomatic approach in Dy is to use non-strict iterators (which can be combined without intermedate data structures) and translate the result to an array if needed:

 

 

 

 

{{out}}

 

 

=={{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|EchoLisp}}==

(iota 12) → { 0 1 2 3 4 5 6 7 8 9 10 11 }

 

→ (0 2 4 6 8 10 12 14 16 18 20 22)

 

 

=={{header|Ela}}==

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

 

 

 

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

 

=={{header|Elena}}==

ELENA 5.0 :

import system'math;

import extensions;

import extensions'routines;

public program()

{

auto array := new int[]{1,2,3,4,5};

Using strong typed collections and extensions:

import system'routines'stex;

import system'math;

import extensions;

public program()

{

int[] array := new int[]{1,2,3,4,5};

{{out}}

<pre>

 

=={{header|Elixir}}==

[1, 2, 3, 4, 5, 6, 7, 8, 9]

iex(11)> Enum.filter(numbers, fn x -> rem(x,2)==0 end)

[2, 4, 6, 8]

iex(12)> for x <- numbers, rem(x,2)==0, do: x # comprehension

 

=={{header|Erlang}}==

 

Or using a list comprehension:

 

 

=={{header|Euphoria}}==

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

evens = {}

end if

end for

 

{{out}}

 

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

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

 

 

=={{header|Factor}}==

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

 

 

''10 <iota>'' is already a sequence, so we can skip the conversion to array.

 

 

=== Destructive ===

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

 

10 <iota> >vector [ even? ] filter! .

 

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

 

10 <iota> >vector [| v |

v [ even? ] filter drop

] 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|FreeBASIC}}==

 

Type FilterType As Function(As Integer) As Boolean

 

Function isEven(n As Integer) As Boolean

End Function

 

End If

Next

If count > 0 Then Redim Preserve b(0 To count - 1) '' trim excess elements

End Sub

count += 1

i -= 1

Next i

 

Redim Preserve da(LBound(da) To UBound(da) - count) '' trim excess elements

End If

End Sub

Dim n As Integer = 12

Dim a(1 To n) As Integer '' creates dynamic array as upper bound is a variable

End

 

 

{{out}}

 

=={{header|Frink}}==

b = array[1 to 100]

c = select[b, {|x| x mod 2 == 0}]

 

=={{header|Futhark}}==

{{incorrect|Futhark|Futhark's syntax has changed, so this example will not compile}}

 

fun main(as: []int): []int =

filter (fn x => x%2 == 0) as

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=e73bc5db1e3bb56c598f89aa669a0825 Click this link to run this code]'''

'______________________________________________________________________________________________________

Public Sub Main()

Print sRandom.join(",")

 

Output:

<pre>

 

=={{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]

{{out}}

<pre>

 

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

}

 

----

 

A Java 8 solution with stream and generic types:

return Arrays.stream(input)

.filter(filterMethod)

.toArray(size -> (T[]) Array.newInstance(input.getClass().getComponentType(), size));

Methodcall:

Warning: This solution works not with primitive types!<br/>

For arrays with a primitive type use the wrapper class.

 

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

 

=={{header|JavaScript}}==

===ES5===

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}}

 

===ES6===

 

'use strict';

 

 

// TEST

return [1,2,3,4,5,6,7,8,9]

.filter(isEven);

 

// [2, 4, 6, 8]

 

{{Out}}

 

=={{header|jq}}==

jq's "select" filter is designed to make it easy to filter both arrays and streams:

{{Out}}

2

6

8

[range(1;10)] | map( select(. % 2 == 0) )

{{Out}}

[2,4,6,8]

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

 

{{out}}

 

=={{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|Kotlin}}==

 

fun main(args: Array<String>) {

mutableList.retainAll { it % 2 == 0 }

println(mutableList.joinToString(" "))

 

{{out}}

2 4 6 8

2 4 6 8

</pre>

 

=={{header|Lang5}}==

10 iota "2 % not" filter . "\n" .

 

 

=={{header|langur}}==

 

 

 

{{out}}

filtered: [2, 4, 6]</pre>

 

=={{header|Lasso}}==

local(evens = (with item in #original where #item % 2 == 0 select #item) -> asstaticarray)

<pre>staticarray(2, 4, 6, 8, 10)</pre>

 

Modifying the original array

with item in #original where #item % 2 != 0 do #original ->removeall(#item)

<pre>array(2, 4, 6, 8, 10)</pre>

 

=={{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 = {}

for i, v in ipairs(t) do

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

 

 

The destructive version is even simpler, since tables are passed by reference:

 

for i, v in ipairs(t) do

if not func(v) then table.remove(t, i) end

local values = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

filter(values, even)

 

=={{header|M2000 Interpreter}}==

===Using Filter for arrays===

Module Checkit {

Print (1,2,3,4,5,6,7,8)#filter(lambda ->number mod 2=0)

}

Checkit

 

===Old style===

 

 

Module CheckIt {

Function GetEvenNumbers (A as array){

=Array([])

}

Dim A(5), B()

A(0)=10,3,6,7,11

Print B() ' print 10,6

Print GetEvenNumbers((1,2,3,4,5,6,7,8)) ' 2 4 6 8

Module Filter2EvenNumbers (&A()) {

If len(A())=0 then exit

A(0)=10,3,6,7,11

Filter2EvenNumbers &A()

}

CheckIt

}

CheckIt

 

=={{header|Maple}}==

evennum:=proc(nums::list(integer))

return select(x->type(x, even), nums);

end proc;

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

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

 

 

{{out}}

 

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|min}}==

{{works with|min|0.19.3}}

{{out}}

<pre>

=={{header|MiniScript}}==

We define a ''filter'' method on the list type that returns a new list containing elements filtered by the given function.

result = []

for item in self

 

nums = [1, 2, 3, 4, 5, 6, 7, 9, 12, 15, 18, 21]

 

The in-place version is simpler, and even allows the use of an unnamed filter function, defined right on the method call.

for i in range(self.len-1, 0)

if not f(self[i]) then self.remove i

end function

 

 

=={{header|ML}}==

==={{header|Standard ML}}===

==={{header|MLite}}===

MLite is similar to Standard ML, though '=>' becomes '=' and 'List.' is elided:

 

=={{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|NetRexx}}==

options replace format comments java crossref symbols nobinary

numeric digits 5000

sd1 = Rexx[]

sd2 = Rexx[]

say 'Test data:'

sd1 = makeSampleData(100)

ry = Rexx[] clist.toArray(Rexx[clist.size()])

return ry

{{out}}

<pre>

Test data:

--------------------------------------------------------------------------------

 

Option 1 (copy to a new array):

--------------------------------------------------------------------------------

 

Option 2 (replace the original array):

 

=={{header|NewLISP}}==

(2 4 6 8 10)

 

=={{header|Nial}}==

 

=={{header|Nim}}==

 

 

 

 

=={{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|Oforth}}==

 

 

=={{header|ooRexx}}==

a=.array~new

b=.array~new

Say 'Filtered values (destructive filtering):' a~makestring(line,' ')

Exit

{{out}}

<pre>Unfiltered values: 1412 2244 6778 4002 439 3335 5877 8273 7882 1469

=={{header|Oz}}==

It is easier to do it with a list:

Lst = [1 2 3 4 5]

 

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

{{PARI/GP select}}

 

Or in anonymous form

 

=={{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|Peloton}}==

Fixed length English dialect

<@ DEFLST>evens</@>

<@ ENULSTLIT>numbers|

<@ LETLSTELTLST>evens|...</@>

</@>

 

=={{header|Perl}}==

 

=={{header|Phix}}==

 

 

{{out}}

<pre>

{2,4,6,8,10}

</pre>

 

 

 

=={{header|PHL}}==

 

 

extern printf;

var evens = arr.filter(#(i) i % 2 == 0);

printf("%s\n", evens::str);

return 0;

 

=={{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}}==

{{out}}

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

 

=={{header|PL/I}}==

filter_values: procedure options (main); /* 15 November 2013 */

declare a(20) fixed, b(*) fixed controlled;

end filter;

 

Results:

<pre>

44270 6008 80477 17004 91587 48669 29623 74640 29841 20019 77833 59865 49647 2272 54781

36154 40114 71893 25960 76863

44270 6008 17004 74640 2272 36154 40114 25960

</pre>

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))+" ")

 

{{out}}

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

 

 

Or in functional terms, by descending generality and increasing brevity:

{{works with|Python|3}}

 

from functools import (reduce)

 

if __name__ == '__main__':

{{Out}}

<pre>By descending generality and increasing brevity:

(x for x in xs if even(x)) -> [0, 2, 4, 6, 8, 10]

filter(even, xs) -> [0, 2, 4, 6, 8, 10]</pre>

 

=={{header|Q}}==

 

=={{header|R}}==

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

 

=={{header|Racket}}==

The classic way:

-> (filter even? '(0 1 2 3 4 5 6 7 8 9))

'(0 2 4 6 8)

getting the list of non-evens too:

-> (partition even? '(0 1 2 3 4 5 6 7 8 9))

'(0 2 4 6 8)

'(1 3 5 7 9)

Finally, using a for loop, similar to list comprehension:

-> (for/list ([x '(0 1 2 3 4 5 6 7 8 9)] #:when (even? x)) x)

'(0 2 4 6 8)

 

=={{header|Raven}}==

group nums each

dup 1 & if drop

 

=={{header|REBOL}}==

 

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

 

 

{{out}}

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

=={{header|Red}}==

orig: [] repeat i 10 [append orig i]

?? orig

remove-each ele orig [odd? ele] ;; destructive

?? orig

{{out}}

<pre>orig: [1 2 3 4 5 6 7 8 9 10]

cpy: [2 4 6 8 10]

orig: [2 4 6 8 10]

</pre>

=={{header|REXX}}==

===using two arrays===

This example uses two arrays. &nbsp; The &nbsp; '''random''' &nbsp; BIF is used to generate the numbers.

<pre>

new.1 = 17520

new.23 = 44360

</pre>

===using one array, destructive===

 

=={{header|Ring}}==

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

bArray = list(3)

 

func evenSelect aArray

if (aArray[n] % 2) = 0

i = i + 1

next

return bArray

 

=={{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|Run BASIC}}==

count = 100

for i = 1 to 100

count = count - (a1(i) mod 2)

next

'dim the extract and fill it

dim a2(count)

end if

next

for i = 1 to count

print a2(i)

 

=={{header|Rust}}==

println!("new vec filtered: ");

let nums: Vec<i32> = (1..20).collect();

nums.retain(|x| x % 2 == 0);

println!("{:?}", nums);

 

{{out}}

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|SequenceL}}==

Filters are primarily written in SequenceL using partial Indexed Functions.<br>

 

{{out}}

[2,4]

</pre>

 

=={{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|Stata}}==

a=2,9,4,7,5,3,6,1,8

 

// Select the indices of even elements of a

selectindex(mod(a,2):==0)

 

=={{header|Swift}}==

let even_numbers = numbers.filter { $0 % 2 == 0 }

{{out}}

<pre>

[2, 4, 6]

</pre>

 

=={{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

{{out}}

<pre>

{{works with|Bash}}

 

unset e[@]

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

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

 

Or, using '''grep''':

 

 

Either way, to display the results:

 

 

{{out}}

 

=={{header|UnixPipes}}==

 

=={{header|Ursala}}==

 

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

However, selection can be done on lists.

 

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

 

#import nat

 

#cast %nL

 

 

{{out}}

of other ways to do it.

Selecting according to a binary predicate can be done like this.

The value of <code>z</code> will be the divisors of 36 appearing in the list.

<pre>

modified by appending an <code>F</code>, it becomes a selection filter.

For example

using the <code>x</code> defined above will evaluate to

<pre>

 

=={{header|V}}==

 

[1 2 3 4 5 6 7 8 9] [even?] filter

 

=={{header|VBA}}==

Option Explicit

 

Dim evens() As Long, i As Long

Dim numbers() As Long

For i = 1 To 100000

ReDim Preserve numbers(1 To i)

numbers(i) = i

Next i

evens = FilterInNewArray(numbers)

Debug.Print "Count of initial array : " & UBound(numbers) & ", first item : " & numbers(LBound(numbers)) & ", last item : " & numbers(UBound(numbers))

Debug.Print "Count of new array : " & UBound(evens) & ", first item : " & evens(LBound(evens)) & ", last item : " & evens(UBound(evens))

FilterInPlace numbers

Debug.Print "Count of initial array (filtered): " & UBound(numbers) & ", first item : " & numbers(LBound(numbers)) & ", last item : " & numbers(UBound(numbers))

End Sub

Private Function IsEven(Number As Long) As Boolean

IsEven = (CLng(Right(CStr(Number), 1)) And 1) = 0

 

{{Out}}

Count of new array : 50000, first item : 2, last item : 100000

Count of initial array (filtered): 50000, first item : 2, last item : 100000</pre>

 

=={{header|VBScript}}==

test_arr_1 = Array(1,2,3,4,5,6,7,8,9,10)

test_arr_2 = Array(1,2,3,4,5,6,7,8,9,10)

ReDim Preserve arr(UBound(arr)-count)

filter_destruct = Join(arr,",")

 

{{Out}}

=={{header|Visual Basic .NET}}==

{{works with|Visual Basic .NET|9.0+}}

 

Sub Main()

 

End Module

 

{{out}}

8

10

</pre>

 

=={{header|WDTE}}==

let s => import 'stream';

 

-> s.collect

-- io.writeln io.stdout

 

{{out}}

 

=={{header|Wrapl}}==

<tt>a</tt> will be the list <tt>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]</tt>

<tt>e</tt> will be the list <tt>[2, 4, 6, 8, 10]</tt>

 

=={{header|XPL0}}==

There is no 'sizeof' operator, unfortunately.

 

 

proc Filter(A, B, Option); \Select all even numbers from array A

[IntOut(0, Array(I)); ChOut(0, ^ )];

CrLf(0);

 

{{out}}

<pre>

</pre>

 

=={{header|XQuery}}==

(: Sequence of numbers from 1 to 10 :)

let $array := (1 to 10)

<long>{$long}</long>

</result>

 

{{out}}

<?xml version="1.0" encoding="UTF-8"?>

<result>

<long>2 4 6 8 10</long>

</result>

 

=={{header|XSLT}}==

<xsl:value-of select="@value" />

 

=={{header|zkl}}==

.filter(fcn(n){(0).isType(n) and n.isOdd})

 

=={{header|ZX Spectrum Basic}}==

20 DIM a(items)

30 FOR i=1 TO items

120 NEXT i

130 DIM a(1): REM To free memory (well, almost all)