tkachoff
BAN USERdef get_all_possible_words(list_numbers):
def extend_words(words, letters):
res = []
for letter in letters:
for word in words:
res.append(word + letter)
return res
mapping = {
0: [""],
1: [""],
2: ["a", "b", "c"],
3: ["d", "e", "f"],
4: ["g", "h", "i"],
5: ["j", "k", "l"],
6: ["m", "n", "o"],
7: ["p", "q", "r", "s"],
8: ["t", "u", "v"],
9: ["w", "x", "y", "z"]
}
return reduce(extend_words, map(lambda x: mapping[x], list_numbers))
print get_all_possible_words([5, 2, 3])
import collections
import itertools
class Item(object):
def __init__(self, id, weight):
super(Item, self).__init__()
self.id = id
self.value = weight
def merge(l1, l2):
d = collections.defaultdict(int)
for item in itertools.chain(l1, l2):
d[item.id] += item.weight
res = []
for k, v in d.items():
res.append(Item(k, v))
return sorted(res, key=lambda x: x.weight)
import math
class Circle(object):
def __init__(self, x, y, r):
super(Circle, self).__init__()
self.x = x
self.y = y
self.r = r
def get_distance(self, circle):
return math.sqrt(math.pow(self.x - circle.x, 2) + math.pow(self.y - circle.y, 2))
def is_intersect(self, circle):
return self.get_distance(circle) < self.r + circle.r
@staticmethod
def has_intersections(list_circles):
list_circles.sort(key=lambda a: a.x - a.r)
sweep_intersected = []
for circle in list_circles:
for in_sweep in sweep_intersected:
if circle.is_intersect(in_sweep):
return True
if in_sweep.x + in_sweep.r < circle.x - circle.r:
sweep_intersected.remove(in_sweep)
sweep_intersected.append(circle)
return False
c1 = Circle(5, 5, 5)
c2 = Circle(11, 11, 5)
c3 = Circle(5.5, 10.5, 0.1)
print Circle.has_intersections([c1, c2, c3])
def get_all_sums(ex_coins, quantity):
def get_as_list(ex_coins, quantity):
result = []
for i in range(len(ex_coins)):
result.extend([ex_coins[i]] * quantity[i])
return result
def extend_sums(sums, n):
res = set()
for s in sums:
res.add(n + s)
res.add(n)
return sums.union(res)
coins = get_as_list(ex_coins, quantity)
return reduce(extend_sums, coins, set())
def get_polindrom(s):
d = collections.defaultdict(int)
for char in s:
d[char] += 1
result = []
odd_added = False
for k, v in d.items():
if not odd_added:
if v % 2 != 0:
odd_added = True
result = result[:(len(result)/2)] + [k] * v + result[(len(result)/2):]
else:
result += [k] * (v // 2)
result = [k] * (v // 2) + result
return "".join(result)
def get_range(matrix):
lt = []
for i in range(len(matrix)):
lt += map(lambda x: (x, i), matrix[i])
lt = sorted(lt, key=lambda x: x[0])
set_size = len(matrix)
min_range = float("+infinity")
result = []
for i in range(len(lt)):
s = set()
for j in range(i, len(lt)):
s.add(lt[j][1])
if len(s) == set_size:
r = lt[j][0] - lt[i][0]
min_range = min([r, min_range])
result = lt[i:j+1]
break
return result
- tkachoff November 28, 2016