String matching: Difference between revisions
m
→{{header|EasyLang}}
Puppydrum64 (talk | contribs) |
|||
(21 intermediate revisions by 16 users not shown) | |||
Line 23:
{{trans|Python}}
<
print(‘abcd’.ends_with(‘zn’))
print(‘bb’ C ‘abab’)
print(‘ab’ C ‘abab’)
print(‘abab’.find(‘bb’) ? -1)
print(‘abab’.find(‘ab’) ? -1)</
{{out}}
Line 41:
=={{header|360 Assembly}}==
<
STRMATCH CSECT
USING STRMATCH,R15
Line 74:
PG DC CL80' '
YREGS
END STRMATCH</
{{out}}
<pre>
Line 88:
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits}}
<syntaxhighlight lang="aarch64 assembly">
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program strMatching64.s */
Line 339:
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
</syntaxhighlight>
=={{header|Action!}}==
<
BYTE i,j,found
Line 450:
TestEndsWith("1234abc","abc")
TestEndsWith("1234abc","ab")
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/String_matching.png Screenshot from Atari 8-bit computer]
Line 466:
=={{header|Ada}}==
<syntaxhighlight lang="ada">
with Ada.Strings.Fixed; use Ada.Strings.Fixed;
with Ada.Text_IO; use Ada.Text_IO;
Line 487:
);
end Match_Strings;
</syntaxhighlight>
{{out}}
<pre>
Line 497:
=={{header|Aime}}==
<
data b;
Line 518:
o_form("starts with, embeds, ends with \"~\": ~, ~, ~\n", t, b.seek(t) == 0,
b.seek(t) != -1,
b.seek(t) != -1 && b.seek(t) + ~t == ~b);</
{{out}}
<pre>starts with, embeds, ends with "Bang": 1, 1, 0
Line 529:
{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}
{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - string in string is non-standard?}}
<
PRIO STARTSWITH = 5, ENDSWITH = 5;
OP STARTSWITH = (STRING str, prefix)BOOL: # assuming LWB = 1 #
Line 546:
(string in string("ab",loc,"abab")|loc|-1), # returns +1 #
(string in string("ab",loc2,"abab"[loc+1:])|loc+loc2|-1) # returns +3 #
))</
{{out}}
<pre>
Line 553:
=={{header|AppleScript}}==
<
set string1 to "I felt happy"
Line 569:
-- Print the location of the match for part 2
offset of string2 in stringA --> 69</
AppleScript doesn't have a builtin means of matching multiple occurrences of a substring, however one can redefine the existing '''offset''' command to add this functionality:
<
on offset of needle in haystack
local needle, haystack
Line 593:
end offset
offset of "happy" in stringA --> {8, 44, 83, 110}</
or, defining an '''offsets''' function in terms of a more general '''findIndices''':
<
on offsets(needle, haystack)
script match
Line 666:
end script
end if
end mReturn</
{{Out}}
<pre>{8, 44, 83, 110}</pre>
Line 672:
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
/* ARM assembly Raspberry PI */
/* program strMatching.s */
Line 914:
bx lr @ return
</syntaxhighlight>
=={{header|Arturo}}==
<
print prefix? "abcd" "cd"
print suffix? "abcd" "ab"
Line 929:
print index "abcd" "bc"
print index "abcd" "xy"</
{{out}}
Line 945:
=={{header|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">
String1 = abcd
String2 = abab
Line 960:
If TempVar = %String2%
MsgBox, "%String1%" ends with "%String2%".
</syntaxhighlight>
=={{header|AutoIt}}==
<
$string2 = "ard"
Line 993:
EndIf
</syntaxhighlight>
=={{header|AWK}}==
<
{ pos=index($2,$1)
print $2, (pos==1 ? "begins" : "does not begin" ), "with " $1
print $2, (pos ? "contains an" : "does not contain" ), "\"" $1 "\""
if (pos) {
l=length($1)
Pos=pos
s=$2
x+=Pos
s=substr(s,Pos+l)
Pos=index(s,$1)
}
}
print $2, (substr($2,pos)==$1
}
</syntaxhighlight>
=={{header|BASIC}}==
{{works with|QBasic}}
<
'Determining if the first string starts with second string
Line 1,048 ⟶ 1,045:
END IF
</syntaxhighlight>
{{out}}
Line 1,056 ⟶ 1,053:
==={{header|Applesoft BASIC}}===
<
20 S$ = "TH"
30 DEF FN S(P) = MID$(A$, P, LEN(S$)) = S$
Line 1,073 ⟶ 1,070:
310 E$(1) = "ENDS"
320 E$(0) = "DOES NOT END"
330 PRINT E$(FN S(LEN(A$) - LEN(S$) + 1))" WITH "S$</
=={{header|Batch File}}==
<
::you put some of the CMD special characters (ex. %,!, etc) inside the strings.
::
Line 1,145 ⟶ 1,142:
set /a length+=1
goto loop
::/The functions.</
{{out}}
<pre>"qwertyuiop" begins with "qwerty".
Line 1,159 ⟶ 1,156:
=={{header|BBC BASIC}}==
<
FOR test% = 1 TO 3
Line 1,191 ⟶ 1,188:
UNTIL I% = 0
= N%
</syntaxhighlight>
{{out}}
<pre>"The fox jumps over the dog" starts with "The"
Line 1,205 ⟶ 1,202:
<code>⍷</code> does much of the heavy lifting here. It is commuted with <code>˜</code> so the order of the arguments makes sense.
<
Contains ← ∨´⍷˜
Line 1,211 ⟶ 1,208:
EW ← ¯1⊑⍷˜
Locs ← /⍷˜</
{{Out|Usage}}
<
1
"abcd" SW "cd"
Line 1,230 ⟶ 1,227:
1
"abab" Locs "ab"
⟨ 0 2 ⟩</
=={{header|Bracmat}}==
Bracmat does pattern matching in expressions <code><i>subject</i>:<i>pattern</i></code> and in strings <code>@(<i>subject</i>:<i>pattern</i>)</code>. The (sub)pattern <code>?</code> is a wild card.
<
& out$(@(!sentence:I ?) & "sentence starts with 'I'" | "sentence does not start with 'I'")
& out$(@(!sentence:? such ?) & "sentence contains 'such'" | "sentence does not contain 'such'")
Line 1,242 ⟶ 1,239:
| out$str$("sentence contains " !N " occurrences of 'be'")
)
)</
In the last line, Bracmat is forced by the always failing node <code>~</code> to backtrack until all occurrences of 'be' are found.
Thereafter the pattern match expression fails.
Line 1,256 ⟶ 1,253:
=={{header|C}}==
Case sensitive matching:
<
#include <stdio.h>
Line 1,287 ⟶ 1,284:
return 0;
}</
{{out}}
<pre>Starts with Test ( Hello,Hell ) : 1
Line 1,293 ⟶ 1,290:
Contains Test ( Google,msn ) : 0</pre>
Code without using string library to demonstrate how char strings are just pointers:
<
/* returns 0 if no match, 1 if matched, -1 if matched and at end */
Line 1,336 ⟶ 1,333:
return 0;
}</
{{out}}
<pre>matching `A Short String' with `ort S':
Line 1,353 ⟶ 1,350:
=={{header|C sharp|C#}}==
{{works with|Mono|2.6}}
<
class Program
{
Line 1,367 ⟶ 1,364:
}
}
</syntaxhighlight>
=={{header|C++}}==
<
using namespace std;
Line 1,383 ⟶ 1,380:
s1.find(s2)//returns string::npos
int loc=s2.find(s3)//returns 0
loc=s2.find(s3,loc+1)//returns 2</
=={{header|Clojure}}==
{{trans|Java}}
<
(. "abcd" endsWith "zn")
(. "abab" contains "bb")
Line 1,396 ⟶ 1,393:
user> (for [i evals] [i (eval i)])
([(. "abcd" startsWith "ab") true] [(. "abcd" endsWith "zn") false] [(. "abab" contains "bb") false] [(. "abab" contains "ab") true] [(. "abab" indexOf "bb") -1] [(let [loc (. "abab" indexOf "ab")] (. "abab" indexOf "ab" (dec loc))) 0])</
=={{header|CoffeeScript}}==
Line 1,402 ⟶ 1,399:
This example uses string slices, but a better implementation might use indexOf for slightly better performance.
<
matchAt = (s, frag, i) ->
s[i...i+frag.length] == frag
Line 1,423 ⟶ 1,420:
console.log matchLocations "bababab", "bab" # [0,2,4]
console.log matchLocations "xxx", "x" # [0,1,2]
</syntaxhighlight>
=={{header|Common Lisp}}==
<
(defun starts-with-p (str1 str2)
"Determine whether `str1` starts with `str2`"
Line 1,455 ⟶ 1,452:
(print (containsp "ababaBa" "ba")) ; (1 3)
(print (containsp "foobar" "x")) ; NIL
</syntaxhighlight>
=={{header|Component Pascal}}==
BlackBox Component Builder
<
MODULE StringMatch;
IMPORT StdLog,Strings;
Line 1,573 ⟶ 1,570:
END Do;
END StringMatch.
</syntaxhighlight>
Execute: ^Q StringMatching.Do <br/>
{{out}}
Line 1,598 ⟶ 1,595:
=={{header|D}}==
<
import std.stdio;
import std.algorithm: startsWith, endsWith, find, countUntil;
Line 1,613 ⟶ 1,610:
[1, 2, 3].countUntil(3).writeln; // 2
[1, 2, 3].countUntil([2, 3]).writeln; // 1
}</
{{out}}
<pre>true
Line 1,625 ⟶ 1,622:
=={{header|DCL}}==
<
$ length_of_first_string = f$length( first_string )
$ second_string = p2
Line 1,648 ⟶ 1,645:
$ else
$ write sys$output "first string does not end with the second string"
$ endif</
{{out}}
<pre>$ @string_matching efabcdef ef
Line 1,668 ⟶ 1,665:
=={{header|Delphi}}==
<
{$APPTYPE CONSOLE}
Line 1,680 ⟶ 1,677:
Writeln(AnsiContainsText('abcd', 'ab')); // True
WriteLn(Pos('ab', 'abcd')); // 1
end.</
=={{header|Dyalect}}==
<
value = "abcd".EndsWith("zn") //returns false
value = "abab".Contains("bb") //returns false
value = "abab".Contains("ab") //returns true
var loc = "abab".IndexOf("bb") //returns -1
loc = "abab".IndexOf("ab") //returns 0</
=={{header|E}}==
<
println(string1.startsWith(string2))
Line 1,703 ⟶ 1,700:
println(string1.endsWith(string2))
}</
=={{header|EchoLisp}}==
<
(string-suffix? "nette" "Antoinette") → #t
(string-prefix? "Simon" "Simon & Garfunkel") → #t
Line 1,712 ⟶ 1,709:
(string-match "Antoinette" "net") → #t ;; contains
(string-index "net" "Antoinette") → 5 ;; substring location
</syntaxhighlight>
=={{header|EasyLang}}==
<syntaxhighlight>
func starts s$ t$ .
if substr s$ 1 len t$ = t$
return 1
.
return 0
.
func ends s$ t$ .
if substr s$ (len s$ - len t$ + 1) len t$ = t$
return 1
.
return 0
.
func contains s$ t$ .
return if strpos s$ t$ > 0
.
print starts "hello world" "he"
print ends "hello world" "rld"
print contains "hello world" "wor"
</syntaxhighlight>
=={{header|Elena}}==
ELENA
<
public program()
Line 1,722 ⟶ 1,742:
var s := "abcd";
console.printLine(s," starts with ab: ",s.startingWith
console.printLine(s," starts with cd: ",s.startingWith
console.printLine(s," ends with ab: ",s.endingWith
console.printLine(s," ends with cd: ",s.endingWith
console.printLine(s," contains ab: ",s.containing
console.printLine(s," contains bc: ",s.containing
console.printLine(s," contains cd: ",s.containing
console.printLine(s," contains az: ",s.containing
console.printLine(s," index of az: ",s.indexOf(0, "az"));
Line 1,739 ⟶ 1,759:
console.readChar()
}</
=={{header|Elixir}}==
The String module has functions that cover the base requirements.
<
s2 = "adab"
s3 = "ab"
Line 1,770 ⟶ 1,790:
Regex.scan(~r/#{s3}/, "abcabc", return: :index)
# => [[{0, 2}], [{3, 2}]]</
=={{header|Emacs Lisp}}==
<
(string-match (regexp-quote needle) haystack))
Line 1,786 ⟶ 1,806:
(string-prefix-p "after" "before center after") ;=> nil
(string-contains "after" "before center after") ;=> 14
(string-suffix-p "after" "before center after") ;=> t</
=={{header|Erlang}}==
<
-module(character_matching).
-export([starts_with/2,ends_with/2,contains/2]).
Line 1,818 ⟶ 1,838:
contains(_S1,_S2,_N,Acc) ->
Acc.
</syntaxhighlight>
=={{header|Euphoria}}==
<
integer x
Line 1,850 ⟶ 1,870:
else
printf(1, "'%s' does not end with '%s'\n", {first, second})
end if</
{{out}}
Line 1,859 ⟶ 1,879:
=={{header|F_Sharp|F#}}==
<
let main args =
Line 1,882 ⟶ 1,902:
if idx < 0 then None else Some (idx, idx+1)) 0
|> Seq.iter (printfn "substring %A begins at position %d (zero-based)" contains)
0</
{{out}}
<pre>text = "一二三四五六七八九十"
Line 1,898 ⟶ 1,918:
=={{header|Factor}}==
Does <code>cheesecake</code> start with <code>cheese</code>?
<
Does <code>cheesecake</code> contain <code>sec</code> at any location?
<
Does <code>cheesecake</code> end with <code>cake</code>?
<
Where in <code>cheesecake</code> is the leftmost <code>sec</code>?
<
Where in <code>Mississippi</code> are all occurrences of <code>iss</code>?
<
"Mississippi" "iss" <regexp> all-matching-slices [ from>> ] map ! { 1 4 }</
=={{header|Falcon}}==
'''VBA/Python programmer's approach. I'm just a junior Falconeer but this code seems falconic''
<
/* created by Aykayayciti Earl Lamont Montgomery
April 9th, 2018 */
Line 1,926 ⟶ 1,946:
> s1.endsWith(s2) ? @ "s1 ends with $s2" : @ "$s1 does not end with $s2"
</syntaxhighlight>
{{out}}
<pre>
Line 1,947 ⟶ 1,967:
* <code>indexrIgnoreCase</code> (like above, ignoring case for ASCII characters)
<
class Main
{
Line 1,970 ⟶ 1,990:
}
}
</syntaxhighlight>
{{out}}
Line 1,988 ⟶ 2,008:
=={{header|FBSL}}==
<
DIM s = "roko, mat jane do"
Line 2,003 ⟶ 2,023:
WHILE INSTR(mane, match, INSTR + 1): PRINT " ", INSTR;: WEND
END SUB
</syntaxhighlight>
{{out}}
<pre>"roko, mat jane do" starts with "roko"
Line 2,013 ⟶ 2,033:
=={{header|Forth}}==
<
tuck 2>r min 2r> compare 0= ;
: ends-with ( a l a2 l2 -- ? )
tuck 2>r negate over + 0 max /string 2r> compare 0= ;
\ use SEARCH ( a l a2 l2 -- a3 l3 ? ) for contains</
=={{header|Fortran}}==
Line 2,026 ⟶ 2,046:
In the case of STARTS, these annoyances can be left to the INDEX function rather than comparing the start of A against B. At the cost of it searching the whole of A if B is not at the start. Otherwise, it would be the mirror of ENDS.
<syntaxhighlight lang="fortran">
SUBROUTINE STARTS(A,B) !Text A starts with text B?
CHARACTER*(*) A,B
Line 2,067 ⟶ 2,087:
CALL ENDS("Brief","Much longer")
END
</syntaxhighlight>
Output: text strings are bounded by >''etc.''< in case of leading or trailing spaces.
<pre>
Line 2,079 ⟶ 2,099:
Similar program using modern Fortran style
<syntaxhighlight lang="fortran">
!-----------------------------------------------------------------------
!Main program string_matching
Line 2,142 ⟶ 2,162:
end function ends
end program string_matching
</syntaxhighlight>
Output: false = 0, true = 1 ( + multiple occurrences if applicable)
<pre>
Line 2,157 ⟶ 2,177:
=={{header|FreeBASIC}}==
<
Dim As String s1 = "abracadabra"
Line 2,182 ⟶ 2,202:
Print
Print "Press any key to quit"
Sleep</
{{out}}
Line 2,192 ⟶ 2,212:
First string contains second string : at index 1 and at index 8
First string ends with second string : true
</pre>
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">window 1, @"String matching", (0,0,650,360)
void local fn DoIt
CFStringRef s1, s2
CFRange range
s1 = @"alphabravocharlie"
s2 = @"alpha"
if ( fn StringHasPrefix( s1, s2 ) )
print @"\"";s1;@"\" starts with \"";s2;@"\""
else
print @"\"";s1;@"\" does not start with \"";s2;@"\""
end if
print
s2 = @"bravo"
if ( fn StringHasPrefix( s1, s2 ) )
print @"\"";s1;@"\" starts with \"";s2;@"\""
else
print @"\"";s1;@"\" does not start with \"";s2;@"\""
end if
print
range = fn StringRangeOfString( s1, s2 )
if ( range.location != NSNotFound )
print @"\"";s1;@"\" contains \"";s2;@"\" at location ";(range.location)
else
print @"\"";s1;@"\" does not contain \"";s2;@"\""
end if
print
s2 = @"delta"
range = fn StringRangeOfString( s1, s2 )
if ( range.location != NSNotFound )
print @"\"";s1;@"\" contains \"";s2;@"\" at location ";(range.location)
else
print @"\"";s1;@"\" does not contain \"";s2;@"\""
end if
print
s2 = @"charlie"
if ( fn StringHasSuffix( s1, s2 ) )
print @"\"";s1;@"\" ends with \"";s2;@"\""
else
print @"\"";s1;@"\" does not end with \"";s2;@"\""
end if
print
s2 = @"alpha"
if ( fn StringHasSuffix( s1, s2 ) )
print @"\"";s1;@"\" ends with \"";s2;@"\""
else
print @"\"";s1;@"\" does not end with \"";s2;@"\""
end if
print
s1 = @"alpha delta charlie delta echo delta futurebasic"
s2 = @"delta"
range = fn StringRangeOfString( s1, s2 )
while ( range.location != NSNotFound )
print @"\"";s1;@"\" contains \"";s2;@"\" at location ";(range.location)
range.location++
range = fn StringRangeOfStringWithOptionsInRange( s1, s2, 0, fn CFRangeMake( range.location, len(s1)-range.location ) )
wend
end fn
fn DoIt
HandleEvents</syntaxhighlight>
{{out}}
<pre>
"alphabravocharlie" starts with "alpha"
"alphabravocharlie" does not start with "bravo"
"alphabravocharlie" contains "bravo" at location 5
"alphabravocharlie" does not contain "delta"
"alphabravocharlie" ends with "charlie"
"alphabravocharlie" does not end with "alpha"
"alpha delta charlie delta echo delta futurebasic" contains "delta" at location 6
"alpha delta charlie delta echo delta futurebasic" contains "delta" at location 20
"alpha delta charlie delta echo delta futurebasic" contains "delta" at location 31
</pre>
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=07bb32f4e8e8f7d81898cf41d4431a2e Click this link to run this code]'''
<
Dim sString1 As String = "Hello world"
Dim sString2 As String = "Hello"
Line 2,204 ⟶ 2,320:
Print sString1 Ends Left(sString2, 5) 'Determine if the first string ends with the second string
End</
Output:
<pre>
Line 2,211 ⟶ 2,327:
False
</pre>
=={{header|GDScript}}==
<syntaxhighlight lang="gdscript">
@tool
extends Node
@export var first_string: String
@export var second_string: String
@export var starts_with: bool:
get: return first_string.begins_with(second_string)
@export var contains: bool:
get: return first_string.contains(second_string)
@export var ends_with: bool:
get: return first_string.ends_with(second_string)
</syntaxhighlight>
=={{header|GML}}==
{{trans|BASIC}}
<
{
first = "qwertyuiop";
Line 2,249 ⟶ 2,383:
show_message("'" + first + "' does not end with '" + second + "'");
}
}</
{{out}} (in message boxes, 1 per line):
Line 2,258 ⟶ 2,392:
=={{header|Go}}==
<
import (
Line 2,287 ⟶ 2,421:
func main() {
match("abracadabra", "abr")
}</
{{out}}
<pre>
Line 2,300 ⟶ 2,434:
=={{header|Groovy}}==
Examples:
<
assert ! "abcd".startsWith("zn")
assert "abcd".endsWith("cd")
Line 2,322 ⟶ 2,456:
assert indicesOf("abab", "ab") == [0, 2]
assert indicesOf("abab", "ba") == [1]
assert indicesOf("abab", "xy") == []</
All assertions pass, so there is no output.
=={{header|Haskell}}==
<
> "abc" `isPrefixOf` "abcdefg"
True
Line 2,338 ⟶ 2,472:
> let infixes a b = findIndices (isPrefixOf a) $ tails b
> infixes "ab" "abcdefabqqab"
[0,6,10]</
=={{header|Icon}} and {{header|Unicon}}==
<
write("Matching s2 :=",image(s2 := "ab")," within s1:= ",image(s1 := "abcdabab"))
Line 2,350 ⟶ 2,484:
write("Test #3 ending ", if s1[0-:*s2] == s2 then "matches" else "fails")
end</
{{out}}
Line 2,359 ⟶ 2,493:
=={{header|J}}==
<
contains=: +./@:E.~
endswith=: ] -: ({.~ -@#)</
Example use:
<
1
'abcd' startswith 'cd'
Line 2,382 ⟶ 2,516:
1
'abab' I.@E.~ 'ab' NB. find starting indicies
0 2</
Note that these verbs contain no constraints restricting them to sequences of characters and so also apply to arrays of type other than character:
<
1
4.2 5.1 1.3 9 3 contains 1.3 4.2 NB. floating point
0
4.2 5.1 1.3 4.2 9 3 contains 1.3 4.2
1</
=={{header|Java}}==
For this task consider the following strings
<syntaxhighlight lang="java">
String string = "string matching";
String suffix = "ing";
</syntaxhighlight>
The most idiomatic way of determining if a string starts with another string is to use the ''String.startsWith'' method.
<syntaxhighlight lang="java">
string.startsWith(suffix)
</syntaxhighlight>
Another way is to use a combination of ''String.substring'' and ''String.equals''
<syntaxhighlight lang="java">
string.substring(0, suffix.length()).equals(suffix)
</syntaxhighlight>
To determine if a string contains at least one occurrence of another string, use the ''String.contains'' method.
<syntaxhighlight lang="java">
string.contains(suffix)
</syntaxhighlight>
A slightly more idiomatic approach would be to use the ''String.indexOf'' method, which will also return the index of the first character.
<syntaxhighlight lang="java">
string.indexOf(suffix) != -1
</syntaxhighlight>
The most idiomatic way of determining whether a string ends with another string is to use the ''String.endsWith'' method.
<syntaxhighlight lang="java">
string.endsWith(suffix);
</syntaxhighlight>
Similarly, a combination of ''String.substring'' and ''String.equals'' can be used.
<syntaxhighlight lang="java">
string.substring(string.length() - suffix.length()).equals(suffix)
</syntaxhighlight>
If you're looking to find the index of each occurrence, you can use the following.
<syntaxhighlight lang="java">
int indexOf;
int offset = 0;
while ((indexOf = string.indexOf(suffix, offset)) != -1) {
System.out.printf("'%s' @ %d to %d%n", suffix, indexOf, indexOf + suffix.length() - 1);
offset = indexOf + 1;
}
</syntaxhighlight>
<pre>
'ing' @ 3 to 5
'ing' @ 12 to 14
</pre>
<br />
Alternately
<syntaxhighlight lang="java">"abcd".startsWith("ab") //returns true
"abcd".endsWith("zn") //returns false
"abab".contains("bb") //returns false
Line 2,399 ⟶ 2,577:
int loc = "abab".indexOf("bb") //returns -1
loc = "abab".indexOf("ab") //returns 0
loc = "abab".indexOf("ab",loc+1) //returns 2
</syntaxhighlight>
<syntaxhighlight lang="java">
public class JavaApplication6 {
public static void main(String[] args) {
String strOne = "complexity";
String strTwo = "udacity";
stringMatch(strOne, strTwo);
}
Line 2,438 ⟶ 2,612:
}
}
</syntaxhighlight>
=={{header|JavaScript}}==
<
, stringB = "co"
, q1, q2, q2multi, m
Line 2,467 ⟶ 2,642:
console.log(" In fact, it happens "+q2matches.length+" times within '"+stringA+"', at index"+(q2matches.length > 1 ? "es" : "")+" "+q2matches.join(', ')+".")
}
console.log("3: Does '"+stringA+"' end with '"+stringB+"'? " + ( q3 ? "Yes." : "No."))</
{{out}}
Line 2,477 ⟶ 2,652:
=={{header|jq}}==
Using the builtins of jq 1.4 and later:
<
"abc" | startswith("ab")
#=> true</
<
# so the jq test "if index(_) then ...." can be used
# without any type conversion.
"abcd" | index( "bc")
#=> 1</
<
"abc" | endswith("bc")
#=> true</
Using the regex functions available in jq 1.5:
<
"abcd" | test("bc")
"abcd" | test("cd$")</
===Multiple Occurrences===
To determine all the indices of one string in another:
<
jq -n '"abcdabcd" | indices("bc")'
[
1,
5
]</
In jq 1.5, the regex function match/1 can also be used:
<
1
5</
=={{header|Julia}}==
<
startswith("abcd","ab") #returns true
findfirst("ab", "abcd") #returns 1:2, indices range where string was found
Line 2,522 ⟶ 2,697:
println(r.offset)
end #returns 1, then 3 matching the two starting indices where the substring was found
</syntaxhighlight>
=={{header|K}}==
<
endswith: {0=(-#y)+(#x)-*_ss[x;y]}
contains: {0<#_ss[x;y]}</
'''Example:'''
<
1
startswith["abcd";"bc"]
Line 2,544 ⟶ 2,719:
0
_ss["abcdabceabc";"abc"] / location of matches
0 4 8</
=={{header|Kotlin}}==
<syntaxhighlight lang="kotlin">
fun main() {
val s1 = "abracadabra"
val s2 = "abra"
println("$s1 begins with $s2
println("$s1 ends with $s2
val b
if (b) {
print("$s1 contains $s2 at these indices: ")
// can use indexOf to get first index or lastIndexOf to get last index
// to get ALL indices, use a for loop or Regex
println(
s2.toRegex(RegexOption.LITERAL).findAll(s1).joinToString { it.range.start.toString() }
)
}
else println("$s1 does not contain $2.")
}</syntaxhighlight>
{{out}}
<pre>
abracadabra begins with abra
abracadabra ends with abra
abracadabra contains abra at these
</pre>
=={{header|Ksh}}==
<
#!/bin/ksh
exec 2> /tmp/String_matching.err
Line 2,637 ⟶ 2,817:
unset posarr ; typeset -a posarr
done
done</
{{out}}<pre>
Hello Starts with Hell
Line 2,687 ⟶ 2,867:
=={{header|Lambdatalk}}==
<syntaxhighlight lang="scheme">
{def S.in
{def S.in.r {lambda {:c :w :i :n}
Line 2,732 ⟶ 2,912:
-> -1 // is not in
</syntaxhighlight>
=={{header|Lang5}}==
<
: comb "" split ; : concat "" join ; : dip swap '_ set execute _ ;
: first 0 extract swap drop ; : flip comb reverse concat ;
Line 2,754 ⟶ 2,934:
"rosettacode" "ocat" contains . # 0
"rosettacode" "edoc" end-with . # 0
"rosettacode" "code" contains . # 7</
=={{header|Lasso}}==
<
a = 'a quick brown peanut jumped over a quick brown fox',
b = 'a quick brown'
Line 2,771 ⟶ 2,951:
//Determining if the first string ends with the second string
#a->endswith(#b) // false</
=={{header|Liberty BASIC}}==
<
st1$="first string"
st2$="first"
Line 2,804 ⟶ 2,984:
print "First string ends with second string."
end if
</syntaxhighlight>
=={{header|Lingo}}==
<
b = "Hello"
Line 2,828 ⟶ 3,008:
-- Print the location of the match for part 2
put offset(b, a)
-- 7</
=={{header|Logo}}==
<
if empty? :sub [output "true]
if empty? :thing [output "false]
Line 2,847 ⟶ 3,027:
show starts.with? "dog "doghouse ; true
show ends.with? "house "doghouse ; true
show substring? "gho "doghouse ; true (built-in)</
=={{header|Lua}}==
<
s2 = "str"
s3 = "ing"
Line 2,862 ⟶ 3,042:
print( "s1 ends with s2: ", select( 2, string.find( s1, s2 ) ) == string.len( s1 ) )
print( "s1 ends with s3: ", select( 2, string.find( s1, s3 ) ) == string.len( s1 ) )</
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
Module StringMatch {
A$="Hello World"
Line 2,881 ⟶ 3,061:
}
StringMatch
</syntaxhighlight>
{{out}}
<pre>
Line 2,894 ⟶ 3,074:
=={{header|Maple}}==
These facilities are all to be found in the StringTools package in Maple.
<syntaxhighlight lang="maple">
> with( StringTools ): # bind package exports at the top-level
> s := "dzrIemaWWIMidXYZwGiqkOOn":
Line 2,926 ⟶ 3,106:
> {seq}( s[ i .. i + 2 ], i = p ); # check them
{"XYZ"}
</syntaxhighlight>
The StringTools package also contains facilities for regular expression matching, but for fixed string patterns, the Search and SearchAll tools are much faster.
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
EndWith[x_, y_] := MemberQ[Flatten[StringPosition[x, y]], StringLength[x]]
StartWith["XYZaaabXYZaaaaXYZXYZ", "XYZ"]
EndWith["XYZaaabXYZaaaaXYZXYZ", "XYZ"]
StringPosition["XYZaaabXYZaaaaXYZXYZ", "XYZ"]</
{{out}}
<pre>True
Line 2,941 ⟶ 3,121:
=={{header|MATLAB}} / {{header|Octave}}==
<syntaxhighlight lang="matlab">
% 1. Determining if the first string starts with second string
strcmp(str1,str2,length(str2))
Line 2,953 ⟶ 3,133:
% 2. Handle multiple occurrences of a string for part 2.
ix = strfind(s1,s2); % ix is a vector containing the starting positions of s2 within s1
</syntaxhighlight>
=={{header|min}}==
One way might be:
{{works with|min|0.19.6}}
<
(indexof -1 !=) :contains?
((/ $/) swap 1 insert "" join regex ("") !=) :ends-with?
Line 2,964 ⟶ 3,144:
"minimalistic" "min" starts-with? puts!
"minimalistic" "list" contains? puts!
"minimalistic" "list" ends-with? puts!</
{{out}}
<pre>
Line 2,975 ⟶ 3,155:
We first extend the built-in string class with three new methods, and then demonstrate their use on some sample strings.
<
return self.len >= s.len and s[:s.len] == s
end function
Line 3,014 ⟶ 3,194:
print
print firstQ + doesOrNot[first.endsWith(second)] + "end with " + secondQ</
{{out}}
<pre>
Line 3,028 ⟶ 3,208:
=={{header|MIPS Assembly}}==
The function below returns the zero-based index where the string pointed to by <code>$a1</code> occurs in <code>$a0</code>.
* If it returns
* If it returns 0, then <
* If it returns <tt>strlen(
* Otherwise, <
* Multiple occurrences can be detected by adding the output to <tt>$a0</tt> and repeating the process; this is left as an exercise to the reader.
<syntaxhighlight lang="mips">InString:
;input: $a0 = ptr to string 1
; $a1 = ptr to string 2
Line 3,068 ⟶ 3,249:
addiu sp,sp,4
jr ra
nop</
{{out}}
<
la $a0,MyString
la $a1,Test1 ;this code was recompiled 5 times, testing a different string each time.
jal InString
nop
Line 3,109 ⟶ 3,290:
.align 4
Test5:
.ascii "1",0
.byte 0
.align 4</
=={{header|NetRexx}}==
<
options replace format comments java crossref savelog symbols
Line 3,162 ⟶ 3,343:
return
</syntaxhighlight>
----
=={{header|NewLISP}}==
<
;; test if str starts with "ab"
Line 3,184 ⟶ 3,365:
(push idx pos -1))))
(find-all-pos "bc" str)</
=={{header|Nim}}==
<
let s = "The quick brown fox"
Line 3,201 ⟶ 3,382:
let pos = find(s, " brown ") # -1 if not found.
if pos >= 0:
echo "“ brown ” is located at position: " & $pos</
{{out}}
Line 3,210 ⟶ 3,391:
=={{header|Objeck}}==
<
bundle Default {
class Matching {
Line 3,224 ⟶ 3,405:
}
}
</syntaxhighlight>
=={{header|Objective-C}}==
<
[@"abcd" hasSuffix:@"zn"] //returns false
int loc = [@"abab" rangeOfString:@"bb"].location //returns -1
loc = [@"abab" rangeOfString:@"ab"].location //returns 0
loc = [@"abab" rangeOfString:@"ab" options:0 range:NSMakeRange(loc+1, [@"abab" length]-(loc+1))].location //returns 2</
=={{header|OCaml}}==
<
let len1 = String.length s1
and len2 = String.length s2 in
if len1 < len2 then false else
let sub = String.sub s1 0 len2 in
(sub = s2)</
testing in the top-level:
Line 3,249 ⟶ 3,430:
- : bool = true
<
let len1 = String.length s1
and len2 = String.length s2 in
Line 3,258 ⟶ 3,439:
if (sub = s2) then true else aux (pred i)
in
aux (len1 - len2)</
# match2 "It's raining, Hello World!" "umbrella" ;;
Line 3,265 ⟶ 3,446:
- : bool = true
<
let len1 = String.length s1
and len2 = String.length s2 in
if len1 < len2 then false else
let sub = String.sub s1 (len1 - len2) len2 in
(sub = s2)</
# match3 "Hello World" "Hello" ;;
Line 3,277 ⟶ 3,458:
- : bool = true
<
let len1 = String.length s1
and len2 = String.length s2 in
Line 3,286 ⟶ 3,467:
if (sub = s2) then (true, i) else aux (pred i)
in
aux (len1 - len2)</
# match2_loc "The sun's shining, Hello World!" "raining" ;;
Line 3,293 ⟶ 3,474:
- : bool * int = (true, 10)
<
let len1 = String.length s1
and len2 = String.length s2 in
Line 3,304 ⟶ 3,485:
else aux (pred i) (n)
in
aux (len1 - len2) 0</
# match2_num "This cloud looks like a camel, \
Line 3,312 ⟶ 3,493:
that other cloud looks like a llama" "cloud" ;;
- : bool * int = (true, 2)
=={{header|Odin}}==
<syntaxhighlight lang="odin">package main
import "core:fmt"
import "core:strings"
main :: proc() {
using strings
s := "Hello world"
fmt.println(has_prefix(s, "He"), contains(s, "wo"), has_suffix(s, "ld"))
// Output: true true true
fmt.println(index(s, "wo"))
// Output: 6
}</syntaxhighlight>
=={{header|Oforth}}==
<
| i |
s2 isAllAt(s1, 1) ifTrue: [ System.Out s1 << " begins with " << s2 << cr ]
Line 3,328 ⟶ 3,528:
System.Out s1 << " includes " << s2 << " at position : " << i << cr
i s2 size + ->i
] ;</
{{out}}
Line 3,344 ⟶ 3,544:
=={{header|OxygenBasic}}==
<
string s="sdfkjhgsdfkdfgkbopefioqwurti487sdfkrglkjfs9wrtgjglsdfkdkjcnmmb.,msfjflkjsdfk"
Line 3,380 ⟶ 3,580:
'
'Total matches: 5
</syntaxhighlight>
=={{header|PARI/GP}}==
This meets the first but not the second of the optional requirements. Note that GP treats any nonzero value as true so the location found by contains() can be ignore if not needed.
<
string=Vec(string);
prefix=Vec(prefix);
Line 3,410 ⟶ 3,610:
for(i=1,#suffix,if(prefix[i]!=string[i+#string-#suffix], return(0)));
1
};</
=={{header|Perl}}==
Line 3,416 ⟶ 3,616:
Using regexes:
<
$str1 =~ /\Q$str2\E/ # true if $str1 contains $str2
$str1 =~ /\Q$str2\E$/ # true if $str1 ends with $str2</
Using <code>index</code>:
<
index($str1, $str2) != -1 # true if $str1 contains $str2
rindex($str1, $str2) == length($str1) - length($str2) # true if $str1 ends with $str2</
Using <code>substr</code>:
<
substr($str1, - length($str2)) eq $str2 # true if $str1 ends with $str2</
Bonus task ''(printing all positions where <code>$str2</code> appears in <code>$str1</code>)'':
<
<
=={{header|Phix}}==
{{libheader|Phix/basics}}
<!--<
<span style="color: #008080;">constant</span> <span style="color: #000000;">word</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"the"</span><span style="color: #0000FF;">,</span> <span style="color: #000080;font-style:italic;">-- (also try this with "th"/"he")</span>
<span style="color: #000000;">sentence</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"the last thing the man said was the"</span>
Line 3,470 ⟶ 3,670:
<span style="color: #000080;font-style:italic;">-- or equivalently:</span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">match_all</span><span style="color: #0000FF;">(</span><span style="color: #000000;">word</span><span style="color: #0000FF;">,</span><span style="color: #000000;">sentence</span><span style="color: #0000FF;">)</span>
<!--</
{{out}}
<pre>
Line 3,482 ⟶ 3,682:
{1,16,33}
</pre>
=={{header|Phixmonti}}==
Simple solution
<syntaxhighlight lang="Phixmonti">/# Rosetta Code problem: https://rosettacode.org/wiki/String_prepend
by Galileo, 11/2022 #/
include ..\Utilitys.pmt
"the last thing the man said was the" "the" pstack
len var l >ps
1 l slice tps == if "Begins with keyword" ? endif
0 l - l slice tps == if "Ends with keyword" ? endif
tail ps> find dup if "Keyword appears first at " print 1 + print " position" ? else drop endif
drop
</syntaxhighlight>
{{out}}
<pre>
["the last thing the man said was the", "the"]
Begins with keyword
Ends with keyword
Keyword appears first at 16 position
=== Press any key to exit ===</pre>
More complex solution
<syntaxhighlight lang="Phixmonti">/# Rosetta Code problem: https://rosettacode.org/wiki/String_prepend
by Galileo, 11/2022 #/
include ..\Utilitys.pmt
"the last thing the man said was the" "the" pstack
( ) rot rot >ps
true while
tps find dup >ps
if swap tps 0 put swap 32 ps> set true else ps> endif
endwhile
len ps> len nip - 1 + >ps drop
len for get
dup 1 == if "Begins with keyword" ? drop else
dup tps == if "Ends with keyword" ? drop else
"Locate at position " print ?
endif endif
endfor
ps> drop
</syntaxhighlight>
{{out}}
<pre>
["the last thing the man said was the", "the"]
Begins with keyword
Locate at position 16
Ends with keyword
=== Press any key to exit ===</pre>
=={{header|PHP}}==
<
/**********************************************************************************
* This program gets needle and haystack from the caller (chm.html) (see below)
Line 3,542 ⟶ 3,797:
<p style="color: red";><strong><?php echo "$tx1" ?></strong></p>
</body>
</html></
<
<!DOCTYPE html>
<!--
Line 3,583 ⟶ 3,838:
</form>
</body>
</html></
=={{header|Picat}}==
The two most common predicate to use for string matching is <code>find/4</code> (find a substring) or <code>append/3</code> (a general purpose reversible predicate for concatenating/splitting lists/strings). Both predicates are non-deterministic and can yield multiple solutions, e.g. together with <code>findall/2</code>.
<
go =>
Line 3,641 ⟶ 3,896:
All2 = findall([Start9,End9], find(S7," ",Start9,End9)),
println(positions=All2),
nl.</
{{out}}
Line 3,655 ⟶ 3,910:
=={{header|PicoLisp}}==
<
-> "abcd"
: (pre? "xy" "abcd")
Line 3,678 ⟶ 3,933:
: (positions "bc" "abcdabcd")
-> (2 6)</
=={{header|PL/I}}==
<syntaxhighlight lang="pl/i">
/* Let s be one string, t be the other that might exist within s. */
/* 8-1-2011 */
Line 3,693 ⟶ 3,948:
if k > 0 then put skip edit (t, ' starts at position ', k) (a);
</syntaxhighlight>
Optional extra:
<syntaxhighlight lang="pl/i">
/* Handle multiple occurrences. */
n = 1;
Line 3,718 ⟶ 3,973:
else stop;
end;
</syntaxhighlight>
=={{header|PowerShell}}==
<syntaxhighlight lang="powershell">
"spicywiener".StartsWith("spicy")
"spicywiener".Contains("icy")
Line 3,727 ⟶ 3,982:
"spicywiener".IndexOf("icy")
[regex]::Matches("spicywiener", "i").count
</syntaxhighlight>
{{out}}
<pre>
Line 3,740 ⟶ 3,995:
<
:- system:set_prolog_flag(double_quotes,codes) .
Line 3,784 ⟶ 4,039:
.
</syntaxhighlight>
{{out}}
Line 3,853 ⟶ 4,108:
=={{header|PureBasic}}==
<
Protected Result
If FindString(String1$, String2$, 1) =1 ; E.g Found in possition 1
Line 3,867 ⟶ 4,122:
EndIf
ProcedureReturn Result
EndProcedure</
And a verification
<
PrintN(Str(StartsWith("Rosettacode", "Rosetta"))) ; = 1
PrintN(Str(StartsWith("Rosettacode", "code"))) ; = 0
Line 3,879 ⟶ 4,134:
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
CloseConsole()
EndIf</
An alternate and more complete solution:
<
;returns one if string1$ starts with string2$, otherwise returns zero
If FindString(string1$, string2$, 1) = 1
Line 3,923 ⟶ 4,178:
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
CloseConsole()
EndIf</
{{out}}
<pre>1
Line 3,938 ⟶ 4,193:
=={{header|Python}}==
<
"abcd".endswith("zn") #returns False
"bb" in "abab" #returns False
Line 3,944 ⟶ 4,199:
loc = "abab".find("bb") #returns -1
loc = "abab".find("ab") #returns 0
loc = "abab".find("ab",loc+1) #returns 2</
=={{header|QB64}}==
<syntaxhighlight lang="qb64">
DefStr S
DefInt P
Line 3,966 ⟶ 4,221:
Wend
Print string2; " is present "; pcount; " times into "; string1
</syntaxhighlight>
=={{header|Quackery}}==
These work for any nests (i.e. dynamic arrays), not just strings (i.e. nests of chars).
<
[ tuck size negate split nip = ] is ends ( [ [ --> b )
Line 3,993 ⟶ 4,248:
$ "abcdefgh" $ "xyz" ends echobool cr
$ "abcdefgh" $ "cde" contains echobool cr
$ "abcdefgh" $ "xyz" contains echobool cr</
{{out}}
Line 4,006 ⟶ 4,261:
=={{header|Racket}}==
<
#lang racket
(require srfi/13)
Line 4,013 ⟶ 4,268:
(string-contains "abab" "bb")
(string-contains "abab" "ba")
</syntaxhighlight>
{{out}}
<pre>
Line 4,027 ⟶ 4,282:
Using string methods:
<syntaxhighlight lang="raku"
$haystack.contains($needle) # True if $haystack contains $needle
$haystack.ends-with($needle) # True if $haystack ends with $needle</
Using regexes:
<syntaxhighlight lang="raku"
so $haystack ~~ / $needle / # True if $haystack contains $needle
so $haystack ~~ / $needle $/ # True if $haystack ends with $needle</
Using <code>substr</code>:
<syntaxhighlight lang="raku"
substr($haystack, *-$needle.chars) eq $needle # True if $haystack ends with $needle</
Bonus task:
<syntaxhighlight lang="raku"
$haystack.indices($needle :overlap); # Also find any overlapping instances of $needle in $haystack</
=={{header|Retro}}==
<
withLength &swap dip 0 swap ^strings'getSubset compare ;
Line 4,061 ⟶ 4,316:
"abcdefghijkl" "ijkl" endsWith?
"abcdefghijkl" "abc" endsWith?</
=={{header|REXX}}==
Extra coding was added to take care of using plurals in the last output message.
<
parse arg A B /*obtain A and B from the command line.*/
say 'string A = ' A /*display string A to the terminal.*/
Line 4,090 ⟶ 4,345:
if #==0 then say "string A doesn't contain string B"
else say 'string A contains string B ' # " time"left('s', #>1),
"(at position"left('s', #>1) $")" /*stick a fork in it, we're all done. */</
{{out|output|text= when the following is specified (the five Marx brothers): <tt> Chico_Harpo_Groucho_Zeppo_Gummo p </tt> }}
<pre>
Line 4,145 ⟶ 4,400:
=={{header|Ring}}==
<
aString = "Welcome to the Ring Programming Language"
bString = "Ring"
bStringIndex = substr(aString,bString)
if bStringIndex > 0 see "" + bStringIndex + " : " + bString ok
</syntaxhighlight>
=={{header|RPL}}==
===Determining if the first string starts with second string===
Returns 1 if the strings match accordingly, 0 otherwise.
"ABCDEF" "ABC"
≪ SWAP OVER SIZE 1 SWAP SUB == ≫ EVAL
===Determining if the first string contains the second string at any location===
Returns the position of the first character of the second string in the first string if the strings match accordingly, 0 otherwise.
"ABCDEF" "BCD"
POS
===Determining if the first string ends with the second string===
Returns 1 if the strings match accordingly, 0 otherwise.
"ABCDEF" "DEF"
≪ SWAP DUP2 SIZE SWAP SIZE - 1 + OVER SIZE SUB == ≫ EVAL
{{out}}
<pre>
3: 1
2: 2
1: 1
</pre>
=={{header|Ruby}}==
<
p 'abcd'.end_with?('ab') #returns false
p 'abab'.include?('bb') #returns false
Line 4,162 ⟶ 4,436:
p 'abab'.index('ab') #returns 0
p 'abab'.index('ab', 1) #returns 2
p 'abab'.rindex('ab') #returns 2</
=={{header|Run BASIC}}==
<
s2$ = "abc" ' begins with
s3$ = "ef" ' is in the string
Line 4,192 ⟶ 4,466:
if mid$(s1$,len(s1$) + 1 - len(sn4$),len(sn4$)) <> sn4$ then a$ = "Not "
print "String:";s1$;" does ";a$;"end with:";sn4$</
{{out}}
<pre>
Line 4,204 ⟶ 4,478:
=={{header|Rust}}==
<
match possible_match {
Some(match_pos) => println!("Found match at pos {}", match_pos),
Line 4,225 ⟶ 4,499:
// Determining if the first string ends with the second string
assert!(s2.ends_with(s3));
}</
<
fn main(){
let hello = String::from("Hello world");
Line 4,234 ⟶ 4,508:
hello.ends_with("ld"),
hello.contains("wi"));
}</
{{out}}
Line 4,242 ⟶ 4,516:
=={{header|Scala}}==
<
"abcd".endsWith("zn") //returns false
"abab".contains("bb") //returns false
Line 4,249 ⟶ 4,523:
var loc="abab".indexOf("bb") //returns -1
loc = "abab".indexOf("ab") //returns 0
loc = "abab".indexOf("ab", loc+1) //returns 2</
=={{header|sed}}==
The following programs handle the input lines pairwise: If the first string of a pair contains the second string, the former one is shown. (Which means that non-matching pairs are filtered out.)
1. Determining if the first string starts with the second string:
<syntaxhighlight lang="sed">N;/^\(.*\).*\n\1$/!d;s/\n.*//</syntaxhighlight>
2. Determining if the first string contains the second string at any location:
<syntaxhighlight lang="sed">N;/.*\(.*\).*\n\1$/!d;s/\n.*//</syntaxhighlight>
3. Determining if the first string ends with the second string:
<syntaxhighlight lang="sed">N;/\(.*\)\n\1$/!d;s/\n.*//</syntaxhighlight>
{{out}}
<pre>
$ printf '%s\n' abcd bcd wxyz wxy | sed -f match1.sed
wxyz
$ printf '%s\n' abcd be vwxyz wxy | sed -f match2.sed
vwxyz
$ printf '%s\n' abcd abc wxyz xyz | sed -f match3.sed
wxyz
</pre>
=={{header|Seed7}}==
<
const proc: main is func
Line 4,267 ⟶ 4,560:
position := pos("abab", "ab", succ(position));
writeln(position); # position is 3
end func;</
{{out}}
Line 4,281 ⟶ 4,574:
=={{header|Sidef}}==
<
var second = "abc";
Line 4,295 ⟶ 4,588:
while (pos = first.index(second, pos+1) != -1) {
say "Match at pos: #{pos}";
}</
=={{header|Smalltalk}}==
<
a includesSubCollection: b. "inherited from superclass"
a includesString: b. "the same, but more readable"
Line 4,306 ⟶ 4,599:
a indexOfString: b
a indexOfStringStartingAt: b
</syntaxhighlight>
=={{header|SNOBOL4}}==
<
s2 = 'ab'
s3 = 'xy'
Line 4,322 ⟶ 4,615:
p3 OUTPUT = ?(s1 ? s2 RPOS(0)) "3. " s2 " ends " s1
END</
{{out}}
<pre>1. ab begins abcdabefgab
Line 4,331 ⟶ 4,624:
=={{header|Standard ML}}==
<
String.isSuffix "zn" "abcd"; (* returns false *)
String.isSubstring "bb" "abab"; (* returns false *)
Line 4,337 ⟶ 4,630:
#2 (Substring.base (#2 (Substring.position "bb" (Substring.full "abab")))); (* returns 4 *)
val loc = #2 (Substring.base (#2 (Substring.position "ab" (Substring.full "abab")))); (* returns 0 *)
val loc' = #2 (Substring.base (#2 (Substring.position "ab" (Substring.extract ("abab", loc+1, NONE))))); (* returns 2 *)</
=={{header|Swift}}==
<
str.hasPrefix("Hell") //True
str.hasPrefix("hell") //False
Line 4,348 ⟶ 4,641:
str.hasSuffix("playground") //True
str.hasSuffix("world") //False</
=={{header|Tailspin}}==
This assumes the string to be found does not contain any regex special characters, otherwise we should work with composers (parsers) see below.
<
templates find&{s:}
when <'$s;.*'> do '$; starts with $s;' !
Line 4,370 ⟶ 4,663:
' -> !OUT::write
'abcd' -> find&{s:'e'} -> !OUT::write
</syntaxhighlight>
{{out}}
<pre>
Line 4,380 ⟶ 4,673:
Working with composers and literal matchers to be able to handle any string.
<
composer startsWith&{s:}
@: 0;
Line 4,417 ⟶ 4,710:
' -> !OUT::write
'banana' -> find&{s:'na'} -> !OUT::write
</syntaxhighlight>
{{out}}
<pre>
Line 4,429 ⟶ 4,722:
In tailspin we don't manipulate strings by character indices but we can still work out the second part. String characters can be streamed and captured in an array, although we prefer to compare in strings, here with a composer (parser).
This has also been crafted to work with strings containing special regex characters by using literal equality.
<
composer index&{s:}
@index: 0;
Line 4,443 ⟶ 4,736:
' -> !OUT::write
'c is found in positions $:'banana' -> index&{s:'c'}; in banana' -> !OUT::write
</syntaxhighlight>
{{out}}
<pre>
Line 4,453 ⟶ 4,746:
=={{header|Tcl}}==
In this code, we are looking in various ways for the string in the variable <tt>needle</tt> in the string in the variable <tt>haystack</tt>.
<
set isContained [expr {[string first $needle $haystack] >= 0}]
set isSuffix [string equal $needle [string range $haystack end-[expr {[string length $needle]-1}] end]]</
Of course, in the cases where the needle is a glob-safe string (i.e., doesn't have any of the characters “<tt>*?[\</tt>” in), this can be written far more conveniently:
<
set isContained [string match *$needle* $haystack]
set isSuffix [string match *$needle $haystack]</
Another powerful technique is to use the regular expression engine in literal string mode:
<
This can be extended by getting the <code>regexp</code> to return the locations of the matches, enabling the other forms of match to be done:
<
# Each match location is a pair, being the index into the string where the needle started
# to match and the index where the needle finished matching
Line 4,476 ⟶ 4,769:
foreach location $matchLocations {
puts "needle matched at index [lindex $location 0]"
}</
=={{header|TUSCRIPT}}==
<
$$ MODE TUSCRIPT
ASK "string1", string1=""
Line 4,503 ⟶ 4,796:
PRINT string1," not ends with ",string2
ENDIF
</syntaxhighlight>
{{out}}
<pre>string1 >Rosetta Code
Line 4,518 ⟶ 4,811:
===TXR Lisp===
<
((big small)
(cond
Line 4,533 ⟶ 4,826:
(put-line `@small does not occur in @big`)))))
(otherwise
(put-line `usage: @(ldiff *full-args* *args*) <bigstring> <smallstring>`)))</
{{out}}
<pre>$ txr cmatch2.tl x
Line 4,554 ⟶ 4,847:
===Pattern Language===
<
@(cases)
@ line
Line 4,579 ⟶ 4,872:
first line is not found in the second line
@ (end)
@(end)</
{{out}}
Line 4,592 ⟶ 4,885:
=={{header|Vala}}==
<
var text = "一二三四五六七八九十";
var starts = "一二";
Line 4,605 ⟶ 4,898:
stdout.printf(@"contains $contains: $(contains in text)\n");
stdout.printf(@"contains $not_contain: $(contains in text)\n");
}</
{{out}}
Line 4,620 ⟶ 4,913:
=={{header|VBA}}==
{{trans|Phix}}<
word = "the" '-- (also try this with "th"/"he")
sentence = "the last thing the man said was the"
Line 4,650 ⟶ 4,943:
r = InStr(r + 1, sentence, word)
Loop
End Sub</
<pre>yes(1)
yes(2)
Line 4,660 ⟶ 4,953:
=={{header|VBScript}}==
<
StartsWith = False
If Left(s1,Len(s2)) = s2 Then
Line 4,702 ⟶ 4,995:
WScript.StdOut.Write "Contains test, 'o' in 'fooooobar': " & Contains("fooooobar","o")
WScript.StdOut.WriteLine
WScript.StdOut.Write "Ends with test, 'bar' in 'foobar': " & EndsWith("foobar","bar")</
{{out}}
Line 4,715 ⟶ 5,008:
{{works with|Visual Basic|VB6 Standard}}
works the same as in VBA, see [[String_matching#VBA]]
=={{header|V (Vlang)}}==
{{trans|Delphi}}
<syntaxhighlight lang="v (vlang)">fn main() {
str := 'abcd'
println(str.starts_with('ab')) // True
println(str.ends_with('zn')) // False
println(str.contains('bb')) // False
println(str.contains('ab')) // True
println(str.index('bc') or {-1}) // 1 // Vlang arrays are 0 based, so first char position is 0 and no result assigned -1
}</syntaxhighlight>
{{out}}
<pre>
true
false
false
true
1
</pre>
=={{header|Wren}}==
<
var t = "abra"
var u = "ra"
Line 4,734 ⟶ 5,047:
var contained = indices.count > 0
System.print("'%(s)' contains '%(u)' is %(contained) %(contained ? "at indices %(indices)" : "")")
System.print("'%(s)' ends with '%(v)' is %(s.endsWith(v))")</
{{out}}
Line 4,744 ⟶ 5,057:
=={{header|XPL0}}==
<
string 0; \use zero-terminated strings
Line 4,785 ⟶ 5,098:
Text(0, if StrFind(Str, "with") = StrLen(Str)-StrLen("with") then "yes" else "no"); CrLf(0); \3.
Text(0, if StrFind(Str, "x w" ) = StrLen(Str)-StrLen("x w" ) then "yes" else "no"); CrLf(0);
]</
{{out}}
Line 4,799 ⟶ 5,112:
=={{header|XProfan}}==
<syntaxhighlight lang="xprofan">
// XProfan can use StringParts, so the results here
// are the comma separated positions of the parts or 0
Line 4,849 ⟶ 5,162:
waitkey
end</
{{out}}
<pre>
Line 4,865 ⟶ 5,178:
=={{header|Yabasic}}==
<syntaxhighlight lang="yabasic">
cadena1$ = "qwertyuiop"
Line 4,894 ⟶ 5,207:
end if
end
</syntaxhighlight>
{{out}}
<pre>
Line 4,902 ⟶ 5,215:
</pre>
=={{header|Z80 Assembly}}==
{{trans|MIPS Assembly}}
<syntaxhighlight lang="z80">InString:
;input: hl = pointer to string 1
; de = pointer to string 2
; assumes len(hl) <= len(de)
; output in BC
;clobbers: ix
push de
pop ix ;back up de into ix
ld bc,0 ;our return value
InString_again:
ld a,(hl)
or a
ret z
ld a,(de)
or a
ret z
cp (hl)
jr nz,InString_noMatch
inc de
jr InString_overhead
InString_noMatch:
push ix
pop de
inc bc
InString_overhead:
inc hl
jr InString_again</syntaxhighlight>
{{out}}
<syntaxhighlight lang="z80">org &1000
ld hl,TestString
ld de,Test1 ;recompiled with each test string and tested it
call InString
ld a,c
call ShowHex
ret
TestString:
db "abcdefg",0
Test1:
db "abc",0 ;returns 0
Test2:
db "def",0 ;returns 3
Test3:
db "efg",0 ;returns 4
Test4:
db "z",0 ;returns 7</syntaxhighlight>
=={{header|zkl}}==
<
f("foobar","foo") //--> Yep
f("foobar","bar") //--> Nope</
<
f("foobar","ob") //--> Contained @2
f("foobar","food") //--> Nope</
<
if( Void!=(n:=text.rfind(p)) and n+p.len()==text.len() )
println("tail gunner") else println("Nope")
Line 4,916 ⟶ 5,282:
f("foobar","r"); f("foobar","ar"); //--> tail gunners
f("foobar","ob"); //--> Nope
f("foobarfoobar","bar"); //--> tail gunner</
{{omit from|bc|No string operations in bc}}
|