For example, given a string str = “this is a test string this a” and a string list lstr = [“is”; "this"; "a"], then the output string is “this a”.

Simple Solution

  • Generate all substrings of str.
  • For each substring, check that it contains all strings in lstr.
  • Print out the smallest one.

Complexity

The complexity depends on the number of substrings which is , where n is the length of str since the number of substring with the length m is . If finding each substring is . Then, the complexity is .

Efficient Solution

  • Find the first occurrence of a substring of str containing all strings in lstr.
  • If there exists one, called substr, then store its length as the indices of its first and last characters in str in a list.
  • Create a new string from str from the index of the character after the first character of substr,called str1. If it is empty, return the list. Otherwise find the first occurrence of a substring of str1 that contains all strings in lstr. Compare its length with the store value in the list, if it is smaller or equal, then add the string indices in the list.
  • Repeat the steps above.

Complexity

The complexity is where m is number of substrings containing all strings in lstr such that its leftmost and rightmost substrings are strings in lstr, and n is the length of str. In the worst-case, it is when str is string of same characters and lstr is list of this single character strings.

In the following, I show how to implement the algorithm above in the functional language OCaml. All other utility functions can be downloaded here.

(* 
 * find the shortest substring of str containing 
 * the strings str1 str2,...,strm in a list
 *)

(* use core for more efficient with long strings *)
open Core.Std 
open Printf

(* 
 * find substring sub in string str forward from pos 
 *)
let find_sub str pos sub = 
  let r = Str.regexp_string sub in
  Str.search_forward r str pos 

(* 
 * find substring sub in string str backward from pos 
 *)
let rfind_sub str pos sub = 
  let r = Str.regexp_string sub in
  Str.search_backward r str pos 

(*
 * get the substring from findex to lindex inclding 
 * characters at findex and lindex
 *)
let get_substring str findex lindex = 
  try 
    let sub = String.sub str findex (lindex - findex + 1) in
    Some sub
  with 
    Invalid_argument e -> None

(*
 * min element in a list
 *)
let min_element l = 
  let h = List.hd l in
  match h with
  | None -> -1
  | Some i -> 
      List.fold_left l ~init:i 
        ~f:(fun a b -> if a <= b then a else b)

(*
 * max element in a list
 *)
let max_element l = 
  let h = List.hd l in 
  match h with 
  | None -> -1
  | Some i -> List.fold_left l ~init:i 
      ~f:(fun a b -> if a >= b then a else b)

(* print all strings in the list of indices *)
let print_lstr_index des str lindex = 
  printf "-------------------------------\n";
  printf "%s\n" des;
	
  let lstr_opt = 
  List.map lindex 
    (fun x -> 
     let fi,li = x in 
     get_substring str fi li) 
  in 
  List.iter lstr_opt ~f: (fun s_opt -> 
    match s_opt with 
    | None -> printf "Invalid indices\n" 
    | Some s -> printf "%s\n" s);
	
  printf "-------------------------------\n"

(* print all strings in a list *)
let print_lstr des lstr = 
  printf "-------------------------------\n";
  printf "%s\n" des;
	
  List.iter lstr ~f: (fun s -> printf "%s\n" s);
	
  printf "-------------------------------\n"

(* print a list of indices *)
let print_lindex des lindex = 
  printf "-------------------------------\n";
  printf "%s\n" des;
	
  List.iter lindex ~f: 
    (fun s -> let x,y = s in printf "(%i,%i)\n" x y);
	
  printf "-------------------------------\n"
	
(*
 * compare two pair of indices 
 *)
let index_compare x y = 
  let x1, x2 = x in 
  let y1, y2 = y in
  if (x1 = y1 && x2 = y2) then 0 
  else if ((x1 < y1) || (x1 = y1 && x2 <= y2)) then -1 
  else 1
 
(*
 * update the set shortest substrings
 * if new_sub is not longer, then add it to the set
 *)
