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())
print(N)
S = input().split()
Output = ""

for i in range(N) :
  Output = Output + S[0][i] + S[1][i]

print(Output)

N = int(input())
S = input().split()
Output = ""
 
for i in range(N) :
  Output = Output + S[0][i] + S[1][i]

print(Output)

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 = input().split()
a = [i for i in a]
b = [i for i in b]
ans =""

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


n = int(input())
a,b = input().split()
a = list(a)
b = list(b)
ans =""
 
for i in range(n):
  ans += a[i]
  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())
a,b=input().split()
a=list(a)
b=list(b)
ab=""
for _ in range(N):
	ab+=a.pop()+b.pop()
print(ab)

N=int(input())
a,b=input().split()
a=list(a)
b=list(b)
ab=""
for _ in range(N):
	ab+=a.pop(0)+b.pop(0)
print(ab)

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())
x = input().split(" ")
ans = ""
for i in range(n):
    ans += x[i%2][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):
a=int(input())
b,c=list(input().split())
ans=[]
for i in range(a):
    print(i)
    ans.append(b[i])
    ans.append(c[i])
sinans="".join(ans)
print(sinans)

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

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=input()
print("".jion(s.split()))

'''
author : w2sc
  date : 2019/12/22
  time : 20:03:13
'''
n=int(input())
a,b=input().split()
i=0
s=""
while i<n:
    s+=a[i]+b[i]
    i+=1
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,t = input().split()	
print(s+t)

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

for i in range(n):

    new +=(s[i]+t[i])
print(new)

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):
new_str = ""
num = int(input())
string = input().split(" ")
print("".join(string))

new_str = ""
num = int(input())
string = input().split(" ")
for i in range(0,num):
    new_str += string[0][i] + string[i][0]
print("".join(new_str))

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

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

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


# ABC148B

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


# ABC148B

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


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=map(input().split())
k=[]
for i in range(n):
    k.append(s[i])
    k.append(t[i])
print("".join(k))


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

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

