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

l = ' '

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

  print(l)


n = int(input())
s,t = input().split()
l = ''
for i in range(n):
    l += s[i]
    l += t[i]
print(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):
N = int(input())
S,T = map(,input().split())
M = len(S)
ans = ''
for i in range(M):
  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):
n = int(input())
s, t = map(int, input().split())
 
answer_list = []
for i in range(n):
  answer_list.append(s[i])
  answer_list.append(t[i])

s = ''.join(answer_list)
print(s)

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

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

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

joint = ''.join(answer_list)
print(joint)

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("")
s = input("")
t = input("")
n = int(n)
ans = ""

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

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

for i in range(n):
    ans = ans + s[i]
    ans = 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(str,input().split())
U=[]
for i in range(len(T)):
  U.append(S[i],T[i])
print(U)


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

N=int(input())
S,T=map(str,input().split())
U=str()
for i in range(N):
  U.append(S[i])
  U.append(T[i])
print(U)

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

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

Verdicts: Runtime Error

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

N = int(input())
ST = 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):
#!/usr/bin/env python3
# -*- coding: utf-8 -*-


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


if __name__ == "__main__":
    main()


# #!/usr/bin/env python3
# # -*- coding: utf-8 -*-


def main():
    N = int(input())
    S, T = map(list, input().split())
    result = ''
    for s, t in zip(S, T):
        result += s + t
    print(result)


if __name__ == "__main__":
    main()


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

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

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()
out=""
for i=range(n):
  out+=s[i]+t[i]
print(out)

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


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):
tmp = input()
print("".join(input().split()))

tmp = input()
print(input() + input())

n = input()
a, b = input().split()
for i, j in zip(a, b):
  print(i, end="")
  print(j, end="")
print()

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):
import os
N= int(input())
S=input().strip()
T=input().strip()
ans=[]
for i in range(N):
    ans.append(S[i])
    ans.append(T[i])

print(''.join(ans))

import os
N= int(input())
nyu = input().split()
S=nyu[0].strip()
T=nyu[1].strip()
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):
num = int(input())

s1,s2 = input().split()

ans = ''

for i in range(num):
	ans = ans + s1[i]
    ans = ans + s2[i]

print(ans)

num = int(input())
 
s1,s2 = input().split()
 
ans = ''
 
for i in range(num):
	ans = ans + s1[i]
	ans = ans + s2[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()
T = input()

S = list(S)
T = list(T)
A = [] 
for i in range(N):
    A.append(S[i])
    A.append(T[i])
print(''.join(A))

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

S = list(S)
T = list(T)
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):
N = int(input())
s, t = input().split()

for i in range(N):
  print(s[i], t[i], seq = '')
  
  


N = int(input())
s, t = map(input().split())

for i in range(N):
  print(s[i], t[i], seq = '')
  
  

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

new = list()
for i in range(N):
  new.append(s[i])
  new.append(t[i])
  
print(*new, 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()
new = ''
for i in range(0, n):
	new += s[i]
  	new += t[i]
print (new)

n = int(input())
str_s, str_t = input().split()
new = ''
for i in range(0, n)
	new += str_s[i]
  	new += str_t[i]
print (new)


n, strs, strt = [s for s in input().split()]
new = []
for i in range(0, n)
	new.append(strs[i])
  	new.append(strt[i])
print (new)

n = int(input())
str_s, str_t = input.split
new = ''
for i in range(0, n)
	new += str_s[i]
  	new += str_t[i]
print (new)

n = int(input())
strs, strt = [s for s in range(n)]
new = ''
for i in range(0, n)
	new += strs[i]
  	new += strt[i]
print (new)

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


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

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

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

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

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

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):
n = int(input())
s = input()
t = input()
a=''
for i in range(0,2*n):
    if i % 2 == 0:
        a += s[i//2]
    else:
        a += t[i//2]
print(a)

n = int(input())
s = input()
t = input()
a=''
for i in range(0,2*n):
    if i % 2 == 0:
        a += s[i//2]
    else:
        a += t[i//2]
print(a)

n = int(input())
s,t = [i for i in input().split()]
a=''
for i in range(0,2*n):
    if i % 2 == 0:
        a += s[i//2]
    else:
        a += t[i//2]
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().strip())
S, T = [input().strip() for i in range(2)]

ans = ''

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

n = int(input().strip())
S, T = input().strip().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()
part = [None for n in range(N)]
for i in range(N):
    part[i] = (S[i] + T[i])
    print(part[i])
print("".join(part))

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

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()
s = str(s.lower())
t = str(t.lower())
if len(s) == n and len(t) == n:
    new_list = []
    for item in range(len(s)):
        new_list.append(s[item])
        new_list.append(t[item])

    print(new_list)
else:
    pass



n = int(input())
s,t = input().split()
s = str(s.lower())
t = str(t.lower())
if len(s) == n and len(t) == n:
    new_list = []
    for item in range(len(s)):
        new_list.append(s[item])
        new_list.append(t[item])

    print(''.join(new_list))
else:
    pass


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

ans = []
for si, ti in zip(s, t):
    ans += [si, ti]
print(''.join(ans))

if n == 2:
    print(n)


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

ans = []
for si, ti in zip(s, t):
    ans += [si, ti]
print(*ans, sep='')

if n == 2:
    print(n)


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

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=list(input())
D=B[0]
E=B[1]
C=[]
for i in range(A):
  C=D[i]
  C=E[i]
print(C)


A=int(input())
B=list(input())
C=[]
for i in range(A):
  C=B[1(i)]
  C=B[2(i)]
print(C)


A=int(input())
B=list(input())
C=[]
for i in range(A):
  C=A[i]
  C=B[i]
print(C)


A=int(input())
B,C=input().split()
D=''
for i in range(A):
  D=B[i]+C[i]
print(D)


A=int(input())
B=list(input())
C=[]
for i in range(A):
  C=B[1[i]]
  C=B[2[i]]
print(C)


A=int(input())
B,C=input().split()
D=''
for i in range(A):
  D+=B[i]
  D+=C[i]
print(D)


Verdicts: Runtime Error

Runtime Error

Runtime Error

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):
ans=""
n=input()
s=input()
t=input()
for i in range(len(s)):
  ans+=s[i]+t[i]
print(ans)


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

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

result = []
for s, t in S, T:
    result.append(s)
    result.append(t)
    
print(''.join(result))

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

result = []
for s, t in zip(S, T):
    result.append(s)
    result.append(t)
    
print(''.join(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 = list(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

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 solve():
    n = int(input())
    s = input()
    t = input()

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



if __name__ == '__main__':
    solve()





def solve():
    n = int(input())
    s, t = input().split()

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

if __name__ == '__main__':
    solve()




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

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

a=int(input())
s,t=[x for x in input().rstrip().split()]

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

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

newword = []
for num in range(len(S)):
    newword.append(S[num])
    newword.append(T[num])
word = ""
for i in newword:
    word+=i
print(word)

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=[]
t=[]
for i in S:
    s.append(i)
for i in T:
    t.append(i)
l=[]
for i in range(n):
    l.append(s[i])
    l.append(t[i])
t=""
for i in range(len(l)):
    t+=l[i]
print(t)

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

s=[]
t=[]
for i in S:
    s.append(i)
for i in T:
    t.append(i)
l=[]
for i in range(n):
    l.append(s[i])
    l.append(t[i])
t=""
for i in range(len(l)):
    t+=l[i]
print(t)

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())
b=input()
c=input()
d=""
for i in range(a):
  d=d+b[i]+c[i]
print(d)

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

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

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

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

print("".join(a))  

n = int(input())
s, t = map(str, input().split())
a = ''
for i in range(n):
  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=input()
ST=input()
S=ST.split(0,N)
T=ST.split(N,2*N)

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

N=input()
ST=input()
S=ST.split(' ')[0]
T=ST.split(' ')[1]

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

N=input()
ST=input()
S=ST.split(' ')[0]
T=ST.split(' ')[1]
result=''

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

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())
s1 = input()
s2 = input()
ans = ""
for i in range(n):
  ans += s1[i]+s2[i]
print(ans)

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


length =int(input())

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

result = ""

for i in s:
  list_t = list(t)
  result = result + s + list_t[i]
 
print(result) 


length =int(input())

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

result = ""

list_s = list(s)
list_t = list(t)

for i in range(length):
  result = result + list_s[i]
  result = result + list_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())
Input = input().split()

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

new = "a"

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

print(new[0:2*N])

N = int(input())
Input = input().split()

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

new = "a"

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

print(new[1:2*N+1])

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


size = int(input())
a,b = list(map(int,input().split()))
ans = ""
for i in size:
  ans += a[i]
  ans += b[i]
print(ans)

size = int(input())
a,b = list(map(str,input().split()))
ans = ""
for i in range(size):
  ans += a[i]
  ans += b[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(nput())
S, T = input().split()
ans = ""
for i in range(N):
  ans = ans + S[i:i+1] + T[i:i+1]
  
print(ans)

N = int(input())
S, T = input().split()
ans = ""
for i in range(N):
  ans = ans + S[i:i+1] + T[i:i+1]
  
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()
ans = []
for i in range(N+1):
  ans.append(A[i] + B[i])
print("".join(ans))

N = int(input())
A,B = input().split()
ans = []
for i in range(0,N):
  ans.append(A[i] + B[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(int,input().split())
l=[]
for i in range(N):
  l.append(S[i])
  l.append(T[i])
print("".join(l))

N = int(input())
S,T = map(str,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):
n=int(input())
s,t=input().sprit()
s=list(input())
t=list(input())
a=[]
for i in range(0,n):
  a.append(s[i])
  a.append(t[i])
print(''.join(a))

n=int(input())
s,t=list(input().split())
a=[]
for i in range(0,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):
N=int(input())
lis=map(str,input().split())
ans=''
for i in lis:
    ans+=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: 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())

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 = input().split()
 
ans = ''
i = j = 0
flag = True
while j < N:
	if flag:
		ans += s[i]
      	i += 1
	else:
    	ans += t[j]
    	j += 1
  
	flag = not flag
else:
	print(ans)

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

ans = ''
i = j = 0
flag = True
while j < N:
  if flag:
	  ans += s[i]
      i += 1
  else:
      ans += t[j]
      j += 1
  
  flag = not flag


N = int(input())
s, t = input().split()
 
ans = ''
i = j = 0
flag = True
while j < N:
    if flag:
	    ans += s[i]
        i += 1
    else:
        ans += t[j]
        j += 1
    flag = not flag

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

ans = ''
i = 0
flag = True

while i < n:
  if flag:
    ans += s[i]
  else:
    ans += t[i]
    i += 1
  flag = not flag
else:
  print(ans)

Verdicts: 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):
a = int(input())
s,t = input().split()
print(s+t)

a = int(input())
s,t = input().split()
print(s+t)

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


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):
input()
s1, s2 = input().split()
for idx in range(len(s)):
  print(s1[idx],end='')
  print(s2[idx],end='')
  
print()

input()
s1, s2 = input().split()
for idx in range(len(s2)):
  print(s1[idx],end='')
  print(s2[idx],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 = map(str, input().split())
S = list(S)
T = list(T)

for i in range(N):
  ans = []
  for j in range(N):
    ans.append(S[i])
    ans.append(T[i])
print(''.join(ans))


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

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

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

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

n = int(input())
[s,t] = [i for i in 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=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.append(S[i])
	U.append(T[i])

print(*U, 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())
a=input()
b=input()
for i in range(n):
    print(a[i],end="")
    print(b[i],end="")
print()
    

n=int(input())
a,b=map(str,input().split())
for i in range(n):
    print(a[i],end="")
    print(b[i],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 = input()
S = input()
T = input()

A=0
P=""
while A < int(N):
  P+=S[A]+T[A]
  A=A+1

print(P)

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

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


import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

A = int(readline())
S, T = readline().decode('utf-8').split()

C = [None] * (A * 2)
print(C)
C[::2] = S
print(C)
C[1::2] = T

print(C)

ans = ''.join(C)

print(ans)



import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

A = int(readline())
S, T = readline().decode('utf-8').split()

C = [None] * (A+A)
C[::2] = S
C[1::2] = T

ans = ''.join(C)

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

num = input()
words = input()
words = words.split()
print("".join(words))

length = int(input())
words = input()
words = words.split()
new = []
for a,b in zip(words[0],words[1]):
  new += [a,b]
print("".join(new))

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


n=int(input())
u=list(input().split())
s=list(u[0])
t=list(u[1])
a=""
for i in range(n):
    a+=s[i]
    a+=t[i]
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, t = input().split()
ans = ""
for i in range(n):
  ans += s[i]
  ans += s[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):
num = int(input())

s = input()
t = input()
u =[]

for _ in range(num):
  u.append(s[_] + t[_])

print(''.join(u))

num = int(input())

s = input()
t = input()
u =[]

for _ in range(num):
  u.append(s[_] + t[_])

print(''.join(u))

num = int(input())

s = input()
t = input()
u =[]

for _ in range(num):
  u.append(s[_] + t[_])

print(''.join(u))


num = int(input())

s = input()
t = input()
u =[]

for _ in range(num):
  u.append(s[_] + t[_])

ans = ''.join(u)

print(ans)

num = int(input())

s, t = input().split()
u =[]

for _ in range(num):
  u.append(s[_] + t[_])

ans = ''.join(u)

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,t = map(str,(input().split()))
result = s+t
print(result)

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

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):
num=int(input())
strs=input().split()
for i in range(num):
  strs[1].insert(i,strs[0][i])
print(strs[1])

num=int(input())
strs=input().split()
text=""
for i in range(num):
  text+=strs[0][i]
  text+=strs[1][i]
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):
n = int(input())
s, t = input()
l = []
m = []
r = ""
for i in s:
  l.append(i)
for i in t:
  m.append(i)

for i in range(n):
  r += (l[i] + m[i])
print(r)

n = int(input())
s, t = input().split(' ')
l = []
m = []
r = ""
for i in s:
  l.append(i)
for i in t:
  m.append(i)
 
for i in range(n):
  r += (l[i] + m[i])
print(r)

Verdicts: Runtime Error

Accepted