Order two numerical lists: Difference between revisions

{{trans|Python}}

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program orderlist64.s */

.include "../includeARM64.inc"

=={{header|ACL2}}==

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

INT i,len

Test(c,5,b,6)

Test(c,5,d,5)

{{out}}

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

This also includes arrays of user defined types, using the type definition order from smallest to largest.

Demonstrated in the program below:

with Ada.Text_IO; use Ada.Text_IO;

procedure Order is

Put_Line (Boolean'Image (List6 > List7)); -- True

end Order;

{{out}}

<pre>

=={{header|ALGOL 68}}==

# returns TRUE if there is an element in a that is < the corresponding #

# element in b and all previous elements are equal; FALSE otherwise #

test( "list8", list8, "list7", list7, TRUE )

{{out}}

<pre>

=={{header|ALGOL W}}==

{{Trans|ALGOL 68}}

% returns TRUE if there is an element in a that is < the corresponding %

% element in b and all previous elements are equal, FALSE otherwise %

test( "list7", list7, 1, 3, "list8", list8, 1, 0, false );

test( "list8", list8, 1, 0, "list7", list7, 1, 3, true )

{{out}}

<pre>

=={{header|Aime}}==

{

integer i, l, o;

0;

=={{header|AppleScript}}==

<= is not defined over lists in AppleScript

-- compare :: [a] -> [a] -> Bool

on compare(xs, ys)

missing value

end if

{{Out}}

----

Here's an iterative implementation:

set aLength to (count a)

set bLength to (count b)

end repeat

{{Out}}

Examples:

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

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program orderlist.s */

pop {r0,r1,r2,r7,lr} @ restaur registers */

bx lr @ return

=={{header|Arturo}}==

loop 0..min @[size a, size b] 'i [

if a\[i] < b\[i] -> return true

do [

print [1 2 1 3 2] <=> [1 2 0 4 4 0 0 0]

{{out}}

{{works with|AutoHotkey_L}}

The function is overkill as we can just compare the list's ObjMaxIndex()

List2 := [1,2,0,4,4,0,0,0]

MsgBox % order(List1, List2)

order(L1, L2){

return L1.MaxIndex() < L2.MaxIndex()

=={{header|AWK}}==

# syntax: GAWK -f ORDER_TWO_NUMERICAL_LISTS.AWK

BEGIN {

return(ans)

}

{{out}}

<pre>

=={{header|BASIC256}}==

{{trans|FreeBASIC}}

arraybase 1

dim list1(5): dim list2(6): dim list3(5): dim list4(5)

return l1 < l2

end function

{{out}}

<pre>

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

'Ordered before' means 'less than' (see [[Talk:Order_two_numerical_lists|talk page]]).

DIM list2(5) : list2() = 1, 2, 1, 5, 2, 2

DIM list3(4) : list3() = 1, 2, 3, 4, 5

IF list1(i%) < list2(i%) THEN = TRUE

IF list1(i%) > list2(i%) THEN = FALSE

{{out}}

<pre>

In that case the function outputs FALSE.

Notice that if the arguments are the same, evaluation of the sum produces the product of one of the terms and a factor two. This complicates the pattern a bit.

& 1 2 1 5 2 2:?List2

& 1 2 1 5 2:?List3

& gt$(!List5,!List6)

& gt$(!List6,!List7)

{{out}}

<pre>TRUE

=={{header|C}}==

{

int i, l = la;

if (la == lb) return 0;

return la > lb ? 1 : -1;

=={{header|C sharp|C#}}==

{

using System;

}

}

{{out}}

<pre>False</pre>

=={{header|C++}}==

The built-in comparison operators already do this:

#include <vector>

std::cout << std::boolalpha << (a < b) << std::endl; // prints "false"

return 0;

=={{header|clojure}}==

(defn lex? [a b]

(compare a b))

=={{header|Common Lisp}}==

(cond ((not b) nil)

((not a) t)

((= (first a) (first b))

(list< (rest a) (rest b)))

Alternate version

(let ((x (find-if-not #'zerop (mapcar #'- a b))))

=={{header|D}}==

The built-in comparison operators already do this:

assert([1,2,1,3,2] >= [1,2,0,4,4,0,0,0]);

=={{header|Delphi}}==

{{libheader| System.SysUtils}}

{{Trans|Java}}

This is not a full translate of [https://rosettacode.org/wiki/Order_two_numerical_lists#Java Java], just adaptation and aplication of method previus introduced.

program Order_two_numerical_lists;

'not', 'a', 'test']));

readln;

{{out}}

<pre>TRUE

=={{header|Ela}}==

_ <. [] = false

(x::xs) <. (y::ys) | x == y = xs <. ys

| else = x < y

=={{header|Elixir}}==

The built-in comparison functions already do this (not only for lists of numbers, but for any arbitrary data type).

true

iex(2)> [1,2,3] < [1,2,4]

=={{header|Erlang}}==

Builtin. Example use from Erlang shell:

5> [1,2,3] < [1,2,3,4].

true

6> [1,2,3] < [1,2,4].

true

=={{header|F_Sharp|F#}}==

By using the Collection.Seq Module the static method Seq.compareWith fits our needs.

let before (s1 : seq<'a>) (s2 : seq<'a>) = (Seq.compareWith cmp s1 s2) < 0

([0; 0], [1]);

]

{{out}}

<pre>[0] >= []

=={{header|FreeBASIC}}==

{{trans|BBC BASIC}}

Dim Shared list2(5) As Integer = {1, 2, 1, 5, 2, 2}

Dim Shared list3(4) As Integer = {1, 2, 3, 4, 5}

If Orden(list3(), list4()) Then Print "list3<list4" Else Print "list3>=list4"

{{out}}

<pre>

=={{header|Go}}==

import "fmt"

}

return b

{{out}}

<pre>

=={{header|Groovy}}==

Solution:

CList() { }

CList(Collection c) { super(c) }

comp ? comp[0] <=> comp[1] : this.size() <=> that.size()

}

Test:

b = [1] as CList; assert (a < b)

a = [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)

=={{header|Haskell}}==

The built-in comparison operators already do this:

=={{header|Icon}} and {{header|Unicon}}==

List_llt is written in the style of all Icon/Unicon relational operators returning its right argument if successful and signaling failure otherwise.

write( if list_llt([1,2,1,3,2],[1,2,0,4,4,0,0,0]) then "true" else "false" )

end

else if L1[i] >> L2[i] then fail

if *L1 < *L2 then return L2

=={{header|J}}==

However numeric scalars sort ahead of vectors, i.e. are different from length one lists.

Below demonstrates non-decreasing order cmp treats length one vector same as scalar

cmp&.>"{~ ('';0;(,0);1;(,1);1 1)

┌─┬─┬─┬─┬─┬─┐

├─┼─┼─┼─┼─┼─┤

│0│0│0│0│0│0│

=={{header|Java}}==

{{trans|Common Lisp}}

There are a few methods here. The method named "ordered" which works on arrays is a translation of [[#Common Lisp|Common Lisp]]. The other two are loose translations of [[#Tcl|Tcl]] (some tweaks were needed to get the length checks to work out) and are probably better options.

import java.util.List;

return i == first.length;

}

=={{header|JavaScript}}==

<= is already defined for numeric lists in JavaScript

'use strict';

// --> [false, true]

})()

{{Out}}

=={{header|Joy}}==

DEFINE order ==

[equal] [false]

=={{header|jq}}==

[1,2,3] < [1,2,3,4] # => true

[1,2,3] < [1,2,4] # => true

=={{header|Julia}}==

{{works with|Julia|0.6}}

for (x, y) in zip(a, b)

if x == y continue end

println("List not sorted:\n - ", join(tests, "\n - "))

sort!(tests; lt=islexless)

{{out}}

=={{header|Klingphix}}==

( 1 2 3 ) ( 1 2 3 4 ) less ?

( 1 2 3 ) ( 1 2 4 ) less ?

=={{header|Kotlin}}==

operator fun <T> List<T>.compareTo(other: List<T>): Int

println()

for (i in 0 until lists.size - 1) println("list${i + 1} > list${i + 2} = ${lists[i] > lists[i + 1]}")

{{out}}

=={{header|Lasso}}==

This is built into the Lasso comparison operators

first = array(1,2,1,3,2),

second = array(1,2,0,4,4,0,0,0),

second = array(1,2,0,4,4,0,0,0),

)

{{out}}

<pre>false

Uses standard '=' notation

print [1 2] = [1 2 3]

print [1 3] = [1 2]

make "list1 [1 2 3 4 5 6]

make "list2 [1 2 3 4 5 7]

{{out}}

false

false

false

=={{header|Lua}}==

In Lua tables with numerical indices are used as lists or arrays and they do not support comparison out-of-the-box, so a function is needed to implement the comparison:

for i = 1, #a do

if b[i] == nil then

end

return true

Here is some demonstration code:

local t = {}

for i = 1, math.random(1, 10) do

arraycompare(a, b) and "<=" or ">",

table.concat(b, ', ')))

{{out}} (time used as random seed: 1413127434):

=={{header|Maple}}==

local len1, len2,i:

len1,len2 := numelems(num1),numelems(num2):

end do:

return evalb(len1 < len2):

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

L1 = List1[[1 ;; Min @@ Length /@ {List1, List2}]],

L2 = List2[[1 ;; Min @@ Length /@ {List1, List2}]]

Length[List1] < Length[List2],

Thread[Order[L1, L2]] == 1

<pre>Example use:

=={{header|Maxima}}==

catch(for i thru n do (if a[i]#b[i] then throw(is(a[i]<b[i]))),

throw(is(length(a)<length(b)))))$

[1,2] << [1,2];

=={{header|Mercury}}==

For a particular numerical type, you can get away with

lt([], [_|_]).

For a list of any numerical type, one way would be to use a typeclass:

lt([], [_|_]).

... which you would have to create:

:- interface.

:- import_module int, float, integer, list.

% pred lt

Which would be used in this way - note the typeclass and the comparison operator.

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

=={{header|Nim}}==

for i in 0 .. min(a.len, b.len):

if a[i] < b[i]: return true

return a.len < b.len

{{out}}

<pre>false</pre>

The built-in comparison operators already do this for lists (although this is not documented):

(Warning: However, the built-in comparison operators do not do this for arrays:

)

But we could write it explicitly this way:

| x1::tl1, x2::tl2 ->

(match compare x1 x2 with

| _ -> true)

| [], _ -> true

Here is a small script to test this function:

let make_num_list p n =

print_num_list lst1;

print_num_list lst2;

Sample execution:

Also notice that the function <code>ordered_lists</code> will work with anything the function <code>Pervasives.compare</code> is able to compare (most OCaml types and structures made from the base types). In the prototype of this function below <code>'a list</code> means a list of anything:

=={{header|Oforth}}==

=={{header|Ol}}==

This sample very similar to Scheme, but implements proper tail recursion. So can test unlimited length lists.

(define (lexorder a b)

(cond

(print (lexorder '(1 2 3) '(1 2 3))) ; => false

(print (lexorder '(1 2 3) '(1 2 8))) ; => true

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

=={{header|Perl}}==

use warnings;

my $before = orderlists([@$first], [@$second]) ? 'true' : 'false';

print "(@$first) comes before (@$second) : $before\n";

{{out}}

<pre>

=={{header|Phix}}==

Handled natively, eg ("?" is the shorthand print operator)

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

Elements can be any mix of integers, floating point numbers, strings, or nested subsequences, with atoms ordered before sequences.<br>

If you want -1/0/+1 (instead of the true(1)/false(0) shown above), use the builtin compare() function, and that will match under p2js.

=={{header|Phixmonti}}==

{{trans|Phix}}

def ? print nl enddef

( 1 2 4 ) ( 1 2 3 ) < ?

( 1 2 3 ) ( 1 2 3 ) < ?

=={{header|Picat}}==

Picat has a built-in general comparison operator <code>@<</code>, which compares terms in lexicographic order (numeric lists as well as atoms, strings, variables, and structures).

Tests = [

[[1,2,3], [1,2,3]],

printf("%w @< %w: %w\n",L1,L2,cond(L1 @< L2,true,false))

end,

In the Picat shell, the result is yes/no rather than true/false:

=={{header|PicoLisp}}==

The built-in comparison functions already do this (not only for lists of numbers, but for any arbitrary data type).

=={{header|Pike}}==

{

if (!sizeof(a)) return true;

return order_array(a[1..], b[1..]);

return a[0] < b[0];

Pikes <code>Array.sort_array()</code> function can sort an array of arrays using the <code><</code> operator, but it will sort longer arrays before shorter ones. Therefore the above function is still needed if the intent is to use the comparison for a sort operation.

If the numbers are in 32bit signed integer range, the following works too:

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

declare a(10) fixed initial (1, 2, 3, 4, 5, 8, 9, 10, 16, 17),

end compare;

Results:

<pre>

=={{header|PowerShell}}==

function order($as,$bs) {

if($as -and $bs) {

}

"$(order @(1,2,1,3,2) @(1,2,0,4,4,0,0,0))"

<b>Output:</b>

<pre>

===Non-Recursive Version===

function Test-Order ([int[]]$ReferenceArray, [int[]]$DifferenceArray)

{

return ($ReferenceArray.Count -lt $DifferenceArray.Count) -or (Compare-Object $ReferenceArray $DifferenceArray) -eq $null

}

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 -DifferenceArray 1, 2, 3

Test-Order -ReferenceArray 1, 2 -DifferenceArray 1, 2

{{Out}}

<pre>

=={{header|PureBasic}}==

Array_1:

Data.i 5 ;element count

CloseConsole()

EndIf

{{out}}

<pre>False

=={{header|Python}}==

The built-in comparison operators already do this:

=={{header|Quackery}}==

dup [] = iff true done

behead rot behead rot

' [ [ ] [ 1 ] [ 1 1 1 ] [ 1 2 ] [ 1 2 1 ] [ 2 ] [ 2 1 ] [ 2 1 1 ] ]

{{out}}

=={{header|Racket}}==

(define (lex<? a b)

(lex<? '(1 2 3 4 5) '(1 2 3 4 4)) ; -> #f

=={{header|Raku}}==

(formerly Perl 6)

There is already a built-in comparison operator.

my @b = <1 2 4>;

say @a," before ",@b," = ", @a before @b;

my @b = flat @a.map: { Bool.pick ?? $_ !! (^100).roll((0..2).pick) }

say @a," before ",@b," = ", @a before @b;

{{out}}

<pre>1 2 4 before 1 2 4 = False

=={{header|Rascal}}==

The built-in comparison operator already does this:

=={{header|REXX}}==

This example will also work with non-numeric strings.

@.=; @.1 = 1 2 1 5 2

@.2 = 1 2 1 5 2 2

end /*k*/

if wx<wy then return 'true' /*handle case of equal (so far). */

{{out|output|:}}

<pre>

=={{header|Ring}}==

list1 = "1, 2, 1, 5, 2"

list2 = "5, 2, 1, 5, 2, 2"

func order alist, blist

return strcmp(alist, blist)

Output:

<pre>

=={{header|Ruby}}==

The built-in <code><=></code> operator already does this:

=={{header|Rust}}==

<code>Vec<T></code> implements <code>Ord</code> when <code>T</code> does, so we can just compare them with <code><</code>. (Same with arrays and slices).

=={{header|Scala}}==

if (b.isEmpty) false

else if (a.isEmpty) true

else if (a.head != b.head) a.head < b.head

case (_, Nil) => false

case (Nil, _) => true

case (a :: _, b :: _) if a != b => a < b

case _ => lessThan2(a.tail, b.tail)

a.zipAll(b, Integer.MIN_VALUE, Integer.MIN_VALUE)

.find{case (a, b) => a != b}

.map{case (a, b) => a < b}

(List(1, 2, 3), List(1, 2, 3)) -> false,

(List(3, 2, 1), List(3, 2, 1)) -> false,

assert(lessThan2(a, b) == c, test)

assert(lessThan3(a, b) == c, test)

=={{header|Scheme}}==

(cond ((null? b) #f)

((null? a) #t)

((= (car a) (car b)) (lex<? (cdr a) (cdr b)))

=={{header|Seed7}}==

The operator corresponding to the ordering described in this example is less than.

const proc: main is func

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

{{out}}

=={{header|Sidef}}==

Built-in, via the comparison operator (`<=>`):

(a <=> b) < 0

}

var before = ordered(a, b)

say "#{a} comes before #{b} : #{before}"

{{out}}

<pre>

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

=={{header|Swift}}==

let b = [1,2,0,4,4,0,0,0]

{{out}}

<pre>

=={{header|Tcl}}==

foreach a $A b $B {

if {$a<$b} {

}

return 0

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

MODE DATA

list1=VALUE(list2)

ENDLOOP

{{out}}

<pre style='height:30ex;overflow:scroll'>

=={{header|VBA}}==

i = 1

Do While list1(i) <= list2(i)

Debug.Print order([{1, 2, 3, 4}], [{1,2,3}])

Debug.Print order([{1, 2, 3}], [{1,2,3,4}])

<pre>Onwaar

Onwaar

=={{header|VBScript}}==

Function order_list(arr1,arr2)

order_list = "FAIL"

WScript.StdOut.WriteLine order_list(Array(0,0),Array(1))

WScript.StdOut.WriteLine order_list(Array(1,2,1,3,2),Array(1,2,0,4,4,0,0,0))

{{Out}}

=={{header|Wart}}==

We'll simply overload <code>&lt;</code> for lists.

if not.b

nil

(cdr.a < cdr.b)

:else

{{out}}

=={{header|Wren}}==

var len = (l1.count <= l2.count) ? l1.count : l2.count

for (i in 0...len) {

var res = orderLists.call(lists[i], lists[i+1])

System.print("list[%(i)] < list[%(i+1)] -> %(res)")

{{out}}

=={{header|Yabasic}}==

{{trans|FreeBASIC}}

read num : dim list1(4)

read num : dim list2(5)

data 1, 2, 3, 4, 5

data 1, 2, 3, 4, 5

{{out}}

<pre>

=={{header|zkl}}==

a.walker().zip(b).filter1(fcn([(a,b)]){ a<b }) : // lazy

if(_) return(True);;

a.len()<b.len()

{{out}}

<pre>