N=input()
S,T=input().split()
print(*[s+t for s,t in zip(S,T)],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,T = list(map(str,input().split()))
ans = []*N 
for i in range(N):
  ans[i] = S[i] + T[i]
  i += 1
print(sum(ans))

N = int(input())
S,T = list(map(str,input().split()))
list_ans = []
for i in range(N):
  list_ans.extend(S[i] + T[i])
  i += 1
ans = ''.join(list_ans)
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()
 
for i in range(n):
    u = u + s[i] + t[i]
 
print(u)

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


print(ans)

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


print(ans)

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

ans = str()
for i in range(n):
    ans += s[i]
    ans += 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 = input()
A, B = input().split()
c = ""

for i in range(n):
  c = c+A[i]
  c = c+B[i]

print(c)

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

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

n = int(input())
A, B = input().split()
c = ""

for i in range(n):
  c = c+A[i]
  c = c+B[i]

print(c)


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

n = int(input())
s,t = map(list, input().split(" "))
a=[]
for i in range(n):
    a.append(s[i])
    a.append(t[i])
print(''.join(a))

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

res = ''

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

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

n=int(input())
s=input()
a=s[:n]
b=s[n+1:]
#print(a,b)
ans=""
for i in range(n):
    ans+=a[i]
    ans+=b[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 = map(list,input().split())
ans = []
for i in range(n)
  ans.append(s[i])
  ans.append(t[i])
print(''.join(ans))

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

N=int(input())
S=list(input())
T=list(input())  
sum=""
for i in range(N):
  sum= sum+S[i]+T[i]
print(sum)

N=int(input())
S=list(input())
T=list(input()) 
sum=""
for i in range(N):
  sum+=S[i]
  sum+=T[i]
print(sum)

N=int(input())
S=list(input())
T=list(input())  
sum=""
for i in range(n):
  sum= sum+s[i]+t[i]
print(sum)

N=int(input())
S=list(input())
T=list(input()) 
sum=""
for i in range(N):
  sum+=S[i]
  sum+=T[i]
print(sum)

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

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

print(strings)

Verdicts: 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):
from collections import defaultdict
import sys
import math
from datetime import datetime
import re
import math
def sol(n, S, T):
    ans = ""
    for i in range(n):
        ans += S[i]
        ans += T[i]
    return ans





do_submit = True


def input_parse(input_str):
    lines = [x.strip() for x in input_str.split("\n") if x.strip()]
    parsed_lines = [list(map(str, line.split())) for line in lines]
    print(parsed_lines)
    # n = int(parsed_lines[0][0])
    
    S = parsed_lines[0][0]
    return S


if not do_submit:
    S = input_parse("""
    1905
    """)
    print(sol(S))

    S = input_parse("""
    0112
    """)
    print(sol(S))

    S = input_parse("""
    1700
    """)
    print(sol(S))

    S = input_parse("""
    0000
    """)
    print(sol(S))

    S = input_parse("""
    1001
    """)
    print(sol(S))



else:
    #A, B = list(map(int, input().split()))
    n = int(input())
    S = input()
    T = input()
    print(sol(n, S, T))

    # S = input().strip()
    # print(sol(S))

from collections import defaultdict
import sys
import math
from datetime import datetime
import re
import math
def sol(n, S, T):
    ans = ""
    for i in range(n):
        ans += S[i]
        ans += T[i]
    return ans





do_submit = True


def input_parse(input_str):
    lines = [x.strip() for x in input_str.split("\n") if x.strip()]
    parsed_lines = [list(map(str, line.split())) for line in lines]
    print(parsed_lines)
    # n = int(parsed_lines[0][0])
    
    S = parsed_lines[0][0]
    return S


if not do_submit:
    S = input_parse("""
    1905
    """)
    print(sol(S))

    S = input_parse("""
    0112
    """)
    print(sol(S))

    S = input_parse("""
    1700
    """)
    print(sol(S))

    S = input_parse("""
    0000
    """)
    print(sol(S))

    S = input_parse("""
    1001
    """)
    print(sol(S))



else:
    #A, B = list(map(int, input().split()))
    n = int(input())
    S, T = list(map(str, input().split()))
    # S = input()
    # T = input()
    print(sol(n, S, T))

    # S = input().strip()
    # print(sol(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):
number = int(input())
word1, word2 = input().split()
moji = ''

word1 = list(word1)
word2 = list(word2)

newword = []

print(word1, word2)

for i in range(number):
    newword.append(word1[i])
    newword.append(word2[i])

print(newword)

for x in newword:
    moji += x

print(moji)

number = int(input())
word1, word2 = input().split()
moji = ''

word1 = list(word1)
word2 = list(word2)

newword = []

print(word1, word2)

for i in range(number):
    newword.append(word1[i])
    newword.append(word2[i])

print(newword)

moji = ''.join(newword)

print(moji)

number = int(input())
word1, word2 = input().split()
moji = ''

word1 = list(word1)
word2 = list(word2)

newword = []

for i in range(number):
    newword.append(word1[i])
    newword.append(word2[i])

moji = ''.join(newword)

print(moji)

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

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

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

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

def main():
  a = int(input())
  b = input()
  l = b.split()
  ll = []
  for i in range(0,a * 2):
    str = (b[0] + b[1])[i::4]
    str1 += str
  print(str1)

if __name__ == '__main__':
  main()

def main():
  a = int(input())
  b = input()
  l = b.split()
  d = a * 2
  str1 = []
  s = "".join(i+j for i, j in zip(l[0],l[1]))
  print(s)
 
if __name__ == '__main__':
  main()

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())
x= []

for i in range(n):

    lst = [s[i], t[i]]
    x.append(''.join(lst))

n = int(input())
s, t = map(str, input().split())
x= []

for i in range(n):

    lst = [s[i], t[i]]
    x.append(''.join(lst))

print(''.join(x))

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


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

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

    


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


n=int(input())
s,t=map(str,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())
A,B = input().split()
tmp = [[] for _ in range(N*2)]
print(A)
M = 2*N
for i in range(0,N):
	tmp[2*i]=A[i]
	tmp[2*i+1]=B[i]
