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()
assert len(S) == N
assert len(T) == N

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

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

Solution (Python):
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 6)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")
al = "abcdefghijklmnopqrstuvwxyz"
AL = al.upper()

n = k()
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()
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())
new_word_list = []

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

print(''.join(new_word_list))

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


def main():
    n = int(input())
    S, T = input().split()
    print(*[s + t for s, t in zip(S, T)], sep="")


if __name__ == "__main__":
    main()

Solution (Python):


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


if __name__ == "__main__":
    main()

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

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

print(c)

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

Solution (Python):
def answer(n: int, s: str, t: str) -> str:
    new_str = ''
    for i in range(n):
        new_str += f'{s[i]}{t[i]}'

    return new_str


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


if __name__ == '__main__':
    main()

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

character = list()

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

answer = "".join(character)

print(answer)

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

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

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

str_list = []

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

print("".join(str_list))

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

for i in range(n):

    a.append(s[i]+t[i])
a = "".join(a)
print(a)

Solution (Python):
n=int(input())
s,t=map(str,input().split())
ans=[]
for i in range(len(s)):
    ans.append(s[i])
    ans.append(t[i])
ans="".join(ans)
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:i+1]+T[i:i+1],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):
a = int(input())
p, q = input().split()

ans = ''
for i in range(a):
    ans += p[i]
    ans += q[i]
print(ans)

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

def ans148(N:int, S:str, T:str):
    newstr=""
    for i in range(0,N):
        newstr=newstr+S[i]+T[i]
    return newstr

print(ans148(N,S,T))

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

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

print(''.join(result))

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

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

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

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

for i in range(n):
    l.extend([s[i], t[i]])

print(''.join(l))

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

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

print(ans)

Solution (Python):

import sys
from itertools import chain


def solve(N: int, S: str, T: str):
    answer = "".join([st[0] + st[1] for st in zip(S, T)])
    return answer


def main():
    tokens = chain(*(line.split() for line in sys.stdin))
    N = int(next(tokens))  
    S = next(tokens)  
    T = next(tokens)  
    answer = solve(N, S, T)
    print(answer)


if __name__ == "__main__":
    main()

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

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

A = []
for s, t in zip(S,T):
    A += s+t
print(*A, sep='')

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()
print(*[i+j for i,j in zip(s,t)],sep="")

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

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

if len(a) == len(b):
    for i in range(0, len(a)):
        print(a[i] + b[i], end = "")

Solution (Python):
l = input()
charl = list(input().split())
ans = ''
for i in range(len(charl[0])):
  ans += charl[0][i] + charl[1][i]
print(ans)

Solution (Python):
a=int(input())
b,c=list(input().split())
ans=[]
for i in range(a):
    ans.append(b[i])
    ans.append(c[i])
sinans="".join(ans)
print(sinans)

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

txt = ""

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

print(txt)

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

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

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

Solution (Python):
import os
import heapq
import sys,threading
import math
import bisect
import operator
from collections import defaultdict
sys.setrecursionlimit(10**5)
from io import BytesIO, IOBase
def gcd(a,b):
    if b==0:

        return a
    else:
        return gcd(b,a%b)
def power(x, p,m):
    res = 1
    while p:
        if p & 1:
            res = (res * x) % m
        x = (x * x) % m
        p >>= 1
    return res
def inar():
    return [int(k) for k in input().split()]

def lcm(num1,num2):
    return (num1*num2)//gcd(num1,num2)

def main():
    n=int(input())
    st1,st2=input().strip().split(" ")
    res=[]
    for i in range(n):
        res.append(st1[i])
        res.append(st2[i])
    print("".join(res))




BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

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):
from sys import exit
import math
import collections
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

n = ii()
s,t = 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 = ans + s[i] + t[i]
print(ans)

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):
N = int(input())
S,T = input().split()
new_list = []
for i in range(N):
    new_list.append(S[i])
    new_list.append(T[i])
print("".join(new_list))

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(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 += S[i] + 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 = (c for c in input().split())
new = []
for i in range(0, n):
    new.append(s[i])
    new.append(t[i])
print("".join(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=map(str,input().split())
ans = ""
for i in range(n):
  ans += S[i]
  ans += T[i]
print(ans)

Solution (Python):

from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]


def inside(y, x, H, W):
    return 0 <= y < H and 0 <= x < W


def ceil(a, b):
    return (a + b - 1) // b


def sum_of_arithmetic_progression(s, d, n):
    return n * (2 * s + (n - 1) * d) // 2


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


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


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

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


def main():
    solve()


if __name__ == '__main__':
    main()

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

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

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

def calc_digit_sum(num):
    digits = sums = 0
    while num > 0:
        digits += 1
        sums += num % 10
        num //= 10
    return digits, sums


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

answer = ""
for ch1, ch2 in zip(s, t):
    answer += ch1 + ch2

print(answer)

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()
ST = "".join([S[i]+T[i] for i in range(N)])
print(ST)

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


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

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

ans=str()

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

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

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

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):
n = int(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="")
print("")

Solution (Python):
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


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

    res = ""

    for a, b in zip(S, T):
        res += a
        res += b

    print(res)


if __name__ == '__main__':
    main()

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

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

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

s, t = input().split()

s = list(s)
t = list(t)
c = []

for i in range(N):
  c.append(s[i])
  c.append(t[i])

C = ''.join(c)

print(C)

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

Solution (Python):
N = int(input())
S, T = map(str,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()
print(*[s+t for s,t in zip(S,T)], sep='')

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

for i in range(len(s)):
    if(i >= 1):
        s_and_t += s[i]
    s_and_t += t[i]

print(s_and_t)

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

print(l)

Solution (Python):
import bisect,collections,copy,itertools,math,string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
def main():
    n = I()
    s,t = LS()
    ans = ""
    for x,y in zip(list(s),list(t)):
        ans += x+y
    print(ans)
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 = map(str,input().split())
for i in range(n):
  print(s[i], t[i], sep = '', end = '')
print()

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

Solution (Python):
N=int(input())
S,T=map(str,input().split())
l=[]
a,b=0,0
for i in range(N*2):
    if (i+1)%2!=0:
        l.append(S[a])
        a+=1
    else:
        l.append(T[b])
        b+=1
print(''.join(l))

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

print(s)

Solution (Python):
n = int(input())
S,T = input().split()
result = ''
for s,t in zip(S,T):
    result += s
    result += t
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):
def main():
    n = int(input())
    s, t = input().split()
    ans = ""

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

    print(ans)


if __name__ == "__main__":
    main()

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

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

print(res)

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

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

Solution (Python):


from typing import *
import collections
import functools
import itertools
import math
import sys

INF = float('inf')


def solve(N: int, S: str, T: str):
    return "".join(s+t for s, t in zip(S, T))


def main():

    sys.setrecursionlimit(10 ** 6)

    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)  
    print(f'{solve(N, S, T)}')


if __name__ == '__main__':
    main()

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

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

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

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]+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()
u = ""

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

print(u)

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

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()
print(''.join(a[i]+b[i] for i in range(n)))

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

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

R=""

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

print(R)

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

Solution (Python):
n=int(input())
li = input().split()
a=''
for i in range(n):
  a+=li[0][i]+li[1][i]
print(a)

Solution (Python):
n = int(input().rstrip())
l = input().rstrip().split()
result = ''
for i in range(n):
    result += l[0][i] + l[1][i]

print(result)

Solution (Python):

n=int(input())

str1,str2=input().split()
for i in range(len(str1)):
    print(str1[i]+str2[i],end="")

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

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()
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())
print(''.join([s[i] + t[i] for i in range(0,n)]))

Solution (Python):
from sys import stdin
import sys
import math
from functools import reduce
import functools
import itertools
from collections import deque,Counter,defaultdict
from operator import mul
import copy


import heapq
sys.setrecursionlimit(10**6)

INF = 10**18
import bisect
import statistics
mod = 10**9+7


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

Solution (Python):
def main():
    n = int(input())
    s, t = input().split(" ")
    print("".join(a+b for a, b in zip(s, t)))


main()

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

Solution (Python):
import sys, bisect, math, itertools, string, queue, copy








def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

n = inp()
s, t = map(str, input().split())
ans = ''
for i in range(n):
    ans = ''.join([ans, s[i], t[i]])
print(ans)

Solution (Python):
import sys, bisect, math, itertools, string, queue, copy
import numpy as np
import scipy
from collections import Counter,defaultdict,deque
from itertools import permutations, combinations
from heapq import heappop, heappush

sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

n = inp()
st = input().split()
s = st[0]
t = st[1]

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

print(ans)

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

result = ''
for index, s in enumerate(S):
    result += s + T[index]

print(result)

Solution (Python):
a = int(input())
b = input().split()
ans = []
for x,y in zip(b[0],b[1]):
    ans += [x,y]
print("".join(ans))

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,numpy,string
import sys
sys.setrecursionlimit(10**7)

def S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())

def main():
    N = I()
    S,T = LS()
    ans = ""
    for i in range(N):
        ans += S[i]
        ans += T[i]
    print(ans)


main()

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

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

Solution (Python):
n=int(input())
s=str(input())
a=''
for i in range(len(s)-n-1):
    a+=s[i]+s[i+n+1]
print(a)

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 = map(str, 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(n):
  ans+=s[i]+t[i]
print(ans)

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

ans=''

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

print(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(''.join(ans))

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

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

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

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

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

print("".join(res))

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 = input()
s, t = map(str, input().split())
out = [si+ti for si, ti in zip(s, t)]
print("".join(out))

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

i = ''
for j in zip(S, T):
    for k in j:
        i += k
print(i)

Solution (Python):
N = int(input())
S,T = map(str,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=input().split()
ans=[]
for i in range(n):
  ans.append(s[i])
  ans.append(t[i])
print(''.join(ans))

Solution (Python):

N = int(input())
a,b = map(str,input().split())
moji = ""
for i in range(N):
    moji += a[i]+b[i]

print(moji)

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

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(2 * N):
    if i % 2 == 0:
        ans += S[i//2]
    else:
        ans += T[i//2]
print(ans)