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 math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline






















def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))

def main():
	A = inputInt()
	T = input()

	ST = T.split()

	ans = ""
	for i in range(A):
		ans += ST[0][i]
		ans += ST[1][i]

	print(ans)



if __name__ == "__main__":
	main()

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

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 = map(str, input().split())
ans = ""
for i in range(N):
    ans += S[i]+T[i]

print(ans)

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

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

print(ans)

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

for s, t in zip(S, T):
    print("{}{}".format(s,t), end="")

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

Solution (Python):
import math

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

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


def solve():
    N = int(input())
    S,T = map(str,input().strip().split())
    rtn = ""
    for i in range(N):
    	rtn += "{}{}".format(S[i],T[i])
    print(rtn)


if __name__ == '__main__':
    solve()

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

print(s)

Solution (Python):


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



ans=[]
for _ in range(N):
    ans.append(S.pop(0))
    ans.append(T.pop(0))
    
print("".join(ans))

Solution (Python):
from collections import defaultdict
import sys
import math
from datetime import datetime
import re
import math
def sol(n, S, T):
    ans = ""
    for i in range(n):
        ans += S[i]
        ans += T[i]
    return ans





do_submit = True


def input_parse(input_str):
    lines = [x.strip() for x in input_str.split("\n") if x.strip()]
    parsed_lines = [list(map(str, line.split())) for line in lines]
    print(parsed_lines)
    
    
    S = parsed_lines[0][0]
    return S


if not do_submit:
    S = input_parse("""
    1905
    """)
    print(sol(S))

    S = input_parse("""
    0112
    """)
    print(sol(S))

    S = input_parse("""
    1700
    """)
    print(sol(S))

    S = input_parse("""
    0000
    """)
    print(sol(S))

    S = input_parse("""
    1001
    """)
    print(sol(S))



else:
    
    n = int(input())
    S, T = list(map(str, input().split()))
    
    
    print(sol(n, S, T))

Solution (Python):
N = int(input())
S, T = list(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()

print("".join(i+j for i, j in zip(S, T)))

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

ans = [""] * (2 * N)

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

print("".join(ans))

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

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

print(*ans,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):
import sys
import math
import bisect
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop


def LI(): return [int(x) for x in sys.stdin.readline().split()]


def I(): return int(sys.stdin.readline())


def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res


def IR(n):
    return [I() for i in range(n)]



def A():
    a = I()
    b = I()
    print(6 - a - b)
    return



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



def C():
    return



def D():
    return



def E():
    return



def F():
    return



def resolve():
    B()
    return



if __name__ == "__main__":
    B()

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

Solution (Python):


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

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

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
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)

N = int(input())
L = input().strip().split(" ")
S = L[0]
T = L[1]

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

print(K)

Solution (Python):
n=int(input())
s,t=map(str,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()

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

print(new_string)

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

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

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

Solution (Python):
input()
a,b = input().split()
a = list(a)
b = list(b)
c = []
i = 0
for _ in a:
  c.append(a[i])
  c.append(b[i])
  i += 1
print(''.join(c))

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

for n in range(N):
  s1 = s[n]
  t1 = t[n]
  
  o = o + s1 + t1
  
print(o)

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

output = ''

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

print(output)

Solution (Python):



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

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

print(R)

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

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


if __name__ == "__main__":
    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):
n = int(input())
ans = ""
s, t = map(str, input().split())
for i in range(n):
    ans = ans + s[i] + t[i]
print(ans)

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



print(result)

Solution (Python):
import collections
import math
import operator as op
from functools import reduce
import numpy as np
import math
import bisect


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

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

    print(ret)


if __name__ == '__main__':
    main()

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

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

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

Solution (Python):

import math
import datetime
import itertools
import sys
import copy





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())
for a,b in zip(s,t):
  print(a+b,end="")

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

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

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

Solution (Python):
import sys; readline = sys.stdin.readline
from collections import deque

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

ans = ''.join(sum(zip(S, T), tuple()))

print(ans)

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

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

print(s)

Solution (Python):


N = int(input())
S = input()
s = S.split()

new_s = ''
for i in range(N):
    new_s += s[0][i]
    new_s += s[1][i]

print(new_s)

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

[print(l[0][i]+l[1][i],end="") for i in range(N)]
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,B=list(map(str,input().split()))

s=''
for a,b in zip(A,B):
    s+=a
    s+=b
print(s)

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

Solution (Python):
N=int(input())
A, B=input().split()
A=list(A)
B=list(B)

