I was trying to solve this questions:
Given an input string, find all combination of unique substrings, which are anagrams of each other and distinct from each other. The substrings must follow 2 <= length(substring) < len(original string).
Example 1:
- String:
"vadapav" - substrings:
va, vad, vada, vadap, vadapa, ad, ada, adap, adapa, adapav, da, dap, dapa, dapav, ap, apa, apav, pa, pav, av - Output:
(va, av), (ad, da), (ap, pa)
How can it be optimised in terms of algorithmic and code complexity? Also, it does not give me all the expected outputs, how to correct it?
# Code goes below
from collections import defaultdict
import itertools
def anagram_substring(str):
substr_list = []
ans = []
is_present = defaultdict(intlist)
for i in rangexrange(2,len(str)):
substr_list.extend for j in xrange([''.joini+2, len(substrstr)+1):
for substr in itertools substr_list.combinationsappend(str,str[i:j])
i substr_list = list(set(substr_list)])
for substr in substr_list:
is_present[substr]if +=1is_present[''.join(sorted(substr))]:
rev_substr = substr[::-1]
if is_present[rev_substr] andfor rev_substr!=substranagram_str in is_present[''.join(sorted(substr))]:
ans.append([substr[anagram_str,rev_substr]substr])
is_present[''.join(sorted(substr))].append(substr)
return ans
str = raw_input().strip()
print anagram_substring(str)
I was trying to solve this questions:
Given an input string, find all combination of unique substrings, which are anagrams of each other and distinct from each other. The substrings must follow 2 <= length(substring) < len(original string).
Example 1:
- String:
"vadapav" - substrings:
va, vad, vada, vadap, vadapa, ad, ada, adap, adapa, adapav, da, dap, dapa, dapav, ap, apa, apav, pa, pav, av - Output:
(va, av), (ad, da), (ap, pa)
How can it be optimised in terms of algorithmic and code complexity? Also, it does not give me all the expected outputs, how to correct it?
# Code goes below
from collections import defaultdict
import itertools
def anagram_substring(str):
substr_list = []
ans = []
is_present = defaultdict(int)
for i in range(2,len(str)):
substr_list.extend([''.join(substr) for substr in itertools.combinations(str, i)])
for substr in substr_list:
is_present[substr] +=1
rev_substr = substr[::-1]
if is_present[rev_substr] and rev_substr!=substr:
ans.append([substr,rev_substr])
return ans
str = raw_input().strip()
print anagram_substring(str)
I was trying to solve this questions:
Given an input string, find all combination of unique substrings, which are anagrams of each other and distinct from each other. The substrings must follow 2 <= length(substring) < len(original string).
Example 1:
- String:
"vadapav" - substrings:
va, vad, vada, vadap, vadapa, ad, ada, adap, adapa, adapav, da, dap, dapa, dapav, ap, apa, apav, pa, pav, av - Output:
(va, av), (ad, da), (ap, pa)
How can it be optimised in terms of algorithmic and code complexity?
# Code goes below
from collections import defaultdict
import itertools
def anagram_substring(str):
substr_list = []
ans = []
is_present = defaultdict(list)
for i in xrange(len(str)):
for j in xrange(i+2, len(str)+1):
substr_list.append(str[i:j])
substr_list = list(set(substr_list))
for substr in substr_list:
if is_present[''.join(sorted(substr))]:
for anagram_str in is_present[''.join(sorted(substr))]:
ans.append([anagram_str,substr])
is_present[''.join(sorted(substr))].append(substr)
return ans
str = raw_input().strip()
print anagram_substring(str)
I was trying to solve this questions:
Given an input string, find all combination of unique substrings, which are anagrams of each other and distinct from each other. The substrings must follow 2 <= length(substring) < len(original string).
Example 1:
- String:
"vadapav" - substrings:
va, vad, vada, vadap, vadapa, ad, ada, adap, adapa, adapav, da, dap, dapa, dapav, ap, apa, apav, pa, pav, av - Output:
(va, av), (ad, da), (ap, pa)
How can it be optimised in terms of algorithmic and code complexity? Also, it does not give me all the expected outputs, how to correct it?
# Code goes below
from collections import defaultdict
import itertools
def anagram_substring(str):
substr_list = []
ans = []
is_present = defaultdict(int)
for i in range(2,len(str)):
substr_list.extend([''.join(substr) for substr in itertools.combinations(str, i)])
for substr in substr_list:
is_present[substr] +=1
rev_substr = substr[::-1]
if is_present[rev_substr] and rev_substr!=substr:
ans.append([substr,rev_substr])
return ans
str = raw_input().strip()
print anagram_substring(str)
I was trying to solve this questions:
Given an input string, find all combination of unique substrings, which are anagrams of each other and distinct from each other. The substrings must follow 2 <= length(substring) < len(original string).
Example 1:
- String:
"vadapav" - substrings:
va, vad, vada, vadap, vadapa, ad, ada, adap, adapa, adapav, da, dap, dapa, dapav, ap, apa, apav, pa, pav, av - Output:
(va, av), (ad, da), (ap, pa)
How can it be optimised in terms of algorithmic and code complexity?
# Code goes below
from collections import defaultdict
import itertools
def anagram_substring(str):
substr_list = []
ans = []
is_present = defaultdict(int)
for i in range(2,len(str)):
substr_list.extend([''.join(substr) for substr in itertools.combinations(str, i)])
for substr in substr_list:
is_present[substr] +=1
rev_substr = substr[::-1]
if is_present[rev_substr] and rev_substr!=substr:
ans.append([substr,rev_substr])
return ans
str = raw_input().strip()
print anagram_substring(str)
I was trying to solve this questions:
Given an input string, find all combination of unique substrings, which are anagrams of each other and distinct from each other. The substrings must follow 2 <= length(substring) < len(original string).
Example 1:
- String:
"vadapav" - substrings:
va, vad, vada, vadap, vadapa, ad, ada, adap, adapa, adapav, da, dap, dapa, dapav, ap, apa, apav, pa, pav, av - Output:
(va, av), (ad, da), (ap, pa)
How can it be optimised in terms of algorithmic and code complexity? Also, it does not give me all the expected outputs, how to correct it?
# Code goes below
from collections import defaultdict
import itertools
def anagram_substring(str):
substr_list = []
ans = []
is_present = defaultdict(int)
for i in range(2,len(str)):
substr_list.extend([''.join(substr) for substr in itertools.combinations(str, i)])
for substr in substr_list:
is_present[substr] +=1
rev_substr = substr[::-1]
if is_present[rev_substr] and rev_substr!=substr:
ans.append([substr,rev_substr])
return ans
str = raw_input().strip()
print anagram_substring(str)
I was trying to solve this questions:
Given an input string, find all combination of unique substrings, which are anagrams of each other and distinct from each other. The substrings must follow 2 <= length(substring) < len(original string)2 <= length(substring) < len(original string).
Example 1: String: "vadapav" substrings: va, vad, vada, vadap, vadapa, ad, ada, adap, adapa, adapav, da, dap, dapa, dapav, ap, apa, apav, pa, pav, av Output: (va, av), (ad, da), (ap, pa)
How can it be optimised in terms of algorithmic and code complexity?
- String:
"vadapav" - substrings:
va, vad, vada, vadap, vadapa, ad, ada, adap, adapa, adapav, da, dap, dapa, dapav, ap, apa, apav, pa, pav, av - Output:
(va, av), (ad, da), (ap, pa)
How can it be optimised in terms of algorithmic and code complexity?
# Code goes below
from collections import defaultdict
import itertools
def anagram_substring(str):
substr_list = []
ans = []
is_present = defaultdict(int)
for i in range(2,len(str)):
substr_list.extend([''.join(substr) for substr in itertools.combinations(str, i)])
for substr in substr_list:
is_present[substr] +=1
rev_substr = substr[::-1]
if is_present[rev_substr] and rev_substr!=substr:
ans.append([substr,rev_substr])
return ans
str = raw_input().strip()
print anagram_substring(str)
I was trying to solve this questions:
Given an input string, find all combination of unique substrings, which are anagrams of each other and distinct from each other. The substrings must follow 2 <= length(substring) < len(original string).
Example 1: String: "vadapav" substrings: va, vad, vada, vadap, vadapa, ad, ada, adap, adapa, adapav, da, dap, dapa, dapav, ap, apa, apav, pa, pav, av Output: (va, av), (ad, da), (ap, pa)
How can it be optimised in terms of algorithmic and code complexity?
# Code goes below
from collections import defaultdict
import itertools
def anagram_substring(str):
substr_list = []
ans = []
is_present = defaultdict(int)
for i in range(2,len(str)):
substr_list.extend([''.join(substr) for substr in itertools.combinations(str, i)])
for substr in substr_list:
is_present[substr] +=1
rev_substr = substr[::-1]
if is_present[rev_substr] and rev_substr!=substr:
ans.append([substr,rev_substr])
return ans
str = raw_input().strip()
print anagram_substring(str)
I was trying to solve this questions:
Given an input string, find all combination of unique substrings, which are anagrams of each other and distinct from each other. The substrings must follow 2 <= length(substring) < len(original string).
Example 1:
- String:
"vadapav" - substrings:
va, vad, vada, vadap, vadapa, ad, ada, adap, adapa, adapav, da, dap, dapa, dapav, ap, apa, apav, pa, pav, av - Output:
(va, av), (ad, da), (ap, pa)
How can it be optimised in terms of algorithmic and code complexity?
# Code goes below
from collections import defaultdict
import itertools
def anagram_substring(str):
substr_list = []
ans = []
is_present = defaultdict(int)
for i in range(2,len(str)):
substr_list.extend([''.join(substr) for substr in itertools.combinations(str, i)])
for substr in substr_list:
is_present[substr] +=1
rev_substr = substr[::-1]
if is_present[rev_substr] and rev_substr!=substr:
ans.append([substr,rev_substr])
return ans
str = raw_input().strip()
print anagram_substring(str)