Problem:
 Score : 200 points    Problem Statement Snuke signed up for a new website which holds programming competitions.
He worried that he might forget his password, and he took notes of it.
Since directly recording his password would cause him trouble if stolen,
he took two notes: one contains the characters at the odd-numbered positions, and the other contains the characters at the even-numbered positions.  You are given two strings O and E . O contains the characters at the odd-numbered positions retaining their relative order, and E contains the characters at the even-numbered positions retaining their relative order.
Restore the original password.      Constraints  O and E consists of lowercase English letters ( a - z ).  1 \leq |O|,|E| \leq 50  |O| - |E| is either 0 or 1 .         Input Input is given from Standard Input in the following format:  O  E       Output Print the original password.        Sample Input 1 xyz
abc      Sample Output 1 xaybzc  The original password is xaybzc . Extracting the characters at the odd-numbered positions results in xyz , and extracting the characters at the even-numbered positions results in abc .       Sample Input 2 atcoderbeginnercontest
atcoderregularcontest      Sample Output 2 aattccooddeerrbreeggiunlnaerrccoonntteesstt

Solution (Python):
o = input()
e = input()
if len(e) != len(o):
  e += ' '
password = ''
for i in range(len(o)):
  password += o[i] + e[i]
print(password)

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()

def resolve():
    o=list(input())
    e=list(input())
    ans=''
    for x,y in zip(o,e):
        ans+=x+y
    if len(o)-len(e)==1:
        ans+=o[-1]
    print(ans)
resolve()

Solution (Python):
O = input()
E = input()
pw = [None] * (len(O) + len(E))
for i in range(len(O)):
    pw[2 * i] = O[i]
for j in range(len(E)):
    pw[2 * j + 1] = E[j]
print(''.join(pw))

Solution (Python):
O = input()
E = input()

for i in range(len(E)):
  print(O[i]+E[i],end='')
if len(O)!=len(E):
  print(O[-1])

Solution (Python):
s = input()
t = input()

