In [27]:
# Determine if a string contains unique characters
import sys
import unittest
def unique_chars(data):
"""Using Hash map."""
if data is None or len(data) == 0:
return False
chars = {}
for x in data:
if x not in chars.keys():
chars[x] = 1
else:
return False
return True
def unique_set(data):
"""Using set data structure."""
if data is None:
return False
else:
chars = set()
for x in data:
if x in chars:
return False
else:
chars.add(x)
return True
class MyTest(unittest.TestCase):
def test_unique(self):
self.assertTrue(unique_set("ABSCDQWOU"))
self.assertFalse(unique_set("AAA"))
self.assertTrue(unique_set([x for x in xrange(10)]))
if __name__ == '__main__':
suite = unittest.TestLoader().loadTestsFromTestCase(MyTest)
unittest.TextTestRunner(verbosity=1, stream=sys.stderr).run(suite)
In [48]:
# Determine if a string is an anagram of another
import sys
import unittest
def sorted_anagram(data1, data2):
"""Compare the sorted version of both strings."""
if data1 is None or data2 is None:
return False
else:
return sorted(data1) == sorted(data2)
def is_anagram(data1, data2):
chars1 = {}
chars2 = {}
for x in data1:
if x not in chars1.keys():
chars1[x] = 1
else:
chars1[x] += 1
for x in data2:
if x not in chars2.keys():
chars2[x] = 1
else:
chars2[x] += 1
if chars1 == chars2:
return True
else:
return False
class MyTest(unittest.TestCase):
def test_unique(self):
self.assertTrue(sorted_anagram("ABCD", "BCAD"))
self.assertTrue(sorted_anagram('', ""))
self.assertTrue(sorted_anagram('1234567890', '0987654321'))
self.assertFalse(sorted_anagram("dsadas", "1231dsada"))
if __name__ == '__main__':
unittest.main(argv=['ignored', '-v'], exit=False)
In [2]:
# Flatten a list.
import sys
import unittest
import collections
data = [
[[1, 2, [3]], 4, [5]], [],
[x for x in xrange(10)],
[1, [], 2, 3, [3, '', []]],
[[1], 2, [[3, 4], 5], [[[]]], [[[6]]], 7, 8, []],
["junk",["nested stuff"],[],[[]]]
]
def flatten(data):
"""Simple recursive flatten."""
ret = []
for x in data:
if isinstance(x, list):
ret.extend(flatten(x))
elif x != '':
ret.append(x)
return ret
def flatten_using_morph(data):
"""Flatten a list using morph library."""
return morph.flatten(data)
def flatten_using_funcy(data):
"""Flatten a list using funcy library."""
return funcy.flatten(data)
# Incomplete.
def flatten_comprehension(data):
"""Flatten a list using list comprehension."""
return [x for y in data for x in y if isinstance(y, list)]
# Incomplete.
def flatten_itertools(data):
"""Flatten a list using itertools."""
return list(itertools.chain.from_iterable(data))
class MyTest(unittest.TestCase):
def test_flatten(self):
self.assertEqual(flatten([[1, 2, [3]], 4, [5]]), [1, 2, 3, 4, 5])
self.assertEqual(flatten([x for x in xrange(10)]), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
self.assertEqual(flatten([1, [], 2, 3, [4, '', []]]), [1, 2, 3, 4])
self.assertEqual(flatten([[1], 2, [[3, 4], 5], [[[]]], [[[6]]], 7, 8, []]), [1, 2, 3, 4, 5, 6, 7, 8])
self.assertEqual(flatten(["junk",["nested stuff"],[],[[]]]), ['junk', 'nested stuff'])
if __name__ == '__main__':
unittest.main(argv=['ignored', '-v'], exit=False)
In [28]:
# Reverse a string.
import sys
import unittest
def reverse_words(data):
if data is None:
return None
else:
return data[::-1]
def reverse_loop(data):
if data is None:
return None
else:
result = []
for x in data:
result.insert(0, x)
return "".join(result)
class MyTest(unittest.TestCase):
def test_reverse(self):
self.assertEqual(reverse_loop("Hello World"), "dlroW olleH")
self.assertEqual(reverse_loop(''), '')
self.assertEqual(reverse_loop(None), None)
self.assertEqual(reverse_loop("Hillary Clinton is a liar"), "rail a si notnilC yralliH")
def test_reverse_words(self):
self.assertEqual(reverse_words("Hello World"), "dlroW olleH")
self.assertEqual(reverse_words(''), '')
self.assertEqual(reverse_words(None), None)
self.assertEqual(reverse_words("Hillary Clinton is a liar"), "rail a si notnilC yralliH")
if __name__ == '__main__':
unittest.main(argv=['ignored', '-v'], exit=False)
In [26]:
# Reverse a list.
import unittest
def reverse(arr):
if arr:
arr[::-1]
def reverse_loop(arr):
if arr:
size = len(arr)-1
i = 0
while i<=size:
arr[i], arr[size-i] = arr[size-i], arr[i]
i += 1
size -= 1
return arr
def reverse_new(arr):
if arr:
out = []
for x in arr:
out.insert(0, x)
return out
class MyTest(unittest.TestCase):
def test_reverse(self):
self.assertEqual(reverse([x for x in xrange(100)]), [99-x for x in xrange(100)])
def test_reverse(self):
self.assertEqual(reverse_loop([x for x in xrange(100)]), [99-x for x in xrange(100)])
def test_reverse(self):
self.assertEqual(reverse_new([x for x in xrange(100)]), [99-x for x in xrange(100)])
if __name__ == '__main__':
unittest.main(argv=['ignored', '-v'], exit=False)
In [20]:
# Merge two sorted lists.
def merge(arr1, arr2):
if arr1 is None or len(arr1) == 0:
return arr2
elif arr2 is None or len(arr2) == 0:
return arr1
else:
out = []
size1 = len(arr1)
size2 = len(arr2)
i = 0
j = 0
while i < size1 and j < size2:
if arr1[i] < arr2[j]:
out.append(arr1[i])
i += 1
elif arr1[i] > arr2[j]:
out.append(arr2[j])
j += 1
else:
out.append(arr1[i])
out.append(arr2[j])
i += 1
j += 1
if i != size1:
out.extend(arr1[i:])
if j != size2:
out.extend(arr2[j:])
return out
class MyTest(unittest.TestCase):
def test_merge(self):
self.assertEqual(merge([x for x in xrange(1000)], [x for x in xrange(1000, 20000)]), [x for x in xrange(20000)])
self.assertEqual(merge([], []), [])
self.assertEqual(merge([x for x in xrange(100)], []), [x for x in xrange(100)])
if __name__ == '__main__':
unittest.main(argv=['ignored', '-v'], exit=False)
In [25]:
# Remove duplicates from a list.
def remove_duplicates(arr):
if arr:
return list(set(arr))
def dups_loop(arr):
if arr:
d = {}
for x in arr:
d[x] = 1
return list(d.keys())
if __name__ == '__main__':
print remove_duplicates([1, 2, 3, 2, 342, 12, 1, 342])
In [10]:
# Fibonacci series.
import unittest
def fib(n):
if n < 2:
return n
else:
return fib(n-1) + fib(n-2)
def fib_cache(n):
arr = {0:0, 1:1}
if n in arr:
return arr[n]
else:
for x in xrange(2, n+1):
arr[x] = arr[x-1] + arr[x-2]
return arr[n]
class MyTest(unittest.TestCase):
def test_fib(self):
self.assertEqual(fib(0), 0)
self.assertEqual(fib(1), 1)
self.assertEqual(fib(10), 55)
self.assertEqual(fib_cache(20), 6765)
self.assertEqual(fib_cache(50), 12586269025)
self.assertEqual(fib_cache(100), 354224848179261915075)
self.assertEqual(fib_cache(500), 139423224561697880139724382870407283950070256587697307264108962948325571622863290691557658876222521294125)
if __name__ == '__main__':
unittest.main(argv=['ignored', '-v'], exit=False)
In [58]:
# Check if a string is palindrome or not.
def palindrome_reverse(data):
if data is None:
return False
elif len(data) <= 1:
return True
else:
return data == data[::-1]
def is_palindrome(data):
if data is None or len(data) == 0:
return True
else:
out = data.lower()
start = 0
end = len(data)-1
while start < end:
if out[start] != out[end]:
return False
start += 1
end -= 1
return True
class MyTest(unittest.TestCase):
def test_palindrome(self):
self.assertTrue(palindrome_reverse(""))
self.assertTrue(palindrome_reverse("helleh"))
self.assertFalse(palindrome_reverse("hello world"))
self.assertTrue(palindrome_reverse("anna"))
if __name__ == '__main__':
unittest.main(argv=['ignored', '-v'], exit=False)
In [59]:
# Count the number of words in a string.
import string
def count_words(data):
if data is None or len(data) == 0:
return 0
else:
return len(data.split())
class MyTest(unittest.TestCase):
def test_words(self):
self.assertEqual(count_words(""), 0)
self.assertEqual(count_words("Hello World"), 2)
self.assertEqual(count_words("My name is Chinmaya Kumar Patanaik."), 6)
self.assertEqual(count_words(" ".join([x for x in string.ascii_lowercase])), 26)
if __name__ == '__main__':
unittest.main(argv=['ignored', '-v'], exit=False)
In [70]:
# Compress a string
def compress(string):
if string is None or len(string) == 0:
return string
result = ''
prev_char = string[0]
count = 0
for char in string:
if char == prev_char:
count += 1
else:
result += prev_char + (str(count) if count > 1 else '')
prev_char = char
count = 1
result += prev_char
if count > 1:
result += str(count)
if len(result) < len(string):
return result
else:
return string
class MyTest(unittest.TestCase):
def test_compress(self):
self.assertEqual(compress(None), None)
self.assertEqual(compress(''), '')
self.assertEqual(compress('AABBCC'), 'AABBCC')
self.assertEqual(compress('AAABCCDDDD'), 'A3BC2D4')
print('Success: test_compress')
if __name__ == '__main__':
unittest.main(argv=['ignored', '-v'], exit=False)
In [2]:
# Return a list of all permutations of a string
def permute(data, low, high):
if low == high:
print "".join(data)
else:
for x in xrange(low, high+1):
data[low], data[x] = data[x], data[low]
permute(data, low+1, high)
data[low], data[x] = data[x], data[low]
s = 'abc'
data = list(s)
permute(data, 0, len(data)-1)
In [ ]: