# Triple Trouble

Create a function that will return a string that combines all of the letters of the three inputed strings in groups.  Taking the first letter of all of the inputs and grouping them next to each other.  Do this for every letter, see example below!

**E.g. Input: "aa", "bb" , "cc" => Output: "abcabc"** 

*Note: You can expect all of the inputs to be the same length.*

Difficulty: EASY
Starter code: def triple_trouble(one, two, three):
	

Solutions:
def triple_trouble(one, two, three):
	return ''.join((''.join(a) for a in zip(one, two, three)))


def triple_trouble(one, two, three):
	return ''.join((a + b + c for (a, b, c) in zip(one, two, three)))


def triple_trouble(*args):
	return ''.join((''.join(a) for a in zip(*args)))


def triple_trouble(one, two, three):
	ans = ''
	for i in range(len(one)):
		ans += one[i]
		ans += two[i]
		ans += three[i]
	return ans


def triple_trouble(*args):
	return ''.join(sum(zip(*args), ()))


def triple_trouble(one, two, three):
	return ''.join([one[i] + two[i] + three[i] for i in range(len(one))])


def triple_trouble(one, two, three):
	a = one.split(' ')
	a = map(lambda x, y, z: x + y + z, one, two, three)
	return ''.join(a)


def triple_trouble(*args):
	return ''.join(map(''.join, zip(*args)))


def triple_trouble(one, two, three):
	ans = ''
	for x in range(len(one)):
		ans += one[x] + two[x] + three[x]
	return ans


def triple_trouble(one, two, three):
	return ''.join((''.join(v) for v in zip(one, two, three)))


def triple_trouble(one, two, three):
	count = 0
	length = len(one)
	string = ''
	while count < length:
		string += one[count] + two[count] + three[count]
		count += 1
	return string


def triple_trouble(one, two, three):
	return ''.join((''.join(s) for s in zip(one, two, three)))


def triple_trouble(one, two, three):
	return ''.join((''.join(i) for i in zip(one, two, three)))


def triple_trouble(one, two, three):
	a = ''
	for i in range(len(one)):
		a += one[i] + two[i] + three[i]
	return a


def triple_trouble(one, two, three):
	i = 0
	t = ''
	while i < len(three):
		t = t + one[i] + two[i] + three[i]
		i += 1
	return t


triple_trouble = lambda *args: ''.join((''.join(z) for z in zip(*args)))


triple_trouble = lambda r, s, t: ''.join([c + s[i] + t[i] for (i, c) in enumerate(list(r))])


def triple_trouble(*l):
	return ''.join([''.join(s) for s in zip(*l)])


def triple_trouble(*args):
	return ''.join((''.join(tupl) for tupl in zip(*args)))


def triple_trouble(one, two, three):
	return ''.join(map(''.join, zip(list(one), list(two), list(three))))


def triple_trouble(one, two, three):
	from functools import reduce
	return ''.join(reduce(lambda x, y: x + y, zip(one, two, three)))


from typing import Tuple

def triple_trouble(*args: Tuple[str]) -> str:
	return ''.join(list(map(''.join, zip(*args))))


from itertools import chain

def triple_trouble(one, two, three):
	return ''.join((c for c in chain.from_iterable(zip(one, two, three))))


def triple_trouble(one, two, three):
	return ''.join(['{}{}{}'.format(one[x], two[x], three[x]) for x in range(len(one))])


def triple_trouble(one, two, three):
	four = ''
	for x in range(len(one)):
		four += one[x] + two[x] + three[x]
	return four


def triple_trouble(one, two, three):
	ret = ''
	for i in range(len(one)):
		ret = ret + one[i] + two[i] + three[i]
	return ret


triple_trouble = lambda o, t, h: ''.join((''.join([a, t[i], h[i]]) for (i, a) in enumerate(o)))


def triple_trouble(one, two, three):
	res = len(one)
	l = ''
	for i in range(res):
		result = one[i] + two[i] + three[i]
		l = l + result
	return l


def triple_trouble(one, two, three):
	x = list(zip(one, two, three))
	result = []
	for item in x:
		result.append(''.join(item))
	return ''.join(result)


def triple_trouble(one, two, three):
	result = ''
	n = 0
	while n < len(one):
		result += one[n] + two[n] + three[n]
		n += 1
	return result


def triple_trouble(one, two, three):
	output = ''
	for (first, second, third) in zip(one, two, three):
		output = ''.join([output, first, second, third])
	return output


