Problem:
Score : 200 points

Problem Statement

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.

Constraints

1 \leq N \leq 100

S consists of lowercase English letters.

|S| = N

Input

Input is given from Standard Input in the following format:

N
S

Output

If S is a concatenation of two copies of some string, print Yes; otherwise, print No.

Sample Input 1

6
abcabc

Sample Output 1

Yes

Let T = abc, and S = T + T.

Sample Input 2

6
abcadc

Sample Output 2

No

Sample Input 3

1
z

Sample Output 3

No

Solution in C# (Mono 4.6.2.0) (judge verdict: Accepted)

//author: camypaper
using System;
using System.Linq;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using Debug = System.Diagnostics.Debug;
using SB = System.Text.StringBuilder;
using System.Numerics;
using Point = System.Numerics.Complex;
using static System.Math;
using Number = System.Int64;
using System.Runtime.CompilerServices;

namespace Program {
    public class Solver {
        Random rnd = new Random(0);
        public void Solve() {
            var n = ri;
            var s = rs;
            var t = s.Substring(0, n / 2);
            if (s == t + t) Console.WriteLine("Yes");
            else Console.WriteLine("No");
        }
        const long INF = 1L << 60;
        int ri => sc.Integer();
        long rl => sc.Long();
        double rd => sc.Double();
        string rs => sc.Scan();
        public IO.StreamScanner sc = new IO.StreamScanner(Console.OpenStandardInput());

        static IEnumerable<int> Rep(int n) => Enumerable.Range(0, n);
        static IEnumerable<int> RRep(int n) => Enumerable.Range(0, n).Reverse();
        static T[] Enumerate<T>(int n, Func<int, T> f) {
            var a = new T[n];
            for (int i = 0; i < a.Length; ++i) a[i] = f(i);
            return a;
        }
        static public void Swap<T>(ref T a, ref T b) { var tmp = a; a = b; b = tmp; }
    }
}

#region main
static class Ex {
    static public string AsString(this IEnumerable<char> ie) { return new string(ie.ToArray()); }
    static public string AsJoinedString<T>(this IEnumerable<T> ie, string st = " ") {
        return string.Join(st, ie);
    }
    static public void Main() {
        Console.SetOut(new Program.IO.Printer(Console.OpenStandardOutput()) { AutoFlush = false });
        var solver = new Program.Solver();
        solver.Solve();
        Console.Out.Flush();
    }
}
#endregion
#region Ex
namespace Program.IO {
    using System.IO;
    using System.Text;
    using System.Globalization;

    public class Printer : StreamWriter {
        public override IFormatProvider FormatProvider => CultureInfo.InvariantCulture;
        public Printer(Stream stream) : base(stream, new UTF8Encoding(false, true)) { }
    }

    public class StreamScanner {
        public StreamScanner(Stream stream) { str = stream; }

        public readonly Stream str;
        private readonly byte[] buf = new byte[1024];
        private int len, ptr;
        public bool isEof = false;

        private byte read() {
            if (isEof) return 0;
            if (ptr >= len) {
                ptr = 0;
                if ((len = str.Read(buf, 0, 1024)) <= 0) {
                    isEof = true;
                    return 0;
                }
            }
            return buf[ptr++];
        }

        public char Char() {
            byte b = 0;
            do b = read(); while ((b < 33 || 126 < b) && !isEof);
            return (char)b;
        }
        public string Scan() {
            var sb = new StringBuilder();
            for (var b = Char(); b >= 33 && b <= 126; b = (char)read()) sb.Append(b);
            return sb.ToString();
        }
        public string ScanLine() {
            var sb = new StringBuilder();
            for (var b = Char(); b != '\n' && b != 0; b = (char)read()) if (b != '\r') sb.Append(b);
            return sb.ToString();
        }
        public long Long() { return isEof ? long.MinValue : long.Parse(Scan()); }
        public int Integer() { return isEof ? int.MinValue : int.Parse(Scan()); }
        public double Double() { return isEof ? double.NaN : double.Parse(Scan(), CultureInfo.InvariantCulture); }
    }
}

#endregion

