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):
n = int(input())
s, t = input().split()
for i in range(n):
    print(s[i], end="")
    print(t[i], end="")
print()

Solution (Python):
n = int(input())
S,T = map(str,input().split())
S_T = []
for i in range(n):
  S_T.append(S[i])
  S_T.append(T[i])
  
print("".join(S_T))

Solution (Python):
N = int(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()
ans = ''
for i in range(N):
    ans += S[i]+T[i]
print(ans)

Solution (Python):
N = int(input())
w = list(map(str, input().split()))

ans = ''
for i in range(N):
	ans+=w[0][i]
	ans+=w[1][i]

print(ans)

Solution (Python):
n=int(input())
s,d=input().split()
print("".join([a+b for a,b in zip(s,d)]))

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

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

print(ans)

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

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

print(ans)

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

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

print("".join(x))

Solution (Python):
from copy import deepcopy
from sys import exit,setrecursionlimit
import math
from collections import defaultdict,Counter,deque
from fractions import Fraction as frac
import fractions
from functools import reduce
from operator import mul
import bisect
import sys
import logging
import heapq
import itertools

logging.basicConfig(level=logging.ERROR)

input = sys.stdin.readline

setrecursionlimit(1000000)


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

def factorization(n):
	if n<2:
		return []
	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 cmb(n,r):
    r = min(n-r,r)
    if r == 0: return 1
    over = reduce(mul, range(n, n - r, -1))
    under = reduce(mul, range(1,r + 1))
    return over // under

def zip(a):
	mae = a[0]
	ziparray = [mae]
	for i in range(1,len(a)):
		if(mae != a[i]):
			ziparray.append(a[i])
			mae = a[i]
	return ziparray

def is_prime(n):
	if n < 2: return False

	for k in range(2, int(math.sqrt(n)) + 1):
		if n % k == 0:
			return False

	return True

def list_replace(n,f,t):
	return [t if i==f else i for i in n]

def base_10_to_n(X, n):
	X_dumy = X
	out = ''
	while X_dumy>0:
		out = str(X_dumy%n)+out
		X_dumy = int(X_dumy/n)
	if(out == ''): return '0'
	return out

def gcd(numbers):
	return reduce(fractions.gcd, numbers)

def lcm(numbers):
    return reduce(lcm_base, numbers, 1)

def lcm_base(x, y):
    return (x * y) // fractions.gcd(x, y)

class Queue():
	def __init__(self):
		self.q = deque([])
	def push(self,i):
		self.q.append(i)
	def pop(self):
		return self.q.popleft()
	def size(self):
		return len(self.q)
	def debug(self):
		return self.q

class Stack():
	def __init__(self):
		self.q = []
	def push(self,i):
		self.q.append(i)
	def pop(self):
		return self.q.pop()
	def size(self):
		return len(self.q)
	def debug(self):
		return self.q

class graph():
	def __init__(self):
		self.graph = defaultdict(list)
	def addnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].append(t)
		self.graph[t].append(f)
	def rmnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].remove(t)
		self.graph[t].remove(f)
	def linked(self,f):
		return self.graph[f]

class dgraph():
	def __init__(self):
		self.graph = defaultdict(set)
	def addnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].append(t)
	def rmnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].remove(t)
	def linked(self,f):
		return self.graph[f]

class PriorityQueue():
	def __init__(self):
		self.queue = []
	def push(self,i):
		heapq.heappush(self.queue,-i)
	def pop(self):
		return -1 * heapq.heappop(self.queue)
	def sum(self):
		return -sum(self.queue)

main()

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

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

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

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 = str()
for i in range(n):
    ans += s[i]
    ans += t[i]


print(ans)

Solution (Python):
n = int(input())
a, b = input().split()

for i in range(n):
    print(a[i], end='')
    print(b[i], end='')

print()

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())
a=list(input().split())


for i in range(N):
  print(a[0][i],end="")
  print(a[1][i],end="")
print()

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

N = int(input())

ans = ""
S, T = (i for i in input().split())  



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[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):
N = int(input())
S, T = input().split()

print(''.join([i+j for i, j in zip(S, T)]))

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

ans = ""

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

print ans

Solution (Python):
import sys
def input():
    return sys.stdin.readline()[:-1]
n=int(input())
s,t=input().split()
tmp=""
for i in range(n):
    tmp+=s[i]
    tmp+=t[i]
print(tmp)

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

a = list(s)
b = list(t)
c = ""
for i in range(n):
    c = c + a[i] + b[i]

print(c)

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())
sss, ttt = input().split()

output = ''
for s, t in zip(sss, ttt):
  output += s + t
  
