TnT/Multi_CodeNet4Repair huggingface dataset:
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
n = int(input())
s, t = map(input().split())
ans = ""
for i, j in zip(s,t):
  ans += i
  ans += j
print(ans)

n = int(input())
s, t = map(str, input().split())
ans = ""
for i, j in zip(s,t):
  ans += i
  ans += j
print(ans)

Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
num = input()
moji_list = input().split()
new_moji = ""
for i in range(num):
	new_moji = moji_list[0][i]+moji_list[1][i]
print(new_moji)

num = input()
moji_list = input().split()
new_moji = ""
for i in range(int(num)):
	new_moji += moji_list[0][i]+moji_list[1][i]
print(new_moji)

Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
n = int(input())
k = input().split()
print(k)
c = ""
for i in list(range(n)):
  c += k[0][i]
  c += k[1][i]
  
print(c)

n = int(input())
k = input().split()
c = ""
for i in list(range(n)):
  c += k[0][i]
  c += k[1][i]
  
print(c)

Verdicts: Wrong Answer

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
N = int(input())
S, T = input().split()
ST = []
for i in range(N):
    ST.append(S[i])
    ST.append(T[i])
print(''.join(ST)

N = int(input())
S, T = input().split()
mix = []
for i in range(N):
    mix.append(S[i])
    mix.append(T[i])
print(*mix, sep='')

Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
n = int(input())
s = input()
t = input()
l = ""
for i in range(n):
    l += s[i]
    l += t[i]

print(l)


s = input()
t = input()
l = ""
for i in range(len(s)):
    l += s[i]
    l += t[i]

print(l)


n = int(input())
s = input().split()
l = ""
for i in range(n):
    l += s[0][i]
    l += s[1][i]

print(l)


Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
n = int(input())
s, t = input().split()

ss, tt=list(s), list(t)
print(ss, tt)

o = str()
for i in range(len(ss)):
    o += ss[i] + tt[i]
    
print(o)


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

ss, tt=list(s), list(t)

o = str()
for i in range(len(ss)):
    o += ss[i] + tt[i]
    
print(o)


Verdicts: Wrong Answer

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
n = int(input())
s,t = input().split()
p = []
for i in range(n):
  p.append(s[i])
  p.append(t[i])

print(p)

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

p = []
p.append(s[0]+t[0])

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

print(p[0])

Verdicts: Wrong Answer

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
N = int(input())
S,T = map(input().split())

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

print(res)

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

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

print(res)


Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
N = int(input())
ST = input()
S = ""
for i in range(N):
  S += ST[i]
  S += ST[N+i]
print(S)

N = int(input())
ST = input()
S = ""
for i in range(N):
  S += ST[i]
  S += ST[N+i+1]
print(S)

Verdicts: Wrong Answer

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
a,b = input().split()
ans = ''
for i, s in enumerate(a):
  ans+=s
  ans+=b[i]
print(ans)

_ = input()
a,b = input().split()
ans = ''
for i, s in enumerate(a):
  ans+=s
  ans+=b[i]
print(ans)

Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
n=int(input())
s,t=input().split()
ans = ''
for i in range(n):
  if n % 2 == 0:
    ans += s[i]
  else:
    ans += t[i]
print(ans)

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

Verdicts: Wrong Answer

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
N = int(input())
Str_input = str(input())
S = Str_input.split()[0]
T = Str_input.split()[1]
ans = ''
for i in range(N):
    ans = ans + S[i:i+1] + T[i:i+1]
ans

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

N = int(input())
Str_input = str(input())
S = Str_input.split()[0]
T = Str_input.split()[1]
ans = ''
for i in range(N):
    ans = ans + S[i:i+1] + T[i:i+1]
print(ans)

Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
#b strings with the same length
n=int(input())
sentence=input().split()
ans=sentence[0]+sentence[1]
print(ans)

#b strings with the same length
n=int(input())
sentence=input().split()
ans=sentence[0]+sentence[1]
print(ans)

#b strings with the same length
n=int(input())
sentence=input().split()
ans=""
for i in range(n):
    ans+=sentence[i]
print(ans)

#b strings with the same length
n=int(input())
sentence=input().split()
ans=""
for i in range(n):
    ans=ans+sentence[0][i]+sentence[1][i]
print(ans)

Verdicts: Wrong Answer

Wrong Answer

Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
length = int(input())
str1, str2 = input().split(" ")

result = ""
for i in range(len(str1)):
  result += str1[i]
  result += str2[i]
 
return result

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

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

print(result)

Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
N = int(input())
S, T = input().split()
A = ''
for a in range(N):
  A.append(S[a]+T[a])
print(A)



N = int(input())
S, T = input().split()
A = ''
for a in range(N):
  A += S[a]+T[a]
print(A)
 

Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
n=int(input())
s=input()
t=input()
word = 0
for i in range(n):
  word += s[i]
  for j in range(n):
    word += t[j]
 
print(word)
  

n=int(input())
s=input()
t=input()
word = 0
for i in range(n):
  for j in range(n):
    word += i + j

print(word)
  

n=int(input())
s=input()
t=input()
word = 0
for i in range(n):
  word += s[n]
  for j in range(n):
    word += t[n]

print(word)
  


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

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


n=int(input())
s=input()
t=input()
word = 0
for i in range(n):
  word += s[i] + t[i]
 
print(word)

zn=int(input())
s,t=input(),split()
word=""
for i in range(n):
  word+=s[i]+t[i]
 
print(word)

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

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

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


n=int(input())
s,t=map(int,input(),split())
word=""
for i in range(n):
  word+=s[i]+t[i]

print(word)

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

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

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


Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
n = int(input())
s1, s2 = list(map(str, input().split()))
print(s1 + s2)



n = int(input())
s1, s2 = list(map(str, input().split()))
for i in range(n):
    print(s1[i] + s2[i], end="")
print()

Verdicts: Wrong Answer

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
n = int(input())

a = input()
b = input()

res = ""
for i in range(n):
  res += a[i]
  res += b[i]
print(res)

n = int(input())

a = input().split()

res = ""
for i in range(n):
  res += a[0][i]
  res += a[1][i]
print(res)

Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
N = input()
S, T = input().split()
A = String()
for s, t in zip(S, T):
  A += s
  A += t
print(A)

N = input()
S, T = input().split()
A = ""
for s, t in zip(S, T):
    A += s
    A += t

N = input()
S, T = input().split()
A = ""
for s, t in zip(S, T):
    A += s
    A += t
print(A)

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
N=int(input())
S,T=input().split()
ans=S[0]+T[0]
for i in range(1,N):
    ans=ans+s[i]+T[i]
print(ans)

N=int(input())
S,T=input().split()
ans=S[0]+T[0]
for i in range(1,N):
    ans=ans+S[i]+T[i]
print(ans)

Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
N=int(input())
S,T=input().split()
ans=""
print(N)
for i in range(N):
  ans+=S[i]
  ans+=T[i]
print(ans)


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


Verdicts: Wrong Answer

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
def s_gen():
    for x in S: 
        yield x
def t_gen():
    for x in T:
        yield x
        

N=int(input())
S=input()[:N]
T=input()[:N]
it=s_gen()
it2=t_gen()

print("".join([next(it)+next(it2) for _ in range(N)]))

def s_gen():
    for x in S: 
        yield x
def t_gen():
    for x in T:
        yield x
        

N=int(input())
S,T=input().split()
print(S,T,N)
S,T=S[:N],T[:N]

print(N,S,T)

it=s_gen()
it2=t_gen()

print("".join([next(it)+next(it2) for _ in range(N)]))

def s_gen():
    for x in S: 
        yield x
def t_gen():
    for x in T:
        yield x
        

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

it=s_gen()
it2=t_gen()

print("".join([next(it)+next(it2) for _ in range(N)]))

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
n=int(input())
s,t=map(int,input().split())
j=0
k=0
r=[0 for i in range(2*n)]
for i in range(0,2*n,2):
  r[i]=s[j]
  j+=1
  
for i in range(1,2*n+1,2):
  r[i]=t[k]
  k+=1
  
print("".join(r))

n=int(input())
s,t=map(str,input().split())
j=0
k=0
r=[0 for i in range(2*n)]
for i in range(0,2*n,2):
  r[i]=s[j]
  j+=1
  
for i in range(1,2*n+1,2):
  r[i]=t[k]
  k+=1
  
print("".join(r))

Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
n = int(input())
s, t = map(int, input().split())

result = ''
for idx in range(n):
  result += s[idx] + t[idx]

  print(result)

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

result = ''
for idx in range(n):
  result += s[idx] + t[idx]

print(result)

Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
# -*- coding:utf-8 -*-
N=int(input())
S,T=map(str,input().split())
for i in range(N):
    ans=ans+S[i]+T[i]
print(ans)

# -*- coding:utf-8 -*-
N=int(input())
S,T=map(str,input().split())
ans=""
for i in range(N):
    ans=ans+S[i]+T[i]
print(ans)

Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
n = int(input())
s, t = input().split()

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

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

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

Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
a=int(input())
s=input()
d=input()
z=""
for i in range(a):
  z+=s[i]
  z+=d[i]
print(z)


a=int(input())
s,d=input().split()
z=""
for i in range(a):
  z+=s[i]
  z+=d[i]
print(z)


Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
N = int(input())
S,T = input().split()

print(S)
print(T)

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

print(s)

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

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

print(s)

Verdicts: Wrong Answer

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):

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

