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):
a=list(input())
b=list(input())
c=['']*1000000
j=0
z=1
e=''
for i in range(0,len(a)):
  c[j]+=a[i]
  j+=2
for i in range(0,len(b)):
  c[z]+=b[i]
  z+=2
for i in range(len(a)+len(b)):
  e+=c[i]
print(e)

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

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()
n = 0
i = len(E)
while(n <= i):
  if(n == i and len(O) == len(E)):
    pass
  else:
    print(O[n],end = "")
  if(n == i):
    pass
  else:
    print(E[n],end = "")
  n += 1

Solution (Python):
s = input()
t = input()
ans = "".join([s[i] + t[i] for i in range(len(t))])
print(ans + s[-1]) if len(s) - len(t) == 1 else 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 = list(input())
E = list(input())+[""]
for x,y in zip(O,E):
    print(x+y,end="")

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

O = input().rstrip()
E = input().rstrip()

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

Solution (Python):

o, e = [input() for _ in range(2)]
passwd = ''.join([o[i] + e[i] for i in range(len(e))])
print(passwd if len(o) == len(e) else passwd + o[-1])

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

Solution (Python):
O = input()
E = input()
out = ""
for x in range(len(O)):
    out += O[x]
    if len(E) > x:
        out += E[x]
print(out)

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

Solution (Python):
O=input().rstrip()
E=input().rstrip()
A=[]
for i in range(len(E)):
  A.append(O[i])
  A.append(E[i])
if len(O)>len(E): A.append(O[-1])
print("".join(A))

Solution (Python):
o = [i for i in input()]
e = [i for i in 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[-1])
print(''.join(l))

Solution (Python):
odd = input()
even = input()

o_len = len(odd)
e_len = len(even)

password = []
for i in range(o_len):
            password.append(odd[i])
            if i < e_len:
                password.append(even[i])

print(''.join(password))

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

Solution (Python):
from collections import deque

o = deque(input())
e = deque(input())

if len(o) > len(e):
    e.append('')
ans = ''

while len(o):
    ans += o.popleft()
    ans += e.popleft()
print(ans)

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

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

    ans = [None] * (len(o) + len(e))
    ans[::2] = o
    ans[1::2] = e
    print(*ans, sep='')


if __name__ == '__main__':
    main()

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

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

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

ans=""

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

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

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

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


if __name__ == '__main__':
    main()

Solution (Python):
O = input()
E = input()
lo = len(O)
le = len(E)
ans = []
for a, b in zip(O, E[:min(le, lo)]):
    ans.append(a)
    ans.append(b)
if le < lo:
    ans.append(O[-1])

print("".join(ans))

Solution (Python):
O = input()
E = input()
lo = len(O)
le = len(E)
ans = []
for a, b in zip(O, E[:min(le, lo)]):
    ans.append(a)
    ans.append(b)
if le < lo:
    ans.append(O[-1])

print("".join(ans))

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

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

print(ans)

Solution (Python):
o = input()
e = input()
e += " "
ret = ""
for i,j in zip(o,e):
    ret+=i
    ret+=j
print(ret.strip())

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

Solution (Python):
from collections import deque
O = deque(input())
E = deque(input())
ans = []
for _ in range(len(O)):
    ans.append(O.popleft())
    if E:
        ans.append(E.popleft())
print("".join(ans))

Solution (Python):
def resolve():
    o = input()
    e = input()
    leno = len(o)
    lene = len(e)
    ans = ""
    for i in range(lene):
        ans += o[i]
        ans += e[i]
    if leno != lene:
        ans += o[-1]
    print(ans)
resolve()

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

def alt(s, t):
    if not s:
        return t
    elif not t:
        return s
    else:
        return s[0] + t[0] + alt(s[1:], t[1:])
      
print(alt(a, b))

Solution (Python):
ans = []
O = list(input())
E = list(input())
for i in range(min(len(O),len(E))):
    ans.append(O[i])
    ans.append(E[i])
if len(O)!=len(E):
    if len(O)>len(E):
        ans.append(O[len(O)-1])
    else:
        ans.append(E[len(E)-1])
ans1 = ''.join(ans)
print(ans1)

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