def triple_trouble(one, two, three):
	new_string = ''
	for letter in range(len(one)):
		new_string += one[letter]
		new_string += two[letter]
		new_string += three[letter]
	return new_string


def triple_trouble(one, two, three):
	str1 = ''
	for i in range(len(one)):
		str1 += one[i]
		str1 += two[i]
		str1 += three[i]
	return str1


def triple_trouble(one, two, three):
	x = list(zip(one, two, three))
	l1 = [''.join(y) for y in x]
	return ''.join(l1)


def triple_trouble(one, two, three):
	result = ''
	for (i, c) in enumerate(one):
		result += c + two[i] + three[i]
	return result


def triple_trouble(one, two, three):
	return ''.join((''.join(set) for set in list(zip(one, two, three))))


def triple_trouble(one, two, three):
	list = []
	for x in range(len(one)):
		list.extend((one[x], two[x], three[x]))
	return ''.join(list)


def triple_trouble(one, two, three):
	x = [one, two, three]
	y = max(x, key=len)
	z = len(y)
	a = ''
	for k in range(0, z):
		a += x[0][k] + x[1][k] + x[2][k]
	return a


def triple_trouble(one, two, three):
	result = ''
	for i in range(len(one)):
		segm = one[i] + two[i] + three[i]
		result += segm
	return result


def triple_trouble(one, two, three):
	word = ''
	for i in range(0, len(one)):
		word += one[i] + two[i] + three[i]
	return word


def triple_trouble(one, two, three):
	i = 0
	list123 = []
	while i < len(one):
		list123.append(one[i])
		list123.append(two[i])
		list123.append(three[i])
		i += 1
	return ''.join(list123)


def triple_trouble(one, two, three):
	L = len(one)
	result = []
	for x in range(L):
		result.append(one[x])
		result.append(two[x])
		result.append(three[x])
	return ''.join(result)


def triple_trouble(one, two, three):
	s = ''
	a = 0
	b = [one, two, three]
	for j in one:
		for i in b:
			s += i[a]
		a += 1
	return s


def triple_trouble(one, two, three):
	collector = ''
	size = 0
	while size < len(one):
		collector += one[size] + two[size] + three[size]
		size += 1
	return collector


def triple_trouble(one, two, three):
	return ''.join((lttr1 + lttr2 + lttr3 for (lttr1, lttr2, lttr3) in zip(one, two, three)))


def triple_trouble(one, two, three):
	result = ''
	x = 0
	for i in one:
		result = result + i + two[x] + three[x]
		x = x + 1
	return result


def triple_trouble(one, two, three):
	return ''.join((''.join(el) for el in zip(one, two, three)))


def triple_trouble(one, two, three):
	strin = ''
	for el in range(len(one)):
		strin += one[el] + two[el] + three[el]
	return strin


def triple_trouble(one, two, three):
	car = ''
	for i in range(len(one)):
		car += one[i] + two[i] + three[i]
	return car


triple_trouble = lambda *a: ''.join((''.join(x) for x in zip(*a)))


def triple_trouble(one, two, three):
	result_str = ''
	for (o, tw, th) in zip(one, two, three):
		result_str += o + tw + th
	return result_str


def triple_trouble(one, two, three):
	list = map(lambda a, b, c: a + b + c, one, two, three)
	return ''.join(list)


def triple_trouble(one, two, three):
	newStr = ''
	for i in range(len(one)):
		newStr += one[i] + two[i] + three[i]
	return newStr


def triple_trouble(a, b, c):
	r = ''
	for i in range(len(a)):
		r += a[i] + b[i] + c[i]
	return r


def triple_trouble(one, two, three):
	tot = ''
	for x in range(len(one)):
		tot += one[x] + two[x] + three[x]
	return tot


def triple_trouble(a, b, c):
	s = ''
	for i in range(len(a)):
		s += a[i] + b[i] + c[i]
	return s


def triple_trouble(one, two, three):
	my_list = []
	for i in range(len(one)):
		my_list.append(one[i] + two[i] + three[i])
	final = ''.join(my_list)
	return final


def triple_trouble(one, two, three):
	return ''.join((''.join(tuple) for tuple in list(zip(one, two, three))))


def triple_trouble(one, two, three):
	output = ''
	for x in range(len(one)):
		output += one[x]
		output += two[x]
		output += three[x]
	return output