print(moji)


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

print(moji)

Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
N = int(input())
S,T = input().split()
q = None
for u in S :
  for d in T:
    q += u
    q += d
    break
print(q)    

N = int(input())
S,T = input().split()
q = ''
for u in S :
  for d in T:
    q += u
    q += d
    T = T.replace(T[0],'')
    break
print(q)

N = int(input())
S,T = input().split()
S = list(S)
T = list(T)
q = ''
for u in S :
  for d in T:
    q += u
    q += d
    T.remove(T[0])
    break
print(q)

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
input()
print(''.join([s+t for s,t in zip(input(),input())]))

N=int(input())
S=input()
print(''.join([S[i]+S[i+N+1] for i in range(N)]))

Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
N=int(input())
S,T=input().split()
result=''
for i in range N:
  result=S[i]+T[i]
print(result)

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


Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
n = int(input())
l, r = input().split()

print(l)

s = ''
for i in range(len(r)):
  s += l[i]
  s += r[i]
  
print(s)

n = int(input())
l, r = input().split()

s = ''
for i in range(len(r)):
  s += l[i]
  s += r[i]
  
print(s)

Verdicts: Wrong Answer

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
N = int(input())
S = str(input())
T = str(input())
ans = ""

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

N = int(input())
S = input()
T = input()
ans = ""

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

