qwertyuiopasdfghjklzxcvbnmqwe rtyuiopasdfghjklzxcvbnmqwertyui opasdfghjklzxcvbnmqwertyuiopa sdfghjklzxcvbnmqwertyuiopasdfg hjklzxcvbnmqwertyuiopasdfghjklz xcvbnmqwertyuiopasdfghjklzxcv bnmqwertyuiopasdfghjklzxcvbnm Term Paper of Data Structure qwertyuiopasdfghjklzxcvbnmqwe Operations on Strings rtyuiopasdfghjklzxcvbnmqwertyui

opasdfghjklzxcvbnmqwertyuiopa sdfghjklzxcvbnmqwertyuiopasdfg hjklzxcvbnmqwertyuiopasdfghjklz xcvbnmqwertyuiopasdfghjklzxcv bnmqwertyuiopasdfghjklzxcvbnm qwertyuiopasdfghjklzxcvbnmqwe rtyuiopasdfghjklzxcvbnmrtyuiopa

On DOS:12/19/2008 Submitted By: Name: Shruti Thakur Roll no.: 10 Reg.:3010070235 Course: BCA-MCA Dual Integrated Section: A

Operations on Strings 200 8

Acknowledgement
I would like to express my gratitude to all those who gave me helping hand in completing this term paper. I want to thank my teacher Miss. Rajdeep Kaur for helping me whenever I needed it the most. My friends have also supported me in my work. I want to thank them all for their help, support, interest and valuable hints.

Operations on Strings 200 8

Contents
Topics Introduction Operations on Strings Conclusion References Page no. 4-5 6-26 27 28

Operations on Strings 200 8 Introduction

String is a sequence of characters enclosed in quotes. E.g. Hello String processing is one of the most important and most frequent applications of a computer Java recognizes this fact and therefore provides special support for strings to make their use convenient Every string is an instance of Javas built in String class, thus, Strings are objects.

Declaration Like any object, a string can be created using new as in the following example: o String str1 = new String(Hello dear); However, as an extra support, Java allows String object to be created without the use of new, as in: o String str2=How are you; This is inconsistent with the way Java treats other classes. String objects are represented as a sequence of characters indexed from 0. Example: String greeting = Hello, World;

H 0

e 1

l 2

l 3

o 4

. 5

W 7

o 8

R 9

l 10

d 11

! 12

A common operation on Strings is extracting a substring from a a given string. Java provides two methods for this operation: Another special feature of Strings is that they are immutable. That is, once a string object is created, its content cannot be changed. For example, consider the following: String str1 = Hello World; str1 = str1.substring(4); Instead of changing the str1 object, another object is created. The former is garbage collected, thus, the reference to the former is lost. The fact that Strings are immutable allows the Java system to process Strings very efficiently. For example, consider the following:

Operations on Strings 200 8

String str1 = Hello; String str2 = Hello; We would expect the following But in fact, this is what happens The Java system is smart enough to know that the two strings are identical and allocates same memory location for the two objects

Operations on Strings 200 8

Operations in String

ABBREV Tests if one string is an abbreviation of another string. An abbreviation is a substring that starts at the beginning of a string. For example, 'auto' could be an abbreviation for 'automobile'.
Syntax:

result = ABBREV(string, abbreviation, length)

string is the string (for which abbreviation may be an abbreviation). abbreviation is a possible abbreviation of string. length is the minimum length that abbreviation must be in order to be considered as an abbreviation. If length is omitted, there is no restriction upon abbreviation's minimum length (and therefore an empty string would be considered an abbreviation for any other string).

Returns 1 if abbreviation is an abbreviation of string, or 0 if not. Notes ABBREV() is case sensitive, and leading/trailing spaces are not stripped off before the two strings are compared. Examples Example Use
ABBREV('Foobar', 'Foo') ABBREV('Foobar', 'Foo', 4) ABBREV('Foobar', 'foo')

Output
1 0 /* 'Foo' isn't at least 4 chars */ 0 /* Different case - 'F' versus 'f' */

Operations on Strings 200 8

CENTER Returns a string formatted to fit centered within a certain number of characters. If necessary, the string's size is decreased to fit into that many characters, or pad characters are used to fill out the new string with the original string centered within the new string. Syntax:
formatted = CENTER(string, length, padchar)

string is the original string (to format). length is the desired length of the final string. If length is less than the size of

