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

}

 

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

public program()

var s := "abcd";

console.printLine(s," index of az: ",s.indexOf(0, "az"));

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

First string contains second string : at index 1 and at index 8

First string ends with second string : true

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

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

 

Output:

<pre>

False

</pre>

 

=={{header|GML}}==

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

public class JavaApplication6 {

public static void main(String[] args) {

String strOne = "complexity";

String strTwo = "udacity";

stringMatch(strOne, strTwo);

}

 

}

}

 

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

val s1 = "abracadabra"

val s2 = "abra"

 

{{out}}

<pre>

</pre>

 

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

jal InString

nop

.align 4

Test5:

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

that other cloud looks like a llama" "cloud" ;;

- : bool * int = (true, 2)

 

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

{1,16,33}

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

 

Optional extra:

 

/* Handle multiple occurrences. */

n = 1;

else stop;

end;

 

=={{header|PowerShell}}==

"spicywiener".StartsWith("spicy")

"spicywiener".Contains("icy")

"spicywiener".IndexOf("icy")

[regex]::Matches("spicywiener", "i").count

{{out}}

<pre>

 

 

:- system:set_prolog_flag(double_quotes,codes) .

 

.

 

 

{{out}}

 

=={{header|PureBasic}}==

Protected Result

If FindString(String1$, String2$, 1) =1 ; E.g Found in possition 1

EndIf

ProcedureReturn Result

And a verification

PrintN(Str(StartsWith("Rosettacode", "Rosetta"))) ; = 1

PrintN(Str(StartsWith("Rosettacode", "code"))) ; = 0

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

 

An alternate and more complete solution:

;returns one if string1$ starts with string2$, otherwise returns zero

If FindString(string1$, string2$, 1) = 1

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

{{out}}

<pre>1

 

=={{header|Python}}==

"abcd".endswith("zn") #returns False

"bb" in "abab" #returns False

loc = "abab".find("bb") #returns -1

loc = "abab".find("ab") #returns 0

 

=={{header|QB64}}==

DefStr S

DefInt P

Wend

Print string2; " is present "; pcount; " times into "; string1

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

$ "abcdefgh" $ "xyz" ends echobool cr

$ "abcdefgh" $ "cde" contains echobool cr

 

{{out}}

 

=={{header|Racket}}==

#lang racket

(require srfi/13)

(string-contains "abab" "bb")

(string-contains "abab" "ba")

{{out}}

<pre>

Using string methods:

 

$haystack.contains($needle) # True if $haystack contains $needle

 

Using regexes:

 

so $haystack ~~ / $needle / # True if $haystack contains $needle

 

Using <code>substr</code>:

 

 

Bonus task:

 

 

=={{header|Retro}}==

withLength &swap dip 0 swap ^strings'getSubset compare ;

 

 

"abcdefghijkl" "ijkl" 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.*/

if #==0 then say "string A doesn't contain string B"

else say 'string A contains string B ' # " time"left('s', #>1),

{{out|output|text=&nbsp; when the following is specified (the five Marx brothers): &nbsp; <tt> Chico_Harpo_Groucho_Zeppo_Gummo p </tt> }}

<pre>

 

=={{header|Ring}}==

aString = "Welcome to the Ring Programming Language"

bString = "Ring"

bStringIndex = substr(aString,bString)

if bStringIndex > 0 see "" + bStringIndex + " : " + bString ok

 

=={{header|Ruby}}==

p 'abcd'.end_with?('ab') #returns false

p 'abab'.include?('bb') #returns false

p 'abab'.index('ab') #returns 0

p 'abab'.index('ab', 1) #returns 2

 

=={{header|Run BASIC}}==

s2$ = "abc" ' begins with

s3$ = "ef" ' is in the string

 

if mid$(s1$,len(s1$) + 1 - len(sn4$),len(sn4$)) <> sn4$ then a$ = "Not "

{{out}}

<pre>

 

=={{header|Rust}}==