N = int(input())
S = input()
T = input()
ans = ""

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

N = int(input())
S = input()
T = input()
ans = ""

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

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

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
n= int(input())
s= list(input())
t= list(input())

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

print(ans)

n= int(input())
s= list(input())
t= list(input())

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

print(ans)

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

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

print(ans)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
N = int(input())
S, T = list(input().split())

for i in range(1,N-1):
    S.insert(i+2,T[i])

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

N = int(input())
S, T = list(input().split())
S = list(S)
T = list(T)
j = 0
for i in range(0,N+N,2):
    S.insert(i+1,T[j])
    j +=1
print("".join(S))

Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
n=int(input())
a=str(input())
b=str(input())

a=a[:n]
b=b[:n]
x=0
for i in a:
	print(a[x],b[x],end='')
	x+=1
print()

n=int(input())

a,b=input().split()
n=0
for i in a:
	print(a[n],end='')
	print(b[n],end='')
	n+=1
print()

Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
N = int(input())
S,T = input().split()
S = list(S)
T = list(T)
ans = []
for s,t in S,T:
  ans.append(s)
  ans.append(t)
print(''.join(ans))

N = int(input())
S,T = input().split()
S = list(S)
T = list(T)
ans = []
for s,t in zip(S,T):
  ans.append(s)
  ans.append(t)
print(''.join(ans))


Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
import sys
n = int(sys.stdin.readline())
s, t = map(str, sys.stdin.readline())
text = ''
for i in s:
  for k in t:
    text += i
    text += k
print(text)