ans = "".join(tmp)
print(ans)

N = int(input())
A,B = input().split()
tmp = [[] for _ in range(N*2)]
M = 2*N
for i in range(0,N):
	tmp[2*i]=A[i]
	tmp[2*i+1]=B[i]
ans = "".join(tmp)
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 = map(str,input().split(" ",N))

print(S + T)

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

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

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=input()
S,T=input().split
print(*[s+t for s,t in zip(S,T)],sep="")


N=input()
S,T=input().split()
print(*[s+t for s,t in zip(S,T)],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):
_ = input()
a, b = input().split()

result = ""

for a_, b_ in zip(a, b):
	result += a_ + b+

print(result)


_ = input()
a, b = input().split()
 
result = ""
 
for a_, b_ in zip(a, b):
	result += a_ + b_
 
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):
a = [input() for i in range(3)]

N = int(a[0])
S = a[1]
T = a[2]

answer = ""

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

N = int(input()) 
a = input().split()
S = a[0]
T = a[1]

answer = ""

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


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

L=[]
for i in range(max(len(s),len(t))):
    L.append(s[i])
    L.append(t[i])
print(L)
        

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

L=[]
for i in range(max(len(s),len(t))):
    L.append(s[i])
    L.append(t[i])
print(''.join(L))

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):
S, T = input().split()
print(*[s+t for s,t in zip(S,T)], sep='')

N = int(input())
S, T = input().split()
print(*s+t for s,t in zip(S,T), sep='')

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

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

ans = ''
for ss, tt in zip(s, t):
    ans += ss + tt

n = int(input()) 
s, t = list(map(str, input().split()))

ans = ''
for ss, tt in zip(s, t):
    ans += ss + tt
    
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())
a = input()
b = input()
res = ''
for i in range(len(a)):
    res += a[i]
    res += b[i]
print(res)


a = input()
b = input()
res = ''
for i in range(len(a)):
    res += a[i]
    res += b[i]
print(res)


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


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(str,input().split())
list=[]
ans=''

for i in range(N):
  for j in range(N):
    list.append(S[i])
    list.append(T[i])
for x in list:
  ans += x
print(ans)

N=int(input())
S,T=map(str,input().split())
list=[]
ans=''

for i in range(N):
  for j in range(N):
    list.append(S[i])
    list.append(T[j])
for x in list:
  ans += x
print(ans)

N=int(input())
S,T=map(str,input().split())
list=[]
ans=''

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


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

def f03():
    n=int(input())
    s, t=map(str, input().split())
    print(*[s[i]+t[i] for i in range(n)], sep='')
f03()

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())
n,m = map(str,input().split())

L = []

for i in range(N):
    L.append(n[i])
    for j in range(N):
        if i==j:
            L.append(m[i])
            continue

print(L)
        
    


N = int(input())
n,m = map(str,input().split())

ans = str()

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

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

N = input()
S = input()
T = input()

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

N = input()
S = input()
T = input()
 
Q = ""
for i in range (N-1):
  Q = Q + S[i] + T[i]
  
print(Q)

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

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

S = input()
T = input()
N = input()

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

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

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

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

Verdicts: 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 = input()
S = input()
l = S.split() # list
print(type(l))
print("".join(l))

N = input()
S = input()
l = S.split() # list
ans = ""