the original string, then characters will be deleted from the front and end of the string in order to fit the desired length. If length is greater than the size of the original string, then the original string will be centered within the new string and padchar characters will be used to fill out the new string to the desired length. length must not be negative, nor have a fractional component -- it must be a positive whole number. padchar is the character to use for padding (if the original string is not already >= the desired length). If padchar is omitted, the default is a space character. Returns A copy of the original string extended to the desired length, with the original string centered within the new string, and padchars filling out the new string. Notes The original string is not altered. Only the returned value from CENTER is formatted. If length is an odd number, any extra padchar is placed on the right-hand side of the centered, original string. Examples Example Use
CENTER('Foobar',10)

Result
' Foobar '

Operations on Strings 200 8

CENTER('Foobar',11) CENTER('Foobar',3) CENTER('Foobar',4) CENTER('Foobar',10,*) ' Foobar ' 'oob' 'ooba' '**Foobar**'

CHANGESTR Exchanges any occurence of one substring (within a given string) with another substring. Syntax: newstring = CHANGESTR(searchfor, string, exchange)

string is the original string (to exchange substrings within). searchfor is which substring to search for (within string. If searchfor is an

empty string, then no exchange is performed, and the original string is returned. exchange is the substring to insert in place of searchfor, wherever searchfor occurs within string. If exchange is an empty string, then each occurence of searchfor is deleted without being replaced by anything. Returns A copy of the original string with all occurences of searchfor replaced with exchange. Notes The original string is not altered. Examples

Example Used
CHANGESTR('a', 'fred', 'c') CHANGESTR('', '', 'new string') CHANGESTR('a', 'abcdef', 'x') CHANGESTR('0', '0', '1') CHANGESTR('a', 'def', 'xyz') CHANGESTR('a', '', 'x')

Output
'fred' '' 'xbcdef' '1' 'def' ''

Operations on Strings 200 8

CHANGESTR('a', '', 'x') CHANGESTR('abc', 'abcdef', 'xyz') CHANGESTR('abcdefg', 'abcdef', 'xyz') 'def' 'xyzdef' 'abcdef'

COMPARE Compares two strings for inequality, and returns the position where they differ. Syntax: result = COMPARE(string1, string2, padchar)

string1 and string2 is the two strings to be compared.

If one of the strings is shorter than the other, padchar is the character used to pad out the shorter string to the same length as the longer string. If padchar is omitted, then by default, the shorter string is padded with extra spaces. Returns

0 if both strings are equal. If not equal, then the first position where the two strings are different is returned (where 1 is the first character in the strings). Notes COMPARE() is case-sensitive, so 'BLORT' does not equal 'blort'. Use TRANSLATE() or the UPPER keyword to upper-case the strings prior to COMPARE(), if desired. Leading and trailing spaces do matter, so ' blort ' does not equal 'blort'. Use STRIP() to removed leading/trailing space prior to COMPARE(), if desired. Example Examples Used
COMPARE('FooBar', 'Foobar') COMPARE('Foobar', 'Foobar') COMPARE('Foobarrr', 'Fooba') COMPARE('Foobarrr', 'Fooba', 'r')

Output 4 0 6 0

COPIES
9

Operations on Strings 200 8

Creates a new string that is another string concatenated (ie, appended) a specified number of times. Syntax: newstring = COPIES(string, total)

string is the original string (to append). If string is an empty string, then the

resulting newstring is also an empty string. total is a count of how many times to append string. total cannot be negative, nor have a fractional component -- it must be a positive whole number. If total is 0, an empty string is created. Returns The new string comprised of total instances of string appended. Examples: Example Used
COPIES('Foo', 3) COPIES('*', 16) COPIES('Bar ', 2) COPIES('', 10000)

Output
'FooFooFoo' '****************' 'Bar Bar ' ''

COUNTSTR Counts how many occurences of a substring are within another string. Syntax: howmany = COUNTSTR(searchfor, string)

string is the original string (to search for searchfor within). searchfor is which substring to search for within string. If searchfor is an
empty string, then 0 is returned to indicate no occurrences of searchfor within string. Returns

10

Operations on Strings 200 8

A count of how many occurrences of searchfor appear within string. Example Example Used
COUNTSTR('', '') COUNTSTR('a', 'abcdef') COUNTSTR(0, 0) COUNTSTR('a', 'def') COUNTSTR('a', '') COUNTSTR('', 'def') COUNTSTR('abc', 'abcdef') COUNTSTR('abc', 'abcdef') COUNTSTR('abc', 'abcdefabccdabcd') COUNTSTR('aaa', 'aaaaaa')

Output 0 1 1 0 0 0 1 0 3 2

DELSTR Removes one or more characters from a string. Syntax: newstring = DELSTR(string, start, length)

string is the string to remove characters from. start is which character number to start removing from, where 1 would be to

start removing at the first character in the string. If there are less characters in the string than start, then no characters are removed. length is the desired number of characters to remove (within string), starting at (ie, including) the start character. If length is omitted, then the default is to remove all character from the start character to the end of the string. length cannot be negative, nor have a fractional component -- it must be a positive whole number. Returns A copy of the original string without the removed characters.

11

Operations on Strings 200 8

Notes It is not an error if start or length (or a combination of them) refers to more characters than string actually contains. The original string is not altered. Only the returned value from DELSTR has characters removed. Example: Example Used
DELSTR('Foobar', 3) DELSTR('Foobar', 3, 2) DELSTR('Foobar', 3, 4) DELSTR('Foobar', 7)

Output
'Foo' 'Foor' 'Foo' 'Foobar'

EXPAND Replaces tab characters with spaces, or vice versa. Syntax: newstring = EXPAND(string, options, tablewidth2, tablewidth2, )

string is the string to replace characters within. options is the desired operation. It is one of the following:
Meaning Replace each tab character with an appropriate number of spaces based upon the tabwidth args. Replace space characters with a tab character based upon the tabwidth args.

>Optio n 'S' 'T'

If omitted, options defaults to 'S'.

tabwidth1 is the desired width of the first tab stop. For example, a value of
'8' would put the first tab stop at the eighth character. If omitted, tabwidth1

12

Operations on Strings 200 8

defaults to 8. There may be more tabwidth arguments supplied. For example, if tabwidth2 is supplied, then this sets the width of the second tab stop. For example, a value of '8' would effectively put the second tab stop at the sixteenth character. If there are more spaces/tabs to be replaced than there are tabwidths specified, then the value of the last tabwidth is used for all subsequent replacements. Returns A copy of the original string with the space/tab characters replaced. Notes The first character in string is presumed to be at a tabstop. The original string is not altered. Only the returned value from EXPAND has characters replaced. Some interpreters do not support this function. Example: Example Used
EXPAND(' Foo bar', 'T', 3) EXPAND(' Foo bar', 'T') EXPAND(' Foo bar', 'T', 3) EXPAND(' Foo bar', 'T') EXPAND(' Foo bar ', 'T', 3, 3, 6)

Output
'09'X || 'Foo' || '09'X || 'bar' ' Foo bar' ' Foo' || '09'X || ' bar' '09'X || 'Foo bar' '0909'X || ' Foo' || '09'X || ' bar '

INSERT Inserts a substring into another string. Syntax: Newstring = INSERT(insert, string, position, length, padchar)

insert is the substring to be inserted (into string). string is the string into which insert is inserted.

13

Operations on Strings 200 8

position is the desired character position (within string) after which to insert

insert. A position of 0 would cause insert to be inserted before the first character in string (ie, at the very start). A position of 1 would cause insert to be inserted after the first character in string (ie, at the very start). If position is greater than the number of characters in string, then insert will be inserted after the last character of string. If position is omitted, then it defaults to 0. length is the desired length for insert. If insert is larger, then characters will be deleted from the end of the string in order to fit the desired length. If insert is smaller, then it is padded out with padchar characters at the end to fit the desired length. length must not be negative, nor have a fractional component -it must be a positive whole number. If length is omitted, then no truncation nor padding is performed upon insert. padchar is the character to use for padding (if the insert is not already >= length). If padchar is omitted, the default is a space character. Returns A copy of the original string with insert inserted into it. Notes The original string is not altered. Only the returned value from INSERT has the inserted substring. Example: Example Used
INSERT('first', 'SECOND') INSERT('first', 'SECOND', 3) INSERT('first', 'SECOND', 3, 10) INSERT('first', 'SECOND', 3, 10, *) INSERT('first', 'SECOND', 3, 4) INSERT('first', 'SECOND', 8)

Output
'SECONDfirst' 'fiSECONDrst' 'fiSECOND rst' 'fiSECOND****rst' 'fiSECOrst' 'first SECOND'

LASTPOS Finds the last occurrence of a substring within another string.

14

Operations on Strings 200 8

Syntax: Where = LASTPOS(searchfor, string, start)

searchfor is which substring to search for (within string. If searchfor is an

empty string, then 0 is returned to indicate no occurrences of searchfor within string. string is the original string (to search for searchfor within). start is which character position to start the backward search from, where 1 would be to start searching backwards at the first character in string. If omitted, the default is to start searching from the last character. start must not be negative, nor have a fractional component -- it must be a positive whole number. Returns If searchfor is found, then LASTPOS() returns the character position where the last occurrence of searchfor occurs within string (where 1 is the first character within string). If searchfor is not found, then LASTPOS() returns 0. Examples Example Used
LASTPOS('be', 'to be or not to be') LASTPOS('be', 'to be or not to be', 10) LASTPOS('is', 'to be or not to be')

Output 17 3 0

LEFT Excerpts one or more characters from the left-hand side of a string. Syntax: excerpt = LEFT(string, length, padchar)

string is the original string (from which to excerpt characters). length is the number of characters to be excerpted. If length is 0, no
characters are excerpted. If length is greater than the number of characters in

15

Operations on Strings 200 8

string, then the excerpt is padded out with padchar characters to the desired length. padchar is the character to use for padding (if the original string is not >= length). If padchar is omitted, the default is a space character. Returns A string containing the excerpted characters. Notes The original string is not altered. Example: Example Used
LEFT('Foo bar', 5) LEFT('Foo bar', 3) LEFT('Foo bar', 10) LEFT('Foo bar', 10, '*')

Output
'Foo b' 'Foo' 'Foo bar ' 'Foo bar***'

LENGTH Counts the number of characters in a string. Syntax: howmany = LENGTH(string)

string is the string (whose length is to be calculated).

Returns A count of how many characters are in the string. Notes Leading and trailing spaces are counted. You may wish to use STRIP first to trim those spaces.

16

Operations on Strings 200 8

Example: Example Used
LENGTH('') LENGTH('Foo') LENGTH(' Foo bar ') LENGTH(' foo bar ')

Output 0 3 7 10

OVERLAY Overlays a substring into another string. OVERLAY() differs from INSERT() in that OVERLAY() overwrites characters in the string. Syntax: newstring = OVERLAY(overlay, string, position, length, padchar)

overlay is the substring to be inserted (into string). string is the string into which overlay is overlaid. position is the desired character position (within string) at which to overlay overlay.
A position of 1 would cause overlay to be overlaid at the first character in string (ie, at the very start). If position is greater than the number of characters in string, then the new string will be padded out with padchar characters and then overlay will be inserted after those pad characters. If position is omitted, then it defaults to 1.

length is the desired length for overlay. If overlay is larger, then characters will be
deleted from the end in order to fit the desired length. If overlay is smaller, then it is padded out with padchar characters at the end to fit the desired length. length must not be negative, nor have a fractional component -- it must be a positive whole number. If length is omitted, then no truncation nor padding is performed upon overlay.

padchar is the character to use for padding (if the overlay is not already >= length).
If padchar is omitted, the default is a space character. Returns

17

Operations on Strings 200 8

A copy of the original string with overlay overlaid in it. Notes The original string is not altered. Only the returned value from OVERLAY has the overlaid substring. Example Used
OVERLAY('NEW', 'old-value') OVERLAY('NEW', 'old-value', 4) OVERLAY('NEW', 'old-value', 4, 5) OVERLAY('NEW', 'old-value', 4, 5, *) OVERLAY('NEW', 'old-value', 4, 2) OVERLAY('NEW', 'old-value', 8) OVERLAY('NEW', 'old-value', 11) OVERLAY('NEW', 'old-value', 4, 2) OVERLAY('NEW', 'old-value', 9)

Output
'NEW-value' 'oldNEWlue' 'oldNEW e' 'oldNEW**e' 'oldNEalue' 'old-valuNEW' 'old-value NEW' 'oldNEalue' 'old-valuNEW'

POS Finds the first occurrence of a substring within another string. Syntax: where = POS(searchfor, string, start)

searchfor is which substring to search for (within string. If searchfor is an

empty string, then 0 is returned to indicate no occurrences of searchfor within string. string is the original string (to search for searchfor within). start is which character position to start the search from, where 1 would be to start searching at the first character in string. If omitted, the default is to start searching from the first character. start must not be negative, nor have a fractional component -- it must be a positive whole number. Returns If searchfor is found, then POS() returns the character position where the first occurrence of searchfor occurs within string (where 1 is the first character within string). If searchfor is not found, then POS() returns 0.

18

Operations on Strings 200 8

Example: Example Used
POS('be', 'to be or not to be') POS('to', 'to be or not to be',10) POS('to', 'to be or not to be',18) POS('is', 'to be or not to be')

Output 4 17 0 0

REVERSE Reverses the order of characters in a string. Syntax: newstring = REVERSE(string)

string whose characters are to be reversed.

Returns

A copy of the original string with the order of its characters reversed. Notes The original string is not altered. Only the return value of REVERSE has its characters reversed. Example: Example Used
REVERSE('FooBar') REVERSE(' Foo Bar') REVERSE('3.14159') 'raBooF' 'raB ooF ' '95141.3'

Output

RIGHT Excerpts one or more characters from the right-hand side of a string.

19

Operations on Strings 200 8

Syntax: excerpt = RIGHT(string, length, padchar)

string is the original string (from which to excerpt characters). length is the number of characters to be excerpted. If length is 0, no characters

are excerpted. If length is greater than the number of characters in string, then the excerpt is padded out on the left with padchar characters to the desired length. padchar is the character to use for padding (if the original string is not >= length). If padchar is omitted, the default is a space character. Returns A string containing the excerpted characters. Notes The original string is not altered. Examples Example Use
RIGHT('Foo bar', 5) RIGHT('Foo bar', 4) RIGHT('Foo bar', 10)

Output
'o bar' ' bar' ' Foo bar'

STRIP Removes leading and/or trailing space (or other) characters from a string. Syntax: newstring = STRIP(string, option, padchar)

string whose leading and trailing space characters are to be removed. padchar is the character to strip. If padchar is omitted, the default is a space
character.

20

Operations on Strings 200 8

option determines whether padchars are stripped from the beginning and/or
end of string. It must be one of the following:

Optio n L T B

Meaning (Leading) Only leading characters are stripped. Trailing characters are not. (Trailing) Only trailing characters are stripped. Leading characters are not. (Both) Both leading and trailing characters are stripped.

If omitted, option defaults to 'B'. Returns A copy of the original string with its leading and trailing space characters removed. Notes The original string is not altered. Only the return value of STRIP has its leading/trailing padchars removed. This removes only those padchars appearing at the front or end of the string. To delete padchars within the string, use SPACE(). When padchar is omitted, Reginald strips TAB characters as well as space characters. Other interpreters may strip only space characters (ie, not TAB). Example Example Used
STRIP(' FooBar') STRIP(' Foo Bar ') STRIP(' Foo Bar ', 'L') STRIP(' 3.14159 ') STRIP('*** Foo *** Bar ***', ,'*')

Output
'FooBar' 'Foo Bar' 'Foo Bar ' '3.14159' ' Foo *** Bar'

SUBSTR
21

Operations on Strings 200 8

Excerpts one or more characters from a string, and returns that excerpt. Syntax: excerpt = SUBSTR(string, start, length, padchar)

string is the original string (from which to excerpt characters). start is which character position to start the excerpt from, where 1 would be to

start the excerpt at the first character in the string. If there are less characters in the string than start, then an empty string is returned. start cannot be 0 or negative, nor have a fractional component -- it must be a positive whole number. length is the number of characters to be excerpted, starting at the character position start. If length is omitted, the default is to excerpt all characters from start to the end of the string. If length is 0, no characters are excerpted. length cannot be negative, nor have a fractional component -- it must be a positive integer. padchar is the character to use for padding (if the original string is not >= length + start). If padchar is omitted, the default is a space character. Returns A string containing the excerpted characters. Notes Any leading or trailing spaces are not trimmed from the excerpt. It is not an error if start or length (or a combination of them) refers to more characters than string actually contains. The original string is not altered. Example Example Used
SUBSTR('Foo bar', 3) SUBSTR('Foo bar', 3, 3) SUBSTR('Foo bar', 4, 6) SUBSTR('Foo bar', 4, 6, '*') SUBSTR('Foo bar', 9, 4, '*')

Output
'o bar' 'o b' ' bar ' ' bar**' '****'

22

Operations on Strings 200 8

TRANSLATE Translates characters in a string to other characters, or makes a string uppercase. Syntax: newstring = TRANSLATE(string, tableout, tablein, padchar)

string is the original string (to translate). tablein is a string containing upto 256 characters, representing characters that you wish translated to the respective characters in tableout.
If one or both of the tables are specified, each character in string that exists in tablein is translated to the character in tableout that occupies the same position as the tablein character. Characters in string which are not found in tablein are left unchanged. If omitted, tablein defaults to all 256 characters of the computer's default character set. If omitted, tableout defaults to an empty set.If tableout is larger than tablein, the extra entries are ignored. If smaller than tablein, tableout is padded with padchar characters to the same length as tablein. If padchar is omitted, the default padding is space characters. If both of the tables are omitted, TRANSLATE() upper-cases string. If a character occurs more than once in tablein, only the first occurrence will matter. Returns

A copy of the original string with each tablein character translated to its respective tableout's character. Notes The original string is not altered. Only the return value of TRANSLATE has its characters translated. Some REXX interpreters support the UPPER keyword which can be used to translate the value of a variable.
/* Upper-case My_Variable's value. */ UPPER My_Variable

23

Operations on Strings 200 8

You can also specify a variable whose value is the name of the variables whose values you wish upper-cased. You put that variable's name in parentheses.
/* Upper-case My_Variable's and Something.1's values. */ these = 'My_Variable Something.1' UPPER (these)

Examples Examples Used

TRANSLATE('FooBar') TRANSLATE('FooBar', 'ABFORabfor', 'abforABFOR') TRANSLATE('FooBar', 'abfor') TRANSLATE('FooBar', 'abfor', , '#')

Output
'FOOBAR' 'fOObAR' 'F B ' 'F##B##'

VERIFY Tests if any characters of one string also occur in another string. Syntax: Where = VERFY(string, Lookfor, option, start)

string is the string to search (for lookfor). start is which character number to start searching from, where 1 would be to

start searching at the first character in the string. If there are less characters in the string than start, then a 0 is returned to indicate that no characters in lookfor matched. option must be one of:
Optio n N Meaning (Nomatch) Return the position of the first character in string that isn't found in lookfor, or 0 if all of the characters in string also exist in

24

Operations on Strings 200 8

lookfor. M (Match) Return the position of the first character in string that also exists in lookfor, or 0 none of the characters in string also exist in lookfor.

If omitted, option defaults to 'N'. Returns A character position (where 1 is the first character in string). Notes It is not an error if start refers to more characters than string actually contains. Example: Example Used
VERIFY('foobar', 'barfo') VERIFY('foobar', 'barfo', 'M') VERIFY('foobar', 'fob', 'N') VERIFY('foobar', 'barf', 'N', 3) VERIFY('foobar', 'barf', 'N', 4)

Output 2 2 5 3 0

XRANGE Creates a range of characters between a given start character and end character. The range of characters is produced from the computer's character set. Syntax: newstring = XRANGE(start, end)

start is which character to start from. If omitted, the default is to start from
character 0 ('00'x).

25

Operations on Strings 200 8

end is which character to end at. If omitted, the default is to end at character
255 ('ff'x). Returns

A string that consists of all the characters from start through end, inclusive. Notes The actual representation of the output from XRANGE() depends on the character set used by your computer. If the value of start is larger than the value of end, the output will wrap around from ffx to 00x. If start or end is not a string containing exactly one character, this raises a SYNTAX error. Example: Example Used
XRANGE('A', 'J') XRANGE('FC'x) XRANGE(, '05'x) XRANGE('FD'x, '04'x)

Output
'ABCDEFGHIJ' 'FCFDFEFF'x '000102030405'x 'FDFEFF0001020304'x

26

Operations on Strings 200 8

Conclusion
A string is basically a sequence of characters that can be indexed. The string datatype provides a number of useful and powerful high level operations. All the operations of strings are discussed above, all the syntax and examples helps us to understand the concept of operations on strings.

27

Operations on Strings 200 8

References
www.cs.grinnell.edu/~rebelsky/Espresso/Readings/strings.html www.cs.hmc.edu/~geoff/classes/hmc.cs070.200401/notes/strings.html www.ezysoftware.com/ezyprolog/Prolog_Inference_Engine/Prolog.../String_o perations/psp_cat_String_Operations.htm

28