import sys
n = int(sys.stdin.readline())
s, t = map(str, sys.stdin.readline().split())
i = 0
text = ''
while i < n:
  text += s[i] + t[i]
  i += 1
print(text)


Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
NNN = input()

S = str(input())
T = str(input())

S_list =list(S)
T_list =list(T)

N = len(S_list)
outstr = []

for n in range(N*2):
    if n%2 == 0:
        outstr.append(S_list[int(n / 2)])
    else:
        outstr.append(T_list[int(n / 2)])

STR = ','.join(outstr)
STR2 = STR.replace(",", "")
print(STR2)



NNN = input()

S,T = map(str, input().split())

S_list =list(S)
T_list =list(T)

N = len(S_list)
outstr = []

for n in range(N*2):
    if n%2 == 0:
        outstr.append(S_list[int(n / 2)])
    else:
        outstr.append(T_list[int(n / 2)])

STR = ','.join(outstr)
STR2 = STR.replace(",", "")
print(STR2)


Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
n=int(input())
a,b=input().split()
r=''
for i in range(N):
  r=r+a[i]
  r=r+b[i]
print(r)

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

Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
n=int(input())
s,t=input().split()
li=[]
for i in range(n):
  li.append(s[i])
  li.append(t[i])

li=",".join(li)
print(li)


n=int(input())
s,t=input().split()
li=[]
for i in range(n):
  li.append(s[i])
  li.append(t[i])
print(li)

n=int(input())
s,t=input().split()
li=[]
for i in range(n):
  li.append(s[i])
  li.append(t[i])

li="".join(li)
print(li)


Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
n = input()
s, t = input().split()

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

print(w)

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

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

print(w)

n = int(input())
s, t = input().split()
print(*[i + j for i, j in zip(s, t)], sep='')


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
N = int(input())
S,T = input().split

l = []
for i in range(N):
  l.append(S[i])
  l.append(T[i])
  
print("".join(l))

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

l = []
for i in range(N):
  l.append(S[i])
  l.append(T[i])
  
print("".join(l))

Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
s = int(input())
str1, str2 = [s for s in input().split()]
print(str1)
print(str2)
ans=[]
for i in range(s):
  ans += str1[i]
  ans += str2[i]

  
print(''.join(ans))

s = int(input())
str1, str2 = [s for s in input().split()]

ans=[]
for i in range(4):
  ans += str1[i]
  ans += str2[i]

  
print(''.join(ans))

s = int(input())
str1, str2 = [s for s in input().split()]
print(str1)
print(str2)
ans=[]
for i in range(s-1):
  ans += str1[i]
  ans += str2[i]

  
print(''.join(ans))

s = int(input())
str1, str2 = [s for s in input().split()]


ans=[]
for i in range(s):
  ans += str1[i]
  ans += str2[i]

  
print(''.join(ans))

Verdicts: Wrong Answer

Runtime Error

Wrong Answer

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
n = int(input())
a,b = input().split()
for i in range(n):
    str += a[i]+b[i]
print(str)

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

Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
N = int(input())

S = input()
T = input()

#print(S)
#print(len(S))
#print(len(T))

moji = ""

if(len(S) == len(T) == N):
  for i in range(0, N):
    str = (S + T)[i::N]
    moji += str
print(moji)

N = int(input())

S = input()
T = input()

if(len(S) == len(T) == N):
  print("OK")

N = int(input())

S, T = map(str, input().split())

#print(S)
#print(len(S))
#print(len(T))

moji = ""

if(len(S) == len(T) == N):
  for i in range(0, N):
    str = (S + T)[i::N]
    moji += str
print(moji)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
n = int(input())
s,t = input().split(" ")
print(s,t)
ans = []
for i in range(n):
    ans.append(s[i]+t[i])

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



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

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


Verdicts: Wrong Answer

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
n = int(input())
S = list(input())
T = list(input())

ans=""

for i in range(n)
	ans+=S[i]+T[i]

print(ans)


n = int(input())
S, T = map(str, input().split())
ans=''

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

Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
5
aaaaa aaaaa

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

Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
N= int(input())
S = input()
T = input()
ans = ""
for i in range(N):
  ans = ans+S[i]+T[i]
