Filter: Difference between revisions

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

 

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

 

{{out}}

 

=={{header|ACL2}}==

(cond ((endp xs) nil)

((evenp (first xs))

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

 

=={{header|Action!}}==

 

INT value ;used in predicate

PrintE("Select all non negative numbers:")

PrintArray(src,srcSize)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Filter.png Screenshot from Atari 8-bit computer]

 

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

 

begin

Print(Evens(Foo));

Here is a non-recursive solution:

 

procedure Array_Selection is

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

 

PROC select = ([]TYPE from, PROC(TYPE)BOOL where)[]TYPE:

 

# Or as a simple one line query #

{{out}}

<pre>

In the sample below, the ''select'' procedure's parameters do not include the parameters of ''where'' - they are commented out.<br>

Recent compilers (such as Awe) require the parameter types be specified and so the parameters to ''where'' should be uncommented when compilling with Awe.

% sets the elements of out to the elements of in that return true from applying the where procedure to them %

% the bounds of in must be 1 :: inUb - out must be at least as big as in and the number of matching %

write()

end.

{{out}}

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

 

 

-- filter :: (a -> Bool) -> [a] -> [a]

end script

end if

{{Out}}

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

 

=={{header|Arturo}}==

 

 

{{out}}

 

=={{header|AutoHotkey}}==

loop, parse, array, `,

{

 

 

 

=={{header|AWK}}==

 

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

 

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

items% = 1000

DIM array%(items%)

END

 

 

=={{header|BCPL}}==

 

// Copy every value for which p(x) is true from in to out

writevec(arr, len)

wrch('*N')

{{out}}

<pre>Numbers: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

 

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

General filtering is done using the <code>/</code>(Replicate) function, which can fliter elements given a bitmask. We can make a modifier based on it to accept a function for filtering.

 

Odd ← 2⊸|

 

 

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

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

 

# Cowgol has strict typing and there are no templates either.

i := i + 1;

end loop;

{{out}}

<pre>2 4 6 8 10

 

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

===Hand-coded version===

 

{$APPTYPE CONSOLE}

Write(i:3);

Writeln;

 

 

{{libheader| Types}}

{{libheader| Boost.Int}}

 

{$APPTYPE CONSOLE}

Writeln('[' + Source.Comma + ']');

End.

 

{{out}}

 

===Non-destructively===

var arr = []

for x in this when pred(x) {

 

var arr = [1..20].Filter(x => x % 2 == 0)

 

{{out}}

 

===Destructively===

var i = 0

while i < this.Length() {

var arr = [1..20]

arr.Filter(x => x % 2 == 0)

 

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

 

var arr = xs.Iterate().Filter(x => x % 2 == 0).Map(x => x.ToString())

 

{{out}}

 

===Non-destructively===

]

for value in copy lst:

= 0 % x 2

 

 

{{out}}

 

===Destructively===

 

filter-destructively pred lst:

filter-destructively @even lst

 

 

{{out}}

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

 

for i range len a[]

if a[i] mod 2 = 0

.

.

 

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

 

evens.forEach:printingLn

Using strong typed collections and extensions:

import system'routines'stex;

import system'math;

.filterBy:(int n => n.mod:2 == 0)

.forEach:(int i){ console.printLine(i) }

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

end function filterwith

 

 

=={{header|FreeBASIC}}==

 

Type FilterType As Function(As Integer) As Boolean

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

 

Filtered([1 .. 100], IsPrime);

 

Filtered([1 .. 10], IsOddInt);

 

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

 

 

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

{{works with|Julia|0.6}}

 

 

{{out}}

 

=={{header|K}}==

even:{0=x!2}

even 1 2 3 4 5

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

=={{header|Lambdatalk}}==

 

 

{def filter

-> 1 3 5 7 9 11 13 15 17 19

 

 

=={{header|Lang5}}==

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

 

 

=={{header|langur}}==

 

{{works with|langur|0.8.1}}

 

writeln " array: ", .arr

 

{{out}}

 

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

}

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

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

return ry

{{out}}

<pre>

 

=={{header|NewLISP}}==

(2 4 6 8 10)

 

=={{header|NGS}}==

 

 

=={{header|Nial}}==

 

=={{header|Nim}}==

 

let values = toSeq(0..9)

var v2 = toSeq(0..9)

v2.keepItIf(it mod 2 != 0)

 

{{out}}

 

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

[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|Ol}}==

(filter even? '(1 2 3 4 5 6 7 8 9 10))

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

{{libheader|Phix/basics}}

===basic task===

<span style="color: #008080;">function</span> <span style="color: #000000;">even<span style="color: #0000FF;">(<span style="color: #004080;">integer</span> <span style="color: #000000;">i<span style="color: #0000FF;">)</span>

<span style="color: #008080;">return</span> <span style="color: #7060A8;">remainder<span style="color: #0000FF;">(<span style="color: #000000;">i<span style="color: #0000FF;">,<span style="color: #000000;">2<span style="color: #0000FF;">)<span style="color: #0000FF;">=<span style="color: #000000;">0</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>

<span style="color: #0000FF;">?<span style="color: #7060A8;">filter<span style="color: #0000FF;">(<span style="color: #7060A8;">tagset<span style="color: #0000FF;">(<span style="color: #000000;">10<span style="color: #0000FF;">)<span style="color: #0000FF;">,<span style="color: #000000;">even<span style="color: #0000FF;">)

{{out}}

<pre>

The following discusses possible destructive/in situ behaviours (in excruciatingly painstaking detail). Phix is reference counted so the distinction between destructive and

non-destructive is somewhat subtle. The following code (builtin filter routine) acts both ways.

<span style="color: #008080;">function</span> <span style="color: #000000;">even<span style="color: #0000FF;">(<span style="color: #004080;">integer</span> <span style="color: #000000;">i<span style="color: #0000FF;">)</span>

<span style="color: #008080;">return</span> <span style="color: #7060A8;">remainder<span style="color: #0000FF;">(<span style="color: #000000;">i<span style="color: #0000FF;">,<span style="color: #000000;">2<span style="color: #0000FF;">)<span style="color: #0000FF;">=<span style="color: #000000;">0</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>

<span style="color: #000000;">main<span style="color: #0000FF;">(<span style="color: #0000FF;">)

{{out}}

<pre>

</pre>

It will help to explain what is going on by looking at a couple of longhand (and greatly simplified) versions, first an explicitly non-destructive one

<span style="color: #008080;">function</span> <span style="color: #000000;">lhnd_filter<span style="color: #0000FF;">(<span style="color: #004080;">sequence</span> <span style="color: #000000;">a<span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">fn<span style="color: #0000FF;">)</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{<span style="color: #0000FF;">}</span>

<span style="color: #008080;">return</span> <span style="color: #000000;">res</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">function

Clearly the above is non-destructive. It makes no attempt to modify a, but builds a new result, and it is fair to say that in some cases the above may be the fastest approach due to fewer reference count updates. However the following may or may not be destructive:

<span style="color: #008080;">function</span> <span style="color: #000000;">lhd_filter<span style="color: #0000FF;">(<span style="color: #004080;">sequence</span> <span style="color: #000000;">a<span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">fn<span style="color: #0000FF;">)</span>

<span style="color: #004080;">integer</span> <span style="color: #000000;">l</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>

<span style="color: #000000;">main<span style="color: #0000FF;">(<span style="color: #0000FF;">)

In the t = lhd_filter(s) call, s is preserved because of copy-on-write semantics. Modifying a does not modify s, because it has a reference count of 2 the first attempt to modify it triggers copy-on-write and safely makes a top-level copy. In the s = lhd_filter(s) call however, s is automatically passed by reference, ie the local s is <no value> over the duration of the call and parameter a of lhd_filter() contains the only reference to the previous content of s, and no copy-on-write occurs. Technically modifying a is still not modifying s, but since it has a reference count of 1 it modifies the data that used to be referenced by s, and will again rsn, in situ.

Note: adding t = s before the s = lhd_filter(s) call would make it non-destructive again, as t must be preserved and there is now a reference count >1 on that data. Also note that automatic pass-by-reference only occurs for routine-local variables.

=={{header|PHL}}==

 

 

extern printf;

 

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

List comprehension is probably the best way of filtering:

 

A more general version of filtering is to use <code>call/1</code> with a defined predicate (here <code>p/1</code>):

L = 1..20,

A = filter(L,p).

p(N) => N mod 2 == 0.

 

 

This general version might be slower since using <code>call/1</code> has some overhead.

 

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

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

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

=={{header|Quackery}}==

 

witheach

[ tuck over do iff

[] 10 times [ 10 random join ]

say "Ten arbitrary digits: " dup echo cr

 

{{out}}

===Destructively===

 

[ over i peek

over do if

[] 10 times [ i join ] shuffle

say "Ten shuffled digits: " dup echo cr

 

{{out}}

 

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

{{works with|Rakudo|2018.03}}

 

 

Alternatively:

 

 

Destructive:

 

 

=={{header|Raven}}==

group nums each

dup 1 & if drop

 

=={{header|REBOL}}==

 

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

 

 

{{out}}

 

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

===using two arrays===

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

parse arg N seed . /*obtain optional arguments from the CL*/

if N=='' | N=="," then N= 50 /*Not specified? Then use the default.*/

do k=1 for # /*display all the NEW numbers. */

say right('new.'k, 20) "=" right(new.k, 9) /*display a line (an array element). */

Programming note: &nbsp; the REXX statement

could've been replaced with

but that would've assumed the numbers are integers &nbsp; (no matter what form they're expressed in).<br>

As it happens, the REXX program uses the numbers generated from the &nbsp; '''random''' &nbsp; BIF, &nbsp; which are integers.

===using one array with a control array===

This version uses a control array, which isn't fully populated &nbsp; (in REXX terms, a sparse array.)

parse arg N seed . /*obtain optional arguments from the CL*/

if N=='' | N=="," then N= 50 /*Not specified? Then use the default.*/

if !.k then iterate /*if it's marked as not even, skip it.*/

say right('array.'k, 20) "=" right(@.k, 9) /*display a even number, filtered array*/

For the following input: &nbsp; &nbsp; <tt> , 1234567 </tt>

 

 

This method doesn't need as much memory to hold the sparse array.

parse arg N seed . /*obtain optional arguments from the CL*/

if N=='' | N=="," then N= 50 /*Not specified? Then use the default.*/

if @.k=='' then iterate /*if it's marked not even, then skip it*/

say right('array.'k, 20) "=" right(@.k, 9) /*display a line (an array element). */

For the following input: &nbsp; &nbsp; <tt> , 1234567 </tt>

 

 

=={{header|Ring}}==

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

bArray = list(3)

next

return bArray

 

=={{header|Ruby}}==

Enumerable#select is the filter that returns a new Array.

 

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

Array#select! is the destructive version which modifies the original Array.

 

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

 

Shorthand:

 

ary.select!(&:even?)

 

=={{header|Run BASIC}}==

count = 100

for i = 1 to 100

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

Filter function definition:

(define filter

(lambda (fn lst)

(iter rest (cons item result))

(iter rest result)))))))

Usage in the interactive prompt:

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

 

=={{header|Sidef}}==

 

# Creates a new array

# Destructive (at variable level)

arr.grep! {|i| i %% 2};

 

=={{header|Slate}}==

 

=={{header|Smalltalk}}==

Creates a new array:

or for short:

Destructive modification is not possible for literal constants (these are immutable);

in addition, Arrays are fix sized collections. It is also considered very bad style, to modify passed in arguments this way. Thus constructing a new Array object (as above) is the only correct solution.

 

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

 

Or to be shorter, you could create the table evens directly from the query result :

 

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

 

=={{header|Tcl}}==

 

{{out}}

<pre>56 62 76 82 94 28 90 52 44</pre>

<br>

Inplace way, quite the inefficient contraption compared to mapping:

upvar 1 $_list list

set list [lreplace $list[set list {}] {*}$args]

}

 

{{out}}

<pre>56 62 76 82 94 28 90 52 44</pre>

Explanation: https://wiki.tcl-lang.org/page/lreplace, section "Performance: Modifying a List In-Place"<br>

Proof by timing removal of the end element of lists of different lengths:

upvar 1 $_list list

set list [lreplace $list[set list {}] {*}$args]

puts " lreplace: [time {set l [lreplace $l end end]}]"

puts " lreplaceip: [time {lreplaceip l end end}]"

{{out}}

<pre>1e5

 

=={{header|Toka}}==

10 cells is-array even

{

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

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

 

Private Function IsEven(Number As Long) As Boolean

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

 

{{Out}}

 

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

 

=={{header|Vlang}}==

mut last := 0

for e in a {

reduce(mut nums)

println('dest: $nums')

{{out}}

<pre>orig: [5,4,8,2,4,6,5,6,34,12,21]

 

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

System.print("The original array is : %(a)")

 

System.print("\nAfter a destructive filter :-")

System.print("The even numbers are : %(evens)")

 

{{out}}

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

 

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

{{untested}}

byte 4,4 ;4 rows, 4 columns.

TestArray:

djnz loop_filterEvenValues

 

 

{{out}}

 

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