# 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: introductory

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
    
    #your code here


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)))

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

from typing import Tuple

def triple_trouble(*args: Tuple[str]) -> str:
    """ Get a string that combines all of the letters of the three inputed strings in groups. """
    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):
    #your code here
    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

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


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

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):
    #your code here
    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
    #your code here


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
    #your code here


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):
    result = ''
    for i in range(len(one)):
        result = result + one[i] + two[i] + three[i]
        print(result)
    return result

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):
    list_word = []
    for i in range(len(one)):
        list_word.append(one[i])
        list_word.append(two[i])
        list_word.append(three[i])
    return "".join(list_word)

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([f'{one[x]}{two[x]}{three[x]}' for x in range(len(one))])

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):
    res = ''
    a = one, two, three
    for i in range(len(one)):
        res += one[i]
        res += two[i]
        res += three[i]
    return res

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
    #your code here


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):

    result = ""
    for i in range(len(one)):
        result += one[i] + two[i] + three[i]

    return result


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)))
    #print(indices)
    for index in indices:
        Kombi= one[index]+two[index]+three[index]
        #print(Kombi)
        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
    #your code here


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):
    x = []
    for i in range(len(one)):
        x.append(one[i])
        x.append(two[i])
        x.append(three[i])
    return ''.join(x)

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):
    new_line = ""
    for i in range(0, len(one)):
        new_line += one[i] + two[i] + three[i]
    return new_line

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):return "".join(["".join([x[i] for x in (one,two,three)]) for i in range(len(one))])

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):
  
    news = ""
    for i in range (0,len(one)):
        news =  news + one[i]+two[i]+three[i]
    return news


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):
    return ''.join(f'{one[i]}{two[i]}{three[i]}' for i in range(0,len(one)))

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

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)