print(output)

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

Solution (Python):
import sys
import math
import re
import io

def main():
    n = int(input())
    s, t = input().split()
    A = []
    for i in range(n):
        A.append(s[i])
        A.append(t[i])
    print(''.join(A))

if __name__ == "__main__":
    main()

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

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

res = ""

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

print(res)

Solution (Python):

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

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[i]+T[i] for i in range(N)]))

Solution (Python):

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

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

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

for i in range(N):
    print(S[i], T[i], sep="", end="")
print()

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

ans = ''
for i in range(n):
    ans += a[i]
    ans += b[i]

print(ans)

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

out = ''

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

print(out)

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

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

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

ans = ''.join(A)
print(ans)

Solution (Python):



 
import sys
import math



 

fileoperation=0
if(fileoperation):
    orig_stdout = sys.stdout
    orig_stdin = sys.stdin
    inputfile = open('W:/Competitive Programming/input.txt', 'r')
    outputfile = open('W:/Competitive Programming/output.txt', 'w')
    sys.stdin = inputfile
    sys.stdout = outputfile


mod=1000000007
 

def nospace(l):
    ans=''.join(str(i) for i in l)
    return ans
 
 
 

t=1
for tt in range(t):
    n=int(input())
    x,y= map(str, sys.stdin.readline().split(' '))
    ans=""
    for i in range(n):
        ans+=x[i]
        ans+=y[i]
    print(ans)
    
    
    

if(fileoperation):
    sys.stdout = orig_stdout
    sys.stdin = orig_stdin
    inputfile.close()
    outputfile.close()

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

ans = ''
for Si, Ti in zip(S, T):
    ans += Si
    ans += Ti

print(ans)

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

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

print(r)

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

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

print(ans)

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

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

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

print("".join(x))

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

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

Solution (Python):
a=int(input())
b,c = (input().split()) 
for i in range(a):
  print(b[i]+c[i],end="")

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

Solution (Python):
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
mod = 10**9+7
Max = sys.maxsize
def l(): 
    return list(map(int,input().split()))
def m(): 
    return map(int,input().split())
def onem(): 
    return int(input())
def s(x): 
    a = []
    aa = x[0]
    su = 1
    for i in range(len(x)-1):
        if aa != x[i+1]:
            a.append([aa,su])
            aa = x[i+1]
            su = 1
        else:
            su += 1
    a.append([aa,su])
    return a
def jo(x): 
    return " ".join(map(str,x))
def max2(x): 
    return max(map(max,x))
def In(x,a): 
    k = bs.bisect_left(a,x)
    if k != len(a) and a[k] ==  x:
        return True
    else:
        return False
"""
def nibu(x,n,r):
    ll = 0
    rr = r
    while True:
        mid = (ll+rr)//2

    if rr == mid:
        return ll
    if (ここに評価入れる):
        rr = mid
    else:
        ll = mid+1
"""

n = onem()

a,b = input().split()

ccc = ""

for i in range(n*2):
    if i % 2 == 0:
        ccc += a[i//2]
    else:
        ccc += b[i//2]
print(ccc)

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().split()[0])
s, t = list(input().split())

ans = ""
for c1, c2 in zip(s, t):
    ans = ans + c1 + c2

print(ans)

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

print(ans)

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())
a, b = input().split()
ans = ""
for i in range(n):
    ans += a[i]
    ans += b[i]
print(ans)

Solution (Python):
def main():
    N = int(input())
    A = list(map(str, input().split()))
    i = 0
    while True:
        if i == N:
            break
        print(A[0][i],end='')
        print(A[1][i],end='')
        i += 1

if __name__ == '__main__':
    main()

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

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

word = ''
for a, b in zip(s, t):
  word += a + b
  
print(word)

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

Solution (Python):
import sys


stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  

n = ni()
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())

for i in range(N):
    print(S[i],end="")
    print(T[i], end="")

Solution (Python):
from sys import stdin
N = int(stdin.readline().rstrip())
S,T = [(x) for x in stdin.readline().rstrip().split()]
ans = ""
for i,j in zip(S,T):
    ans += (i + j)
print(ans)

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()
ans = ''
for i in range(n):
    ans = ans + s[i]
    ans = ans + t[i]
print(ans)

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(str,input().split())
ans = []
for i in range(n):
    ans.append(s[i])
    ans.append(t[i])

print(''.join(ans))

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

Solution (Python):
num = int(input())
s1,s2 = map(str,input().split())
l = ""
for i in range(0,num):
    l+=s1[i]
    l+=s2[i]

print(l)