#region Set<T>
public class Set<T>
    where T : IComparable<T> {

    Node root = Node.NIL;

    public int Count { get { return root.cnt; } }
    public void Add(T v) { Insert(v, LowerBound(v)); }
    public bool Remove(T v) {
        if (EqualRange(v) == 0) return false;
        RemoveAt(LowerBound(v));
        return true;
    }
    #region Impl
    public void Insert(T v, int k) {
        root = insert(root, v, k);
    }
    public void RemoveAt(int k) {
        root = removeat(root, k);
    }
    public int EqualRange(T v) { return UpperBound(v) - LowerBound(v); }
    public int LowerBound(T v) { return lowerBound(root, v); }
    public int UpperBound(T v) { return upperBound(root, v); }
    public T this[int k] { get { return find(root, k); } }
    Node insert(Node t, T v, int k) {
        Debug.Assert(t.cnt >= k);
        if (t == Node.NIL) return new Node(v);
        if (t.lst.cnt >= k)
            t.lst = insert(t.lst, v, k);
        else
            t.rst = insert(t.rst, v, k - t.lst.cnt - 1);
        t.Update();

        if (t.lst.h - t.rst.h == -2) {
            if (t.rst.lst.h - t.rst.rst.h > 0) t.rst = rotR(t.rst);
            t = rotL(t);
        }
        else if (t.lst.h - t.rst.h == 2) {
            if (t.lst.lst.h - t.lst.rst.h < 0) t.lst = rotL(t.lst);
            t = rotR(t);
        }
        t.Update();
        return t;
    }
    Node removeat(Node t, int k) {
        Debug.Assert(t.cnt > k);
        var cnt = t.lst.cnt;
        if (cnt < k) t.rst = removeat(t.rst, k - cnt - 1);
        else if (cnt > k) t.lst = removeat(t.lst, k);
        else {
            if (cnt == 0) return t.rst;
            if (t.rst.cnt == 0) return t.lst;

            t.val = find(t, k - 1);
            t.lst = removeat(t.lst, k - 1);
        }
        t.Update();
        if (t.lst.h - t.rst.h == -2) {
            if (t.rst.lst.h - t.rst.rst.h > 0) t.rst = rotR(t.rst);
            t = rotL(t);
        }
        else if (t.lst.h - t.rst.h == 2) {
            if (t.lst.lst.h - t.lst.rst.h < 0) t.lst = rotL(t.lst);
            t = rotR(t);
        }
        else t.Update();
        return t;
    }

    int lowerBound(Node t, T v) {
        if (t.cnt == 0) return 0;
        if (v.CompareTo(t.val) <= 0) return lowerBound(t.lst, v);
        else return t.lst.cnt + 1 + lowerBound(t.rst, v);
    }
    int upperBound(Node t, T v) {
        if (t.cnt == 0) return 0;
        if (t.val.CompareTo(v) <= 0) return t.lst.cnt + 1 + upperBound(t.rst, v);
        else return upperBound(t.lst, v);
    }
    T find(Node t, int k) {
        Debug.Assert(k < t.cnt);
        if (k == t.lst.cnt) return t.val;
        else if (k < t.lst.cnt) return find(t.lst, k);
        else return find(t.rst, k - (t.lst.cnt + 1));
    }
    Node rotR(Node t) {
        var l = t.lst;
        var lr = l.rst;
        l.rst = t;
        t.lst = lr;
        t.Update();
        l.Update();
        return l;
    }
    Node rotL(Node t) {
        var r = t.rst;
        var rl = r.lst;
        t.rst = rl;
        r.lst = t;
        t.Update();
        r.Update();
        return r;
    }
    #endregion
    class Node {
        static public readonly Node NIL = new Node();
        public int h;
        public int cnt;
        internal T val;
        internal Node lst, rst;
        private Node() { }
        internal Node(T v) { h = 1; cnt = 1; val = v; lst = NIL; rst = NIL; }
        public void Update() {
            if (cnt == 0) return;
            h = 1 + Math.Max(lst.h, rst.h);
            cnt = 1 + lst.cnt + rst.cnt;
        }
        public override string ToString() {
            return string.Format("count:{0}, value:{1}", cnt, val);
        }
        public T[] Items { get { return items(this); } }
        static public T[] items(Node t) {
            var ret = new T[t.cnt];
            var ptr = 0;
            dfs(t, ref ptr, ret);
            return ret;
        }
        static void dfs(Node t, ref int ptr, T[] ret) {
            if (t == Node.NIL) return;
            dfs(t.lst, ref ptr, ret);
            ret[ptr++] = t.val;
            dfs(t.rst, ref ptr, ret);
        }
    }
    public T[] Items { get { return root.Items; } }
    public override string ToString() { return string.Format("Count = {0}", Count); }

}
#endregion