Compare a list of strings: Difference between revisions

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

{{trans|D}}

V strings = strings_s.split(‘ ’)

print(strings)

print(all(zip(strings, strings[1..]).map(a -> a[0] == a[1])))

print(all(zip(strings, strings[1..]).map(a -> a[0] < a[1])))

 

=={{header|360 Assembly}}==

The program uses one ASSIST macro (XPRNT) to keep the code as short as possible.

COMPLIST CSECT

USING COMPLIST,R13 base register

PG DS CL80

YREGS

{{out}}

<pre>

AAA : all elements are equal

ACB : neither equal nor in increasing order

</pre>

 

 

We will store the "list" of strings in a vector. The vector will hold "indefinite" strings, i.e., the strings can have different lengths.

(Index_Type => Positive, Element_Type => String);

 

The equality test iterates from the first to the last-but one index. For index Idx,

yes for any Idx, the function immediately returns False. If the answer is no for all Idx,

the function finally returns True.

begin

for Idx in Strings.First_Index .. Strings.Last_Index-1 loop

end loop;

return True;

 

Similarily, the strictly ascending test checks if Strings(Idx) is greater or equal Strings(Idx+1).

begin

for Idx in Strings.First_Index+1 .. Strings.Last_Index loop

end loop;

return True;

 

If the variable Strings is of the type String_Vec.vector, one can call these two functions

as usual.

If Strings holds two or more strings, the result will be either of TRUE, FALSE, or FALSE, TRUE, or FALSE, FALSE, indicating all strings are the same, or they are strictly ascending, or neither.

 

 

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

[]STRING list2 = ("AA","AA","AA");

[]STRING list3 = ("AA","CC","BB");

BOOL ok := TRUE;

FOR i TO UPB list - 1 WHILE ok DO

OD;

ok

BOOL ok := TRUE;

FOR i TO UPB list - 1 WHILE ok DO

OD;

ok

print (("...is not in strict ascending order", new line))

FI

{{out}}

<pre>list: AA BB CC

 

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

% As Algol W procedures cannot determine the bounds of an array, the bounds %

% must be specified in lo and hi %

end;

ordered

 

=={{header|AppleScript}}==

 

 

on allEqual(xs)

_and(zipWith(my _equal, xs, rest of xs))

end script

end if

 

{{Out}}

<pre>{allEqual:{false, false, true}, azSorted:{false, true, true}}</pre>

 

=={{header|AWK}}==

# syntax: GAWK -f COMPARE_A_LIST_OF_STRINGS.AWK

BEGIN {

printf("\n%d\n%d\n",test1,test2)

}

{{out}}

<pre>

1

</pre>

 

=={{header|Bracmat}}==

 

 

 

Demonstration

. isiZulu

isiXhosa

)

)

'''Output'''

<pre>test1 lstA fails

test1 lstC succeeds

test2 lstC fails</pre>

 

=={{header|C}}==

#include <string.h>

 

{

}

 

{

 

{{works with|C sharp|7}}

strings.Count < 2 ? (true, true) :

(

strings.Distinct().Count() < 2,

Enumerable.Range(1, strings.Count - 1).All(i => string.Compare(strings[i-1], strings[i]) < 0)

 

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

 

{{works with|C++|11}}

#include <string>

 

std::all_of( ++(strings.begin()), strings.end(),

[&](std::string a){ return a == strings.front(); } ) // All equal

 

std::is_sorted( strings.begin(), strings.end(),

 

=={{header|Clojure}}==

Used similar approach as the Python solution

 

 

;; Checks if all items in strings list are equal (returns true if list is empty)

(every? (fn [[a nexta]] (<= (compare a nexta) 0)) (map vector strings (rest strings))))

 

 

=={{header|COBOL}}==

{{works with|GnuCOBOL}}

program-id. CompareLists.

 

end-if

display " "

{{out}}

<pre>list:

 

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

(defun strings-equal-p (strings)

(null (remove (first strings) (rest strings) :test #'string=)))

for string2 in (rest strings)

always (string-lessp string1 string2)))

 

=={{header|D}}==

import std.stdio, std.algorithm, std.range, std.string;

 

writeln;

}

{{out}}

<pre>["AA", "AA", "AA", "AA"]

true

</pre>

 

=={{header|Dyalect}}==

 

var prev

for x in xs {

}

true

 

=={{header|Elena}}==

import system'routines;

import extensions;

{

isEqual()

isAscending()

later.next();

}

}

public program()

{

{

console.printLine(list.asEnumerable()," all equal - ",list.isEqual());

console.readChar()

{{out}}

<pre>

AA,BB,CC ascending - true

AA,AA,AA all equal - true

AA,CC,BB all equal - false

AA,CC,BB ascending - false

 

=={{header|Elixir}}==

def compare_strings(strings) do

{length(Enum.uniq(strings))<=1, strict_ascending(strings)}

Enum.each(lists, fn list ->

IO.puts "#{inspect RC.compare_strings(list)}\t<= #{inspect list} "

 

{{out}}

{{trans|Haskell}}

 

-module(compare_strings).

 

all_fulfill(Fun,Strings) ->

lists:all(fun(X) -> X end,lists:zipwith(Fun, lists:droplast(Strings), tl(Strings)) ).

 

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

<p>Actually <code>allEqual</code> is a shortcut and <code>ascending</code> is a general pattern. We can make a function

out of it which constructs a new function from a comparision function</p>

<p>and define the 2 task functions that way</p>

<p>getting something similar as the builtin in Raku</p>

 

=={{header|Factor}}==

Assuming the list is on top of the data stack, testing for lexical equality:

Testing for ascending order:

 

=={{header|Forth}}==

Raw Forth is a very low level language and has no Native lists so we have to build from scratch.

Remarkably by concatenating these low level operations and using the simple Forth parser we can build the linked lists of strings and the list operators quite simply. The operators and lists that we create become extensions to the language.

: ," ( -- ) [CHAR] " WORD c@ 1+ ALLOT ; \ Parse input stream until " and write into next available memory

: [[ ( -- ) 0 C, ; \ begin a list. write a 0 into next memory byte (null string)

create strings [[ ," ENTRY 4" ," ENTRY 3" ," ENTRY 2" ," ENTRY 1" ]]

create strings2 [[ ," the same" ," the same" ," the same" ]]

 

Test at the Forth console

Application code is hard to write and hard to read when low-level code is mixed in with application code.

It is better to hide low-level code in general-purpose code-libraries so that the application code can be simple.

: test-equality ( string node -- new-string bad? )

over count \ -- string node adr cnt

seq .line @ seq 2nd 'test find-node

nip 0= ;

Here is a test of the above code:

{{out}}

On the other hand a function such as ALLINORDER would show the sound of one hand clapping. It would also reveal the order in which comparisons were made, and whether the loop would quit on the first failure or blockheadedly slog on through the lot regardless. Alas, on these questions the documentation for ALL is suspiciously silent.

 

INTEGER MANY,LONG

PARAMETER (LONG = 6,MANY = 4) !Adjust to suit.

END IF

END

 

And yes, if MANY is set to one and the extra texts are commented out, the results are both true, and ungrammatical statements are made. Honest. Possibly, another special function, as in <code>COUNT(STRINGS(1:MANY - 1) .LT. STRINGS(2:MANY)))</code> would involve less one-hand-clapping when there are no comparisons to make, but the production of a report that would use it is not in the specification.

===F2003-F2008===

F2008 standard ([ISO 2010], 4.4.3) defines the character variable of the character type as a set of values composed of character strings and a character string is a sequence of characters, numbered from left to right 1, 2, 3, ... up to the number of characters in the string. The number of characters in the string is called the length of the string. The length is a type parameter; its kind is processor dependent and its value is greater than or equal to zero. I.e in declaration

character (len=12) :: surname

keyword len is NOT a size of array, it is an intrinsic parameter of character type, and character type is in fortran a [[first-class type]]: they can be assigned as objects or passed as parameters to a subroutine.

 

In summary, the character data type in Fortran is a real, first class data type. Fortran character strings are not hacked-up arrays!

program compare_char_list

implicit none

end if

end program compare_char_list

 

=={{header|FreeBASIC}}==

' FB 1.05.0 Win64

 

Return True

End Function

 

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Go}}==

 

func AllEqual(strings []string) bool {

return false

}

 

func AllLessThan(strings []string) bool {

return false

}

}

return true

See [[Compare_a_list_of_strings/GoTests]] for validation tests.

 

 

=={{header|Gosu}}==

 

var isHomogeneous = list.toSet().Count < 2

 

=={{header|Haskell}}==

allEqual xs = and $ zipWith (==) xs (tail xs)

allIncr :: Ord a => [a] -> Bool

 

 

Alternatively, using folds:

 

:: Eq a

=> [a] -> Bool

=> [a] -> Bool

allIncreasing [] = True

 

or seeking earlier exit (from longer lists) with '''until''', but in fact, perhaps due to lazy execution, the zipWith at the top performs best.

 

:: Eq a

=> [a] -> Bool

(\(x, xs) -> null xs || x >= head xs)

(\(_, x:xs) -> (x, xs))

 

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

Icon and Unicon expressions either succeed and return a value (which may be &null) or fail.

 

# list-compare.icn

#

}

return

 

{{out}}

=={{header|J}}==

 

'''Notes''': <tt>asc</tt> indicates whether <tt>y</tt> is monotonically increasing, but not necessarily strictly monotonically increasing (in other words, it allows equal elements if they are adjacent to each other).

 

=={{header|Java}}==

{{works with|Java|8}}

 

public class CompareListOfStrings {

String[][] arr = {{"AA", "AA", "AA", "AA"}, {"AA", "ACB", "BB", "CC"}};

for (String[] a : arr) {

}

}

{{out}}

<pre>[AA, AA, AA, AA]

===ES5===

====Iterative====

var out = true, i = 0;

while (++i<a.length) {

console.log(azSorted(empty)); // true

console.log(azSorted(single)); // true

 

===ES6===

 

Using a generic zipWith, and functionally composed predicates:

'use strict';

 

};

 

 

{{Out}}

"allEqual": [

false,

true

]

 

=={{header|jq}}==

For both the following functions, the input is assumed to be a (possibly empty) array of strings.

In both cases also, the implementations are fast but could be improved at the expense of complexity.

def lexically_equal:

. as $in

. as $in

| reduce range(0;length-1) as $i

'''Examples''':

 

=={{header|Jsish}}==

Code from Javascript, ES5.

 

function allEqual(a) {

var out = true, i = 0;

 

if (allAscending(strings)) puts("strings array in strict ascending order");

 

{{out}}

{{works with|Julia|0.6}}

 

 

test = [["RC", "RC", "RC"], ["RC", "RC", "Rc"], ["RA", "RB", "RC"],

println("The elements are $("not " ^ !allequal(v))all equal.")

println("The elements are $("not " ^ !issorted(v))strictly increasing.")

 

{{out}}

 

=={{header|Klong}}==

{:[2>#x;1;&/=:'x]}:(["test" "test" "test"])

1

{:[2>#x;1;&/<:'x]}:(["bar" "baz" "foo"])

1

 

=={{header|Kotlin}}==

 

fun areEqual(strings: Array<String>): Boolean {

if (strings.size < 2) return true

}

 

fun areAscending(strings: Array<String>): Boolean {

if (strings.size < 2) return true

}

 

else if (areAscending(args)) println("They are in strictly ascending order")

else println("They are neither equal nor in ascending order")

Sample input/output:

{{out}}

 

=={{header|Lambdatalk}}==

{def allsame

{def allsame.r

} -> true false false true true

 

 

=={{header|Lua}}==

_, fst = next(t_str)

if fst then

check("AA,CC,BB")

check("AA,ACB,BB,CC")

{{out}}

<pre>ayu dab dog gar panda tui yak: not identical and ascending.

 

=={{header|M2000 Interpreter}}==

Module CheckIt {

Function Equal(Strings){

}

Checkit

 

=={{header|Maple}}==

local i:

for i from 2 to numelems(lst) do

tst := ["abc","abc","abc","abc","abc"]:

lexEqual(tst):

{{Out|Examples}}

<pre>true

false</pre>

 

Apply[Equal, data]

{{out}}

<pre>False

True</pre>

 

=={{header|MATLAB}} / {{header|Octave}}==

Only the first task is implemented.

 

=={{header|Nanoquery}}==

def stringsEqual(stringList)

// if the list is empty, return true

// return whether the string were less than each other or not

return lessThan

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

 

return

 

{{out}}

<pre>

elements are in ascending order

</pre>

 

=={{header|OCaml}}==

open List;;

 

 

List.iter test [lasc;leq;lnoasc];;

{{out}}

<pre>

=={{header|Oforth}}==

 

 

=={{header|ooRexx}}==

* 28.06.2014 Walter Pachl

*--------------------------------------------------------------------*/

Say 'List' name': neither equal nor in increasing order'

End

{{out}}

<pre>List ABC: elements are in increasing order

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

Easiest is to use <code>Set()</code>:

 

More efficient:

 

=={{header|Perl}}==

 

 

all { $strings[0] eq $strings[$_] } 1..$#strings # All equal

 

Alternatively, if you can guarantee that the input strings don't contain null bytes, the equality test can be performed by a regex like this:

 

 

=={{header|Phix}}==

{{out}}

<pre>

</pre>

 

=={{header|Phixmonti}}==

 

( "alpha" "beta" "gamma" "delta" "epsilon" "zeta"

 

dup len swap 1 get rot repeat == /# put 0 (false) in the pile, indicating that they are not repeated strings #/

 

=={{header|PicoLisp}}==

PicoLisp has the native operators =, > and < these can take an infinite number of arguments and are also able to compare Transient symbols (the Strings of PicoLisp).

-> T

(= "AA" "AA" "Aa")

-> T

(> "A" "B" "Z" "C")

If you want a function which takes one list here are some straight-forward implementation:

(de same (List)

(apply = List))

(same '("AA" "AA" "AA"))

-> T

This would of course also work with <= and >= without any hassle.

 

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

/*--------------------------------------------------------------------

* 01.07.2014 Walter Pachl

Put Skip List(name!!': '!!txt);

End;

{{out}}

<pre>ABC: elements are in increasing order

 

=={{header|Plain English}}==

If the string things are empty, say yes.

Get a string thing from the string things.

If the string thing's string is less than the string thing's previous' string, say no.

Put the string thing's next into the string thing.

 

=={{header|PowerShell}}==

{{works with|PowerShell|4.0}}

function IsAscending ( [string[]]$Array ) { ( 0..( $Array.Count - 2 ) ).Where{ $Array[$_] -le $Array[$_+1] }.Count -eq $Array.Count - 1 }

function IsEqual ( [string[]]$Array ) { ( 0..( $Array.Count - 2 ) ).Where{ $Array[$_] -eq $Array[$_+1] }.Count -eq $Array.Count - 1 }

IsEqual 'A', 'C', 'B', 'C'

IsEqual 'A', 'A', 'A', 'A'

{{out}}

<pre>

 

=={{header|Prolog}}==

los(["AA","AA","AA"]).

los(["AA","CC","BB"]).

nl.

 

{{out}}

<pre>

 

=={{header|PureBasic}}==

DataSection

Data.s ~"AA\tAA\tAA\nAA\tBB\tCC\nAA\tCC\tBB\nAA\tACB\tBB\tCC\nsingel_element"

PrintN("")

Next

{{out}}

<pre>List : AA AA AA

A useful pattern is that when you need some function of an item in a list with its next item over possibly all items in the list then <code>f(a, nexta) for a, nexta in zip(alist, alist[1:]))</code> works nicely.

(Especially if an index is not needed elsewhere in the algorithm).

all(a < nexta for a, nexta in zip(strings, strings[1:])) # Strictly ascending

 

len(set(strings)) == 1 # Concise all equal

sorted(strings, reverse=True) == strings # Concise (but not particularly efficient) ascending

 

 

and, if we wish, pass functional forms of standard operators to either of them:

 

 

 

 

all(map(lt, az, az[1:]))

{{Out}}

<pre>True False True</pre>

 

 

 

 

 

 

 

 

 

 

 

 

 

=={{header|Racket}}==

 

Hence the wrapper in the code below:

(define ((list-stringX? stringX?) strs)

(or (null? strs) (null? (cdr strs)) (apply stringX? strs)))

(list-string<? '("a" "a")) => #f

(list-string<? '("a" "b" "a")) => #f

 

=={{header|Raku}}==

(formerly Perl 6)

 

 

 

=={{header|Red}}==

 

list1: ["asdf" "Asdf" "asdf"]

print all-equal? list3

print sorted? list3

{{out}}

<pre>false

=={{header|REXX}}==

===version 1===

* 28.06.2014 Walter Pachl

*--------------------------------------------------------------------*/

Say 'List' value(list)': neither equal nor in increasing order'

End

{{out}}

<pre>List ABC: elements are in increasing order

:::::::* '''parse upper arg x'''

:::::::* '''arg x'''

@.1= 'ayu dab dog gar panda tui yak' /*seven strings: they're all ascending.*/

@.2= 'oy oy oy oy oy oy oy oy oy oy' /* ten strings: all equal. */

if word(strings,k)<<=word(strings,k-1) then return 0 /*string>prev? */

end /*k*/ /* [↑] 0=false, [↓] 1=true. */

{{out|output|text=&nbsp; when using the supplied lists:}}

<pre>

===version 3===

This REXX version is more idiomatic.

@.1= 'ayu dab dog gar panda tui yak' /*seven strings: they're all ascending.*/

@.2= 'oy oy oy oy oy oy oy oy oy oy' /* ten strings: all equal. */

if how=='A' then if word(x,k) <<= word(x,k-1) then return 0 /*≤ prev.?*/

end /*k*/ /* [↓] 1=true. [↑] 0=false. */

{{out|output|text=&nbsp; is identical to the above REXX version.}} <br><br>

 

 

=={{header|Ruby}}==

 

Short circuiting:

 

=={{header|Rust}}==

 

match seq {

&[] | &[_] => true,

_ => false

}

match seq {

&[] | &[_] => true,

_ => false

}

 

=={{header|S-lang}}==

"Simple Loop" and "Array Idiomatic" versions:

{

variable n = length(sarr), a0, i;

atest(["single_element"]);

atest(NULL);

{{out}}

<pre>"AA"

=={{header|Scala}}==

Functions implemented in Scala following a functional paradigm

def strings_are_equal(seq:List[String]):Boolean = seq match {

case Nil => true

}

 

{{out}}

<pre>

For known lists that are 'short-enough', the simplest solution uses 'apply', but that relies on the list being shorter than the maximum number of arguments a function can accept. Better is to write a simple loop:

 

(define (compare-strings fn strs)

(or (null? strs) ; returns #t on empty list

(compare-strings string=? strings) ; test for all equal

(compare-strings string<? strings) ; test for in ascending order

 

=={{header|Seed7}}==

 

const func boolean: allTheSame (in array string: strings) is func

end if;

end for;

 

=={{header|SenseTalk}}==

analyze ["AA","AA","AA"]

analyze ["AA","CC","BB"]

end repeat

return True

{{Out}}

<pre>

=={{header|Sidef}}==

Short-circuiting:

 

Non short-circuiting:

 

=={{header|Tailspin}}==

Note that we choose here to use 1 as true and 0 as false since Tailspin doesn't (yet?) have booleans

// matcher testing if the array contains anything not equal to the first element

templates allEqual

otherwise 0 !

end strictEqual

 

=={{header|Tcl}}==

The command form of the <code>eq</code> and <code>&lt;</code> operators (introduced in Tcl 8.5) handle arbitrarily many arguments and will check if they're all equal/ordered.

Making the operators work with a list of values is just a matter of using the expansion syntax with them.

 

=={{header|VBA}}==

Private Function IsEqualOrAscending(myList) As String

Dim i&, boolEqual As Boolean, boolAsc As Boolean

IsEqualOrAscending = "List : " & Join(myList, ",") & ", IsEqual : " & (Not boolEqual) & ", IsAscending : " & Not boolAsc

End Function

Call :

Sub Main()

Dim List

Debug.Print IsEqualOrAscending(List)

End Sub

{{Out}}

<pre>

 

=={{header|VBScript}}==

Function string_compare(arr)

lexical = "Pass"

WScript.StdOut.WriteLine string_compare(Array("AA","ACB","BB","CC"))

WScript.StdOut.WriteLine string_compare(Array("FF"))

 

{{Out}}

Ascending Test: Pass

</pre>

 

=={{header|Wren}}==

{{libheader|Wren-sort}}

 

var areEqual = Fn.new { |strings|

System.print("%(b) are ascending : %(areAscending.call(b))")

System.print("%(c) are all equal : %(areEqual.call(c))")

 

{{out}}

[a, a, b] are all equal : false

[a, d, c] are ascending : false

</pre>

 

=={{header|zkl}}==

These short circuit.

fcn monoUp(strings){

strings.len()<2 or

strings.reduce(fcn(a,b){ if(a>=b) return(Void.Stop,False); b }).toBool()

allEQ(T("AA","AA","AA","AA")).println(); //True

allEQ(T("A", "AA","AA","AA")).println(); //False

monoUp(T("a","aa","aaa","aaaa")).println(); //True

monoUp(T("a","aa","aaa","aaa")).println(); //False

 

=={{header|zonnon}}==

module CompareStrings;

type

write("ascending?: ");writeln(ascending)

end CompareStrings.

 

=={{header|ZX Spectrum Basic}}==

{{trans|AWK}}

20 RESTORE j

30 READ n

180 DATA 3,"AA","CC","BB"

190 DATA 4,"AA","ACB","BB","CC"