match possible_match {

Some(match_pos) => println!("Found match at pos {}", match_pos),

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

assert!(s2.ends_with(s3));

 

fn main(){

let hello = String::from("Hello world");

hello.ends_with("ld"),

hello.contains("wi"));

 

{{out}}

 

=={{header|Scala}}==

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

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

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

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

 

=={{header|Seed7}}==

 

const proc: main is func

position := pos("abab", "ab", succ(position));

writeln(position); # position is 3

 

{{out}}

 

=={{header|Sidef}}==

var second = "abc";

 

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"

a indexOfString: b

a indexOfStringStartingAt: b

 

=={{header|SNOBOL4}}==

s2 = 'ab'

s3 = 'xy'

 

p3 OUTPUT = ?(s1 ? s2 RPOS(0)) "3. " s2 " ends " s1

{{out}}

<pre>1. ab begins abcdabefgab

 

=={{header|Standard ML}}==

String.isSuffix "zn" "abcd"; (* returns false *)

String.isSubstring "bb" "abab"; (* returns false *)

#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 *)

 

=={{header|Swift}}==

str.hasPrefix("Hell") //True

str.hasPrefix("hell") //False

 

str.hasSuffix("playground") //True

 

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

' -> !OUT::write

'abcd' -> find&{s:'e'} -> !OUT::write

{{out}}

<pre>

 

Working with composers and literal matchers to be able to handle any string.

composer startsWith&{s:}

@: 0;

' -> !OUT::write

'banana' -> find&{s:'na'} -> !OUT::write

{{out}}

<pre>

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;

' -> !OUT::write

'c is found in positions $:'banana' -> index&{s:'c'}; in banana' -> !OUT::write

{{out}}

<pre>

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

 

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]

 

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

foreach location $matchLocations {

puts "needle matched at index [lindex $location 0]"

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

ASK "string1", string1=""

PRINT string1," not ends with ",string2

ENDIF

{{out}}

<pre>string1 >Rosetta Code

===TXR Lisp===

 

((big small)

(cond

(put-line `@small does not occur in @big`)))))

(otherwise

{{out}}

<pre>$ txr cmatch2.tl x

===Pattern Language===

 

@(cases)

@ line

first line is not found in the second line

@ (end)

 

{{out}}

 

=={{header|Vala}}==

var text = "一二三四五六七八九十";

var starts = "一二";

stdout.printf(@"contains $contains: $(contains in text)\n");

stdout.printf(@"contains $not_contain: $(contains in text)\n");

 

{{out}}

 

=={{header|VBA}}==

word = "the" '-- (also try this with "th"/"he")

sentence = "the last thing the man said was the"

r = InStr(r + 1, sentence, word)

Loop

<pre>yes(1)

yes(2)

 

=={{header|VBScript}}==

StartsWith = False

If Left(s1,Len(s2)) = s2 Then

WScript.StdOut.Write "Contains test, 'o' in 'fooooobar': " & Contains("fooooobar","o")

WScript.StdOut.WriteLine

 

{{out}}

{{works with|Visual Basic|VB6 Standard}}

works the same as in VBA, see [[String_matching#VBA]]

 

=={{header|Wren}}==

var t = "abra"

var u = "ra"

var contained = indices.count > 0

System.print("'%(s)' contains '%(u)' is %(contained) %(contained ? "at indices %(indices)" : "")")

 

{{out}}

 

=={{header|XPL0}}==

string 0; \use zero-terminated strings

 

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

 

=={{header|XProfan}}==

// XProfan can use StringParts, so the results here

// are the comma separated positions of the parts or 0

 

waitkey

{{out}}

<pre>

 

=={{header|Yabasic}}==

cadena1$ = "qwertyuiop"

 

end if

end

{{out}}

<pre>

</pre>

 

 

=={{header|zkl}}==

f("foobar","foo") //--> Yep

f("foobar","ob") //--> Contained @2

if( Void!=(n:=text.rfind(p)) and n+p.len()==text.len() )

println("tail gunner") else println("Nope")

f("foobar","r"); f("foobar","ar"); //--> tail gunners

f("foobar","ob"); //--> Nope

 

{{omit from|bc|No string operations in bc}}