Solution (Python):
n = int(input())
s = input()
ss = s.split()
a = list(ss[0])
b = list(ss[1])

for i in range(n):
  print(a[i], end="")
  print(b[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):

import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
write = sys.stdout.write
def ii(): return int(readline())
def mi(): return map(int, readline().rstrip().split())
def li(): return list(readline().rstrip())
def lmi(): return list(map(int, readline().rstrip().split()))
def end(*arg): print(*arg); sys.exit()



def main():
    N = ii()
    S, T = input().rstrip().split()
    ans = ""
    for i in range(N):
        ans += S[i] + T[i]
    print(ans)
    return


if __name__ == '__main__':
    main()

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

Solution (Python):
n = int(input())
s, t = 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()
res = ""
for i in range(N):
    res += S[i]
    res += T[i]

print(res)

Solution (Python):
import math
import queue
import bisect
import heapq
import time
import itertools

mod = int(1e9+7)

def swap(a,b):
    return (b,a)

def gcd(a,b): 
    if (a<b):
        a,b = swap(a,b)
    if (b==0):
        return a
    else:
        return gcd(b,a%b)

def divisors(a): 
    divisors = []
    for i in range(1,int(a**0.5)+1):
        if a%i==0:
            divisors.append(i)
            if i!=a//i:
                divisors.append(a//i)
    return divisors

def is_prime(a): 
    if a<2:
        return False
    elif a==2:
        return True
    elif a%2==0:
        return False
    sqrt_num = int(a**0.5)
    for i in range(3,sqrt_num+1,2):
        if a%i==0:
            return False
    return True

def prime_num(a): 
    pn = [2]
    for i in range(3,int(a**0.5),2):
        prime = True
        for j in pn:
            if i%j==0:
                prime = False
                break
        if prime:
            pn.append(i)
    return pn

def main():
    n = int(input())
    s,t = input().split()
    ans = []
    for i in range(n):
        ans.append(s[i])
        ans.append(t[i])
    print(''.join(ans))
    return

if __name__=='__main__':
    main()

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

Solution (Python):


import sys
import math
import collections
import itertools
from inspect import currentframe
INF = 10 ** 10
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def gcd(x, y) : return y if x % y == 0 else gcd(y, x % y)
def lcm(x, y) : return (x * y) // gcd(x, y)
def I() : return int(input())
def MI() : return map(int, input().split())
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(input()) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]
def chkprint(*args) : names = {id(v):k for k,v in currentframe().f_back.f_locals.items()}; print(', '.join(names.get(id(arg),'???')+' = '+repr(arg) for arg in args))

N = I()
S, T = input().split(" ")

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

print()

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

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

print(ST)

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

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

ans = []
for i in range(N):
    ans.append(S[0][i])
    ans.append(S[1][i])

print("".join(ans))

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

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 s, t in zip(S, T):
    ans = ans + s + t

print(ans)

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

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

n_str = ''
for i, j in zip(s, t):
    n_str += i
    n_str += j

print(n_str)

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

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())
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())
a,b = input().split()
s = ["0"]*n*2
s[::2] = a
s[1::2] = b
print(''.join(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 = input().split()

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

print(ans)

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

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

print(''.join(chars))

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

for i in range(N):
    print(S[i],end="")
    print(T[i],end="")

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

for i in range(N):
    print(S[i],end = "")
    print(T[i],end = "")
print()

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


def main():
    N = int(input())
    S, T = map(str, input().split())
    ans = ""
    for c, d in zip(S, T):
        ans += c
        ans += d
    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
N = int(input())
A, B = list(list(input().split()))
ans = ""
for a, b in zip(A, B):
    ans += a + b
print(ans)

Solution (Python):
import sys, math
def input():
    return sys.stdin.readline()[:-1]
from itertools import permutations, combinations
from collections import defaultdict

sys.setrecursionlimit(10**7)
N = int(input())
S, T = input().split()

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

print(l)

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

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()
res = ""
for i in range(n):
    res += s[i] + t[i]
print(res)

Solution (Python):
def main():
    n = int(input())
    s, t = input().split()
    res = []
    for i in range(n):
        res.append(s[i])
        res.append(t[i])
    return "".join(res)


print(main())

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

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

Solution (Python):



def merge(n, s, t):
    res = ""
    for i in range(n):
        res += s[i] + t[i]
    return res


def main():
    n = int(input())
    s, t = input().split()
    r = merge(n, s, t)
    print(r)


if __name__ == "__main__":
    main()

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()
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):
    ans += s[i]
    ans += t[i]

print(ans)

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

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


print(ans)

Solution (Python):
n = int(input())
st = input().split(" ")

result = ""

for i in range(0, n):
    result += st[0][i] + st[1][i]

print(result)

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())
s1,s2 = input().split()