ans=[]
for i in range(N):
  ans.append(A[i])
  ans.append(B[i])


for a in ans:
  print(a, end='')

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

print("".join(ans))

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

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

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


if __name__ == '__main__':
    main()

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

rslt = ""
for idx, s in enumerate(S):
    rslt = rslt + (s + T[idx])

print(rslt)

Solution (Python):

import sys
read = sys.stdin.readline


def read_ints():
    return list(map(int, read().split()))


def read_a_int():
    return int(read())


def read_matrix(H):
    '''
    H is number of rows
    '''
    return [list(map(int, read().split())) for _ in range(H)]


def read_map(H):
    '''
    H is number of rows
    文字列で与えられた盤面を読み取る用
    '''
    return [read()[:-1] for _ in range(H)]


def read_col(H, n_cols):
    '''
    H is number of rows
    n_cols is number of cols

    A列、B列が与えられるようなとき
    '''
    ret = [[] for _ in range(n_cols)]
    for _ in range(H):
        tmp = list(map(int, read().split()))
        for col in range(n_cols):
            ret[col].append(tmp[col])

    return ret


N = read_a_int()
S, T = list(input().split())

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

Solution (Python):
N = int(input())
S, T = list(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 = ans + S[i]
  ans = ans + T[i]
  
print(ans)

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

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

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

ans = ""

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

Solution (Python):
n=int(input())
ans=""
st=input().split()
for i in range(n):
    ans=ans+st[0][i]+st[1][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())
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()

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

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

out = []

for s,t in zip(S,T):
  out.append(s)
  out.append(t)
  
print(''.join(out))

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

Solution (Python):

MOD = 10 ** 9 + 7

import math
import itertools



def sosuhante(n):
    for k in range(2, int(math.sqrt(n))+1):
        if n% k ==0:
            return False
    return True
def cmb(n, r):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result

def kingaku(a,b,n):
    keta=len(str(n))
    return a*n+b*keta

def my_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default


def main():


    n=int(input())
    s,t=map(str,input().split())
    s=list(s)
    t=list(t)
    c=[]
    for i in range(n):
        c.append(s[i])
        c.append(t[i])
    print("".join(c))

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

Solution (Python):
def main():

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

    for i in range(n):
        print(s[i], end="")
        print(t[i], end="")
if __name__=='__main__':
    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):
n=int(input())
s,t = input().split()
li=[]
for i in range(n):
  li.append(s[i])
  li.append(t[i])
mojiretu=""
for x in li:
  mojiretu += x
print(mojiretu)

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

for z in zip(S, T):
  print(*z, sep='', end='')
print()

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()
ans = ''

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

Solution (Python):
"""
Atcoder_Beginner_Contest_148
B

"""
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000)

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

print(result)

Solution (Python):
n=int(input())
s=input().split()
i=0
j=0
flag=0
l=list()
while(i<n or j<n):
    if(flag==0):
        l.append(s[0][i])
        i+=1
        flag=1
    else:
        l.append(s[1][j])
        j+=1
        flag=0
for i in range(len(l)):
    print(l[i],end="")

Solution (Python):
import math


def inputIntList():
    return [int(s) for s in input().split()]


def inputInt():
    return int(input())


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

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

    return ans


if __name__ == "__main__":
    print(main())

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 = [i for i in 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 = input().split(" ")
s = list(S)
t = list(T)
r = ""
for i in range(N):
    r += s[i] + t[i]
print(r)

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

Solution (Python):
import sys

stdin = sys.stdin

ri = lambda: int(rs())
rl = lambda: list(map(int, stdin.readline().split()))  
rs = lambda: stdin.readline().rstrip()  

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

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

print(answer)

Solution (Python):




ll= lambda : list(map(int,input().split()))
testcases=1

for testcase in range(testcases):
	[n] = ll()
	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.append(s[i])
    ans.append(t[i])

print(''.join(ans))

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

ans = ""
for val  in range(n):
    ans = ans + s1[val] + s2[val]
print(ans)

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

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

Solution (Python):
N = input()
S, T = raw_input().split()
print "".join(sum(map(list, zip(S, T)), []))

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 = 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 i in range(n):
    a.append(s[i])
    a.append(t[i])
print(''.join(a))

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 = (i for i in input().split())  

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

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

Solution (Python):
import sys











def main():
	n=int(input())
	s,t=map(str,input().split())
	a=""
	for i in range(n):
		a+=s[i]+t[i]
	print(a)
	




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

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

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

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

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

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

res = ''

for (i, s) in enumerate(S):
    res += s
    res += T[i]

print(res)

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])
print("".join(a))

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