let update_lshortest_substr l i = 
  let a_opt = List.hd l in
  match a_opt with
  | None -> [ i ]
  | Some a -> 
    let i1, i2 = i in 
    let a1, a2 = a in 
    if ((i2 - i1) = (a2 - a1)) then
      i :: l
    else if ((i2 - i1) < (a2 - a1)) then 
      [ i ]
    else l

(* 
 * find the first occurrence of a substring in str 
 * that contains all strings in lstr
 * return the first and list indices of that substring
 * For example,
 * str = "This is a This string"
 * lstr = ["This"; "a"]
 * return = (0, 8)
 *)
let sub_lstr str lstr = 
  try 
    let length_list = List.map lstr (String.length) in 
    (* list of first occurrence indices of all strings in lstr *)
    let findex_list = List.map lstr (find_sub str 0) in 
    (* return the first occurence of substring containing all strings in lstr *)
    let lindex_list = List.map2_exn findex_list length_list (+) in 
    ((min_element findex_list), ((max_element lindex_list) - 1))					
  with 
    | Invalid_argument e -> (-1, -1)
    | Not_found -> (-1, -1)

(* 
 * find the last occurence of a substring in str that 
 * contains all strings in lstr
 * return the first and list indices of that substring
 * For example,
 * str = "This is a This string"
 * lstr = ["This"; "a"]
 * return = (8, 13)
 *)
let rsub_lstr str lstr = 
  try 
    let length_list = List.map lstr (String.length) in 
    (* list of first occurrence indices of all strings in lstr *)
    let findex_list = List.map lstr (rfind_sub str (String.length str - 1)) in 
    (* return the last occurrence of substring containing all strings in lstr *)
    let lindex_list = List.map2_exn findex_list length_list (+) in 
    ((min_element findex_list), ((max_element lindex_list) - 1))					
  with 
    | Invalid_argument e -> (-1, -1)
    | Not_found -> (-1, -1)


(*
 * find the shortest substring that containing all strings in the list
 * str : the string for searching
 * lstr : list of searching strings
 * n : the number of substrings containing all strings in lstr
 * lshortest_substr : return a list of (findex,lindex) indicate the locations of shortest substrings containing all strings in the lstr
 *)
let rec find_shortest_substrings_aux n lshortest_substr str lstr offset = 
  if (String.is_empty str) then
    (n, lshortest_substr)
  else
    begin
      (* find forward a substring containing the strings in lstr *)
      let substr_index = sub_lstr str lstr in 
      if (substr_index = (-1, -1)) then 
        (* not found return the result *)
        (n, lshortest_substr)
      else 
        (* updated lshortest_substr an find the next substring from fi + 1 to the end of str *)
        let fi, li = substr_index in 
        find_shortest_substrings_aux (n + 1) (update_lshortest_substr lshortest_substr (fi + offset, li + offset)) (String.sub str (fi + 1) (String.length str - (fi + 1))) lstr (offset + fi + 1)
    end

let find_shortest_substrings str list_strings = 
  (* remove all empty strings in the lstr *)
  let lstr_tmp = List.filter list_strings (fun x -> not (String.is_empty x)) in 
  (* remove all duplicate strings in lstr_tmp *)
  let lstr = List.dedup ~compare:(compare) lstr_tmp in 
  if (List.is_empty lstr) then 
    (-1, [(0,-1)]) (* empty string *)
  else if (String.is_empty str) then
    (0, [(-1,-1)])
  else
    begin
     (* find the first occurrence of substring containing the strings in lstr *)
     let substr_index = sub_lstr str lstr in 
     if (substr_index = (-1,-1)) then 
       (0, [(-1,-1)])
     else 
       begin
         let fi, li = substr_index in 
         let (n, lshortest_substr) = find_shortest_substrings_aux 1 [substr_index] (String.sub str (fi + 1) (String.length str - (fi + 1))) lstr (fi + 1) in 
         (* remove all duplicates before return *)
         (n, List.dedup ~compare:(index_compare) lshortest_substr)
       end
    end