Initial data commit
This commit is contained in:
Ingy döt Net
parent
72d218235f
commit
f23f22d71c
199087 changed files with 3378941 additions and 0 deletions
3
Task/Order-two-numerical-lists/00-META.yaml
Normal file
3
Task/Order-two-numerical-lists/00-META.yaml
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
---
|
||||
from: http://rosettacode.org/wiki/Order_two_numerical_lists
|
||||
note: Sorting Algorithms
|
||||
14
Task/Order-two-numerical-lists/00-TASK.txt
Normal file
14
Task/Order-two-numerical-lists/00-TASK.txt
Normal file
|
|
@ -0,0 +1,14 @@
|
|||
{{Category:Sorting}}
|
||||
{{Sorting Algorithm}}
|
||||
|
||||
Write a function that orders two lists or arrays filled with numbers.
|
||||
The function should accept two lists as arguments and return <code>true</code> if the first list should be ordered before the second, and <code>false</code> otherwise.
|
||||
|
||||
The order is determined by [[wp:Lexicographical order#Ordering of sequences of various lengths|lexicographic order]]: Comparing the first element of each list.
|
||||
If the first elements are equal, then the second elements should be compared, and so on, until one of the list has no more elements.
|
||||
If the first list runs out of elements the result is <code>true</code>.
|
||||
If the second list or both run out of elements the result is <code>false</code>.
|
||||
|
||||
<small>Note: further clarification of lexicographical ordering is expounded on the talk page [[Talk:Order_two_numerical_lists#Lexicographic_order|here]] and [[Talk:Order_two_numerical_lists#Is_the_task_statement_consistent.3F|here]].</small>
|
||||
<br><br>
|
||||
|
||||
|
|
@ -0,0 +1 @@
|
|||
[1,2,1,3,2] < [1,2,0,4,4,0,0,0]
|
||||
|
|
@ -0,0 +1,149 @@
|
|||
/* ARM assembly AARCH64 Raspberry PI 3B */
|
||||
/* program orderlist64.s */
|
||||
|
||||
/*******************************************/
|
||||
/* Constantes file */
|
||||
/*******************************************/
|
||||
/* for this file see task include a file in language AArch64 assembly*/
|
||||
.include "../includeConstantesARM64.inc"
|
||||
|
||||
/*********************************/
|
||||
/* Initialized data */
|
||||
/*********************************/
|
||||
.data
|
||||
szMessResult1: .asciz "List1 < List2 \n" // message result
|
||||
szMessResult2: .asciz "List1 => List2 \n" // message result
|
||||
szCarriageReturn: .asciz "\n"
|
||||
|
||||
qTabList1: .quad 1,2,3,4,5
|
||||
.equ NBELEMENTS1, (. - qTabList1) /8
|
||||
qTabList2: .quad 1,2,1,5,2,2
|
||||
.equ NBELEMENTS2, (. - qTabList2) /8
|
||||
qTabList3: .quad 1,2,3,4,5
|
||||
.equ NBELEMENTS3, (. - qTabList3) /8
|
||||
qTabList4: .quad 1,2,3,4,5,6
|
||||
.equ NBELEMENTS4, (. - qTabList4) /8
|
||||
/*********************************/
|
||||
/* UnInitialized data */
|
||||
/*********************************/
|
||||
.bss
|
||||
/*********************************/
|
||||
/* code section */
|
||||
/*********************************/
|
||||
.text
|
||||
.global main
|
||||
main: // entry of program
|
||||
ldr x0,qAdriTabList1
|
||||
mov x1,NBELEMENTS1
|
||||
ldr x2,qAdriTabList2
|
||||
mov x3,NBELEMENTS2
|
||||
bl listeOrder
|
||||
cmp x0,0 // false ?
|
||||
beq 1f // yes
|
||||
ldr x0,qAdrszMessResult1 // list 1 < list 2
|
||||
bl affichageMess // display message
|
||||
b 2f
|
||||
1:
|
||||
ldr x0,qAdrszMessResult2
|
||||
bl affichageMess // display message
|
||||
|
||||
2:
|
||||
ldr x0,qAdriTabList1
|
||||
mov x1,NBELEMENTS1
|
||||
ldr x2,qAdriTabList3
|
||||
mov x3,NBELEMENTS3
|
||||
bl listeOrder
|
||||
cmp x0,0 // false ?
|
||||
beq 3f // yes
|
||||
ldr x0,qAdrszMessResult1 // list 1 < list 2
|
||||
bl affichageMess // display message
|
||||
b 4f
|
||||
3:
|
||||
ldr x0,qAdrszMessResult2
|
||||
bl affichageMess // display message
|
||||
4:
|
||||
ldr x0,qAdriTabList1
|
||||
mov x1,NBELEMENTS1
|
||||
ldr x2,qAdriTabList4
|
||||
mov x3,NBELEMENTS4
|
||||
bl listeOrder
|
||||
cmp x0,0 // false ?
|
||||
beq 5f // yes
|
||||
ldr x0,qAdrszMessResult1 // list 1 < list 2
|
||||
bl affichageMess // display message
|
||||
b 6f
|
||||
5:
|
||||
ldr x0,qAdrszMessResult2
|
||||
bl affichageMess // display message
|
||||
6:
|
||||
100: // standard end of the program
|
||||
mov x0,0 // return code
|
||||
mov x8,EXIT // request to exit program
|
||||
svc 0 // perform the system call
|
||||
qAdriTabList1: .quad qTabList1
|
||||
qAdriTabList2: .quad qTabList2
|
||||
qAdriTabList3: .quad qTabList3
|
||||
qAdriTabList4: .quad qTabList4
|
||||
qAdrszMessResult1: .quad szMessResult1
|
||||
qAdrszMessResult2: .quad szMessResult2
|
||||
qAdrszCarriageReturn: .quad szCarriageReturn
|
||||
/******************************************************************/
|
||||
/* liste order */
|
||||
/******************************************************************/
|
||||
/* x0 contains the address of list 1 */
|
||||
/* x1 contains list 1 size */
|
||||
/* x2 contains the address of list 2 */
|
||||
/* x3 contains list 2 size */
|
||||
/* x0 returns 1 if list1 < list2 */
|
||||
/* x0 returns 0 else */
|
||||
listeOrder:
|
||||
stp x1,lr,[sp,-16]! // save registers
|
||||
stp x2,x3,[sp,-16]! // save registers
|
||||
cbz x1,99f // list 1 size = zero ?
|
||||
cbz x3,98f // list 2 size = zero ?
|
||||
|
||||
mov x4,#0 // index list 1
|
||||
mov x5,#0 // index list 2
|
||||
1:
|
||||
ldr x6,[x0,x4,lsl #3] // load list 1 element
|
||||
ldr x8,[x2,x5,lsl #3] // load list 2 element
|
||||
cmp x6,x8 // compar
|
||||
bgt 4f
|
||||
beq 2f // list 1 = list 2
|
||||
add x4,x4,1 // increment index 1
|
||||
cmp x4,x1 // end list ?
|
||||
bge 5f
|
||||
b 1b // else loop
|
||||
2:
|
||||
add x4,x4,1 // increment index 1
|
||||
cmp x4,x1 // end list ?
|
||||
bge 3f // yes -> verif size
|
||||
add x5,x5,1 // else increment index 2
|
||||
cmp x5,x3 // end list 2 ?
|
||||
bge 4f
|
||||
b 1b // else loop
|
||||
3:
|
||||
cmp x1,x3 // compar size
|
||||
bge 4f // list 2 < list 1
|
||||
blt 5f // list 1 < list 2
|
||||
b 100f
|
||||
4:
|
||||
mov x0,#0 // list 1 > list 2
|
||||
b 100f
|
||||
5:
|
||||
mov x0,#1 // list 1 < list 2
|
||||
b 100f
|
||||
98: // error
|
||||
mov x0,-2
|
||||
b 100f
|
||||
99: // error
|
||||
mov x0,-1
|
||||
100:
|
||||
ldp x2,x3,[sp],16 // restaur 2 registers
|
||||
ldp x1,lr,[sp],16 // restaur 2 registers
|
||||
ret // return to address lr x30
|
||||
/********************************************************/
|
||||
/* File Include fonctions */
|
||||
/********************************************************/
|
||||
/* for this file see task include a file in language AArch64 assembly */
|
||||
.include "../includeARM64.inc"
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
BEGIN # compare lists (rows) of integers #
|
||||
# returns TRUE if there is an element in a that is < the corresponding #
|
||||
# element in b and all previous elements are equal; FALSE otherwise #
|
||||
OP < = ( []INT a, b )BOOL:
|
||||
IF INT a pos := LWB a;
|
||||
INT b pos := LWB b;
|
||||
BOOL equal := TRUE;
|
||||
WHILE a pos <= UPB a AND b pos <= UPB b AND equal DO
|
||||
equal := a[ a pos ] = b[ b pos ];
|
||||
IF equal THEN
|
||||
a pos +:= 1;
|
||||
b pos +:= 1
|
||||
FI
|
||||
OD;
|
||||
NOT equal
|
||||
THEN
|
||||
# there is an element in a and b that is not equal #
|
||||
a[ a pos ] < b[ b pos ]
|
||||
ELSE
|
||||
# all elements are equal or one list is shorter #
|
||||
# a is < b if a has fewer elements #
|
||||
a pos > UPB a AND b pos <= UPB b
|
||||
FI # < # ;
|
||||
|
||||
# tests a < b has the expected result #
|
||||
PROC test = ( STRING a name, []INT a, STRING b name, []INT b, BOOL expected )VOID:
|
||||
BEGIN
|
||||
BOOL result = a < b;
|
||||
print( ( a name, IF result THEN " < " ELSE " >= " FI, b name
|
||||
, IF result = expected THEN "" ELSE ", NOT as expected" FI
|
||||
, newline
|
||||
)
|
||||
)
|
||||
END # test # ;
|
||||
|
||||
# test cases as in the BBC basic sample #
|
||||
[]INT list1 = ( 1, 2, 1, 5, 2 );
|
||||
[]INT list2 = ( 1, 2, 1, 5, 2, 2 );
|
||||
[]INT list3 = ( 1, 2, 3, 4, 5 );
|
||||
[]INT list4 = ( 1, 2, 3, 4, 5 );
|
||||
test( "list1", list1, "list2", list2, TRUE );
|
||||
test( "list2", list2, "list3", list3, TRUE );
|
||||
test( "list3", list3, "list4", list4, FALSE );
|
||||
|
||||
# additional test cases #
|
||||
[]INT list5 = ( 9, 0, 2, 1, 0 );
|
||||
[]INT list6 = ( 4, 0, 7, 7 );
|
||||
[]INT list7 = ( 4, 0, 7 );
|
||||
[]INT list8 = ( );
|
||||
test( "list5", list5, "list6", list6, FALSE );
|
||||
test( "list6", list6, "list7", list7, FALSE );
|
||||
test( "list7", list7, "list8", list8, FALSE );
|
||||
test( "list8", list8, "list7", list7, TRUE )
|
||||
|
||||
END
|
||||
|
|
@ -0,0 +1,70 @@
|
|||
begin % compare lists (rows) of integers %
|
||||
% returns TRUE if there is an element in a that is < the corresponding %
|
||||
% element in b and all previous elements are equal, FALSE otherwise %
|
||||
% the bounds of a and b should aLb :: aUb and bLb :: bUb %
|
||||
logical procedure iLT ( integer array a ( * )
|
||||
; integer value aLb, aUb
|
||||
; integer array b ( * )
|
||||
; integer value bLb, bUb
|
||||
) ;
|
||||
begin
|
||||
integer aPos, bPos;
|
||||
logical equal;
|
||||
aPos := aLb;
|
||||
bPos := bLb;
|
||||
equal := true;
|
||||
while aPos <= aUb and bPos <= bUb and equal do begin
|
||||
equal := a( aPos ) = b( bPos );
|
||||
if equal then begin
|
||||
aPos := aPOs + 1;
|
||||
bPos := bPos + 1
|
||||
end if_equal
|
||||
end while_more_elements_and_equal ;
|
||||
if not equal
|
||||
then % there is an element in a and b that is not equal %
|
||||
a( aPos ) < b( bPos )
|
||||
else % all elements are equal or one list is shorter %
|
||||
% a is < b if a has fewer elements %
|
||||
aPos > aUb and bPos <= bUb
|
||||
end iLT ;
|
||||
% tests a < b has the expected result %
|
||||
procedure test ( string(5) value aName
|
||||
; integer array a ( * )
|
||||
; integer value aLb, aUb
|
||||
; string(5) value bName
|
||||
; integer array b ( * )
|
||||
; integer value bLb, bUb
|
||||
; logical value expected
|
||||
) ;
|
||||
begin
|
||||
logical isLt;
|
||||
isLt := iLT( a, aLb, aUb, b, bLb, bUb );
|
||||
write( aName, if isLt then " < " else " >= ", bName
|
||||
, if isLt = expected then "" else ", NOT as expected"
|
||||
)
|
||||
end test ;
|
||||
|
||||
integer array list1, list3, list4 ( 1 :: 5 );
|
||||
integer array list2 ( 1 :: 6 );
|
||||
integer array list5 ( 1 :: 5 );
|
||||
integer array list6 ( 1 :: 4 );
|
||||
integer array list7 ( 1 :: 3 );
|
||||
integer array list8 ( 1 :: 1 );
|
||||
integer aPos;
|
||||
% test cases as in the BBC basic sample %
|
||||
aPos := 1; for i := 1, 2, 1, 5, 2 do begin list1( aPos ) := i; aPos := aPos + 1 end;
|
||||
aPos := 1; for i := 1, 2, 1, 5, 2, 2 do begin list2( aPos ) := i; aPos := aPos + 1 end;
|
||||
aPos := 1; for i := 1, 2, 3, 4, 5 do begin list3( aPos ) := i; aPos := aPos + 1 end;
|
||||
aPos := 1; for i := 1, 2, 3, 4, 5 do begin list4( aPos ) := i; aPos := aPos + 1 end;
|
||||
test( "list1", list1, 1, 5, "list2", list2, 1, 6, true );
|
||||
test( "list2", list2, 1, 6, "list3", list3, 1, 5, true );
|
||||
test( "list3", list3, 1, 5, "list4", list4, 1, 5, false );
|
||||
% additional test cases %
|
||||
aPos := 1; for i := 9, 0, 2, 1, 0 do begin list5( aPos ) := i; aPos := aPos + 1 end;
|
||||
aPos := 1; for i := 4, 0, 7, 7 do begin list6( aPos ) := i; aPos := aPos + 1 end;
|
||||
aPos := 1; for i := 4, 0, 7 do begin list7( aPos ) := i; aPos := aPos + 1 end;
|
||||
test( "list5", list5, 1, 5, "list6", list6, 1, 4, false );
|
||||
test( "list6", list6, 1, 4, "list7", list7, 1, 3, false );
|
||||
test( "list7", list7, 1, 3, "list8", list8, 1, 0, false );
|
||||
test( "list8", list8, 1, 0, "list7", list7, 1, 3, true )
|
||||
end.
|
||||
|
|
@ -0,0 +1,154 @@
|
|||
/* ARM assembly Raspberry PI */
|
||||
/* program orderlist.s */
|
||||
|
||||
/* Constantes */
|
||||
.equ STDOUT, 1 @ Linux output console
|
||||
.equ EXIT, 1 @ Linux syscall
|
||||
.equ WRITE, 4 @ Linux syscall
|
||||
|
||||
/*********************************/
|
||||
/* Initialized data */
|
||||
/*********************************/
|
||||
.data
|
||||
szMessResult1: .asciz "List1 < List2 \n" @ message result
|
||||
szMessResult2: .asciz "List1 => List2 \n" @ message result
|
||||
szCarriageReturn: .asciz "\n"
|
||||
|
||||
iTabList1: .int 1,2,3,4,5
|
||||
.equ NBELEMENTS1, (. - iTabList1) /4
|
||||
iTabList2: .int 1,2,1,5,2,2
|
||||
.equ NBELEMENTS2, (. - iTabList2) /4
|
||||
iTabList3: .int 1,2,3,4,5
|
||||
.equ NBELEMENTS3, (. - iTabList3) /4
|
||||
iTabList4: .int 1,2,3,4,5,6
|
||||
.equ NBELEMENTS4, (. - iTabList4) /4
|
||||
/*********************************/
|
||||
/* UnInitialized data */
|
||||
/*********************************/
|
||||
.bss
|
||||
/*********************************/
|
||||
/* code section */
|
||||
/*********************************/
|
||||
.text
|
||||
.global main
|
||||
main: @ entry of program
|
||||
ldr r0,iAdriTabList1
|
||||
mov r1,#NBELEMENTS1
|
||||
ldr r2,iAdriTabList2
|
||||
mov r3,#NBELEMENTS2
|
||||
bl listeOrder
|
||||
cmp r0,#0 @ false ?
|
||||
beq 1f @ yes
|
||||
ldr r0,iAdrszMessResult1 @ list 1 < list 2
|
||||
bl affichageMess @ display message
|
||||
b 2f
|
||||
1:
|
||||
ldr r0,iAdrszMessResult2
|
||||
bl affichageMess @ display message
|
||||
|
||||
2:
|
||||
ldr r0,iAdriTabList1
|
||||
mov r1,#NBELEMENTS1
|
||||
ldr r2,iAdriTabList3
|
||||
mov r3,#NBELEMENTS3
|
||||
bl listeOrder
|
||||
cmp r0,#0 @ false ?
|
||||
beq 3f @ yes
|
||||
ldr r0,iAdrszMessResult1 @ list 1 < list 2
|
||||
bl affichageMess @ display message
|
||||
b 4f
|
||||
3:
|
||||
ldr r0,iAdrszMessResult2
|
||||
bl affichageMess @ display message
|
||||
4:
|
||||
ldr r0,iAdriTabList1
|
||||
mov r1,#NBELEMENTS1
|
||||
ldr r2,iAdriTabList4
|
||||
mov r3,#NBELEMENTS4
|
||||
bl listeOrder
|
||||
cmp r0,#0 @ false ?
|
||||
beq 5f @ yes
|
||||
ldr r0,iAdrszMessResult1 @ list 1 < list 2
|
||||
bl affichageMess @ display message
|
||||
b 6f
|
||||
5:
|
||||
ldr r0,iAdrszMessResult2
|
||||
bl affichageMess @ display message
|
||||
6:
|
||||
100: @ standard end of the program
|
||||
mov r0, #0 @ return code
|
||||
mov r7, #EXIT @ request to exit program
|
||||
svc #0 @ perform the system call
|
||||
iAdriTabList1: .int iTabList1
|
||||
iAdriTabList2: .int iTabList2
|
||||
iAdriTabList3: .int iTabList3
|
||||
iAdriTabList4: .int iTabList4
|
||||
iAdrszMessResult1: .int szMessResult1
|
||||
iAdrszMessResult2: .int szMessResult2
|
||||
iAdrszCarriageReturn: .int szCarriageReturn
|
||||
/******************************************************************/
|
||||
/* display text with size calculation */
|
||||
/******************************************************************/
|
||||
/* r0 contains the address of list 1 */
|
||||
/* r1 contains list 1 size */
|
||||
/* r2 contains the address of list 2 */
|
||||
/* r3 contains list 2 size */
|
||||
/* r0 returns 1 if list1 < list2 */
|
||||
/* r0 returns 0 else */
|
||||
listeOrder:
|
||||
push {r1-r7,lr} @ save registres
|
||||
cmp r1,#0 @ list 1 size = zero ?
|
||||
moveq r0,#-1 @ yes -> error
|
||||
beq 100f
|
||||
cmp r3,#0 @ list 2 size = zero ?
|
||||
moveq r0,#-2 @ yes -> error
|
||||
beq 100f
|
||||
mov r4,#0 @ index list 1
|
||||
mov r5,#0 @ index list 2
|
||||
1:
|
||||
ldr r6,[r0,r4,lsl #2] @ load list 1 element
|
||||
ldr r7,[r2,r5,lsl #2] @ load list 2 element
|
||||
cmp r6,r7 @ compar
|
||||
movgt r0,#0 @ list 1 > list 2 ?
|
||||
bgt 100f
|
||||
beq 2f @ list 1 = list 2
|
||||
add r4,#1 @ increment index 1
|
||||
cmp r4,r1 @ end list ?
|
||||
movge r0,#1 @ yes -> ok list 1 < list 2
|
||||
bge 100f
|
||||
b 1b @ else loop
|
||||
2:
|
||||
add r4,#1 @ increment index 1
|
||||
cmp r4,r1 @ end list ?
|
||||
bge 3f @ yes -> verif size
|
||||
add r5,#1 @ else increment index 2
|
||||
cmp r5,r3 @ end list 2 ?
|
||||
movge r0,#0 @ yes -> list 2 < list 1
|
||||
bge 100f
|
||||
b 1b @ else loop
|
||||
3:
|
||||
cmp r1,r3 @ compar size
|
||||
movge r0,#0 @ list 2 < list 1
|
||||
movlt r0,#1 @ list 1 < list 2
|
||||
100:
|
||||
pop {r1-r7,lr} @ restaur registers
|
||||
bx lr @ return
|
||||
/******************************************************************/
|
||||
/* display text with size calculation */
|
||||
/******************************************************************/
|
||||
/* r0 contains the address of the message */
|
||||
affichageMess:
|
||||
push {r0,r1,r2,r7,lr} @ save registres
|
||||
mov r2,#0 @ counter length
|
||||
1: @ loop length calculation
|
||||
ldrb r1,[r0,r2] @ read octet start position + index
|
||||
cmp r1,#0 @ if 0 its over
|
||||
addne r2,r2,#1 @ else add 1 in the length
|
||||
bne 1b @ and loop
|
||||
@ so here r2 contains the length of the message
|
||||
mov r1,r0 @ address message in r1
|
||||
mov r0,#STDOUT @ code to write to the standard output Linux
|
||||
mov r7, #WRITE @ code call system "write"
|
||||
svc #0 @ call systeme
|
||||
pop {r0,r1,r2,r7,lr} @ restaur registers */
|
||||
bx lr @ return
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
# syntax: GAWK -f ORDER_TWO_NUMERICAL_LISTS.AWK
|
||||
BEGIN {
|
||||
split("1,2,1,5,2",list1,",")
|
||||
split("1,2,1,5,2,2",list2,",")
|
||||
split("1,2,3,4,5",list3,",")
|
||||
split("1,2,3,4,5",list4,",")
|
||||
x = compare_array(list1,list2) ? "<" : ">=" ; printf("list1%slist2\n",x)
|
||||
x = compare_array(list2,list3) ? "<" : ">=" ; printf("list2%slist3\n",x)
|
||||
x = compare_array(list3,list4) ? "<" : ">=" ; printf("list3%slist4\n",x)
|
||||
exit(0)
|
||||
}
|
||||
function compare_array(arr1,arr2, ans,i) {
|
||||
ans = 0
|
||||
for (i=1; i<=length(arr1); i++) {
|
||||
if (arr1[i] != arr2[i]) {
|
||||
ans = 1
|
||||
break
|
||||
}
|
||||
}
|
||||
if (length(arr1) != length(arr2)) {
|
||||
ans = 1
|
||||
}
|
||||
return(ans)
|
||||
}
|
||||
|
|
@ -0,0 +1,64 @@
|
|||
INT FUNC Compare(INT ARRAY x INT xLen INT ARRAY y INT yLen)
|
||||
INT i,len
|
||||
|
||||
len=xLen
|
||||
IF len>yLen THEN
|
||||
len=yLen
|
||||
FI
|
||||
FOR i=0 TO len-1
|
||||
DO
|
||||
IF x(i)>y(i) THEN
|
||||
RETURN (1)
|
||||
ELSEIF x(i)<y(i) THEN
|
||||
RETURN (-1)
|
||||
FI
|
||||
OD
|
||||
IF xLen>yLen THEN
|
||||
RETURN (1)
|
||||
ELSEIF xLen<yLen THEN
|
||||
RETURN (-1)
|
||||
FI
|
||||
RETURN (0)
|
||||
|
||||
BYTE FUNC Less(INT ARRAY x INT xLen INT ARRAY y INT yLen)
|
||||
IF Compare(x,xLen,y,yLen)<0 THEN
|
||||
RETURN (1)
|
||||
FI
|
||||
RETURN (0)
|
||||
|
||||
PROC PrintArray(INT ARRAY x INT len)
|
||||
INT i
|
||||
|
||||
Put('[)
|
||||
FOR i=0 TO len-1
|
||||
DO
|
||||
PrintI(x(i))
|
||||
IF i<len-1 THEN
|
||||
Put(' )
|
||||
FI
|
||||
OD
|
||||
Put('])
|
||||
RETURN
|
||||
|
||||
PROC Test(INT ARRAY x INT xLen INT ARRAY y INT yLen)
|
||||
PrintArray(x,xLen)
|
||||
IF Less(x,xLen,y,yLen) THEN
|
||||
Print(" < ")
|
||||
ELSE
|
||||
Print(" >= ")
|
||||
FI
|
||||
PrintArray(y,yLen) PutE()
|
||||
RETURN
|
||||
|
||||
PROC Main()
|
||||
INT ARRAY a=[1 2 1 5 2]
|
||||
INT ARRAY b=[1 2 1 5 2 2]
|
||||
INT ARRAY c=[1 2 3 4 5]
|
||||
INT ARRAY d=[1 2 3 4 5]
|
||||
|
||||
Test(a,5,b,6)
|
||||
Test(b,6,a,5)
|
||||
Test(b,6,c,5)
|
||||
Test(c,5,b,6)
|
||||
Test(c,5,d,5)
|
||||
RETURN
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
with Ada.Text_IO; use Ada.Text_IO;
|
||||
procedure Order is
|
||||
|
||||
type IntArray is array (Positive range <>) of Integer;
|
||||
List1 : IntArray := (1, 2, 3, 4, 5);
|
||||
List2 : IntArray := (1, 2, 1, 5, 2, 2);
|
||||
List3 : IntArray := (1, 2, 1, 5, 2);
|
||||
List4 : IntArray := (1, 2, 1, 5, 2);
|
||||
|
||||
type Animal is (Rat, Cat, Elephant);
|
||||
type AnimalArray is array (Positive range <>) of Animal;
|
||||
List5 : AnimalArray := (Cat, Elephant, Rat, Cat);
|
||||
List6 : AnimalArray := (Cat, Elephant, Rat);
|
||||
List7 : AnimalArray := (Cat, Cat, Elephant);
|
||||
|
||||
begin
|
||||
Put_Line (Boolean'Image (List1 > List2)); -- True
|
||||
Put_Line (Boolean'Image (List2 > List3)); -- True
|
||||
Put_Line (Boolean'Image (List3 > List4)); -- False, equal
|
||||
Put_Line (Boolean'Image (List5 > List6)); -- True
|
||||
Put_Line (Boolean'Image (List6 > List7)); -- True
|
||||
end Order;
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
ordl(list a, b)
|
||||
{
|
||||
integer i, l, o;
|
||||
|
||||
l = min(~a, ~b);
|
||||
i = 0;
|
||||
while (i < l) {
|
||||
if (a[i] != b[i]) {
|
||||
o = a[i] < b[i];
|
||||
break;
|
||||
}
|
||||
|
||||
i += 1;
|
||||
}
|
||||
|
||||
i < l ? o : ~a <= ~b;
|
||||
}
|
||||
|
||||
main(void)
|
||||
{
|
||||
o_(ordl(list(1, 2), list(1, 2)), "\n");
|
||||
o_(ordl(list(1e2, 2), list(1e2, 2, 3)), "\n");
|
||||
o_(ordl(list(1, 2, 3), list(1, 2)), "\n");
|
||||
o_(ordl(list(.5, 4), list(.5, 2)), "\n");
|
||||
o_(ordl(list(1, 4, 2, 3), list(1, 4, 2.1, 3)), "\n");
|
||||
|
||||
0;
|
||||
}
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
-- <= for lists
|
||||
-- compare :: [a] -> [a] -> Bool
|
||||
on compare(xs, ys)
|
||||
if length of xs = 0 then
|
||||
true
|
||||
else
|
||||
if length of ys = 0 then
|
||||
false
|
||||
else
|
||||
set {hx, txs} to uncons(xs)
|
||||
set {hy, tys} to uncons(ys)
|
||||
|
||||
if hx = hy then
|
||||
compare(txs, tys)
|
||||
else
|
||||
hx < hy
|
||||
end if
|
||||
end if
|
||||
end if
|
||||
end compare
|
||||
|
||||
|
||||
|
||||
-- TEST
|
||||
on run
|
||||
|
||||
{compare([1, 2, 1, 3, 2], [1, 2, 0, 4, 4, 0, 0, 0]), ¬
|
||||
compare([1, 2, 0, 4, 4, 0, 0, 0], [1, 2, 1, 3, 2])}
|
||||
|
||||
end run
|
||||
|
||||
|
||||
---------------------------------------------------------------------------
|
||||
|
||||
-- GENERIC FUNCTION
|
||||
|
||||
-- uncons :: [a] -> Maybe (a, [a])
|
||||
on uncons(xs)
|
||||
if length of xs > 0 then
|
||||
{item 1 of xs, rest of xs}
|
||||
else
|
||||
missing value
|
||||
end if
|
||||
end uncons
|
||||
|
|
@ -0,0 +1 @@
|
|||
{false, true}
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
on listAComesBeforeListB(a, b)
|
||||
set aLength to (count a)
|
||||
set bLength to (count b)
|
||||
set i to 0
|
||||
repeat
|
||||
set i to i + 1
|
||||
if (i > bLength) then
|
||||
return false
|
||||
else if (i > aLength) then
|
||||
return true
|
||||
else
|
||||
set aVal to item i of a
|
||||
set bVal to item i of b
|
||||
if (aVal = bVal) then
|
||||
else
|
||||
return (bVal > aVal)
|
||||
end if
|
||||
end if
|
||||
end repeat
|
||||
end listAComesBeforeListB
|
||||
|
||||
-- Test code:
|
||||
set a to {}
|
||||
repeat (random number 10) times
|
||||
set end of a to random number 10
|
||||
end repeat
|
||||
set b to {}
|
||||
repeat (random number 10) times
|
||||
set end of b to random number 10
|
||||
end repeat
|
||||
|
||||
return {a:a, b:b, | a < b |: listAComesBeforeListB(a, b)},
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
{a:{3, 5, 6, 5, 2, 1, 4}, b:{5, 8, 9, 2, 0, 1, 9, 0, 4, 10}, | a < b |:true}
|
||||
{a:{10, 9, 5, 8, 8, 4, 3}, b:{5, 10, 8, 9, 10, 8, 7, 8}, | a < b |:false}
|
||||
{a:{0, 10}, b:{0, 10}, | a < b |:false}
|
||||
{a:{0, 10}, b:{0, 10, 5}, | a < b |:true}
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
compareLists: function [a,b][
|
||||
loop 0..min @[size a, size b] 'i [
|
||||
if a\[i] < b\[i] -> return true
|
||||
if a\[i] > b\[i] -> return false
|
||||
]
|
||||
return less? size a size b
|
||||
]
|
||||
|
||||
alias.infix '<=> 'compareLists
|
||||
|
||||
do [
|
||||
print [1 2 1 3 2] <=> [1 2 0 4 4 0 0 0]
|
||||
]
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
List1 := [1,2,1,3,2]
|
||||
List2 := [1,2,0,4,4,0,0,0]
|
||||
MsgBox % order(List1, List2)
|
||||
|
||||
order(L1, L2){
|
||||
return L1.MaxIndex() < L2.MaxIndex()
|
||||
}
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
arraybase 1
|
||||
dim list1(5): dim list2(6): dim list3(5): dim list4(5)
|
||||
list1 = {1, 2, 1, 5, 2}
|
||||
list2 = {1, 2, 1, 5, 2, 2}
|
||||
list3 = {1, 2, 3, 4, 5}
|
||||
list4 = {1, 2, 3, 4, 5}
|
||||
|
||||
if Orden(list1[], list2[]) then print "list1 < list2" else print "list 1>= list2"
|
||||
if Orden(list2[], list3[]) then print "list2 < list3" else print "list2 >= list3"
|
||||
if Orden(list3[], list4[]) then print "list3 < list4" else print "list3 >= list4"
|
||||
end
|
||||
|
||||
function Orden(listA[], listB[])
|
||||
i = 0
|
||||
l1 = listA[?]
|
||||
l2 = listB[?]
|
||||
while (listA[i] = listB[i]) and i < l1 and i < l2
|
||||
i = i + 1
|
||||
end while
|
||||
if listA[?] < listB[?] then return True
|
||||
if listA[?] > listB[?] then return False
|
||||
return l1 < l2
|
||||
end function
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
DIM list1(4) : list1() = 1, 2, 1, 5, 2
|
||||
DIM list2(5) : list2() = 1, 2, 1, 5, 2, 2
|
||||
DIM list3(4) : list3() = 1, 2, 3, 4, 5
|
||||
DIM list4(4) : list4() = 1, 2, 3, 4, 5
|
||||
|
||||
IF FNorder(list1(), list2()) PRINT "list1<list2" ELSE PRINT "list1>=list2"
|
||||
IF FNorder(list2(), list3()) PRINT "list2<list3" ELSE PRINT "list2>=list3"
|
||||
IF FNorder(list3(), list4()) PRINT "list3<list4" ELSE PRINT "list3>=list4"
|
||||
END
|
||||
|
||||
DEF FNorder(list1(), list2())
|
||||
LOCAL i%, l1%, l2%
|
||||
l1% = DIM(list1(),1) : l2% = DIM(list2(),1)
|
||||
WHILE list1(i%) = list2(i%) AND i% < l1% AND i% < l2%
|
||||
i% += 1
|
||||
ENDWHILE
|
||||
IF list1(i%) < list2(i%) THEN = TRUE
|
||||
IF list1(i%) > list2(i%) THEN = FALSE
|
||||
= l1% < l2%
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
( 1 2 3 4 5:?List1
|
||||
& 1 2 1 5 2 2:?List2
|
||||
& 1 2 1 5 2:?List3
|
||||
& 1 2 1 5 2:?List4
|
||||
& Cat Elephant Rat Cat:?List5
|
||||
& Cat Elephant Rat:?List6
|
||||
& Cat Cat Elephant:?List7
|
||||
& ( gt
|
||||
= first second
|
||||
. !arg:(?first,?second)
|
||||
& out
|
||||
$ ( (.!first)+(.!second)
|
||||
: ((.!first)+(.!second)|2*(.!first))
|
||||
& FALSE
|
||||
| TRUE
|
||||
)
|
||||
)
|
||||
& gt$(!List1,!List2)
|
||||
& gt$(!List2,!List3)
|
||||
& gt$(!List3,!List4)
|
||||
& gt$(!List4,!List5)
|
||||
& gt$(!List5,!List6)
|
||||
& gt$(!List6,!List7)
|
||||
);
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
#include <iostream>
|
||||
#include <vector>
|
||||
|
||||
int main() {
|
||||
std::vector<int> a;
|
||||
a.push_back(1);
|
||||
a.push_back(2);
|
||||
a.push_back(1);
|
||||
a.push_back(3);
|
||||
a.push_back(2);
|
||||
std::vector<int> b;
|
||||
b.push_back(1);
|
||||
b.push_back(2);
|
||||
b.push_back(0);
|
||||
b.push_back(4);
|
||||
b.push_back(4);
|
||||
b.push_back(0);
|
||||
b.push_back(0);
|
||||
b.push_back(0);
|
||||
|
||||
std::cout << std::boolalpha << (a < b) << std::endl; // prints "false"
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
namespace RosettaCode.OrderTwoNumericalLists
|
||||
{
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
|
||||
internal static class Program
|
||||
{
|
||||
private static bool IsLessThan(this IEnumerable<int> enumerable,
|
||||
IEnumerable<int> otherEnumerable)
|
||||
{
|
||||
using (
|
||||
IEnumerator<int> enumerator = enumerable.GetEnumerator(),
|
||||
otherEnumerator = otherEnumerable.GetEnumerator())
|
||||
{
|
||||
while (true)
|
||||
{
|
||||
if (!otherEnumerator.MoveNext())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!enumerator.MoveNext())
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
if (enumerator.Current == otherEnumerator.Current)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
return enumerator.Current < otherEnumerator.Current;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static void Main()
|
||||
{
|
||||
Console.WriteLine(
|
||||
new[] {1, 2, 1, 3, 2}.IsLessThan(new[] {1, 2, 0, 4, 4, 0, 0, 0}));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
int list_cmp(int *a, int la, int *b, int lb)
|
||||
{
|
||||
int i, l = la;
|
||||
if (l > lb) l = lb;
|
||||
for (i = 0; i < l; i++) {
|
||||
if (a[i] == b[i]) continue;
|
||||
return (a[i] > b[i]) ? 1 : -1;
|
||||
}
|
||||
if (la == lb) return 0;
|
||||
return la > lb ? 1 : -1;
|
||||
}
|
||||
|
|
@ -0,0 +1 @@
|
|||
#define list_less_or_eq(a,b,c,d) (list_cmp(a,b,c,d) != 1)
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
(defn lex? [a b]
|
||||
(compare a b))
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
(defun list< (a b)
|
||||
(cond ((not b) nil)
|
||||
((not a) t)
|
||||
((= (first a) (first b))
|
||||
(list< (rest a) (rest b)))
|
||||
(t (< (first a) (first b)))))
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
(defun list< (a b)
|
||||
(let ((x (find-if-not #'zerop (mapcar #'- a b))))
|
||||
(if x (minusp x) (< (length a) (length b)))))
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
void main() {
|
||||
assert([1,2,1,3,2] >= [1,2,0,4,4,0,0,0]);
|
||||
}
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
program Order_two_numerical_lists;
|
||||
|
||||
{$APPTYPE CONSOLE}
|
||||
|
||||
uses
|
||||
System.SysUtils,
|
||||
System.Generics.Defaults;
|
||||
|
||||
type
|
||||
TArray = record
|
||||
class function LessOrEqual<T>(first, second: TArray<T>): Boolean; static;
|
||||
end;
|
||||
|
||||
class function TArray.LessOrEqual<T>(first, second: TArray<T>): Boolean;
|
||||
begin
|
||||
if Length(first) = 0 then
|
||||
exit(true);
|
||||
if Length(second) = 0 then
|
||||
exit(false);
|
||||
var comp := TComparer<T>.Default.Compare(first[0], second[0]);
|
||||
if comp = 0 then
|
||||
exit(LessOrEqual(copy(first, 1, length(first)), copy(second, 1, length(second))));
|
||||
Result := comp < 0;
|
||||
end;
|
||||
|
||||
begin
|
||||
writeln(TArray.LessOrEqual<Integer>([1, 2, 3], [2, 3, 4]));
|
||||
writeln(TArray.LessOrEqual<Integer>([2, 3, 4], [1, 2, 3]));
|
||||
writeln(TArray.LessOrEqual<Integer>([1, 2], [1, 2, 3]));
|
||||
writeln(TArray.LessOrEqual<Integer>([1, 2, 3], [1, 2]));
|
||||
writeln(TArray.LessOrEqual<Char>(['a', 'c', 'b'], ['a', 'b', 'b']));
|
||||
writeln(TArray.LessOrEqual<string>(['this', 'is', 'a', 'test'], ['this', 'is',
|
||||
'not', 'a', 'test']));
|
||||
readln;
|
||||
end.
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
[] <. _ = true
|
||||
_ <. [] = false
|
||||
(x::xs) <. (y::ys) | x == y = xs <. ys
|
||||
| else = x < y
|
||||
|
||||
[1,2,1,3,2] <. [1,2,0,4,4,0,0,0]
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
iex(1)> [1,2,3] < [1,2,3,4]
|
||||
true
|
||||
iex(2)> [1,2,3] < [1,2,4]
|
||||
true
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
5> [1,2,3] < [1,2,3,4].
|
||||
true
|
||||
6> [1,2,3] < [1,2,4].
|
||||
true
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
let inline cmp x y = if x < y then -1 else if x = y then 0 else 1
|
||||
let before (s1 : seq<'a>) (s2 : seq<'a>) = (Seq.compareWith cmp s1 s2) < 0
|
||||
|
||||
[
|
||||
([0], []);
|
||||
([], []);
|
||||
([], [0]);
|
||||
([-1], [0]);
|
||||
([0], [0]);
|
||||
([0], [-1]);
|
||||
([0], [0; -1]);
|
||||
([0], [0; 0]);
|
||||
([0], [0; 1]);
|
||||
([0; -1], [0]);
|
||||
([0; 0], [0]);
|
||||
([0; 0], [1]);
|
||||
]
|
||||
|> List.iter (fun (x, y) -> printf "%A %s %A\n" x (if before x y then "< " else ">=") y)
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
Dim Shared list1(4) As Integer = {1, 2, 1, 5, 2}
|
||||
Dim Shared list2(5) As Integer = {1, 2, 1, 5, 2, 2}
|
||||
Dim Shared list3(4) As Integer = {1, 2, 3, 4, 5}
|
||||
Dim Shared list4(4) As Integer = {1, 2, 3, 4, 5}
|
||||
|
||||
Function Orden(listA() As Integer, listB() As Integer) As Boolean
|
||||
Dim As Integer i = 0, l1, l2
|
||||
l1 = Ubound(listA, 1)
|
||||
l2 = Ubound(listB, 1)
|
||||
While listA(i) = listB(i) And i < l1 And i < l2
|
||||
i += 1
|
||||
Wend
|
||||
If listA(i) < listB(i) Then Return True
|
||||
If listA(i) > listB(i) Then Return False
|
||||
Return l1 < l2
|
||||
End Function
|
||||
|
||||
If Orden(list1(), list2()) Then Print "list1<list2" Else Print "list1>=list2"
|
||||
If Orden(list2(), list3()) Then Print "list2<list3" Else Print "list2>=list3"
|
||||
If Orden(list3(), list4()) Then Print "list3<list4" Else Print "list3>=list4"
|
||||
|
||||
Sleep
|
||||
|
|
@ -0,0 +1,73 @@
|
|||
package main
|
||||
|
||||
import "fmt"
|
||||
|
||||
// If your numbers happen to be in the range of Unicode code points (0 to 0x10ffff), this function
|
||||
// satisfies the task:
|
||||
func lessRune(a, b []rune) bool {
|
||||
return string(a) < string(b) // see also bytes.Compare
|
||||
}
|
||||
|
||||
// Otherwise, the following function satisfies the task for all integer
|
||||
// and floating point types, by changing the type definition appropriately.
|
||||
type numericType int
|
||||
|
||||
func lessNT(a, b []numericType) bool {
|
||||
l := len(a)
|
||||
if len(b) < l {
|
||||
l = len(b)
|
||||
}
|
||||
for i := 0; i < l; i++ {
|
||||
if a[i] != b[i] {
|
||||
return a[i] < b[i]
|
||||
}
|
||||
}
|
||||
return l < len(b)
|
||||
}
|
||||
|
||||
var testCases = [][][]numericType{
|
||||
{{0}, {}},
|
||||
{{}, {}},
|
||||
{{}, {0}},
|
||||
|
||||
{{-1}, {0}},
|
||||
{{0}, {0}},
|
||||
{{0}, {-1}},
|
||||
|
||||
{{0}, {0, -1}},
|
||||
{{0}, {0, 0}},
|
||||
{{0}, {0, 1}},
|
||||
{{0, -1}, {0}},
|
||||
{{0, 0}, {0}},
|
||||
{{0, 0}, {1}},
|
||||
}
|
||||
|
||||
func main() {
|
||||
// demonstrate the general function
|
||||
for _, tc := range testCases {
|
||||
fmt.Printf("order %6s before %6s : %t\n",
|
||||
fmt.Sprintf("%v", tc[0]),
|
||||
fmt.Sprintf("%v", tc[1]),
|
||||
lessNT(tc[0], tc[1]))
|
||||
}
|
||||
fmt.Println()
|
||||
|
||||
// demonstrate that the byte specific function gives identical results
|
||||
// by offsetting test data to a printable range of characters.
|
||||
for _, tc := range testCases {
|
||||
a := toByte(tc[0])
|
||||
b := toByte(tc[1])
|
||||
fmt.Printf("order %6q before %6q : %t\n",
|
||||
string(a),
|
||||
string(b),
|
||||
lessByte(a, b))
|
||||
}
|
||||
}
|
||||
|
||||
func toByte(a []numericType) []byte {
|
||||
b := make([]byte, len(a))
|
||||
for i, n := range a {
|
||||
b[i] = 'b' + byte(n)
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
class CList extends ArrayList implements Comparable {
|
||||
CList() { }
|
||||
CList(Collection c) { super(c) }
|
||||
int compareTo(Object that) {
|
||||
assert that instanceof List
|
||||
def n = [this.size(), that.size()].min()
|
||||
def comp = [this[0..<n], that[0..<n]].transpose().find { it[0] != it[1] }
|
||||
comp ? comp[0] <=> comp[1] : this.size() <=> that.size()
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
CList a, b; (a, b) = [[], []]; assert ! (a < b)
|
||||
b = [1] as CList; assert (a < b)
|
||||
a = [1] as CList; assert ! (a < b)
|
||||
b = [2] as CList; assert (a < b)
|
||||
a = [2, -1, 0] as CList; assert ! (a < b)
|
||||
b = [2, -1] as CList; assert ! (a < b)
|
||||
b = [2, -1, 0] as CList; assert ! (a < b)
|
||||
b = [2, -1, 0, -17] as CList; assert (a < b)
|
||||
a = [2, 8, 0] as CList; assert ! (a < b)
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
Prelude> [1,2,1,3,2] < [1,2,0,4,4,0,0,0]
|
||||
False
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
procedure main()
|
||||
write( if list_llt([1,2,1,3,2],[1,2,0,4,4,0,0,0]) then "true" else "false" )
|
||||
end
|
||||
|
||||
|
||||
procedure list_llt(L1,L2) #: returns L2 if L1 lexically lt L2 or fails
|
||||
every i := 1 to min(*L1,*L2) do
|
||||
if L1[i] << L2[i] then return L2
|
||||
else if L1[i] >> L2[i] then fail
|
||||
if *L1 < *L2 then return L2
|
||||
end
|
||||
|
|
@ -0,0 +1 @@
|
|||
before=: -.@(-: /:~)@,&<~
|
||||
|
|
@ -0,0 +1 @@
|
|||
cmp=: {.@\:@,:&(,&__)
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
cmp&.>"{~ ('';0;(,0);1;(,1);1 1)
|
||||
┌─┬─┬─┬─┬─┬─┐
|
||||
│0│1│1│1│1│1│
|
||||
├─┼─┼─┼─┼─┼─┤
|
||||
│0│0│0│1│1│1│
|
||||
├─┼─┼─┼─┼─┼─┤
|
||||
│0│0│0│1│1│1│
|
||||
├─┼─┼─┼─┼─┼─┤
|
||||
│0│0│0│0│0│1│
|
||||
├─┼─┼─┼─┼─┼─┤
|
||||
│0│0│0│0│0│1│
|
||||
├─┼─┼─┼─┼─┼─┤
|
||||
│0│0│0│0│0│0│
|
||||
└─┴─┴─┴─┴─┴─┘
|
||||
|
||||
before&.>"{~ (0;1;'';(,0);(,1);1 1)
|
||||
┌─┬─┬─┬─┬─┬─┐
|
||||
│0│1│1│1│1│1│
|
||||
├─┼─┼─┼─┼─┼─┤
|
||||
│0│0│1│1│1│1│
|
||||
├─┼─┼─┼─┼─┼─┤
|
||||
│0│0│0│1│1│1│
|
||||
├─┼─┼─┼─┼─┼─┤
|
||||
│0│0│0│0│1│1│
|
||||
├─┼─┼─┼─┼─┼─┤
|
||||
│0│0│0│0│0│1│
|
||||
├─┼─┼─┼─┼─┼─┤
|
||||
│0│0│0│0│0│0│
|
||||
└─┴─┴─┴─┴─┴─┘
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
public class ListOrder{
|
||||
public static boolean ordered(double[] first, double[] second){
|
||||
if(first.length == 0) return true;
|
||||
if(second.length == 0) return false;
|
||||
if(first[0] == second[0])
|
||||
return ordered(Arrays.copyOfRange(first, 1, first.length),
|
||||
Arrays.copyOfRange(second, 1, second.length));
|
||||
return first[0] < second[0];
|
||||
}
|
||||
|
||||
public static <T extends Comparable<? super T>> boolean ordered(List<T> first, List<T> second){
|
||||
int i = 0;
|
||||
for(; i < first.size() && i < second.size();i++){
|
||||
int cmp = first.get(i).compareTo(second.get(i));
|
||||
if(cmp == 0) continue;
|
||||
if(cmp < 0) return true;
|
||||
return false;
|
||||
}
|
||||
return i == first.size();
|
||||
}
|
||||
|
||||
public static boolean ordered2(double[] first, double[] second){
|
||||
int i = 0;
|
||||
for(; i < first.length && i < second.length;i++){
|
||||
if(first[i] == second[i]) continue;
|
||||
if(first[i] < second[i]) return true;
|
||||
return false;
|
||||
}
|
||||
return i == first.length;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
(() => {
|
||||
'use strict';
|
||||
|
||||
// <= is already defined for lists in JS
|
||||
|
||||
// compare :: [a] -> [a] -> Bool
|
||||
const compare = (xs, ys) => xs <= ys;
|
||||
|
||||
|
||||
// TEST
|
||||
return [
|
||||
compare([1, 2, 1, 3, 2], [1, 2, 0, 4, 4, 0, 0, 0]),
|
||||
compare([1, 2, 0, 4, 4, 0, 0, 0], [1, 2, 1, 3, 2])
|
||||
];
|
||||
|
||||
// --> [false, true]
|
||||
})()
|
||||
|
|
@ -0,0 +1 @@
|
|||
[false, true]
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
DEFINE order ==
|
||||
[equal] [false]
|
||||
[[[[size] dip size <=] [[<=] mapr2 true [and] fold]] [i] map i and]
|
||||
ifte.
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
[1,2,3] < [1,2,3,4] # => true
|
||||
[1,2,3] < [1,2,4] # => true
|
||||
[1,2,3] < [1,2,3] # => false
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
function islexless(a::AbstractArray{<:Real}, b::AbstractArray{<:Real})
|
||||
for (x, y) in zip(a, b)
|
||||
if x == y continue end
|
||||
return x < y
|
||||
end
|
||||
return length(a) < length(b)
|
||||
end
|
||||
|
||||
using Primes, Combinatorics
|
||||
tests = [[1, 2, 3], primes(10), 0:2:6, [-Inf, 0.0, Inf], [π, e, φ, catalan], [2015, 5], [-sqrt(50.0), 50.0 ^ 2]]
|
||||
println("List not sorted:\n - ", join(tests, "\n - "))
|
||||
sort!(tests; lt=islexless)
|
||||
println("List sorted:\n - ", join(tests, "\n - "))
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
include ..\Utilitys.tlhy
|
||||
|
||||
( 1 2 3 ) ( 1 2 3 4 ) less ?
|
||||
( 1 2 3 4 ) ( 1 2 3 ) less ?
|
||||
( 1 2 4 ) ( 1 2 3 ) less ?
|
||||
( 1 2 3 ) ( 1 2 3 ) less ?
|
||||
( 1 2 3 ) ( 1 2 4 ) less ?
|
||||
|
||||
"End " input
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
// version 1.0.6
|
||||
|
||||
operator fun <T> List<T>.compareTo(other: List<T>): Int
|
||||
where T: Comparable<T>, T: Number {
|
||||
for (i in 0 until this.size) {
|
||||
if (other.size == i) return 1
|
||||
when {
|
||||
this[i] < other[i] -> return -1
|
||||
this[i] > other[i] -> return 1
|
||||
}
|
||||
}
|
||||
return if (this.size == other.size) 0 else -1
|
||||
}
|
||||
|
||||
fun main(args: Array<String>) {
|
||||
val lists = listOf(
|
||||
listOf(1, 2, 3, 4, 5),
|
||||
listOf(1, 2, 1, 5, 2, 2),
|
||||
listOf(1, 2, 1, 5, 2),
|
||||
listOf(1, 2, 1, 5, 2),
|
||||
listOf(1, 2, 1, 3, 2),
|
||||
listOf(1, 2, 0, 4, 4, 0, 0, 0),
|
||||
listOf(1, 2, 0, 4, 4, 1, 0, 0)
|
||||
)
|
||||
for (i in 0 until lists.size) println("list${i + 1} : ${lists[i]}")
|
||||
println()
|
||||
for (i in 0 until lists.size - 1) println("list${i + 1} > list${i + 2} = ${lists[i] > lists[i + 1]}")
|
||||
}
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
local(
|
||||
first = array(1,2,1,3,2),
|
||||
second = array(1,2,0,4,4,0,0,0),
|
||||
)
|
||||
#first < #second
|
||||
|
||||
local(
|
||||
first = array(1,1,1,3,2),
|
||||
second = array(1,2,0,4,4,0,0,0),
|
||||
)
|
||||
#first < #second
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
print [1 2] = [1 2]
|
||||
print [1 2] = [1 2 3]
|
||||
print [1 3] = [1 2]
|
||||
print [1 2 3] = [1 2]
|
||||
|
||||
make "list1 [1 2 3 4 5 6]
|
||||
make "list2 [1 2 3 4 5 7]
|
||||
print :list1 = :list2
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
true
|
||||
false
|
||||
false
|
||||
false
|
||||
false
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
function arraycompare(a, b)
|
||||
for i = 1, #a do
|
||||
if b[i] == nil then
|
||||
return true
|
||||
end
|
||||
if a[i] ~= b[i] then
|
||||
return a[i] < b[1]
|
||||
end
|
||||
end
|
||||
return true
|
||||
end
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
function randomarray()
|
||||
local t = {}
|
||||
for i = 1, math.random(1, 10) do
|
||||
t[i] = math.random(1, 10)
|
||||
end
|
||||
return t
|
||||
end
|
||||
|
||||
math.randomseed(os.time())
|
||||
|
||||
for i = 1, 10 do
|
||||
local a = randomarray()
|
||||
local b = randomarray()
|
||||
|
||||
print(
|
||||
string.format("{%s} %s {%s}",
|
||||
table.concat(a, ', '),
|
||||
arraycompare(a, b) and "<=" or ">",
|
||||
table.concat(b, ', ')))
|
||||
end
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
orderLists := proc(num1,num2)
|
||||
local len1, len2,i:
|
||||
len1,len2 := numelems(num1),numelems(num2):
|
||||
for i to min(len1,len2) do
|
||||
if num1[i] <> num2[i] then
|
||||
return evalb(num1[i]<num2[i]):
|
||||
end if:
|
||||
end do:
|
||||
return evalb(len1 < len2):
|
||||
end proc:
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
order[List1_, List2_] := With[{
|
||||
L1 = List1[[1 ;; Min @@ Length /@ {List1, List2}]],
|
||||
L2 = List2[[1 ;; Min @@ Length /@ {List1, List2}]]
|
||||
},
|
||||
If [Thread[Order[L1, L2]] == 0,
|
||||
Length[List1] < Length[List2],
|
||||
Thread[Order[L1, L2]] == 1
|
||||
]]
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
"<<"(a,b):=block([n:min(length(a),length(b))],
|
||||
catch(for i thru n do (if a[i]#b[i] then throw(is(a[i]<b[i]))),
|
||||
throw(is(length(a)<length(b)))))$
|
||||
infix("<<")$
|
||||
|
||||
[1,2,3] << [1,2,4];
|
||||
true
|
||||
|
||||
[1,2,3] << [1,2];
|
||||
false
|
||||
|
||||
[1,2] << [1,2];
|
||||
false
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
:- pred lt(list(int)::in, list(int)::in) is semidet.
|
||||
lt([], [_|_]).
|
||||
lt([H1|T1], [H2|T2]) :- H1 =< H2, T1 `lt` T2.
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
:- pred lt(list(T)::in, list(T)::in) is semidet <= comparable(T).
|
||||
lt([], [_|_]).
|
||||
lt([H1|T1], [H2|T2]) :- H1 =< H2, T1 `lt` T2.
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
:- module comparable.
|
||||
:- interface.
|
||||
:- import_module int, float, integer, list.
|
||||
|
||||
:- typeclass comparable(T) where [
|
||||
pred '<'(T::in, T::in) is semidet,
|
||||
pred '=<'(T::in, T::in) is semidet
|
||||
].
|
||||
:- instance comparable(int).
|
||||
:- instance comparable(float).
|
||||
:- instance comparable(integer).
|
||||
:- instance comparable(list(T)) <= comparable(T).
|
||||
|
||||
:- implementation.
|
||||
|
||||
:- instance comparable(int) where [
|
||||
pred('<'/2) is int.(<),
|
||||
pred('=<'/2) is int.(=<)
|
||||
].
|
||||
% likewise for float and integer...
|
||||
:- instance comparable(list(T)) <= comparable(T) where [
|
||||
pred('<'/2) is lt, % the 'lt' above.
|
||||
pred('=<'/2) is lte % 'lt' with: lte([], []).
|
||||
].
|
||||
|
||||
% pred lt
|
||||
% pred lte
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
:- pred test(list(T), list(T), io, io) <= comparable(T).
|
||||
:- mode test(in, in, di, uo) is det.
|
||||
test(A, B) -->
|
||||
io.write(A), io.write_string(" < "), io.write(B),
|
||||
io.write_string(" : "), io.write_string(S), io.nl,
|
||||
{ A < B -> S = "yes" ; S = "no" }.
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
main :: [sys_message]
|
||||
main = [Stdout (lay (map show [
|
||||
order [1,2,1,3,2] [1,2,0,4,4,0,0,0],
|
||||
order [1,2,0,4,4,0,0,0] [1,2,1,3,2]]))]
|
||||
|
||||
order :: [*]->[*]->bool
|
||||
order as [] = True
|
||||
order [] as = False
|
||||
order (a:as) (b:bs) = a < b, if a ~= b
|
||||
= order as bs, otherwise
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
proc `<`[T](a, b: openarray[T]): bool =
|
||||
for i in 0 .. min(a.len, b.len):
|
||||
if a[i] < b[i]: return true
|
||||
if a[i] > b[i]: return false
|
||||
return a.len < b.len
|
||||
|
||||
echo([1,2,1,3,2] < [1,2,0,4,4,0,0,0])
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
# [1;2;1;3;2] < [1;2;0;4;4;0;0;0];;
|
||||
- : bool = false
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
# [|1;2;1;3;2|] < [|1;2;0;4;4;0;0;0|];;
|
||||
- : bool = true
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
let rec ordered_lists = function
|
||||
| x1::tl1, x2::tl2 ->
|
||||
(match compare x1 x2 with
|
||||
| 0 -> ordered_lists (tl1, tl2)
|
||||
| 1 -> false
|
||||
| _ -> true)
|
||||
| [], _ -> true
|
||||
| _ -> false
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
(* copy-paste the code of ordered_lists here *)
|
||||
|
||||
let make_num_list p n =
|
||||
let rec aux acc =
|
||||
if Random.int p = 0 then acc
|
||||
else aux (Random.int n :: acc)
|
||||
in
|
||||
aux []
|
||||
|
||||
let print_num_list lst =
|
||||
List.iter (Printf.printf " %d") lst;
|
||||
print_newline()
|
||||
|
||||
let () =
|
||||
Random.self_init();
|
||||
let lst1 = make_num_list 8 5 in
|
||||
let lst2 = make_num_list 8 5 in
|
||||
print_num_list lst1;
|
||||
print_num_list lst2;
|
||||
Printf.printf "ordered: %B\n" (ordered_lists (lst1, lst2))
|
||||
|
|
@ -0,0 +1 @@
|
|||
val ordered_lists : 'a list * 'a list -> bool
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
(define (lexorder a b)
|
||||
(cond
|
||||
((null? b) #false)
|
||||
((null? a) #true)
|
||||
((< (car a) (car b)) #true)
|
||||
((> (car a) (car b)) #false)
|
||||
(else
|
||||
(lexorder (cdr a) (cdr b)))))
|
||||
|
||||
(print (lexorder '(1 2 3) '(1 2 3 4))) ; => true
|
||||
(print (lexorder '(1 2 4) '(1 2 3))) ; => false
|
||||
(print (lexorder '(1 2 3) '(1 2))) ; => false
|
||||
(print (lexorder '(1 2 3) '(1 2 3))) ; => false
|
||||
(print (lexorder '(1 2 3) '(1 2 8))) ; => true
|
||||
|
|
@ -0,0 +1 @@
|
|||
lex(u,v)<1
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
lists: procedure options (main); /* 8 June 2014 */
|
||||
|
||||
declare a(10) fixed initial (1, 2, 3, 4, 5, 8, 9, 10, 16, 17),
|
||||
b(15) fixed initial (5, 6, 7, 8, 9, 10, 11, 12, 15, 16, 17, 18, 20, 22, 23);
|
||||
|
||||
put skip list (compare(a, b));
|
||||
put skip list (compare(b, a));
|
||||
put skip list (compare(a, a));
|
||||
|
||||
|
||||
compare: procedure (a, b) returns (bit (1));
|
||||
declare (a, b)(*) fixed;
|
||||
declare (i, m, n) fixed binary;
|
||||
|
||||
m = hbound(a,1); n = hbound(b,1);
|
||||
do i = 1 to min(m, n);
|
||||
return (a(i) < b(i));
|
||||
end;
|
||||
return (m < n);
|
||||
end compare;
|
||||
|
||||
end lists;
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
use strict;
|
||||
use warnings;
|
||||
|
||||
sub orderlists {
|
||||
my ($firstlist, $secondlist) = @_;
|
||||
|
||||
my ($first, $second);
|
||||
while (@{$firstlist}) {
|
||||
$first = shift @{$firstlist};
|
||||
if (@{$secondlist}) {
|
||||
$second = shift @{$secondlist};
|
||||
if ($first < $second) {
|
||||
return 1;
|
||||
}
|
||||
if ($first > $second) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
@{$secondlist} ? 1 : 0;
|
||||
}
|
||||
|
||||
foreach my $pair (
|
||||
[[1, 2, 4], [1, 2, 4]],
|
||||
[[1, 2, 4], [1, 2, ]],
|
||||
[[1, 2, ], [1, 2, 4]],
|
||||
[[55,53,1], [55,62,83]],
|
||||
[[20,40,51],[20,17,78,34]],
|
||||
) {
|
||||
my $first = $pair->[0];
|
||||
my $second = $pair->[1];
|
||||
my $before = orderlists([@$first], [@$second]) ? 'true' : 'false';
|
||||
print "(@$first) comes before (@$second) : $before\n";
|
||||
}
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
(phixonline)-->
|
||||
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
|
||||
<span style="color: #0000FF;">?{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">}<{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">}</span> <span style="color: #000080;font-style:italic;">-- 1 (true under p2js)</span>
|
||||
<span style="color: #0000FF;">?{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">}<{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">}</span> <span style="color: #000080;font-style:italic;">-- 0 (false "")</span>
|
||||
<span style="color: #0000FF;">?{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">}<{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">}</span> <span style="color: #000080;font-style:italic;">-- 0 (false "")</span>
|
||||
<span style="color: #0000FF;">?{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">}<{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">}</span> <span style="color: #000080;font-style:italic;">-- 0 (false "")</span>
|
||||
<span style="color: #0000FF;">?{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">}<{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">}</span> <span style="color: #000080;font-style:italic;">-- 1 (true "")</span>
|
||||
<!--
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
include Utilitys.pmt
|
||||
|
||||
def ? print nl enddef
|
||||
|
||||
( 1 2 3 ) ( 1 2 3 4 ) < ?
|
||||
( 1 2 3 4 ) ( 1 2 3 ) < ?
|
||||
( 1 2 4 ) ( 1 2 3 ) < ?
|
||||
( 1 2 3 ) ( 1 2 3 ) < ?
|
||||
( 1 2 3 ) ( 1 2 4 ) < ?
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
go =>
|
||||
Tests = [
|
||||
[[1,2,3], [1,2,3]],
|
||||
[[1,2,3], [1,2,3,4]],
|
||||
[[1,2,2], [1,2,3]],
|
||||
[[1,2,4], [1,2,3]],
|
||||
[1..10 , 1..8],
|
||||
[[] , []],
|
||||
[[] , [1]],
|
||||
[[1] , [] ],
|
||||
[[-1,2,3,6,5],[-1,2,3,5,6]],
|
||||
[[-1,2,3,-5,6],[-1,2,3,-6,5]]
|
||||
],
|
||||
foreach([L1,L2] in Tests)
|
||||
printf("%w @< %w: %w\n",L1,L2,cond(L1 @< L2,true,false))
|
||||
end,
|
||||
nl.
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
: (> (1 2 0 4 4 0 0 0) (1 2 1 3 2))
|
||||
-> NIL
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
int(0..1) order_array(array a, array b)
|
||||
{
|
||||
if (!sizeof(a)) return true;
|
||||
if (!sizeof(b)) return false;
|
||||
if (a[0] == b[0])
|
||||
return order_array(a[1..], b[1..]);
|
||||
return a[0] < b[0];
|
||||
}
|
||||
|
|
@ -0,0 +1 @@
|
|||
(string)a < (string)b;
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
function order($as,$bs) {
|
||||
if($as -and $bs) {
|
||||
$a, $as = $as
|
||||
$b, $bs = $bs
|
||||
if($a -eq $b) {order $as $bs}
|
||||
else{$a -lt $b}
|
||||
} elseif ($bs) {$true} else {$false}
|
||||
}
|
||||
"$(order @(1,2,1,3,2) @(1,2,0,4,4,0,0,0))"
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
function Test-Order ([int[]]$ReferenceArray, [int[]]$DifferenceArray)
|
||||
{
|
||||
for ($i = 0; $i -lt $ReferenceArray.Count; $i++)
|
||||
{
|
||||
if ($ReferenceArray[$i] -lt $DifferenceArray[$i])
|
||||
{
|
||||
return $true
|
||||
}
|
||||
elseif ($ReferenceArray[$i] -gt $DifferenceArray[$i])
|
||||
{
|
||||
return $false
|
||||
}
|
||||
}
|
||||
|
||||
return ($ReferenceArray.Count -lt $DifferenceArray.Count) -or (Compare-Object $ReferenceArray $DifferenceArray) -eq $null
|
||||
}
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
Test-Order -ReferenceArray 1, 2, 1, 3, 2 -DifferenceArray 1, 2, 0, 4, 4, 0, 0, 0
|
||||
Test-Order -ReferenceArray 1, 2, 1, 3, 2 -DifferenceArray 1, 2, 2, 4, 4, 0, 0, 0
|
||||
Test-Order -ReferenceArray 1, 2, 3 -DifferenceArray 1, 2
|
||||
Test-Order -ReferenceArray 1, 2 -DifferenceArray 1, 2, 3
|
||||
Test-Order -ReferenceArray 1, 2 -DifferenceArray 1, 2
|
||||
|
|
@ -0,0 +1,70 @@
|
|||
DataSection
|
||||
Array_1:
|
||||
Data.i 5 ;element count
|
||||
Data.i 1, 2, 3, 4, 5 ;element data
|
||||
Array_2:
|
||||
Data.i 6
|
||||
Data.i 1, 2, 1, 5, 2, 2
|
||||
Array_3:
|
||||
Data.i 5
|
||||
Data.i 1, 2, 1, 5, 2
|
||||
Array_4:
|
||||
Data.i 5
|
||||
Data.i 1, 2, 1, 5, 2
|
||||
Array_5:
|
||||
Data.i 4
|
||||
Data.i 1, 2, 1, 6
|
||||
Array_6:
|
||||
Data.i 5
|
||||
Data.i 1, 2, 1, 6, 2
|
||||
EndDataSection
|
||||
|
||||
#False = 0
|
||||
#True = 1
|
||||
|
||||
;helper subrountine to initialize a dataset, *dataPtr points to the elementcount followed by the element data
|
||||
Procedure initArrayData(Array a(1), *dataPtr)
|
||||
Protected elementCount = PeekI(*dataPtr)
|
||||
|
||||
Dim a(elementCount - 1)
|
||||
For i = 0 To elementCount - 1
|
||||
*dataPtr + SizeOf(Integer)
|
||||
a(i) = PeekI(*dataPtr)
|
||||
Next
|
||||
EndProcedure
|
||||
|
||||
;helper subroutine that returns 'True' or 'False' for a boolean input
|
||||
Procedure.s booleanText(b)
|
||||
If b: ProcedureReturn "True": EndIf
|
||||
ProcedureReturn "False"
|
||||
EndProcedure
|
||||
|
||||
Procedure order(Array a(1), Array b(1))
|
||||
Protected len_a = ArraySize(a()), len_b = ArraySize(b()), elementIndex
|
||||
|
||||
While elementIndex <= len_a And elementIndex <= len_b And a(elementIndex) = b(elementIndex)
|
||||
elementIndex + 1
|
||||
Wend
|
||||
|
||||
If (elementIndex > len_a And elementIndex <= len_b) Or (elementIndex <= len_b And a(elementIndex) <= b(elementIndex))
|
||||
ProcedureReturn #True
|
||||
EndIf
|
||||
EndProcedure
|
||||
|
||||
Dim A_1(0): initArrayData(A_1(), ?Array_1)
|
||||
Dim A_2(0): initArrayData(A_2(), ?Array_2)
|
||||
Dim A_3(0): initArrayData(A_3(), ?Array_3)
|
||||
Dim A_4(0): initArrayData(A_4(), ?Array_4)
|
||||
Dim A_5(0): initArrayData(A_5(), ?Array_5)
|
||||
Dim A_6(0): initArrayData(A_6(), ?Array_6)
|
||||
|
||||
If OpenConsole()
|
||||
PrintN(booleanText(order(A_1(), A_2()))) ;False
|
||||
PrintN(booleanText(order(A_2(), A_3()))) ;False
|
||||
PrintN(booleanText(order(A_3(), A_4()))) ;False
|
||||
PrintN(booleanText(order(A_4(), A_5()))) ;True
|
||||
PrintN(booleanText(order(A_5(), A_6()))) ;True
|
||||
|
||||
Print(#crlf$ + #crlf$ + "Press ENTER to exit"): Input()
|
||||
CloseConsole()
|
||||
EndIf
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
>>> [1,2,1,3,2] < [1,2,0,4,4,0,0,0]
|
||||
False
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
[ [ over [] = iff false done
|
||||
dup [] = iff true done
|
||||
behead rot behead rot
|
||||
2dup = iff
|
||||
[ 2drop swap ] again
|
||||
> ]
|
||||
unrot 2drop ] is []< ( [ [ --> b )
|
||||
|
||||
' [ [ ] [ 1 ] [ 1 1 1 ] [ 1 2 ] [ 1 2 1 ] [ 2 ] [ 2 1 ] [ 2 1 1 ] ]
|
||||
|
||||
shuffle sortwith []< echo
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
/*REXX program determines if a list < previous list, and returns true or false. */
|
||||
@.=; @.1 = 1 2 1 5 2
|
||||
@.2 = 1 2 1 5 2 2
|
||||
@.3 = 1 2 3 4 5
|
||||
@.4 = 1 2 3 4 5
|
||||
/* [↓] compare a list to previous list*/
|
||||
do j=2 while @.j\==''; p= j - 1 /*P: points to previous value in list.*/
|
||||
if FNorder(@.p, @.j)=='true' then is= " < " /*use a more familiar glyph.*/
|
||||
else is= " ≥ " /* " " " " " */
|
||||
say
|
||||
say right('['@.p"]", 40) is '['@.j"]"
|
||||
end /*i*/
|
||||
exit /*stick a fork in it, we're all done. */
|
||||
/*──────────────────────────────────────────────────────────────────────────────────────*/
|
||||
FNorder: procedure; parse arg x,y
|
||||
wx= words(x); wy= words(y)
|
||||
do k=1 for min(wx, wy)
|
||||
a= word(x, k) /*get a value from X. */
|
||||
b= word(y, k) /* " " " " Y. */
|
||||
if a<b then return 'true'
|
||||
else if a>b then return 'false'
|
||||
end /*k*/
|
||||
if wx<wy then return 'true' /*handle case of equal (so far). */
|
||||
return 'false' /* " " " " " " */
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
#lang racket
|
||||
|
||||
(define (lex<? a b)
|
||||
(cond ((null? b) #f)
|
||||
((null? a) #t)
|
||||
((= (car a) (car b)) (lex<? (cdr a) (cdr b)))
|
||||
(else (< (car a) (car b)))))
|
||||
|
||||
(lex<? '(1 2 3 4 5) '(1 2 3 4 4)) ; -> #f
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
my @a = <1 2 4>;
|
||||
my @b = <1 2 4>;
|
||||
say @a," before ",@b," = ", @a before @b;
|
||||
|
||||
@a = <1 2 4>;
|
||||
@b = <1 2>;
|
||||
say @a," before ",@b," = ", @a before @b;
|
||||
|
||||
@a = <1 2>;
|
||||
@b = <1 2 4>;
|
||||
say @a," before ",@b," = ", @a before @b;
|
||||
|
||||
for 1..10 {
|
||||
my @a = flat (^100).roll((2..3).pick);
|
||||
my @b = flat @a.map: { Bool.pick ?? $_ !! (^100).roll((0..2).pick) }
|
||||
say @a," before ",@b," = ", @a before @b;
|
||||
}
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
rascal>[2,1,3] < [5,2,1,3]
|
||||
bool: true
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
list1 = "1, 2, 1, 5, 2"
|
||||
list2 = "5, 2, 1, 5, 2, 2"
|
||||
list3 = "1, 2, 3, 4, 5"
|
||||
list4 = "1, 2, 3, 4, 5"
|
||||
|
||||
if order(list1, list2) = 0 see "list1=list2" + nl
|
||||
but order(list1, list2) < 0 see "list1<list2" + nl
|
||||
else see "list1>list2" + nl ok
|
||||
|
||||
if order(list2, list3) = 0 see "list2=list3" + nl
|
||||
but order(list2, list3) < 0 see "list2<list3" + nl
|
||||
else see "list2>list3" + nl ok
|
||||
|
||||
if order(list3, list4) = 0 see "list3=list4" + nl
|
||||
but order(list3, list4) < 0 see "list3<list4" + nl
|
||||
else see "list3>list4" + nl ok
|
||||
|
||||
func order alist, blist
|
||||
return strcmp(alist, blist)
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
>> ([1,2,1,3,2] <=> [1,2,0,4,4,0,0,0]) < 0
|
||||
=> false
|
||||
|
|
@ -0,0 +1 @@
|
|||
vec![1, 2, 1, 3, 2] < vec![1, 2, 0, 4, 4, 0, 0, 0]
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
def lessThan1(a: List[Int], b: List[Int]): Boolean =
|
||||
if (b.isEmpty) false
|
||||
else if (a.isEmpty) true
|
||||
else if (a.head != b.head) a.head < b.head
|
||||
else lessThan1(a.tail, b.tail)
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
def lessThan2(a: List[Int], b: List[Int]): Boolean = (a, b) match {
|
||||
case (_, Nil) => false
|
||||
case (Nil, _) => true
|
||||
case (a :: _, b :: _) if a != b => a < b
|
||||
case _ => lessThan2(a.tail, b.tail)
|
||||
}
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
def lessThan3(a: List[Int], b: List[Int]): Boolean =
|
||||
a.zipAll(b, Integer.MIN_VALUE, Integer.MIN_VALUE)
|
||||
.find{case (a, b) => a != b}
|
||||
.map{case (a, b) => a < b}
|
||||
.getOrElse(false)
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
val tests = List(
|
||||
(List(1, 2, 3), List(1, 2, 3)) -> false,
|
||||
(List(3, 2, 1), List(3, 2, 1)) -> false,
|
||||
(List(1, 2, 3), List(3, 2, 1)) -> true,
|
||||
(List(3, 2, 1), List(1, 2, 3)) -> false,
|
||||
(List(1, 2), List(1, 2, 3)) -> true,
|
||||
(List(1, 2, 3), List(1, 2)) -> false
|
||||
)
|
||||
|
||||
tests.foreach{case test @ ((a, b), c) =>
|
||||
assert(lessThan1(a, b) == c, test)
|
||||
assert(lessThan2(a, b) == c, test)
|
||||
assert(lessThan3(a, b) == c, test)
|
||||
}
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
(define (lex<? a b)
|
||||
(cond ((null? b) #f)
|
||||
((null? a) #t)
|
||||
((= (car a) (car b)) (lex<? (cdr a) (cdr b)))
|
||||
(else (< (car a) (car b)))))
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
$ include "seed7_05.s7i";
|
||||
|
||||
const proc: main is func
|
||||
begin
|
||||
writeln([] (1) < [] (1, 2)); # If the first list runs out of elements the result is TRUE.
|
||||
writeln([] (1, 2) < [] (1)); # If the second list runs out of elements the result is FALSE.
|
||||
writeln([] (1, 2) < [] (1, 2)); # If both lists run out of elements the result is FALSE.
|
||||
writeln([] (1, 2, 3) < [] (1, 1, 3)); # The second element is greater than --> FALSE
|
||||
writeln([] (1, 2, 3) < [] (1, 3, 3)); # The second element is less than --> TRUE
|
||||
writeln(0 times 0 < [] (1)); # The empty list is less than any nonempty list --> TRUE
|
||||
writeln([] (1) < 0 times 0); # Any nonempty list is not less than the empty list --> FALSE
|
||||
writeln(0 times 0 < 0 times 0); # The empty list is not less than the empty list --> FALSE
|
||||
end func;
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
func ordered(a, b) {
|
||||
(a <=> b) < 0
|
||||
}
|
||||
|
||||
for p in [
|
||||
Pair([1,2,4], [1,2,4]),
|
||||
Pair([1,2,4], [1,2] ),
|
||||
Pair([1,2], [1,2,4]),
|
||||
] {
|
||||
var a = p.first
|
||||
var b = p.second
|
||||
var before = ordered(a, b)
|
||||
say "#{a} comes before #{b} : #{before}"
|
||||
}
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
- List.collate Int.compare ([1,2,1,3,2], [1,2,0,4,4,0,0,0]) = LESS;
|
||||
val it = false : bool
|
||||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Add a link
Reference in a new issue