triple_trouble = lambda one, two, three: ''.join([f'{one[i]}{two[i]}{three[i]}' for i in range(len(one))])


def triple_trouble(one, two, three):
	tup = list(zip(one, two, three))
	out = list(sum(tup, ()))
	return ''.join(out)


def triple_trouble(one, two, three):
	Liste = list()
	indices = list(range(len(one)))
	for index in indices:
		Kombi = one[index] + two[index] + three[index]
		Liste.append(Kombi)
	Liste = ''.join(Liste)
	return Liste


def triple_trouble(one, two, three):
	Trible = ''
	for x in range(len(one)):
		Trible += one[x] + two[x] + three[x]
	return Trible


triple_trouble = lambda a, b, c: ''.join([a[i] + b[i] + c[i] for i in range(0, len(a))])


def triple_trouble(one, two, three):
	result = ''
	counter = 0
	while counter < len(one):
		result += one[counter] + two[counter] + three[counter]
		counter += 1
	return result


def triple_trouble(one, two, three):
	x = ''
	a = list(one)
	b = list(two)
	c = list(three)
	for i in range(0, max(len(a), len(b), len(c))):
		x = x + a[i] + b[i] + c[i]
	return x


def triple_trouble(one, two, three):
	soln = ''
	for i in range(len(one)):
		soln += one[i] + two[i] + three[i]
	return soln


def triple_trouble(one, two, three):
	return ''.join((one[n] + two[n] + three[n] for n in range(len(one))))


def triple_trouble(one, two, three):
	combined = ''
	i = 0
	for letter in range(len(one)):
		combined += one[i] + two[i] + three[i]
		i += 1
	return combined


def triple_trouble(one, two, three):
	counter = 0
	res = ''
	for i in one:
		res += i
		res += two[counter]
		res += three[counter]
		counter += 1
	return res


def triple_trouble(one, two, three):
	res = ''
	for x in range(len(one)):
		res += one[x]
		res += two[x]
		res += three[x]
	return res


def triple_trouble(one, two, three):
	str = ''
	for n in range(len(one)):
		str += one[n] + two[n] + three[n]
	return str


def triple_trouble(one, two, three):
	s = one + two + three
	A = len(s)
	B = len(one)
	answ = ''
	start = 0
	for j in range(B):
		for i in range(start, A, B):
			answ += s[i]
		start += 1
	return answ


def triple_trouble(one, two, three):
	zipped = list(zip(one, two, three))
	return ''.join(('%s%s%s' % z for z in zipped))


def triple_trouble(one, two, three):
	arr = [one, two, three]
	result = ''
	for i in range(len(arr[0])):
		for j in range(3):
			result += arr[j][i]
	print(result)
	return result


def triple_trouble(one, two, three):
	l = []
	for i in range(0, len(one)):
		l.append(one[i] + two[i] + three[i])
	return ''.join(l)


def triple_trouble(one, two, three):
	one = [item for item in one]
	two = [item for item in two]
	three = [item for item in three]
	new = []
	for i in range(0, len(one)):
		new.append(one[i] + two[i] + three[i])
	return ''.join(new)


def triple_trouble(one, two, three):
	char = ''
	for (i, j, k) in zip(one, two, three):
		char += str(i) + str(j) + str(k)
	return char


def triple_trouble(one, two, three):
	new = ''
	for j in range(0, len(one)):
		name = one[j] + two[j] + three[j]
		new += one[j] + two[j] + three[j]
	return new
ziel = triple_trouble('burn', 'reds', 'roll')
print(ziel)


def triple_trouble(one: str, two: str, three: str) -> str:
	return ''.join([''.join(x) for x in zip(one, two, three)])


def triple_trouble(one, two, three):
	oneL = list(one)
	twoL = list(two)
	threeL = list(three)
	returnArr = []
	for i in range(len(oneL)):
		returnArr.append(oneL[i])
		returnArr.append(twoL[i])
		returnArr.append(threeL[i])
	return ''.join(returnArr)


def triple_trouble(one, two, three):
	result = ''
	e = 0
	while e < len(one):
		result += one[e] + two[e] + three[e]
		e += 1
	return result


def triple_trouble(one, two, three):
	result = []
	for (pt1, pt2, pt3) in zip(one, two, three):
		for (i, j, k) in zip(pt1, pt2, pt3):
			result.append(i)
			result.append(j)
			result.append(k)
	return ''.join(result)