print(word)

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

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

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

Solution (Python):
N=int(input())
sl=input().split(" ")

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

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

Solution (Python):
n = int(input())
s, t = input().split()
a = [None]*(2*n)
for i in range(n):
    a[i*2] = s[i]
    a[i*2+1] = t[i]
print(''.join(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 = list(input().split())
ans = ""
for i in range(n):
  ans = ans+s[i]
  ans = ans+t[i]
print(ans)

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

li = []

for i in range(n):
    li.append(st[0][i])
    li.append(st[1][i])
    
print(*li,sep='')

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

s = ''
for i in range(N):
    s += S[i]
    s += T[i]
print(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 = list(input().split())

r = ""

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

print(r)

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
 
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))

sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

N = INT()
S, T = S_MAP()
b = []
for i in range(N):
  a = S[i] + T[i]
  b.append(a)
b = "".join(b)
print(b)

Solution (Python):



import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
import sys

N = int(input())
S, T = input().split()
ans = []
for s, t in zip(S, T):
    print(s + t, 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 = [i for i in input().split()]
ans = ""
for i in range(len(s[0])):
  ans += s[0][i]
  ans += s[1][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):
def run():
  N = int(input())
  S, T = input().split()
  ans = ''
  for s, t in zip(list(S), list(T)):
    ans += s+t
  print(ans)
  
if __name__ == '__main__':
  run()

Solution (Python):
N = int(input())
s,t = input().split()
answer = ''
for num in range(N):
    answer += s[num]
    answer += t[num]
print(answer)

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

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

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

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 = map(list, input().split())
new_str = []
for i in range(n):
    new_str.append(s[i])
    new_str.append(t[i])
new_str = "".join(new_str)
print(new_str)

Solution (Python):
def main():
    n = int(input())
    s,t = input().split()
    ans = ""
    for i in range(n):
        ans = ans + s[i]
        ans = ans + t[i]
    print(ans)
    
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().strip())

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

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 = ''.join(s+t for s, t in zip(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):
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,copy,time
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 = inp()
S,T = input().split()
print(''.join([s+t for s,t in zip(S,T)]))

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

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

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

ans = ""
for ss, tt in zip(s,t):
  ans = ans+ss+tt

print(ans)

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

def solve(N, S, T):
    U = ['*'] * (N * 2)
    for i in range(N):
        U[i*2] = S[i]
        U[i*2+1] = T[i]
    return ''.join(U)


if __name__ == '__main__':
    inputs = read()
    print("%s" % solve(*inputs))

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


import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7

N = INT()
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())

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

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

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

Solution (Python):
N = int(input())
S, T = [s for s in input().split()]
S = list(S)
T = list(T)

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

Solution (Python):
N = int(input())
S,T =  input().split()
ans = ""
for i,j in zip(S,T):
  ans = ans+i+j
  
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())
for i in range(N):
    print(S[i]+T[i], end="")
print("")

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

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

print('')

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

output = ''
for i in range(N):
  output = output + S[0][i] + S[1][i]

print(output)

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

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


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

Solution (Python):
n = int(input())
st = input().split(" ")
s = st[0]
t = st[1]

r = ""

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

print(r)

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

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

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

res = ''
for i in range(n):
    res += st[0][i]
    res += st[1][i]

print(res)

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,j in zip(s,t):
    ans += i+j
print(ans)

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

print("".join(map(str, a)))

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

print(''.join([''.join([S[i], T[i]]) for i in range(N)]))

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())
ss = input().split()
print("".join([ss[0][i] + ss[1][i] for i in range(n)]))

Solution (Python):
input_line = int(input())
l = input().rstrip().split(' ')
s = l[0]
t = l[1]

ans = ""

for i in range(input_line):
	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] + 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())
txts = input().split(" ")

out = ""
for i in range(n):
    out += txts[0][i] + txts[1][i]

print(out)

Solution (Python):
n = int(input())
s, t = map(str, input().split())
for i in range(n * 2):
    if i % 2 == 0:
        print(s[int(i / 2)], end = "")
    else:
        print(t[int((i - 1) / 2)], end = "")
print()

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

for i in range(n):
  s=s+a[i:i+1]+b[i:i+1]
  
print(s)

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

result = []
for s, t in zip(S, T):
    result.append(s)
    result.append(t)
    
print(''.join(result))

Solution (Python):


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

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


target = ''
for si,ti in zip(s,t):
    target += si
    target += ti
print(target)

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