Problem:
 Score : 200 points    Problem Statement Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T , as follows: the first character of S , the first character of T , the second character of S , the second character of T , ... , the N -th character of S , the N -th character of T . Print this new string.      Constraints  1 \leq N \leq 100  |S| = |T| = N  S and T are strings consisting of lowercase English letters.         Input Input is given from Standard Input in the following format:  N  S  T       Output Print the string formed.        Sample Input 1 2
ip cc      Sample Output 1 icpc       Sample Input 2 8
hmhmnknk uuuuuuuu      Sample Output 2 humuhumunukunuku       Sample Input 3 5
aaaaa aaaaa      Sample Output 3 aaaaaaaaaa

Solution (Python):
import sys
import os
import math

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

MOD = 10 ** 9 + 7


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    N = ii()
    S, T = sl()
    ret = []
    for n in range(N):
        ret.append(S[n])
        ret.append(T[n])
    print("".join(ret))


if __name__ == '__main__':
    main()

Solution (Python):
import sys
import os
import math

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

MOD = 10 ** 9 + 7


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    N = ii()
    S, T = sl()
    ret = []
    for n in range(N):
        ret.append(S[n])
        ret.append(T[n])
    print(*ret,sep="")


if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
list = list(input().split(" "))
for i in range(0,n):
    print(list[0][i], end="")
    print(list[1][i], end="")

Solution (Python):
def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    
    from itertools import combinations, permutations, accumulate, groupby
    
    from bisect import bisect_left,bisect_right
    from heapq import heapify, heappop, heappush
    from math import floor, ceil
    

    
    

    n = int(input())
    s,t = input().rstrip().split()
    res = ''
    for a,b in zip(s, t):
        res += a + b
    print(res)

if __name__ == '__main__':
    main()

Solution (Python):


N = int(input())
S, T = input().split()
ans = ''

for s, t in zip(S, T):
    ans += s
    ans += t
print(ans)

Solution (Python):
n=int(input())
s,t=input().split()
new_s=""
for s,t in zip(s,t):
    new_s+=s+t
print(new_s)

Solution (Python):
N = int(input())
S, T = input().split()
for i in range(N):
    print(S[i] + T[i], end="")

Solution (Python):
def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    
    from itertools import combinations, permutations, accumulate, groupby
    
    from bisect import bisect_left,bisect_right
    from heapq import heapify, heappop, heappush
    from math import floor, ceil
    

    
    

    n = int(input())
    s,t = input().rstrip().split()
    res = ''
    for i in range(n):
        res += s[i]
        res += t[i]
    print(res)

if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
S, T = input().split()

A = []
for i in range(n):
    A.append(S[i])
    A.append(T[i])

for i in range(len(A)):
    print(A[i], end = "")

Solution (Python):
N=int(input())
S,T=input().split()
ans=''
for i in range(N):
    ans+=S[i]
    ans+=T[i]
print(ans)

Solution (Python):
N = int(input())
S, T = input().split()
print(''.join([s+t for s, t in zip(list(S), list(T))]))

Solution (Python):
N=int(input())
S,T=map(str,input().split())
for i in range (len(S)):
    print(S[i]+T[i], end='')

Solution (Python):
n = int(input())
s,t = input().split()
ans = ''
for i in range(n):
    ans += s[i] + t[i]
print(ans)

Solution (Python):
n=int(input())
s,t=input().split()
s=list(s)
t=list(t)
ans=[]
for i in range(n):
    ans.append(s[i])
    ans.append(t[i])
print("".join(ans))

Solution (Python):
N = int(input())
S, T = map(str, input().split())

result = ''

for i in range(N):
    result += S[i]
    result += T[i]

print(result)

Solution (Python):
N=int(input())
S,T=map(str,input().split())

ans=''

for i in range(N):
    ans+=S[i]
    ans+=T[i]

print(ans)

Solution (Python):
N = int(input())
S, T = input().split()
print(*[s+t for s,t in zip(S,T)], sep='')

Solution (Python):
N=input()
S,T=input().split()
print(*[s+t for s,t in zip(S,T)],sep="")

Solution (Python):
N = int(input())
S, T = input().split()
list = []
for i in range(0,N):
    list.append(S[i])
    list.append(T[i])
print(*list, sep='')

Solution (Python):
n = int(input())
s, t = map(str, input().split())
x = []
for i in range(n):
     x.append(s[i])
     x.append(t[i])
print(*x, sep='')

Solution (Python):
N = int(input())
s, t = map(str, input().split())

ans = ''
for i in range(N):
  ans = ans + s[i] + t[i]
  
print(ans)

Solution (Python):
n=int(input())

s,t=map(str,input().split())

u=""

for i in range(n):
  u+=s[i]
  u+=t[i]

print(u)

Solution (Python):
n = int(input())
s, t = input().split()
out = ""
for i in range(n):
    out += s[i] + t[i]
print(out)

Solution (Python):
n = int(input())
s1, s2 = map(list, input().split())

s = ''
for i in range(n):
  s = s + s1[i]
  s = s + s2[i]

print(s)

Solution (Python):
n = int(input())
S, T = map(str, input().split())
ans=''

for i in range(n):
	ans+=S[i]+T[i]
print(ans)

Solution (Python):
n = int(input())
s, t = map(str,input().split())
ans = []
for i in range(n):
    news = s[i]
    newt = t[i]
    ans.append(news)
    ans.append(newt)
print(*ans,sep="")

Solution (Python):

n = int(input())
s, t = input().split()
ans = ""
for i in range(n):
    ans += s[i]
    ans += t[i]
print(ans)

Solution (Python):
_, S, T = open(0).read().split()
print(''.join([s + t for s, t in zip(S, T)]))

Solution (Python):
N = int(input())
S, T = map(str,input().split())
s = list(S)
t = list(T)
A=[]
for i in range(N):
    A.append(s[i])
    A.append(t[i])
print("".join(A))

Solution (Python):
n = int(input())
s, t= input().split()
u = list()
for i in range(n):
    u.append(s[i])
    u.append(t[i])
print("".join(u))

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

n = int(readline())
s, t = input().split()
ans = ''
for i in range(n):
    ans += s[i] + t[i]
print(ans)

Solution (Python):
_, (S, T) = input(), input().split()
newline = ""
for s, t in zip(S, T):
  newline += (s + t)
print(newline)

Solution (Python):
N=int(input())
S,T=input().split()
a=""
for i in range(N):
  a+=S[i]
  a+=T[i]
print(a)

Solution (Python):
N = int(input())
S, T = map(str, input().split())

ans = ''

for i in range(N):
    ans += S[i] + T[i]

print(ans)

Solution (Python):
N = int(input())
S, T = input().split()
a = ''
for i in range(N):
  a += S[i]
  a += T[i]
print(a)

Solution (Python):
N=int(input())
S,T=input().split()
for i in range(N):
  print(S[i]+T[i],end='')

Solution (Python):
n = int(input())
s,t = input().split()
ans = ''
for i in range(2*n):
  if i&1:
    ans += t[i//2]
  else:
    ans += s[i//2]
print(ans)

Solution (Python):
N = int(input())

S, T = map(str, input().split())
S, T = list(S), list(T)

l = []
for i in range(N):
    l.append(S[i])
    l.append(T[i])

l = ''.join(l)

print(l)

Solution (Python):

N =int(input())
S,T = (x for x in input().split(" "))


x =""
for i in range(N):
    x += S[i] +T[i]
print(x)

Solution (Python):
N = int(input())
S,T = map(str, input().split())
A = ''
for i in range(N):
    A += S[i]+T[i]
print(A)

Solution (Python):
n = int(input())
s, t = input().split()

res = ""

for i in range(n):
  res += s[i] + t[i]
  
print(res)

Solution (Python):
N = int(input())
inputted = input().split()
S = inputted[0]
T = inputted[1]

answer = ''
for s, t in zip(S, T):
    answer += s + t

answer = ''.join([s + t for s, t in zip(S, T)])

print(answer)

Solution (Python):
n = int(input())
s, t = input().split()
print(*[i + j for i, j in zip(s, t)], sep='')

Solution (Python):
N=int(input())
S, T=input().split()
U=[]
for i in range(N):
	U.append(S[i])
	U.append(T[i])

print(*U, sep="")

Solution (Python):
N=int(input())
S,T=input().split()
U=""
for i in range(N):
  U+=S[i]+T[i]
  
print(U)

Solution (Python):
n = int(input())
s, t = input().split()
ans = []
for x, y in zip(s, t):
    ans.append(x)
    ans.append(y)
print(''.join(ans))

Solution (Python):
n = int(input())
s,t = input().split()
ans = ""
for i in range(n):
    ans += s[i] + t[i]
print(ans)

Solution (Python):
N = int(input())
S, T = input().split()


new_string = ''

for i in range(N):
    
    new_string += S[i] + T[i]
print(new_string)

Solution (Python):
n = int(input())
s, t = map(str,input().split())

ans = ''
for i in range(2*n):
    if i % 2 == 0:
        ans = ans + s[int(i/2)]
    else:
        ans = ans + t[int((i-1)/2)]

print(ans)

Solution (Python):

import sys


def solve(N: int, S: str, T: str):
    result = ""
    for i in range(N):
        result += S[i]+T[i]
    print(result)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    S = next(tokens)  
    T = next(tokens)  
    solve(N, S, T)


if __name__ == '__main__':
    main()

Solution (Python):
a=int(input())
b,c=list(map(str,input().split()))

for i in range(a):
  print(b[i],end="")
  print(c[i],end="")

Solution (Python):
n=int(input())
s,t=input().split()
k=[]
for i in range(n):
    k.append(s[i])
    k.append(t[i])
print("".join(k))

Solution (Python):
n = int(input())
s, t = input().split()

for i in range(n):
  print(s[i], end='')
  print(t[i], end='')

Solution (Python):
n = int(input())
s, t = input().split()
l=''
for i in range(n):
    l += s[i] + t[i]
print(l)

Solution (Python):
import sys
input = sys.stdin.readline
from collections import Counter, deque

INF = float('inf')

""" Input
S = input()
A = list(map(int, input().split()))
D = [int(input()) for _ in range(N)]
"""

def main():
    N = int(input())
    S, T = map(str, input().split())

    string = ""
    for i in range(N):
        string += S[i]
        string += T[i]
    print(string)


if __name__ == '__main__':
    main()

Solution (Python):
a = int(input())
p,q= input().split()
total= ''
for i in range(a):
    total += p[i]
    total += q[i]

print(total)

Solution (Python):










"""def kiri(n,m):
  r_ = n / m
  if (r_ - (n // m)) > 0:
    return (n//m) + 1
  else:
    return (n//m)"""
  
def main():
  n = int(input())
  s,t = map(str,input().split())
  new = ""
  for i in range(n):
    new += s[i]
    new += t[i]
  print(*new,sep="")
if __name__ == '__main__':
  main()

Solution (Python):
n = int(input())
s, t = input().split()
result = ''
for i in range(n):
    result += s[i]+t[i]
print(result)

Solution (Python):
N = int(input())
S,T = input().split()
S = list(S)
T = list(T)
i = 0
r = ""
while i < N:
    r += S[i] 
    r += T[i]
    i += 1
print(r)

Solution (Python):
n = int(input())
s, t = input().split()
a = ''
for i in range(n):
    a += s[i] + t[i]
print(a)

Solution (Python):
N = int(input()) 
T, S= map(str, input().split())
ans=''
for i in range(N):
    ans = ans+T[i]+S[i]
print(ans)

Solution (Python):
n = int(input())
s, t = input().split()

r = ''
for i in range(n):
    r = r + s[i] + t[i]
print(r)

Solution (Python):
n = int(input())
a,b = input().split()
string = ''
for i in range(n):
    string += a[i]
    string += b[i]
print(string)

Solution (Python):
N = int(input())
S,T = input().split()
ans = ''
for i in range(N):
    ans += S[i]+T[i]
print(ans)

Solution (Python):
N = int(input())
S,T = input().split()

ans = ""
for i in range(2*N):
    if i%2 == 0:
        ans += S[i//2]
    else:
        ans += T[i//2]

print(ans)

Solution (Python):
n = int(input())
s, t = input().split()
out = ""
for i in range(n):
    out += s[i] + t[i]
print(out)

Solution (Python):
n=int(input())
s,t=input().split()
a=""
for i in range(n):
    a+=s[i]+t[i]
print(a)

Solution (Python):
N=int(input());S,T=input().split();i=0;A=''
while i<N:A+=S[i]+T[i];i+=1
print(A)

Solution (Python):




def main():
    N = int(input())
    S, T = input().split()

    st = []

    for i in range(N):
        st.append(S[i])
        st.append(T[i])
    
    print(''.join(st))


if __name__ == '__main__':
    main()

Solution (Python):
N = input()
S, T = input().split(' ')

ans = []
ans = list(map(lambda s1,s2: s1+s2, list(S), list(T)))

print(''.join(ans))

Solution (Python):
n = int(input())
s, t =list(input().split())

a = []
for i in range(n):
    a.append(s[i])
    a.append(t[i])
print("".join(a))

Solution (Python):
n=int(input())
st=input().rstrip().split(" ")
s=st[0]
t=st[1]
string=""
for i in range(n):
    string=string+s[i:i+1]
    string=string+t[i:i+1]
print(string)

Solution (Python):
n = int(input())
s, b = input().split()
ans = ''
for c1, c2 in zip(s,b):
  ans += c1 + c2
print(ans)

Solution (Python):
N = int(input())

S , T = input().split()

L = ''

for i in range(N):
	L += S[i]
	L += T[i]
	
print(L)

Solution (Python):
import sys

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

N = ir()
S, T = sr().split()
answer = ''
for x, y in zip(S, T):
    answer += x + y

print(answer)

Solution (Python):
n=int(input())
s,t=input().split()
for i in range(n):
    print(s[i],t[i],sep="",end="")

Solution (Python):
N=int(input())
S=input().split()
L=[]
for i in range(N):
    for j in range(2):
        L.append(S[j][i])
print(*L,sep="")

Solution (Python):
n=int(input())
s,t=input().split()
res=""
for i in range(n):
  res+=s[i]+t[i]
print(res)

Solution (Python):
n = int(input())
s, t = list(map(str, input().split()))
a = ''
for num,_ in enumerate(s):
  a += s[num]
  a += t[num]
print(a)

Solution (Python):
N = int(input())
S, T = input().split()

ans = ""
for i in range(N):
    ans += S[i]
    ans += T[i]
print(ans)

Solution (Python):
N =int(input())
S,T= input().split()


B=""
for i in range(N):
  B=B+S[i]+T[i]
  
print(B)

Solution (Python):
n = int(input())
s, t = input().split()

ans = str()
for i in range(n):
    ans += s[i]
    ans += t[i]

print(ans)

Solution (Python):
N=input()
S,T=input().split()
print(*[s+t for s,t in zip(S,T)],sep="")

Solution (Python):
n = int(input())
s,t = input().split()
ans = ''
for i in range(n):
    ans += s[i] + t[i]
print(ans)

Solution (Python):
n = int(input())
s,t = input().split()
new = ""

for i in range(n):

    new +=(s[i]+t[i])
print(new)

Solution (Python):
n = int(input())
s,t = input().split()
result = ""
for i in range(n):
    result = result + s[i] + t[i]
print(result)

Solution (Python):
N=int(input())
S,T=input().split()
ans=''
for i in range(N):
    ans = ans + S[i] + T[i]

print(ans)

Solution (Python):
N = int(input())
S,T = input().split()
new = ""
for i in range(N):
    new += S[i]+T[i]

print(new)

Solution (Python):
n = int(input())
s, t = input().split()
l = []
for i in range(n):
  l.append(s[i])
  l.append(t[i])
  
print(''.join(l))

Solution (Python):
N=int(input())
S,T=input().split()
ans=""
for i in range(N):
  ans+=S[i]
  ans+=T[i]
print(ans)

Solution (Python):
n = int(input())
s, t = map(list, input().split())

r = []

for i in range(n):
    r.append(s[i])
    r.append(t[i])

print(''.join(r))

Solution (Python):
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))
def ism():return map(str,input().split())
def isl():return list(map(str,input().split()))

n = ii()
s,t = ism()
ans = ''
for i in range(n):
    ans += (s[i]+t[i])
print(ans)

Solution (Python):
n = int(input())
s,t = input().split()
for i in range(n):
    print(s[i],t[i],sep="",end="")

Solution (Python):
N = int(input())
S, T = input().split()
ans = ""
for i in range(N):
    ans += S[i]
    ans += T[i]

print(ans)

Solution (Python):
input()
S,T=input().split()
print("".join([a+b for a,b in zip(S,T)]))

Solution (Python):
N=int(input())
S,T=map(str,input().split())
ans=""
for i in range(N):
    ans+=(S[i]+T[i])
print(ans)

Solution (Python):
N=input()
S,T=input().split()
print(*[s+t for s,t in zip(S,T)],sep="")

Solution (Python):
N=int(input())
S,T=input().split()
for i in range(N):
  print(S[i],T[i],sep="",end="")

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 6)  
to_index = lambda x: int(x) - 1  
print_list_in_2D = lambda x: print(*x, sep="\n")  


def input_int(): return int(input())

def map_int_input(): return map(int, input())

MII = map_int_input

def MII_split(): return map(int, input().split())

def MII_to_index(): return map(to_index, input())

def MII_split_to_index(): return map(to_index, input().split())


def list_int_inputs(): return list(map(int, input()))

LII = list_int_inputs

def LII_split(): return list(map(int, input().split()))


def LII_2D(rows_number): return [LII() for _ in range(rows_number)]

def LII_split_2D(rows_number): return [LII_split() for _ in range(rows_number)]

N = input_int()
S, T = input().split()
ans = ''
for i in range(N):
    ans += S[i] + T[i]
print(ans)

Solution (Python):
N = int(input())
S, T  = [str(c) for c in input().split(" ")]
c = ""
for i in range(0,N):
  c = c+S[i]+T[i]
  
print(str(c))

Solution (Python):
N = int(input())
S, T = input().split()

ans = ""
for i in range(N):
  ans += S[i]
  ans += T[i]

print(ans)

Solution (Python):
n = int(input())
s,t=input().split()
a=''
for i in range(n):
    a += s[i]
    a += t[i]
print(a)

Solution (Python):
N = int(input())
S, T = input().split()

ans = ""

for i in range(N):
    ans += S[i]
    ans += T[i]

print(ans)

Solution (Python):
N = int(input())
S, T = input().split()

ans = ''

for  i in range(N):
    ans += S[i] + T[i]

print(ans)

Solution (Python):
n = int(input())
s, t = input().split()
ans = ""

for i in range(n):
  ans = ans + s[i] + t[i]

print(ans)

Solution (Python):
N=int(input())
S,T=map(str,input().split())
print(''.join(S[i]+T[i] for i in range(N)))

Solution (Python):
n=input()
S,T=input().split()
print(''.join([s+t for s,t in zip(S,T)]))

Solution (Python):
n = int(input())
s, t = input().split()
print(''.join([s[i]+t[i] for i in range(n)]))

Solution (Python):
N = int(input())
S, T = input().split()

ans = ''

for i in range(N):
    ans += S[i]
    ans += T[i]

print(ans)

Solution (Python):
a = int(input())
x , y = input().split(" ")

for i in range(a):
    print(x[i]+y[i],end="")

Solution (Python):
n = int(input())
 
s,t = input().split()
 
ans = s[0]+ t[0]
if n == 1:
    print(ans)
else:
    for i in range(1,n):
        ans = ans + s[i]+ t[i]
    print(ans)

Solution (Python):
n=int(input())
s,t=map(str,input().split())
d=[]
d.append(list(s))
d.append(list(t))

e=[]
for i in range(n):
    e.append(d[0][i])
    e.append(d[1][i])

for j in range(1,2*n):
    e[0]=e[0]+e[j]
    


print(e[0])

Solution (Python):
N=int(input())
S, T=input().split()

str=''
for i in range(N):
    str+=(S[i]+T[i])
print(str)

Solution (Python):
N=input()
S,T=input().split()
print(*[s+t for s,t in zip(S,T)],sep="")

Solution (Python):
n = int(input())
s, t = input().split()
w = ''
 
for i in range(n):
    w += s[i] + t[i]
 
print(w)

Solution (Python):
n = int(input())
s, t = map(str, input().split())
ans = ""
for i in range(n):
  ans += s[i] + t[i]
  
print(ans)

Solution (Python):
n = int(input())
s,t = map(str,input().split())
s_l,t_l = list(s),list(t)
result = []

for i in range(n):
    result.append(s_l[i])
    result.append(t_l[i])
    
print("".join(result))

Solution (Python):
n = int(input())
s, t = input().split()

ans = ''
for i in range(n):
    ans += s[i]
    ans += t[i]
print(ans)

Solution (Python):
N = int(input())
S, T = input().split()
A = ''
for i in range(N):
  A = A + S[i] + T[i]
print(A)

Solution (Python):
n = int(input())
data = input().split()

res = ""
for i in range(n):
  res += data[0][i]
  res += data[1][i]
 
print(res)

Solution (Python):

N = int(input())
S,T = input().split()
L =[]
for i in range(N):
    L.append(S[i])
    L.append(T[i])
print(''.join(L))

Solution (Python):
n=int(input())
s,t=map(str,input().split())
j=0
k=0
r=[0 for i in range(2*n)]
for i in range(0,2*n,2):
  r[i]=s[j]
  j+=1
  
for i in range(1,2*n+1,2):
  r[i]=t[k]
  k+=1
  
print("".join(r))

Solution (Python):
n=int(input())
s,t=input().split()
ans=""
for i in range(n):
  ans=ans+s[i]+t[i]
print(ans)

Solution (Python):


import sys
import heapq, math
from itertools import zip_longest, permutations, combinations, combinations_with_replacement
from itertools import accumulate, dropwhile, takewhile, groupby
from functools import lru_cache, reduce
from copy import deepcopy





N = int(input())
S, T = input().split()

ans = ""
for i in range(N):
    ans += S[i] + T[i]

print(ans)

Solution (Python):
N = int(input())
S, T = input().split()
ans = []
for n in range(N):
    ans.append(S[n])
    ans.append(T[n])
print("".join(ans))

Solution (Python):
N=int(input())
S,T=map(str,input().split())
S_list=list(S)
T_list=list(T)
ST=[]

for i in range(N):
    ST.append(S_list[i])
    ST.append(T_list[i])
print(''.join(ST))

Solution (Python):
N = int(input())
S, T = input().split()
print("".join([S[i]+T[i] for i in range(N)]))

Solution (Python):
N = int(input())
S, T = map(str,input().split())
for i in range(N):
     print(S[i] + T[i],end="")

Solution (Python):
N = int(input())
S,T = map(str,input().split())
total = ''
for i in range(N):
  total += S[i]
  total += T[i]
print(total)

Solution (Python):
N = int(input())
S,T = input().split()
A = []
for i in range(N):
  A += S[i] + T[i]
  
B = ''.join(A)
print(B)

Solution (Python):
input()
a,b = input().split()
A = [s for s in a]
B = [s for s in b]
out = ""
for i in range(len(A)):
    out = out + A[i]+B[i]
print(out)

Solution (Python):
n = int(input())
s,t = map(str,input().split())
for i in range(n):
    print(s[i]+t[i],end="")

Solution (Python):
n = int(input())
s, t = map(str,input().split())
for i in range(n):
    print(s[i]+t[i], end = "")

Solution (Python):
n = int(input())
s = list(input().split())
t = []

for i in range(n):
    t.append(s[0][i])
    t.append(s[1][i])

t = "".join(t)
print(t)

Solution (Python):
N = int(input())
S,T =list(map(str,input().split()))
out = ""
for i in range(0,N):
  out = out + S[i]+T[i] 

print(out)

Solution (Python):
n = int(input())
s = input().split()
ans = ""
for i in range(n):
  ans += s[0][i]+s[1][i]
print(ans)

Solution (Python):
N = int(input())
S, T = map(str, input().split())
L = ""
for i in range(N):
  L += S[i]+T[i]
print(L)

Solution (Python):
n = int(input())
s,t = map(str, input().split())
new = ""
for i in range(n):
  new += s[i]
  new += t[i]
  
print(new)

Solution (Python):
n = int(input())
s,t = input().split()
s_list = list(s)
t_list = list(t)
new = []
for i in range(n):
    new.append(s_list[i])
    new.append(t_list[i])
print(''.join(new))

Solution (Python):

import sys


def solve(N: int, S: str, T: str):
    ans = ''
    for i in range(N):
        ans += S[i]
        ans += T[i]
    print(ans)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    S = next(tokens)  
    T = next(tokens)  
    solve(N, S, T)

if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
s, t = input().split()
ans = ''
for si, ti in zip(s, t):
    ans += si + ti
print(ans)

Solution (Python):
def strings_with_the_same_length(n:int, s:str, t:str) -> str:
    message = []
    for i in range(n):
        message.append(s[i])
        message.append(t[i])
    message_x = "".join(message)
    return message_x

n = int(input())
s, t = input().split()
print(strings_with_the_same_length(n, s, t))

Solution (Python):
n = int(input())

s, t =input().split()

ans = ''

for i in range(n):
    ans += s[i]
    ans += t[i]

print(ans)

Solution (Python):
def main():
    N = int(input())
    S, T = input().split()
    ans = ''
    for i in range(N):
        ans += S[i]
        ans += T[i]
    print(ans)
    

main()

Solution (Python):
N = int(input())
S, T = input().split(' ')
for i in range(N):
    print(S[i], T[i], sep='', end='')
print()

Solution (Python):
N = input()
N = int(N)
S, T = map(str, input().split())

ans = ''

for n in range(N):
    ans = ans + S[n] + T[n]

print(ans)

Solution (Python):
N = int(input())
S, T = input().split()

new_string = []

for i in range(N):
    new_string.append(S[i])
    new_string.append(T[i])
    
ans = ''.join(new_string)

print(ans)

Solution (Python):
n = int(input())
s, t = input().split()
a = ""
for i,j in zip(s, t):
  a += i+j
print(a)

Solution (Python):
n = int(input())
s,t = list(input().split())
a = list()
for i in range(n):
  a.append(s[i])
  a.append(t[i])
b = ''.join(a)
print(b)

Solution (Python):
N = int(input())
A,B = input().split()
ans = []
for i in range(0,N):
  ans.append(A[i] + B[i])

print("".join(ans))

Solution (Python):
N = int(input())
A,B = input().split()
ans = []
for i in range(0,N):
  ans.append(A[i] + B[i])

print("".join(ans))

Solution (Python):
n = int(input())
s, t = input().split()
a = ""
for i,j in zip(s,t):a+=i+j
print(a)

Solution (Python):
n=int(input())
a=list(input().split())
b=list(a[0])
c=list(a[1])
d=[]
for k in range(0,n):
  d.append(b[k])
  d.append(c[k])
print("".join(d))

Solution (Python):
N =input()
S, T = input().split()
ans = ""
for i in range(len(S)):
    ans = ans+S[i]+T[i]
print(ans)

Solution (Python):
n=int(input())
s,t=map(str,input().split())

for i in range(n):
  print(s[i],end="")
  print(t[i],end="")
print("")

Solution (Python):
n = int(input())
s,t = input().split()
ans = ""
for i in range(n):
    ans += s[i] + t[i]
print(ans)

Solution (Python):
n=int(input())
s,t=map(str,input().split())
c=[]
d=[]
for i in range(n):
  a=s[i]
  b=t[i]
  d+=a+b
  
d=''.join(d)
print(d)

Solution (Python):
from collections import defaultdict, deque
import sys, heapq, bisect, math, itertools, string, queue, copy, time
from fractions import gcd
import numpy as np
sys.setrecursionlimit(10**8)
INF = float('inf')
MOD = 10**9+7
EPS = 10**-7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())


n = int(input())
s, t = input().split(" ")
ans_s = str()
for i in range(n):
    ans_s += s[i]
    ans_s += t[i]

print(ans_s)

Solution (Python):
n=input()
s,t=input().split()
print(*[a+b for a,b in zip(s,t)],sep='')

Solution (Python):
N = int(input())
S, T = input().split()
S_l = [i for i in S]
T_l = [i for i in T]
ans = list()
for i in range(1, 2*N+1):
    if i % 2 == 1:
        a = S[i//2]
    else:
        a = T[i//2-1]
    ans.append(a)
print(''.join(ans))

Solution (Python):
n = int(input())
s, t = input().split()
[print(i + j, end='')for i, j in zip(s, t)]
print()

Solution (Python):
n = int(input())
s,t = input().split()
l = ''

for i in range(n):
    l += s[i] + t[i]
print(l)

Solution (Python):
n = int(input())
s, t = input().rstrip().split()

x = ''
for i in range(n):
    x += s[i]
    x += t[i]
print(x)

Solution (Python):
n = int(input())
s,t = input().split()
d = ""
for i in range (n):
    d += s[i]
    d += t[i]
print(d)

Solution (Python):
n=int(input())
s,t=input().split()
ans=""

for i in range(n):
    ans+=s[i]+t[i]

print(ans)

Solution (Python):
N = int(input())
S,T = map(str,input().split(" "))

list = [0] * (2*N)
for i in range(N):
    list[2 * i] = S[i]
for j in range(N):
    list[2 * j + 1] = T[j]

ans = "".join(list)
print(ans)

Solution (Python):






import sys
input = sys.stdin.readline

import math
from collections import deque
from fractions import gcd
from functools import lru_cache






MOD = 10**9 +7
INF = float('inf')






def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]


def inv(n): return pow(n, MOD-2, MOD)


kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret


def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])
    return arr


