Count occurrences of a substring: Difference between revisions

 

It should return an integer count.

3

 

// do not count substrings that overlap with previously-counted substrings:

print countSubstring("ababababab","abab")

 

The matching should yield the highest number of non-overlapping matches.

 

=={{header|11l}}==

 

{{out}}

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

The program uses two ASSIST macros (XDECO,XPRNT) to keep the code as short as possible.

COUNTSTR CSECT

USING COUNTSTR,R13 base register

* ---- -------------------------------------------------------

YREGS

{{out}}

<pre>

<code>DE</code>.

 

jmp demo

;;; Count non-overlapping substrings (BC) in string (HL)

sub2: db 'abab',0 ; result should be 2

str3: db 'cat',0

 

{{out}}

 

=={{header|8086 Assembly}}==

org 100h

section .text

.sub2: db 'abab',0 ; result should be 2

.str3: db 'cat',0

 

{{out}}

 

<pre>3 2 0</pre>

 

=={{header|Ada}}==

 

procedure Substrings is

Ada.Integer_Text_IO.Put (Ada.Strings.Fixed.Count (Source => "ababababab",

Pattern => "abab"));

 

{{out}}

 

=={{header|ALGOL 68}}==

INT start:=LWB haystack, next, out:=0;

FOR count WHILE string in string(needle, next, haystack[start:]) DO

);

 

<pre>

3 2 2

=={{header|Apex}}==

Apex example for 'Count occurrences of a substring'.

String substr = 'ABC';

String str = 'ABCZZZABCYABCABCXXABC';

}

System.debug('Count String : '+count);

 

<pre>

{{works with|Dyalog APL}}

 

 

{{out}}

 

=={{header|AppleScript}}==

This is a good example of the kind of problem to which standard libraries (a regex library in this case) would offer most languages a simple and immediate solution.

AppleScript, however, for want of various basics like regex and math library functions, can require scripters to draw on the supplementary resources of Bash, using the built-in ''do shell script'' function.

Here we use a generic ''evalOSA(language, code)'' function to apply a JavaScript for Automation regex to a pair of AppleScript strings, using OSAKit.

 

 

on run

return oError's NSLocalizedDescription as text

 

{{out}}

The above assertions notwithstanding, it's always been possible to use AppleScript's text item delimiters for this purpose with its native strings, except that the TIDs have only observed the current considering/ignoring state with the 'unicode text' class, which was introduced around Mac OS X 10.4 and became AppleScript's only native text class with the introduction of AppleScript 2.0 in Mac OS X 10.5.

 

set astid to AppleScript's text item delimiters

set AppleScript's text item delimiters to theSubstring

end countSubstring

 

 

{{Out}}

 

=={{header|Arturo}}==

 

 

loop [["the three truths" "th"] ["ababababab" "abab"]] 'pair ->

~"occurrences of '|last pair|' in '|first pair|':"

countOccurrences first pair last pair

 

{{out}}

AutoHotkey has a rather unconventional method which outperforms this.

StringReplace sets the number of replaced strings to ErrorLevel.

MsgBox % countSubstring("ababababab","abab") ; 2

 

StringReplace, junk, fullstring, %substring%, , UseErrorLevel

return errorlevel

 

=={{header|AWK}}==

 

# countsubstring(string, pattern)

# Returns number of occurrences of pattern in string

print countsubstring_regex("[do&d~run?d!run&>run&]", "run[&]")

print countsubstring("the three truths","th")

{{out}}

<pre>$ awk -f countsubstring.awk

 

=={{header|BaCon}}==

LOCAL x

WHILE TALLY(text$, part$)

 

PRINT "the three truths - th: ", Uniq_Tally("the three truths", "th")

{{out}}

<pre>

In FreeBASIC, this needs to be compiled with <code>-lang qb</code> or <code>-lang fblite</code>.

 

 

PRINT "the three truths, th:", countSubstring&("the three truths", "th")

LOOP

countSubstring = c

 

{{out}}

 

