TnT/Multi_CodeNet4Repair huggingface dataset:
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
n = int(input())/2
s = input()
if s[:n]=s[n:]:
  print('Yes')
else:
  print('No')

n = int(input())
s = input()
if n%2==0:
  if s[:n]=s[n:]:
    print('Yes')
  else:
    print('No')
else:
  print('No')

n = int(input())
s = input()
m = n/2
if n%2==0:
  if s[:m]==s[m:]:
    print('Yes')
  else:
    print('No')
else:
  print('No')

n = int(input())
s = input()
m = int(n/2)
if n%2==0:
  if s[:m]==s[m:]:
    print('Yes')
  else:
    print('No')
else:
  print('No')

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

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

print(s[0:int(n/2)], s[int(n/2):n])

if s[0:int(n/2)] == s[int(n/2):n]:
    print("Yes")
else: print("No")


n = int(input())
s = input()

if s[0:int(n/2)] == s[int(n/2):n]:
    print("Yes")
else: print("No")


Verdicts: Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
N = int(input())
S = [input().split() for i in range(N)]

if N >= 1 and N <=100:
	def S.islower():
	if True:
      T = S[0:N / 2 - 1]
    else:

if (T + T in s):
  print('Yes')
else:
  print('No')


S = input()
N = int(input())

T = S[0:N / 2 - 1]

if (T + T in s):
 print('Yes')
  
else:
 print('No')


N = int(input())
S = [input().split() for i in range(N)]
T = S[0:N / 2 - 1]
 
if N >= 1 and N <=100:
	def S.islower():
	if True and T + T in s:
    	print('Yes')
    else:
  		print('No')

N = int(input())
S = input()

if N >= 1 and N <=100:
	def S.islower():
	if True:
      T = S[0:N / 2 - 1]
    else:
 
if (T + T in s):
  print('Yes')
else:
  print('No')

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