def lcm(a, b):
    return a * b // gcd (a, b)





N = inputI()
S,T = inputSL()
s = list(S)
t = list(T)

print("".join([s[i]+t[i] for i in range(N)]))

Solution (Python):
n = input()
s,t = raw_input().split()
 

ns = ""
for i in xrange(n):
    ns += s[i]
    ns+= t[i]
print ns

Solution (Python):
N = input()
S, T = input().split()

l = [s+t for s, t in zip(S, T)]
print("".join(l))

Solution (Python):
N=int(input());
S,T=map(str,input().split());
for i in range(N):
  print(S[i],end="");
  print(T[i],end="");

Solution (Python):
n = int(input())
s_1, s_2 = input().split()

ans = ""
for i in range(n):
    ans += s_1[i] + s_2[i]

print(ans)

Solution (Python):
N = int(input())
S,T = input().split()
ans = ""
for n in range(N):
	ans += S[n] + T[n]
print(ans)

Solution (Python):
n = int(input())
s,t = input().split()
s = list(s)
t = list(t)

for i in range(n):
   s[i] = s[i] + t[i]

print("".join(s))

Solution (Python):
from sys import stdin
import math

n = int(stdin.readline().rstrip())
s, t = stdin.readline().rstrip().split()

result = ''
for i in range(n):
    result += s[i]
    result += t[i]

print(result)

Solution (Python):
N=int(input())
A,B=input().split()
S=""
for i in range(N):
  S+=A[i]+B[i]
print(S)

Solution (Python):
import sys
input = sys.stdin.readline

def solve():
  n = int(input())
  s,t = input().split()
  ans = ""
  for i in range(n):
    ans += s[i]
    ans += t[i]
  print(ans)
  
solve()