for i in range(len(s)+len(t)):
  if i%2 == 0:
    print(s[i//2],end='')
  else:
    print(t[i//2],end='')

Solution (Python):
o = str(input())
e = str(input())
password = ""

for i in range(min(len(o), len(e))):
    password += o[i] + e[i]
if len(o) != len(e):
    password += o[-1]
print(password)

Solution (Python):
o = str(input())
e = str(input())
ans = ""

for i in range(len(o)):
    ans += (o + e)[i::len(o)]
print(ans)

Solution (Python):
o = input()
e = input()
print(*[a+b for a,b in zip(o,e)], sep='', end='')
if len(o) != len(e):
    print(o[len(o) - 1])

Solution (Python):
o = input()
e = input()
ans = []
for i in range(len(e)):
    ans.append(o[i])
    ans.append(e[i])
if len(o) == len(e):
    print(''.join(ans))
else:
    ans.append(o[-1])
    print(''.join(ans))

Solution (Python):
O=list(input())
E=list(input())
ans=""
if len(O)-len(E) > 0:
    ans+=O[0]
    O.pop(0)
    for i in range(len(O)):
        ans+=E[i]
        ans+=O[i]
else:
    for i in range(len(O)):
        ans+=O[i]
        ans+=E[i]
print(ans)

Solution (Python):
def main():
    O = input()
    E = input()

    ans = ''
    for i in range(len(O)):
        if len(O) == len(E):
            ans += O[i] + E[i]
        elif i < len(O)-1:
            ans += O[i] + E[i]
        else:
            ans += O[i]

    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
O = list(input())
E = list(input())
L = ''
for i in range(len(O+E)):
    if i%2 == 0:
        s = O.pop(0)
        L += s
    else:
        s = E.pop(0)
        L += s
print(L)

Solution (Python):
O = list(input())
E = list(input())

ans = []

for i in range(len(E)):
    ans.append(O[i])
    ans.append(E[i])

if len(O) > len(E):
    ans.append(O[-1])
print(''.join(ans))

Solution (Python):
print("".join(map(lambda t: "".join(t), zip(input(), input() + " "))).strip())

Solution (Python):
o = input()
e = input()
ans = ''
n = len(o)
a = 0
while a < n:
  ans += o[a]
  if a+1 <= len(e):
    ans += e[a]
  a += 1
print(ans)

Solution (Python):
o=str(input())
e=str(input())
s="A"
l=min(len(o),len(e))
for i in range(0,l):
  s=s+o[i]+e[i]
if len(o)<len(e):
  s=s+e[len(e)-1]
elif len(o)>len(e):
  s=s+o[len(o)-1]
s=s.lstrip("A")
print(s)

Solution (Python):
o = str(input())
e = str(input())



print(*[a + b for a, b in zip(o, e)], sep="", end="")
if len(o) != len(e):
    print(o[-1])
else:
    pass

Solution (Python):
def reconst(s, t):
  reconst = ""
  for i in range(len(s)):
    reconst += s[i]
    reconst += t[i]
  return reconst

o = input()
e = input()

if len(o) == len(e):
  print(reconst(o,e))
else:
  print(reconst(o[:-1],e) + o[-1])

Solution (Python):
O=list(input())
E=list(input())

answer_list=[]
for i in range(len(O)):
  answer_list.append(O[i])
  if i<len(E):
    answer_list.append(E[i])
    
print("".join(answer_list))

Solution (Python):
o = input()
e = input()
res = ""
if len(o)>len(e):
  for i in range(len(e)):
    res = res + o[i]
    res = res + e[i]
  res = res + o[len(o)-1]
else:
  for i in range(len(e)):
    res= res + o[i]
    res= res + e[i]
print(res)

Solution (Python):
O=input()
E=input()

ans=''
i=0
while i<len(O):
    ans+=O[i]
    if i<len(E):
        ans+=E[i]
    i+=1

print(ans)

Solution (Python):
o = input()
e = input()
ans = ""
i = 0
while i < len(o):
  ans += o[i]
  if i < len(e):
    ans += e[i]
  i += 1
print(ans)

Solution (Python):
o = input()
e = input()
if len(o)==len(e):
    for i in range(len(o)):
        print(o[i]+e[i],end="")
else:
    for i in range(len(o)-1):
        print(o[i]+e[i],end="")
    print(o[-1])

Solution (Python):
O = input()
E = input()

for o, e in zip(O, E):
    print(o, e, sep="", end="")

print(O[-1] if len(O) > len(E) else "")

Solution (Python):


odd = input()
even = input()
ans = []

for i in range(len(even)):
    ans.append(odd[i])
    ans.append(even[i])

if len(odd) != len(even):
    ans.append(odd[-1])

print(''.join(ans))

Solution (Python):
o=input()
e=input()
s=""
for i in range(len(o)+len(e)):
  if i%2==0:
    s+=o[i//2]
  else:
    s+=e[i//2]
print(s)

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, log2
from itertools import accumulate, permutations, combinations, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
import numpy as np
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
 
O = list(input())
E = list(input())

ans = []

while E != []:
	ans.append(O.pop(0))
	ans.append(E.pop(0))

if O != []:
	ans.append(O.pop(0))

print("".join(ans))

Solution (Python):
O = input()
E = input()
Olen = len(O)
Elen = len(E)
password = ''
for i in range(min(Olen, Elen)):
    password += O[i] + E[i]
if Olen != Elen:
    password += O[-1]
print(password)

Solution (Python):
O=list(input())
E=list(input())+[""]
for o,e in zip(O,E):
    print(o+e,end="")

Solution (Python):
o=list(input())
e=list(input()) + [""]
for x,y in zip(o,e):print(x+y,end="")

Solution (Python):
o=list(input())
e=list(input())+[""]
for x,y in zip(o,e):print(x+y,end="")

Solution (Python):
o = input()
e = input()
ans = ''
for i in range(len(e)):
    ans += o[i] + e[i]
if len(o) > len(e):
    ans += o[-1]
print(ans)

Solution (Python):
o = input()
e = input()
s = ""
if len(o) > len(e):

    for i in range(len(e)):
        s+=o[i]+e[i]
    s+=o[-1]
else:
    for i in range(len(e)):
        s+=o[i]+e[i]

print(s)

Solution (Python):
o = input()
e = input()
p = ''
i, j = 0, 0
for n in range(len(o) + len(e)):
    if n % 2 != 0:
        p += e[i]
        i += 1
    else:
        p += o[j]
        j += 1

print(p)

Solution (Python):
o = input()
e = input()
r = ''
for i in range(len(e)):
	r +=o[i]
	r +=e[i]
if len(o)-len(e)==1:
	r +=o[len(o)-1]
print(r)

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil
from operator import itemgetter
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def printns(x): print('\n'.join(x))
def printni(x): print('\n'.join(list(map(str,x))))
inf = 10**17
mod = 10**9 + 7


s=input().rstrip()
t=input().rstrip()
ans=""
for i in range(len(t)):
    ans+=s[i]
    ans+=t[i]
if len(s)>len(t):
    ans+=s[-1]
print(ans)

Solution (Python):
o = input()
e = input()

ans = []
for i in range(len(e)):
  ans.append(o[i])
  ans.append(e[i])
  
if len(o)>len(e):
  ans.append(o[-1])

for i in ans:
  print(i,end="")

Solution (Python):


def main():
    O = input()
    E = input()

    ans = []
    for i in range(0, len(O)):
        ans.append(O[i])
        if i < len(E):
            ans.append(E[i])
    print(''.join(ans))


main()

Solution (Python):
o = input()
e = input()
ans = ''
for i, j in zip(o, e):
    ans += i+j
if len(o)>len(e):
    ans += o[-1]
print(ans)

Solution (Python):
O=list(str(input()))
E=list(str(input()))

resuidal=[]
if len(O)!=len(E):
    resuidal.append(O[-1])
    O.pop()

    
Ans=[]
for index in range(len(O)):
    Ans.append(O[index])
    Ans.append(E[index])
    
if resuidal!=[]:
    Ans.append(resuidal[0])
    
print(("").join(Ans))

Solution (Python):
o=list(input())
e=list(input())+[""]
for x,y in zip(o,e):print(x+y,end="")

Solution (Python):
A = input()
B = input()

lans = list()
if len(A) == len(B):
    for i in range(len(A)):
        lans.extend([A[i],B[i]])

else:
    for i in range(len(A)-1):
        lans.extend([A[i],B[i]])
    lans.extend(A[-1])


lans=''.join(lans)
print(lans)

Solution (Python):
o = input()
e = input()
ans = ''
if len(o) == len(e):
    for i in range(len(o)):
        ans += o[i] + e[i]
else:
    for i in range(len(e)):
        ans += o[i] + e[i]
    ans += o[len(o) - 1]
print(ans)

Solution (Python):
o=input()
e=input()
moji=""
for i in range(0,len(o)):
  moji+=o[i]
  try:
    moji+=e[i]
  except IndexError:
    pass
print(moji)

Solution (Python):
O = input()
E = input()
for i in range(len(O)+len(E)):
    if i%2 == 0:
        print(O[int(i/2)],end='')
    else:
        print(E[int(i/2)],end='')
print("")

Solution (Python):
O=input()
E=input()
for i in range(len(O)*2-1 if len(O)!=len(E) else len(O)*2):
    if i%2==0:
        print(O[i//2],end="")
    else:
        print(E[i//2],end="")

Solution (Python):
o=input()
e=input()
a=[]
i=0
while 1:
    
    if i%2==0:
        a.append(o[i//2])
    else:
        a.append(e[i//2])
    i+=1
    if len(o)+len(e)==i:
        a="".join(a)
        print(a)
        exit()

Solution (Python):
o, e = input(), input()
ol, el = len(o), len(e)

ans = ""
for q in range(min(ol, el)):
    ans += o[q] + e[q]
if ol != el:
    ans += o[-1] if ol > el else e[-1]
print(ans)

Solution (Python):
o = input()
e = input()

s = ''

for i in range(len(o)):
    s += o[i]
    if len(e) > i:
        s += e[i]

print(s)

Solution (Python):
O = input()
E = input()
for o,e in zip(O,E):
  print(o,e,end="",sep="")
if len(O)>len(E):
    print(O[-1],end="")

Solution (Python):
O = input()
E = input()
N = len(O)+len(E)
p = ""
for i in range(N//2):
    p += O[i] + E[i]
if N % 2 ==1:
    p += O[i+1]
print(p)

Solution (Python):
o, e = input(), input()
op = ""
for i in range(len(e)): op += o[i] + e[i]
print(op if len(e) == len(o) else op+o[-1])

Solution (Python):
o = input()
e = input()
s = ''.join(map(lambda x:x[0]+x[1],zip(o,e)))
if len(e) != len(o):
  s += o[-1]
print(s)

Solution (Python):
O=input()
E=input()
for i in range(len(O)):
    if i!=len(O)-1:
        print(O[i],end="")
        print(E[i],end="")
    else:
        print(O[i],end="")
        if len(O)-len(E)==0:
            print(E[i],end="")
        else:
            continue

Solution (Python):
O = input()
E = input()
ans = ''
for i in range(len(O) + len(E)):
  if i%2==0:
    ans += O[i//2]
  else:
    ans += E[(i-1)//2]
print(ans)

Solution (Python):
o = input()
e = input()
ans = ""
for i in range(len(o)+len(e)):
    if i%2 == 0:
        ans += o[i//2]
    else:
        ans += e[i//2]
print (ans)

Solution (Python):
o = input()
e = input()
ans_l = [0] * (len(o) + len(e))
for i in range(len(o)):
    ans_l[i*2] = o[i]
for j in range(len(e)):
    ans_l[j*2+1] = e[j]
print(''.join(ans_l))

Solution (Python):
import math
o=input()
e=input()
l=[]
for i in range(len(o+e)):
    if i%2==0:
        l.append(o[i//2])
    else:
        l.append(e[math.floor(i/2)])
print("".join(l))

Solution (Python):
import sys

input = sys.stdin.readline
MOD = 1000000007

O = input()[:-1]
E = input()[:-1]


for i in range(min(len(O),len(E))):
    print(O[i],end="")
    print(E[i],end="")

if len(O) > len(E):
    print(O[-1])
if len(O) < len(E):
    print(E[-1])
else:
    print()

Solution (Python):
import sys

def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
def MII(): return list(map(int, IS().split()))
def MIIZ(): return list(map(lambda x: x-1, MII()))

def DD2(d1,d2,init=0): return [[init]*d2 for _ in range(d1)]
def DD3(d1,d2,d3,init=0): return [DD2(d2,d3,init) for _ in range(d1)]

def to_bin(x: int) -> str: return format(x, 'b') 
def to_oct(x: int) -> str: return format(x, 'o') 
def to_hex(x: int) -> str: return format(x, 'x') 
MOD=10**9+7
def divc(x,y) -> int: return -(-x//y)
def divf(x,y) -> int: return x//y
def gcd(x,y):
    while y: x,y = y,x%y
    return x
def lcm(x,y): return x*y//gcd(x,y)
def enumerate_divs(n):
    """Return a tuple list of divisor of n"""
    return [(i,n//i) for i in range(1,int(n**0.5)+1) if n%i==0]
def get_primes(MAX_NUM=10**3):
    """Return a list of prime numbers n or less"""
    is_prime = [True]*(MAX_NUM+1)
    is_prime[0] = is_prime[1] = False
    for i in range(2, int(MAX_NUM**0.5)+1):
        if not is_prime[i]: continue
        for j in range(i*2, MAX_NUM+1, i):
            is_prime[j] = False
    return [i for i in range(MAX_NUM+1) if is_prime[i]]

from itertools import accumulate as acc
from collections import deque, Counter
from heapq import heapify, heappop, heappush
from bisect import bisect_left


def main():
    o = IS()
    e = IS()
    res = ''
    for i in range(len(e)):
        res += o[i]+e[i]
    if len(o) > len(e):
        res += o[-1]
    print(res)

if __name__ == '__main__':
    main()

Solution (Python):


o=input()
e=input()

ans=""
for i in range(len(o)-1):
    ans+=o[i]+e[i]
ans+=o[-1]
if len(o)==len(e):
    ans+=e[-1]
print(ans)

Solution (Python):
a=list(input())
b=list(input())
ans=[]
for i in range(len(b)):
    ans.append(a[i])
    ans.append(b[i])
ANS=''.join(ans)
print(ANS if len(a)==len(b) else ANS+a[len(a)-1])

Solution (Python):
O = list(input())
E = list(input())

x = []
for i,j in zip(O,E):
  x.extend((i,j))

if len(O) != len(E):
  x.extend(O[-1])
  
print("".join(x))

Solution (Python):
o=list(input())
e=list(input())+[""]
for x,y in zip(o,e): print(x+y, end="")

Solution (Python):
o = input()
e = input()
s = ""
for i in range(len(o)):
    s += o[i]
    try:
        s += e[i]
    except Exception:
        pass

print(s)

Solution (Python):
O=input()
E=input()

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

if len(O)-len(E)==1:
  print(O[-1])

Solution (Python):
O = input()
E = input()
ans = ''
if len(O) > len(E):
    ans += O[0]
    O = O[1:]
    for o, e in zip(O, E):
        ans += (e + o)
else:
    for o, e in zip(O, E):
        ans += (o + e)
print(ans)

Solution (Python):
o = input()
e = input()

ans = ""
for i in range(len(o)-1):
    ans = ans + o[i] + e[i]


if (len(o) == len(e)):
    ans = ans + o[len(o)-1] + e[len(e)-1]
else:
    ans = ans + o[len(o)-1]

print(ans)

Solution (Python):
def resolve():
    O = input()
    E = input()
    length = max(len(O), len(E))
    s = ""
    for i in range(length):
        o = "" if len(O) <= i else O[i]
        e = "" if len(E) <= i else E[i]
        s += o
        s += e
    print(s)


if '__main__' == __name__:
    resolve()

Solution (Python):
o=list(input())
e=list(input()+" ")
for x,y in zip(o,e):
    print((x+y),end="")

Solution (Python):
from itertools import zip_longest

O = input()
E = input()

for i, j in zip_longest(O, E):
    print(i, end='')
    if j:
        print(j, end='')
print()

Solution (Python):
import sys

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


def resolve():
    o = list(input())
    e = list(input())

    res = [""] * (len(o) + len(e))
    for i in range(len(o) + len(e)):
        if i % 2 != 0:
            s = e.pop(0)
            res[i] = s
        else:
            s = o.pop(0)
            res[i] = s

    print("".join(res))


if __name__ == '__main__':
    resolve()

Solution (Python):
O = input()
E = input()
ans = ''
l1 = len(O)
l2 = len(E)
for i in range(l2):
    ans += O[i]
    ans += E[i]
if l1 > l2:
    ans += O[-1]
print(ans)

Solution (Python):
o=input()
e=input()
if len(o)-len(e)==1:
    e+=' '
for i in range(len(o)):
    print(o[i]+e[i],end="")

Solution (Python):
o=str(input())
e=str(input())
ans=''
if len(o)==len(e):
  for i in range(len(o)):
    ans+=o[i]
    ans+=e[i]
else:
  for i in range(len(e)):
    ans+=o[i]
    ans+=e[i]
  ans+=o[len(o)-1]
print(ans)

Solution (Python):
from collections import deque

o = deque(input())
e = deque(input())
s = ""
while (o and e):
    s += o.popleft()
    s += e.popleft()

if o:
    s += o.popleft()
print(s)

Solution (Python):
a=list(input())
b=list(input())
A=["" for i in range(len(a) + len(b))]
A[::2]=a ; A[1::2]=b
print("".join(A))

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7

def main():
    O = input()
    E = input()
    ans = ''
    L1 = len(O)
    L2 = len(E)
    for i in range(L2):
        ans += O[i] + E[i]
    if L1 != L2:
        ans += O[-1]
    print(ans)

if __name__ == '__main__':
    main()

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

o = list(input().rstrip())
e = list(input())


for i in range(len(e)):
    o.insert(i+1*(i+1), e[i])

print(''.join(o))

Solution (Python):
o = list(input())
e = list(input())
l = []
for i in range(len(e)):
  l.append(o[i])
  l.append(e[i])
if len(o)-len(e)==1:
  l.append(o[len(o)-1])
print(''.join(l))

Solution (Python):
o = input()
e = input()

O = []
for _ in o:
  O.append(_)
E = []
for _ in e:
  E.append(_)

ans = []

if len(O) == len(E):
  for i in range(len(O)):
    ans.append(O[i])
    ans.append(E[i])
elif len(O) > len(E):
  for j in range(len(E)):
    ans.append(O[j])
    ans.append(E[j])
  ans.append(O[len(O)-1])
print(*ans, sep='')

Solution (Python):
o= input()
e= input()
P = ''

if len(o)==len(e):
    for i in range(len(o)):
        P += o[i]
        P += e[i]
else:
    for i in range(len(o)-1):
        P += o[i]
        P += e[i]
    P += o[len(o)-1]
print(P)

Solution (Python):
odd = input()
even = input()
for i in range(len(even)):
    print(odd[i] + even[i], end = "")
print((odd[-1] if len(odd) - len(even) else ""))

Solution (Python):
O = input()
E = input()
if len(O) > len(E):
    for o, e in zip(O[:-1], E):
        print(o + e, end='')
    print(O[-1])
else:
    for o, e in zip(O, E):
        print(o + e, end='')

Solution (Python):
o = input()
e = input()
l = len(o)
s = o[0]
for i in range(1,l):
    s += e[i-1]+o[i]
if (l+len(e))%2==0:
    s += e[l-1]
print(s)

Solution (Python):
def resolve():
	o = input()
	e = input()
	a = ""
	for i in range(len(o)):
		if i < len(o):
			a += o[i]
		if i < len(e):
			a += e[i]
	print(a)
resolve()

Solution (Python):
o = input()
e = input()
for i in range(len(e)):
    print(o[i] + e[i], end = "")
if len(e) < len(o):
    print(o[i + 1])
else:
    print()

Solution (Python):
O = input()
E = input()
X = ""
for i in range(len(E)):
    X += (O[i]+E[i])
if len(O) != len(E):
    X += O[-1]

print(X)

Solution (Python):

o = input()
e = input()
ans = ""

for i, j in zip(o, e):
    ans += i + j

if len(o) != len(e):
    ans += o[-1]

print(ans)

Solution (Python):
s = input()
t = input()
ans = ""

for i in range(min(len(s),len(t))):
  ans = ans + s[i] + t[i]

if len(s) > i+1:
  ans = ans + s[i+1:]
elif len(t) > i+1:
  ans = ans + t[i+1:]

print(ans)

Solution (Python):
o=input()
e=input()
lo, le=len(o), len(e)
s=''
for i in range(le):
  s=s+o[i]+e[i]
if lo>le:
  s+=o[-1]
print(s)

Solution (Python):
o = list(input())
e = list(input()) + ['']

for x,y in zip(o, e):
    print(x+y, end='')

Solution (Python):
O=input()
E=input()

for i in range(len(E)):
    print(O[i]+E[i], end='')
if(len(O) != len(E)):
    print(O[-1])

Solution (Python):
O = input()
E = input()
ans = ""

for i in range(1, len(O) + len(E)+1):
    if i%2 == 1:
        ans += O[i//2]
    else:
        ans += E[i//2 - 1]

print(ans)

Solution (Python):
O = list(input())
E = list(input())
ans =[]

if len(O)>len(E):
  for i in range(len(E)):
    ans.append(O[i])
    ans.append(E[i])
  ans.append(O[-1])
  print("".join(ans))
else:
  for i in range(len(E)):
    ans.append(O[i])
    ans.append(E[i])
  print("".join(ans))

Solution (Python):
o = input()
e = input()

ans_li = ['
for i,s in enumerate(o):
    ans_li[i*2]=s
for i,s in enumerate(e):
    ans_li[i*2+1]=s
print(''.join(ans_li))

Solution (Python):
o = input()
e = input()
no = len(o)
ne = len(e)
ans = ""
for i in range(no+ne):
    index = i//2
    if i%2 == 0:
        ans += o[index]
    else:
        ans += e[index]
print(ans)

Solution (Python):
o = input()
e = input()
ans = ""
for a,b in zip(o,e):
    ans += a + b

if len(o)-len(e) == 1:
    print(ans+o[-1])
else:
    print(ans)

Solution (Python):
O = input()
E = input()
ans = ''
for i in range(len(E)):
    ans += O[i] + E[i]
if len(O) != len(E):
    ans += O[-1]
print(ans)

Solution (Python):
O = input()
E = input()
print(*[o + e for o, e in zip(O, E)], sep="", end="")
if len(O) != len(E):
    print(O[-1])

Solution (Python):
O=str(input())
E=str(input())
S=""
if len(O)==len(E):
  for i in range(len(O)):
    S=S+O[i]+E[i]
else:
  for i in range(len(O)-1):
    S=S+O[i]+E[i]
  S=S+O[len(O)-1]
print(S)

Solution (Python):
from itertools import zip_longest

O,E = open(0).read().split()

for i,j in zip_longest(O,E,fillvalue=""):
  print(i+j,end="")

Solution (Python):
def main():
    Odd = input()
    Even = input()
    ans = ''
    for i in range(len(Odd) + len(Even)):
        if (i + 1) % 2 == 1:
            ans += Odd[i // 2]
        else:
            ans += Even[i // 2]
    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
o=input()
e=input()
ans=[]
cnt=0

for i in range(2*len(e)):
    if  i%2==0:
        ans.append(o[i//2])
    else:
        ans.append(e[i//2])

if len(o)!=len(e):
    ans.append(o[-1])

print(*ans, sep='')

Solution (Python):
o = input()
e = input()

res = []
for i in range(min(len(o),len(e))):
    res.append(o[i])
    res.append(e[i])
if len(o)>len(e):
    res.append(o[-1])

print("".join(res))

Solution (Python):
O = input()
E = input()

for i in range(max(len(O), len(E))):
    try:
        print(O[i], end='')
    except IndexError:
        pass
    try:
        print(E[i], end='')
    except IndexError:
        pass

print()

Solution (Python):
o = input()
e = input()
ans = ''
for i in range(len(o) + len(e)):
    if i % 2 == 0:
        ans += o[i // 2]
    else:
        ans += e[(i - 1) // 2]
print(ans)

Solution (Python):


from collections import deque,Counter













O = input()
E = input()

Oq = deque(O)
Eq = deque(E)
ans = []
for i in range(len(O)):
    ans.append(Oq.popleft())
    if len(Eq)>0:
        ans.append(Eq.popleft())

print(*ans,sep="")

Solution (Python):
O=input()
E=input()
pas=['A']*(len(O)+len(E))
for i in range(0,len(O)+len(E)):
    if i%2==0:
        pas[i]=O[int(i/2)]
    else:
        pas[i]=E[int((i-1)/2)]
print(''.join(pas))

Solution (Python):
o=list(input())
e=list(input())
ans=["e" for _ in range(len(o)+len(e))]
for i in range(len(o)+len(e)):
    if i%2==0:
        ans[i]=o[i//2]
    else:
        ans[i]=e[i//2]
print("".join(ans))

Solution (Python):
O=input()
E=input()

ans=''
for i in range(len(O)-1):
  ans += O[i]+E[i]
ans+=O[len(O)-1]
if len(O)==len(E):
  ans+=E[len(E)-1]
print(ans)

Solution (Python):
o = input()
e = input()
ans = ""
if len(o)-len(e) == 1:
    e += "."
    for o_, e_ in zip(o,e):
        ans += o_ + e_
    print(ans[:-1])
else:
    
    for o_,e_ in zip(o,e):
        ans += o_ + e_
    print(ans)

Solution (Python):
O = str(input())
E = str(input())
l = []

for i in range(len(O)):
	l.append(O[i])
	try:
		l.append(E[i])
	except:
		pass
print(''.join(l))

Solution (Python):
o=input()
e=input()

a=""

if len(o)!=len(e):
    e+=" "
    for i in range(len(o)):
        a+=o[i]+e[i]
    print(a[:-1])
else:
    for i in range(len(o)):
        a+=o[i]+e[i]
    print(a)

Solution (Python):
o = input()
e = input()

ans = ''

if len(o) == len(e):
    for i in range(len(o)):
        ans += o[i] + e[i]
else:
    for i in range(len(o) - 1):
        ans += o[i] + e[i]
    ans += o[-1]

print(ans)

Solution (Python):
O = input()
E = input()
P = ""
if len(O) - len(E) == 0:
    for i in range(len(E)):
        P = P + O[i] + E[i]
else:
    for i in range(len(E)):
        P = P + O[i] + E[i]
    P = P + O[-1]
print(P)

Solution (Python):
o = list(input())
e = list(input())

s = [o[i] + e[i] for i in range(len(e))]

if len(o) != len(e):
  s.append(o[-1])
print("".join(s))

Solution (Python):
O = list(input())
E = list(input()) + [""]
for x, y in zip(O, E): print(x + y, end="")

Solution (Python):
if __name__ == '__main__':
    a = input()
    b = input()
    ans =""
    for i in range(len(a)):
        ans += a[i]
        if  i<len(b):
            ans +=b[i]
    print(ans)

Solution (Python):
o = input()
e = input()
s = [0]*(len(o)+len(e))
s[::2] = o
s[1::2] = e
print(''.join(s))

Solution (Python):
o = str(input())
e = str(input())
length = min(len(o), len(e))
ans = ""
for i in range(length):
  ans = ans + o[i] + e[i]
if len(o) > len(e):
  ans += o[length]
elif len(e) > len(o):
  ans += e[length]
print(ans)

Solution (Python):
n = list(input())
o = list(input())

ans = str()

for i in range(len(o)):
    ans += n[i]
    ans += o[i]

if len(n) > len(o):
    ans += n[-1]

print(ans)

Solution (Python):
o = input()
e = input()
oi = 0
ei = 0
s = ""
for i in range(len(o)+len(e)):
    if i%2==0:
        s += o[oi]
        oi += 1
    else:
        s += e[ei]
        ei += 1
print(s)

Solution (Python):
O=input()
E=input()
p=""
if len(O)==len(E):
    for i in range(len(O)):
        p+=O[i]
        p+=E[i]
elif len(O)>len(E):
    for i in range(len(O)-1):
        p+=O[i]
        p+=E[i]
    p+=O[-1]
print(p)

Solution (Python):
O = list(input())
E = list(input())
ans = []

for i in range(len(E)):
    ans += O[i]
    ans += E[i]

if len(E) != len(O):
    ans += O[-1]
    
print (''.join(ans))

Solution (Python):
o=list(input())
e=list(input())
p=[]
l=len(o)
while len(o)+len(e):
    p.append(o.pop(0))
    if len(e):
        p.append(e.pop(0))
print("".join(p))

Solution (Python):
o = list(input())
e = list(input())
i = 0
ans = ""
while i < len(e):
  ans += o[i]+e[i]
  i += 1
if len(o) > len(e):
  ans += o[len(o)-1]
print(ans)

Solution (Python):
o = list(input())
e = list(input())
i = 0
ans = ""
while i < len(e):
  ans += o[i]+e[i]
  i += 1
if len(o) > len(e):
  ans += o[len(o)-1]
print(ans)

Solution (Python):
o=input()
e=input()
i=0
ans=""
while i<len(e):
  ans+=o[i]+e[i]
  i+=1
if len(o)>len(e):
  ans+=o[len(o)-1]
print(ans)

Solution (Python):
icase=0
if icase==0:
    o=list(input())
    e=list(input())
    s=""
    for i in range(len(o)):
        s=s+o[i]
        if i<len(e):
            s=s+e[i]
    print(s)

Solution (Python):
o = list(input())
e = list(input()) + [" "]
for x, y in zip(o, e): print(x + y, end="")

Solution (Python):
def myAnswer(O:list,E:list) -> str:
   ans = ""
   for n in range(len(E)):
      ans+=O.pop(0)+E.pop(0)
   return ans if(O == []) else ans+O.pop(0)

def modelAnswer():
   tmp=1
def main():
   O = list(input())
   E = list(input())
   print(myAnswer(O,E))

if __name__ == '__main__':
   main()

Solution (Python):
n = list(input())
m = list(input())+[""]
for x,y in zip(n,m):print(x+y,end="")

Solution (Python):
o = input()
e = input()
if len(o) > len(e):
    e += ' '
for s, t in zip(o, e):
    print(s + t, end='')
print()

Solution (Python):
o=input()
e=input()
ans=""
for i in range(len(o)+len(e)):
  if (i%2==0):
    ans=ans+o[i//2]
  else:
    ans=ans+e[i//2]
  
print(ans)

Solution (Python):
O = input()
E = input()
password = ''
for i in range(len(O + E)):
    if i % 2 == 0:
        password += O[i // 2]
    else:
        password += E[i // 2]
print(password)

Solution (Python):
o = input()
e = input()

for i in range(len(e)):
    print(o[i] + e[i], end='')

if len(e) != len(o):
    print(o[-1], end='')
print()

Solution (Python):
a = list(input())
b = list(input())

ans = []
for i in range(len(a)-1):
  ans.append(a[i])
  ans.append(b[i])
  
if len(a) > len(b):
  ans.append(a[-1])
else:
  ans.append(a[-1])
  ans.append(b[-1])
  
print(''.join(ans))

Solution (Python):
o = input()
e = input()
ans = ''
for i in range(len(o)):
  ans += o[i]
  if i<len(e):
    ans += e[i]
print(ans)

Solution (Python):
O = input()
E = input()

ans = ''
for o, e in zip(O, E):
    ans += o + e

if len(O) - len(E) != 0:
    ans += O[-1]

print(ans)

Solution (Python):
import collections
import sys
import numpy as np
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
MOD = 10**9+7
import itertools
import math

o = input()
e = input()
ans = ""
for i in range(len(e)):
    ans += o[i] + e[i]
if len(o)>len(e):
    ans += o[-1]
print(ans)

Solution (Python):
O = input()
E = input()

ans = ''

if len(O) == len(E):
    for o, e in zip(O, E):
        ans += o+e
else:
    for o, e in zip(O[:-1], E):
        ans += o+e
    ans += O[-1]

print(ans)

Solution (Python):
O = list(input())
E = list(input())+[""]
for x,y in zip(O,E):
    print(x+y,end="")

Solution (Python):
o = input()
e = input()

for i in range(len(o)+len(e)):
    if i % 2 == 0:
        print(o[i//2], end='')
    else:
        print(e[i//2], end='')

Solution (Python):
O = input()
E = input()
P = ""
if len(O) == len(E):
    for i in range(len(O)):
        P += O[i]+E[i]
    print(P)
else :
    for i in range(len(E)):
        P += O[i]+E[i]
    P += O[i+1]
    print(P)

Solution (Python):

o = list(input())
e = list(input())
ans = []
flg = False
if len(o) != len(e):
    e.append(0)
    flg = True

for i in range(len(o)):
    ans.append(o[i])
    ans.append(e[i])
if flg:
    del ans[-1]
    print("".join(ans))
else:
    print("".join(ans))

Solution (Python):
def main():
    O = input()
    E = input()
    p = ""
    i = 0
    j = 0
    for k in range(len(O) + len(E)):
        if (k + 1)%2 == 0:
            p += E[j]
            j += 1
        else:
            p += O[i]
            i += 1
    print(p)
main()

Solution (Python):
O = input()
E = input()

ans = ''
for o, e in zip(O, E):
    ans += o + e

if len(O) != len(E):
    ans += O[-1]

print(ans)

Solution (Python):
n1=input().rstrip()

n2=input().rstrip()

j=0
for i in range(len(n1)):
  print(n1[j],end="")
  if j<len(n2):
  	print(n2[j],end="")
  j+=1
print("")