Rosetta Code

Filter: Difference between revisions

Page Discussion

Filter (view source)

Revision as of 01:41, 14 April 2024

6,892 bytes added ,  1 month ago
→‎{{header|langur}}
(add task to arm assembly raspberry pi)
 
(11 intermediate revisions by 7 users not shown)
Line 21:
<pre>
[2, 4, 6, 8, 10]
</pre>
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits <br> or android 64 bits with application Termux }}
<syntaxhighlight lang AArch64 Assembly>
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program filterdes64.s */
 
/************************************/
/* Constantes */
/************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
 
/************************************/
/* Initialized data */
/************************************/
.data
szMessResult: .asciz "Start array : "
szMessResultFil: .asciz "Filter array : "
szMessResultdest: .asciz "Same array : "
szMessStart: .asciz "Program 64 bits start.\n"
szCarriageReturn: .asciz "\n"
szFiller: .asciz " "
.align 4
arrayNumber: .quad 1,2,3,4,5,6,7,8,9,10
.equ LGARRAY, (. - arrayNumber) / 8
/************************************/
/* UnInitialized data */
/************************************/
.bss
.align 4
arrayNumberFil: .skip 8 * LGARRAY // result array
sZoneConv: .skip 24
/************************************/
/* code section */
/************************************/
.text
.global main
main:
ldr x0,qAdrszMessStart // display start message
bl affichageMess
ldr x0,qAdrszMessResult // display message
bl affichageMess
ldr x5,qAdrarrayNumber // start array address
mov x4,#0 // index
1:
ldr x0,[x5,x4,lsl #3] // load a value
ldr x1,qAdrsZoneConv
bl conversion10 // décimal conversion
ldr x0,qAdrsZoneConv
bl affichageMess // display value
ldr x0,qAdrszFiller
bl affichageMess
add x4,x4,#1 // increment index
cmp x4,#LGARRAY // end array ?
blt 1b // no -> loop
ldr x0,qAdrszCarriageReturn
bl affichageMess
ldr x6,qAdrarrayNumberFil // adrress result array
mov x4,#0 // index
mov x3,#0 // index result
2:
ldr x0,[x5,x4,lsl #3] // load a value
tst x0,#1 // odd ?
bne 3f
str x0,[x6,x3,lsl #3] // no -> store in result array
add x3,x3,#1 // and increment result index
3:
add x4,x4,#1 // increment array index
cmp x4,#LGARRAY // end ?
blt 2b // no -> loop
ldr x0,qAdrszMessResultFil
bl affichageMess
mov x4,#0 // init index
4: // display filter result array
ldr x0,[x6,x4,lsl #3]
ldr x1,qAdrsZoneConv
bl conversion10
ldr x0,qAdrsZoneConv
bl affichageMess
ldr x0,qAdrszFiller
bl affichageMess
add x4,x4,#1
cmp x4,x3
blt 4b
ldr x0,qAdrszCarriageReturn
bl affichageMess
// array destruction
mov x4,#0 // index
mov x3,#0 // index result
5:
ldr x0,[x5,x4,lsl #3] // load a value
tst x0,#1 // odd ?
bne 7f
cmp x3,x4 // index = no store
beq 6f
str x0,[x5,x3,lsl #3] // store in free item on same array
6:
add x3,x3,#1 // and increment result index
7:
add x4,x4,#1 // increment array index
cmp x4,#LGARRAY // end ?
blt 5b // no -> loop
ldr x0,qAdrszMessResultdest
bl affichageMess
mov x4,#0 // init index
8: // display array
ldr x0,[x5,x4,lsl #3]
ldr x1,qAdrsZoneConv
bl conversion10
ldr x0,qAdrsZoneConv
bl affichageMess
ldr x0,qAdrszFiller
bl affichageMess
add x4,x4,#1
cmp x4,x3
blt 8b
ldr x0,qAdrszCarriageReturn
bl affichageMess
 
100: // standard end of the program
mov x0, #0 // return code
mov x8, #EXIT // request to exit program
svc 0 // perform the system call
qAdrszCarriageReturn: .quad szCarriageReturn
qAdrszMessStart: .quad szMessStart
qAdrarrayNumber: .quad arrayNumber
qAdrszMessResult: .quad szMessResult
qAdrarrayNumberFil: .quad arrayNumberFil
qAdrszMessResultFil: .quad szMessResultFil
qAdrszMessResultdest: .quad szMessResultdest
qAdrsZoneConv: .quad sZoneConv
qAdrszFiller: .quad szFiller
/***************************************************/
/* ROUTINES INCLUDE */
/***************************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeARM64.inc"
 
 
</syntaxhighlight>
{{Out}}
<pre>
Program 64 bits start.
Start array : 1 2 3 4 5 6 7 8 9 10
Filter array : 2 4 6 8 10
Same array : 2 4 6 8 10
</pre>
 
Line 1,411 ⟶ 1,566:
auto array := new int[]{1,2,3,4,5};
 
var evens := array.filterBy::(n => n.mod:(2) == 0).toArray();
 
evens.forEach:(printingLn)
}</syntaxhighlight>
Using strong typed collections and extensions:
Line 1,426 ⟶ 1,581:
 
array
.filterBy::(int n => n.mod:(2) == 0)
.forEach::(int i){ console.printLine(i) }
}</syntaxhighlight>
{{out}}
Line 1,720 ⟶ 1,875:
filter (fn x => x%2 == 0) as
</syntaxhighlight>
 
=={{header|FutureBasic}}==
Even elements from array added to new array.
<syntaxhighlight lang="futurebasic">
include "NSLog.incl"
 
local fn EvenNumbersFromArrayToNewArray
CFArrayRef numbersArray = @[@1,@2,@3,@4,@5,@6,@7,@8,@9,@10,@11,@12]
PredicateRef isEvenPred = fn PredicateWithFormat( @"modulus:by:(SELF, 2) == 0" )
CFArrayRef evensArray = fn ArrayFilteredArrayUsingPredicate( numbersArray, isEvenPred )
NSLog( @"Array of odd and even numbers before sort:\n\t%@\n", numbersArray )
NSLog( @"New array of even numbers after sort:\n\t%@\n", evensArray )
end fn
fn EvenNumbersFromArrayToNewArray
NSLogScrollToTop
</syntaxhighlight>
Destructive version: Odd elemnts removed from mutable array.
<syntaxhighlight>
local fn OddNumbersRemovedFromArray
CFMutablearrayRef mutableNumbersArray = fn MutableArrayWithArray( @[@1,@2,@3,@4,@5,@6,@7,@8,@9,@10,@11,@12] )
NSLog( @"Mutable array of odd and even numbers before sort:\n\t%@\n", mutableNumbersArray )
PredicateRef isEvenPred = fn PredicateWithFormat( @"modulus:by:(SELF, 2) == 0" )
MutableArrayFilterUsingPredicate( mutableNumbersArray, isEvenPred )
NSLog( @"Mutable array with odd numbers removed:\n\t%@\n", mutableNumbersArray )
end fn
 
fn OddNumbersRemovedFromArray
NSLogScrollToTop
 
HandleEvents
</syntaxhighlight>
{{output}}
<pre style="height:20ex;">
 
Array of odd and even numbers before sort:
(
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12
)
 
New array of even numbers after sort:
(
2,
4,
6,
8,
10,
12
)
 
Mutable array of odd and even numbers before sort:
(
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12
)
 
Mutable array with odd numbers removed:
(
2,
4,
6,
8,
10,
12
)
</pre>
 
 
 
 
=={{header|Gambas}}==
Line 2,144 ⟶ 2,388:
 
=={{header|langur}}==
Using the filter() function filters by a function or regex and returns ana arraylist of values.
 
<syntaxhighlight lang="langur">val .list = series 7
{{works with|langur|0.11}}
<syntaxhighlight lang="langur">val .arr = series 7
 
writeln " array list: ", .arrlist
writeln "filtered: ", filter ffn{div 2}, .arr</syntaxhighlight>list
</syntaxhighlight>
 
{{out}}
<pre> array list: [1, 2, 3, 4, 5, 6, 7]
filtered: [2, 4, 6]</pre>
 
Line 3,794 ⟶ 4,038:
 
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">var arr = [1,2,3,4,5];
 
# Creates a new array
var new = arr.grep {|i| i.is_even %% 2};
say new.dump; # => [2, 4]
 
# Destructive (at variable level)
arr.grep! {|i| i.is_even %% 2};
say arr.dump; # => [2, 4]</syntaxhighlight>
 
=={{header|Slate}}==
Line 4,249 ⟶ 4,493:
 
=={{header|V (Vlang)}}==
<syntaxhighlight lang="v (vlang)">fn reduce(mut a []int){
fn reduce(mut a []int){
mut last := 0
for e in a {
if e % 2 == 0 {
a[last] = e
last++
}
}
a = a[..last].clone()
}
fn main() {
mut nums := [5, 4, 8, 2, 4, 6, 5, 6, 34, 12, 21]
even := nums.filter(it % 2 == 0)
println('orig: ${nums}')
println('even: ${even}')
reduce(mut nums)
println('dest: ${nums}')
}
}</syntaxhighlight>
</syntaxhighlight>
{{out}}
<pre>
<pre>orig: [5,4,8,2,4,6,5,6,34,12,21]
orig: [5, 4, 8, 2, 4, 6, 5, 6, 34, 12, 21]
even: [4, 8, 2, 4, 6, 6, 34, 12]
dest: [4, 8, 2, 4, 6, 6, 34, 12]</pre>
</pre>
 
=={{header|WDTE}}==
Line 4,294 ⟶ 4,542:
 
=={{header|Wren}}==
<syntaxhighlight lang="ecmascriptwren">var a = [1, 4, 17, 8, -21, 6, -11, -2, 18, 31]
System.print("The original array is : %(a)")
 
Langurmonkey
890

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/346804...363582"