String comparison: Difference between revisions
m (→{{header|J}}: match output to ge fix) |
|||
Line 139: | Line 139: | ||
* !\<< Strictly Not Less Than |
* !\<< Strictly Not Less Than |
||
* !\>> Strictly Not Greater Than |
* !\>> Strictly Not Greater Than |
||
=={{header|Run BASIC}}== |
|||
<lang runbasic>a$ = "dog" |
|||
b$ = "cat" |
|||
if a$ = b$ then print "the strings are equal" ' test for equalitY |
|||
if a$ <> b$ then print "the strings are not equal" ' test for inequalitY |
|||
if a$ > b$ then print a$;" is lexicallY higher than ";b$ ' test for lexicallY higher |
|||
if a$ < b$ then print a$;" is lexicallY lower than ";b$ ' test for lexicallY lower |
|||
if a$ <= b$ then print a$;" is not lexicallY higher than ";b$ |
|||
if a$ >= b$ then print a$;" is not lexicallY lower than ";b$ |
|||
end</lang> |
|||
=={{header|Tcl}}== |
=={{header|Tcl}}== |
Revision as of 14:39, 23 February 2013
Basic Data Operation
This is a basic data operation. It represents a fundamental action on a basic data type.
You may see other such operations in the Basic Data Operations category, or:
Integer Operations
Arithmetic |
Comparison
Boolean Operations
Bitwise |
Logical
String Operations
Concatenation |
Interpolation |
Comparison |
Matching
Memory Operations
Pointers & references |
Addresses
The task is to demonstrate how to compare two strings from within the language and how to achieve a lexical comparison. The task should demonstrate:
- Comparing two strings for exact equality
- Comparing two strings for inequality (i.e., the inverse of exact equality)
- Comparing two strings to see if one is lexically lower than the other
- Comparing two strings to see if one is lexically higher than the other
Bonus:
- Demonstrate the other kinds of string comparisons that the language provides.
See also:
AWK
<lang awk>BEGIN {
a="BALL" b="BELL"
IF (a == b) { print "The strings are equal" } IF (a != b) { print "The strings are not equal" } IF (a > b) { print "The first string is lexically higher than the second" } IF (a < b) { print "The first string is lexically lower than the second" } IF (a >= b) { print "The first string is not lexically lower than the second" } IF (a <= b) { print "The first string is not lexically higher than the second" }
}</lang>
BASIC
<lang basic>10 LET "A$="BELL" 20 LET B$="BELT" 30 IF A$ = B$ THEN PRINT "THE STRINGS ARE EQUAL": REM TEST FOR EQUALITY 40 IF A$ <> B$ THEN PRINT "THE STRINGS ARE NOT EQUAL": REM TEST FOR INEQUALITY 50 IF A$ > B$ THEN PRINT A$;" IS LEXICALLY HIGHER THAN ";B$: REM TEST FOR LEXICALLY HIGHER 60 IF A$ < B$ THEN PRINT A$;" IS LEXICALLY LOWER THAN ";B$: REM TEST FOR LEXICALLY LOWER 70 IF A$ <= B$ THEN PRINT A$;" IS NOT LEXICALLY HIGHER THAN ";B$ 80 IF A$ >= B$ THEN PRINT A$;" IS NOT LEXICALLY LOWER THAN ";B$ 90 END</lang>
Burlesque
<lang burlesque> blsq ) "abc""abc"== 1 blsq ) "abc""abc"!= 0 blsq ) "abc""Abc"cm 1 blsq ) "ABC""Abc"cm -1 </lang>
cm is used for comparision which returns 1,0,-1 like C's strcmp. == is Equal and != is NotEqual.
J
Solution:
The primitive -:
can be used to determine whether two strings are equivalent, but J doesn't have other inbuilt lexical comparison operators. They can defined as follows:
<lang j>eq=: -: NB. equal
ne=: -.@-: NB. not equal
gt=: {.@/:@,&boxopen *. ne NB. lexically greater than
lt=: -.@{.@/:@,&boxopen *. ne NB. lexically less than
ge=: {.@/:@,&boxopen +. eq NB. lexically greater than or equal to
le=: -.@{.@/:@,&boxopen NB. lexically less than or equal to</lang>
Usage: <lang j> 'ball' (eq , ne , gt , lt , ge , le) 'bell' 0 1 0 1 0 1
'ball' (eq , ne , gt , lt , ge , le) 'ball'
1 0 0 0 1 1
'YUP' (eq , ne , gt , lt , ge , le) 'YEP'
0 1 1 0 1 0</lang>
Perl 6
<lang perl6>sub compare($a,$b) {
if $a eq $b { say "$a and $b are equal" } if $a ne $b { say "$a and $b are not equal" }
if $a gt $b { say "$a is lexically higher than $b" } if $a lt $b { say "$a is lexically lower than $b" }
if $a ge $b { say "$a is not lexically lower than $b" } if $a le $b { say "$a is not lexically higher than $b" }
say "The lexical relationship of $a and $b is { $a leg $b }"; say ;
}
compare 'YUP', 'YUP'; compare 'BALL', 'BELL'; compare 24, 123;</lang>
- Output:
YUP and YUP are equal YUP is not lexically lower than YUP YUP is not lexically higher than YUP The lexical relationship of YUP and YUP is Same BALL and BELL are not equal BALL is lexically lower than BELL BALL is not lexically higher than BELL The lexical relationship of BALL and BELL is Increase 24 and 123 are not equal 24 is lexically higher than 123 24 is not lexically lower than 123 The lexical relationship of 24 and 123 is Decrease
REXX
<lang rexx>animal = 'dog' if animal = 'cat' then
say animal "is lexically equal to cat"
if animal != 'cat' then
say animal "is not lexically equal cat"
if animal > 'cat' then
say animal "is lexically higher than cat"
if animal < 'cat' then
say animal "is lexically lower than cat"
if animal >= 'cat' then
say animal "is not lexically lower than cat"
if animal <= 'cat' then
say animal "is not lexically higher than cat"
/* The above comparative operators do not consider
leading and trailing whitespace when making comparisons. */
if ' cat ' = 'cat' then
say "this will print because whitespace is stripped"
/* To consider all whitespace in a comparison
we need to use strict comparative operators */
if ' cat ' == 'cat' then
say "this will not print because comparison is strict"</lang>
Here is a list of the strict comparative operators and their meaning:
- == Strictly Equal To
- !\== Strictly Not Equal To
- << Strictly Less Than
- >> Strictly Greater Than
- <<= Strictly Less Than or Equal To
- >>= Strictly Greater Than or Equal To
- !\<< Strictly Not Less Than
- !\>> Strictly Not Greater Than
Run BASIC
<lang runbasic>a$ = "dog" b$ = "cat" if a$ = b$ then print "the strings are equal" ' test for equalitY if a$ <> b$ then print "the strings are not equal" ' test for inequalitY if a$ > b$ then print a$;" is lexicallY higher than ";b$ ' test for lexicallY higher if a$ < b$ then print a$;" is lexicallY lower than ";b$ ' test for lexicallY lower if a$ <= b$ then print a$;" is not lexicallY higher than ";b$ if a$ >= b$ then print a$;" is not lexicallY lower than ";b$ end</lang>
Tcl
The best way to compare two strings in Tcl for equality is with the eq
and ne
expression operators:
<lang tcl>if {$a eq $b} {
puts "the strings are equal"
} if {$a ne $b} {
puts "the strings are not equal"
}</lang>
The numeric ==
and !=
operators also mostly work, but can give somewhat unexpected results when the both the values look numeric. The string equal
command is equally suited to equality-testing (and generates the same bytecode).
For ordering, the <
and >
operators may be used, but again they are principally numeric operators. For guaranteed string ordering, the result of the string compare
command should be used instead (which uses the unicode codepoints of the string):
<lang tcl>if {[string compare $a $b] < 0} {
puts "first string lower than second"
} if {[string compare $a $b] > 0} {
puts "first string higher than second"
}</lang>
Greater-or-equal and less-or-equal operations can be done by changing what exact comparison is used on the result of the string compare
.
Tcl also can do a prefix-equal (approximately the same as strncmp()
in C) through the use of the -length option:
<lang tcl>if {[string equal -length 3 $x "abc123"]} {
puts "first three characters are equal"
}</lang>
And case-insensitive equality is (orthogonally) enabled through the -nocase option. These options are supported by both string equal
and string compare
, but not by the expression operators.
UNIX Shell
<lang sh>#!/bin/sh
A=Bell B=Ball
- Traditional test command implementations test for equality and inequality
- but do not have a lexical comparison facility
if [ $A = $B ] ; then
ECHO 'The strings are equal'
fi if [ $A != $B ] ; then
ECHO 'The strings are not equal'
fi</lang>