for i in range(int(N)):
    ans = ans + l[0][i] + l[1][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 = map(list, input().split())

r = []

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

print(r)

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

r = []

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

print(''.join(r))

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()
S,T=input().split()
print(*[zip(iter(S),iter(T))])


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

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

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


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

for i in range(N):
    r += S[i] + T[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 = input()
t = input()

ans = []
for i in range(n):
    a.append(s[i])
    a.append(t[i])
print(''.join(a))

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

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

def main():
    N = int(input())
    row = input()
    for (s, t) in zip(row[:N], row[N:]):
        print(s+t, end="")
    print("") 

    if __name__ == "__main__":
    main()


def main():
    N = int(input())
    row = input()
    for (s, t) in zip(row[:N], row[N:]):
        print(s+t, end="")
    print("") 

if __name__ == "__main__":
    main()

def main():
    N = int(input())
    row = input()
    for (s, t) in zip(row[:N+1], row[N+1:]):
        print(s+t, end="")
    print("") 

if __name__ == "__main__":
    main()

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())
l = list(input().split())
s = ""
for i in range(n):
  s += (l[0][n] + l[1][n])
print(s)

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

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

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

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

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

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()
a=""
for i , j in (s,t):
  a+=i
  a+=j
print(a)

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

for i, j in zip(s, t):
  print(s+t, end='')
  
print()

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

for i, j in zip(s, t):
  print(i+j, end='')
  
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 = ISS()
S =""
for i in range(n):
	S+=s[i]+t[i]
print(S)


import sys

def ISS(): return sys.stdin.readline().rstrip().split()

n = int(input())
s, t = ISS()
S =""
for i in range(n):
	S+=s[i]+t[i]
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):
inp = input()
inp = input().split(" ")
r = ""

for o in zip(inp[0], inp[1]):
  r += str(o)

print(o)

inp_1 = int(input())
inp_2 = input().split(" ")
r = ""

for i in range(inp_1):
  r += inp_2[0][i]
  r += inp_2[1][i]

print(o)


inp = int(input())
inp = input().split(" ")
r = ""

for o in zip(inp[0], inp[1]):
  r += str(o)

print(o)

inp_1 = int(input())
inp_2 = input().split(" ")
r = ""

for i in range(inp_1):
  r += inp_2[0][i]
  r += inp_2[1][i]

print(r)


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())
ans = ["0"] * 2N

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

print("".join(ans))

N = int(input())
ans = ["0"] * 2 * N
 
S, T = input().split()
for i in range(N):
  ans[2*i] = S[i]
  ans[2*i+1] = T[i] 
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):
N = int(input())
s,t = map(str,input().split())
ans = ""
for i in range(N):
  ans.append(s[i])
  ans.append(t[i])
print(ans)
  

N = int(input())
s,t = map(str,input().split())
ans = []
for i in range(N):
  ans.append(s[i])
  ans.append(t[i])
a = str(ans)
print(a)
  

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



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):
a = int(input())
b = int(input())

ans = [1, 2, 3]
ans.remove(a)
ans.remove(b)

print(ans[0])

n = int(input())
S, T = [str(a) for a in input().split()]

ans = ''
for s, t in zip(S, T):
    ans += s
    ans += t

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):
# -*- coding: utf-8 -*-
N=int(input())
S, T=map(list, input().split())
W=""
for i in range(N):
    W=W+S[i-1]
    W=W+T[i-1]


print(W)

# -*- coding: utf-8 -*-
N=int(input())
S, T=map(list, input().split())
W=[]
for i in range(N)
    W.append(S[i-1])
    W.append(T[i-1])

W=str(W)
print(W)

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

print(W)

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, T = input("Enter a two value: ").split() 
if((len(S)==N)&&(len(T)==N)):
  print(S+T)

N = int(input())
T = input()
print(T.split())


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

N = int(input())
S, T = input("Enter a two value: ").split(' ') 

print(S+T)

N = int(input())
Str = input()
word = Str.split(' ')
if(((len(word))/2) == N):
  print(word)
  

N = int(input())
S, T = map(String, input().split()) 
if(len(S)==len(T)):
  print(S+T)

N = int(input())
S, T = input("Enter a two value: ").split(' ') 
if((len(S)==N)&&(len(T)==N)):
  print(S+T)

N = int(input())
S, T = input("Enter a two value: ").split() 
if(len(S)==len(T)):
  print(S+T)

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

Verdicts: Runtime Error

Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Runtime Error

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(str,input())

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

n = int(input())
s, t = map(str,input())

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

print(ans)

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

ans = ''
for i in range(n):
    ans += s[i]
    ans += 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())
a,b=input().split()
c=""
for _ in range(n):
  c+=a[0]+b[0]
print(c)

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

Verdicts: Wrong Answer

Accepted