See also: [[#Liberty BASIC|Liberty BASIC]], [[#PowerBASIC|PowerBASIC]], [[#PureBasic|PureBasic]].

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

20 S$ = "THE THREE TRUTHS"

30 GOSUB 100"COUNT SUBSTRING

170 IF F$ = MID$(S$, I, F) THEN R = R + 1 : I = I + F - 1

180 NEXT I

 

==={{header|IS-BASIC}}===

110 INPUT PROMPT "Substring: ":SUB$

120 PRINT COUNT(LCASE$(TXT$),LCASE$(SUB$))

180 LOOP UNTIL PO=0

190 LET COUNT=N

 

==={{header|Sinclair ZX81 BASIC}}===

Works with 1k of RAM.

20 LET U$="TH"

30 GOSUB 100

150 LET N=N+1

160 LET I=I+LEN U$

 

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

setlocal enabledelayedexpansion

 

set input=!trimmed!

set /a cnt+=1

{{Out}}

<pre>3

 

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

sub$ = "th"

PRINT ; FNcountSubstring(tst$, sub$) " """ sub$ """ in """ tst$ """"

UNTIL I% = 0

= N%

{{out}}

<pre>3 "th" in "the three truths"

 

=={{header|BCPL}}==

 

let countsubstr(str, match) = valof

show("ababababab", "abab")

show("cat", "dog")

{{out}}

<pre>"th" in "the three truths": 3

"abab" in "ababababab": 2

"dog" in "cat": 0</pre>

 

=={{header|Bracmat}}==

= n S s p

. 0:?n:?p

& out$(count-substring$("the three truths".th))

& out$(count-substring$(ababababab.abab))

{{out}}

<pre>3

 

=={{header|C}}==

#include <string.h>

 

printf("not: %d\n", match("abababababa", "aba", 0));

return 0;

 

Alternate version:

#include <string.h>

 

 

return 0;

{{out}}

<pre>

</pre>

 

 

class SubStringTestClass

return count;

}

 

Using C# 6.0's expression-bodied member, null-conditional operator, and coalesce operator features:

 

class SubStringTestClass

{

public static int CountSubStrings(this string testString, string testSubstring) =>

testString?.Split(new [] { testSubstring }, StringSplitOptions.None)?.Length - 1 ?? 0;

 

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

#include <string>

 

 

return 0;

{{out}}

<pre>

=={{header|Clojure}}==

Use a sequence of regexp matches to count occurrences.

(defn re-quote

"Produces a string that can be used to create a Pattern

(defn count-substring [txt sub]

(count (re-seq (re-pattern (re-quote sub)) txt)))

 

Use the trick of blank replacement and maths to count occurrences.

(defn count-substring1 [txt sub]

(/ (- (count txt) (count (.replaceAll txt sub "")))

(count sub)))

 

A Java 8 stream-based solution, which should avoid creation of temporary strings

(though it will produce temporary MatchResult instances).

(defn count-substring2 [txt sub]

(-> sub

(.results)

(.count)))

 

=={{header|COBOL}}==

<code>INSPECT</code> can be used for this task without having to create a function.

PROGRAM-ID. testing.

 

 

GOBACK

 

{{out}}

 

=={{header|CoffeeScript}}==

countSubstring = (str, substr) ->

n = 0

console.log countSubstring "the three truths", "th"

console.log countSubstring "ababababab", "abab"

 

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

(loop with z = 0 with s = 0 while s do

(when (setf s (search pat str :start2 s))

 

(count-sub "ababa" "ab") ; 2

 

=={{header|Cowgol}}==

 

sub countSubstring(str: [uint8], match: [uint8]): (count: uint8) is

print_nl();

print_i8(countSubstring("cat","dog")); # should print 0

 

{{out}}

 

=={{header|D}}==

import std.stdio, std.algorithm;

 

"the three truths".count("th").writeln;

"ababababab".count("abab").writeln;

{{out}}

<pre>3

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

Writeln(CountSubstring('the three truths', 'th'));

Writeln(CountSubstring('ababababab', 'abab'));

 

=={{header|Dyalect}}==

 

var idx = 0

var count = 0

while true {

if idx == -1 {

break

}

count += 1

}

 

print(countSubstring("the three truths", "th"))

 

{{out}}

 

=={{header|Déjà Vu}}==

{{out}}

<pre>3

2</pre>

 

=={{header|EchoLisp}}==

;; from Racket

(define count-substring

(count-substring "/ .e/" "Longtemps je me suis couché de bonne heure") ;; regexp

→ 4

 

=={{header|EGL}}==

{{works with|EDT}}

The "remove and count the difference" and "manual loop" methods. Implementation includes protection from empty source and search strings.

function main()

 

end

{{out}}

<pre>Remove and Count:

 

=={{header|Eiffel}}==

class

APPLICATION

search_for:STRING = "abab"

end

 

=={{header|Elixir}}==

(str, sub) -> length(String.split(str, sub)) - 1 end

 

Enum.each(data, fn{str, sub} ->

IO.puts countSubstring.(str, sub)

 

{{out}}

0

0

</pre>

 

=={{header|Erlang}}==

%% Count non-overlapping substrings in Erlang for the rosetta code wiki.

%% Implemented by J.W. Luiten

main(String, Sub) ->

{{out}}

<pre>

 

Alternative using built in functions:

main( String, Sub ) -> erlang:length( binary:split(binary:list_to_bin(String), binary:list_to_bin(Sub), [global]) ) - 1.

 

=={{header|Euphoria}}==

integer from,count

count = 0

 

? countSubstring("the three truths","th")

 

{{out}}

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

"Remove and count the difference" method, as shown by J, Java, ...

 

let countSubstring (where :string) (what : string) =

show "ababababab" "abab"

show "abc" ""

<pre>countSubstring("the three truths", "th") = 3

countSubstring("ababababab", "abab") = 2

 

=={{header|Factor}}==

 

=={{header|Forth}}==

2swap 0 >r

begin 2over search

 

s" the three truths" s" th" str-count . \ 3

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

implicit none

integer :: n

end do

end function

{{out}}

<pre>3

 

=={{header|FreeBASIC}}==

 

Function countSubstring(s As String, search As String) As Integer

Print

Print "Press any key to quit"

 

{{out}}

 

=={{header|FunL}}==

 

def countSubstring( str, substr ) = Regex( substr ).findAllMatchIn( str ).length()

 

println( countSubstring("the three truths", "th") )

 

{{out}}

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Go}}==

Using strings.Count() method:

import (

"fmt"

fmt.Println(strings.Count("the three truths", "th")) // says: 3

fmt.Println(strings.Count("ababababab", "abab")) // says: 2

 

=={{header|Groovy}}==

Solution, uses the Groovy "find" operator (=~), and the Groovy-extended Matcher property "count":

println (('ababababab' =~ /abab/).count)

println (('abaabba*bbaba*bbab' =~ /a*b/).count)

 

{{out}}

=={{header|Haskell}}==

=== Text-based solution ===

 

-- Return the number of non-overlapping occurrences of sub in str.

print $ countSubStrs "the three truths" "th"

print $ countSubStrs "ababababab" "abab"

{{out}}

<pre>

 

Alternatively, in a language built around currying, it might make more sense to reverse the suggested order of arguments.

 

 

main :: IO ()

main =

{{Out}}

<pre>[5,2,2]</pre>

Even though list-based strings are not "the right" way of representing texts, the problem of counting subsequences in a list is generally useful.

 

count [] = error "empty substring"

count sub = go

scan [] xs = 1 + go xs

scan (x:xs) (y:ys) | x == y = scan xs ys

{{Out}}

<pre>λ> count "th" "the three truths"

The following solution is almost two times faster than the previous one.

 

import Data.Maybe (catMaybes)

 

count :: Eq a => [a] -> [a] -> Int

 

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

every A := ![ ["the three truths","th"], ["ababababab","abab"] ] do

write("The string ",image(A[2])," occurs as a non-overlapping substring ",

}

return c

 

{{out}}

=={{header|J}}==

 

 

In other words: find length of original string, replace the string to be counted with the empty string, find the difference in lengths and divide by the length of the string to be counted.

Example use:

 

3

'ababababab' countss 'abab'

 

=={{header|Java}}==

{{works with|Java|1.5+}}

The "remove and count the difference" method:

public static int countSubstring(String subStr, String str){

return (str.length() - str.replace(subStr, "").length()) / subStr.length();

System.out.println(countSubstring("a*b", "abaabba*bbaba*bbab"));

}

{{out}}

<pre>3

{{works with|Java|1.5+}}

The "split and count" method:

 

public class CountSubstring {

System.out.println(countSubstring("a*b", "abaabba*bbaba*bbab"));

}

{{out}}

<pre>3

 

Manual looping

public static int countSubstring(String subStr, String str){

int count = 0;

System.out.println(countSubstring("a*b", "abaabba*bbaba*bbab"));

}

{{out}}

<pre>3

=={{header|JavaScript}}==

Using regexes:

var matches = str.match(new RegExp(subStr, "g"));

return matches ? matches.length : 0;

 

Using 'split' and ES6 notation:

 

=={{header|jq}}==

Using regexes (available in jq versions after June 19, 2014):

def countSubstring(sub):

 

=={{header|Julia}}==

 

'''Main'''

ts = ["the three truths", "ababababab"]

tsub = ["th", "abab"]

println(length(matchall(Regex(tsub[i]), ts[i], true)))

end

 

{{out}}

=={{header|K}}==

The dyadic verb _ss gives the positions of substring y in string x.

0 4 13

 

#"ababababab" _ss "abab"

2

 

=={{header|Klingphix}}==

 

:count %s !s

"ababababab" "abab" count ?

 

Other solution

 

:count "- " convert "-" 2 tolist split len nip ;

"ababababab" "abab" count ?

 

{{out}}

<pre>3

 

=={{header|Kotlin}}==

 

fun countSubstring(s: String, sub: String): Int = s.split(sub).size - 1

println(countSubstring("ababababab","abab"))

println(countSubstring("",""))

 

{{out}}

 

=={{header|Lambdatalk}}==

{def countSubstring

{def countSubstring.r

{countSubstring aba ababa}

-> 1

 

=={{header|langur}}==

 

{{out}}

 

=={{header|Lasso}}==

local(i = 1, foundpos = -1, found = 0)

while(#i < #str->size && #foundpos != 0) => {

//3

countSubstring_bothways('ababababab','abab')

 

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

print countSubstring( "the three truths", "th")

print countSubstring( "ababababab", "abab")

countSubstring =c

end function

 

=={{header|Logtalk}}==

Using atoms for string representation:

:- object(counting).

 

 

:- end_object.

{{out}}

| ?- counting::count('the three truths', th, N).

N = 3

N = 2

yes

 

=={{header|Lua}}==

Solution 1:

 

return select(2, s1:gsub(s2, ""))

end

 

print(countSubstring("the three truths", "th"))

<pre>3

2</pre>

Solution 2:

 

local count = 0

for eachMatch in s1:gmatch(s2) do

 

print(countSubstring("the three truths", "th"))

<pre>3

2</pre>

 

=={{header|Maple}}==

f:=proc(s::string,c::string,count::nonnegint) local n;

n:=StringTools:-Search(c,s);

 

f("ababababab","abab",0);

{{out}}

<pre>

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

3

StringPosition["ababababab","abab",Overlaps->False]//Length

 

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

 

length(findstr("ababababab","abab",0))

length(findstr("the three truths","th",0))

 

% Count occurrences of a substring with overlap

 

{{out}}

 

=={{header|Maxima}}==

[n: 0, k: 1],

while integerp(k: ssearch(e, s, k)) do (n: n + 1, k: k + 1),

 

scount("na", "banana");

 

=={{header|MiniScript}}==

return self.split(s).len - 1

end function

 

print "the three truths".count("th")

{{out}}

<pre>

 

=={{header|Mirah}}==

import java.util.regex.Matcher

 

puts count_substring3("abab", "ababababab") # ==> 2

puts count_substring3("a*b", "abaabba*bbaba*bbab") # ==> 2

 

=={{header|Nanoquery}}==

{{trans|Java}}

return int((len(str) - len(str.replace(subStr, ""))) / len(subStr))

 

=={{header|Nemerle}}==

{{trans|F#}}

 

module CountSubStrings

WriteLine($"$target2 occurs $(text2.CountSubStrings(target2)) times in $text2");

}

{{out}}

<pre>th occurs 3 times in the three truths

NetRexx provides the <tt>''string''.countstr(''needle'')</tt> built-in function:

 

options replace format comments java crossref symbols nobinary

 

return

{{out}}

<pre>

=={{header|NewLISP}}==

 

; url: http://rosettacode.org/wiki/Count_occurrences_of_a_substring

; author: oofoe 2012-01-29

)

 

 

{{out}}

 

=={{header|Nim}}==

 

proc count(s, sub: string): int =

echo count("the three truths","th")

 

{{out}}

<pre>3

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

The "split and count" method:

- (NSUInteger)occurrencesOfSubstring:(NSString *)subStr;

@end

}

return 0;

{{out}}

<pre>3

 

The "remove and count the difference" method:

- (NSUInteger)occurrencesOfSubstring:(NSString *)subStr;

@end

}

return 0;

{{out}}

<pre>3

 

Manual looping:

- (NSUInteger)occurrencesOfSubstring:(NSString *)subStr;

@end

}

return 0;

{{out}}

<pre>3

=={{header|OCaml}}==

 

let sub_len = String.length sub in

let len_diff = (String.length str) - sub_len

Printf.printf "count 1: %d\n" (count_substring "the three truth" "th");

Printf.printf "count 2: %d\n" (count_substring "ababababab" "abab");

 

=={{header|Oforth}}==

 

: countSubString(s, sub)

0 1 while(sub swap s indexOfAllFrom dup notNull) [ sub size + 1 under+ ]

 

{{out}}

 

=={{header|ooRexx}}==

bag="the three truths"

x="th"

x="abab"

say left(bag,30) left(x,15) 'found' bag~caselesscountstr(x)

{{out}}

<pre style="height:10ex;overflow:scroll">

 

=={{header|PARI/GP}}==

my(i=1,s);

while(i+#u<=#v,

substr(s1,s2)=subvec(Vec(s1),Vec(s2));

substr("the three truths","th")

{{out}}

<pre>%1 = 3

 

=={{header|Perl}}==

my $str = shift;

my $sub = quotemeta(shift);

print countSubstring("the three truths","th"), "\n"; # prints "3"

 

=={{header|Phix}}==

<span style="color: #004080;">sequence</span> <span style="color: #000000;">tests</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{{</span><span style="color: #008000;">"the three truths"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"th"</span><span style="color: #0000FF;">},</span>

<span style="color: #0000FF;">{</span><span style="color: #008000;">"ababababab"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"abab"</span><span style="color: #0000FF;">},</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"The string \"%s\" occurs as a non-overlapping substring %d times in \"%s\"\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">substring</span><span style="color: #0000FF;">,</span><span style="color: #000000;">count</span><span style="color: #0000FF;">,</span><span style="color: #000000;">test</span><span style="color: #0000FF;">})</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre>

 

=={{header|PHP}}==

echo substr_count("the three truths", "th"), PHP_EOL; // prints "3"

echo substr_count("ababababab", "abab"), PHP_EOL; // prints "2"

 

=={{header|PicoLisp}}==

(let (Cnt 0 H (chop Sub))

(for (S (chop Str) S (cdr S))

(inc 'Cnt)

(setq S (map prog2 H S)) ) )

Test:

<pre>: (countSubstring "the three truths" "th")

 

=={{header|Pike}}==

write("%d %d\n",

String.count("the three truths", "th"),

String.count("ababababab", "abab"));

{{Out}}

<pre>

 

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

declare (i, tally) fixed binary;

declare (text, key) character (100) varying;

end;

put skip list (tally);

 

Output for the two specified strings is as expected.

 

=={{header|PL/M}}==

/* CP/M CALLS */

BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS;

 

CALL EXIT;

{{out}}

<pre>3

Note that while this example is marked as working with PB/Win, the <code>PRINT</code> statement would need to be replaced with <code>MSGBOX</code>, or output to a file. (PB/Win does not support console output.)

 

PRINT "the three truths, th:", TALLY("the three truths", "th")

PRINT "ababababab, abab:", TALLY("ababababab", "abab")

 

{{out}}

 

{{works with|PowerShell|4.0}}

[regex]::Matches("the three truths", "th").count

<b>Output:</b>

<pre>

</pre>

 

[regex]::Matches("ababababab","abab").count

<b>Output:</b>

<pre>

Using SWI-Prolog's string facilities (this solution is very similar to the Logtalk solution that uses sub_atom/5):

 

 

count_substring(String, Sub, Total) :-

DropN is Before + Length,

sub_string(String, DropN, Remain, 0, Rest).

 

Usage:

?- count_substring("the three truths","th",X).

X = 3.

?- count_substring("ababababab","abab",X).

X = 2.

 

=== version using DCG ===

 

{{works with|SWI-Prolog|7.6.4}}

:- system:set_prolog_flag(double_quotes,chars) .

 

.

 

 

{{out}}

 

=={{header|PureBasic}}==

b = CountString("ababababab","abab")

; a = 3

 

=={{header|Python}}==

3

>>> "ababababab".count("abab")

 

=={{header|Quackery}}==

Quackery does not come equipped with a "find substring m within string n" function, but one is defined in The Book of Quackery, as a demonstration of creating a finite state machine in Quackery. It is reproduced here with permission.

 

[ i^ space +

join ] ] constant is alphabet ( --> $ )

else

[ swap buildfsm

 

 

[ 2drop [] ] done

[] unrot

nip swap again ]

2drop drop ] is findall$ ( $ $ --> [ )

 

{{out}}

</pre>

 

 

 

$ "the three truths" $ "th" occurences echo cr

$ "ababababab" $ "abab" occurences echo cr

 

{{out}}

The <code>fixed</code> parameter (and, in <code>stringr</code>, the function of the same name) is used to specify a search for a fixed string. Otherwise, the search pattern is interpreted as a POSIX regular expression. PCRE is also an option: use the <code>perl</code> parameter or function.

 

{v = attr(gregexpr(needle, haystack, fixed = T)[[1]], "match.length")

if (identical(v, -1L)) 0 else length(v)}

 

 

{{libheader|stringr}}

 

 

=={{header|Racket}}==

(define count-substring

(compose length regexp-match*))

> (count-substring "th" "the three truths")

3

> (count-substring "abab" "ababababab")

2

 

=={{header|Raku}}==

(formerly Perl 6)

 

=={{header|Red}}==

]

{{out}}

 

 

=={{header|REXX}}==

::::* &nbsp; too many arguments

::::* &nbsp; if &nbsp; '''start''' &nbsp; is a positive integer (when specified)

w=. /*max. width so far.*/

bag= 'the three truths' ; x= "th" ; call showResult

if x=='' then x= " (null)" /* " " " " */

say left(bag, w) left(x, w%2) center(countstr(bag, x), 5)

'''output''' &nbsp; when using the default (internal) inputs:

<pre>

 

=={{header|Ring}}==

aString = "Ring Welcome Ring to the Ring Ring Programming Ring Language Ring"

bString = "Ring"

cString = substr(cString,substr(cString,dString)+len(string(sum)))

end

 

Output:

<pre>

6

</pre>

 

=={{header|Ruby}}==

str.scan(subStr).length

end

 

p countSubstrings "the three truths", "th" #=> 3

 

String#scan returns an array of substrings, and Array#length (or Array#size) counts them.

 

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

print countSubstring("ababababab","abab")

 

i = instr(s$,find$,i) + len(find$)

WEND

{{out}}

<pre>3

 

=={{header|Rust}}==

fn main() {

println!("{}","the three truths".matches("th").count());

println!("{}","ababababab".matches("abab").count());

}

{{out}}

<pre>

=={{header|Scala}}==

===Using Recursion===

def countSubstring(str1:String, str2:String):Int={

@tailrec def count(pos:Int, c:Int):Int={

}

count(0,0)

 

===Using Sliding===

 

===Using Regular Expressions===

<br/>

{{out}}

<pre>2

=={{header|Scheme}}==

{{works with|Gauche Scheme}}

#<undef>

gosh> (length (lrxmatch "th" "the three truths"))

gosh> (length (lrxmatch "abab" "ababababab"))

2

 

=={{header|Seed7}}==

 

const func integer: countSubstring (in string: stri, in string: searched) is func

writeln(countSubstring("the three truths", "th"));

writeln(countSubstring("ababababab", "abab"));

 

{{out}}

2

</pre>

 

=={{header|SenseTalk}}==

'''Simply stated:'''

put the number of occurrences of "th" in "the three truths" --> 3

put the number of occurrences of "abab" in "ababababab" -- > 2

'''User-created function:'''

put countSubstring("aaaaa","a") // 5

put countSubstring("abababa","aba") // 2

return number of occurrences of subString in mainString

end countSubstring

 

=={{header|Sidef}}==

'''Built-in:'''

 

'''User-created function:'''

var re = Regex.new(ss.escape, 'g'); # 'g' for global

var counter = 0;

 

say countSubstring("the three truths","th");

{{out}}

<pre>

</pre>

=={{header|Simula}}==

INTEGER PROCEDURE COUNTSUBSTRING(T,TSUB); TEXT T,TSUB;

OUTINT(COUNTSUBSTRING("ABABABABAB", "ABAB"),0);

OUTIMAGE;

{{out}}

<pre>

=={{header|Smalltalk}}==

{{works with|Smalltalk/X}}

{{out}}

<pre>3

 

=={{header|SNOBOL4}}==

DEFINE("countSubstring(t,s)")

 

3

2

 

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

 

let

fun aux (str', count) =

print (Int.toString (count_substrings ("the three truths", "th")) ^ "\n");

print (Int.toString (count_substrings ("ababababab", "abab")) ^ "\n");

 

=={{header|Stata}}==

n = 0

k = 1-(i=strlen(x))

 

strcount("ababababab","abab")

 

=={{header|Swift}}==

 

 

func countSubstring(str: String, substring: String) -> Int {

 

print(countSubstring(str: "the three truths", substring: "th"))

 

{{out}}

=={{header|Tcl}}==

The regular expression engine is ideal for this task, especially as the <tt>***=</tt> prefix makes it interpret the rest of the argument as a literal string to match:

regexp -all ***=$needle $haystack

}

puts [countSubstrings "the three truths" "th"]

puts [countSubstrings "ababababab" "abab"]

{{out}}

<pre>3

2

2</pre>

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT, {}

occurences=COUNT ("the three truths", ":th:")

occurences=COUNT ("ababababab", ":abab:")

occurences=COUNT ("abaabba*bbaba*bbab",":a\*b:")

{{out}}

<pre>

=={{header|TXR}}==

 

@(do (defun count-occurrences (haystack needle)

(for* ((occurrences 0)

@(output)

@(count-occurrences hay ndl) occurrences(s) of @ndl inside @hay

 

<pre>$ ./txr count-occurrences.txr "baba" "babababa"

=={{header|UNIX Shell}}==

{{works with|Bash}}

 

function countString(){

 

countString "the three truths" "th"

{{Out}}

<pre>3

=={{header|VBA}}==

 

CountStringInString = UBound(Split(stLookIn, stLookFor))

 

=={{header|VBScript}}==

Function CountSubstring(str,substr)

CountSubstring = 0

WScript.StdOut.Write CountSubstring("the three truths","th") & vbCrLf

WScript.StdOut.Write CountSubstring("ababababab","abab") & vbCrLf

 

{{Out}}

<pre>

 

=={{header|Visual Basic .NET}}==

Sub Main()

Console.WriteLine(CountSubstring("the three truths", "th"))

Return count

End Function

{{Out}}

<pre>3

2

0</pre>

 

=={{header|Wortel}}==

c &[s t] #!s.match &(t)g

 

!!c "ababababab" "abab"

]]

Returns: <pre>[3 2]</pre>

 

{{libheader|Wren-pattern}}

{{libheader|Wren-fmt}}

 

var countSubstring = Fn.new { |str, sub|

var count = countSubstring.call(test[0], test[1])

Fmt.print("$6s occurs $d times in $q.", Fmt.q(test[1]), count, test[0])

 

{{out}}

"b" occurs 0 times in "aaaaaaaaaaaaaa".

</pre>

 

=={{header|XPL0}}==

string 0; \use zero-terminated strings, instead of MSb terminated

 

[IntOut(0, SubStr("the three truths", "th")); CrLf(0);

IntOut(0, SubStr("ababababab", "abab")); CrLf(0);

 

{{out}}

=={{header|zkl}}==

Two solutions:

while(Void!=(n:=s.find(p,n))){cnt+=1; n+=pn}

cnt

{{trans|J}}

{{out}}

<pre>

 

=={{header|ZX Spectrum Basic}}==

20 LET t$="THE THREE TRUTHS": LET p$="TH": GO SUB 1000

30 STOP

1040 NEXT i

1050 PRINT p$;"=";c''