Filter
From Rosetta Code
You are encouraged to solve this task according to the task description, using any language you may know.
Select certain elements from an Array into a new Array in a generic way. To demonstrate, select all even numbers from an Array.
[edit] ActionScript
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]);
}
[edit] Ada
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;
Here is a non-recursive solution:
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;
[edit] ALGOL 68
Works with: ALGOL 68 version Standard - no extensions to language used Works with: ALGOL 68G version Any - tested with release mk15-0.8b.fc9.i386 Works with: ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386
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))
Output:
+2 +4 +6 +8 +10
+4 +16 +36 +64 +100
[edit] AmigaE
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
[edit] AppleScript
set array to {1, 2, 3, 4, 5, 6}Result is (a list):
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
{2, 4, 6}
[edit] AutoHotkey
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)
}
[edit] AWK
In this example, an array is filled with the numbers 1..9. In a loop, even elements are collected into the string r. Note that sequence is not necessarily maintained.
$ 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
[edit] C
int arr[5] = {1,2,3,4,5};
int *result;
int memoryReqd = 0,length = sizeof(arr)/sizeof(arr[0]), i,j;
for (i=0; i<length; i++)
{
if(0 == arr[i]%2)
{
memoryReqd++;
}
}
result = malloc(memoryReqd*sizeof(int));
for(i=0,j=0; i<length; i++)
{
if(0 == arr[i]%2)
{
result[j++]=arr[i];
}
}
Test our resultant array:
for(i=0; i<memoryReqd; i++)
{
printf("%d\n",result[i]);
}
[edit] C++
#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;
}
[edit] C#
Works with: .NET version 1.1
ArrayList array = new ArrayList( new int[] { 1, 2, 3, 4, 5 } );
ArrayList evens = new ArrayList();
foreach( int i in array )
{
if( (i%2) == 0 )
evens.Add( i );
}
foreach( int i in evens )
System.Console.WriteLine( i.ToString() );
Works with: .NET version 2.0
List<int> array = new List<int>( new int[] { 1, 2, 3, 4, 5 } );
List<int> evens = array.FindAll( delegate( int i ) { return (i%2)==0; } );
foreach( int i in evens )
System.Console.WriteLine( i.ToString() );
Works with: .NET version 3.5
IEnumerable<int> array = new List<int>( new int[] { 1, 2, 3, 4, 5 } );
IEnumerable<int> evens = array.Where( delegate( int i ) { return (i%2)==0; } );
foreach( int i in evens )
System.Console.WriteLine( i.ToString() );
Replacing the delegate with the more concise lambda expression syntax.
int[] array = { 1, 2, 3, 4, 5 };
int[] evens = array.Where(i => (i % 2) == 0).ToArray();
foreach (int i in evens)
Console.WriteLine(i);
[edit] 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.
module SelectFromArray
import StdEnv
Create a lazy array where each element comes from the list 1 to 10.
array :: {Int}
array = {x \\ x <- [1 .. 10]}
Create (and print) a strict array where each element (coming from another array) is even.
Start :: {!Int}
Start = {x \\ x <-: array | isEven x}
[edit] Clojure
;; 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))))
[edit] Common Lisp
Common Lisp has many ways of accomplishing this task. Most of them involve higher-order sequence functions that take a predicate as the first argument and a list as the second argument. A predicate is a function that returns a boolean. The higher-order functions call the predicate for each element in list, testing the element.
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:
(remove-if-not #'evenp '(1 2 3 4 5 6 7 8 9 10))
> (2 4 6 8 10)
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:
(delete-if-not #'evenp '(1 2 3 4 5 6 7 8 9 10))
> (2 4 6 8 10)
[edit] D
Library: Tango
import tango.core.Array;
import 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
}
Output:
Evens - [ 2, 4, 6, 8, 10 ] Odds - [ 1, 3, 5, 7, 9 ]
[edit] E
There are several ways this could be done.
pragma.enable("accumulator")
accum [] for x ? (x %% 2 <=> 0) in [1,2,3,4,5,6,7,8,9,10] { _.with(x) }
var result := []
for x ? (x %% 2 <=> 0) in [1,2,3,4,5,6,7,8,9,10] {
result with= x
}
result
def makeSeries := <elang:control.makeSeries>
makeSeries([1,2,3,4,5,6,7,8,9,10]).filter(fn x,_{x %% 2 <=> 0}).asList()
[edit] Erlang
Numbers = lists:seq(1, 5).
EvenNumbers = lists:filter(fun (X) -> X rem 2 == 0 end, Numbers).
Or using a list comprehension:
EvenNumbers = [X || X <- Numbers, X rem 2 == 0].
[edit] F#
let evenList = List.filter (fun i -> i%2 = 0 )
let evenList2 = fun list -> [for i in list do if i%2=0 then yield i]
let evenArray = Array.filter (fun i -> i%2 = 0 )
let evenSeq = fun list -> seq { for i in list do if i%2=0 then yield i}
[edit] Factor
10 iota >array [ even? ] filter .
[edit] Forth
: 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
[edit] Fortran
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
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
[edit] Groovy
def evens = [1, 2, 3, 4, 5].findAll{it % 2 == 0}
[edit] Haskell
In Haskell, a list is often more basic than an array:
ary = [1..10]
evens = [x | x <- ary, even x]
or
evens = filter even ary
To do the same operation on an array, the simplest way it to convert it lazily into a list:
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]
Note that the bounds must be known before creating the array, so the temporary list will be fully evaluated before the array is created.
[edit] IDL
The where() function can select elements on any logical expression. For example
result = array[where(NOT array AND 1)]
[edit] Icon and Unicon
[edit] Icon
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
[edit] Unicon
The Icon solution works in Unicon.
[edit] J
Solution:
With any verb (function) f that returns a boolean for each element of a vector v, the following is the generic solution:
(#~ f) v
Examples:
] 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
Or using the generic form suggested above:
isEven=: 0 = 2&| NB. verb testing for even numbers
(#~ isEven) v
92 92 36 40 16 2 22
We might decide that we use this pattern so often that it is worthwhile creating a new adverb select that filters an array using the verb to its left.
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
[edit] Java
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]);
[edit] JavaScript
The standard way is to use the Array.prototype.filter function (Works with: JavaScript version 1.6):
var arr = [1,2,3,4,5];
var evens = arr.filter(function(a) {return a % 2 == 0});
Other ways:
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]);
Works with: Firefox version 2.0
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)];
Library: Functional
Functional.select("+1&1", [1,2,3,4]) // [2, 4]
[edit] Liberty BASIC
' 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
[edit] Lisaac
+ 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;
};
};
[edit] Logo
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]
[edit] Lua
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)))
[edit] Mathematica
Check for even integers:
Select[{4, 5, Pi, 2, 1.3, 7, 6, 8.0}, EvenQ]
gives:
{4, 2, 6}
To check also for approximate number (like 8.0 in the example above) a possible solution is:
Select[{4, 5, Pi, 2, 1.3, 7, 6, 8.0}, Mod[#, 2] == 0 &]
gives:
{4, 2, 6, 8.}
notice that the function returns 8. not 8 (the dot indicates that it is a float number, not an integer).
[edit] MAXScript
arr = #(1, 2, 3, 4, 5, 6, 7, 8, 9)
newArr = for i in arr where (mod i 2 == 0) collect i
[edit] MUMPS
FILTERARRAYTesting:
;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
WRITE A(1)=1 A(2)=2 A(3)=3 A(4)=4 A(5)=5 A(6)=6 A(7)=7 A(8)=8 A(9)=9 A(10)=10 B(1)=2 B(2)=4 B(3)=6 B(4)=8 B(5)=10 I=10 J=5
[edit] Nial
filter (= [0 first, mod [first, 2 first] ] ) 0 1 2 3 4 5 6 7 8 9 10
=0 2 4 6 8 10
[edit] Objective-C
Works with: Mac OS X version 10.5
NSArray *numbers = [NSArray arrayWithObjects:[NSNumber numberWithInt:1],
[NSNumber numberWithInt:2],
[NSNumber numberWithInt:3],
[NSNumber numberWithInt:4],
[NSNumber numberWithInt:5], nil];
NSPredicate *isEven = [NSPredicate predicateWithFormat:@"modulus:by:(SELF, 2) == 0"];
NSArray *evens = [numbers filteredArrayUsingPredicate:isEven];
Works with: GNUstep
#import <Foundation/Foundation.h>
@interface NSNumber ( ExtFunc )
-(int) modulo2;
@end
@implementation NSNumber ( ExtFunc )
-(int) modulo2
{
return [self intValue] % 2;
}
@end
int main()
{
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
NSArray *numbers = [NSArray arrayWithObjects:[NSNumber numberWithInt:1],
[NSNumber numberWithInt:2],
[NSNumber numberWithInt:3],
[NSNumber numberWithInt:4],
[NSNumber numberWithInt:5], nil];
NSPredicate *isEven = [NSPredicate predicateWithFormat:@"modulo2 == 0"];
NSArray *evens = [numbers filteredArrayUsingPredicate:isEven];
NSLog(@"%@", evens);
[pool release];
return 0;
}
[edit] Objeck
use Structure;
bundle Default {
class Evens {
function : Main(args : String[]) ~ Nil {
values := IntVector->New([1, 2, 3, 4, 5]);
f := Filter(Int) ~ Bool;
evens := values->Filter(f);
each(i : evens) {
evens->Get(i)->PrintLine();
};
}
function : Filter(v : Int) ~ Bool {
return v % 2 = 0;
}
}
}
[edit] OCaml
It is easier to do it with a list:
let lst = [1;2;3;4;5;6]
let even_lst = List.filter (fun x -> x mod 2 = 0) lst
[edit] Octave
arr = [1:100];
evennums = arr( mod(arr, 2) == 0 );
disp(evennums);
[edit] Oz
It is easier to do it with a list:
declare
Lst = [1 2 3 4 5]
LstEven = {Filter Lst IsEven}
[edit] Pascal
Arrays are supported in all versions of pascal so this simple example will cover the entire gamut.
Works with: Delphi
Works with: Turbo Pascal
const
numbers:array[0..9] of integer = (0,1,2,3,4,5,6,7,8,9);
for x = 1 to 10 do
if odd(numbers[x]) then
writeln( 'The number ',numbers[x],' is odd.');
else
writeln( 'The number ',numbers[x],' is even.');
The odd() function is a standard library function of pascal as is the function even().
[edit] Perl
my @a = (1, 2, 3, 4, 5, 6);
my @even = grep { $_%2 == 0 } @a;
[edit] Perl 6
Works with: Rakudo Star version 2010-08
my @a = 1, 2, 3, 4, 5, 6;
my @even = grep * %% 2, @a;
Alternatively:
my @even = @a.grep(* %% 2);
[edit] PHP
Using a standard loop
$arr = range(1,5);
$evens = array();
foreach ($arr as $val){
if ($val % 2 == 0) $evens[] = $val);
}
print_r($evens);
Using a filter function
function is_even($var) { return(!($var & 1)); }
$arr = range(1,5);
$evens = array_filter($arr, "is_even");
print_r($evens);
[edit] PicoLisp
(filter '((N) (not (bit? 1 N)))
(1 2 3 4 5 6 7 8 9) )
Output:
-> (2 4 6 8)
[edit] 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:
;;; Generic filtering procedure which selects from ar elements
;;; satisfying pred
define filter_array(ar, pred);
lvars i, k;
stacklength() -> k;
for i from 1 to length(ar) do
;;; if element satisfies pred we leave it on the stack
if pred(ar(i)) then ar(i) endif;
endfor;
;;; Collect elements from the stack into a vector
return (consvector(stacklength() - k));
enddefine;
;;; Use it
filter_array({1, 2, 3, 4, 5},
procedure(x); not(testbit(x, 0)); endprocedure) =>
[edit] PowerShell
$array = -15..37
$array | Where-Object { $_ % 2 -eq 0 }
[edit] Prolog
evens(D, Es) :- findall(E, (member(E, D), E mod 2 =:= 0), Es).
Usage:
?- evens([1,2,3,4,5,6,7,8,9,10],E).
E = [2, 4, 6, 8, 10]
[edit] PureBasic
Dim Tal.i(9)
Dim Evens.i(0)
;- Set up an array with random numbers
For i=0 To ArraySize(Tal())
Tal(i)=Random(100)
Next
;- Pick out all Even and save them
j=0
For i=0 To ArraySize(Tal())
If Tal(i)%2=0
ReDim Evens(j) ; extend the Array as we find new Even's
Evens(j)=tal(i)
j+1
EndIf
Next
;- Display the result
PrintN("List of Randoms")
For i=0 To ArraySize(Tal())
Print(Str(Tal(i))+" ")
Next
PrintN(#CRLF$+#CRLF$+"List of Even(s)")
For i=0 To ArraySize(Evens())
Print(Str(Evens(i))+" ")
Next
Output can look like
List of Randoms 32 35 89 91 11 33 12 22 42 43 List of Even(s) 32 12 22 42
[edit] Python
Works with: Python version 2.4
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)
Alternative using the slice syntax with its optional "stride" expression:
values = range(10)
evens = values[::2]
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.
Since strings in Python can be treated as a sort of immutable list of characters then the slicing and extended slicing can also be used with them as well. Thus mystring[::-2] will return every other character from the reverse order of the string.
One can also assign to a slice (of a list or other mutable indexed object. Thus the following:
values = range(10)
values[::2] = [11,13,15,17,19]
print values
11, 1, 13, 3, 15, 5, 17, 7, 19, 9
[edit] R
a <- 1:100
evennums <- a[ a%%2 == 0 ]
print(evennums)
[edit] Raven
[ 0 1 2 3 4 5 6 7 8 9 ] as nums
group nums each
dup 1 & if drop
list as evens
[edit] REBOL
a: [] repeat i 100 [append a i] ; Build and load array.
evens: [] repeat element a [if even? element [append evens element]]
print mold evens
Output:
[2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50 52 54 56 58 60 62 64 66 68 70 72 74 76 78 80 82 84 86 88 90 92 94 96 98 100]
[edit] Ruby
ary = [1,2,3,4,5,6] #or ary = (1..6).to_a
even_ary = ary.select {|elem| elem.even?}
# => [2, 4, 6]
[edit] Sather
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;
[edit] Seed7
var array integer: arr is [] (1, 2, 3, 4, 5);
var array integer: evens is 0 times 0;
var integer: number is 0;
for number range arr do
if not odd(number) then
evens &:= [] (number);
end if;
end for;
[edit] Scala
(1 to 100).filter(_ % 2 == 0)
[edit] Scheme
In the interactive prompt:
> (filter even? '(1 2 3 4 5 6 7 8 9 10))
(2 4 6 8 10)
Or as a function:
(define (select-even lst)
(filter even? lst))
(select-even '(1 2 3 4 5 6 7 8 9 10))
[edit] Slate
#(1 2 3 4 5) select: [| :number | number isEven].
[edit] Smalltalk
#(1 2 3 4 5) select: [:number | number even]
[edit] SQL
Task: Select certain elements from an Array into a new Array in a generic way. To demonstrate, select all even numbers from an Array.
Works with: MS SQL
--Create the original array (table #nos) with numbers from 1 to 10
CREATE TABLE #nos (v INT)
DECLARE @n INT SET @n=1
while @n<=10 BEGIN INSERT INTO #nos VALUES (@n) SET @n=@n+1 END
--Select the subset that are even into the new array (table #evens)
SELECT v INTO #evens FROM #nos WHERE v % 2 = 0
-- Show #evens
SELECT * FROM #evens
-- Clean up so you can edit and repeat:
DROP TABLE #nos
DROP TABLE #evens
'Works with: MySQL
CREATE TEMPORARY TABLE nos (v INT);
INSERT INTO nos VALUES (1),(2),(3),(4),(5),(6),(7),(8),(9),(10);
CREATE TEMPORARY TABLE evens (v INT);
INSERT INTO evens SELECT v FROM nos WHERE v%2=0;
SELECT * FROM evens ORDER BY v; /*2,4,6,8,10*/
DROP TABLE nos;
DROP TABLE evens;
Or to be shorter, you could create the table evens directly from the query result :
CREATE TEMPORARY TABLE evens SELECT * FROM nos WHERE v%2=0;
[edit] Standard ML
val ary = [1,2,3,4,5,6];
List.filter (fn x => x mod 2 = 0) ary
[edit] Tcl
Tcl doesn't really have a concept of a "number" per se - strictly speaking its only data type is the string (but a string can be interpreted as a number, of course). The generic way of getting certain elements from an array looks roughly like this:
foreach key [array names arr] {if { <condition> } then {puts $arr($key)}}
In this case, we can do this particular challenge with:
foreach {key val} [array get srcArray] {
if {[string is integer -strict $key] && !($key%2)} {
set dstArray($key) $val
}
}
If we were using Tcl's lists and interpreting the challenge to mean getting just the elements at index 0, 2, 4, ...
foreach {even odd} $srcList {
lappend dstList $even
}
[edit] Toka
10 cells is-array table
10 cells is-array even
{
variable source
[ swap source ! >r reset r> 0
[ i source @ array.get
dup 2 mod 0 <> [ drop ] ifTrue
] countedLoop
depth 0 swap [ i even array.put ] countedLoop
]
} is copy-even
10 0 [ i i table array.put ] countedLoop
table 10 copy-even
[edit] UnixPipes
yes \ | cat -n | while read a; do ; expr $a % 2 >/dev/null && echo $a ; done
[edit] Ursala
Ursala doesn't have arrays, except when the run time system transparently converts a list to an array as needed for an external math library function call. However, selection can be done on lists.
[edit] Unary predicates
The most common way to select items from a list according to a unary
predicate p is to write p*~, as shown below.
#import std
#import nat
x = <89,36,13,15,41,39,21,3,15,92,16,59,52,88,33,65,54,88,93,43>
#cast %nL
y = (not remainder\2)*~ x
The output will be
<36,92,16,52,88,54,88>
[edit] Binary predicates
Selection is so frequently useful that the language has a couple of other ways to do it. Selecting according to a binary predicate can be done like this.
z = (not remainder)~| (36,<1,2,3,4,5,6,7,8,9,10,11,12>)
The value of z will be the divisors of 36 appearing in the list.
<1,2,3,4,6,9,12>
This usage has the advantage over writing (not remainder/36)*~ with the operator
above that it allows the 36 to be part of the argument rather than
being hard coded into the function.
[edit] Operator suffixes
Many operators in Ursala allow suffixes that modify their semantics.
For example, the suffix ihB on the identity function ~& makes it
~&ihB, a predicate to detect odd numbers by inspecting the binary
representation. If an operator with this kind of suffix is further
modified by appending an F, it becomes a selection filter.
For example
shortcut = ~&ihBF x
using the x defined above will evaluate to
<89,13,15,41,39,21,3,15,59,33,65,93,43>
There are also suffixes corresponding to the ~| operator.
[edit] V
[even? dup 2 / >int 2 * - zero?].
[1 2 3 4 5 6 7 8 9] [even?] filter
=[2 4 6 8]
[edit] Wrapl
VAR l <- ALL 1:to(10);
l will be the list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
VAR m <- ALL l:values \ $ % 2 = 0;
m will be the list [2, 4, 6, 8, 10]
[edit] XSLT
<xsl:for-each select="nodes[@value mod 2 = 0]">
<xsl:value-of select="@value" />
</xsl:for-each>
[edit] XQuery
(: Sequence of numbers from 1 to 10 :)
let $array := (1 to 10)
(: Short version :)
let $short := $array[. mod 2 = 0]
(: Long version with a FLWOR expression :)
let $long := for $value in $array
where $value mod 2 = 0
return $value
(: Show the results :)
return
<result>
<short>{$short}</short>
<long>{$short}</long>
</result>
The output of this query is:
<?xml version="1.0" encoding="UTF-8"?>
<result>
<short>2 4 6 8 10</short>
<long>2 4 6 8 10</long>
</result>
