String matching: Difference between revisions

{{trans|Python}}

print(‘abcd’.ends_with(‘zn’))

print(‘bb’ C ‘abab’)

print(‘ab’ C ‘abab’)

print(‘abab’.find(‘bb’) ? -1)

{{out}}

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

STRMATCH CSECT

USING STRMATCH,R15

PG DC CL80' '

YREGS

{{out}}

<pre>

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program strMatching64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

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

BYTE i,j,found

TestEndsWith("1234abc","abc")

TestEndsWith("1234abc","ab")

{{out}}

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

=={{header|Ada}}==

with Ada.Strings.Fixed; use Ada.Strings.Fixed;

with Ada.Text_IO; use Ada.Text_IO;

);

end Match_Strings;

{{out}}

<pre>

=={{header|Aime}}==

data b;

o_form("starts with, embeds, ends with \"~\": ~, ~, ~\n", t, b.seek(t) == 0,

b.seek(t) != -1,

{{out}}

<pre>starts with, embeds, ends with "Bang": 1, 1, 0

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

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

=={{header|AppleScript}}==

set string1 to "I felt happy"

-- Print the location of the match for part 2

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

end offset

or, defining an '''offsets''' function in terms of a more general '''findIndices''':

on offsets(needle, haystack)

script match

end script

end if

{{Out}}

<pre>{8, 44, 83, 110}</pre>

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program strMatching.s */

bx lr @ return

=={{header|Arturo}}==

print prefix? "abcd" "cd"

print suffix? "abcd" "ab"

print index "abcd" "bc"

{{out}}

=={{header|AutoHotkey}}==

String1 = abcd

String2 = abab

If TempVar = %String2%

MsgBox, "%String1%" ends with "%String2%".

=={{header|AutoIt}}==

$string2 = "ard"

EndIf

=={{header|AWK}}==

{ pos=index($2,$1)

print $2, (pos==1 ? "begins" : "does not begin" ), "with " $1

print $2, (substr($2,pos)==$1 ? "ends" : "does not end"), "with " $1

}

=={{header|BASIC}}==

{{works with|QBasic}}

'Determining if the first string starts with second string

END IF

{{out}}

==={{header|Applesoft BASIC}}===

20 S$ = "TH"

30 DEF FN S(P) = MID$(A$, P, LEN(S$)) = S$

310 E$(1) = "ENDS"

320 E$(0) = "DOES NOT END"

=={{header|Batch File}}==

::you put some of the CMD special characters (ex. %,!, etc) inside the strings.

::

set /a length+=1

goto loop

{{out}}

<pre>"qwertyuiop" begins with "qwerty".

=={{header|BBC BASIC}}==

FOR test% = 1 TO 3

UNTIL I% = 0

= N%

{{out}}

<pre>"The fox jumps over the dog" starts with "The"

<code>⍷</code> does much of the heavy lifting here. It is commuted with <code>˜</code> so the order of the arguments makes sense.

Contains ← ∨´⍷˜

EW ← ¯1⊑⍷˜

{{Out|Usage}}

1

"abcd" SW "cd"

1

"abab" Locs "ab"

=={{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'")

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

=={{header|C}}==

Case sensitive matching:

#include <stdio.h>

return 0;

{{out}}

<pre>Starts with Test ( Hello,Hell ) : 1

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 */

return 0;

{{out}}

<pre>matching `A Short String' with `ort S':

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

{{works with|Mono|2.6}}

class Program

{

}

}

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

using namespace std;

s1.find(s2)//returns string::npos

int loc=s2.find(s3)//returns 0

=={{header|Clojure}}==

{{trans|Java}}

(. "abcd" endsWith "zn")

(. "abab" contains "bb")

user> (for [i evals] [i (eval i)])

=={{header|CoffeeScript}}==

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

console.log matchLocations "bababab", "bab" # [0,2,4]

console.log matchLocations "xxx", "x" # [0,1,2]

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

(defun starts-with-p (str1 str2)

"Determine whether `str1` starts with `str2`"

(print (containsp "ababaBa" "ba")) ; (1 3)

(print (containsp "foobar" "x")) ; NIL

=={{header|Component Pascal}}==

BlackBox Component Builder

MODULE StringMatch;

IMPORT StdLog,Strings;

END Do;

END StringMatch.

Execute: ^Q StringMatching.Do <br/>

{{out}}

=={{header|D}}==

import std.stdio;

import std.algorithm: startsWith, endsWith, find, countUntil;

[1, 2, 3].countUntil(3).writeln; // 2

[1, 2, 3].countUntil([2, 3]).writeln; // 1

{{out}}

<pre>true

=={{header|DCL}}==

$ length_of_first_string = f$length( first_string )

$ second_string = p2

$ else

$ write sys$output "first string does not end with the second string"

{{out}}

<pre>$ @string_matching efabcdef ef

=={{header|Delphi}}==

{$APPTYPE CONSOLE}

Writeln(AnsiContainsText('abcd', 'ab')); // True

WriteLn(Pos('ab', 'abcd')); // 1

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

=={{header|E}}==

println(string1.startsWith(string2))

println(string1.endsWith(string2))

=={{header|EchoLisp}}==

(string-suffix? "nette" "Antoinette") → #t

(string-prefix? "Simon" "Simon & Garfunkel") → #t

(string-match "Antoinette" "net") → #t ;; contains

(string-index "net" "Antoinette") → 5 ;; substring location

=={{header|Elena}}==

ELENA 4.x :

public program()

console.readChar()

=={{header|Elixir}}==

The String module has functions that cover the base requirements.

s2 = "adab"

s3 = "ab"

Regex.scan(~r/#{s3}/, "abcabc", return: :index)

=={{header|Emacs Lisp}}==

(string-match (regexp-quote needle) haystack))

(string-prefix-p "after" "before center after") ;=> nil

(string-contains "after" "before center after") ;=> 14

=={{header|Erlang}}==

-module(character_matching).

-export([starts_with/2,ends_with/2,contains/2]).

contains(_S1,_S2,_N,Acc) ->

Acc.

=={{header|Euphoria}}==

integer x

else

printf(1, "'%s' does not end with '%s'\n", {first, second})

{{out}}

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

let main args =

if idx < 0 then None else Some (idx, idx+1)) 0

|> Seq.iter (printfn "substring %A begins at position %d (zero-based)" contains)

{{out}}

<pre>text = "一二三四五六七八九十"

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

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

> s1.endsWith(s2) ? @ "s1 ends with $s2" : @ "$s1 does not end with $s2"

{{out}}

<pre>

* <code>indexrIgnoreCase</code> (like above, ignoring case for ASCII characters)

class Main

{

}

}

{{out}}

=={{header|FBSL}}==

DIM s = "roko, mat jane do"

WHILE INSTR(mane, match, INSTR + 1): PRINT " ", INSTR;: WEND

END SUB

{{out}}

<pre>"roko, mat jane do" starts with "roko"

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

=={{header|Fortran}}==

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.

SUBROUTINE STARTS(A,B) !Text A starts with text B?

CHARACTER*(*) A,B

CALL ENDS("Brief","Much longer")

END

Output: text strings are bounded by >''etc.''< in case of leading or trailing spaces.

<pre>

Similar program using modern Fortran style

!-----------------------------------------------------------------------

!Main program string_matching

end function ends

end program string_matching

Output: false = 0, true = 1 ( + multiple occurrences if applicable)

<pre>

=={{header|FreeBASIC}}==

Dim As String s1 = "abracadabra"

Print

Print "Press any key to quit"

{{out}}

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

Print sString1 Ends Left(sString2, 5) 'Determine if the first string ends with the second string

Output:

<pre>

{{trans|BASIC}}

{

first = "qwertyuiop";

show_message("'" + first + "' does not end with '" + second + "'");

}

{{out}} (in message boxes, 1 per line):

=={{header|Go}}==

import (

func main() {

match("abracadabra", "abr")

{{out}}

<pre>

=={{header|Groovy}}==

Examples:

assert ! "abcd".startsWith("zn")

assert "abcd".endsWith("cd")

assert indicesOf("abab", "ab") == [0, 2]

assert indicesOf("abab", "ba") == [1]

All assertions pass, so there is no output.

=={{header|Haskell}}==

> "abc" `isPrefixOf` "abcdefg"

True

> let infixes a b = findIndices (isPrefixOf a) $ tails b

> infixes "ab" "abcdefabqqab"

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

write("Matching s2 :=",image(s2 := "ab")," within s1:= ",image(s1 := "abcdabab"))

write("Test #3 ending ", if s1[0-:*s2] == s2 then "matches" else "fails")

{{out}}

=={{header|J}}==

contains=: +./@:E.~

Example use:

1

'abcd' startswith 'cd'

1

'abab' I.@E.~ 'ab' NB. find starting indicies

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

=={{header|Java}}==

"abcd".endsWith("zn") //returns false

"abab".contains("bb") //returns false

int loc = "abab".indexOf("bb") //returns -1

loc = "abab".indexOf("ab") //returns 0

// -----------------------------------------------------------//

=={{header|JavaScript}}==

, stringB = "co"

, q1, q2, q2multi, m

console.log(" In fact, it happens "+q2matches.length+" times within '"+stringA+"', at index"+(q2matches.length > 1 ? "es" : "")+" "+q2matches.join(', ')+".")

}

{{out}}

=={{header|jq}}==

Using the builtins of jq 1.4 and later:

"abc" | startswith("ab")

# so the jq test "if index(_) then ...." can be used

# without any type conversion.

"abcd" | index( "bc")

"abc" | endswith("bc")

Using the regex functions available in jq 1.5:

"abcd" | test("bc")

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

=={{header|Julia}}==

startswith("abcd","ab") #returns true

findfirst("ab", "abcd") #returns 1:2, indices range where string was found

println(r.offset)

end #returns 1, then 3 matching the two starting indices where the substring was found

=={{header|K}}==

endswith: {0=(-#y)+(#x)-*_ss[x;y]}

'''Example:'''

1

startswith["abcd";"bc"]

0

_ss["abcdabceabc";"abc"] / location of matches

=={{header|Kotlin}}==

fun main(args: Array<String>) {

if (b) println(" at locations ${s1.indexOf(s2) + 1} and ${s1.lastIndexOf(s2) + 1}")

else println()

{{out}}

=={{header|Ksh}}==

#!/bin/ksh

exec 2> /tmp/String_matching.err

unset posarr ; typeset -a posarr

done

{{out}}<pre>

Hello Starts with Hell

=={{header|Lambdatalk}}==

{def S.in

{def S.in.r {lambda {:c :w :i :n}

-> -1 // is not in

=={{header|Lang5}}==

: comb "" split ; : concat "" join ; : dip swap '_ set execute _ ;

: first 0 extract swap drop ; : flip comb reverse concat ;

"rosettacode" "ocat" contains . # 0

"rosettacode" "edoc" end-with . # 0

=={{header|Lasso}}==

a = 'a quick brown peanut jumped over a quick brown fox',

b = 'a quick brown'

//Determining if the first string ends with the second string

=={{header|Liberty BASIC}}==

st1$="first string"

st2$="first"

print "First string ends with second string."

end if

=={{header|Lingo}}==

b = "Hello"

-- Print the location of the match for part 2

put offset(b, a)

=={{header|Logo}}==

if empty? :sub [output "true]

if empty? :thing [output "false]

show starts.with? "dog "doghouse ; true

show ends.with? "house "doghouse ; true

=={{header|Lua}}==

s2 = "str"

s3 = "ing"

print( "s1 ends with s2: ", select( 2, string.find( s1, s2 ) ) == string.len( s1 ) )

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

Module StringMatch {

A$="Hello World"

}

StringMatch

{{out}}

<pre>

=={{header|Maple}}==

These facilities are all to be found in the StringTools package in Maple.

> with( StringTools ): # bind package exports at the top-level

> s := "dzrIemaWWIMidXYZwGiqkOOn":

> {seq}( s[ i .. i + 2 ], i = p ); # check them

{"XYZ"}

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

{{out}}

<pre>True

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

% 1. Determining if the first string starts with second string

strcmp(str1,str2,length(str2))

% 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

=={{header|min}}==

One way might be:

{{works with|min|0.19.6}}

(indexof -1 !=) :contains?

((/ $/) swap 1 insert "" join regex ("") !=) :ends-with?

"minimalistic" "min" starts-with? puts!

"minimalistic" "list" contains? puts!

{{out}}

<pre>

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

print

{{out}}

<pre>

* Otherwise, <tt>$a0</tt> contains <tt>$a1</tt> starting at the specified location.

* 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.

;input: $a0 = ptr to string 1

; $a1 = ptr to string 2

addiu sp,sp,4

jr ra

{{out}}

la $a0,MyString

la $a1,Test1 ;this code was recompiled 5 times, testing a different string each time.

.ascii "1",0 ;InString returned 0x1A (decimal 26)

.byte 0

=={{header|NetRexx}}==

options replace format comments java crossref savelog symbols

return

----

=={{header|NewLISP}}==

;; test if str starts with "ab"

(push idx pos -1))))

=={{header|Nim}}==

let s = "The quick brown fox"

let pos = find(s, " brown ") # -1 if not found.

if pos >= 0:

{{out}}

=={{header|Objeck}}==

bundle Default {

class Matching {

}

}

=={{header|Objective-C}}==

[@"abcd" hasSuffix:@"zn"] //returns false

int loc = [@"abab" rangeOfString:@"bb"].location //returns -1

loc = [@"abab" rangeOfString:@"ab"].location //returns 0

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

testing in the top-level:

- : bool = true

let len1 = String.length s1

and len2 = String.length s2 in

if (sub = s2) then true else aux (pred i)

in

# match2 "It's raining, Hello World!" "umbrella" ;;

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

# match3 "Hello World" "Hello" ;;

- : bool = true

let len1 = String.length s1

and len2 = String.length s2 in

if (sub = s2) then (true, i) else aux (pred i)

in

# match2_loc "The sun's shining, Hello World!" "raining" ;;

- : bool * int = (true, 10)

let len1 = String.length s1

and len2 = String.length s2 in

else aux (pred i) (n)

in

# match2_num "This cloud looks like a camel, \

=={{header|Oforth}}==

| i |

s2 isAllAt(s1, 1) ifTrue: [ System.Out s1 << " begins with " << s2 << cr ]

System.Out s1 << " includes " << s2 << " at position : " << i << cr

i s2 size + ->i

{{out}}

=={{header|OxygenBasic}}==

string s="sdfkjhgsdfkdfgkbopefioqwurti487sdfkrglkjfs9wrtgjglsdfkdkjcnmmb.,msfjflkjsdfk"

'

'Total matches: 5

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

for(i=1,#suffix,if(prefix[i]!=string[i+#string-#suffix], return(0)));

1

=={{header|Perl}}==

Using regexes:

$str1 =~ /\Q$str2\E/ # true if $str1 contains $str2

Using <code>index</code>:

index($str1, $str2) != -1 # true if $str1 contains $str2

Using <code>substr</code>:

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>

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

=={{header|PHP}}==

/**********************************************************************************

* This program gets needle and haystack from the caller (chm.html) (see below)

<p style="color: red";><strong><?php echo "$tx1" ?></strong></p>

</body>

<!DOCTYPE html>

<!--

</form>

</body>

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

All2 = findall([Start9,End9], find(S7," ",Start9,End9)),

println(positions=All2),

{{out}}

=={{header|PicoLisp}}==

-> "abcd"

: (pre? "xy" "abcd")

: (positions "bc" "abcdabcd")

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

/* Let s be one string, t be the other that might exist within s. */

/* 8-1-2011 */

if k > 0 then put skip edit (t, ' starts at position ', k) (a);