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 = list(input())
e = list(input())
oc = 0
ec = 0

ans = ''

n = len(o)+len(e)
for i in range(1,n+1):
    if i % 2 == 0:
        add = e[ec]
        ec += 1
    else:
        add = o[oc]
        oc += 1
    ans += add

print(ans)

Solution (Python):
a = input()
b = input()
s = ""
for i in range(len(b)):
    s += a[i] + b[i]
if len(a) > len(b):
    s += a[-1]
print(s)

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

Solution (Python):
o=list(input())
e=input()
for i in range(len(e)):
    o.insert(2*i+1,e[i])
print(*o,sep="")

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

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

Solution (Python):
o = [a for a in str(input())]
e = [b for b in str(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):
s1 = input()
s2 = input()
ans = ""
for i,j in zip(s1, s2):
  ans += (i + j)
  
if len(s1) != len(s2):
  ans += s1[-1]
print(ans)

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

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

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

Solution (Python):
def answer(o: str, e: str) -> str:
    result = ''
    e += ' '
    for i in range(len(o)):
        result += o[i] + e[i]

    return result.strip()


def main():
    o = input()
    e = input()
    print(answer(o, e))


if __name__ == '__main__':
    main()

Solution (Python):
li_o = input()
li_e = input()
an = ''
for i in range(len(li_o)):
    an += li_o[i]
    if i != len(li_e):
        an += li_e[i]
    else:
        break
print(an)

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

import sys
input=sys.stdin.readline

def main():
    O = input().rstrip()
    E = input().rstrip()
    password=""
    last = ""

    if len(O) > len(E):
        last = O[-1]
    elif len(O) < len(E):
        last = E[-1]
    else:
        last=""

    for p1,p2 in zip(O,E):
        password+=p1+p2
    print(password+last)

if __name__=="__main__":
    main()

Solution (Python):
o = list(input())
e = list(input())
s = []
t = ""
if len(o+e) % 2 == 0:
    for i in range(int(len(o+e)/2)):
        s.append(o[i]+e[i])
    t = t.join(s)
else:
    for i in range(int(len(o+e)/2)):
        s.append(o[i]+e[i])
    t = t.join(s)
    t = t + o[int(len(o+e)/2)]

print(t)

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

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

ans = []

for i in range(len(a)):
    ans.append(a[i])
    if i < len(b):
        ans.append(b[i])
print(''.join(ans))

Solution (Python):


def main():
    a = list(input())
    b = list(input()) + [""]
    for i in range(len(a)):
        print(a[i], end="")
        print(b[i], end="")


if __name__ == "__main__":
    main()

Solution (Python):


def main():
    a = input()
    b = input()
    for i in range(len(a)):
        print(a[i], end="")
        if i < len(b):
            print(b[i], end="")
    print()


if __name__ == "__main__":
    main()

Solution (Python):



from math import gcd
from itertools import combinations,permutations,accumulate, product 

from collections import deque,defaultdict,Counter
import decimal
import re
import math
import bisect
import heapq














import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7


INF = float('inf')
from sys import stdin
readline = stdin.readline
def readInts():
  return list(map(int,readline().split()))
def readTuples():
    return tuple(map(int,readline().split()))
def I():
    return int(readline())
o = input()
e = input()
ans = ""
for i in range(len(o)):
    ans += o[i]
    if i >= len(e):
        pass
    else:
        ans += e[i]
print(ans)

Solution (Python):
o = list(input())
e = list(input()) + [""]
ans = "".join(o + e for o, e in zip(o, e))
print(ans)

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

Solution (Python):
o = input()
e = input()
ans = "".join([o[i]+e[i] for i in range(min(len(o), len(e)))])
if len(o)!=len(e):
    if len(o) > len(e): ans += o[-1]
    else: ans += e[-1]
print(ans)

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

res = ""
for i, j in zip(o, e):
    res += i + j
if(len(o) != len(e)): res += o[-1]
print(res)

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

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

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 = list(str(input()))
e = list(str(input()))

o.reverse()
e.reverse()

n = len(o)+len(e)

ans = []
for i in range(n):
    if i%2 == 0:
        ans.append(o.pop())
    else:
        ans.append(e.pop())
print(''.join(ans))

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

print(ans)

Solution (Python):
O = input()
E = input()
for i in range(min(len(O),len(E))):
	print(O[i],E[i],sep="",end="")
if len(O) > len(E):
	print(O[-1])

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

ans = ""
for i in range(1, len(a) + len(b) + 1):
  if i % 2 == 1:
    ans += a[i // 2]
  else:
    ans += b[i // 2 - 1]
    
print(ans)

Solution (Python):
O = input()
E = 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[-1]

print(ans)

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

pw = ''
for i in range(len(o)):
    pw += o[i]
    if i < len(e):
        pw += e[i]
print(pw)

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

Solution (Python):
s=input()
t=input()
ans=""
for i in range(max(len(s),len(t))):
  if i < len(s):
    ans += s[i]
  if i < len(t):
    ans += t[i]
print(ans)

Solution (Python):
O = str(input())
E = str(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):
o = input()
e = input()
ans = ''
if len(o) == len(e):
    time = len(o) * 2
else:
    time = len(o) * 2 - 1
for i in range(time):
    if i % 2 == 0:
        ans += o[i // 2]
    else:
        ans += e[i // 2]
print(ans)

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

Solution (Python):
o=input()
e=input()
s=[]
i=1
j=0
while True:
    if i%2==0:
        s.append(e[j])
        i+=1
        j+=1
    else:
        s.append(o[j])
        i+=1
    if i>=len(o)+len(e)+1:
        break
for i in range(len(s)):
    print(s[i],end="")

Solution (Python):
o = input()
e = input()
res = ""
n = min(len(o), len(e))
for i in range(n):
    res += o[i] + e[i]

if len(e) > len(o):
    res += e[-1]
elif len(e) < len(o):
    res += o[-1]

print(res)

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):
    print(o[len(o)-1])

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

for i in range(0, len(a) + len(b)):
    if i % 2 == 0:
        print(a.pop(0), end = "")
    else:
        print(b.pop(0), end = "")

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

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

ans = [0]*(len(O)+len(E))
for i in range(len(ans)):
    if i % 2 == 0:
        ans[i] = O[0]
        del O[0]
    else:
        ans[i] = E[0]
        del E[0]
        
print("".join(ans))

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

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

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)

o = input().strip()
e = input().strip()

ans = []
for i, v in enumerate(o):
    ans.append(v)
    if (i != len(o) - 1) or (len(o) == len(e)):
        ans.append(e[i])
print(''.join(ans))

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

len_o = len(o)
len_e = len(e)
ans = ''

if len_o == len_e:
  for i in range(len_o):
    ans += o[i]
    ans += e[i]
elif len_o > len_e:
  for i in range(len_e):
    ans += o[i]
    ans += e[i]
  for i in range(len_e, len_o):
    ans += o[i]
else:
  for i in range(len_o):
    ans += o[i]
    ans += e[i]
  for i in range(len_o, len_e):
    ans += e[i]
print(ans)

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

Solution (Python):


def read_int():
    return int(input().strip())


def read_ints():
    return list(map(int, input().strip().split(' ')))


def solve():
    O = input().strip()
    E = input().strip()
    answer = [None]*(len(O)+len(E))
    for i in range(len(O)):
        answer[2*i] = O[i]
    for i in range(len(E)):
        answer[2*i+1] = E[i]
    return ''.join(answer)


if __name__ == '__main__':
    print(solve())

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

Solution (Python):
O=input()
E=input()
ans=""
for i in range(len(E)):
  ans+=O[i]
  ans+=E[i]

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

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

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


def read():
    O = input().strip()
    E = input().strip()
    return O, E


def solve(O, E):
    ans = []
    oq = deque(O)
    eq = deque(E)
    while eq:
        ans.append(oq.popleft())
        ans.append(eq.popleft())
    if oq:
        ans.append(oq.popleft())
    return "".join(ans)


if __name__ == '__main__':
    inputs = read()
    outputs = solve(*inputs)
    if outputs is not None:
        print("%s" % str(outputs))

Solution (Python):
from itertools import zip_longest

O = input()
E = input()
ans = ''
for o, e in zip_longest(O, E, fillvalue=''):
    ans += o + e
print(ans)

Solution (Python):
a = list(input())
b = list(input())
f = False
x = []
if len(a)> len(b):
    b.append(0)
    f = True
for i in range(len(a)):
    x.append(a[i])
    x.append(b[i])
if f:
    x.pop()
print("".join(x))

Solution (Python):
a = list(input())
b = list(input())
f = False
x = []
if len(a)> len(b):
    b.append(0)
    f = True
for i in range(len(a)):
    x.append(a[i])
    x.append(b[i])
if f:
    x.pop()
print("".join(x))

Solution (Python):
def main():
    o, e = input(), 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)


if __name__ == "__main__":
    main()

Solution (Python):
def main():
    o, e = input(), input()
    len_o, len_e = len(o), len(e)
    ans = ""

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

    if len_o == len_e + 1:
        ans += o[-1]

    print(ans)


if __name__ == "__main__":
    main()

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

res = []

if len(O) - len(E) == 0:
    for i, j in zip(O, E):
        res.append(i)
        res.append(j)
else:
    E.append('')
    for i, j in zip(O, E):
        res.append(i)
        res.append(j)
    res.pop(-1)
 
pw = ''.join(res)
print(pw)

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

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

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

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

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

Solution (Python):
import sys, re
from math import ceil, floor, sqrt, pi, factorial, gcd
from copy import deepcopy
from collections import Counter, deque
from heapq import heapify, heappop, heappush
from itertools import accumulate, product, combinations, combinations_with_replacement
from bisect import bisect, bisect_left, bisect_right
from functools import reduce
from decimal import Decimal, getcontext

def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 6)
INF = float('inf')
MOD = 10 ** 9 + 7
num_list = []
str_list = []

def main():
    o = s_input()
    e = s_input()

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

    print()

if __name__ == '__main__':
    main()

Solution (Python):

def main():
    o = list(input())
    d = list(input())

    for i in range(len(o)+len(d)):
        if i % 2 == 0:
            print(o.pop(0), end='')
        else:
            print(d.pop(0), end='')

  
        
if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
from collections import deque
from itertools import count
Odd = deque(input())
Even = deque(input())
rtnList = lambda x: Odd if x & 1 else Even
ans = ''
for i in count(1,1):
    try:
        s = rtnList(i).popleft()
    except IndexError:
        print(ans)
        exit()
    ans += s

Solution (Python):
def main():
    O = input()
    E = input()
    pas = ''
    for i in range(len(E)):
        pas += O[i] + E[i]
    if len(O) > len(E):
        pas += O[-1]
    print(pas)

if __name__ == '__main__':
    main()

Solution (Python):

A=list(input())
B=list(input())
x=A[0]+B[0]
for i in range(1,len(B)):
    x=x+A[i]+B[i]
if len(A)>len(B):
    x=x+A[-1]
print(x)

Solution (Python):
from itertools import zip_longest

def solve():
    N = input()
    O = input()
    ans = ''
    for x, y in zip_longest(N, O, fillvalue=''):
        ans += x + y
    print(ans)

if __name__ == "__main__":
    solve()

Solution (Python):
a=input()
b=input()
c=len(a)
d=len(b)
x=""
if c<=d:
  for i in range(c):
    x=x+a[i]
    x=x+b[i]
  print(x)
if c>d:
  for i in range(d):
    x=x+a[i]
    x=x+b[i]
  x=x+a[len(a)-1]
  print(x)

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

p=""

for i in range(len(o)):
    p+=o[i]
    if i<len(e):
        p+=e[i]
        
print (p)

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

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

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

print(password)

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

lst = []
for oo,ee in zip(o,e):
    lst.append(oo+ee)

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

print("".join(lst))

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

Solution (Python):
import sys

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


def main():
    from itertools import zip_longest

    o = input()
    e = input()

    res = ""
    for a, b in zip_longest(o, e, fillvalue=""):
        res += a
        res += b

    print(res)


if __name__ == '__main__':
    main()

Solution (Python):
def main():
    O = list(input())
    E = list(input())
    O.reverse()
    E.reverse()
    ans = ''
    for _ in range(200):
        ans += O.pop()
        if len(E) == 0:
            break
        ans += E.pop()
        if len(O) == 0:
            break
    print(ans)

if __name__ == "__main__":
    main()

Solution (Python):
s = list(input())
t = list(input())
l = min(len(s),len(t))
if len(s)>len(t):
    x = 1
elif len(s)<len(t):
    x = 2
else:
    x = 0
for i in range(l):
    print(s[i],end = "")
    print(t[i],end = "")
if x == 1:
    print(s[-1])
elif x == 2:
    print(t[-1])

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

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

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

ans = ""
while len(O)>0:
  ans += O[:1]+E[:1]
  O = O[1:]
  E = E[1:]
print(ans)

Solution (Python):
q=str(input())
e=str(input())
a=len(q)
b=len(e)
c=""
if a==b:
  for i in range(a):
    c+=q[i]
    c+=e[i]
else:
  for i in range(b):
    c+=q[i]
    c+=e[i]
  c+=q[a-1]

print(c)

Solution (Python):
o=input()
e=input()
n=len(o)
m=len(e)
ans=[]
for i in range(m):
  ans.append(o[i])
  ans.append(e[i])
if n-m==0:
  print(*ans,sep='')
else:
  ans.append(o[n-1])
  print(*ans,sep='')

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

Solution (Python):
import sys
sys.setrecursionlimit(4100000)
import math
import itertools
INF = float('inf')
from heapq import heapify, heappop, heappush
import collections

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

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


if __name__ == '__main__':
    main()

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

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

n = len(o) + len(e)
s = ['' for _ in range(n)]
for i in range(n):
    j = i // 2
    if i % 2 == 0:
        s[i] = o[j]
    else:
        s[i] = e[j]

print(''.join(s))

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

ans = ""
judge = False
if len(o)-len(e) == 1:
    judge = True

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

print(ans)

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

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

Solution (Python):
O = list(input())
lo = len(O)
E = list(input())
le = len(E)
w = lo + le

X = ['*']*w
for i in range(le):
  X[2*i] =O[i]
  X[2*i+1] = E[i]
if lo > le:
  X[-1] = O[-1]
  
print(''.join(X))

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

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

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

combi=''

for i in range(len(O)+len(E)):
    if i%2==0:
        combi+=O[i//2]
    elif i%2!=2:
        combi+=E[i//2]
print(combi)

Solution (Python):
def actual(O, E):
    s = ''.join([f'{o}{e}' for o, e in zip(O, E)])

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

    return s

O = input()
E = input()

print(actual(O, E))

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

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

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

print(ans)

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

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

Solution (Python):
odd = list(map(str, input()))
even = list(map(str, input()))
if len(odd)==len(even):
  L=len(odd)*2
else:
  L=len(odd)+len(even)
li=[]

for i in range(1,L+1):
  if i%2==1:
    if i==1:
      li.append(odd[0])
    else:
      li.append(odd[i//2])
  else:
    li.append(even[i//2-1])
    
print(''.join(li))

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

pw = ""
if len(A) == len(B):
    for i in range(len(A)):
        pw += A[i]
        pw += B[i]
    print(pw)
    exit()

else:
    for i in range(len(B)):
        pw += A[i]
        pw += B[i]
    print(pw + A[-1])
    exit()

Solution (Python):
a,b=input(),input()+' ';print(*[i+j for i,j in zip(a,b)],sep='')

Solution (Python):
a,b=input(),input();n=[i+j for i,j in zip(a,b)]
print(*[n,n+[a[-1]]][len(a)-len(b)],sep='')

Solution (Python):
a,b=input(),input();n=[i+j for i,j in zip(a,b)]
print(*[n,n+[a[-1]]][len(a)-len(b)==1],sep='')

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

Solution (Python):
O = input()
E = input()
Ans = []

if len(O) - len(E) == 0:
  for i in range(len(O)):
  	Ans.append(O[i])
  	Ans.append(E[i])
else:
  for i in range(len(E)):
    Ans.append(O[i])
    Ans.append(E[i])
  Ans.append(O[len(O)-1])
  
print(''.join(Ans))

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

for i in range(len(o)):
    a += o[i]
    if i < len(e):
        a += e[i]

print(a)

Solution (Python):
o = list(input())
e = list(input())
result = []
for a, b in zip(o, e):
    result.append(a)
    result.append(b)
if len(o) > len(e):
    result.append(o[-1])
elif len(e) > len(o):
    result.append(e[-1])
print("".join(result))

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

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

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

Solution (Python):
O=list(input())
E=list(input())
F=[]
if len(O)==len(E):
    for i in range(len(O)):
        F=F+[O[i]]+[E[i]]
else:
    for i in range(len(O)-1):
        F=F+[O[i]]+[E[i]]
    F+=O[len(O)-1]
print(''.join(F))

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

for so,se in zip(O,E):
    s += so+se

if len(list(O)) > len(list(E)):
    s += O[-1]
elif len(list(O)) < len(list(E)):
    s += E[-1]
    
print(*s,sep="")

Solution (Python):
import math
a=input()
b=input()

n=''
for i in range(len(a)+len(b)):
    if i%2==0:
        n=n+a[i//2]
    else:
        n=n+b[math.ceil(i/2)-1]
print(n)

Solution (Python):
o = str(input())
s = str(input())
n = ""

if not len(o) == len(s):
	for i in range(min(len(o),len(s))):
		n += o[i]
		n += s[i]

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

else:
	for i in range(len(o)):
		n += o[i]
		n += s[i]
		
print(n)

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

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

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

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

passw = [""]
for i in range(len(e)):
    passw.append(o[i])
    passw.append(e[i])
    
if len(o)>len(e):
    passw.append(o[-1])
    
print(''.join(passw))

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

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):
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): 
    return list(map(int,input().split()))
def m(): 
    return map(int,input().split())
def onem(): 
    return int(input())
def s(x): 
    a = []
    if len(x) == 0:
        return []
    aa = x[0]
    su = 1
    for i in range(len(x)-1):
        if aa != x[i+1]:
            a.append([aa,su])
            aa = x[i+1]
            su = 1
        else:
            su += 1
    a.append([aa,su])
    return a
def jo(x): 
    return " ".join(map(str,x))
def max2(x): 
    return max(map(max,x))
def In(x,a): 
    k = bs.bisect_left(a,x)
    if k != len(a) and a[k] ==  x:
        return True
    else:
        return False

def pow_k(x, n):
    ans = 1
    while n:
        if n % 2:
            ans *= x
        x *= x
        n >>= 1
    return ans

"""
def nibu(x,n,r):
    ll = 0
    rr = r
    while True:
        mid = (ll+rr)//2

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

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

data = ""

for i in range(len(O) + len(E)):
    if i % 2 == 0:
        data += O[i//2]
    else:
        data += E[i//2]
print(data)

Solution (Python):
print(''.join(map(''.join, zip(input(), input() + ' '))))

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

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

Solution (Python):
O=str(input())
E=str(input())
ans=""
for i in range(len(O)):
    ans+=O[i]
    if i<len(E):
        ans+=E[i]
print(ans)

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

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

Solution (Python):

O = input()
E = input()

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

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

print(ans)

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

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

ans = ""
for i in range(len(O)+len(E)):
    if i % 2:
        ans += E[i//2]
    else:
        ans += O[i//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()
flag = True
if len(o) != len(e):
    flag = False
for i in range(len(o)):
    print(o[i], end='')
    if not flag and i == len(e):
        break
    print(e[i], end='')

Solution (Python):
o = input()
e = input()
n = []
e += ' '
for i in range(len(o)):
  n.append(o[i])
  n.append(e[i])
print(''.join(n).strip())

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

Solution (Python):

O = list(input())
E = list(input())

S = [O[i//2] if i%2 == 0 else E[i//2] for i in range(len(O)+len(E))]
    
print(''.join(S))

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

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

ans = str()

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

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

Solution (Python):
import sys
o = input ()
e = input ()
for i in range (len(e)):
  sys.stdout.write(o[i])
  sys.stdout.flush()
  sys.stdout.write(e[i])
  sys.stdout.flush()
if len(o) > len(e):
  sys.stdout.write(o[-1])
  sys.stdout.flush()

Solution (Python):
O = input()
E = input()
A = ""
for x,y in zip(O,E):
  A += x + y
if len(O) == len(E):
  print(A)
else:
  print(A + O[-1])

Solution (Python):




def resolve():
    import sys
    input = sys.stdin.readline

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

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

    print(ans)

if __name__ == "__main__":
    resolve()

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

def main():
    O = input()
    E = input()
    password = ""
    for o, e in zip(O, E):
        password += o + e
    if len(O) > len(E): password += O[-1]
    print(password)
    

if __name__ == "__main__":
    main()

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

l=""
i=0
j=0
while True:
  if i < len(s):
    l+=s[i]
    i+=1
  if j < len(t):
    l+=t[j]
    j+=1
  if len(l) == len(s)+len(t):
    break
print(l)

Solution (Python):
o = input()
e = input()
for i in range(max(len(o), len(e))):
    
    if len(o) > i:
         print(o[i], end="", sep="")
    if len(e) > i:
         print(e[i], end="", sep="")
print()

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((''.join(['{}{}'.format(a,b) for a,b in zip(o,e)])).replace(' ',''))

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