def main():
    o = list(input().rstrip())
    e = list(input().rstrip())

    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(O) + len(E)):
    if i % 2 == 0:
        ans += O[i//2]
    else:
        ans += E[i//2]
print(ans)

Solution (Python):
from itertools import zip_longest
O = input()
E = input()
ans = ""
for oi, ei in zip_longest(O, E):
    ans += oi
    if ei:
        ans += ei
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)==1:
  ans.append(o[-1])
print(''.join(ans))

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

Solution (Python):
o = list(input())
e = list(input())
l = len(o) + len(e)

n = 0
ans = ""
for i in range(l):
  if i % 2 == 0: 
    ans += o[n]
  else:
    ans += e[n]
    n += 1
print(ans)

Solution (Python):

import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1

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

Solution (Python):
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)

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

for i in range(len(o)+len(e)):
    if i % 2 == 0:
        print(o[i//2],end="")
    elif i % 2 == 1:
        print(e[(i-1)//2],end="")

Solution (Python):
o=input()
e=input()
for i in range(min(len(o),len(e))):
    print(o[i],end='')
    print(e[i],end='')
if len(o)==len(e):
    exit()
print(o[-1] if len(o)>len(e) else e[-1])

Solution (Python):
def examA():
    O = SI()
    E = SI()
    ans = ""
    for i in range(len(O)+len(E)):
        if i%2==0:
            ans += O[i//2]
        else:
            ans += E[i//2]
    print(ans)
    return

def examB():
    ans = 0
    print(ans)
    return

def examC():
    ans = 0
    print(ans)
    return

def examD():
    ans = 0
    print(ans)
    return

def examE():
    ans = 0
    print(ans)
    return

def examF():
    ans = 0
    print(ans)
    return

import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]

sys.setrecursionlimit(10**6)

if __name__ == '__main__':
    examA()

"""

"""

Solution (Python):
import sys
input = sys.stdin.readline
O = list(input())[: -1]
E = list(input())[: -1]
res = [""] * (len(O) + len(E))
for i in range(len(res)):
  if i % 2: res[i] = E[i // 2]
  else: res[i] = O[i // 2]
print("".join(res))

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

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):
o = list(input())[::-1]
e = list(input())[::-1]
s = ""
while o or e:
  if o:
    s += o.pop()
  if e:
    s += e.pop()
print(s)

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


if __name__ == '__main__':
    main()

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin, log, log10
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
def debug(*args):
    if debugmode:
        print(*args)
def input(): return sys.stdin.readline().strip()
def STR(): return input()
def INT(): return int(input())
def FLOAT(): return float(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7
dx = [0, 0, 1, -1, 1, -1, -1, 1]
dy = [1, -1, 0, 0, 1, -1, 1, -1]
debugmode = False

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

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

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

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

for i in range(0, len(O)):
    print(O[i], end='')
    if (i<len(E)):
        print(E[i], end='')

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

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

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

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

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

print(ans)

Solution (Python):
j = ''.join
print(j(map(j, zip(*open(0)))))

Solution (Python):



O = input()
E = input()


password = ""
for n in range(len(O)):
    password += O[n]
    if n < len(E):
        password += E[n]

print(password)

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)==1:
    ans.append(o[-1])
print("".join(ans))

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

leno = len(o)
lene = len(e)

s=""
if leno==lene:
  for i in range(leno):
    s += o[i]+e[i]
else:
  for i in range(lene):
    s+= o[i]+e[i]
  s+=o[-1]
print(s)

Solution (Python):
o = list(input())
e = list(input())
i = 0
while i < len(o):
    print(o[i], end='')
    if i < len(e):
        print(e[i], end='')
    i += 1

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

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

ans = []
tmp = ""
union = o+e

for i in range(len_o):
	tmp = union[i::len_o]
	ans += tmp

print("".join(ans))

Solution (Python):
ans=''
a, b = (input() for _ in range(2))

if len(b) < len(a):
    b += ' '
for i, j in zip(a, b):
    ans += i + j
print(ans)

Solution (Python):
o = list(input())
e = list(input())
if len(o) > len(e):
    l =[o[0]]
    for i in range(len(e)):
        l.append(e[i])
        l.append(o[i + 1])
else:
    l = []
    for i in range(len(e)):
        l.append(o[i])
        l.append(e[i])
print(*l, sep="")

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

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

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

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

len_pass = len(O) + len(E)
for num in range(1, len_pass + 1):
  if (num % 2 == 1):
    odd_index = num // 2
    print(O[odd_index], end="")
  elif (num % 2 == 0):
    even_index = (num // 2) - 1
    print(E[odd_index], end="")
print("")

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

Solution (Python):
O=input()
E=input()
lengthO=len(O)
lengthE=len(E)
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):

import math
import itertools
import statistics

import collections



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

Solution (Python):
o = input()
s = input()
ans = ''
if len(s) == len(o):
    for i in range(len(o)):
        ans += o[i]+s[i]
else:
    for i in range(len(s)):
        ans += o[i]+s[i]
    ans += o[-1]
print(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()

l = len(O) + len(E)
oc = 0
ec = 0
for i in range(1, l+1):
    if i % 2 == 1:
        print(O[oc], end="")
        oc += 1
    else:
        print(E[ec], end="")
        ec += 1

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]+e[i]
print(s)

Solution (Python):
s1=input()

s2=input()

ans = []

for i in range(len(s1)+len(s2)):
    if i%2==0:
        ans.append(s1[i//2])
    else:
        ans.append(s2[i//2])

print(''.join(map(str,ans)))

Solution (Python):
odd = input()
even = input()
ans = ""
num = int(len(even))

for i in range(num):
    ans += odd[i]
    ans += even[i]
if (len(odd) != len(even)):
    ans += odd[-1]  
print(ans[:])

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

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

print(output)

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(input())
e=list(input())
k=[]
for i in range(len(e)):
    k.append(o[i])
    k.append(e[i])
if len(o)!=len(e):print(''.join(k)+o[-1])
else:print(''.join(k))

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()
r = ''
for i, oc in enumerate(o):
	 r = r + oc + e[i] if len(e) > i else r + oc
print(r)

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

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

Solution (Python):
O=input()
E=input()
R=O[:len(E)]
print(*[r+e for r,e in zip(R,E)],sep="",end="")
if len(O)!=len(E):
  print(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):
    ans.append(o[-1])

print(*ans,sep="")

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

Solution (Python):


import sys
 
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
 
ni      = lambda: int(ns())
nin     = lambda y: [ni() for _ in range(y)]
na      = lambda: list(map(int, stdin.readline().split()))
nan     = lambda y: [na() for _ in range(y)]
nf      = lambda: float(ns())
nfn     = lambda y: [nf() for _ in range(y)]
nfa     = lambda: list(map(float, stdin.readline().split()))
nfan    = lambda y: [nfa() for _ in range(y)]
ns      = lambda: stdin.readline().rstrip()
nsn     = lambda y: [ns() for _ in range(y)]
ncl     = lambda y: [list(ns()) for _ in range(y)]
nas     = lambda: stdin.readline().split()

o = ns()
e = ns()

s = []
i = 0
for i, j in zip(o, e):
    s.append(i)
    s.append(j)

if len(o) > len(e):
    s.append(o[-1])
elif len(e) > len(o):
    s.append(e[-1])

print(*s, sep="")

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

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

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

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)):
    ans += o[i]
    if i < len(e):
        ans += e[i]
print(ans)

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

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

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

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

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

Solution (Python):
O = input()
E = input() + " "
for i in range(len(O)): print(O[i]+E[i],end="",sep="")

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

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

for i in range(max(len(O),len(E))+1):
  pw += O[i:i+1]+E[i:i+1]
print(pw)

Solution (Python):
o=input()
e=input()
i=0
j=0
cur=1
ans=''
while i<len(o) or j<len(e):
    if cur==1:
        ans+=o[i]
        i+=1
    else:
        ans+=e[j]
        j+=1
    cur^=1
print(ans)

Solution (Python):
O = str(input())
E = str(input())
l = []
for i in range(len(E)):
  l.append(O[i]+E[i])
  if i == len(E)-1 and len(O)>len(E):
    l.append(O[i+1])
print(''.join(l))

Solution (Python):
O = input()
E = input()
n1 = len(O)
n2 = len(E)
L =[]
if n1 > n2:
    for i in range(n2):
        L.append(O[i]+E[i])
    L.append(O[-1])
    print(''.join(L))
elif n1 == n2:
    for i in range(n1):
        L.append(O[i]+E[i])
    print(''.join(L))

Solution (Python):
S = input()
T = input()
ans = ""
if len(S)>len(T):
  for i in range(len(T)):
    ans += S[i]
    ans += T[i]
  ans += S[-1]
elif len(S)<len(T):
  for i in range(len(S)):
    ans += S[i]
    ans += T[i]
  ans += T[-1]
else:
  for i in range(len(T)):
    ans += S[i]
    ans += T[i]
print(ans)

Solution (Python):
S1 = list(input())
S2 = list(input())

ans = []

if len(S1) != len(S2):
  for s1, s2 in zip(S1[:-1], S2):
    ans.append(s1)
    ans.append(s2)
  ans.append(S1[-1])
else:
  for s1, s2 in zip(S1, S2):
    ans.append(s1)
    ans.append(s2)
    
print("".join(ans))

Solution (Python):
O = input()
E = input()
n = len(E)
m = len(O)
L = []
if m== n:
    for i in range(n):
        L.append(O[i]+E[i])
else:
    for i in range(n):
        L.append(O[i]+E[i])
    L.append(O[m-1])
ans = ''.join(L)
print(ans)

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

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

print(res)

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

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

Solution (Python):
O = list(input())
E = list(input())
ans = list()
 
for i in range(len(O)):
    ans.append(O[i])
    if len(E) > i:
        ans.append(E[i])

result = "".join(ans)
print(result)

Solution (Python):
O = list(input())
E = list(input())
ans = list()
LEN = len(O)+len(E)
for i in range(LEN):
    if i%2==0:
        ans.append(O[0])
        del O[0]
    else:
        ans.append(E[0])
        del E[0]
result = "".join(ans)
print(result)

Solution (Python):
O = list(input())
E = list(input())
ans = list()
 
for i in range(len(O)):
    ans.append(O[i])
    if i < len(E):
        ans.append(E[i])
result = "".join(ans)
print(result)

Solution (Python):
O = list(input())
E = list(input())
ans = list()
LEN = len(O)+len(E)
for i in range(LEN):
    if i%2==0:
        ans.append(O[0])
        del O[0]
    else:
        ans.append(E[0])
        del E[0]
result = "".join(ans)
print(result)

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):
a=input()
b=input()
cnt=0
passw=''
if (len(a)-len(b))==1:
  while 1:
      passw=passw+a[cnt]+b[cnt]
      cnt=cnt+1
      if (cnt+1)>len(b):
        passw=passw+a[cnt]
        break
else:
  while 1:
      passw=passw+a[cnt]+b[cnt]
      cnt=cnt+1
      if (cnt+1)>len(b):
        break
print(passw)

Solution (Python):
a=list(input())
b=list(input())
c=['']*1000000
j=0
z=1
e=''
for i in range(0,len(a)):
  c[j]+=a[i]
  j+=2
for i in range(0,len(b)):
  c[z]+=b[i]
  z+=2
for i in range(len(a)+len(b)):
  e+=c[i]
print(e)

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

Solution (Python):
s1 = list(input())
s2 = list(input())
n = len(s1)
ans = ""
for i in range(n):
  try:
  	ans += s1[i]+s2[i]
  except:
    ans += s1[i]
print(ans)

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())
n=len(o)+len(e)
for i in range(n):
    print(o[i//2] if(i%2==0) else e[i//2],end="")
print('\n')

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

for i in range(len(o) + len(e)):
    if i % 2 == 0:
        ans.append(o.pop(0))
    else:
        ans.append(e.pop(0))

print("".join(ans))

Solution (Python):
import sys
import math










mod = int(1e9+7)
INF = 1<<29
lINF = 1<<35

def main():
    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))
    return

if __name__=='__main__':
    main()

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

o = list(input().rstrip("\r\n"))
e = list(input().rstrip("\r\n")) + [""]
ans = ""
for i, j in zip(o, e):
    ans += (i+j)
print(ans)

Solution (Python):
import bisect,collections,copy,itertools,math,string
def I(): return int(input())
def S(): return input()
def LI(): return list(map(int,input().split()))
def LS(): return list(input().split())

O = S()
E = S()
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 = ""
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):
from __future__ import print_function

import sys

import re
import array
import copy
import functools
import operator

import math
import string
import fractions
from fractions import Fraction
from fractions import gcd



import collections
import itertools
import bisect

import random
import time

import heapq
from heapq import heappush
from heapq import heappop
from heapq import heappushpop
from heapq import heapify
from heapq import heapreplace
from queue import PriorityQueue as pq
from queue import Queue

from itertools import accumulate

from collections import deque
from collections import Counter

from operator import mul
from functools import reduce

input = sys.stdin.readline


def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)
    return


def lcm(n, m):
    return int(n * m / gcd(n, m))


def coprimize(p, q):
    common = fractions.gcd(p, q)
    return (p // common, q // common)


def combinations_count(n, r):
    r = min(r, n - r)
    numer = reduce(mul, range(n, n - r, -1), 1)
    denom = reduce(mul, range(1, r + 1), 1)
    return numer // denom


def main():
    S = input().strip()
    L = input().strip()
    for i in range(max(len(S), len(L))):
        if i < len(S):
            print(S[i], end="")
        if i < len(L):
            print(L[i], end="")
    print()


if __name__ == '__main__':
    main()

Solution (Python):
O=input()
E=input()
N=min(len(O),len(E))
ans=''

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

Solution (Python):


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

if __name__ == "__main__":
    main()

Solution (Python):
o=input()
e=input()
t=""
m=max(len(o),len(e))
for i in range(m):
    t+=o[i]
    if i==len(e):
        break
    t+=e[i]
print(t)

Solution (Python):
O=input("")
E=input("")
s=[]
lo=len(O)
le=len(E)
if(lo<le):
    p=lo
else:
    p=le
for i in range(p):
    s.append(O[i])
    s.append(E[i])

if(lo==le):
    print(''.join(s))
elif(lo<le):
    s.append(E[le-1])
    print(''.join(s))
else:
    s.append(O[lo-1])
    print(''.join(s))

Solution (Python):
o = input()
e = input()
n = len(o)
m = len(e)
st = [0]*(n+m)
for i in range(0,n):
  try:
    st[i*2]=o[i]
  except:
    pass
  try:
    st[i*2+1]=e[i]
  except:
    pass
string = "".join(map(str,st)) 
print(string)

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

if(len(a) > len(b)):
    for i in range(len(b)):
        print(a[i],b[i],sep="",end="")
    print(a[i+1:])
else:
    for i in range(len(a)):
        print(a[i],b[i],sep="",end="")
    print(b[i+1:])

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

Solution (Python):
o=input("")
e=input("")
s=[]
l1=len(o)
l2=len(e)
if(l1<l2):
    p=l1
else:
    p=l2
for i in range(p):
    s.append(o[i])
    s.append(e[i])

if(l1==l2):
    print(''.join(s))
elif(l1<l2):
    s.append(e[l2-1])
    print(''.join(s))
else:
    s.append(o[l1-1])
    print(''.join(s))

Solution (Python):
o=raw_input("")
e=raw_input("")
final=""
i=j=0
while(i<len(o) or j<len(e)):
    if(i<len(o)):
        final+=o[i]
        i+=1
    if(j<len(e)):
        final+=e[j]
        j+=1
print(final)

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

Solution (Python):
o=input()
e=input()
ans=''
lo = len(o)
le = len(e)

for i in range(min(lo,le)):
    ans+=o[i]
    ans+=e[i]

if lo<le:
    ans+=e[lo:]
elif le<lo:
    ans+=o[le:]

print(ans)

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

    try:
        for i in range(max(len(o), len(e))):
            print(o[i], end='')
            print(e[i], end='')
    except:
        pass


if __name__ == "__main__":
    solve()