T = S[0:int(N) // 2]
W = S[int(N) // 2:int(N) + 1] 

if T == W:
	print('Yes')
else:
	print('No')


Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
r = int(input())
print(r**2)

n = int(input())
s = str(input())

S_1=s[:(n//2)]
S_2=s[(n//2):]
 
if S_1 == S_2:
    print("Yes")
else:
    print("No")

Verdicts: Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
n = int(input())
s = input()
if n % 2 == 0 and s[:n//2] == s[s//2:] :
  print('Yes')
else:
  print('No')

n = int(input())
s = input()
if n % 2 == 0 and s[:n//2] == s[n//2:] :
  print('Yes')
else:
  print('No')

Verdicts: Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
t = input()
if(len(t) %2 == 1):
  print("No")
  exit()
if(t[:len(t)//2] == t[len(t)//2:]):
  print("Yes")
else:
  print("No")

if(int(input()) %2 == 1):
  print("No")
  exit()
t = input()
if(t[:len(t)//2] == t[len(t)//2:]):
  print("Yes")
else:
  print("No")


Verdicts: Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
N = int(input())
S = input()
if N%2 == 0:
  if S[:N//2+1] == [N//2:]:
    print("Yes")
  else:
    print("No")
else:
  print("No")

N = int(input())
S = input()
if N%2 == 0:
  if S[:N//2] == S[N//2:]:
    print("Yes")
  else:
    print("No")
else:
  print("No")

Verdicts: Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
N = int(input())
T = input()
l = []
m = []
for i in range(int(len(T) / 2)):
    l.append(i)
for j in range(int(len(T) / 2) + 1 ,len(T) ):
    m.append(j)
if l == m:
    print("Yes")
else:
    print("No")

N = int(input())
T = input()
l = T[:int(len(T) / 2)]
m = T[int(len(T) / 2):]
if l == m:
    print("Yes")
else:
    print("No")

Verdicts: Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
s = input()
n = len(s)
if n%2 ==1 :
  print("No")
else :
  t = s[0:n//2]
  if t == s[n//2:] :
    print("Yes")
  else : 
    print("No")

n = input()
s = input()
n = len(s)
if n%2 ==1 :
  print("No")
else :
  t = s[0:n//2]
  if t == s[n//2:] :
    print("Yes")
  else : 
    print("No")

Verdicts: Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

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

print("Yes" if S[0:(N//2)]==S[(N//2):N] else "No")


N = int(input())
S = input()

print("Yes" if S[:(N//2)] == S[(N//2):N] else "No")


Verdicts: Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
N = int(input())
S = input()
if N % 2 != 0:
    print("No")
else:
    if S[0:N/2] == S[N/2:]:
        print("Yes")
    else:
        print("No")


N = int(input())
S = input()
harf = int(N/2)
if N % 2 != 0:
    print("No")
else:
    if S[0:harf] == S[harf:]:
        print("Yes")
    else:
        print("No")



Verdicts: Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
n = int(input())
s = str(input())
if int(n) <= 100 and int(n) >=1 and int(n) == len(s):
    if s.islower():
        half = len(s)/2
        s1 = s[int(half):]
        print(s1)
        if s.count(s1)==2:
            print("Yes")
        else:
            print("No")
    else:
        print("No")

n = int(input())
s = str(input())
if int(n) <= 100 and int(n) >=1 and int(n) == len(s):
    if s.islower():
        half = len(s)/2
        s1 = s[int(half):]
        print(s1)
        if s.count(s1)==2:
            print("Yes")
        else:
            print("No")
    else:
        print("No")

n = int(input())
s = str(input())
if int(n) <= 100 and int(n) >=1 and int(n) == len(s) and s.islower(): 
    s1 = s[int(len(s)/2):]
    print(s1)
    if s.count(s1)==2:
        print("Yes")
    else:
        print("No")

from sys import exit

N = int(input())
S = input()

if N % 2 == 1:
    print('No')
    exit()

if S[:N // 2] == S[N // 2:]:
    print('Yes')
else:
    print('No')

Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
input()
a=input()
if len(a)%2==0 and a[:len(a)/2]==a[len(a)/2:]:
	print("Yes")
else:
	pritn("No")

input()
s=input()
if len(a)%2==0 and a[:len(a)/2]==a[len(a)/2:]:
	print("Yes")
else:
	pritn("No")

input()
a=input()
if len(a)%2==0 and a[:len(a)//2]==a[len(a)//2:]:
	print("Yes")
else:
	print("No")

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
 int(input())
s = list(input())
 
a = n//2
if n % 2 == 1:
    print("No")
elif s[0:a] == s[a:n]:
    print("Yes")
else:
    print("No")

n = int(input())
s = input()
if s[:(n//2-1)]==s[:(n//2)]:
    print("Yes")
else:
    print("No")

n = int(input())
s = list(input().split())

a = n//2
if n % 2 == 1:
    print("No")
elif s[0:a-1] ==s[a:-1]:
    print("Yes")
else:
    print("No")

n = int(input())
s = input()
if s[:(n//2)]==s[(n//2):]:
    print("Yes")
else:
    print("No")

Verdicts: Runtime Error

Wrong Answer

Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
def solve():
    n, data = [x for x in input().split(" ")]
    n = int(n)
    if data[:n//2] == data[n//2:]:
        return "Yes"
    return "No"

if __name__ == "__main__":
    # test = int(input())
    # for _ in test:
    print(solve())

def solve():
    n, data = [x for x in input().split(" ")]
    n = int(n)
    if data[:n//2] == data[n//2:-1]:
        return "Yes"
    return "No"

if __name__ == "__main__":
    # test = int(input())
    # for _ in test:
    solve()

def solve():
    n = int(input())
    data = input()
    # n, data = [x for x in input().split(" ")]
    n = int(n)
    if data[:n//2] == data[n//2:]:
        return "Yes"
    return "No"

if __name__ == "__main__":
    # test = int(input())
    # for _ in test:
    print(solve())

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

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

a = s[0:int(n/2)]
b = s[int(n/2):]

print(a,b)

if n % 2 != 0 or n != len(s):
    print("No")
elif a == b:
    print("Yes")
else:
    print("No")


n = int(input())
s = input()

if s[0:int(n/2)-1] == s[int(n/2):n-1]:
    print("YES")
else:
    print("NO")


n = int(input())
s = input()

a = s[0:int(n/2)]
b = s[int(n/2):]

if n % 2 != 0 or n != len(s):
    print("No")
elif a == b:
    print("Yes")
else:
    print("No")


Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

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

if len(s)%2 != 0: print("No")
else:
  c = n//2
  t = s[:c]
  print(t)
  if 2*t ==s: 
    print("Yes")
  else: print("No")


n = int(input())
s = input()

if len(s)%2 != 0: print("No")
else:
  c = n//2+1
  t = s[:c]
  if 2*t ==s:
    print("Yes")
  else: print("No")

n = int(input())
s = input()

if len(s)%2 != 0: print("No")
else:
  c = n//2
  t = s[:c]
 
  if 2*t ==s: 
    print("Yes")
  else: print("No")


Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
def main():
    n = int(input())
    s = input()s
    if n % 2 == 0:
        s1 = s[:(n//2)]
        s2 = s[n//2:]
        if s1 == s2:
            print("Yes")
        else:
            print("No")
    else:
        print("No")



if __name__ == "__main__":
    main()


def main():
    n = int(input())
    s = input()
    if n % 2 == 0:
        s1 = s[:(n//2)]
        s2 = s[n//2:]
        if s1 == s2:
            print("Yes")
        else:
            print("No")
    else:
        print("No")



if __name__ == "__main__":
    main()


Verdicts: Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
i = int(input())
s = input()
n = i // 2
s1 = s[0:n]
s2 = s[n:i]
#print(s1)
#print(s2)

if((i % 2 == 0)and(s1 == s2)):
    print("Yes")
e6lse:
    print("No")

i = int(input())
s = input()
n = i // 2
s1 = s[0:n]
s2 = s[n:i]

if((i % 2 == 0)and(s1 == s2)):
    print("Yes")
else:
    print("No")

Verdicts: Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
N = int(input())
S = input()
if N%2 == 1:
    print("No")
    exit()
t = S[:N/2]
if S[N/2:] == t:
    print("Yes")
else:
    print("No")


N = int(input())
S = input()
if N%2 == 1:
    print("No")
    exit()
if S[N//2:] == S[:N//2]:
    print("Yes")
else:
    print("No")


Verdicts: Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
n = int(input())
s = str(input())
if n % 2 !=0:
  print('No')
else:
  if s[0:n/2-1] == s[n/2:n-1]:
    print('Yes')
  else:
    print('No')

n = int(input())
s = str(input())
if n % 2 !=0:
  print('No')
else:
  if s[0:int(n/2)] == s[int(n/2):int(n)]:
    print('Yes')
  else:
    print('No')
    

Verdicts: Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
import sys
S = input()
if S[len(S)//2:] ==S[:len(S)//2]:
    print('Yes')
else:
    print('No')

import sys
N = int(input())
S = input()
if S[len(S)//2:] ==S[:len(S)//2]:
    print('Yes')
else:
    print('No')

Verdicts: Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
#145
n = int(input())
s = input()

if n % 2 != 0:
    print("No") 
else:
    print(s[0:n//2], s[n//2:])
    if s[0:n//2] == s[n//2:]:
        print("Yes")
    else:
        print("No")

#145
n = int(input())
s = input()

if n % 2 != 0:
    print("No") 
else:
    if s[0:n//2] == s[n//2:]:
        print("Yes")
    else:
        print("No")

Verdicts: Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
1
z

N = int(input())
S = input()
if len(S)%2 != 0:
    print("No")
    exit()
if S[:len(S)//2] == S[len(S)//2:]:
    print("Yes")
else:
    print("No")

Verdicts: Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
# coding: utf-8
N=int(input())
S=input()
if S[:N/2]==S[N/2:]: print("Yes")
else: print("No")

# coding: utf-8
N=int(input())
S=input()
if S[:int(N/2)]==S[int(N/2):]: print("Yes")
else: print("No")


Verdicts: Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
import sys
input = sys.stdin.readline
 
n=int(input())
s=input()
s1=s[:n//2]
s2=s[n//2:]
#if s1==s2:
if s==(s1+s1):
    print("Yes")
else:
    print("No")


import sys
input = sys.stdin.readline
 
n=int(input())
s=input()
if n%2:
    print("No")
    exit()

s1=s[0:n//2]
#s2=s[n//2:]
#if s1==s2:
if s==(s1+s1):
    print("Yes")
else:
    print("No")


import sys
#input = sys.stdin.readline
input = sys.stdin.readline().rstrip()

n=int(input())
s=input()
s1=s[:n//2]
s2=s[n//2:]
if s1==s2:
    print("Yes")
else:
    print("No")


import sys
input = sys.stdin.readline
 
n=int(input())
s=input()
if n%2:
    print("No")
    exit()
    
s1=s[:n//2]
s2=s[n//2:]
#if s1==s2:
if s==(s1+s1):
    print("Yes")
else:
    print("No")


import sys
input = sys.stdin.readline

n=int(input())
#s=input()
s=input().rstrip()
s1=s[:n//2]
s2=s[n//2:]
if s1==s2:
    print("Yes")
else:
    print("No")


Verdicts: Wrong Answer

Wrong Answer

Runtime Error

Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
N = int(input())
S = input()
if N//2 == 0:
  T = S[0:N/2]
  if T+T == S:
    print("Yes")
  else:
    print("No")
else:
  print("No")

N = int(input())
S = input()
if N%2 == 0:
  T = S[0:N/2]
  if T+T == S:
    print("Yes")
  else:
    print("No")
else:
  print("No")

N = int(input())
S = input()
if N%2 == 0:
  T = S[0:int(N/2)]
  if T+T == S:
    print("Yes")
  else:
    print("No")
else:
  print("No")

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
N=int(input())
S=input()
A=S[:N//2]
B=S[N//2:]
ans=0
if N%2!=0:
    ans=-1
for i in range(N//2):
    if A[i]!=B[i]:
        ans=-1
        break
    else:
        pass
print(ans)
if ans==-1:
    print("No")
else:
    print("Yes")

N=int(input())
S=input()
A=S[:N//2]
B=S[N//2:]
if A==B:
    print("Yes")
else:
    print("No")

Verdicts: Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
n=int(input())
s=input()
ans="No"
if n%2==0 and s[:n//2+1]==s[n//2+1]:
    ans="Yes"
print(ans)

n=int(input())
s=input()
ans="No"
if n%2==0 and s[:n//2]==s[n//2:]:
    ans="Yes"
print(ans)

Verdicts: Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
N=int(input())
S=list(input())
n=int(N/2)
if S[0:n]==S[n+1:N]:
  print("Yes")
else:
  print("No")

N=int(input())
S=list(input())
if N%2==1:
  print("No")
else:
  n=int(N/2)
  if S[0:n]==S[n:N]:
    print("Yes")
  else:
    print("No")


Verdicts: Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
n = int(input())
st = input()
if len(st) == 1:
  print("No")
elif n % 2 == 0:
  print("No")
else:
  first = st[n//2:]
  last = st[:n//2]
  if first == last:
    print("Yes")
  else:
  	print("No")
  

n = int(input())
st = input()
if len(st) == 1:
  print("No")
elif n % 2 != 0:
  print("No")
else:
    first = st[n//2:]
    last = st[:n//2]
    if first == last:
        print("Yes")
    else:
        print("No")

Verdicts: Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
n=int(input())
s=input()
import sys
a=0
sys.exit()
if n==1:
    print('No')
    sys.exit()
if n%2!=0:
    print('No')
    sys.exit()
else:
    for i in range(n//2):
        if s[i]==s[i+(n//2)]:
            pass
        else:
            a=1
            break
if a==0:
    print('Yes') 
else:
    print('No')       

n=int(input())
s=input()
import sys
a=0
if n==1:
    print('No')
    sys.exit()
if n%2!=0:
    print('No')
    sys.exit()
else:
    for i in range(n//2):
        if s[i]==s[i+(n//2)]:
            pass
        else:
            a=1
            break
if a==0:
    print('Yes') 
else:
    print('No')       

Verdicts: Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
n=int(input())
s=input()
if s==s[::-1]:print("Yes")
else:print("No")

n=int(input())
s=input()
if s==s[:len(s)//2]*2:print("Yes")
else:print("No")


Verdicts: Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
N = int(input())
S = input()
ans = false
if N % 2 == 0:
  ans = S[:N//2] == S[N//2:]
print(ans)

N = int(input())
S = input()
ans = False
if N % 2 == 0:
  ans = S[:N//2] == S[N//2:]
print(ans)


N = int(input())
S = input()
ans = 'No'
if N % 2 == 0 and S[:N//2] == S[N//2:]:
  ans = 'Yes'
print(ans)


Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

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

if n % 2 != 0:
    print("No")
elif s[0:(n/2)] == s[(n/2):n]:
    print("Yes")
else:
    print("No")

n = int(input())
s = input()

if n % 2 != 0:
    print("No")
elif s[0:(n//2)] == s[(n//2):n]:
    print("Yes")
else:
    print("No")

Verdicts: Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
i = int(input()) 
s = input()
if i >= 1 and 100 >= i and i % 2 == 0 and i == len(s) and s.isalpha() and s.islower():
  t_0 = s[0]
  t_1 = s[i/2]
    for j in range(1, i/2):
      t_0 += s[j]
    for k in range(i/2 + 1, i):
      t_1 += s[k]
    if t_0 == t_1:
      print("Yes")
    else:
      print("No")


i = int(input())
if i >= 1 and 100 >= i and i % 2 == 0:  
  s = input()
    if i == len(s) and s.isalpha() and s.islower():  
      t_0 = s[0]
      t_1 = s[i/2]
	  for j in range(1, i/2):
	    t_0 += s[j]
      for k in range(i/2 + 1, i):
        t_1 += s[k]
      if t_0 == t_1:
        print("Yes")
      else:
        print("No")


i = int(input())
if i >= 1 and 100 >= i and i % 2 == 0:  
  s = input()
if i == len(s) and s.isalpha() and s.islower():  
  t_0 = s[0]
  t_1 = s[i/2]
	for j in range(1, i/2):
	  t_0 = t_0 + s[j]
    for k in range(i/2 + 1, i):
      t_1 = t_1 + s[k]
  if t_0 == t_1:
    print("Yes")
  else:
    print("No")

i = int(input())
if ( i >= 0 and 100 >= i and (i % 2 == 0) ):  
  s = input()
  t_0 = s[0]
  t_1 = s[i/2]
	for j in range(1, i/2):
	  t_0 = t_0 + s[j]
    for k in range(i/2 + 1, i):
      t_1 = t_1 + s[k]
  if (t_0 == t_1):
    print('Yes')
  else:
    print('No')

i = int(input()) 
s = input()
if i >= 1 and 100 >= i and i % 2 == 0 and i == len(s) and s.isalpha() and s.islower():
  n = (int)(i/2)
  t_0 = s[0]
  t_1 = s[n]
  for j in range(1, n):
    t_0 += s[j]
  for k in range(n + 1, i):
    t_1 += s[k]
  if t_0 == t_1:
    print("Yes")
  else:
    print("No")
else:
  print("No")

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
n=int(input())
s=input()
if n%2==1:
  print(No)
else:
  for i in range(n//2):
    if s[i]!=s[n//2+i]:
      print(No)
      break
    elif i==n//2:
      print(Yes)

n=int(input())
s=input()
if n%2==1:
  print("No")
else:
  for i in range(n//2):
    if s[i]!=s[n//2+i]:
      print("No")
      break
    elif i==n//2-1:
      print("Yes")

Verdicts: Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):

N=int(input())
S=input()
if S[:N//2]==S[N//2+1:] and N%2==0:
  print("Yes")
else:
  print("No")


n=int(input())
s=input()
if n%2!=0:
  print("No")
else:
  t1=s[:n//2]
  t2=s[n//2:]
  # print(t1,t2)
  if t1==t2:
    print("Yes")
  else:
    print("No")

Verdicts: Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
n=int(input())
s=input()
if n%2==1:
  print("NO")

n=n//2
if s[:n]==s[n:]:
  print("YES")
else:
  print("NO")
  

n=int(input())
s=input()
if n%2==1:
  print("No")
  exit()

n=n//2
if s[:n]==s[n:]:
  print("Yes")
else:
  print("No")
  


Verdicts: Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
s = input()
s = input()
if (s[:len(s)//2] ==s[len(s)//2:]):
	print("YES")
else:
	print("NO")

s = input()
s = input()
if (s[:len(s)//2] ==s[len(s)//2:]):
	print("Yes")
else:
	print("No")

Verdicts: Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
#!/usr/bin/env python3

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

if len(s) % 2 != 2:
    print("No")
    exit()

len_s = len(s)//2
if s[:len_s] == s[len_s:]:
    print("Yes")
else:
    print("No")


#!/usr/bin/env python3

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

if s[:len(s)//2]*2 == s:
    print("Yes")
else:
    print("No")


Verdicts: Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

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

if len(S) % 2 != 0:
    print("No")
else:
    if S[:(len(S) / 2)] == S[(len(S) / 2) :]:
        print("Yes")
    else:
        print("No")

N = int(input())
S = input()

if len(S) % 2 != 0:
    print("No")
else:
    if S[:(len(S) // 2)] == S[(len(S) // 2) :]:
        print("Yes")
    else:
        print("No")


Verdicts: Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

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

if s[:int(n/2)] == s[int(n/2):]:
    print('yes')
else:
    print('no')

n = int(input ())
s = input()

if s[:int(n/2)] == s[int(n/2):]:
    print("yes")
else:
    print("no")

n = int(input())
s = input()
if s[:int(n/2)] == s[int(n/2):]:
    print('Yes')
else:
    print('No')

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

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

if N % 2 ==1:
  print("No")
else:
  if S[:int(N/2)]==S[int(N/2):]:
    print("Yes")
  else:
    print("No")
 
　　

N = int(input())
S = input()

if N % 2 ==1:
    print("No")
else:
    if S[:int(N/2)]==S[int(N/2):]:
        print("Yes")
    else:
        print("No")
 
　　

N = int(input())
S = input()

if N % 2 ==1:
    print("No")
else:
    if S[:int(N/2)]==S[int(N/2):]:
        print("Yes")
    else:
        print("No")

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
n=int(input())
s=input()
if s(:int(n/2)) == s(int(n/2):):
  print("Yes")
else:
  print("No")

n=int(input())
s=input()
if s[:int(n/2)] == s[int(n/2):]:
  print("Yes")
else:
  print("No")

Verdicts: Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
c=input()
a=input()
b=0
if c%2==1:
  print("No")
else:
  for i in range(c/2):
    if a[i]!=a[i+int(c/2)]:
      b=b+1
  if b==0:
    print("Yes")
  else:
    print("No")

a=input()
b=0
if (len(a))%2==1:
  print("No")
else:
  for i in range(len(a/2)):
    a[i]!=a[i+a/2]:
      b=b+1
  if b==0:
    print("Yes")
  else:
    print("No")

a=input()
b=0
if (len(a))%2==1:
  print("No")
else:
  for i in range(a/2):
    a[i]!=a[i+a/2]:
      b=b+1
  if b==0:
    print("Yes")
  else:
    print("No")

c=input()
c=int(c)
a=input()
b=0
if c%2==1:
  print("No")
else:
  for i in range(int(c/2)):
    if a[i]!=a[i+int(c/2)]:
      b=b+1
  if b==0:
    print("Yes")
  else:
    print("No")

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
N = int(input())
S = input()
if N%2!=0:
  print("No")
else:
  if S[:N//2]*2 == S:print("Ok")
  else : print("No")
                            


N,S = [int(input()) for _ in range(2)]
if N%2!=0:
  print("No")
else:
  print(S[:(N/2-1)])

N = int(input())
S = input()
if N%2!=0:
  print("No")
else:
  if S[:N//2]*2 == S:print("Yes")
  else : print("No")
                            


Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
 = int(input())
s = str(input())
if n%2 == 1:
    print('No')
else:
    if s[:n//2] == s[n//2:]:
        print('Yes')
    else:
        print('No')

n = int(input())
s = str(input())
if n%2 == 1:
    print('No')
else:
    if s[:n//2] == s[n//2:]:
        print('Yes')
    else:
        print('No')

Verdicts: Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

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

s_length = len(s)

if s[: s_length // 2] == s[s_length // 2]:
  print('Yes')
else:
  print('No')

n = int(input())
s = input()

s_length = len(s)

if s[: s_length // 2] == s[s_length // 2]:
  print('Yes')
else:
  print('No')

n = int(input())
s = input()

s_length = len(s)

if s[: s_length // 2] == s[s_length // 2:]:
  print('Yes')
else:
  print('No')

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
N = input()
S = input()
if S[:N]==S[N:]:
  print("Yes")
else:
  print("No")

N = int(input())
S = input()
if S[:N//2]==S[N//2:]:
  print("Yes")
else:
  print("No")

Verdicts: Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
N=int(input())
S=str(input())
if N%2!=0:
  print('No')
elif S[0:N/2-1]==S[N/2:N-1]:
  print('Yes')
else:
  print('No')

N=int(input())
S=str(input())
if N%2!=0:
  print('No')
elif S[0:round(N/2)]==S[round(N/2):N]:
  print('Yes')
else:
  print('No')

Verdicts: Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
n = int(input())
s = input()
if(n&1):
  print("No")
else:
  for i in range(n/2):
    if s[i]!=s[n+i]:
      print("No")
      break
  else:
    print("Yes")

n = int(input())
s = input()
if(n&1):
  print("No")
else:
  if(s[:n//2]==s[n//2:]):
    print("Yes")
  else:
    print("No")

Verdicts: Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
N = int(input())
S = input()
if N%2==1:
    print('No')
else:
    for i in range(N//2):
        S1 += S[i]
    for j in range(N//2,N):
        S2 += S[j]
    if S1==S2:
        print('Yes')
    else:
        print('No')

N = int(input())
S = input()
S1 = ''
S2 = ''
if N%2==1:
    print('No')
else:
    for i in range(N//2):
        S1 += S[i]
    for j in range(N//2,N):
        S2 += S[j]
    if S1==S2:
        print('Yes')
    else:
        print('No')

Verdicts: Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
n = int(input)
moji = input()
res = 'Yes'
if n % 2 == 1:res = 'No'
else:
  for i in range(len(n/2)):
    if moji[i] != moji[n/2+1]:
      res = 'No'
      
print(res)

n = int(input())
moji = input()
res = 'Yes'
if n % 2 == 1:
    res = 'No'
else:
    for i in range(int(n/2)):
        if moji[i] != moji[int(n/2)+1]:
            res = 'No'
            break
      
print(res)


n = int(input())
moji = input()
res = 'Yes'
if n % 2 == 1:
    res = 'No'
else:
    for i in range(int(n/2)):
        if moji[i] != moji[int(n/2)+i]:
            res = 'No'
            break
      
print(res)


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

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

if N%2==1:
    print ('No')
    exit()

S1 = S[0:N//2]
print (S1)
if S == S1+S1:
    print ('Yes')
else:
    print('No')



N = int(input())
S = input()

if N%2==1:
    print ('No')
    exit()

S1 = S[0:N]
if S == S[0:N]+S[0:N]:
    print ('Yes')
else:
    print('No')



N = int(input())
S = input()

S1 = substr(S, 0, N)
if S == S1+S1:
    print ('Yes')
else:
    print('No')



N = int(input())
S = input()

S1 = S[0:N]
if S == S1+S1:
    print ('Yes')
else:
    print('No')


N = int(input())
S = input()

if N%2==1:
    print ('No')
    exit()

if S[:N//2] == S[N//2:]:
    print ('Yes')
else:
    print('No')



Verdicts: Wrong Answer

Wrong Answer

Runtime Error

Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
from collections import Counter
a = input()
c1 = Counter(a)
flag = False
for i,j in c1.items():
  if(len(set(j))==1:
     flag=True
  else:
     flag= False
if(flag):
     print('Yes')
else:
     print('No')

size = int(input())
a = input()
if a[0:size//2] == a[size//2:]:
    print('Yes')
else:
    print('No')

Verdicts: Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

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

if N % 2 == 1:
  print("No")
else:
  half = N/2
  ans = "Yes"
  for i in range(half):
    if S[i] != S[i+half]:
      ans = "No"
      break
  print(ans)

N = int(input())
S = input()

if N % 2 == 1:
  print("No")
else:
  half = int(N/2)
  ans = "Yes"
  for i in range(half):
    if S[i] != S[i+half]:
      ans = "No"
      break
  print(ans)


Verdicts: Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
n = int(input())
s = input()
if n//2: print("No")
else:
  if s[:n//2] == s[n//2:]:
    print("Yes")
  else:
    print("No")

n = int(input())
s = input()
if n%2: print("No")
else:
    if s[:n//2] == s[n//2:]:
        print("Yes")
    else:
        print("No")

Verdicts: Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):


n = int(input())
s = input()

if n < 2:
   print("No")
   
if n // 2 != 0:
   print("No")

else:
   t_num = int(n / 2)

   t = s[:t_num]

   if t * 2 == s:
      print("Yes")
   else:
      print("No")


n = int(input())
s = input()

t_num = int(n / 2)

t = s[:t_num]

if t * 2 == s:
   print("Yes")
else:
   print("No")



Verdicts: Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
N = int(input())
S = input()
if S[:int(N/2):] == S[int(N/2)+1::]:
    print("Yes")
else:
    print("No")

N = int(input())
S = input()
if S[:int(N/2):] == S[int(N/2)::]:
    print("Yes")
else:
    print("No")

Verdicts: Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
N=int(input())
if N%2==1:
  print(No)
  
else:
  s=input()
  b=N//2
  s=0
  for i in range (0,b):
    if s[i]==s[i+b]:
      s=s
    else:
      s=s+1
  if s==0:
    print(Yes)
  else:
    print(No)

N=int(input())
if N%2==1:
  print("No")
  
else:
  s=input()
  b=N//2
  t=0
  for i in range (0,b):
    if s[i]==s[i+b]:
      t=t
    else:
      t=t+1
  if t==0:
    print("Yes")
  else:
    print("No")

Verdicts: Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
n = int(input())
s = input()
ans = "No"
if n % 2 == 0:
    ans = "Yes"
    for i in range(n / 2):
        if s[i] != s[n / 2 + i]:
            ans = "No"
            break
print(ans)


n = int(input())
s = input()
ans = "No"
if n % 2 == 0:
    if s[0:n / 2] == s[n / 2:]:
        ans = "Yes"
print(ans)

n = int(input())
s = input()
ans = "No"
if n % 2 == 0:
    ans = "Yes"
    for i in range(n // 2):
        if s[i] != s[n // 2 + i]:
            ans = "No"
            break
print(ans)


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

Submission attempts (in order):
n=int(input())
s=input()
if n%2==1:
  print(No)
  exit(0)
if s[:i//2]==s[i//2:]:
  print('Yes')
  exit(0)
print('No')
  

# ABC145b


def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**6)

    # map(int,input().split())
    n = int(input())
    s = input()[:-1]
    print('Yes' if s[:n//2] == s[n//2:] else 'No')


if __name__ == '__main__':
    main()

Verdicts: Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

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


if n%2!=0:
    print('NO')
else:

    if s[:int(n/2)] == s[int(n/2):]:
        print('YES')
    else:
        print('NO')

n = int(input())
s=input()


if n%2!=0:
    print('No')
else:

    if s[:int(n/2)] == s[int(n/2):]:
        print('Yes')
    else:
        print('No')

Verdicts: Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

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

if (a/2)%2==1:
  print('No')
elif:
  if b[0:int(a/2)]==b[int(a/2):]:
    print('Yes')
  else:
    print('No')

a = int(input())
b = str(input())
 
if (a/2)%2==1:
  print('No')
elif: b[0:int(a/2)]==b[int(a/2):]:
    print('Yes')
else:
  print('No')

a = int(input())
b = str(input())
 
if (a%2)==1:
  print('No')
elif b[0:int(a/2)]==b[int(a/2):]:
    print('Yes')
else:
  print('No')
  

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

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


if N < 2 or N % 2 != 0:
    print("No")

if N == 2:
    right = S[0]
    left = S[1]
else:
    c = N // 2
    right = S[0:c]
    left = S[c:]

print(f"{right} {left}")

if right == left:
    print("Yes")
else:
    print("No")

# input 
N = int(input())
S = input()


if N < 2 or N % 2 != 0:
    print("No")

if N == 2:
    right = S[0]
    left = S[1]
else:
    c = N // 2
    right = S[0:c - 1]
    left = S[c:]

if right == left:
    print("Yes")
else:
    print("No")

# input
N = int(input())
S = input()


if N < 2 or N % 2 != 0:
    print("No")
else:
    if N == 2:
        right = S[0]
        left = S[1]
    else:
        c = N // 2
        right = S[0:c]
        left = S[c:]

    if right == left:
        print("Yes")
    else:
        print("No")

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: Given are a positive integer N and a string S of length N consisting of lowercase English letters.  Determine whether the string is a concatenation of two copies of some string. That is, determine whether there is a string T such that S = T + T.

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


if(n%2==1):
  print('No')
  exit()

else:  
   
    
    if s[0:n//2]==s[(n//2)+1:n]:
     	print('Yes')
    else:
      print("No")
    

n=int(input())
s=input()


if(n%2==1):
  print('No')

else:  
   
    
    if s[0:n//2]==s[(n//2)+1:n]:
     	print('Yes')
    else:
      print("No")
    

n=int(input())
s=input()

if(n%2==1):
    print('No')
    exit()

else:  
   
    if s[0:n//2]==s[(n//2)+1:n]:
     	print('Yes')
    else:
        print("No")
    

n=int(input())
s=input()


if(n%2==1):
  print('No')

else:  
   
    
    if s[0:n//2]==s[(n//2)+1:n]:
    print('Yes')
    else:
      print("No")
    

        
     

n=int(input())
s=input()

if(n%2==1):
    print('No')
    exit()

else:  
   
    if s[0:n//2]==s[(n//2):n]:
     	print('Yes')
    else:
        print("No")
    

Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Runtime Error

Accepted