print(ans)

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

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


Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
n = int(input())
s = input().split(" ")
a = ""
for i in s:
    a = a + i
print(a)


n = int(input())
s = [input() for i in range(2)]
a = ""
for i in s:
    a = a + i
print(a)

n = int(input())
s = input().split(" ")
b = list(s[0])
c = list(s[1])
a = ""
for i in range(n):
    a = a + b[i] + c[i]
print(a)

Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
N=int(input())
S=input().split()
L=[]
print(S[0][0])
for i in range(N):
    for j in range(2):
        L.append(S[j][i])
print(*L,sep="")

N=int(input())
S=input().split()
L=[]
for i in range(N):
    for j in range(2):
        L.append(S[j][i])
print(*L,sep="")

Verdicts: Wrong Answer

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
N = int(input())
Ar =list(map(str,input().split))

S = list(Ar[0])
T = list(Ar[1])

Ans_Ar = []

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

result = ''.join(Ans_Ar)
print(result)

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

S = list(Ar[0])
T = list(Ar[1])

Ans_Ar = []

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

result = ''.join(Ans_Ar)
print(result)

Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
n = int(input())
st = str(input()).split(' ')
ans = ''
for i in range(n):
    ans += st[i][0]
    ans += st[i][1]
print(ans)

n = int(input())
st = str(input()).split(' ')
ans = ''
for i in range(n):
    ans += st[0][i]
    ans += st[1][i]
print(ans)

Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

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

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

Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
n=int(input())
s,t=input().split()
u=''
for i in range(n):
  u.append(s[i])
  u.append(t[i])
print(u)

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

Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
N = int(input())
S, T = map(str,input().split())

for i in range(N):
  print(S[i])
  print(T[i])

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

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

Verdicts: Wrong Answer

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
l = int(input())
s = input().split(' ')
print(s[0][:l]+s[1][:l])

l = int(input())
s = input().split(' ')
print(s[0]+s[1])

N = int(input("input N:"))
T = input("input S and T:").split(" ")
print(T[0]+T[1])

l = int(input())
s = input().split(' ')
r = ""
for i in range(l):
    r = r + s[0][i]+s[1][i]
print(r)

Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
N = int(input())
S = list(input())
T = list(input())
ans = ""
for i in range(N):
  ans += S[i] + T[i]
print(ans)

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


Verdicts: Runtime Error

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
N=int(input())
S,T=input().split()
ans=S[0]+T[0]
for i in range(N-1):
    ans=ans+S[i]+T[i]
print(ans)

N=int(input())
S,T=input().split()
ans=S[0]+T[0]
for i in range(1,N):
    ans=ans+S[i]+T[i]
print(ans)

Verdicts: Wrong Answer

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
N = int(input())
S, T = input().split()
k = S[0]+T[0]
for i in range(1,N-1):
  k += S[i] + T[i]
print(k)

N = int(input())
S, T = input().split()
k = S[0]+T[0]
for i in range(1,N):
  k += S[i] + T[i]
print(k)

Verdicts: Wrong Answer

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
n = input()
a = input()
b = input()

output = ""

for s, t in zip(a, b):
    output += a
    output += b
print(output)

n = input()
a, b = input().split(" ")
output = ""
print(a, b)
for s, t in zip(a, b):
    output += s
    output += t
print(output)

n = input()
a, b = input().split(" ")
output = ""
for s, t in zip(a, b):
    output += s
    output += t
print(output)

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: Given are strings s and t of length N each, both consisting of lowercase English letters.  Let us form a new string by alternating the characters of S and the characters of T, as follows: the first character of S, the first character of T, the second character of S, the second character of T, ..., the N-th character of S, the N-th character of T. Print this new string.

Submission attempts (in order):
N = int(input())
S = str(input())
T = str(input())

for i in range(N)
	ST[i]   = S[i]
  	ST[i+1] = T[i]

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

ST = ''

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

print(ST)

N = int(input())
S = str(input())
T = str(input())

ST = ''

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

print(ST)

N = int(input())
S = str(input())
T = str(input())

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


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

ST = ''

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

print(ST)


Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted