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>

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

BYTE FUNC AreEqual(PTR ARRAY a BYTE len)

a4(0)="aaa"

Test(a4,1)

{{out}}

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

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

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

=={{header|Arturo}}==

ascending?: function [lst] -> lst = sort lst

print ["allEqual?" allEqual? l]

print ["ascending?" ascending? l "\n"]

{{out}}

=={{header|AWK}}==

# syntax: GAWK -f COMPARE_A_LIST_OF_STRINGS.AWK

BEGIN {

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

}

{{out}}

<pre>

If all are not equal and the list is invariant under sorting, then it is in ascending order.

Asc ← ¬∘AllEq∧∧≡⊢

•Show AllEq ⟨"AA", "ACB", "BB", "CC"⟩

0

0

[https://mlochbaum.github.io/BQN/try.html#code=QWxsRXEg4oaQIOKNi+KJoeKNkgpBc2Mg4oaQIMKs4oiYQWxsRXHiiKfiiKfiiaHiiqIKCuKAolNob3cgQWxsRXEg4p+oIkFBIiwgIkFBIiwgIkFBIiwgIkFBIuKfqQrigKJTaG93IEFzYyDin6giQUEiLCAiQUEiLCAiQUEiLCAiQUEi4p+pCgrigKJTaG93IEFsbEVxIOKfqCJBQSIsICJBQ0IiLCAiQkIiLCAiQ0Mi4p+pCuKAolNob3cgQXNjIOKfqCJBQSIsICJBQ0IiLCAiQkIiLCAiQ0Mi4p+pCg== Try It!]

Demonstration

. isiZulu

isiXhosa

)

)

'''Output'''

<pre>test1 lstA fails

=={{header|C}}==

#include <string.h>

return false;

return true;

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

{{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::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"]

{{libheader| System.SysUtils}}

{{Trans|Go}}

program Compare_a_list_of_strings;

readln;

{{out}}

<pre>[a]

=={{header|Dyalect}}==

var prev

for x in xs {

}

true

=={{header|Elena}}==

ELENA 5.0 :

import system'routines;

import extensions;

console.readChar()

{{out}}

<pre>

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

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

Here is my solution using LIST.4TH from my novice-package: http://www.forth.org/novice.html

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

}

}

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

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

This particular version of "Compare a list of strings" was created in Mathcad Prime Express 7.0, a free version of Mathcad Prime 7.0 with restrictions (such as no programming or symbolics). All Mathcad numbers are complex doubles. There is a recursion depth limit of about 4,500. Strings are a distinct data and are not conceptually a list of integers.

-- Mathcad vectors are single column arrays.

-- The following notation is for convenience in writing arrays in text form.

list:=[11,11,11],[11,22,33],[11,33,22],[33,22,11],[11,132,22,33],[11]]

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

Apply[Equal, data]

{{out}}

<pre>False

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

This is the obvious (and more efficient way) to compare strings in Nim:

func allEqual(s: openArray[string]): bool =

doAssert allEqual(["abc"])

For “allEqual”, there is another simple way using template “allIt” from standard module “sequtils”:

func allEqual(s: openArray[string]): bool =

doAssert allEqual(["abc", "abc", "abc"])

doAssert not allEqual(["abc", "abd", "abc"])

There are other less obvious and less efficient ways, using hash sets, sorting or “map” and “zip”.

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

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">allsame</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">test</span><span style="color: #0000FF;">({</span><span style="color: #008000;">"AA"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"ACB"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"BB"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"CC"</span><span style="color: #0000FF;">})</span>

<span style="color: #000000;">test</span><span style="color: #0000FF;">({</span><span style="color: #008000;">"single_element"</span><span style="color: #0000FF;">})</span>

{{out}}

<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|Picat}}==

Lists = [["AA","BB","CC"],

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

all_same([A,B|Rest]) :-

A == B,

{{out}}

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

The word <code>$></code> compares two strings using the QACSFOT lexical ordering. (QACSFOT - Quackery Arbitrary Character Sequence For Ordered Text. It is less arbitrary than the ASCII sequence.)

dup size 1 > while

behead swap

[ tuck $> if

[ dip not conclude ] ] ]

=={{header|R}}==

function yields false.

chunks <- function (compare, xs) {

starts = which(c(T, !compare(head(xs, -1), xs[-1]), T))

function(i) xs[starts[i]:(starts[i+1]-1)] )

}

Testing:

> chunks(`<`, c(0,4,8,1,3,5,7,9))

[[1]]

[[2]]

[1] 1 3 5 7 9

R displays the results in a very prolix manner, so let's simplify it.

> toString(chunks(`<`, c(0,4,8,1,3,5,7,9,-2,0,88)))

[1] "c(0, 4, 8), c(1, 3, 5, 7, 9), c(-2, 0, 88)"

> toString(chunks(`==`, c(0,0,0,5,5,8)))

[1] "c(0, 0, 0), c(5, 5), 8"

Defining the required functions:

all.eq <- function(xs) 1 == length( chunks(`==`, xs))

ascending <- function(xs) 1 == length( chunks(`<`, xs))

Testing:

> all.eq(c('by'))

[1] TRUE

> ascending(c("at"))

[1] TRUE

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

In Raku, putting square brackets around an [[wp:Infix_notation|infix]] operator turns it into a listop that effectively works as if the operator had been but in between all of the elements of the argument list ''(or in technical terms, it [[wp:Fold_(higher-order_function)|folds/reduces]] the list using that operator, while taking into account the operator's inherent [https://design.raku.org/S03.html#Operator_precedence associativity] and identity value)'':

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

}

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

=={{header|Vlang}}==

{{trans|go}}

for s in strings {

if s != strings[0] {

}

return true

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

=={{header|XProfan}}==

Parameters long liste

var int result = 1

ClearList 0