ans = ''
for c1,c2 in zip(s1,s2):
  ans += c1 + c2

print(ans)

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):
import sys
def input(): return sys.stdin.readline().rstrip()

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


if __name__ == '__main__':
    main()

Solution (Python):
N=int(input())
lst=input().split()
S=lst[0]
T=lst[1]
for i in range(2*N):
    if i%2==0:
        print(S[int(i/2)],end="")
    else:
        print(T[int(i/2)],end="")
print()

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

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 = int(input())
S, T = input().split()
ans = ''
for s, t in zip(S, T):
    ans += s + t
print(ans)

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

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

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

for i in v:
    print(i, end='')

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

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

print(new)

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 = list(map(str, input().split()))

for i, j in zip(s, t):
  print(i, end='')
  print(j,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()
u = ''
for i in range(n):
  u += s[i]
  u += t[i]
print(u)

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

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

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

ans = ''
for i in range(n):
    ans += a[0][i]+a[1][i]

print(ans)

Solution (Python):
import queue
import math
import copy
"""
N = int(input())



A = []
for i in range(N):
	A.append(int(input()))

print(A)

"""
N = int(input())
S = input().split()
print("".join([S[0][i]+S[1][i]for i in range(N)]))

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

ans=""

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

Solution (Python):
a = int(input())
s1, s2 = map(str, input().split())
s = ""
for i in range(a*2):
  if(i%2 == 0):
    s+=s1[int(i/2)]
  else:
    s+=s2[int(i/2)]
print(s)

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

ans = ""
for i in range(N):
    ans += S[0][i]
    ans += S[1][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()
st=""
for i in range(n):
    st = st+s[i]+t[i]
print(st)

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

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())
for i in range(n):
    print(s[i]+t[i],end="")
print("")

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()
A = ""
for i in range(N):
    A += S[i] + T[i]

print(A)

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

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

ans=""

for i in range(n):
    ans+=lsa[i]+lsb[i]

print(ans)

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


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


def read_list():
    return list(read_values())


def read_lists(N):
    return [read_list() for n in range(N)]


def main():
    N = int(input())
    S, T = input().split()
    
    res = ""
    for s, t in zip(S, T):
        res += s + t
    
    print(res)


if __name__ == "__main__":
    main()

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

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

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()
ret = ""

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

print(ret)

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

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

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

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

print(ans)

Solution (Python):
import sys

def solve():
    N = int(input())
    S, T = map(str, input().split())
    Ans = [None] * (2 * N)
    for i in range(N):
        Ans[2 * i] = S[i]
        Ans[2 * i + 1] = T[i]
    print("".join(map(str, Ans)))
    
    return 0

if __name__ == "__main__":
    solve()

Solution (Python):
def main():
    N = int(input())
    S, T = input().split(' ')
    a = ''
    for i, j in zip(S, T):
        a += i + j
    print(a)
main()

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 = input()
S, T = input().split()
ans = ""
for s, t in zip(S, T):
  ans += s + t
print(ans)

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

Solution (Python):
N=int(input())
S,T=input().split()
ls=['' for _ in range(2*N)]
for i in range(N):
  ls[2*i]=S[i]
  ls[2*i+1]=T[i]
print(*ls,sep='')

Solution (Python):
n = input()
a, b = input().split()

ans = ""

for i in range(len(a)):
    ans += a[i]
    ans += b[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 += s[i]
    ans += t[i]
print(ans)

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

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

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().strip().split(' ')
ans = []
for i, j in zip(s, t):
    ans += i
    ans += j
print(''.join(ans))

Solution (Python):

n = int(input())
S,T = input().split()
ans = ''
for s,t in zip(S,T):
    ans += s + t
print(ans)

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()
ans = []
for a in range(len(s) + len(t)):
    if a%2==0:
        ans.append(s[a//2])
    else:
        ans.append(t[a//2])
print("".join(ans))

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

ans = []

for s, t in zip(S, T):
    ans.append(s)
    ans.append(t)

print(''.join(ans))

Solution (Python):
N=int(input())
S,T=input().split()
for i in range(2*N):
  if i%2==0:
    print(S[i//2],end="")
  else:
    print(T[i//2],end="")
print()

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

Solution (Python):
import sys
def input():
    return sys.stdin.readline()[:-1]
N = int(input())
S,T = map(str,input().split(' '))
ans = []
for i in range(N):
    ans.append(S[i]+T[i])
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()
ans = ""
for s, t in zip(S, T):
  ans += s + t
print(ans)