node_ids
listlengths 4
1.4k
| edge_index
listlengths 1
2.22k
| text
listlengths 4
1.4k
| source
stringlengths 14
427k
|
|---|---|---|---|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
2,
4,
13,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
13,
13,
14,
2,
18,
13,
39,
13,
18,
13,
39,
13,
0,
13,
2,
2,
4,
13,
18,
13,
39,
13,
4,
13,
18,
13,
39,
13,
13,
3,
0,
13,
17,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13
] |
[
[
87,
2
],
[
75,
8
],
[
93,
12
],
[
81,
16
],
[
76,
20
],
[
94,
23
],
[
72,
25
],
[
29,
28
],
[
88,
31
],
[
78,
33
],
[
88,
35
],
[
28,
36
],
[
76,
40
],
[
94,
44
],
[
84,
48
],
[
76,
54
],
[
94,
60
],
[
73,
63
],
[
91,
63
],
[
90,
66
],
[
85,
70
],
[
82,
70
],
[
72,
73
],
[
75,
76
],
[
78,
79
],
[
81,
82
],
[
84,
85
],
[
87,
88
],
[
90,
91
],
[
93,
94
]
] |
[
"n = int(input())\ns = input()\nt = input()\nans = len(s) + len(t)\nc= 0\nfor i in range(n):\n j = n-i\n if s[i:] == t[:j]:\n ans = len(s[i:]) + len(t[:i]) + c\n break\n else:\n c+=1\nprint(ans)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"ans = len(s) + len(t)",
"ans",
"len(s) + len(t)",
"len(s)",
"len",
"s",
"len(t)",
"len",
"t",
"c= 0",
"c",
"0",
"for i in range(n):\n j = n-i\n if s[i:] == t[:j]:\n ans = len(s[i:]) + len(t[:i]) + c\n break\n else:\n c+=1",
"i",
"range(n)",
"range",
"n",
"j = n-i",
"j",
"n-i",
"n",
"i",
"if s[i:] == t[:j]:\n ans = len(s[i:]) + len(t[:i]) + c\n break\n else:\n c+=1",
"s[i:] == t[:j]",
"s[i:]",
"s",
"i:",
"i",
"t[:j]",
"t",
":j",
"j",
"ans = len(s[i:]) + len(t[:i]) + c",
"ans",
"len(s[i:]) + len(t[:i]) + c",
"len(s[i:]) + len(t[:i])",
"len(s[i:])",
"len",
"s[i:]",
"s",
"i:",
"i",
"len(t[:i])",
"len",
"t[:i]",
"t",
":i",
"i",
"c",
"break",
"c+=1",
"c",
"1",
"print(ans)",
"print",
"ans",
"c= 0",
"0",
"c",
"s = input()",
"input()",
"s",
"j = n-i",
"n-i",
"j",
"ans = len(s) + len(t)",
"len(s) + len(t)",
"ans",
"ans = len(s[i:]) + len(t[:i]) + c",
"len(s[i:]) + len(t[:i]) + c",
"ans",
"n = int(input())",
"int(input())",
"n",
"c+=1",
"1",
"c",
"t = input()",
"input()",
"t"
] |
n = int(input())
s = input()
t = input()
ans = len(s) + len(t)
c= 0
for i in range(n):
j = n-i
if s[i:] == t[:j]:
ans = len(s[i:]) + len(t[:i]) + c
break
else:
c+=1
print(ans)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
14,
2,
13,
13,
4,
13,
13,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
2,
13,
18,
13,
39,
40,
13,
14,
2,
18,
13,
39,
40,
13,
13,
3,
4,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13
] |
[
[
67,
2
],
[
58,
8
],
[
61,
14
],
[
59,
21
],
[
62,
22
],
[
68,
25
],
[
28,
27
],
[
68,
32
],
[
64,
35
],
[
59,
37
],
[
62,
39
],
[
27,
42
],
[
65,
46
],
[
68,
49
],
[
62,
50
],
[
65,
56
],
[
58,
59
],
[
61,
62
],
[
64,
65
],
[
67,
68
]
] |
[
"n=int(input())\ns=str(input())\nt=str(input())\n \nif s==t:\n print(n)\nelse:\n for i in range(1,n+1):\n x = s + t[-i:]\n if x[-n:] == t:\n break\n print(len(x))",
"n=int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s=str(input())",
"s",
"str(input())",
"str",
"input()",
"input",
"t=str(input())",
"t",
"str(input())",
"str",
"input()",
"input",
"if s==t:\n print(n)\nelse:\n for i in range(1,n+1):\n x = s + t[-i:]\n if x[-n:] == t:\n break\n print(len(x))",
"s==t",
"s",
"t",
"print(n)",
"print",
"n",
"for i in range(1,n+1):\n x = s + t[-i:]\n if x[-n:] == t:\n break\n ",
"i",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"x = s + t[-i:]",
"x",
"s + t[-i:]",
"s",
"t[-i:]",
"t",
"-i:",
"-i",
"i",
"if x[-n:] == t:\n break\n ",
"x[-n:] == t",
"x[-n:]",
"x",
"-n:",
"-n",
"n",
"t",
"break",
"print(len(x))",
"print",
"len(x)",
"len",
"x",
"s=str(input())",
"str(input())",
"s",
"t=str(input())",
"str(input())",
"t",
"x = s + t[-i:]",
"s + t[-i:]",
"x",
"n=int(input())",
"int(input())",
"n"
] |
n=int(input())
s=str(input())
t=str(input())
if s==t:
print(n)
else:
for i in range(1,n+1):
x = s + t[-i:]
if x[-n:] == t:
break
print(len(x))
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
2,
13,
13,
0,
13,
13,
28,
13,
4,
13,
13,
14,
2,
18,
13,
39,
13,
18,
13,
39,
13,
0,
13,
2,
13,
18,
13,
39,
13,
3,
0,
13,
17,
4,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13
] |
[
[
62,
2
],
[
71,
8
],
[
56,
12
],
[
59,
16
],
[
72,
18
],
[
57,
19
],
[
74,
21
],
[
63,
22
],
[
25,
24
],
[
63,
27
],
[
72,
31
],
[
57,
35
],
[
65,
39
],
[
72,
41
],
[
57,
43
],
[
68,
48
],
[
66,
54
],
[
60,
54
],
[
56,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
],
[
63,
74
],
[
74,
75
]
] |
[
"#!/usr/bin/env python3\n\nN = int(input())\nS = input()\nT = input()\n\n\nans = S + T\nend = N\nfor i in range(N):\n if S[i:] == T[:end]:\n ans = S + T[end:]\n break\n\n end -= 1\n\nprint(len(ans))",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"S = input()",
"S",
"input()",
"input",
"T = input()",
"T",
"input()",
"input",
"ans = S + T",
"ans",
"S + T",
"S",
"T",
"end = N",
"end",
"N",
"for i in range(N):\n if S[i:] == T[:end]:\n ans = S + T[end:]\n break\n\n end -= 1",
"i",
"range(N)",
"range",
"N",
"if S[i:] == T[:end]:\n ans = S + T[end:]\n break\n\n ",
"S[i:] == T[:end]",
"S[i:]",
"S",
"i:",
"i",
"T[:end]",
"T",
":end",
"end",
"ans = S + T[end:]",
"ans",
"S + T[end:]",
"S",
"T[end:]",
"T",
"end:",
"end",
"break",
"end -= 1",
"end",
"1",
"print(len(ans))",
"print",
"len(ans)",
"len",
"ans",
"T = input()",
"input()",
"T",
"ans = S + T",
"S + T",
"ans",
"N = int(input())",
"int(input())",
"N",
"ans = S + T[end:]",
"S + T[end:]",
"ans",
"end -= 1",
"1",
"end",
"S = input()",
"input()",
"S",
"end = N",
"N",
"end"
] |
#!/usr/bin/env python3
N = int(input())
S = input()
T = input()
ans = S + T
end = N
for i in range(N):
if S[i:] == T[:end]:
ans = S + T[end:]
break
end -= 1
print(len(ans))
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
28,
13,
4,
13,
13,
28,
13,
13,
4,
13,
18,
13,
39,
2,
13,
13,
14,
2,
18,
13,
2,
13,
13,
13,
9,
3,
4,
13,
2,
13,
13,
3,
4,
13,
2,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
53,
2
],
[
59,
8
],
[
56,
12
],
[
17,
16
],
[
54,
19
],
[
57,
26
],
[
54,
29
],
[
16,
30
],
[
60,
34
],
[
16,
37
],
[
54,
44
],
[
16,
45
],
[
54,
51
],
[
53,
54
],
[
56,
57
],
[
59,
60
]
] |
[
"N = int(input())\nS = input()\nT = input()\n\nfor i in range(N):\n for j, t in enumerate(T[:N-i]):\n if S[j+i] == t:\n continue\n else:\n break\n else:\n print(N+i)\n break\nelse:\n print(2*N)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"S = input()",
"S",
"input()",
"input",
"T = input()",
"T",
"input()",
"input",
"for i in range(N):\n for j, t in enumerate(T[:N-i]):\n if S[j+i] == t:\n continue\n else:\n break\n else:\n print(N+i)\n break\nelse:\n print(2*N)",
"i",
"range(N)",
"range",
"N",
"for j, t in enumerate(T[:N-i]):\n if S[j+i] == t:\n continue\n else:\n break\n else:\n print(N+i)\n break",
"j",
"t",
"enumerate(T[:N-i])",
"enumerate",
"T[:N-i]",
"T",
":N-i",
"N-i",
"N",
"i",
"if S[j+i] == t:\n continue\n else:\n break\n ",
"S[j+i] == t",
"S[j+i]",
"S",
"j+i",
"j",
"i",
"t",
"continue",
"break",
"print(N+i)",
"print",
"N+i",
"N",
"i",
"break",
"print(2*N)",
"print",
"2*N",
"2",
"N",
"N = int(input())",
"int(input())",
"N",
"T = input()",
"input()",
"T",
"S = input()",
"input()",
"S"
] |
N = int(input())
S = input()
T = input()
for i in range(N):
for j, t in enumerate(T[:N-i]):
if S[j+i] == t:
continue
else:
break
else:
print(N+i)
break
else:
print(2*N)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
17,
0,
13,
17,
14,
2,
13,
13,
4,
13,
13,
4,
13,
28,
13,
4,
13,
17,
13,
0,
13,
18,
13,
39,
13,
0,
13,
18,
13,
39,
40,
13,
14,
2,
13,
13,
4,
13,
2,
2,
17,
13,
4,
13,
13,
4,
13,
4,
13,
2,
13,
17,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13,
10,
4,
13,
10,
18,
13
] |
[
[
76,
2
],
[
85,
8
],
[
70,
12
],
[
73,
16
],
[
79,
19
],
[
86,
23
],
[
71,
24
],
[
77,
27
],
[
32,
31
],
[
77,
35
],
[
88,
37
],
[
86,
39
],
[
82,
43
],
[
71,
45
],
[
31,
48
],
[
89,
51
],
[
83,
52
],
[
77,
58
],
[
89,
61
],
[
77,
67
],
[
70,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
]
] |
[
"n=int(input())\ns=input()\nt=input()\nflg=True\ntmp=0\nif s==t:\n print(n)\n exit()\nfor i in range(1,n):\n ss=s[i:]\n tt=t[:-i]\n if ss==tt:\n print(2*n-len(ss))\n exit()\nprint(n*2)",
"n=int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s=input()",
"s",
"input()",
"input",
"t=input()",
"t",
"input()",
"input",
"flg=True",
"flg",
"True",
"tmp=0",
"tmp",
"0",
"if s==t:\n print(n)\n exit()",
"s==t",
"s",
"t",
"print(n)",
"print",
"n",
"exit()",
"exit",
"for i in range(1,n):\n ss=s[i:]\n tt=t[:-i]\n if ss==tt:\n print(2*n-len(ss))\n exit()",
"i",
"range(1,n)",
"range",
"1",
"n",
"ss=s[i:]",
"ss",
"s[i:]",
"s",
"i:",
"i",
"tt=t[:-i]",
"tt",
"t[:-i]",
"t",
":-i",
"-i",
"i",
"if ss==tt:\n print(2*n-len(ss))\n exit()",
"ss==tt",
"ss",
"tt",
"print(2*n-len(ss))",
"print",
"2*n-len(ss)",
"2*n",
"2",
"n",
"len(ss)",
"len",
"ss",
"exit()",
"exit",
"print(n*2)",
"print",
"n*2",
"n",
"2",
"t=input()",
"input()",
"t",
"flg=True",
"True",
"flg",
"n=int(input())",
"int(input())",
"n",
"tmp=0",
"0",
"tmp",
"tt=t[:-i]",
"t[:-i]",
"tt",
"s=input()",
"input()",
"s",
"ss=s[i:]",
"s[i:]",
"ss"
] |
n=int(input())
s=input()
t=input()
flg=True
tmp=0
if s==t:
print(n)
exit()
for i in range(1,n):
ss=s[i:]
tt=t[:-i]
if ss==tt:
print(2*n-len(ss))
exit()
print(n*2)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
17,
14,
2,
18,
13,
2,
2,
13,
13,
17,
18,
13,
17,
28,
13,
4,
13,
2,
2,
13,
13,
17,
14,
2,
18,
13,
2,
2,
13,
17,
13,
18,
13,
2,
2,
2,
13,
13,
17,
13,
9,
0,
13,
17,
14,
2,
13,
17,
4,
13,
4,
13,
2,
13,
18,
13,
39,
2,
13,
13,
3,
0,
13,
17,
14,
2,
13,
17,
4,
13,
4,
13,
2,
13,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13
] |
[
[
111,
2
],
[
114,
8
],
[
120,
14
],
[
108,
20
],
[
24,
23
],
[
112,
26
],
[
123,
28
],
[
121,
33
],
[
112,
36
],
[
23,
37
],
[
115,
40
],
[
44,
43
],
[
112,
48
],
[
23,
49
],
[
115,
54
],
[
112,
57
],
[
43,
59
],
[
121,
61
],
[
112,
65
],
[
23,
66
],
[
43,
68
],
[
105,
71
],
[
106,
75
],
[
124,
75
],
[
109,
75
],
[
118,
75
],
[
115,
82
],
[
121,
84
],
[
112,
87
],
[
23,
88
],
[
117,
91
],
[
118,
95
],
[
106,
95
],
[
124,
95
],
[
109,
95
],
[
115,
102
],
[
121,
103
],
[
105,
106
],
[
108,
109
],
[
111,
112
],
[
114,
115
],
[
117,
118
],
[
120,
121
],
[
123,
124
]
] |
[
"n = int(input())\ns = list(input())\nt = list(input())\n\n\nans = 0\nfor i in range(n):\n ans = 0\n if t[n - i - 1] == s[-1]:\n for j in range(n - i - 1):\n if s[n - 1 - j] == t[n - i - 1 - j]:\n continue\n else:\n ans = 1\n if ans == 0:\n print(len(s + t[n - i :]))\n break\n else:\n ans = 1\nif ans == 1:\n print(len(s + t))",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = list(input())",
"s",
"list(input())",
"list",
"input()",
"input",
"t = list(input())",
"t",
"list(input())",
"list",
"input()",
"input",
"ans = 0",
"ans",
"0",
"for i in range(n):\n ans = 0\n if t[n - i - 1] == s[-1]:\n for j in range(n - i - 1):\n if s[n - 1 - j] == t[n - i - 1 - j]:\n continue\n else:\n ans = 1\n if ans == 0:\n print(len(s + t[n - i :]))\n break\n else:\n ans = 1",
"i",
"range(n)",
"range",
"n",
"ans = 0",
"ans",
"0",
"if t[n - i - 1] == s[-1]:\n for j in range(n - i - 1):\n if s[n - 1 - j] == t[n - i - 1 - j]:\n continue\n else:\n ans = 1\n if ans == 0:\n print(len(s + t[n - i :]))\n break\n else:\n ans = 1",
"t[n - i - 1] == s[-1]",
"t[n - i - 1]",
"t",
"n - i - 1",
"n - i",
"n",
"i",
"1",
"s[-1]",
"s",
"-1",
"for j in range(n - i - 1):\n if s[n - 1 - j] == t[n - i - 1 - j]:\n continue\n else:\n ans = 1\n ",
"j",
"range(n - i - 1)",
"range",
"n - i - 1",
"n - i",
"n",
"i",
"1",
"if s[n - 1 - j] == t[n - i - 1 - j]:\n continue\n else:\n ans = 1\n ",
"s[n - 1 - j] == t[n - i - 1 - j]",
"s[n - 1 - j]",
"s",
"n - 1 - j",
"n - 1",
"n",
"1",
"j",
"t[n - i - 1 - j]",
"t",
"n - i - 1 - j",
"n - i - 1",
"n - i",
"n",
"i",
"1",
"j",
"continue",
"ans = 1",
"ans",
"1",
"if ans == 0:\n print(len(s + t[n - i :]))\n break\n ",
"ans == 0",
"ans",
"0",
"print(len(s + t[n - i :]))",
"print",
"len(s + t[n - i :])",
"len",
"s + t[n - i :]",
"s",
"t[n - i :]",
"t",
"n - i :",
"n - i",
"n",
"i",
"break",
"ans = 1",
"ans",
"1",
"if ans == 1:\n print(len(s + t))",
"ans == 1",
"ans",
"1",
"print(len(s + t))",
"print",
"len(s + t)",
"len",
"s + t",
"s",
"t",
"ans = 1",
"1",
"ans",
"ans = 0",
"0",
"ans",
"n = int(input())",
"int(input())",
"n",
"s = list(input())",
"list(input())",
"s",
"ans = 1",
"1",
"ans",
"t = list(input())",
"list(input())",
"t",
"ans = 0",
"0",
"ans"
] |
n = int(input())
s = list(input())
t = list(input())
ans = 0
for i in range(n):
ans = 0
if t[n - i - 1] == s[-1]:
for j in range(n - i - 1):
if s[n - 1 - j] == t[n - i - 1 - j]:
continue
else:
ans = 1
if ans == 0:
print(len(s + t[n - i :]))
break
else:
ans = 1
if ans == 1:
print(len(s + t))
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
18,
13,
39,
2,
2,
13,
13,
17,
18,
13,
39,
2,
13,
17,
0,
13,
2,
13,
17,
4,
13,
2,
2,
13,
17,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13
] |
[
[
64,
2
],
[
61,
8
],
[
55,
12
],
[
52,
16
],
[
20,
19
],
[
65,
22
],
[
62,
26
],
[
65,
30
],
[
19,
31
],
[
56,
34
],
[
19,
37
],
[
58,
40
],
[
19,
42
],
[
65,
48
],
[
59,
50
],
[
53,
50
],
[
52,
53
],
[
55,
56
],
[
58,
59
],
[
61,
62
],
[
64,
65
]
] |
[
"N=int(input())\ns=input()\nt=input()\ncount=0\nfor i in range(N):\n if s[N-i-1:]==t[:i+1]:\n count=i+1\nprint(N*2-count)",
"N=int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s=input()",
"s",
"input()",
"input",
"t=input()",
"t",
"input()",
"input",
"count=0",
"count",
"0",
"for i in range(N):\n if s[N-i-1:]==t[:i+1]:\n count=i+1",
"i",
"range(N)",
"range",
"N",
"if s[N-i-1:]==t[:i+1]:\n count=i+1",
"s[N-i-1:]==t[:i+1]",
"s[N-i-1:]",
"s",
"N-i-1:",
"N-i-1",
"N-i",
"N",
"i",
"1",
"t[:i+1]",
"t",
":i+1",
"i+1",
"i",
"1",
"count=i+1",
"count",
"i+1",
"i",
"1",
"print(N*2-count)",
"print",
"N*2-count",
"N*2",
"N",
"2",
"count",
"count=0",
"0",
"count",
"t=input()",
"input()",
"t",
"count=i+1",
"i+1",
"count",
"s=input()",
"input()",
"s",
"N=int(input())",
"int(input())",
"N"
] |
N=int(input())
s=input()
t=input()
count=0
for i in range(N):
if s[N-i-1:]==t[:i+1]:
count=i+1
print(N*2-count)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
14,
2,
13,
13,
4,
13,
13,
28,
13,
4,
13,
17,
13,
14,
2,
18,
13,
39,
13,
18,
13,
39,
40,
13,
4,
13,
2,
13,
13,
4,
13,
4,
13,
2,
13,
17,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
55,
2
],
[
58,
8
],
[
52,
12
],
[
59,
17
],
[
53,
18
],
[
56,
21
],
[
24,
23
],
[
56,
27
],
[
59,
31
],
[
53,
35
],
[
23,
38
],
[
56,
42
],
[
23,
43
],
[
56,
49
],
[
52,
53
],
[
55,
56
],
[
58,
59
]
] |
[
"N = int(input())\ns = input()\nt = input()\n\nif s == t:\n print(N)\nelse:\n for i in range(1, N):\n if s[i:] == t[:-i]:\n print(N + i)\n exit()\n print(N * 2)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"if s == t:\n print(N)\nelse:\n for i in range(1, N):\n if s[i:] == t[:-i]:\n print(N + i)\n exit()\n print(N * 2)",
"s == t",
"s",
"t",
"print(N)",
"print",
"N",
"for i in range(1, N):\n if s[i:] == t[:-i]:\n print(N + i)\n exit()\n ",
"i",
"range(1, N)",
"range",
"1",
"N",
"if s[i:] == t[:-i]:\n print(N + i)\n exit()\n ",
"s[i:] == t[:-i]",
"s[i:]",
"s",
"i:",
"i",
"t[:-i]",
"t",
":-i",
"-i",
"i",
"print(N + i)",
"print",
"N + i",
"N",
"i",
"exit()",
"exit",
"print(N * 2)",
"print",
"N * 2",
"N",
"2",
"t = input()",
"input()",
"t",
"N = int(input())",
"int(input())",
"N",
"s = input()",
"input()",
"s"
] |
N = int(input())
s = input()
t = input()
if s == t:
print(N)
else:
for i in range(1, N):
if s[i:] == t[:-i]:
print(N + i)
exit()
print(N * 2)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
2,
17,
13,
0,
13,
13,
42,
13,
14,
2,
18,
13,
39,
40,
13,
18,
13,
39,
13,
0,
13,
13,
3,
0,
13,
17,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13
] |
[
[
59,
2
],
[
47,
8
],
[
50,
12
],
[
62,
16
],
[
60,
19
],
[
53,
21
],
[
60,
22
],
[
48,
28
],
[
54,
31
],
[
66,
31
],
[
51,
33
],
[
56,
37
],
[
54,
38
],
[
66,
38
],
[
65,
41
],
[
57,
45
],
[
63,
45
],
[
47,
48
],
[
50,
51
],
[
60,
53
],
[
53,
54
],
[
54,
56
],
[
66,
56
],
[
56,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
]
] |
[
"N=int(input())\nS=input()\nT=input()\n\nans=2*N\ni=N\nwhile i:\n if S[-i:]==T[:i]:\n ans-=i\n break\n i-=1\n\nprint(ans)",
"N=int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"S=input()",
"S",
"input()",
"input",
"T=input()",
"T",
"input()",
"input",
"ans=2*N",
"ans",
"2*N",
"2",
"N",
"i=N",
"i",
"N",
"while i:\n if S[-i:]==T[:i]:\n ans-=i\n break\n i-=1",
"i",
"if S[-i:]==T[:i]:\n ans-=i\n break\n ",
"S[-i:]==T[:i]",
"S[-i:]",
"S",
"-i:",
"-i",
"i",
"T[:i]",
"T",
":i",
"i",
"ans-=i",
"ans",
"i",
"break",
"i-=1",
"i",
"1",
"print(ans)",
"print",
"ans",
"S=input()",
"input()",
"S",
"T=input()",
"input()",
"T",
"i=N",
"N",
"i",
"ans-=i",
"i",
"ans",
"N=int(input())",
"int(input())",
"N",
"ans=2*N",
"2*N",
"ans",
"i-=1",
"1",
"i"
] |
N=int(input())
S=input()
T=input()
ans=2*N
i=N
while i:
if S[-i:]==T[:i]:
ans-=i
break
i-=1
print(ans)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
2,
17,
13,
28,
13,
4,
13,
17,
2,
13,
17,
14,
2,
18,
13,
39,
2,
13,
13,
18,
13,
39,
13,
0,
13,
2,
2,
17,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13
] |
[
[
63,
2
],
[
57,
8
],
[
54,
12
],
[
51,
16
],
[
64,
19
],
[
22,
21
],
[
64,
26
],
[
58,
31
],
[
64,
34
],
[
21,
35
],
[
55,
37
],
[
60,
41
],
[
64,
45
],
[
21,
46
],
[
61,
49
],
[
52,
49
],
[
51,
52
],
[
54,
55
],
[
57,
58
],
[
60,
61
],
[
63,
64
]
] |
[
"N=int(input())\na=input()\nb=input()\nans=2*N\n\nfor i in range(1,N+1):\n if a[N-i:]==b[:i]:\n ans=2*N-i\n\nprint(ans)",
"N=int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"a=input()",
"a",
"input()",
"input",
"b=input()",
"b",
"input()",
"input",
"ans=2*N",
"ans",
"2*N",
"2",
"N",
"for i in range(1,N+1):\n if a[N-i:]==b[:i]:\n ans=2*N-i",
"i",
"range(1,N+1)",
"range",
"1",
"N+1",
"N",
"1",
"if a[N-i:]==b[:i]:\n ans=2*N-i",
"a[N-i:]==b[:i]",
"a[N-i:]",
"a",
"N-i:",
"N-i",
"N",
"i",
"b[:i]",
"b",
":i",
"i",
"ans=2*N-i",
"ans",
"2*N-i",
"2*N",
"2",
"N",
"i",
"print(ans)",
"print",
"ans",
"ans=2*N",
"2*N",
"ans",
"b=input()",
"input()",
"b",
"a=input()",
"input()",
"a",
"ans=2*N-i",
"2*N-i",
"ans",
"N=int(input())",
"int(input())",
"N"
] |
N=int(input())
a=input()
b=input()
ans=2*N
for i in range(1,N+1):
if a[N-i:]==b[:i]:
ans=2*N-i
print(ans)
|
[
7,
15,
13,
4,
18,
13,
13,
2,
17,
17,
0,
13,
12,
4,
13,
4,
18,
18,
13,
13,
13,
41,
28,
13,
4,
18,
4,
18,
18,
13,
13,
13,
13,
4,
4,
13,
13,
0,
13,
12,
13,
0,
13,
12,
4,
18,
4,
18,
18,
13,
13,
13,
13,
0,
13,
12,
4,
13,
17,
31,
13,
17,
32,
4,
13,
0,
13,
18,
13,
13,
32,
13,
23,
16,
12,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
28,
13,
4,
13,
2,
13,
17,
14,
4,
18,
13,
13,
18,
13,
39,
13,
29,
4,
13,
2,
18,
13,
39,
13,
13,
29,
4,
13,
2,
13,
13,
4,
13,
4,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13
] |
[
[
127,
11
],
[
24,
23
],
[
23,
36
],
[
130,
38
],
[
124,
42
],
[
136,
54
],
[
67,
66
],
[
78,
77
],
[
128,
79
],
[
82,
81
],
[
125,
83
],
[
86,
85
],
[
125,
87
],
[
90,
89
],
[
77,
93
],
[
85,
98
],
[
81,
101
],
[
81,
109
],
[
85,
112
],
[
81,
117
],
[
85,
118
],
[
134,
122
],
[
124,
125
],
[
127,
128
],
[
130,
131
],
[
136,
137
]
] |
[
"import sys\n\nsys.setrecursionlimit(10 ** 8)\nini = lambda: int(sys.stdin.readline())\ninl = lambda: [int(x) for x in sys.stdin.readline().split()]\nins = lambda: sys.stdin.readline().rstrip()\ndebug = lambda *a, **kw: print(\"\\033[33m\", *a, \"\\033[0m\", **dict(file=sys.stderr, **kw))\n\n\ndef solve():\n n = ini()\n s = ins()\n t = ins()\n for i in range(n + 1):\n if t.startswith(s[i:]):\n return len(s[:i] + t)\n\n return len(s + t)\n\n\nprint(solve())",
"import sys",
"sys",
"sys.setrecursionlimit(10 ** 8)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10 ** 8",
"10",
"8",
"ini = lambda: int(sys.stdin.readline())",
"ini",
"lambda: int(sys.stdin.readline())",
"int(sys.stdin.readline())",
"int",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"int(x) for x in sys.stdin.readline().split()",
"for x in sys.stdin.readline().split()",
"x",
"sys.stdin.readline().split()",
"sys.stdin.readline().split",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"split",
"for x in sys.stdin.readline().split()",
"int(x)",
"int",
"x",
"inl = lambda: [int(x) for x in sys.stdin.readline().split()]",
"inl",
"lambda: [int(x) for x in sys.stdin.readline().split()]",
"[int(x) for x in sys.stdin.readline().split()]",
"ins = lambda: sys.stdin.readline().rstrip()",
"ins",
"lambda: sys.stdin.readline().rstrip()",
"sys.stdin.readline().rstrip()",
"sys.stdin.readline().rstrip",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"rstrip",
"debug = lambda *a, **kw: print(\"\\033[33m\", *a, \"\\033[0m\", **dict(file=sys.stderr, **kw))",
"debug",
"lambda *a, **kw: print(\"\\033[33m\", *a, \"\\033[0m\", **dict(file=sys.stderr, **kw))",
"print(\"\\033[33m\", *a, \"\\033[0m\", **dict(file=sys.stderr, **kw))",
"print",
"\"\\033[33m\"",
"*a",
"a",
"\"\\033[0m\"",
"**dict(file=sys.stderr, **kw)",
"dict(file=sys.stderr, **kw)",
"dict",
"file=sys.stderr",
"file",
"sys.stderr",
"sys",
"stderr",
"**kw",
"kw",
"*a",
"**kw",
"def solve():\n n = ini()\n s = ins()\n t = ins()\n for i in range(n + 1):\n if t.startswith(s[i:]):\n return len(s[:i] + t)\n\n return len(s + t)",
"solve",
"n = ini()",
"n",
"ini()",
"ini",
"s = ins()",
"s",
"ins()",
"ins",
"t = ins()",
"t",
"ins()",
"ins",
"for i in range(n + 1):\n if t.startswith(s[i:]):\n return len(s[:i] + t)\n\n ",
"i",
"range(n + 1)",
"range",
"n + 1",
"n",
"1",
"if t.startswith(s[i:]):\n return len(s[:i] + t)\n\n ",
"t.startswith(s[i:])",
"t.startswith",
"t",
"startswith",
"s[i:]",
"s",
"i:",
"i",
"return len(s[:i] + t)",
"len(s[:i] + t)",
"len",
"s[:i] + t",
"s[:i]",
"s",
":i",
"i",
"t",
"return len(s + t)",
"len(s + t)",
"len",
"s + t",
"s",
"t",
"print(solve())",
"print",
"solve()",
"solve",
"ins = lambda: sys.stdin.readline().rstrip()",
"lambda: sys.stdin.readline().rstrip()",
"ins",
"ini = lambda: int(sys.stdin.readline())",
"lambda: int(sys.stdin.readline())",
"ini",
"inl = lambda: [int(x) for x in sys.stdin.readline().split()]",
"lambda: [int(x) for x in sys.stdin.readline().split()]",
"inl",
"def solve():\n n = ini()\n s = ins()\n t = ins()\n for i in range(n + 1):\n if t.startswith(s[i:]):\n return len(s[:i] + t)\n\n return len(s + t)",
"def solve():\n n = ini()\n s = ins()\n t = ins()\n for i in range(n + 1):\n if t.startswith(s[i:]):\n return len(s[:i] + t)\n\n return len(s + t)",
"solve",
"debug = lambda *a, **kw: print(\"\\033[33m\", *a, \"\\033[0m\", **dict(file=sys.stderr, **kw))",
"lambda *a, **kw: print(\"\\033[33m\", *a, \"\\033[0m\", **dict(file=sys.stderr, **kw))",
"debug"
] |
import sys
sys.setrecursionlimit(10 ** 8)
ini = lambda: int(sys.stdin.readline())
inl = lambda: [int(x) for x in sys.stdin.readline().split()]
ins = lambda: sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print("\033[33m", *a, "\033[0m", **dict(file=sys.stderr, **kw))
def solve():
n = ini()
s = ins()
t = ins()
for i in range(n + 1):
if t.startswith(s[i:]):
return len(s[:i] + t)
return len(s + t)
print(solve())
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
18,
13,
39,
2,
2,
13,
13,
17,
0,
13,
18,
13,
39,
2,
13,
17,
14,
2,
13,
13,
0,
13,
2,
13,
17,
4,
13,
4,
13,
2,
13,
18,
13,
39,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13
] |
[
[
73,
2
],
[
67,
8
],
[
61,
12
],
[
76,
16
],
[
20,
19
],
[
74,
22
],
[
70,
24
],
[
68,
26
],
[
74,
30
],
[
19,
31
],
[
79,
34
],
[
62,
36
],
[
19,
39
],
[
71,
43
],
[
80,
44
],
[
64,
46
],
[
19,
48
],
[
68,
55
],
[
62,
57
],
[
61,
62
],
[
64,
65
],
[
67,
68
],
[
70,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
]
] |
[
"N = int(input())\ns = input()\nt = input()\nidx = 0\nfor i in range(N):\n tmp_s = s[N - i - 1:]\n tmp_t = t[:i + 1]\n if tmp_s == tmp_t:\n idx = i + 1\n\nprint(len(s + t[idx:]))",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"idx = 0",
"idx",
"0",
"for i in range(N):\n tmp_s = s[N - i - 1:]\n tmp_t = t[:i + 1]\n if tmp_s == tmp_t:\n idx = i + 1",
"i",
"range(N)",
"range",
"N",
"tmp_s = s[N - i - 1:]",
"tmp_s",
"s[N - i - 1:]",
"s",
"N - i - 1:",
"N - i - 1",
"N - i",
"N",
"i",
"1",
"tmp_t = t[:i + 1]",
"tmp_t",
"t[:i + 1]",
"t",
":i + 1",
"i + 1",
"i",
"1",
"if tmp_s == tmp_t:\n idx = i + 1",
"tmp_s == tmp_t",
"tmp_s",
"tmp_t",
"idx = i + 1",
"idx",
"i + 1",
"i",
"1",
"print(len(s + t[idx:]))",
"print",
"len(s + t[idx:])",
"len",
"s + t[idx:]",
"s",
"t[idx:]",
"t",
"idx:",
"idx",
"t = input()",
"input()",
"t",
"idx = i + 1",
"i + 1",
"idx",
"s = input()",
"input()",
"s",
"tmp_s = s[N - i - 1:]",
"s[N - i - 1:]",
"tmp_s",
"N = int(input())",
"int(input())",
"N",
"idx = 0",
"0",
"idx",
"tmp_t = t[:i + 1]",
"t[:i + 1]",
"tmp_t"
] |
N = int(input())
s = input()
t = input()
idx = 0
for i in range(N):
tmp_s = s[N - i - 1:]
tmp_t = t[:i + 1]
if tmp_s == tmp_t:
idx = i + 1
print(len(s + t[idx:]))
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
18,
13,
39,
2,
4,
13,
13,
13,
18,
13,
39,
13,
0,
13,
13,
4,
13,
2,
2,
13,
17,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
67,
2
],
[
64,
8
],
[
70,
16
],
[
58,
24
],
[
28,
27
],
[
68,
31
],
[
65,
36
],
[
65,
41
],
[
27,
42
],
[
71,
44
],
[
61,
48
],
[
27,
49
],
[
68,
54
],
[
62,
56
],
[
59,
56
],
[
58,
59
],
[
27,
61
],
[
61,
62
],
[
64,
65
],
[
67,
68
],
[
70,
71
]
] |
[
"n = int(input())\ns = list(str(input()))\nt = list(str(input()))\nans = 0\n\nfor i in range(n+1):\n if s[len(s) - i:] == t[:i]:\n ans = i\n\n\nprint(n*2 - ans)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = list(str(input()))",
"s",
"list(str(input()))",
"list",
"str(input())",
"str",
"input()",
"input",
"t = list(str(input()))",
"t",
"list(str(input()))",
"list",
"str(input())",
"str",
"input()",
"input",
"ans = 0",
"ans",
"0",
"for i in range(n+1):\n if s[len(s) - i:] == t[:i]:\n ans = i",
"i",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"if s[len(s) - i:] == t[:i]:\n ans = i",
"s[len(s) - i:] == t[:i]",
"s[len(s) - i:]",
"s",
"len(s) - i:",
"len(s) - i",
"len(s)",
"len",
"s",
"i",
"t[:i]",
"t",
":i",
"i",
"ans = i",
"ans",
"i",
"print(n*2 - ans)",
"print",
"n*2 - ans",
"n*2",
"n",
"2",
"ans",
"ans = 0",
"0",
"ans",
"ans = i",
"i",
"ans",
"s = list(str(input()))",
"list(str(input()))",
"s",
"n = int(input())",
"int(input())",
"n",
"t = list(str(input()))",
"list(str(input()))",
"t"
] |
n = int(input())
s = list(str(input()))
t = list(str(input()))
ans = 0
for i in range(n+1):
if s[len(s) - i:] == t[:i]:
ans = i
print(n*2 - ans)
|
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
28,
13,
4,
13,
17,
2,
13,
17,
14,
2,
18,
13,
39,
13,
13,
18,
13,
39,
17,
2,
13,
13,
13,
2,
13,
13,
3,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
44,
2
],
[
41,
6
],
[
47,
10
],
[
15,
14
],
[
45,
19
],
[
42,
24
],
[
48,
29
],
[
45,
33
],
[
14,
34
],
[
45,
37
],
[
14,
38
],
[
41,
42
],
[
44,
45
],
[
47,
48
]
] |
[
"n=input()\ns=raw_input()\nt=raw_input()\nfor i in xrange(0,n+1):\n\tif s[i:n]==t[0:n-i]:\n\t\tprint n+i\n\t\tbreak",
"n=input()",
"n",
"input()",
"input",
"s=raw_input()",
"s",
"raw_input()",
"raw_input",
"t=raw_input()",
"t",
"raw_input()",
"raw_input",
"for i in xrange(0,n+1):\n\tif s[i:n]==t[0:n-i]:\n\t\tprint n+i\n\t\tbreak",
"i",
"xrange(0,n+1)",
"xrange",
"0",
"n+1",
"n",
"1",
"if s[i:n]==t[0:n-i]:\n\t\tprint n+i\n\t\tbreak",
"s[i:n]==t[0:n-i]",
"s[i:n]",
"s",
"i:n",
"i",
"n",
"t[0:n-i]",
"t",
"0:n-i",
"0",
"n-i",
"n",
"i",
"print",
"n+i",
"n",
"i",
"break",
"s=raw_input()",
"raw_input()",
"s",
"n=input()",
"input()",
"n",
"t=raw_input()",
"raw_input()",
"t"
] |
n=input()
s=raw_input()
t=raw_input()
for i in xrange(0,n+1):
if s[i:n]==t[0:n-i]:
print n+i
break
|
[
7,
15,
15,
15,
13,
15,
13,
12,
13,
29,
4,
13,
4,
13,
12,
13,
29,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
12,
13,
29,
4,
13,
12,
13,
29,
4,
18,
4,
13,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
14,
2,
2,
13,
13,
40,
4,
13,
13,
13,
4,
13,
4,
13,
13,
4,
13,
14,
40,
13,
2,
4,
13,
13,
4,
13,
13,
4,
13,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
4,
13,
4,
13,
13,
4,
13,
13,
14,
2,
18,
13,
39,
2,
2,
13,
17,
17,
18,
13,
39,
2,
13,
17,
0,
13,
2,
13,
17,
4,
13,
2,
2,
4,
13,
13,
4,
13,
13,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
17,
13,
10,
4,
13,
10,
12,
13,
10,
2,
13,
10,
12,
13
] |
[
[
147,
41
],
[
151,
43
],
[
132,
45
],
[
138,
49
],
[
133,
55
],
[
139,
56
],
[
133,
60
],
[
148,
61
],
[
133,
66
],
[
148,
71
],
[
133,
75
],
[
139,
78
],
[
148,
81
],
[
144,
85
],
[
89,
88
],
[
133,
95
],
[
139,
98
],
[
133,
102
],
[
88,
106
],
[
139,
110
],
[
88,
113
],
[
153,
116
],
[
88,
118
],
[
133,
126
],
[
139,
129
],
[
154,
130
],
[
145,
130
],
[
132,
133
],
[
138,
139
],
[
144,
145
],
[
147,
148
],
[
153,
154
]
] |
[
"from collections import defaultdict\nfrom collections import deque\nimport itertools\nimport math\n\ndef readInt():\n return int(input())\ndef readInts():\n return list(map(int, input().split()))\ndef readChar():\n return input()\ndef readChars():\n return input().split()\n\nn = readInt()\ns = input()\nt = input()\n\nif s==t and len(s)>=n:\n print(len(s))\n exit()\nif n>=len(s)+len(t):\n print(n)\n exit()\n\nde = 0\nfor i in range(min(len(s),len(t))):\n if s[i*-1-1:]==t[:i+1]:\n de = i+1\n\nprint(len(s)+len(t)-de)",
"from collections import defaultdict",
"from collections import deque",
"import itertools",
"itertools",
"import math",
"math",
"def readInt():\n return int(input())",
"readInt",
"return int(input())",
"int(input())",
"int",
"input()",
"input",
"def readInts():\n return list(map(int, input().split()))",
"readInts",
"return list(map(int, input().split()))",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"def readChar():\n return input()",
"readChar",
"return input()",
"input()",
"input",
"def readChars():\n return input().split()",
"readChars",
"return input().split()",
"input().split()",
"().split",
"()",
"input",
"split",
"n = readInt()",
"n",
"readInt()",
"readInt",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"if s==t and len(s)>=n:\n print(len(s))\n exit()",
"s==t and len(s)>=n",
"s==t",
"s",
"t",
"len(s)>=n",
"len(s)",
"len",
"s",
"n",
"print(len(s))",
"print",
"len(s)",
"len",
"s",
"exit()",
"exit",
"if n>=len(s)+len(t):\n print(n)\n exit()",
"n>=len(s)+len(t)",
"n",
"len(s)+len(t)",
"len(s)",
"len",
"s",
"len(t)",
"len",
"t",
"print(n)",
"print",
"n",
"exit()",
"exit",
"de = 0",
"de",
"0",
"for i in range(min(len(s),len(t))):\n if s[i*-1-1:]==t[:i+1]:\n de = i+1",
"i",
"range(min(len(s),len(t)))",
"range",
"min(len(s),len(t))",
"min",
"len(s)",
"len",
"s",
"len(t)",
"len",
"t",
"if s[i*-1-1:]==t[:i+1]:\n de = i+1",
"s[i*-1-1:]==t[:i+1]",
"s[i*-1-1:]",
"s",
"i*-1-1:",
"i*-1-1",
"i*-1",
"i",
"-1",
"1",
"t[:i+1]",
"t",
":i+1",
"i+1",
"i",
"1",
"de = i+1",
"de",
"i+1",
"i",
"1",
"print(len(s)+len(t)-de)",
"print",
"len(s)+len(t)-de",
"len(s)+len(t)",
"len(s)",
"len",
"s",
"len(t)",
"len",
"t",
"de",
"s = input()",
"input()",
"s",
"def readChars():\n return input().split()",
"def readChars():\n return input().split()",
"readChars",
"t = input()",
"input()",
"t",
"def readChar():\n return input()",
"def readChar():\n return input()",
"readChar",
"de = 0",
"0",
"de",
"n = readInt()",
"readInt()",
"n",
"def readInt():\n return int(input())",
"def readInt():\n return int(input())",
"readInt",
"de = i+1",
"i+1",
"de",
"def readInts():\n return list(map(int, input().split()))",
"def readInts():\n return list(map(int, input().split()))",
"readInts"
] |
from collections import defaultdict
from collections import deque
import itertools
import math
def readInt():
return int(input())
def readInts():
return list(map(int, input().split()))
def readChar():
return input()
def readChars():
return input().split()
n = readInt()
s = input()
t = input()
if s==t and len(s)>=n:
print(len(s))
exit()
if n>=len(s)+len(t):
print(n)
exit()
de = 0
for i in range(min(len(s),len(t))):
if s[i*-1-1:]==t[:i+1]:
de = i+1
print(len(s)+len(t)-de)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
2,
17,
17,
28,
13,
4,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
17,
0,
13,
2,
18,
13,
39,
13,
18,
13,
39,
13,
14,
2,
4,
13,
13,
13,
9,
14,
2,
2,
18,
13,
39,
13,
13,
2,
18,
13,
39,
40,
13,
13,
0,
13,
4,
13,
13,
4,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
88,
2
],
[
94,
8
],
[
91,
12
],
[
85,
16
],
[
22,
21
],
[
89,
25
],
[
29,
28
],
[
89,
32
],
[
79,
35
],
[
95,
38
],
[
92,
42
],
[
80,
49
],
[
89,
50
],
[
80,
56
],
[
95,
59
],
[
80,
62
],
[
89,
65
],
[
92,
66
],
[
82,
68
],
[
86,
71
],
[
83,
71
],
[
80,
74
],
[
83,
77
],
[
86,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
],
[
94,
95
]
] |
[
"N=int(input())\ns=input()\nt=input()\nans=10**9\nfor i in range(N+1):\n for j in range(N+1):\n u=s[:i]+t[j:]\n if len(u)<N:\n continue\n if u[:N]==s and u[-N:]==t:\n ans=min(ans,len(u))\nprint(ans)",
"N=int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s=input()",
"s",
"input()",
"input",
"t=input()",
"t",
"input()",
"input",
"ans=10**9",
"ans",
"10**9",
"10",
"9",
"for i in range(N+1):\n for j in range(N+1):\n u=s[:i]+t[j:]\n if len(u)<N:\n continue\n if u[:N]==s and u[-N:]==t:\n ans=min(ans,len(u))",
"i",
"range(N+1)",
"range",
"N+1",
"N",
"1",
"for j in range(N+1):\n u=s[:i]+t[j:]\n if len(u)<N:\n continue\n if u[:N]==s and u[-N:]==t:\n ans=min(ans,len(u))",
"j",
"range(N+1)",
"range",
"N+1",
"N",
"1",
"u=s[:i]+t[j:]",
"u",
"s[:i]+t[j:]",
"s[:i]",
"s",
":i",
"i",
"t[j:]",
"t",
"j:",
"j",
"if len(u)<N:\n continue\n ",
"len(u)<N",
"len(u)",
"len",
"u",
"N",
"continue",
"if u[:N]==s and u[-N:]==t:\n ans=min(ans,len(u))",
"u[:N]==s and u[-N:]==t",
"u[:N]==s",
"u[:N]",
"u",
":N",
"N",
"s",
"u[-N:]==t",
"u[-N:]",
"u",
"-N:",
"-N",
"N",
"t",
"ans=min(ans,len(u))",
"ans",
"min(ans,len(u))",
"min",
"ans",
"len(u)",
"len",
"u",
"print(ans)",
"print",
"ans",
"u=s[:i]+t[j:]",
"s[:i]+t[j:]",
"u",
"ans=min(ans,len(u))",
"min(ans,len(u))",
"ans",
"ans=10**9",
"10**9",
"ans",
"N=int(input())",
"int(input())",
"N",
"t=input()",
"input()",
"t",
"s=input()",
"input()",
"s"
] |
N=int(input())
s=input()
t=input()
ans=10**9
for i in range(N+1):
for j in range(N+1):
u=s[:i]+t[j:]
if len(u)<N:
continue
if u[:N]==s and u[-N:]==t:
ans=min(ans,len(u))
print(ans)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
28,
13,
4,
13,
13,
17,
17,
14,
2,
18,
13,
39,
40,
13,
18,
13,
39,
13,
4,
13,
2,
2,
13,
17,
13,
4,
13,
4,
13,
2,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
48,
2
],
[
54,
8
],
[
51,
12
],
[
17,
16
],
[
49,
19
],
[
55,
25
],
[
16,
28
],
[
52,
30
],
[
49,
37
],
[
16,
39
],
[
49,
46
],
[
48,
49
],
[
51,
52
],
[
54,
55
]
] |
[
"N = int(input())\ns = input()\nt = input()\n\nfor i in range(N, 0, -1):\n if s[-i:] == t[:i]:\n print(N * 2 - i)\n exit()\nprint(2 * N)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"for i in range(N, 0, -1):\n if s[-i:] == t[:i]:\n print(N * 2 - i)\n exit()",
"i",
"range(N, 0, -1)",
"range",
"N",
"0",
"-1",
"if s[-i:] == t[:i]:\n print(N * 2 - i)\n exit()",
"s[-i:] == t[:i]",
"s[-i:]",
"s",
"-i:",
"-i",
"i",
"t[:i]",
"t",
":i",
"i",
"print(N * 2 - i)",
"print",
"N * 2 - i",
"N * 2",
"N",
"2",
"i",
"exit()",
"exit",
"print(2 * N)",
"print",
"2 * N",
"2",
"N",
"N = int(input())",
"int(input())",
"N",
"t = input()",
"input()",
"t",
"s = input()",
"input()",
"s"
] |
N = int(input())
s = input()
t = input()
for i in range(N, 0, -1):
if s[-i:] == t[:i]:
print(N * 2 - i)
exit()
print(2 * N)
|
[
7,
15,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
28,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
14,
40,
18,
13,
2,
13,
13,
18,
13,
13,
0,
13,
17,
3,
14,
13,
4,
13,
2,
13,
13,
4,
18,
13,
13,
4,
13,
2,
17,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13
] |
[
[
63,
4
],
[
66,
10
],
[
75,
14
],
[
19,
18
],
[
64,
21
],
[
72,
23
],
[
27,
26
],
[
64,
30
],
[
18,
31
],
[
67,
35
],
[
18,
37
],
[
26,
38
],
[
76,
40
],
[
26,
41
],
[
69,
43
],
[
64,
51
],
[
18,
52
],
[
64,
61
],
[
63,
64
],
[
66,
67
],
[
69,
70
],
[
72,
73
],
[
75,
76
]
] |
[
"import sys\nN = int(input())\ns = input()\nt = input()\nfor i in range(N):\n flg = True\n for j in range(N - i):\n if s[i + j] != t[j]:\n flg = False\n break\n if flg:\n print(N + i)\n sys.exit()\nprint(2 * N)",
"import sys",
"sys",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"for i in range(N):\n flg = True\n for j in range(N - i):\n if s[i + j] != t[j]:\n flg = False\n break\n if flg:\n print(N + i)\n sys.exit()",
"i",
"range(N)",
"range",
"N",
"flg = True",
"flg",
"True",
"for j in range(N - i):\n if s[i + j] != t[j]:\n flg = False\n break\n ",
"j",
"range(N - i)",
"range",
"N - i",
"N",
"i",
"if s[i + j] != t[j]:\n flg = False\n break\n ",
"s[i + j] != t[j]",
"s[i + j]",
"s",
"i + j",
"i",
"j",
"t[j]",
"t",
"j",
"flg = False",
"flg",
"False",
"break",
"if flg:\n print(N + i)\n sys.exit()",
"flg",
"print(N + i)",
"print",
"N + i",
"N",
"i",
"sys.exit()",
"sys.exit",
"sys",
"exit",
"print(2 * N)",
"print",
"2 * N",
"2",
"N",
"N = int(input())",
"int(input())",
"N",
"s = input()",
"input()",
"s",
"flg = False",
"False",
"flg",
"flg = True",
"True",
"flg",
"t = input()",
"input()",
"t"
] |
import sys
N = int(input())
s = input()
t = input()
for i in range(N):
flg = True
for j in range(N - i):
if s[i + j] != t[j]:
flg = False
break
if flg:
print(N + i)
sys.exit()
print(2 * N)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
13,
28,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
18,
13,
2,
13,
13,
18,
13,
13,
14,
13,
0,
13,
13,
3,
4,
13,
2,
13,
13,
10,
2,
13,
10,
13,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13
] |
[
[
71,
2
],
[
65,
8
],
[
74,
12
],
[
59,
16
],
[
72,
17
],
[
20,
19
],
[
72,
22
],
[
68,
24
],
[
28,
27
],
[
72,
31
],
[
19,
32
],
[
56,
34
],
[
66,
37
],
[
27,
39
],
[
19,
40
],
[
75,
42
],
[
27,
43
],
[
62,
47
],
[
19,
48
],
[
72,
53
],
[
63,
54
],
[
60,
54
],
[
56,
57
],
[
72,
59
],
[
59,
60
],
[
19,
62
],
[
62,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
]
] |
[
"n = int(input())\ns = input()\nt = input()\nans = n\nfor i in range(n):\n f = True\n for j in range(n - i):\n f &= s[j + i] == t[j]\n if f:\n ans = i\n break\nprint(n+ans)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"ans = n",
"ans",
"n",
"for i in range(n):\n f = True\n for j in range(n - i):\n f &= s[j + i] == t[j]\n if f:\n ans = i\n break",
"i",
"range(n)",
"range",
"n",
"f = True",
"f",
"True",
"for j in range(n - i):\n f &= s[j + i] == t[j]\n ",
"j",
"range(n - i)",
"range",
"n - i",
"n",
"i",
"f &= s[j + i] == t[j]",
"f",
"s[j + i] == t[j]",
"s[j + i]",
"s",
"j + i",
"j",
"i",
"t[j]",
"t",
"j",
"if f:\n ans = i\n break",
"f",
"ans = i",
"ans",
"i",
"break",
"print(n+ans)",
"print",
"n+ans",
"n",
"ans",
"f &= s[j + i] == t[j]",
"s[j + i] == t[j]",
"f",
"ans = n",
"n",
"ans",
"ans = i",
"i",
"ans",
"s = input()",
"input()",
"s",
"f = True",
"True",
"f",
"n = int(input())",
"int(input())",
"n",
"t = input()",
"input()",
"t"
] |
n = int(input())
s = input()
t = input()
ans = n
for i in range(n):
f = True
for j in range(n - i):
f &= s[j + i] == t[j]
if f:
ans = i
break
print(n+ans)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
2,
17,
13,
28,
13,
4,
13,
17,
2,
13,
17,
14,
2,
18,
13,
39,
2,
13,
13,
18,
13,
39,
13,
0,
13,
4,
13,
2,
2,
2,
13,
13,
17,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
59,
2
],
[
62,
8
],
[
65,
12
],
[
56,
16
],
[
60,
19
],
[
22,
21
],
[
60,
26
],
[
63,
31
],
[
60,
34
],
[
21,
35
],
[
66,
37
],
[
68,
41
],
[
60,
47
],
[
21,
48
],
[
21,
50
],
[
57,
51
],
[
69,
51
],
[
69,
54
],
[
57,
54
],
[
56,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
]
] |
[
"n = int(input())\nS1 = input()\nS2 = input()\nans = 2 * n\nfor i in range(1,n + 1):\n if S1[n - i:] == S2[:i]:\n ans = min((n - i) * 2 + i,ans)\nprint(ans)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"S1 = input()",
"S1",
"input()",
"input",
"S2 = input()",
"S2",
"input()",
"input",
"ans = 2 * n",
"ans",
"2 * n",
"2",
"n",
"for i in range(1,n + 1):\n if S1[n - i:] == S2[:i]:\n ans = min((n - i) * 2 + i,ans)",
"i",
"range(1,n + 1)",
"range",
"1",
"n + 1",
"n",
"1",
"if S1[n - i:] == S2[:i]:\n ans = min((n - i) * 2 + i,ans)",
"S1[n - i:] == S2[:i]",
"S1[n - i:]",
"S1",
"n - i:",
"n - i",
"n",
"i",
"S2[:i]",
"S2",
":i",
"i",
"ans = min((n - i) * 2 + i,ans)",
"ans",
"min((n - i) * 2 + i,ans)",
"min",
"(n - i) * 2 + i",
"(n - i) * 2",
"n - i",
"n",
"i",
"2",
"i",
"ans",
"print(ans)",
"print",
"ans",
"ans = 2 * n",
"2 * n",
"ans",
"n = int(input())",
"int(input())",
"n",
"S1 = input()",
"input()",
"S1",
"S2 = input()",
"input()",
"S2",
"ans = min((n - i) * 2 + i,ans)",
"min((n - i) * 2 + i,ans)",
"ans"
] |
n = int(input())
S1 = input()
S2 = input()
ans = 2 * n
for i in range(1,n + 1):
if S1[n - i:] == S2[:i]:
ans = min((n - i) * 2 + i,ans)
print(ans)
|
[
7,
12,
13,
12,
13,
12,
13,
12,
13,
12,
13,
0,
13,
4,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
28,
13,
4,
13,
13,
14,
2,
18,
13,
39,
13,
18,
13,
39,
2,
13,
13,
4,
13,
2,
13,
13,
4,
13,
4,
13,
2,
17,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13
] |
[
[
78,
12
],
[
76,
14
],
[
72,
16
],
[
66,
22
],
[
29,
28
],
[
79,
31
],
[
73,
35
],
[
67,
39
],
[
79,
42
],
[
28,
43
],
[
79,
47
],
[
28,
48
],
[
79,
55
],
[
66,
67
],
[
72,
73
],
[
78,
79
]
] |
[
"def ii():return int(input())\ndef iim():return map(int,input().split())\ndef iil():return list(map(int,input().split()))\ndef ism():return map(str,input().split())\ndef isl():return list(map(str,input().split()))\n\nn = ii()\ns = list(input())\nt = list(input())\n\nfor i in range(n):\n if s[i:] == t[:n-i]:\n print(n+i)\n exit()\n\n\nprint(2*n)",
"def ii():return int(input())",
"ii",
"def iim():return map(int,input().split())",
"iim",
"def iil():return list(map(int,input().split()))",
"iil",
"def ism():return map(str,input().split())",
"ism",
"def isl():return list(map(str,input().split()))",
"isl",
"n = ii()",
"n",
"ii()",
"ii",
"s = list(input())",
"s",
"list(input())",
"list",
"input()",
"input",
"t = list(input())",
"t",
"list(input())",
"list",
"input()",
"input",
"for i in range(n):\n if s[i:] == t[:n-i]:\n print(n+i)\n exit()",
"i",
"range(n)",
"range",
"n",
"if s[i:] == t[:n-i]:\n print(n+i)\n exit()",
"s[i:] == t[:n-i]",
"s[i:]",
"s",
"i:",
"i",
"t[:n-i]",
"t",
":n-i",
"n-i",
"n",
"i",
"print(n+i)",
"print",
"n+i",
"n",
"i",
"exit()",
"exit",
"print(2*n)",
"print",
"2*n",
"2",
"n",
"def ism():return map(str,input().split())",
"def ism():return map(str,input().split())",
"ism",
"def isl():return list(map(str,input().split()))",
"def isl():return list(map(str,input().split()))",
"isl",
"def iim():return map(int,input().split())",
"def iim():return map(int,input().split())",
"iim",
"t = list(input())",
"list(input())",
"t",
"def iil():return list(map(int,input().split()))",
"def iil():return list(map(int,input().split()))",
"iil",
"s = list(input())",
"list(input())",
"s",
"def ii():return int(input())",
"def ii():return int(input())",
"ii",
"n = ii()",
"ii()",
"n"
] |
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))
def ism():return map(str,input().split())
def isl():return list(map(str,input().split()))
n = ii()
s = list(input())
t = list(input())
for i in range(n):
if s[i:] == t[:n-i]:
print(n+i)
exit()
print(2*n)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
13,
28,
13,
4,
13,
13,
14,
2,
18,
13,
39,
13,
18,
13,
39,
2,
13,
13,
0,
13,
13,
3,
4,
13,
2,
13,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13
] |
[
[
51,
2
],
[
54,
8
],
[
48,
12
],
[
45,
16
],
[
52,
17
],
[
20,
19
],
[
52,
22
],
[
55,
26
],
[
49,
30
],
[
52,
33
],
[
19,
34
],
[
57,
36
],
[
19,
37
],
[
58,
42
],
[
46,
42
],
[
52,
43
],
[
52,
45
],
[
45,
46
],
[
48,
49
],
[
51,
52
],
[
54,
55
],
[
19,
57
],
[
57,
58
]
] |
[
"n = int(input())\ns = input()\nt = input()\n\nu = n\nfor i in range(n):\n if s[i:] == t[:(n-i)]:\n u = i\n break\n\nprint(u+n)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"u = n",
"u",
"n",
"for i in range(n):\n if s[i:] == t[:(n-i)]:\n u = i\n break",
"i",
"range(n)",
"range",
"n",
"if s[i:] == t[:(n-i)]:\n u = i\n break",
"s[i:] == t[:(n-i)]",
"s[i:]",
"s",
"i:",
"i",
"t[:(n-i)]",
"t",
":(n-i)",
"n-i",
"n",
"i",
"u = i",
"u",
"i",
"break",
"print(u+n)",
"print",
"u+n",
"u",
"n",
"u = n",
"n",
"u",
"t = input()",
"input()",
"t",
"n = int(input())",
"int(input())",
"n",
"s = input()",
"input()",
"s",
"u = i",
"i",
"u"
] |
n = int(input())
s = input()
t = input()
u = n
for i in range(n):
if s[i:] == t[:(n-i)]:
u = i
break
print(u+n)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
2,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
18,
13,
39,
2,
2,
13,
13,
17,
13,
18,
13,
39,
17,
2,
13,
17,
0,
13,
2,
13,
17,
4,
13,
2,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13
] |
[
[
60,
2
],
[
72,
8
],
[
57,
12
],
[
69,
16
],
[
61,
18
],
[
66,
21
],
[
25,
24
],
[
61,
27
],
[
73,
31
],
[
61,
35
],
[
24,
36
],
[
58,
40
],
[
24,
44
],
[
63,
47
],
[
24,
49
],
[
70,
54
],
[
64,
55
],
[
67,
55
],
[
57,
58
],
[
60,
61
],
[
63,
64
],
[
66,
67
],
[
69,
70
],
[
72,
73
]
] |
[
"N = int(input())\ns = input()\nt = input()\nans = N*2\ntmp = 0\nfor i in range(N):\n if(s[N-i-1:N] == t[0:i+1]):\n tmp = i + 1\nprint(ans-tmp)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"ans = N*2",
"ans",
"N*2",
"N",
"2",
"tmp = 0",
"tmp",
"0",
"for i in range(N):\n if(s[N-i-1:N] == t[0:i+1]):\n tmp = i + 1",
"i",
"range(N)",
"range",
"N",
"if(s[N-i-1:N] == t[0:i+1]):\n tmp = i + 1",
"s[N-i-1:N] == t[0:i+1]",
"s[N-i-1:N]",
"s",
"N-i-1:N",
"N-i-1",
"N-i",
"N",
"i",
"1",
"N",
"t[0:i+1]",
"t",
"0:i+1",
"0",
"i+1",
"i",
"1",
"tmp = i + 1",
"tmp",
"i + 1",
"i",
"1",
"print(ans-tmp)",
"print",
"ans-tmp",
"ans",
"tmp",
"t = input()",
"input()",
"t",
"N = int(input())",
"int(input())",
"N",
"tmp = i + 1",
"i + 1",
"tmp",
"tmp = 0",
"0",
"tmp",
"ans = N*2",
"N*2",
"ans",
"s = input()",
"input()",
"s"
] |
N = int(input())
s = input()
t = input()
ans = N*2
tmp = 0
for i in range(N):
if(s[N-i-1:N] == t[0:i+1]):
tmp = i + 1
print(ans-tmp)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
2,
17,
13,
28,
13,
4,
13,
13,
28,
13,
4,
13,
17,
2,
13,
17,
14,
2,
18,
13,
39,
13,
18,
13,
39,
13,
0,
13,
4,
13,
13,
2,
2,
17,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13
] |
[
[
57,
2
],
[
69,
8
],
[
60,
12
],
[
63,
16
],
[
58,
19
],
[
22,
21
],
[
58,
24
],
[
27,
26
],
[
58,
31
],
[
70,
36
],
[
61,
40
],
[
66,
44
],
[
64,
47
],
[
67,
47
],
[
58,
51
],
[
26,
52
],
[
67,
55
],
[
64,
55
],
[
57,
58
],
[
60,
61
],
[
63,
64
],
[
66,
67
],
[
69,
70
]
] |
[
"N = int(input())\nS = input()\nT = input()\nans = 2 * N\nfor i in range(N):\n for j in range(1, N + 1):\n if (S[i:] == T[:j]):\n ans = min(ans, 2 * N - j)\nprint(ans)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"S = input()",
"S",
"input()",
"input",
"T = input()",
"T",
"input()",
"input",
"ans = 2 * N",
"ans",
"2 * N",
"2",
"N",
"for i in range(N):\n for j in range(1, N + 1):\n if (S[i:] == T[:j]):\n ans = min(ans, 2 * N - j)",
"i",
"range(N)",
"range",
"N",
"for j in range(1, N + 1):\n if (S[i:] == T[:j]):\n ans = min(ans, 2 * N - j)",
"j",
"range(1, N + 1)",
"range",
"1",
"N + 1",
"N",
"1",
"if (S[i:] == T[:j]):\n ans = min(ans, 2 * N - j)",
"S[i:] == T[:j]",
"S[i:]",
"S",
"i:",
"i",
"T[:j]",
"T",
":j",
"j",
"ans = min(ans, 2 * N - j)",
"ans",
"min(ans, 2 * N - j)",
"min",
"ans",
"2 * N - j",
"2 * N",
"2",
"N",
"j",
"print(ans)",
"print",
"ans",
"N = int(input())",
"int(input())",
"N",
"T = input()",
"input()",
"T",
"ans = 2 * N",
"2 * N",
"ans",
"ans = min(ans, 2 * N - j)",
"min(ans, 2 * N - j)",
"ans",
"S = input()",
"input()",
"S"
] |
N = int(input())
S = input()
T = input()
ans = 2 * N
for i in range(N):
for j in range(1, N + 1):
if (S[i:] == T[:j]):
ans = min(ans, 2 * N - j)
print(ans)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
13,
28,
13,
4,
13,
13,
14,
2,
18,
13,
39,
13,
18,
13,
39,
2,
40,
13,
13,
3,
0,
13,
17,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
4,
13
] |
[
[
44,
2
],
[
56,
8
],
[
47,
12
],
[
50,
16
],
[
45,
17
],
[
20,
19
],
[
45,
22
],
[
57,
26
],
[
48,
30
],
[
19,
34
],
[
45,
35
],
[
53,
38
],
[
54,
42
],
[
51,
42
],
[
44,
45
],
[
47,
48
],
[
45,
50
],
[
50,
51
],
[
53,
54
],
[
56,
57
]
] |
[
"n = int(input())\ns = input()\nt = input()\n\nans = n\n\nfor i in range(n):\n if s[i:] == t[:-i + n]:\n break\n else:\n ans += 1\n\nprint(ans)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"ans = n",
"ans",
"n",
"for i in range(n):\n if s[i:] == t[:-i + n]:\n break\n else:\n ans += 1",
"i",
"range(n)",
"range",
"n",
"if s[i:] == t[:-i + n]:\n break\n else:\n ans += 1",
"s[i:] == t[:-i + n]",
"s[i:]",
"s",
"i:",
"i",
"t[:-i + n]",
"t",
":-i + n",
"-i + n",
"-i",
"i",
"n",
"break",
"ans += 1",
"ans",
"1",
"print(ans)",
"print",
"ans",
"n = int(input())",
"int(input())",
"n",
"t = input()",
"input()",
"t",
"ans = n",
"n",
"ans",
"ans += 1",
"1",
"ans",
"s = input()",
"input()",
"s"
] |
n = int(input())
s = input()
t = input()
ans = n
for i in range(n):
if s[i:] == t[:-i + n]:
break
else:
ans += 1
print(ans)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
28,
13,
4,
13,
13,
0,
13,
18,
13,
39,
13,
0,
13,
18,
13,
39,
2,
13,
13,
14,
2,
13,
13,
4,
13,
2,
2,
17,
13,
2,
13,
13,
4,
13,
4,
13,
2,
17,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13
] |
[
[
64,
2
],
[
58,
8
],
[
61,
12
],
[
17,
16
],
[
65,
19
],
[
67,
21
],
[
59,
23
],
[
55,
27
],
[
62,
29
],
[
65,
32
],
[
16,
33
],
[
68,
36
],
[
56,
37
],
[
65,
43
],
[
65,
45
],
[
16,
46
],
[
65,
53
],
[
55,
56
],
[
58,
59
],
[
61,
62
],
[
64,
65
],
[
67,
68
]
] |
[
"N=int(input())\ns=input()\nt=input()\nfor i in range(N):\n A=s[i:]\n B=t[:N-i]\n if A==B:\n print(2*N-(N-i))\n exit()\nprint(2*N)",
"N=int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s=input()",
"s",
"input()",
"input",
"t=input()",
"t",
"input()",
"input",
"for i in range(N):\n A=s[i:]\n B=t[:N-i]\n if A==B:\n print(2*N-(N-i))\n exit()",
"i",
"range(N)",
"range",
"N",
"A=s[i:]",
"A",
"s[i:]",
"s",
"i:",
"i",
"B=t[:N-i]",
"B",
"t[:N-i]",
"t",
":N-i",
"N-i",
"N",
"i",
"if A==B:\n print(2*N-(N-i))\n exit()",
"A==B",
"A",
"B",
"print(2*N-(N-i))",
"print",
"2*N-(N-i)",
"2*N",
"2",
"N",
"N-i",
"N",
"i",
"exit()",
"exit",
"print(2*N)",
"print",
"2*N",
"2",
"N",
"B=t[:N-i]",
"t[:N-i]",
"B",
"s=input()",
"input()",
"s",
"t=input()",
"input()",
"t",
"N=int(input())",
"int(input())",
"N",
"A=s[i:]",
"s[i:]",
"A"
] |
N=int(input())
s=input()
t=input()
for i in range(N):
A=s[i:]
B=t[:N-i]
if A==B:
print(2*N-(N-i))
exit()
print(2*N)
|
[
7,
12,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
14,
2,
13,
13,
4,
13,
13,
29,
28,
13,
4,
13,
4,
13,
17,
13,
0,
13,
2,
13,
18,
13,
39,
13,
14,
2,
4,
18,
13,
13,
13,
4,
18,
13,
13,
13,
4,
13,
4,
13,
13,
29,
4,
13,
10,
12,
13
] |
[
[
5,
4
],
[
11,
10
],
[
15,
14
],
[
10,
19
],
[
14,
20
],
[
4,
23
],
[
27,
26
],
[
4,
32
],
[
35,
34
],
[
10,
36
],
[
14,
38
],
[
34,
45
],
[
10,
47
],
[
34,
50
],
[
14,
52
],
[
34,
57
],
[
63,
60
]
] |
[
"\ndef main():\n n = int(input())\n s = input()\n t = input()\n\n if s == t:\n print(n)\n return\n\n for i in reversed(range(0, n)):\n target = s + t[i:]\n if target.startswith(s) and target.endswith(t):\n print(len(target))\n return\n\nmain()",
"def main():\n n = int(input())\n s = input()\n t = input()\n\n if s == t:\n print(n)\n return\n\n for i in reversed(range(0, n)):\n target = s + t[i:]\n if target.startswith(s) and target.endswith(t):\n print(len(target))\n return",
"main",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"if s == t:\n print(n)\n return\n\n ",
"s == t",
"s",
"t",
"print(n)",
"print",
"n",
"return",
"for i in reversed(range(0, n)):\n target = s + t[i:]\n if target.startswith(s) and target.endswith(t):\n print(len(target))\n return",
"i",
"reversed(range(0, n))",
"reversed",
"range(0, n)",
"range",
"0",
"n",
"target = s + t[i:]",
"target",
"s + t[i:]",
"s",
"t[i:]",
"t",
"i:",
"i",
"if target.startswith(s) and target.endswith(t):\n print(len(target))\n return",
"target.startswith(s) and target.endswith(t)",
"target.startswith(s)",
"target.startswith",
"target",
"startswith",
"s",
"target.endswith(t)",
"target.endswith",
"target",
"endswith",
"t",
"print(len(target))",
"print",
"len(target)",
"len",
"target",
"return",
"main()",
"main",
"def main():\n n = int(input())\n s = input()\n t = input()\n\n if s == t:\n print(n)\n return\n\n for i in reversed(range(0, n)):\n target = s + t[i:]\n if target.startswith(s) and target.endswith(t):\n print(len(target))\n return",
"def main():\n n = int(input())\n s = input()\n t = input()\n\n if s == t:\n print(n)\n return\n\n for i in reversed(range(0, n)):\n target = s + t[i:]\n if target.startswith(s) and target.endswith(t):\n print(len(target))\n return",
"main"
] |
def main():
n = int(input())
s = input()
t = input()
if s == t:
print(n)
return
for i in reversed(range(0, n)):
target = s + t[i:]
if target.startswith(s) and target.endswith(t):
print(len(target))
return
main()
|
[
7,
15,
13,
13,
15,
15,
15,
15,
15,
15,
15,
15,
15,
15,
15,
13,
12,
13,
12,
13,
12,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
12,
13,
23,
13,
4,
18,
13,
13,
2,
17,
17,
0,
13,
4,
13,
17,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
14,
2,
13,
13,
4,
13,
13,
4,
13,
28,
13,
4,
13,
17,
13,
0,
13,
18,
13,
39,
13,
0,
13,
18,
13,
39,
40,
13,
14,
2,
13,
13,
4,
13,
2,
2,
17,
13,
4,
13,
13,
3,
4,
13,
2,
17,
13,
10,
18,
13,
10,
12,
13,
10,
2,
13,
10,
18,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13
] |
[
[
27,
26
],
[
141,
32
],
[
36,
36
],
[
146,
45
],
[
122,
50
],
[
134,
57
],
[
132,
59
],
[
149,
61
],
[
144,
63
],
[
137,
65
],
[
144,
67
],
[
150,
70
],
[
138,
71
],
[
135,
74
],
[
79,
78
],
[
135,
82
],
[
125,
84
],
[
150,
86
],
[
116,
90
],
[
138,
92
],
[
78,
95
],
[
126,
98
],
[
117,
99
],
[
135,
105
],
[
126,
108
],
[
135,
114
],
[
116,
117
],
[
122,
123
],
[
125,
126
],
[
134,
135
],
[
137,
138
],
[
146,
147
],
[
149,
150
]
] |
[
"import sys, re\nfrom collections import deque, defaultdict, Counter\nfrom math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians\nfrom itertools import accumulate, permutations, combinations, product\nfrom operator import itemgetter, mul\nfrom copy import deepcopy\nfrom string import ascii_lowercase, ascii_uppercase, digits\nfrom bisect import bisect, bisect_left\nfrom fractions import gcd\nfrom heapq import heappush, heappop\nfrom functools import reduce\nimport numpy as np\ndef input(): return sys.stdin.readline().strip()\ndef INT(): return int(input())\ndef MAP(): return map(int, input().split())\ndef LIST(): return list(map(int, input().split()))\ndef ZIP(n): return zip(*(MAP() for _ in range(n)))\nsys.setrecursionlimit(10 ** 9)\nINF = float('inf')\nmod = 10 ** 9 + 7\n\nN = INT()\ns = input()\nt = input()\nif s == t:\n\tprint(N)\n\texit()\n\nfor i in range(1, N):\n\ts1 = s[i:]\n\tt1 = t[:-i]\n\tif s1 == t1:\n\t\tprint(2*N-len(s1))\n\t\tbreak\nelse:\n\tprint(2*N)",
"import sys, re",
"sys",
"re",
"from collections import deque, defaultdict, Counter",
"from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians",
"from itertools import accumulate, permutations, combinations, product",
"from operator import itemgetter, mul",
"from copy import deepcopy",
"from string import ascii_lowercase, ascii_uppercase, digits",
"from bisect import bisect, bisect_left",
"from fractions import gcd",
"from heapq import heappush, heappop",
"from functools import reduce",
"import numpy as np",
"numpy",
"def input(): return sys.stdin.readline().strip()",
"input",
"def INT(): return int(input())",
"INT",
"def MAP(): return map(int, input().split())",
"MAP",
"def LIST(): return list(map(int, input().split()))",
"LIST",
"MAP() for _ in range(n)",
"for _ in range(n)",
"_",
"range(n)",
"range",
"n",
"for _ in range(n)",
"MAP()",
"MAP",
"def ZIP(n): return zip(*(MAP() for _ in range(n)))",
"ZIP",
"n",
"n",
"sys.setrecursionlimit(10 ** 9)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10 ** 9",
"10",
"9",
"INF = float('inf')",
"INF",
"float('inf')",
"float",
"'inf'",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"N = INT()",
"N",
"INT()",
"INT",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"if s == t:\n\tprint(N)\n\texit()",
"s == t",
"s",
"t",
"print(N)",
"print",
"N",
"exit()",
"exit",
"for i in range(1, N):\n\ts1 = s[i:]\n\tt1 = t[:-i]\n\tif s1 == t1:\n\t\tprint(2*N-len(s1))\n\t\tbreak\nelse:\n\tprint(2*N)",
"i",
"range(1, N)",
"range",
"1",
"N",
"s1 = s[i:]",
"s1",
"s[i:]",
"s",
"i:",
"i",
"t1 = t[:-i]",
"t1",
"t[:-i]",
"t",
":-i",
"-i",
"i",
"if s1 == t1:\n\t\tprint(2*N-len(s1))\n\t\tbreak",
"s1 == t1",
"s1",
"t1",
"print(2*N-len(s1))",
"print",
"2*N-len(s1)",
"2*N",
"2",
"N",
"len(s1)",
"len",
"s1",
"break",
"print(2*N)",
"print",
"2*N",
"2",
"N",
"t1 = t[:-i]",
"t[:-i]",
"t1",
"def ZIP(n): return zip(*(MAP() for _ in range(n)))",
"def ZIP(n): return zip(*(MAP() for _ in range(n)))",
"ZIP",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"s1 = s[i:]",
"s[i:]",
"s1",
"def LIST(): return list(map(int, input().split()))",
"def LIST(): return list(map(int, input().split()))",
"LIST",
"def INT(): return int(input())",
"def INT(): return int(input())",
"INT",
"N = INT()",
"INT()",
"N",
"t = input()",
"input()",
"t",
"def MAP(): return map(int, input().split())",
"def MAP(): return map(int, input().split())",
"MAP",
"def input(): return sys.stdin.readline().strip()",
"def input(): return sys.stdin.readline().strip()",
"input",
"INF = float('inf')",
"float('inf')",
"INF",
"s = input()",
"input()",
"s"
] |
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
import numpy as np
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
N = INT()
s = input()
t = input()
if s == t:
print(N)
exit()
for i in range(1, N):
s1 = s[i:]
t1 = t[:-i]
if s1 == t1:
print(2*N-len(s1))
break
else:
print(2*N)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
14,
40,
18,
13,
2,
2,
13,
13,
13,
18,
13,
13,
0,
13,
17,
14,
13,
4,
13,
2,
2,
13,
17,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13
] |
[
[
59,
2
],
[
68,
8
],
[
71,
12
],
[
62,
16
],
[
20,
19
],
[
60,
24
],
[
65,
27
],
[
31,
30
],
[
19,
33
],
[
69,
37
],
[
60,
40
],
[
19,
41
],
[
30,
42
],
[
72,
44
],
[
30,
45
],
[
74,
47
],
[
60,
55
],
[
63,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
]
] |
[
"n = int(input())\ns = input()\nt = input()\nc = 0\nfor i in range(1,n+1):\n f = True\n for j in range(i):\n if s[n-i+j]!=t[j]:\n f = False\n if f:c=i\nprint(n*2-c)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"c = 0",
"c",
"0",
"for i in range(1,n+1):\n f = True\n for j in range(i):\n if s[n-i+j]!=t[j]:\n f = False\n if f:c=i",
"i",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"f = True",
"f",
"True",
"for j in range(i):\n if s[n-i+j]!=t[j]:\n f = False\n ",
"j",
"range(i)",
"range",
"i",
"if s[n-i+j]!=t[j]:\n f = False\n ",
"s[n-i+j]!=t[j]",
"s[n-i+j]",
"s",
"n-i+j",
"n-i",
"n",
"i",
"j",
"t[j]",
"t",
"j",
"f = False",
"f",
"False",
"if f",
"f",
"print(n*2-c)",
"print",
"n*2-c",
"n*2",
"n",
"2",
"c",
"n = int(input())",
"int(input())",
"n",
"c = 0",
"0",
"c",
"f = True",
"True",
"f",
"s = input()",
"input()",
"s",
"t = input()",
"input()",
"t",
"f = False",
"False",
"f"
] |
n = int(input())
s = input()
t = input()
c = 0
for i in range(1,n+1):
f = True
for j in range(i):
if s[n-i+j]!=t[j]:
f = False
if f:c=i
print(n*2-c)
|
[
7,
15,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
14,
2,
13,
13,
4,
13,
13,
4,
18,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
18,
13,
39,
13,
13,
18,
13,
39,
17,
2,
13,
13,
0,
13,
17,
3,
14,
13,
4,
13,
2,
13,
13,
4,
13,
2,
17,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13
] |
[
[
83,
4
],
[
74,
10
],
[
71,
16
],
[
75,
23
],
[
72,
24
],
[
84,
27
],
[
80,
33
],
[
37,
36
],
[
84,
39
],
[
75,
43
],
[
72,
48
],
[
84,
52
],
[
36,
53
],
[
77,
55
],
[
84,
63
],
[
84,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
]
] |
[
"import sys\nn = int(input())\ns = list(input())\nt = list(input())\n\nif s == t:\n print(n)\n sys.exit()\ncan = False\nfor i in range(n):\n if s[i:n] == t[0:(n-i)]:\n can = True\n break\nif can:\n print(n + i )\nelse:\n print(2*n)",
"import sys",
"sys",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = list(input())",
"s",
"list(input())",
"list",
"input()",
"input",
"t = list(input())",
"t",
"list(input())",
"list",
"input()",
"input",
"if s == t:\n print(n)\n sys.exit()",
"s == t",
"s",
"t",
"print(n)",
"print",
"n",
"sys.exit()",
"sys.exit",
"sys",
"exit",
"can = False",
"can",
"False",
"for i in range(n):\n if s[i:n] == t[0:(n-i)]:\n can = True\n break",
"i",
"range(n)",
"range",
"n",
"if s[i:n] == t[0:(n-i)]:\n can = True\n break",
"s[i:n] == t[0:(n-i)]",
"s[i:n]",
"s",
"i:n",
"i",
"n",
"t[0:(n-i)]",
"t",
"0:(n-i)",
"0",
"n-i",
"n",
"i",
"can = True",
"can",
"True",
"break",
"if can:\n print(n + i )\nelse:\n print(2*n)",
"can",
"print(n + i )",
"print",
"n + i",
"n",
"i",
"print(2*n)",
"print",
"2*n",
"2",
"n",
"t = list(input())",
"list(input())",
"t",
"s = list(input())",
"list(input())",
"s",
"can = True",
"True",
"can",
"can = False",
"False",
"can",
"n = int(input())",
"int(input())",
"n"
] |
import sys
n = int(input())
s = list(input())
t = list(input())
if s == t:
print(n)
sys.exit()
can = False
for i in range(n):
if s[i:n] == t[0:(n-i)]:
can = True
break
if can:
print(n + i )
else:
print(2*n)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
14,
2,
13,
13,
4,
13,
13,
4,
13,
0,
13,
18,
13,
39,
17,
0,
13,
18,
13,
39,
17,
0,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
18,
13,
13,
18,
13,
13,
0,
13,
17,
0,
13,
17,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
18,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13
] |
[
[
65,
2
],
[
83,
8
],
[
74,
12
],
[
84,
17
],
[
75,
18
],
[
66,
21
],
[
86,
25
],
[
75,
27
],
[
71,
31
],
[
84,
33
],
[
77,
37
],
[
66,
38
],
[
80,
40
],
[
44,
43
],
[
66,
46
],
[
72,
50
],
[
84,
50
],
[
81,
51
],
[
69,
51
],
[
87,
53
],
[
75,
53
],
[
43,
54
],
[
68,
56
],
[
89,
59
],
[
90,
63
],
[
78,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
],
[
66,
77
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
],
[
89,
90
]
] |
[
"n = int(input())\ns = input()\nt = input()\nif s == t:\n print(n)\n exit()\nt = t[::-1]\ns = s[::-1]\nres = n\nj = 0\nfor i in range(n):\n if s[j]==t[i]:\n j += 1\n else:\n res += 1\nprint(res)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"if s == t:\n print(n)\n exit()",
"s == t",
"s",
"t",
"print(n)",
"print",
"n",
"exit()",
"exit",
"t = t[::-1]",
"t",
"t[::-1]",
"t",
"::-1",
"-1",
"s = s[::-1]",
"s",
"s[::-1]",
"s",
"::-1",
"-1",
"res = n",
"res",
"n",
"j = 0",
"j",
"0",
"for i in range(n):\n if s[j]==t[i]:\n j += 1\n else:\n res += 1",
"i",
"range(n)",
"range",
"n",
"if s[j]==t[i]:\n j += 1\n else:\n res += 1",
"s[j]==t[i]",
"s[j]",
"s",
"j",
"t[i]",
"t",
"i",
"j += 1",
"j",
"1",
"res += 1",
"res",
"1",
"print(res)",
"print",
"res",
"n = int(input())",
"int(input())",
"n",
"j += 1",
"1",
"j",
"s = s[::-1]",
"s[::-1]",
"s",
"t = input()",
"input()",
"t",
"res = n",
"n",
"res",
"j = 0",
"0",
"j",
"s = input()",
"input()",
"s",
"t = t[::-1]",
"t[::-1]",
"t",
"res += 1",
"1",
"res"
] |
n = int(input())
s = input()
t = input()
if s == t:
print(n)
exit()
t = t[::-1]
s = s[::-1]
res = n
j = 0
for i in range(n):
if s[j]==t[i]:
j += 1
else:
res += 1
print(res)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
13,
28,
13,
4,
13,
2,
13,
17,
0,
13,
2,
13,
18,
13,
39,
13,
14,
2,
2,
18,
13,
39,
13,
13,
2,
18,
13,
39,
40,
13,
13,
0,
13,
13,
4,
13,
4,
13,
13,
10,
2,
13,
10,
13,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
69,
2
],
[
72,
8
],
[
66,
12
],
[
63,
16
],
[
73,
17
],
[
20,
19
],
[
70,
23
],
[
57,
26
],
[
73,
28
],
[
67,
30
],
[
58,
37
],
[
73,
40
],
[
58,
43
],
[
70,
46
],
[
67,
47
],
[
60,
49
],
[
58,
50
],
[
61,
55
],
[
64,
55
],
[
57,
58
],
[
58,
60
],
[
60,
61
],
[
73,
63
],
[
63,
64
],
[
66,
67
],
[
69,
70
],
[
72,
73
]
] |
[
"N = int(input())\ns = input()\nt = input()\nans = s\nfor i in range(N + 1):\n tmp_ans = s + t[i:]\n # print(tmp_ans)\n if tmp_ans[:N] == s and tmp_ans[-N:] == t:\n ans = tmp_ans\nprint(len(ans))",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"ans = s",
"ans",
"s",
"for i in range(N + 1):\n tmp_ans = s + t[i:]\n # print(tmp_ans)\n if tmp_ans[:N] == s and tmp_ans[-N:] == t:\n ans = tmp_ans",
"i",
"range(N + 1)",
"range",
"N + 1",
"N",
"1",
"tmp_ans = s + t[i:]",
"tmp_ans",
"s + t[i:]",
"s",
"t[i:]",
"t",
"i:",
"i",
"if tmp_ans[:N] == s and tmp_ans[-N:] == t:\n ans = tmp_ans",
"tmp_ans[:N] == s and tmp_ans[-N:] == t",
"tmp_ans[:N] == s",
"tmp_ans[:N]",
"tmp_ans",
":N",
"N",
"s",
"tmp_ans[-N:] == t",
"tmp_ans[-N:]",
"tmp_ans",
"-N:",
"-N",
"N",
"t",
"ans = tmp_ans",
"ans",
"tmp_ans",
"print(len(ans))",
"print",
"len(ans)",
"len",
"ans",
"tmp_ans = s + t[i:]",
"s + t[i:]",
"tmp_ans",
"ans = tmp_ans",
"tmp_ans",
"ans",
"ans = s",
"s",
"ans",
"t = input()",
"input()",
"t",
"N = int(input())",
"int(input())",
"N",
"s = input()",
"input()",
"s"
] |
N = int(input())
s = input()
t = input()
ans = s
for i in range(N + 1):
tmp_ans = s + t[i:]
# print(tmp_ans)
if tmp_ans[:N] == s and tmp_ans[-N:] == t:
ans = tmp_ans
print(len(ans))
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
14,
2,
13,
13,
4,
13,
13,
28,
13,
4,
13,
13,
0,
13,
2,
18,
13,
39,
2,
13,
17,
13,
14,
2,
18,
13,
39,
13,
13,
4,
13,
4,
13,
13,
3,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13
] |
[
[
58,
2
],
[
55,
8
],
[
61,
14
],
[
56,
21
],
[
62,
22
],
[
59,
25
],
[
28,
27
],
[
59,
30
],
[
64,
32
],
[
56,
35
],
[
27,
38
],
[
62,
40
],
[
65,
44
],
[
56,
47
],
[
65,
52
],
[
55,
56
],
[
58,
59
],
[
61,
62
],
[
64,
65
]
] |
[
"n = int(input())\ns = str(input())\nt = str(input())\nif s == t:\n print(n)\nelse:\n for i in range(n):\n l = s[:i + 1] + t\n if l[:n] == s:\n print(len(l))\n break",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = str(input())",
"s",
"str(input())",
"str",
"input()",
"input",
"t = str(input())",
"t",
"str(input())",
"str",
"input()",
"input",
"if s == t:\n print(n)\nelse:\n for i in range(n):\n l = s[:i + 1] + t\n if l[:n] == s:\n print(len(l))\n break",
"s == t",
"s",
"t",
"print(n)",
"print",
"n",
"for i in range(n):\n l = s[:i + 1] + t\n if l[:n] == s:\n print(len(l))\n break",
"i",
"range(n)",
"range",
"n",
"l = s[:i + 1] + t",
"l",
"s[:i + 1] + t",
"s[:i + 1]",
"s",
":i + 1",
"i + 1",
"i",
"1",
"t",
"if l[:n] == s:\n print(len(l))\n break",
"l[:n] == s",
"l[:n]",
"l",
":n",
"n",
"s",
"print(len(l))",
"print",
"len(l)",
"len",
"l",
"break",
"s = str(input())",
"str(input())",
"s",
"n = int(input())",
"int(input())",
"n",
"t = str(input())",
"str(input())",
"t",
"l = s[:i + 1] + t",
"s[:i + 1] + t",
"l"
] |
n = int(input())
s = str(input())
t = str(input())
if s == t:
print(n)
else:
for i in range(n):
l = s[:i + 1] + t
if l[:n] == s:
print(len(l))
break
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
18,
4,
13,
13,
0,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
17,
17,
14,
2,
18,
13,
39,
2,
13,
13,
18,
13,
39,
13,
0,
13,
13,
3,
4,
13,
2,
2,
17,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13
] |
[
[
55,
2
],
[
64,
8
],
[
58,
15
],
[
61,
22
],
[
26,
25
],
[
56,
28
],
[
65,
34
],
[
56,
37
],
[
25,
38
],
[
59,
40
],
[
67,
44
],
[
25,
45
],
[
56,
52
],
[
68,
53
],
[
62,
53
],
[
55,
56
],
[
58,
59
],
[
61,
62
],
[
64,
65
],
[
25,
67
],
[
67,
68
]
] |
[
"N = int(input())\ns = input().strip()\nt = input().strip()\nflag = 0\nfor k in range(N,0,-1):\n if s[N-k:]==t[:k]:\n flag = k\n break\nprint(2*N-flag)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s = input().strip()",
"s",
"input().strip()",
"().strip",
"()",
"input",
"strip",
"t = input().strip()",
"t",
"input().strip()",
"().strip",
"()",
"input",
"strip",
"flag = 0",
"flag",
"0",
"for k in range(N,0,-1):\n if s[N-k:]==t[:k]:\n flag = k\n break",
"k",
"range(N,0,-1)",
"range",
"N",
"0",
"-1",
"if s[N-k:]==t[:k]:\n flag = k\n break",
"s[N-k:]==t[:k]",
"s[N-k:]",
"s",
"N-k:",
"N-k",
"N",
"k",
"t[:k]",
"t",
":k",
"k",
"flag = k",
"flag",
"k",
"break",
"print(2*N-flag)",
"print",
"2*N-flag",
"2*N",
"2",
"N",
"flag",
"N = int(input())",
"int(input())",
"N",
"t = input().strip()",
"input().strip()",
"t",
"flag = 0",
"0",
"flag",
"s = input().strip()",
"input().strip()",
"s",
"flag = k",
"k",
"flag"
] |
N = int(input())
s = input().strip()
t = input().strip()
flag = 0
for k in range(N,0,-1):
if s[N-k:]==t[:k]:
flag = k
break
print(2*N-flag)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
18,
13,
39,
13,
0,
13,
18,
13,
39,
17,
2,
13,
13,
14,
2,
13,
13,
0,
13,
17,
3,
14,
13,
4,
13,
2,
13,
13,
4,
13,
2,
13,
17,
10,
17,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13
] |
[
[
71,
2
],
[
65,
8
],
[
68,
12
],
[
77,
16
],
[
20,
19
],
[
72,
22
],
[
74,
24
],
[
66,
26
],
[
62,
30
],
[
69,
32
],
[
72,
36
],
[
19,
37
],
[
75,
40
],
[
63,
41
],
[
59,
43
],
[
72,
51
],
[
72,
56
],
[
59,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
]
] |
[
"N = int(input())\ns = input()\nt = input()\n\nfind = False\nfor i in range(N):\n mae = s[i:]\n ushiro = t[0:N-i]\n if mae == ushiro:\n find = True\n break\nif find:\n print(N+i)\nelse:\n print(N*2)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"find = False",
"find",
"False",
"for i in range(N):\n mae = s[i:]\n ushiro = t[0:N-i]\n if mae == ushiro:\n find = True\n break",
"i",
"range(N)",
"range",
"N",
"mae = s[i:]",
"mae",
"s[i:]",
"s",
"i:",
"i",
"ushiro = t[0:N-i]",
"ushiro",
"t[0:N-i]",
"t",
"0:N-i",
"0",
"N-i",
"N",
"i",
"if mae == ushiro:\n find = True\n break",
"mae == ushiro",
"mae",
"ushiro",
"find = True",
"find",
"True",
"break",
"if find:\n print(N+i)\nelse:\n print(N*2)",
"find",
"print(N+i)",
"print",
"N+i",
"N",
"i",
"print(N*2)",
"print",
"N*2",
"N",
"2",
"find = True",
"True",
"find",
"ushiro = t[0:N-i]",
"t[0:N-i]",
"ushiro",
"s = input()",
"input()",
"s",
"t = input()",
"input()",
"t",
"N = int(input())",
"int(input())",
"N",
"mae = s[i:]",
"s[i:]",
"mae",
"find = False",
"False",
"find"
] |
N = int(input())
s = input()
t = input()
find = False
for i in range(N):
mae = s[i:]
ushiro = t[0:N-i]
if mae == ushiro:
find = True
break
if find:
print(N+i)
else:
print(N*2)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
14,
2,
13,
13,
4,
13,
4,
13,
13,
4,
13,
28,
13,
4,
13,
4,
13,
13,
0,
13,
2,
13,
4,
18,
17,
13,
18,
13,
39,
2,
40,
13,
17,
14,
2,
18,
13,
39,
2,
13,
17,
13,
4,
13,
4,
13,
13,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13
] |
[
[
65,
2
],
[
71,
8
],
[
74,
12
],
[
72,
17
],
[
75,
18
],
[
72,
23
],
[
28,
27
],
[
75,
32
],
[
68,
34
],
[
72,
36
],
[
75,
42
],
[
27,
46
],
[
69,
51
],
[
27,
54
],
[
75,
56
],
[
69,
61
],
[
65,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
]
] |
[
"N = int(input())\nS = input()\nT = input()\nif S == T:\n print(len(S))\n exit()\nfor i in range(len(T)):\n tmp = S+''.join(T[-i-1:])\n if tmp[i+1:] == T:\n print(len(tmp))\n exit() ",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"S = input()",
"S",
"input()",
"input",
"T = input()",
"T",
"input()",
"input",
"if S == T:\n print(len(S))\n exit()",
"S == T",
"S",
"T",
"print(len(S))",
"print",
"len(S)",
"len",
"S",
"exit()",
"exit",
"for i in range(len(T)):\n tmp = S+''.join(T[-i-1:])\n if tmp[i+1:] == T:\n print(len(tmp))\n exit() ",
"i",
"range(len(T))",
"range",
"len(T)",
"len",
"T",
"tmp = S+''.join(T[-i-1:])",
"tmp",
"S+''.join(T[-i-1:])",
"S",
"''.join(T[-i-1:])",
"''.join",
"''",
"join",
"T[-i-1:]",
"T",
"-i-1:",
"-i-1",
"-i",
"i",
"1",
"if tmp[i+1:] == T:\n print(len(tmp))\n exit() ",
"tmp[i+1:] == T",
"tmp[i+1:]",
"tmp",
"i+1:",
"i+1",
"i",
"1",
"T",
"print(len(tmp))",
"print",
"len(tmp)",
"len",
"tmp",
"exit()",
"exit",
"N = int(input())",
"int(input())",
"N",
"tmp = S+''.join(T[-i-1:])",
"S+''.join(T[-i-1:])",
"tmp",
"S = input()",
"input()",
"S",
"T = input()",
"input()",
"T"
] |
N = int(input())
S = input()
T = input()
if S == T:
print(len(S))
exit()
for i in range(len(T)):
tmp = S+''.join(T[-i-1:])
if tmp[i+1:] == T:
print(len(tmp))
exit()
|
[
7,
15,
13,
4,
18,
13,
13,
2,
17,
17,
0,
13,
18,
18,
13,
13,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
2,
17,
13,
28,
13,
4,
13,
13,
14,
2,
18,
13,
39,
13,
13,
18,
13,
39,
2,
13,
13,
4,
13,
2,
2,
17,
13,
2,
13,
13,
4,
13,
4,
13,
2,
17,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13
] |
[
[
74,
11
],
[
77,
18
],
[
75,
22
],
[
71,
24
],
[
75,
26
],
[
83,
28
],
[
75,
30
],
[
80,
32
],
[
78,
35
],
[
38,
37
],
[
78,
40
],
[
72,
44
],
[
84,
49
],
[
78,
52
],
[
37,
53
],
[
78,
59
],
[
78,
61
],
[
37,
62
],
[
78,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
]
] |
[
"import sys\nsys.setrecursionlimit(10 ** 7)\ninput = sys.stdin.readline\n\nn = int(input())\ns = input() #sys.stdin.readlineは最後が改行\nt = input() #sys.stdin.readlineは最後が改行\n\nans = 2*n\nfor i in range(n):\n if s[i:n] == t[:(n-i)]:\n print(2*n-(n-i))\n exit()\n\nprint(2*n)",
"import sys",
"sys",
"sys.setrecursionlimit(10 ** 7)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10 ** 7",
"10",
"7",
"input = sys.stdin.readline",
"input",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"ans = 2*n",
"ans",
"2*n",
"2",
"n",
"for i in range(n):\n if s[i:n] == t[:(n-i)]:\n print(2*n-(n-i))\n exit()",
"i",
"range(n)",
"range",
"n",
"if s[i:n] == t[:(n-i)]:\n print(2*n-(n-i))\n exit()",
"s[i:n] == t[:(n-i)]",
"s[i:n]",
"s",
"i:n",
"i",
"n",
"t[:(n-i)]",
"t",
":(n-i)",
"n-i",
"n",
"i",
"print(2*n-(n-i))",
"print",
"2*n-(n-i)",
"2*n",
"2",
"n",
"n-i",
"n",
"i",
"exit()",
"exit",
"print(2*n)",
"print",
"2*n",
"2",
"n",
"s = input()",
"input()",
"s",
"input = sys.stdin.readline",
"sys.stdin.readline",
"input",
"n = int(input())",
"int(input())",
"n",
"ans = 2*n",
"2*n",
"ans",
"t = input()",
"input()",
"t"
] |
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
n = int(input())
s = input() #sys.stdin.readlineは最後が改行
t = input() #sys.stdin.readlineは最後が改行
ans = 2*n
for i in range(n):
if s[i:n] == t[:(n-i)]:
print(2*n-(n-i))
exit()
print(2*n)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
2,
13,
13,
28,
13,
4,
13,
17,
2,
13,
17,
14,
2,
18,
13,
39,
40,
13,
18,
13,
39,
13,
0,
13,
2,
13,
18,
13,
39,
13,
4,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13
] |
[
[
59,
2
],
[
65,
8
],
[
53,
12
],
[
62,
16
],
[
66,
18
],
[
54,
19
],
[
22,
21
],
[
60,
26
],
[
66,
31
],
[
21,
34
],
[
54,
36
],
[
56,
40
],
[
66,
42
],
[
54,
44
],
[
57,
51
],
[
63,
51
],
[
53,
54
],
[
56,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
]
] |
[
"N = int(input())\nS = input()\nT = input()\nans = S+T\nfor i in range(1,N+1):\n #print(S[-i:],T[:i])\n if S[-i:] == T[:i]:\n ans = S + T[i:]\nprint(len(ans))",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"S = input()",
"S",
"input()",
"input",
"T = input()",
"T",
"input()",
"input",
"ans = S+T",
"ans",
"S+T",
"S",
"T",
"for i in range(1,N+1):\n #print(S[-i:],T[:i])\n if S[-i:] == T[:i]:\n ans = S + T[i:]",
"i",
"range(1,N+1)",
"range",
"1",
"N+1",
"N",
"1",
"if S[-i:] == T[:i]:\n ans = S + T[i:]",
"S[-i:] == T[:i]",
"S[-i:]",
"S",
"-i:",
"-i",
"i",
"T[:i]",
"T",
":i",
"i",
"ans = S + T[i:]",
"ans",
"S + T[i:]",
"S",
"T[i:]",
"T",
"i:",
"i",
"print(len(ans))",
"print",
"len(ans)",
"len",
"ans",
"T = input()",
"input()",
"T",
"ans = S + T[i:]",
"S + T[i:]",
"ans",
"N = int(input())",
"int(input())",
"N",
"ans = S+T",
"S+T",
"ans",
"S = input()",
"input()",
"S"
] |
N = int(input())
S = input()
T = input()
ans = S+T
for i in range(1,N+1):
#print(S[-i:],T[:i])
if S[-i:] == T[:i]:
ans = S + T[i:]
print(len(ans))
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
0,
13,
2,
13,
13,
28,
13,
4,
13,
4,
13,
4,
13,
13,
4,
13,
13,
14,
2,
18,
13,
39,
2,
17,
13,
18,
13,
39,
2,
13,
17,
0,
13,
2,
13,
18,
13,
39,
2,
13,
17,
4,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13
] |
[
[
66,
2
],
[
75,
8
],
[
72,
14
],
[
78,
20
],
[
76,
22
],
[
73,
23
],
[
26,
25
],
[
76,
32
],
[
73,
35
],
[
76,
39
],
[
25,
43
],
[
73,
45
],
[
25,
48
],
[
69,
51
],
[
76,
53
],
[
73,
55
],
[
25,
58
],
[
70,
64
],
[
79,
64
],
[
66,
67
],
[
69,
70
],
[
72,
73
],
[
75,
76
],
[
78,
79
]
] |
[
"N = int(input())\nS = str(input())\nT = str(input())\nans = S+T\nfor i in range(min(len(S),len(T))):\n if S[-1-i:] == T[:i+1]:\n ans = S+T[i+1:]\n\nprint(len(ans))",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"S = str(input())",
"S",
"str(input())",
"str",
"input()",
"input",
"T = str(input())",
"T",
"str(input())",
"str",
"input()",
"input",
"ans = S+T",
"ans",
"S+T",
"S",
"T",
"for i in range(min(len(S),len(T))):\n if S[-1-i:] == T[:i+1]:\n ans = S+T[i+1:]",
"i",
"range(min(len(S),len(T)))",
"range",
"min(len(S),len(T))",
"min",
"len(S)",
"len",
"S",
"len(T)",
"len",
"T",
"if S[-1-i:] == T[:i+1]:\n ans = S+T[i+1:]",
"S[-1-i:] == T[:i+1]",
"S[-1-i:]",
"S",
"-1-i:",
"-1-i",
"-1",
"i",
"T[:i+1]",
"T",
":i+1",
"i+1",
"i",
"1",
"ans = S+T[i+1:]",
"ans",
"S+T[i+1:]",
"S",
"T[i+1:]",
"T",
"i+1:",
"i+1",
"i",
"1",
"print(len(ans))",
"print",
"len(ans)",
"len",
"ans",
"N = int(input())",
"int(input())",
"N",
"ans = S+T[i+1:]",
"S+T[i+1:]",
"ans",
"T = str(input())",
"str(input())",
"T",
"S = str(input())",
"str(input())",
"S",
"ans = S+T",
"S+T",
"ans"
] |
N = int(input())
S = str(input())
T = str(input())
ans = S+T
for i in range(min(len(S),len(T))):
if S[-1-i:] == T[:i+1]:
ans = S+T[i+1:]
print(len(ans))
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
28,
13,
4,
13,
2,
13,
17,
0,
13,
2,
18,
13,
39,
13,
13,
14,
2,
2,
18,
13,
39,
13,
13,
2,
18,
13,
39,
40,
13,
13,
4,
13,
4,
13,
13,
3,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
58,
2
],
[
55,
8
],
[
61,
12
],
[
17,
16
],
[
59,
20
],
[
52,
23
],
[
56,
26
],
[
62,
29
],
[
53,
34
],
[
56,
37
],
[
53,
40
],
[
59,
43
],
[
62,
44
],
[
53,
49
],
[
52,
53
],
[
55,
56
],
[
58,
59
],
[
61,
62
]
] |
[
"# coding: utf-8\n# Your code here!\n\nN = int(input())\ns = input()\nt = input()\n\nfor i in range(N+1):\n string = s[:i]+t\n \n if string[:N] == s and string[-N:] == t:\n print(len(string))\n break",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"for i in range(N+1):\n string = s[:i]+t\n \n if string[:N] == s and string[-N:] == t:\n print(len(string))\n break",
"i",
"range(N+1)",
"range",
"N+1",
"N",
"1",
"string = s[:i]+t",
"string",
"s[:i]+t",
"s[:i]",
"s",
":i",
"i",
"t",
"if string[:N] == s and string[-N:] == t:\n print(len(string))\n break",
"string[:N] == s and string[-N:] == t",
"string[:N] == s",
"string[:N]",
"string",
":N",
"N",
"s",
"string[-N:] == t",
"string[-N:]",
"string",
"-N:",
"-N",
"N",
"t",
"print(len(string))",
"print",
"len(string)",
"len",
"string",
"break",
"string = s[:i]+t",
"s[:i]+t",
"string",
"s = input()",
"input()",
"s",
"N = int(input())",
"int(input())",
"N",
"t = input()",
"input()",
"t"
] |
# coding: utf-8
# Your code here!
N = int(input())
s = input()
t = input()
for i in range(N+1):
string = s[:i]+t
if string[:N] == s and string[-N:] == t:
print(len(string))
break
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
18,
13,
39,
40,
2,
13,
17,
18,
13,
39,
2,
13,
17,
0,
13,
2,
13,
17,
4,
13,
2,
2,
4,
13,
13,
4,
13,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13
] |
[
[
65,
2
],
[
77,
8
],
[
71,
12
],
[
80,
16
],
[
78,
21
],
[
72,
24
],
[
74,
26
],
[
30,
29
],
[
66,
32
],
[
78,
36
],
[
29,
40
],
[
72,
43
],
[
29,
46
],
[
68,
49
],
[
29,
51
],
[
78,
59
],
[
72,
62
],
[
69,
63
],
[
75,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
]
] |
[
"\nN=int(input())\nS=input()\nT=input()\nL=min(len(S), len(T))\n\ncount=0\nfor i in range(N):\n if S[-(i+1):]==T[:(i+1)]:\n count=(i+1)\n\nprint(len(S)+len(T)-count)",
"N=int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"S=input()",
"S",
"input()",
"input",
"T=input()",
"T",
"input()",
"input",
"L=min(len(S), len(T))",
"L",
"min(len(S), len(T))",
"min",
"len(S)",
"len",
"S",
"len(T)",
"len",
"T",
"count=0",
"count",
"0",
"for i in range(N):\n if S[-(i+1):]==T[:(i+1)]:\n count=(i+1)",
"i",
"range(N)",
"range",
"N",
"if S[-(i+1):]==T[:(i+1)]:\n count=(i+1)",
"S[-(i+1):]==T[:(i+1)]",
"S[-(i+1):]",
"S",
"-(i+1):",
"-(i+1)",
"i+1",
"i",
"1",
"T[:(i+1)]",
"T",
":(i+1)",
"i+1",
"i",
"1",
"count=(i+1)",
"count",
"i+1",
"i",
"1",
"print(len(S)+len(T)-count)",
"print",
"len(S)+len(T)-count",
"len(S)+len(T)",
"len(S)",
"len",
"S",
"len(T)",
"len",
"T",
"count",
"N=int(input())",
"int(input())",
"N",
"count=(i+1)",
"i+1",
"count",
"T=input()",
"input()",
"T",
"count=0",
"0",
"count",
"S=input()",
"input()",
"S",
"L=min(len(S), len(T))",
"min(len(S), len(T))",
"L"
] |
N=int(input())
S=input()
T=input()
L=min(len(S), len(T))
count=0
for i in range(N):
if S[-(i+1):]==T[:(i+1)]:
count=(i+1)
print(len(S)+len(T)-count)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
18,
13,
39,
2,
2,
13,
13,
17,
18,
13,
39,
2,
13,
17,
0,
13,
2,
13,
17,
4,
13,
2,
2,
17,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13
] |
[
[
64,
2
],
[
52,
8
],
[
58,
12
],
[
55,
16
],
[
20,
19
],
[
65,
22
],
[
53,
26
],
[
65,
30
],
[
19,
31
],
[
59,
34
],
[
19,
37
],
[
61,
40
],
[
19,
42
],
[
65,
49
],
[
62,
50
],
[
56,
50
],
[
52,
53
],
[
55,
56
],
[
58,
59
],
[
61,
62
],
[
64,
65
]
] |
[
"n = int(input())\nS = input()\nT = input()\ncnt = 0\nfor i in range(n):\n if S[n - i - 1:] == T[: i + 1]:\n cnt = i + 1\nprint(2*n-cnt)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"S = input()",
"S",
"input()",
"input",
"T = input()",
"T",
"input()",
"input",
"cnt = 0",
"cnt",
"0",
"for i in range(n):\n if S[n - i - 1:] == T[: i + 1]:\n cnt = i + 1",
"i",
"range(n)",
"range",
"n",
"if S[n - i - 1:] == T[: i + 1]:\n cnt = i + 1",
"S[n - i - 1:] == T[: i + 1]",
"S[n - i - 1:]",
"S",
"n - i - 1:",
"n - i - 1",
"n - i",
"n",
"i",
"1",
"T[: i + 1]",
"T",
": i + 1",
"i + 1",
"i",
"1",
"cnt = i + 1",
"cnt",
"i + 1",
"i",
"1",
"print(2*n-cnt)",
"print",
"2*n-cnt",
"2*n",
"2",
"n",
"cnt",
"S = input()",
"input()",
"S",
"cnt = 0",
"0",
"cnt",
"T = input()",
"input()",
"T",
"cnt = i + 1",
"i + 1",
"cnt",
"n = int(input())",
"int(input())",
"n"
] |
n = int(input())
S = input()
T = input()
cnt = 0
for i in range(n):
if S[n - i - 1:] == T[: i + 1]:
cnt = i + 1
print(2*n-cnt)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
18,
13,
39,
13,
18,
13,
39,
2,
13,
13,
0,
13,
2,
13,
13,
3,
4,
13,
2,
2,
17,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13
] |
[
[
49,
2
],
[
58,
8
],
[
55,
12
],
[
61,
16
],
[
20,
19
],
[
50,
22
],
[
59,
26
],
[
56,
30
],
[
50,
33
],
[
19,
34
],
[
52,
36
],
[
50,
38
],
[
19,
39
],
[
50,
46
],
[
53,
47
],
[
62,
47
],
[
49,
50
],
[
52,
53
],
[
55,
56
],
[
58,
59
],
[
61,
62
]
] |
[
"n=int(input())\ns=input()\nt=input()\nmatch = 0\n\nfor i in range(n):\n if s[i:] == t[:n-i]:\n match = n-i\n break\n\nprint(2*n-match)",
"n=int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s=input()",
"s",
"input()",
"input",
"t=input()",
"t",
"input()",
"input",
"match = 0",
"match",
"0",
"for i in range(n):\n if s[i:] == t[:n-i]:\n match = n-i\n break",
"i",
"range(n)",
"range",
"n",
"if s[i:] == t[:n-i]:\n match = n-i\n break",
"s[i:] == t[:n-i]",
"s[i:]",
"s",
"i:",
"i",
"t[:n-i]",
"t",
":n-i",
"n-i",
"n",
"i",
"match = n-i",
"match",
"n-i",
"n",
"i",
"break",
"print(2*n-match)",
"print",
"2*n-match",
"2*n",
"2",
"n",
"match",
"n=int(input())",
"int(input())",
"n",
"match = n-i",
"n-i",
"match",
"t=input()",
"input()",
"t",
"s=input()",
"input()",
"s",
"match = 0",
"0",
"match"
] |
n=int(input())
s=input()
t=input()
match = 0
for i in range(n):
if s[i:] == t[:n-i]:
match = n-i
break
print(2*n-match)
|
[
7,
15,
15,
15,
13,
15,
13,
12,
13,
29,
4,
13,
4,
13,
12,
13,
29,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
12,
13,
29,
4,
13,
12,
13,
29,
4,
18,
4,
13,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
14,
40,
13,
2,
4,
13,
13,
4,
13,
13,
4,
13,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
4,
13,
4,
13,
13,
4,
13,
13,
14,
2,
18,
13,
39,
2,
2,
13,
17,
17,
18,
13,
39,
2,
13,
17,
0,
13,
2,
13,
17,
4,
13,
2,
2,
4,
13,
13,
4,
13,
13,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13
] |
[
[
133,
41
],
[
119,
43
],
[
115,
45
],
[
139,
49
],
[
134,
54
],
[
116,
58
],
[
140,
61
],
[
134,
64
],
[
130,
68
],
[
72,
71
],
[
116,
78
],
[
140,
81
],
[
116,
85
],
[
71,
89
],
[
140,
93
],
[
71,
96
],
[
136,
99
],
[
71,
101
],
[
116,
109
],
[
140,
112
],
[
137,
113
],
[
131,
113
],
[
115,
116
],
[
130,
131
],
[
133,
134
],
[
136,
137
],
[
139,
140
]
] |
[
"from collections import defaultdict\nfrom collections import deque\nimport itertools\nimport math\n\ndef readInt():\n return int(input())\ndef readInts():\n return list(map(int, input().split()))\ndef readChar():\n return input()\ndef readChars():\n return input().split()\n\nn = readInt()\ns = input()\nt = input()\n\nif n>=len(s)+len(t):\n print(n)\n exit()\n\nde = 0\nfor i in range(min(len(s),len(t))):\n if s[i*-1-1:]==t[:i+1]:\n de = i+1\n\nprint(len(s)+len(t)-de)",
"from collections import defaultdict",
"from collections import deque",
"import itertools",
"itertools",
"import math",
"math",
"def readInt():\n return int(input())",
"readInt",
"return int(input())",
"int(input())",
"int",
"input()",
"input",
"def readInts():\n return list(map(int, input().split()))",
"readInts",
"return list(map(int, input().split()))",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"def readChar():\n return input()",
"readChar",
"return input()",
"input()",
"input",
"def readChars():\n return input().split()",
"readChars",
"return input().split()",
"input().split()",
"().split",
"()",
"input",
"split",
"n = readInt()",
"n",
"readInt()",
"readInt",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"if n>=len(s)+len(t):\n print(n)\n exit()",
"n>=len(s)+len(t)",
"n",
"len(s)+len(t)",
"len(s)",
"len",
"s",
"len(t)",
"len",
"t",
"print(n)",
"print",
"n",
"exit()",
"exit",
"de = 0",
"de",
"0",
"for i in range(min(len(s),len(t))):\n if s[i*-1-1:]==t[:i+1]:\n de = i+1",
"i",
"range(min(len(s),len(t)))",
"range",
"min(len(s),len(t))",
"min",
"len(s)",
"len",
"s",
"len(t)",
"len",
"t",
"if s[i*-1-1:]==t[:i+1]:\n de = i+1",
"s[i*-1-1:]==t[:i+1]",
"s[i*-1-1:]",
"s",
"i*-1-1:",
"i*-1-1",
"i*-1",
"i",
"-1",
"1",
"t[:i+1]",
"t",
":i+1",
"i+1",
"i",
"1",
"de = i+1",
"de",
"i+1",
"i",
"1",
"print(len(s)+len(t)-de)",
"print",
"len(s)+len(t)-de",
"len(s)+len(t)",
"len(s)",
"len",
"s",
"len(t)",
"len",
"t",
"de",
"s = input()",
"input()",
"s",
"def readInt():\n return int(input())",
"def readInt():\n return int(input())",
"readInt",
"def readInts():\n return list(map(int, input().split()))",
"def readInts():\n return list(map(int, input().split()))",
"readInts",
"def readChars():\n return input().split()",
"def readChars():\n return input().split()",
"readChars",
"def readChar():\n return input()",
"def readChar():\n return input()",
"readChar",
"de = 0",
"0",
"de",
"n = readInt()",
"readInt()",
"n",
"de = i+1",
"i+1",
"de",
"t = input()",
"input()",
"t"
] |
from collections import defaultdict
from collections import deque
import itertools
import math
def readInt():
return int(input())
def readInts():
return list(map(int, input().split()))
def readChar():
return input()
def readChars():
return input().split()
n = readInt()
s = input()
t = input()
if n>=len(s)+len(t):
print(n)
exit()
de = 0
for i in range(min(len(s),len(t))):
if s[i*-1-1:]==t[:i+1]:
de = i+1
print(len(s)+len(t)-de)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
14,
2,
13,
13,
4,
13,
13,
4,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
18,
13,
39,
13,
0,
13,
8,
2,
13,
17,
13,
18,
13,
39,
40,
13,
0,
13,
17,
28,
13,
4,
13,
4,
13,
13,
14,
2,
18,
13,
13,
18,
13,
13,
0,
13,
17,
0,
13,
4,
13,
13,
13,
4,
13,
2,
2,
17,
13,
13,
10,
17,
13,
10,
17,
13,
10,
18,
13,
10,
8,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13
] |
[
[
110,
2
],
[
101,
8
],
[
107,
12
],
[
102,
17
],
[
108,
18
],
[
111,
21
],
[
104,
26
],
[
30,
29
],
[
111,
32
],
[
92,
34
],
[
102,
36
],
[
95,
40
],
[
29,
43
],
[
108,
45
],
[
108,
47
],
[
29,
50
],
[
89,
52
],
[
56,
55
],
[
93,
60
],
[
93,
64
],
[
55,
65
],
[
96,
67
],
[
55,
68
],
[
86,
70
],
[
98,
73
],
[
105,
76
],
[
99,
76
],
[
87,
77
],
[
90,
77
],
[
111,
83
],
[
99,
84
],
[
105,
84
],
[
86,
87
],
[
89,
90
],
[
92,
93
],
[
95,
96
],
[
98,
99
],
[
101,
102
],
[
104,
105
],
[
107,
108
],
[
110,
111
]
] |
[
"N = int(input())\ns = input()\nt = input()\n\nif s == t:\n print(N)\n exit(0)\n\ncnt = 0\nfor i in range(N):\n tmp_s = s[i:]\n tmp_t = t if i == 0 else t[:-i]\n\n tmp_cnt = 0\n for j in range(len(tmp_s)):\n if tmp_s[j] == tmp_t[j]:\n tmp_cnt += 1\n\n cnt = max(cnt, tmp_cnt)\n\nprint(2 * N - cnt)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"if s == t:\n print(N)\n exit(0)",
"s == t",
"s",
"t",
"print(N)",
"print",
"N",
"exit(0)",
"exit",
"0",
"cnt = 0",
"cnt",
"0",
"for i in range(N):\n tmp_s = s[i:]\n tmp_t = t if i == 0 else t[:-i]\n\n tmp_cnt = 0\n for j in range(len(tmp_s)):\n if tmp_s[j] == tmp_t[j]:\n tmp_cnt += 1\n\n cnt = max(cnt, tmp_cnt)",
"i",
"range(N)",
"range",
"N",
"tmp_s = s[i:]",
"tmp_s",
"s[i:]",
"s",
"i:",
"i",
"tmp_t = t if i == 0 else t[:-i]",
"tmp_t",
"t if i == 0 else t[:-i]",
"i == 0",
"i",
"0",
"t",
"t[:-i]",
"t",
":-i",
"-i",
"i",
"tmp_cnt = 0",
"tmp_cnt",
"0",
"for j in range(len(tmp_s)):\n if tmp_s[j] == tmp_t[j]:\n tmp_cnt += 1\n\n ",
"j",
"range(len(tmp_s))",
"range",
"len(tmp_s)",
"len",
"tmp_s",
"if tmp_s[j] == tmp_t[j]:\n tmp_cnt += 1\n\n ",
"tmp_s[j] == tmp_t[j]",
"tmp_s[j]",
"tmp_s",
"j",
"tmp_t[j]",
"tmp_t",
"j",
"tmp_cnt += 1",
"tmp_cnt",
"1",
"cnt = max(cnt, tmp_cnt)",
"cnt",
"max(cnt, tmp_cnt)",
"max",
"cnt",
"tmp_cnt",
"print(2 * N - cnt)",
"print",
"2 * N - cnt",
"2 * N",
"2",
"N",
"cnt",
"tmp_cnt += 1",
"1",
"tmp_cnt",
"tmp_cnt = 0",
"0",
"tmp_cnt",
"tmp_s = s[i:]",
"s[i:]",
"tmp_s",
"tmp_t = t if i == 0 else t[:-i]",
"t if i == 0 else t[:-i]",
"tmp_t",
"cnt = max(cnt, tmp_cnt)",
"max(cnt, tmp_cnt)",
"cnt",
"s = input()",
"input()",
"s",
"cnt = 0",
"0",
"cnt",
"t = input()",
"input()",
"t",
"N = int(input())",
"int(input())",
"N"
] |
N = int(input())
s = input()
t = input()
if s == t:
print(N)
exit(0)
cnt = 0
for i in range(N):
tmp_s = s[i:]
tmp_t = t if i == 0 else t[:-i]
tmp_cnt = 0
for j in range(len(tmp_s)):
if tmp_s[j] == tmp_t[j]:
tmp_cnt += 1
cnt = max(cnt, tmp_cnt)
print(2 * N - cnt)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
0,
13,
2,
13,
13,
28,
13,
4,
13,
4,
13,
4,
13,
13,
4,
13,
13,
14,
2,
18,
13,
39,
2,
17,
13,
18,
13,
39,
2,
13,
17,
0,
13,
2,
13,
18,
13,
39,
2,
13,
17,
4,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13
] |
[
[
75,
2
],
[
69,
8
],
[
66,
14
],
[
72,
20
],
[
70,
22
],
[
67,
23
],
[
26,
25
],
[
70,
32
],
[
67,
35
],
[
70,
39
],
[
25,
43
],
[
67,
45
],
[
25,
48
],
[
78,
51
],
[
70,
53
],
[
67,
55
],
[
25,
58
],
[
79,
64
],
[
73,
64
],
[
66,
67
],
[
69,
70
],
[
72,
73
],
[
75,
76
],
[
78,
79
]
] |
[
"n = int(input())\ns = str(input())\nt = str(input())\nval = s+t\nfor i in range(min(len(s),len(t))):\n if s[-1-i:] == t[:i+1]:\n val = s+t[i+1:]\n \nprint(len(val))",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = str(input())",
"s",
"str(input())",
"str",
"input()",
"input",
"t = str(input())",
"t",
"str(input())",
"str",
"input()",
"input",
"val = s+t",
"val",
"s+t",
"s",
"t",
"for i in range(min(len(s),len(t))):\n if s[-1-i:] == t[:i+1]:\n val = s+t[i+1:]\n ",
"i",
"range(min(len(s),len(t)))",
"range",
"min(len(s),len(t))",
"min",
"len(s)",
"len",
"s",
"len(t)",
"len",
"t",
"if s[-1-i:] == t[:i+1]:\n val = s+t[i+1:]\n ",
"s[-1-i:] == t[:i+1]",
"s[-1-i:]",
"s",
"-1-i:",
"-1-i",
"-1",
"i",
"t[:i+1]",
"t",
":i+1",
"i+1",
"i",
"1",
"val = s+t[i+1:]",
"val",
"s+t[i+1:]",
"s",
"t[i+1:]",
"t",
"i+1:",
"i+1",
"i",
"1",
"print(len(val))",
"print",
"len(val)",
"len",
"val",
"t = str(input())",
"str(input())",
"t",
"s = str(input())",
"str(input())",
"s",
"val = s+t",
"s+t",
"val",
"n = int(input())",
"int(input())",
"n",
"val = s+t[i+1:]",
"s+t[i+1:]",
"val"
] |
n = int(input())
s = str(input())
t = str(input())
val = s+t
for i in range(min(len(s),len(t))):
if s[-1-i:] == t[:i+1]:
val = s+t[i+1:]
print(len(val))
|
[
7,
12,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
28,
13,
4,
13,
13,
14,
2,
18,
13,
39,
13,
18,
13,
39,
2,
13,
13,
4,
13,
2,
13,
13,
3,
4,
13,
2,
17,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13
] |
[
[
5,
4
],
[
11,
10
],
[
15,
14
],
[
19,
18
],
[
4,
21
],
[
10,
25
],
[
14,
29
],
[
4,
32
],
[
18,
33
],
[
4,
37
],
[
18,
38
],
[
4,
44
],
[
53,
50
]
] |
[
"def main():\n n = int(input())\n s = input()\n t = input()\n\n for i in range(n):\n if s[i:] == t[:n - i]:\n print(n + i)\n break\n else:\n print(2 * n)\n\n\nif __name__ == \"__main__\":\n main()",
"def main():\n n = int(input())\n s = input()\n t = input()\n\n for i in range(n):\n if s[i:] == t[:n - i]:\n print(n + i)\n break\n else:\n print(2 * n)",
"main",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"for i in range(n):\n if s[i:] == t[:n - i]:\n print(n + i)\n break\n else:\n print(2 * n)",
"i",
"range(n)",
"range",
"n",
"if s[i:] == t[:n - i]:\n print(n + i)\n break\n ",
"s[i:] == t[:n - i]",
"s[i:]",
"s",
"i:",
"i",
"t[:n - i]",
"t",
":n - i",
"n - i",
"n",
"i",
"print(n + i)",
"print",
"n + i",
"n",
"i",
"break",
"print(2 * n)",
"print",
"2 * n",
"2",
"n",
"if __name__ == \"__main__\":\n main()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"main()",
"main",
"def main():\n n = int(input())\n s = input()\n t = input()\n\n for i in range(n):\n if s[i:] == t[:n - i]:\n print(n + i)\n break\n else:\n print(2 * n)",
"def main():\n n = int(input())\n s = input()\n t = input()\n\n for i in range(n):\n if s[i:] == t[:n - i]:\n print(n + i)\n break\n else:\n print(2 * n)",
"main"
] |
def main():
n = int(input())
s = input()
t = input()
for i in range(n):
if s[i:] == t[:n - i]:
print(n + i)
break
else:
print(2 * n)
if __name__ == "__main__":
main()
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
14,
2,
13,
13,
4,
13,
13,
4,
13,
28,
13,
4,
13,
17,
13,
0,
13,
18,
13,
39,
13,
13,
0,
13,
18,
13,
39,
17,
2,
13,
13,
14,
2,
13,
13,
0,
13,
2,
18,
13,
39,
13,
13,
4,
13,
4,
13,
13,
4,
13,
4,
13,
2,
17,
13,
10,
18,
13,
10,
18,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
87,
2
],
[
90,
8
],
[
84,
14
],
[
91,
21
],
[
85,
22
],
[
88,
25
],
[
30,
29
],
[
88,
33
],
[
75,
35
],
[
91,
37
],
[
78,
42
],
[
85,
44
],
[
88,
48
],
[
29,
49
],
[
76,
52
],
[
79,
53
],
[
81,
55
],
[
91,
58
],
[
85,
61
],
[
82,
66
],
[
88,
73
],
[
75,
76
],
[
78,
79
],
[
81,
82
],
[
84,
85
],
[
87,
88
],
[
90,
91
]
] |
[
"n = int(input())\ns = str(input())\nt = str(input())\n\nif s == t:\n print(n)\n exit()\n\nfor i in range(1, n):\n s_ = s[i:n]\n t_ = t[0:n-i]\n if s_ == t_:\n ans = s[:i]+t\n print(len(ans))\n exit()\nelse:\n print(2*n)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = str(input())",
"s",
"str(input())",
"str",
"input()",
"input",
"t = str(input())",
"t",
"str(input())",
"str",
"input()",
"input",
"if s == t:\n print(n)\n exit()",
"s == t",
"s",
"t",
"print(n)",
"print",
"n",
"exit()",
"exit",
"for i in range(1, n):\n s_ = s[i:n]\n t_ = t[0:n-i]\n if s_ == t_:\n ans = s[:i]+t\n print(len(ans))\n exit()\nelse:\n print(2*n)",
"i",
"range(1, n)",
"range",
"1",
"n",
"s_ = s[i:n]",
"s_",
"s[i:n]",
"s",
"i:n",
"i",
"n",
"t_ = t[0:n-i]",
"t_",
"t[0:n-i]",
"t",
"0:n-i",
"0",
"n-i",
"n",
"i",
"if s_ == t_:\n ans = s[:i]+t\n print(len(ans))\n exit()",
"s_ == t_",
"s_",
"t_",
"ans = s[:i]+t",
"ans",
"s[:i]+t",
"s[:i]",
"s",
":i",
"i",
"t",
"print(len(ans))",
"print",
"len(ans)",
"len",
"ans",
"exit()",
"exit",
"print(2*n)",
"print",
"2*n",
"2",
"n",
"s_ = s[i:n]",
"s[i:n]",
"s_",
"t_ = t[0:n-i]",
"t[0:n-i]",
"t_",
"ans = s[:i]+t",
"s[:i]+t",
"ans",
"t = str(input())",
"str(input())",
"t",
"n = int(input())",
"int(input())",
"n",
"s = str(input())",
"str(input())",
"s"
] |
n = int(input())
s = str(input())
t = str(input())
if s == t:
print(n)
exit()
for i in range(1, n):
s_ = s[i:n]
t_ = t[0:n-i]
if s_ == t_:
ans = s[:i]+t
print(len(ans))
exit()
else:
print(2*n)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
17,
0,
13,
17,
0,
13,
13,
42,
2,
2,
13,
13,
40,
18,
13,
39,
13,
18,
13,
39,
13,
0,
13,
17,
0,
13,
17,
4,
13,
2,
2,
17,
13,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13
] |
[
[
73,
2
],
[
70,
8
],
[
58,
12
],
[
67,
16
],
[
52,
19
],
[
61,
22
],
[
74,
23
],
[
53,
27
],
[
65,
27
],
[
74,
28
],
[
71,
31
],
[
59,
35
],
[
64,
39
],
[
55,
42
],
[
74,
49
],
[
56,
50
],
[
62,
50
],
[
52,
53
],
[
55,
56
],
[
58,
59
],
[
74,
61
],
[
61,
62
],
[
64,
65
],
[
67,
68
],
[
70,
71
],
[
73,
74
]
] |
[
"n = int(input())\na = input()\nb = input()\nans = ''\nidx1 = 0\nidx2 = n\nwhile idx1 < n and a[idx1:] != b[:idx2]:\n idx1+=1\n idx2-=1\nprint(2*n - idx2)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a = input()",
"a",
"input()",
"input",
"b = input()",
"b",
"input()",
"input",
"ans = ''",
"ans",
"''",
"idx1 = 0",
"idx1",
"0",
"idx2 = n",
"idx2",
"n",
"while idx1 < n and a[idx1:] != b[:idx2]:\n idx1+=1\n idx2-=1",
"idx1 < n and a[idx1:] != b[:idx2]",
"idx1 < n",
"idx1",
"n",
"a[idx1:] != b[:idx2]",
"a[idx1:]",
"a",
"idx1:",
"idx1",
"b[:idx2]",
"b",
":idx2",
"idx2",
"idx1+=1",
"idx1",
"1",
"idx2-=1",
"idx2",
"1",
"print(2*n - idx2)",
"print",
"2*n - idx2",
"2*n",
"2",
"n",
"idx2",
"idx1 = 0",
"0",
"idx1",
"idx2-=1",
"1",
"idx2",
"b = input()",
"input()",
"b",
"idx2 = n",
"n",
"idx2",
"idx1+=1",
"1",
"idx1",
"ans = ''",
"''",
"ans",
"a = input()",
"input()",
"a",
"n = int(input())",
"int(input())",
"n"
] |
n = int(input())
a = input()
b = input()
ans = ''
idx1 = 0
idx2 = n
while idx1 < n and a[idx1:] != b[:idx2]:
idx1+=1
idx2-=1
print(2*n - idx2)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
0,
13,
2,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
17,
0,
13,
18,
13,
39,
13,
28,
13,
13,
4,
13,
13,
13,
14,
2,
13,
13,
0,
13,
17,
3,
0,
13,
4,
13,
13,
13,
4,
13,
2,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
18,
13
] |
[
[
68,
2
],
[
83,
8
],
[
74,
14
],
[
80,
20
],
[
69,
22
],
[
86,
25
],
[
29,
28
],
[
69,
31
],
[
89,
33
],
[
92,
36
],
[
84,
38
],
[
93,
46
],
[
75,
47
],
[
71,
53
],
[
77,
57
],
[
87,
60
],
[
78,
60
],
[
72,
61
],
[
90,
61
],
[
81,
65
],
[
78,
66
],
[
87,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
],
[
89,
90
],
[
92,
93
]
] |
[
"N = int(input())\ns = list(input())\nt = list(input())\nN2 = N * 2\nans = 0\nfor i in range(N):\n temp = 0\n ns = s[i:]\n for j, k in zip(ns, t):\n if j == k:\n temp += 1\n else:\n break\n else:\n ans = max(ans, temp)\n\nprint(N2 - ans)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s = list(input())",
"s",
"list(input())",
"list",
"input()",
"input",
"t = list(input())",
"t",
"list(input())",
"list",
"input()",
"input",
"N2 = N * 2",
"N2",
"N * 2",
"N",
"2",
"ans = 0",
"ans",
"0",
"for i in range(N):\n temp = 0\n ns = s[i:]\n for j, k in zip(ns, t):\n if j == k:\n temp += 1\n else:\n break\n else:\n ans = max(ans, temp)",
"i",
"range(N)",
"range",
"N",
"temp = 0",
"temp",
"0",
"ns = s[i:]",
"ns",
"s[i:]",
"s",
"i:",
"i",
"for j, k in zip(ns, t):\n if j == k:\n temp += 1\n else:\n break\n else:\n ans = max(ans, temp)",
"j",
"k",
"zip(ns, t)",
"zip",
"ns",
"t",
"if j == k:\n temp += 1\n else:\n break\n ",
"j == k",
"j",
"k",
"temp += 1",
"temp",
"1",
"break",
"ans = max(ans, temp)",
"ans",
"max(ans, temp)",
"max",
"ans",
"temp",
"print(N2 - ans)",
"print",
"N2 - ans",
"N2",
"ans",
"N = int(input())",
"int(input())",
"N",
"temp += 1",
"1",
"temp",
"t = list(input())",
"list(input())",
"t",
"ans = max(ans, temp)",
"max(ans, temp)",
"ans",
"N2 = N * 2",
"N * 2",
"N2",
"s = list(input())",
"list(input())",
"s",
"ans = 0",
"0",
"ans",
"temp = 0",
"0",
"temp",
"ns = s[i:]",
"s[i:]",
"ns"
] |
N = int(input())
s = list(input())
t = list(input())
N2 = N * 2
ans = 0
for i in range(N):
temp = 0
ns = s[i:]
for j, k in zip(ns, t):
if j == k:
temp += 1
else:
break
else:
ans = max(ans, temp)
print(N2 - ans)
|
[
7,
15,
13,
0,
13,
18,
18,
13,
13,
13,
12,
13,
0,
13,
17,
0,
13,
4,
13,
4,
13,
0,
13,
4,
18,
4,
13,
13,
17,
0,
13,
4,
18,
4,
13,
13,
17,
28,
13,
4,
13,
13,
14,
2,
18,
13,
39,
13,
18,
13,
39,
2,
13,
13,
4,
13,
2,
13,
13,
3,
4,
13,
2,
13,
17,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
18,
13
] |
[
[
75,
4
],
[
14,
13
],
[
17,
16
],
[
76,
20
],
[
23,
22
],
[
76,
26
],
[
31,
30
],
[
76,
34
],
[
39,
38
],
[
16,
41
],
[
22,
45
],
[
30,
49
],
[
16,
52
],
[
38,
53
],
[
16,
57
],
[
38,
58
],
[
16,
63
],
[
73,
70
],
[
75,
76
]
] |
[
"import sys\n\ninput = sys.stdin.readline\n\ndef main():\n ans = 0\n n = int(input())\n s = input().rstrip('\\n')\n t = input().rstrip('\\n')\n for i in range(n):\n if s[i:] == t[:n-i]:\n print(n+i)\n break\n else:\n print(n*2)\n \nif __name__ == '__main__':\n main()",
"import sys",
"sys",
"input = sys.stdin.readline",
"input",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"def main():\n ans = 0\n n = int(input())\n s = input().rstrip('\\n')\n t = input().rstrip('\\n')\n for i in range(n):\n if s[i:] == t[:n-i]:\n print(n+i)\n break\n else:\n print(n*2)\n ",
"main",
"ans = 0",
"ans",
"0",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = input().rstrip('\\n')",
"s",
"input().rstrip('\\n')",
"().rstrip",
"()",
"input",
"rstrip",
"'\\n'",
"t = input().rstrip('\\n')",
"t",
"input().rstrip('\\n')",
"().rstrip",
"()",
"input",
"rstrip",
"'\\n'",
"for i in range(n):\n if s[i:] == t[:n-i]:\n print(n+i)\n break\n else:\n print(n*2)\n ",
"i",
"range(n)",
"range",
"n",
"if s[i:] == t[:n-i]:\n print(n+i)\n break\n ",
"s[i:] == t[:n-i]",
"s[i:]",
"s",
"i:",
"i",
"t[:n-i]",
"t",
":n-i",
"n-i",
"n",
"i",
"print(n+i)",
"print",
"n+i",
"n",
"i",
"break",
"print(n*2)",
"print",
"n*2",
"n",
"2",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def main():\n ans = 0\n n = int(input())\n s = input().rstrip('\\n')\n t = input().rstrip('\\n')\n for i in range(n):\n if s[i:] == t[:n-i]:\n print(n+i)\n break\n else:\n print(n*2)\n ",
"def main():\n ans = 0\n n = int(input())\n s = input().rstrip('\\n')\n t = input().rstrip('\\n')\n for i in range(n):\n if s[i:] == t[:n-i]:\n print(n+i)\n break\n else:\n print(n*2)\n ",
"main",
"input = sys.stdin.readline",
"sys.stdin.readline",
"input"
] |
import sys
input = sys.stdin.readline
def main():
ans = 0
n = int(input())
s = input().rstrip('\n')
t = input().rstrip('\n')
for i in range(n):
if s[i:] == t[:n-i]:
print(n+i)
break
else:
print(n*2)
if __name__ == '__main__':
main()
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
2,
13,
13,
28,
13,
4,
13,
17,
2,
4,
13,
13,
13,
17,
14,
2,
18,
13,
39,
2,
13,
13,
18,
13,
39,
13,
0,
13,
2,
2,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13
] |
[
[
67,
2
],
[
79,
8
],
[
64,
12
],
[
70,
16
],
[
80,
19
],
[
73,
21
],
[
65,
24
],
[
76,
26
],
[
71,
28
],
[
74,
29
],
[
32,
31
],
[
71,
38
],
[
74,
39
],
[
80,
44
],
[
71,
47
],
[
31,
48
],
[
65,
50
],
[
82,
54
],
[
71,
57
],
[
74,
58
],
[
31,
59
],
[
83,
62
],
[
77,
62
],
[
64,
65
],
[
67,
68
],
[
70,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
]
] |
[
"N = int(input())\ns = input()\nt = input()\nl1 = len(s)\nl2 = len(t)\nans = l1+l2\nfor i in range(1,min(l1,l2)+1):\n if s[l1-i:] == t[:i]:\n ans = l1+l2-i\nprint(ans)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"l1 = len(s)",
"l1",
"len(s)",
"len",
"s",
"l2 = len(t)",
"l2",
"len(t)",
"len",
"t",
"ans = l1+l2",
"ans",
"l1+l2",
"l1",
"l2",
"for i in range(1,min(l1,l2)+1):\n if s[l1-i:] == t[:i]:\n ans = l1+l2-i",
"i",
"range(1,min(l1,l2)+1)",
"range",
"1",
"min(l1,l2)+1",
"min(l1,l2)",
"min",
"l1",
"l2",
"1",
"if s[l1-i:] == t[:i]:\n ans = l1+l2-i",
"s[l1-i:] == t[:i]",
"s[l1-i:]",
"s",
"l1-i:",
"l1-i",
"l1",
"i",
"t[:i]",
"t",
":i",
"i",
"ans = l1+l2-i",
"ans",
"l1+l2-i",
"l1+l2",
"l1",
"l2",
"i",
"print(ans)",
"print",
"ans",
"t = input()",
"input()",
"t",
"N = int(input())",
"int(input())",
"N",
"l1 = len(s)",
"len(s)",
"l1",
"l2 = len(t)",
"len(t)",
"l2",
"ans = l1+l2",
"l1+l2",
"ans",
"s = input()",
"input()",
"s",
"ans = l1+l2-i",
"l1+l2-i",
"ans"
] |
N = int(input())
s = input()
t = input()
l1 = len(s)
l2 = len(t)
ans = l1+l2
for i in range(1,min(l1,l2)+1):
if s[l1-i:] == t[:i]:
ans = l1+l2-i
print(ans)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
28,
13,
4,
13,
2,
13,
17,
14,
2,
18,
13,
39,
13,
18,
13,
39,
2,
13,
13,
4,
13,
2,
13,
13,
4,
13,
4,
13,
2,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
57,
2
],
[
54,
8
],
[
51,
14
],
[
21,
20
],
[
58,
24
],
[
55,
29
],
[
52,
33
],
[
58,
36
],
[
20,
37
],
[
58,
41
],
[
20,
42
],
[
58,
49
],
[
51,
52
],
[
54,
55
],
[
57,
58
]
] |
[
"n=int(input())\ns=list(input())\nt=list(input())\n\nfor i in range(n+1):\n if s[i:]==t[:n-i]:\n print(n+i)\n exit()\nprint(2*n)\n\n\n",
"n=int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s=list(input())",
"s",
"list(input())",
"list",
"input()",
"input",
"t=list(input())",
"t",
"list(input())",
"list",
"input()",
"input",
"for i in range(n+1):\n if s[i:]==t[:n-i]:\n print(n+i)\n exit()",
"i",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"if s[i:]==t[:n-i]:\n print(n+i)\n exit()",
"s[i:]==t[:n-i]",
"s[i:]",
"s",
"i:",
"i",
"t[:n-i]",
"t",
":n-i",
"n-i",
"n",
"i",
"print(n+i)",
"print",
"n+i",
"n",
"i",
"exit()",
"exit",
"print(2*n)",
"print",
"2*n",
"2",
"n",
"t=list(input())",
"list(input())",
"t",
"s=list(input())",
"list(input())",
"s",
"n=int(input())",
"int(input())",
"n"
] |
n=int(input())
s=list(input())
t=list(input())
for i in range(n+1):
if s[i:]==t[:n-i]:
print(n+i)
exit()
print(2*n)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
2,
13,
17,
28,
13,
4,
13,
13,
17,
17,
14,
2,
18,
13,
39,
2,
13,
13,
18,
13,
39,
13,
0,
13,
2,
2,
13,
17,
13,
3,
4,
13,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
60,
2
],
[
57,
8
],
[
63,
12
],
[
51,
16
],
[
61,
18
],
[
22,
21
],
[
61,
24
],
[
58,
30
],
[
61,
33
],
[
21,
34
],
[
64,
36
],
[
54,
40
],
[
61,
43
],
[
21,
45
],
[
55,
49
],
[
52,
49
],
[
51,
52
],
[
54,
55
],
[
57,
58
],
[
60,
61
],
[
63,
64
]
] |
[
"n = int(input())\ns = input()\nt = input()\n\nans=n*2\nfor i in range(n,-1,-1):\n if s[n-i:]==t[:i]:\n ans=n*2-i\n break\nprint(ans)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"ans=n*2",
"ans",
"n*2",
"n",
"2",
"for i in range(n,-1,-1):\n if s[n-i:]==t[:i]:\n ans=n*2-i\n break",
"i",
"range(n,-1,-1)",
"range",
"n",
"-1",
"-1",
"if s[n-i:]==t[:i]:\n ans=n*2-i\n break",
"s[n-i:]==t[:i]",
"s[n-i:]",
"s",
"n-i:",
"n-i",
"n",
"i",
"t[:i]",
"t",
":i",
"i",
"ans=n*2-i",
"ans",
"n*2-i",
"n*2",
"n",
"2",
"i",
"break",
"print(ans)",
"print",
"ans",
"ans=n*2",
"n*2",
"ans",
"ans=n*2-i",
"n*2-i",
"ans",
"s = input()",
"input()",
"s",
"n = int(input())",
"int(input())",
"n",
"t = input()",
"input()",
"t"
] |
n = int(input())
s = input()
t = input()
ans=n*2
for i in range(n,-1,-1):
if s[n-i:]==t[:i]:
ans=n*2-i
break
print(ans)
|
[
7,
12,
13,
14,
2,
2,
18,
13,
39,
13,
13,
2,
18,
13,
39,
40,
13,
13,
29,
17,
29,
17,
23,
13,
23,
13,
23,
13,
23,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
2,
13,
17,
28,
13,
4,
13,
13,
0,
13,
18,
13,
39,
2,
13,
13,
0,
13,
2,
13,
13,
14,
4,
13,
13,
13,
13,
13,
14,
2,
13,
4,
13,
13,
0,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
2,
13,
10,
18,
13,
10,
2,
13,
10,
4,
13
] |
[
[
23,
7
],
[
27,
10
],
[
23,
13
],
[
25,
16
],
[
29,
17
],
[
23,
23
],
[
25,
25
],
[
27,
27
],
[
29,
29
],
[
95,
31
],
[
89,
37
],
[
110,
41
],
[
101,
45
],
[
96,
47
],
[
51,
50
],
[
96,
53
],
[
104,
55
],
[
111,
57
],
[
96,
60
],
[
50,
61
],
[
107,
63
],
[
90,
65
],
[
105,
66
],
[
99,
69
],
[
108,
70
],
[
96,
71
],
[
90,
72
],
[
111,
73
],
[
102,
76
],
[
93,
76
],
[
108,
79
],
[
92,
81
],
[
108,
84
],
[
93,
87
],
[
102,
87
],
[
89,
90
],
[
92,
93
],
[
95,
96
],
[
101,
102
],
[
104,
105
],
[
107,
108
],
[
110,
111
]
] |
[
"# AtCoder Grand Contest 006\n# A - Prefix and Suffix\n\ndef f(word,N,S,T):\n if word[:N]==S and word[-N:]==T:\n return True\n else :\n return False\n\n\nN=int(input())\nS=input()\nT=input()\n\nans = N*2\n\nfor i in range (N):\n t=T[N-i:]\n word=S+t\n\n if f(word,N,S,T):\n if ans>len(word):\n ans=len(word)\n else:\n pass\n\nprint(ans)",
"def f(word,N,S,T):\n if word[:N]==S and word[-N:]==T:\n return True\n else :\n return False",
"f",
"if word[:N]==S and word[-N:]==T:\n return True\n else :\n return False",
"word[:N]==S and word[-N:]==T",
"word[:N]==S",
"word[:N]",
"word",
":N",
"N",
"S",
"word[-N:]==T",
"word[-N:]",
"word",
"-N:",
"-N",
"N",
"T",
"return True",
"True",
"return False",
"False",
"word",
"word",
"N",
"N",
"S",
"S",
"T",
"T",
"N=int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"S=input()",
"S",
"input()",
"input",
"T=input()",
"T",
"input()",
"input",
"ans = N*2",
"ans",
"N*2",
"N",
"2",
"for i in range (N):\n t=T[N-i:]\n word=S+t\n\n if f(word,N,S,T):\n if ans>len(word):\n ans=len(word)\n else:\n pass",
"i",
"range (N)",
"range",
"N",
"t=T[N-i:]",
"t",
"T[N-i:]",
"T",
"N-i:",
"N-i",
"N",
"i",
"word=S+t",
"word",
"S+t",
"S",
"t",
"if f(word,N,S,T):\n if ans>len(word):\n ans=len(word)\n else:\n pass",
"f(word,N,S,T)",
"f",
"word",
"N",
"S",
"T",
"if ans>len(word):\n ans=len(word)\n ",
"ans>len(word)",
"ans",
"len(word)",
"len",
"word",
"ans=len(word)",
"ans",
"len(word)",
"len",
"word",
"print(ans)",
"print",
"ans",
"S=input()",
"input()",
"S",
"ans=len(word)",
"len(word)",
"ans",
"N=int(input())",
"int(input())",
"N",
"def f(word,N,S,T):\n if word[:N]==S and word[-N:]==T:\n return True\n else :\n return False",
"def f(word,N,S,T):\n if word[:N]==S and word[-N:]==T:\n return True\n else :\n return False",
"f",
"ans = N*2",
"N*2",
"ans",
"t=T[N-i:]",
"T[N-i:]",
"t",
"word=S+t",
"S+t",
"word",
"T=input()",
"input()",
"T"
] |
# AtCoder Grand Contest 006
# A - Prefix and Suffix
def f(word,N,S,T):
if word[:N]==S and word[-N:]==T:
return True
else :
return False
N=int(input())
S=input()
T=input()
ans = N*2
for i in range (N):
t=T[N-i:]
word=S+t
if f(word,N,S,T):
if ans>len(word):
ans=len(word)
else:
pass
print(ans)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
2,
17,
13,
28,
13,
4,
13,
13,
0,
13,
18,
13,
39,
13,
13,
0,
13,
18,
13,
39,
17,
2,
13,
13,
14,
2,
13,
13,
0,
13,
2,
13,
13,
3,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
18,
13,
10,
4,
13,
10,
18,
13
] |
[
[
61,
2
],
[
70,
8
],
[
58,
12
],
[
55,
16
],
[
62,
19
],
[
22,
21
],
[
62,
24
],
[
73,
26
],
[
71,
28
],
[
67,
33
],
[
59,
35
],
[
62,
39
],
[
21,
40
],
[
74,
43
],
[
68,
44
],
[
64,
46
],
[
62,
48
],
[
21,
49
],
[
65,
53
],
[
56,
53
],
[
55,
56
],
[
58,
59
],
[
61,
62
],
[
64,
65
],
[
67,
68
],
[
70,
71
],
[
73,
74
]
] |
[
"N = int(input())\ns = input()\nt = input()\nans = 2*N\nfor i in range(N):\n ss = s[i:N]\n tt = t[0:N-i]\n if (ss == tt):\n ans = N+i\n break\nprint(ans)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"ans = 2*N",
"ans",
"2*N",
"2",
"N",
"for i in range(N):\n ss = s[i:N]\n tt = t[0:N-i]\n if (ss == tt):\n ans = N+i\n break",
"i",
"range(N)",
"range",
"N",
"ss = s[i:N]",
"ss",
"s[i:N]",
"s",
"i:N",
"i",
"N",
"tt = t[0:N-i]",
"tt",
"t[0:N-i]",
"t",
"0:N-i",
"0",
"N-i",
"N",
"i",
"if (ss == tt):\n ans = N+i\n break",
"ss == tt",
"ss",
"tt",
"ans = N+i",
"ans",
"N+i",
"N",
"i",
"break",
"print(ans)",
"print",
"ans",
"ans = 2*N",
"2*N",
"ans",
"t = input()",
"input()",
"t",
"N = int(input())",
"int(input())",
"N",
"ans = N+i",
"N+i",
"ans",
"tt = t[0:N-i]",
"t[0:N-i]",
"tt",
"s = input()",
"input()",
"s",
"ss = s[i:N]",
"s[i:N]",
"ss"
] |
N = int(input())
s = input()
t = input()
ans = 2*N
for i in range(N):
ss = s[i:N]
tt = t[0:N-i]
if (ss == tt):
ans = N+i
break
print(ans)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
4,
13,
4,
13,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
18,
13,
2,
2,
2,
4,
13,
13,
17,
13,
13,
18,
13,
13,
0,
13,
17,
0,
13,
4,
13,
13,
13,
0,
13,
2,
2,
4,
13,
13,
4,
13,
13,
13,
14,
2,
13,
13,
0,
13,
13,
4,
13,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13
] |
[
[
109,
2
],
[
112,
8
],
[
97,
14
],
[
91,
20
],
[
24,
23
],
[
113,
30
],
[
98,
33
],
[
103,
35
],
[
39,
38
],
[
23,
42
],
[
113,
47
],
[
113,
53
],
[
23,
55
],
[
38,
56
],
[
98,
58
],
[
38,
59
],
[
100,
61
],
[
106,
64
],
[
92,
67
],
[
107,
67
],
[
101,
68
],
[
104,
68
],
[
115,
70
],
[
113,
75
],
[
98,
78
],
[
107,
79
],
[
92,
79
],
[
116,
82
],
[
110,
83
],
[
94,
85
],
[
110,
86
],
[
95,
89
],
[
116,
89
],
[
91,
92
],
[
110,
94
],
[
94,
95
],
[
97,
98
],
[
100,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
],
[
112,
113
],
[
115,
116
]
] |
[
"n = int(input())\ns = list(input())\nt = list(input())\ncnt = 0\nfor i in range(min(len(s), len(t))):\n c = 0\n for j in range(i + 1):\n if s[len(s) - 1 - i + j] == t[j]:\n c += 1\n cnt = max(cnt, c)\nans = len(s) + len(t) - cnt\nif ans < n:\n ans = n\nprint(ans)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = list(input())",
"s",
"list(input())",
"list",
"input()",
"input",
"t = list(input())",
"t",
"list(input())",
"list",
"input()",
"input",
"cnt = 0",
"cnt",
"0",
"for i in range(min(len(s), len(t))):\n c = 0\n for j in range(i + 1):\n if s[len(s) - 1 - i + j] == t[j]:\n c += 1\n cnt = max(cnt, c)",
"i",
"range(min(len(s), len(t)))",
"range",
"min(len(s), len(t))",
"min",
"len(s)",
"len",
"s",
"len(t)",
"len",
"t",
"c = 0",
"c",
"0",
"for j in range(i + 1):\n if s[len(s) - 1 - i + j] == t[j]:\n c += 1\n ",
"j",
"range(i + 1)",
"range",
"i + 1",
"i",
"1",
"if s[len(s) - 1 - i + j] == t[j]:\n c += 1\n ",
"s[len(s) - 1 - i + j] == t[j]",
"s[len(s) - 1 - i + j]",
"s",
"len(s) - 1 - i + j",
"len(s) - 1 - i",
"len(s) - 1",
"len(s)",
"len",
"s",
"1",
"i",
"j",
"t[j]",
"t",
"j",
"c += 1",
"c",
"1",
"cnt = max(cnt, c)",
"cnt",
"max(cnt, c)",
"max",
"cnt",
"c",
"ans = len(s) + len(t) - cnt",
"ans",
"len(s) + len(t) - cnt",
"len(s) + len(t)",
"len(s)",
"len",
"s",
"len(t)",
"len",
"t",
"cnt",
"if ans < n:\n ans = n",
"ans < n",
"ans",
"n",
"ans = n",
"ans",
"n",
"print(ans)",
"print",
"ans",
"cnt = 0",
"0",
"cnt",
"ans = n",
"n",
"ans",
"t = list(input())",
"list(input())",
"t",
"c += 1",
"1",
"c",
"c = 0",
"0",
"c",
"cnt = max(cnt, c)",
"max(cnt, c)",
"cnt",
"n = int(input())",
"int(input())",
"n",
"s = list(input())",
"list(input())",
"s",
"ans = len(s) + len(t) - cnt",
"len(s) + len(t) - cnt",
"ans"
] |
n = int(input())
s = list(input())
t = list(input())
cnt = 0
for i in range(min(len(s), len(t))):
c = 0
for j in range(i + 1):
if s[len(s) - 1 - i + j] == t[j]:
c += 1
cnt = max(cnt, c)
ans = len(s) + len(t) - cnt
if ans < n:
ans = n
print(ans)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
13,
13,
0,
13,
18,
13,
39,
40,
13,
0,
13,
18,
13,
39,
13,
14,
2,
13,
13,
0,
13,
2,
13,
13,
3,
4,
13,
2,
2,
17,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
18,
13,
10,
18,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13
] |
[
[
80,
2
],
[
59,
8
],
[
65,
12
],
[
74,
16
],
[
20,
19
],
[
81,
22
],
[
77,
24
],
[
81,
26
],
[
19,
27
],
[
68,
29
],
[
60,
31
],
[
78,
34
],
[
71,
36
],
[
66,
38
],
[
69,
43
],
[
72,
44
],
[
62,
46
],
[
81,
48
],
[
19,
49
],
[
81,
56
],
[
63,
57
],
[
75,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
]
] |
[
"n=int(input())\ns=input()\nt=input()\nc=0\nfor i in range(n):\n moji=n-i\n a=s[-moji:]\n b=t[:moji]\n if a==b:\n c=n-i\n break\nprint(2*n-c)",
"n=int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s=input()",
"s",
"input()",
"input",
"t=input()",
"t",
"input()",
"input",
"c=0",
"c",
"0",
"for i in range(n):\n moji=n-i\n a=s[-moji:]\n b=t[:moji]\n if a==b:\n c=n-i\n break",
"i",
"range(n)",
"range",
"n",
"moji=n-i",
"moji",
"n-i",
"n",
"i",
"a=s[-moji:]",
"a",
"s[-moji:]",
"s",
"-moji:",
"-moji",
"moji",
"b=t[:moji]",
"b",
"t[:moji]",
"t",
":moji",
"moji",
"if a==b:\n c=n-i\n break",
"a==b",
"a",
"b",
"c=n-i",
"c",
"n-i",
"n",
"i",
"break",
"print(2*n-c)",
"print",
"2*n-c",
"2*n",
"2",
"n",
"c",
"s=input()",
"input()",
"s",
"c=n-i",
"n-i",
"c",
"t=input()",
"input()",
"t",
"a=s[-moji:]",
"s[-moji:]",
"a",
"b=t[:moji]",
"t[:moji]",
"b",
"c=0",
"0",
"c",
"moji=n-i",
"n-i",
"moji",
"n=int(input())",
"int(input())",
"n"
] |
n=int(input())
s=input()
t=input()
c=0
for i in range(n):
moji=n-i
a=s[-moji:]
b=t[:moji]
if a==b:
c=n-i
break
print(2*n-c)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
28,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
13,
14,
2,
18,
13,
13,
18,
13,
2,
13,
13,
9,
0,
13,
17,
3,
14,
2,
13,
17,
4,
13,
4,
13,
2,
18,
13,
39,
13,
13,
4,
13,
4,
13,
2,
17,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13
] |
[
[
75,
2
],
[
69,
8
],
[
66,
12
],
[
17,
16
],
[
76,
19
],
[
78,
21
],
[
25,
24
],
[
16,
27
],
[
76,
28
],
[
70,
32
],
[
24,
33
],
[
67,
35
],
[
24,
37
],
[
16,
38
],
[
72,
41
],
[
73,
46
],
[
79,
46
],
[
70,
54
],
[
67,
57
],
[
76,
64
],
[
66,
67
],
[
69,
70
],
[
72,
73
],
[
75,
76
],
[
78,
79
]
] |
[
"N=int(input())\ns=input()\nt=input()\n\nfor i in range(N):\n F=0\n for j in range(i,N):\n if s[j]==t[j-i]:\n continue\n else:\n F=1\n break\n if F==0:\n print(len(s[:i]+t))\n exit()\nprint(2*N)",
"N=int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s=input()",
"s",
"input()",
"input",
"t=input()",
"t",
"input()",
"input",
"for i in range(N):\n F=0\n for j in range(i,N):\n if s[j]==t[j-i]:\n continue\n else:\n F=1\n break\n if F==0:\n print(len(s[:i]+t))\n exit()",
"i",
"range(N)",
"range",
"N",
"F=0",
"F",
"0",
"for j in range(i,N):\n if s[j]==t[j-i]:\n continue\n else:\n F=1\n break\n ",
"j",
"range(i,N)",
"range",
"i",
"N",
"if s[j]==t[j-i]:\n continue\n else:\n F=1\n break\n ",
"s[j]==t[j-i]",
"s[j]",
"s",
"j",
"t[j-i]",
"t",
"j-i",
"j",
"i",
"continue",
"F=1",
"F",
"1",
"break",
"if F==0:\n print(len(s[:i]+t))\n exit()",
"F==0",
"F",
"0",
"print(len(s[:i]+t))",
"print",
"len(s[:i]+t)",
"len",
"s[:i]+t",
"s[:i]",
"s",
":i",
"i",
"t",
"exit()",
"exit",
"print(2*N)",
"print",
"2*N",
"2",
"N",
"t=input()",
"input()",
"t",
"s=input()",
"input()",
"s",
"F=1",
"1",
"F",
"N=int(input())",
"int(input())",
"N",
"F=0",
"0",
"F"
] |
N=int(input())
s=input()
t=input()
for i in range(N):
F=0
for j in range(i,N):
if s[j]==t[j-i]:
continue
else:
F=1
break
if F==0:
print(len(s[:i]+t))
exit()
print(2*N)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
14,
2,
13,
13,
4,
13,
13,
4,
13,
28,
13,
4,
13,
13,
14,
2,
18,
13,
39,
13,
18,
13,
39,
2,
2,
2,
13,
17,
13,
17,
3,
0,
13,
13,
0,
13,
2,
2,
13,
17,
2,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13
] |
[
[
69,
2
],
[
75,
8
],
[
66,
14
],
[
76,
21
],
[
67,
22
],
[
70,
25
],
[
30,
29
],
[
70,
32
],
[
76,
36
],
[
67,
40
],
[
70,
45
],
[
29,
47
],
[
73,
47
],
[
72,
51
],
[
70,
52
],
[
78,
54
],
[
70,
60
],
[
79,
64
],
[
66,
67
],
[
69,
70
],
[
70,
72
],
[
72,
73
],
[
75,
76
],
[
78,
79
]
] |
[
"n = int(input())\ns = str(input())\nt = str(input())\n\nif s == t:\n print(n)\n exit()\n\nfor i in range(n):\n #print(s[i:], t[:n-1-i+1])\n if s[i:] == t[:n-1-i+1]:\n break\nelse:\n i = n\n #pass\nans = i*2+(n-i)\nprint(ans)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = str(input())",
"s",
"str(input())",
"str",
"input()",
"input",
"t = str(input())",
"t",
"str(input())",
"str",
"input()",
"input",
"if s == t:\n print(n)\n exit()",
"s == t",
"s",
"t",
"print(n)",
"print",
"n",
"exit()",
"exit",
"for i in range(n):\n #print(s[i:], t[:n-1-i+1])\n if s[i:] == t[:n-1-i+1]:\n break\nelse:\n i = n\n #pass",
"i",
"range(n)",
"range",
"n",
"if s[i:] == t[:n-1-i+1]:\n break",
"s[i:] == t[:n-1-i+1]",
"s[i:]",
"s",
"i:",
"i",
"t[:n-1-i+1]",
"t",
":n-1-i+1",
"n-1-i+1",
"n-1-i",
"n-1",
"n",
"1",
"i",
"1",
"break",
"i = n",
"i",
"n",
"ans = i*2+(n-i)",
"ans",
"i*2+(n-i)",
"i*2",
"i",
"2",
"n-i",
"n",
"i",
"print(ans)",
"print",
"ans",
"t = str(input())",
"str(input())",
"t",
"n = int(input())",
"int(input())",
"n",
"i = n",
"n",
"i",
"s = str(input())",
"str(input())",
"s",
"ans = i*2+(n-i)",
"i*2+(n-i)",
"ans"
] |
n = int(input())
s = str(input())
t = str(input())
if s == t:
print(n)
exit()
for i in range(n):
#print(s[i:], t[:n-1-i+1])
if s[i:] == t[:n-1-i+1]:
break
else:
i = n
#pass
ans = i*2+(n-i)
print(ans)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
18,
4,
13,
13,
0,
13,
4,
18,
4,
13,
13,
0,
13,
2,
17,
13,
28,
13,
4,
13,
17,
2,
13,
17,
14,
2,
18,
13,
39,
40,
13,
18,
13,
39,
13,
0,
13,
4,
13,
13,
2,
2,
17,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13
] |
[
[
65,
2
],
[
59,
8
],
[
68,
15
],
[
71,
22
],
[
66,
25
],
[
28,
27
],
[
66,
32
],
[
60,
37
],
[
27,
40
],
[
69,
42
],
[
62,
46
],
[
72,
49
],
[
63,
49
],
[
66,
53
],
[
27,
54
],
[
63,
57
],
[
72,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
]
] |
[
"N = int(input())\ns = input().strip()\nt = input().strip()\nlmin = 2*N\nfor i in range(1,N+1):\n if s[-i:]==t[:i]:\n lmin = min(lmin,2*N-i)\nprint(lmin)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s = input().strip()",
"s",
"input().strip()",
"().strip",
"()",
"input",
"strip",
"t = input().strip()",
"t",
"input().strip()",
"().strip",
"()",
"input",
"strip",
"lmin = 2*N",
"lmin",
"2*N",
"2",
"N",
"for i in range(1,N+1):\n if s[-i:]==t[:i]:\n lmin = min(lmin,2*N-i)",
"i",
"range(1,N+1)",
"range",
"1",
"N+1",
"N",
"1",
"if s[-i:]==t[:i]:\n lmin = min(lmin,2*N-i)",
"s[-i:]==t[:i]",
"s[-i:]",
"s",
"-i:",
"-i",
"i",
"t[:i]",
"t",
":i",
"i",
"lmin = min(lmin,2*N-i)",
"lmin",
"min(lmin,2*N-i)",
"min",
"lmin",
"2*N-i",
"2*N",
"2",
"N",
"i",
"print(lmin)",
"print",
"lmin",
"s = input().strip()",
"input().strip()",
"s",
"lmin = min(lmin,2*N-i)",
"min(lmin,2*N-i)",
"lmin",
"N = int(input())",
"int(input())",
"N",
"t = input().strip()",
"input().strip()",
"t",
"lmin = 2*N",
"2*N",
"lmin"
] |
N = int(input())
s = input().strip()
t = input().strip()
lmin = 2*N
for i in range(1,N+1):
if s[-i:]==t[:i]:
lmin = min(lmin,2*N-i)
print(lmin)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
14,
40,
18,
13,
2,
13,
13,
18,
13,
13,
0,
13,
17,
3,
14,
2,
13,
17,
0,
13,
17,
3,
14,
2,
13,
17,
4,
13,
2,
13,
13,
4,
13,
2,
17,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13
] |
[
[
70,
2
],
[
88,
8
],
[
82,
12
],
[
76,
16
],
[
20,
19
],
[
71,
22
],
[
79,
24
],
[
28,
27
],
[
71,
31
],
[
19,
32
],
[
89,
36
],
[
19,
38
],
[
27,
39
],
[
83,
41
],
[
27,
42
],
[
73,
44
],
[
74,
49
],
[
80,
49
],
[
85,
52
],
[
86,
57
],
[
77,
57
],
[
71,
62
],
[
71,
68
],
[
70,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
]
] |
[
"n=int(input())\ns=input()\nt=input()\nactualfail=0\nfor i in range(n):\n fail=0\n for j in range(n-i):\n if s[i+j]!=t[j]:\n fail=1\n break\n if fail==0:\n actualfail=1\n break\nif actualfail==1:\n print(n+i)\nelse:\n print(2*n)",
"n=int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s=input()",
"s",
"input()",
"input",
"t=input()",
"t",
"input()",
"input",
"actualfail=0",
"actualfail",
"0",
"for i in range(n):\n fail=0\n for j in range(n-i):\n if s[i+j]!=t[j]:\n fail=1\n break\n if fail==0:\n actualfail=1\n break",
"i",
"range(n)",
"range",
"n",
"fail=0",
"fail",
"0",
"for j in range(n-i):\n if s[i+j]!=t[j]:\n fail=1\n break\n ",
"j",
"range(n-i)",
"range",
"n-i",
"n",
"i",
"if s[i+j]!=t[j]:\n fail=1\n break\n ",
"s[i+j]!=t[j]",
"s[i+j]",
"s",
"i+j",
"i",
"j",
"t[j]",
"t",
"j",
"fail=1",
"fail",
"1",
"break",
"if fail==0:\n actualfail=1\n break",
"fail==0",
"fail",
"0",
"actualfail=1",
"actualfail",
"1",
"break",
"if actualfail==1:\n print(n+i)\nelse:\n print(2*n)",
"actualfail==1",
"actualfail",
"1",
"print(n+i)",
"print",
"n+i",
"n",
"i",
"print(2*n)",
"print",
"2*n",
"2",
"n",
"n=int(input())",
"int(input())",
"n",
"fail=1",
"1",
"fail",
"actualfail=0",
"0",
"actualfail",
"fail=0",
"0",
"fail",
"t=input()",
"input()",
"t",
"actualfail=1",
"1",
"actualfail",
"s=input()",
"input()",
"s"
] |
n=int(input())
s=input()
t=input()
actualfail=0
for i in range(n):
fail=0
for j in range(n-i):
if s[i+j]!=t[j]:
fail=1
break
if fail==0:
actualfail=1
break
if actualfail==1:
print(n+i)
else:
print(2*n)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
2,
17,
13,
28,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
14,
40,
18,
13,
2,
13,
13,
18,
13,
13,
3,
0,
13,
2,
13,
17,
14,
2,
13,
2,
13,
13,
0,
13,
2,
2,
13,
13,
13,
3,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13
] |
[
[
107,
2
],
[
86,
8
],
[
83,
14
],
[
89,
20
],
[
87,
23
],
[
98,
25
],
[
84,
28
],
[
101,
30
],
[
108,
33
],
[
36,
35
],
[
108,
38
],
[
95,
40
],
[
44,
43
],
[
108,
47
],
[
35,
48
],
[
90,
52
],
[
87,
52
],
[
35,
54
],
[
43,
55
],
[
99,
57
],
[
84,
57
],
[
43,
58
],
[
104,
61
],
[
96,
63
],
[
105,
63
],
[
105,
67
],
[
96,
67
],
[
108,
69
],
[
35,
70
],
[
92,
72
],
[
102,
75
],
[
93,
75
],
[
108,
76
],
[
35,
77
],
[
93,
81
],
[
102,
81
],
[
83,
84
],
[
86,
87
],
[
89,
90
],
[
92,
93
],
[
95,
96
],
[
98,
99
],
[
101,
102
],
[
104,
105
],
[
107,
108
]
] |
[
"n=int(input())\ns=str(input())\nt=str(input())\ns=list(s)\nt=list(t)\nans=2*n\nfor i in range(n):\n cnt=0\n for j in range(n-i):\n if s[i+j]!=t[j]:\n break\n else:\n cnt=cnt+1\n if cnt==n-i:\n ans=ans-n+i\n break\nprint(ans)",
"n=int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s=str(input())",
"s",
"str(input())",
"str",
"input()",
"input",
"t=str(input())",
"t",
"str(input())",
"str",
"input()",
"input",
"s=list(s)",
"s",
"list(s)",
"list",
"s",
"t=list(t)",
"t",
"list(t)",
"list",
"t",
"ans=2*n",
"ans",
"2*n",
"2",
"n",
"for i in range(n):\n cnt=0\n for j in range(n-i):\n if s[i+j]!=t[j]:\n break\n else:\n cnt=cnt+1\n if cnt==n-i:\n ans=ans-n+i\n break",
"i",
"range(n)",
"range",
"n",
"cnt=0",
"cnt",
"0",
"for j in range(n-i):\n if s[i+j]!=t[j]:\n break\n else:\n cnt=cnt+1\n ",
"j",
"range(n-i)",
"range",
"n-i",
"n",
"i",
"if s[i+j]!=t[j]:\n break\n else:\n cnt=cnt+1\n ",
"s[i+j]!=t[j]",
"s[i+j]",
"s",
"i+j",
"i",
"j",
"t[j]",
"t",
"j",
"break",
"cnt=cnt+1",
"cnt",
"cnt+1",
"cnt",
"1",
"if cnt==n-i:\n ans=ans-n+i\n break",
"cnt==n-i",
"cnt",
"n-i",
"n",
"i",
"ans=ans-n+i",
"ans",
"ans-n+i",
"ans-n",
"ans",
"n",
"i",
"break",
"print(ans)",
"print",
"ans",
"t=str(input())",
"str(input())",
"t",
"s=str(input())",
"str(input())",
"s",
"s=list(s)",
"list(s)",
"s",
"ans=ans-n+i",
"ans-n+i",
"ans",
"cnt=0",
"0",
"cnt",
"t=list(t)",
"list(t)",
"t",
"ans=2*n",
"2*n",
"ans",
"cnt=cnt+1",
"cnt+1",
"cnt",
"n=int(input())",
"int(input())",
"n"
] |
n=int(input())
s=str(input())
t=str(input())
s=list(s)
t=list(t)
ans=2*n
for i in range(n):
cnt=0
for j in range(n-i):
if s[i+j]!=t[j]:
break
else:
cnt=cnt+1
if cnt==n-i:
ans=ans-n+i
break
print(ans)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
2,
18,
13,
39,
13,
18,
13,
39,
2,
13,
13,
13,
4,
13,
2,
13,
13,
0,
13,
17,
3,
14,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13
] |
[
[
49,
2
],
[
58,
8
],
[
61,
12
],
[
52,
16
],
[
20,
19
],
[
50,
22
],
[
59,
27
],
[
62,
31
],
[
50,
34
],
[
19,
35
],
[
59,
36
],
[
19,
40
],
[
50,
41
],
[
55,
43
],
[
49,
50
],
[
52,
53
],
[
55,
56
],
[
58,
59
],
[
61,
62
]
] |
[
"n=int(input())\na=input()\nb=input()\np=True\nfor i in range(n):\n if a[:i]+b[:n-i]==a:\n print(i+n)\n p=False\n break\nif p:print(2*n)",
"n=int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a=input()",
"a",
"input()",
"input",
"b=input()",
"b",
"input()",
"input",
"p=True",
"p",
"True",
"for i in range(n):\n if a[:i]+b[:n-i]==a:\n print(i+n)\n p=False\n break",
"i",
"range(n)",
"range",
"n",
"if a[:i]+b[:n-i]==a:\n print(i+n)\n p=False\n break",
"a[:i]+b[:n-i]==a",
"a[:i]+b[:n-i]",
"a[:i]",
"a",
":i",
"i",
"b[:n-i]",
"b",
":n-i",
"n-i",
"n",
"i",
"a",
"print(i+n)",
"print",
"i+n",
"i",
"n",
"p=False",
"p",
"False",
"break",
"if p:print(2*n)",
"p",
"n=int(input())",
"int(input())",
"n",
"p=True",
"True",
"p",
"p=False",
"False",
"p",
"a=input()",
"input()",
"a",
"b=input()",
"input()",
"b"
] |
n=int(input())
a=input()
b=input()
p=True
for i in range(n):
if a[:i]+b[:n-i]==a:
print(i+n)
p=False
break
if p:print(2*n)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
28,
13,
4,
13,
13,
14,
2,
13,
13,
4,
13,
4,
13,
13,
4,
13,
14,
2,
18,
13,
39,
13,
18,
13,
39,
2,
13,
13,
4,
13,
4,
13,
2,
13,
18,
13,
39,
40,
13,
4,
13,
4,
13,
4,
13,
2,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
67,
2
],
[
70,
8
],
[
64,
12
],
[
17,
16
],
[
68,
19
],
[
71,
22
],
[
65,
23
],
[
71,
28
],
[
71,
34
],
[
65,
38
],
[
68,
41
],
[
16,
42
],
[
71,
48
],
[
65,
50
],
[
16,
53
],
[
71,
61
],
[
65,
62
],
[
64,
65
],
[
67,
68
],
[
70,
71
]
] |
[
"n = int(input())\ns = input()\nt = input()\nfor i in range(n):\n if s == t:\n print(len(s))\n exit()\n if s[i:] == t[:n-i]:\n print(len(s+t[-i:]))\n exit()\nprint(len(s+t))",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"for i in range(n):\n if s == t:\n print(len(s))\n exit()\n if s[i:] == t[:n-i]:\n print(len(s+t[-i:]))\n exit()",
"i",
"range(n)",
"range",
"n",
"if s == t:\n print(len(s))\n exit()\n ",
"s == t",
"s",
"t",
"print(len(s))",
"print",
"len(s)",
"len",
"s",
"exit()",
"exit",
"if s[i:] == t[:n-i]:\n print(len(s+t[-i:]))\n exit()",
"s[i:] == t[:n-i]",
"s[i:]",
"s",
"i:",
"i",
"t[:n-i]",
"t",
":n-i",
"n-i",
"n",
"i",
"print(len(s+t[-i:]))",
"print",
"len(s+t[-i:])",
"len",
"s+t[-i:]",
"s",
"t[-i:]",
"t",
"-i:",
"-i",
"i",
"exit()",
"exit",
"print(len(s+t))",
"print",
"len(s+t)",
"len",
"s+t",
"s",
"t",
"t = input()",
"input()",
"t",
"n = int(input())",
"int(input())",
"n",
"s = input()",
"input()",
"s"
] |
n = int(input())
s = input()
t = input()
for i in range(n):
if s == t:
print(len(s))
exit()
if s[i:] == t[:n-i]:
print(len(s+t[-i:]))
exit()
print(len(s+t))
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
2,
18,
13,
39,
2,
4,
13,
13,
13,
18,
13,
39,
13,
0,
13,
13,
4,
13,
2,
2,
17,
13,
13,
10,
13,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
66,
2
],
[
60,
8
],
[
63,
14
],
[
57,
20
],
[
24,
23
],
[
67,
27
],
[
61,
32
],
[
61,
37
],
[
23,
38
],
[
64,
40
],
[
54,
44
],
[
23,
45
],
[
67,
51
],
[
55,
52
],
[
58,
52
],
[
23,
54
],
[
54,
55
],
[
57,
58
],
[
60,
61
],
[
63,
64
],
[
66,
67
]
] |
[
"n = int(input())\ns = list(input())\nt = list(input())\nans = 0\nfor i in range(n+1):\n if s[len(s)-i:] == t[:i]:\n ans = i\nprint(2*n-ans)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = list(input())",
"s",
"list(input())",
"list",
"input()",
"input",
"t = list(input())",
"t",
"list(input())",
"list",
"input()",
"input",
"ans = 0",
"ans",
"0",
"for i in range(n+1):\n if s[len(s)-i:] == t[:i]:\n ans = i",
"i",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"if s[len(s)-i:] == t[:i]:\n ans = i",
"s[len(s)-i:] == t[:i]",
"s[len(s)-i:]",
"s",
"len(s)-i:",
"len(s)-i",
"len(s)",
"len",
"s",
"i",
"t[:i]",
"t",
":i",
"i",
"ans = i",
"ans",
"i",
"print(2*n-ans)",
"print",
"2*n-ans",
"2*n",
"2",
"n",
"ans",
"ans = i",
"i",
"ans",
"ans = 0",
"0",
"ans",
"s = list(input())",
"list(input())",
"s",
"t = list(input())",
"list(input())",
"t",
"n = int(input())",
"int(input())",
"n"
] |
n = int(input())
s = list(input())
t = list(input())
ans = 0
for i in range(n+1):
if s[len(s)-i:] == t[:i]:
ans = i
print(2*n-ans)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
18,
13,
39,
13,
18,
13,
39,
2,
13,
13,
0,
13,
2,
13,
13,
3,
4,
13,
2,
2,
17,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13
] |
[
[
55,
2
],
[
58,
8
],
[
52,
12
],
[
61,
16
],
[
20,
19
],
[
56,
22
],
[
59,
26
],
[
53,
30
],
[
56,
33
],
[
19,
34
],
[
49,
36
],
[
56,
38
],
[
19,
39
],
[
56,
46
],
[
50,
47
],
[
62,
47
],
[
49,
50
],
[
52,
53
],
[
55,
56
],
[
58,
59
],
[
61,
62
]
] |
[
"N = int(input())\ns = input()\nt = input()\nsameLen = 0\nfor i in range(N):\n if s[i:] == t[: N - i]:\n sameLen = N - i\n break\nprint(2 * N - sameLen)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"sameLen = 0",
"sameLen",
"0",
"for i in range(N):\n if s[i:] == t[: N - i]:\n sameLen = N - i\n break",
"i",
"range(N)",
"range",
"N",
"if s[i:] == t[: N - i]:\n sameLen = N - i\n break",
"s[i:] == t[: N - i]",
"s[i:]",
"s",
"i:",
"i",
"t[: N - i]",
"t",
": N - i",
"N - i",
"N",
"i",
"sameLen = N - i",
"sameLen",
"N - i",
"N",
"i",
"break",
"print(2 * N - sameLen)",
"print",
"2 * N - sameLen",
"2 * N",
"2",
"N",
"sameLen",
"sameLen = N - i",
"N - i",
"sameLen",
"t = input()",
"input()",
"t",
"N = int(input())",
"int(input())",
"N",
"s = input()",
"input()",
"s",
"sameLen = 0",
"0",
"sameLen"
] |
N = int(input())
s = input()
t = input()
sameLen = 0
for i in range(N):
if s[i:] == t[: N - i]:
sameLen = N - i
break
print(2 * N - sameLen)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
28,
13,
4,
13,
13,
2,
17,
13,
0,
13,
2,
2,
17,
13,
13,
0,
13,
18,
13,
39,
2,
17,
13,
0,
13,
18,
13,
39,
13,
14,
2,
13,
13,
4,
13,
13,
4,
13,
4,
13,
2,
17,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
2,
13
] |
[
[
59,
2
],
[
68,
8
],
[
65,
12
],
[
17,
16
],
[
60,
19
],
[
60,
22
],
[
74,
24
],
[
60,
28
],
[
16,
29
],
[
62,
31
],
[
69,
33
],
[
75,
37
],
[
71,
39
],
[
66,
41
],
[
63,
46
],
[
72,
47
],
[
16,
50
],
[
60,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
]
] |
[
"n = int(input())\ns = input()\nt = input()\n\nfor i in range(n, 2 * n):\n check = 2 * n - i\n ss = s[-1 * check:]\n tt = t[:check]\n if ss == tt:\n print(i)\n exit()\n\nprint(2 * n)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"for i in range(n, 2 * n):\n check = 2 * n - i\n ss = s[-1 * check:]\n tt = t[:check]\n if ss == tt:\n print(i)\n exit()",
"i",
"range(n, 2 * n)",
"range",
"n",
"2 * n",
"2",
"n",
"check = 2 * n - i",
"check",
"2 * n - i",
"2 * n",
"2",
"n",
"i",
"ss = s[-1 * check:]",
"ss",
"s[-1 * check:]",
"s",
"-1 * check:",
"-1 * check",
"-1",
"check",
"tt = t[:check]",
"tt",
"t[:check]",
"t",
":check",
"check",
"if ss == tt:\n print(i)\n exit()",
"ss == tt",
"ss",
"tt",
"print(i)",
"print",
"i",
"exit()",
"exit",
"print(2 * n)",
"print",
"2 * n",
"2",
"n",
"n = int(input())",
"int(input())",
"n",
"ss = s[-1 * check:]",
"s[-1 * check:]",
"ss",
"t = input()",
"input()",
"t",
"s = input()",
"input()",
"s",
"tt = t[:check]",
"t[:check]",
"tt",
"check = 2 * n - i",
"2 * n - i",
"check"
] |
n = int(input())
s = input()
t = input()
for i in range(n, 2 * n):
check = 2 * n - i
ss = s[-1 * check:]
tt = t[:check]
if ss == tt:
print(i)
exit()
print(2 * n)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
18,
13,
39,
2,
2,
13,
13,
17,
18,
13,
39,
2,
13,
17,
0,
13,
2,
13,
17,
4,
13,
2,
2,
13,
17,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13
] |
[
[
58,
2
],
[
61,
8
],
[
55,
12
],
[
64,
16
],
[
20,
19
],
[
59,
22
],
[
62,
26
],
[
59,
30
],
[
19,
31
],
[
56,
34
],
[
19,
37
],
[
52,
40
],
[
19,
42
],
[
59,
48
],
[
53,
50
],
[
65,
50
],
[
52,
53
],
[
55,
56
],
[
58,
59
],
[
61,
62
],
[
64,
65
]
] |
[
"n = int(input())\ns = input()\nt = input()\n\na = 0\nfor i in range(n):\n if s[n - i - 1:] == t[:i + 1]:\n a = i + 1\nprint(n * 2 - a)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"a = 0",
"a",
"0",
"for i in range(n):\n if s[n - i - 1:] == t[:i + 1]:\n a = i + 1",
"i",
"range(n)",
"range",
"n",
"if s[n - i - 1:] == t[:i + 1]:\n a = i + 1",
"s[n - i - 1:] == t[:i + 1]",
"s[n - i - 1:]",
"s",
"n - i - 1:",
"n - i - 1",
"n - i",
"n",
"i",
"1",
"t[:i + 1]",
"t",
":i + 1",
"i + 1",
"i",
"1",
"a = i + 1",
"a",
"i + 1",
"i",
"1",
"print(n * 2 - a)",
"print",
"n * 2 - a",
"n * 2",
"n",
"2",
"a",
"a = i + 1",
"i + 1",
"a",
"t = input()",
"input()",
"t",
"n = int(input())",
"int(input())",
"n",
"s = input()",
"input()",
"s",
"a = 0",
"0",
"a"
] |
n = int(input())
s = input()
t = input()
a = 0
for i in range(n):
if s[n - i - 1:] == t[:i + 1]:
a = i + 1
print(n * 2 - a)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
0,
13,
2,
13,
13,
14,
2,
13,
13,
4,
13,
4,
13,
13,
4,
13,
28,
13,
4,
13,
17,
13,
14,
2,
18,
13,
39,
40,
13,
18,
13,
39,
13,
0,
13,
2,
13,
18,
13,
39,
13,
4,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13
] |
[
[
69,
2
],
[
66,
8
],
[
72,
14
],
[
75,
20
],
[
67,
22
],
[
73,
23
],
[
67,
26
],
[
73,
27
],
[
67,
32
],
[
37,
36
],
[
70,
40
],
[
67,
44
],
[
36,
47
],
[
73,
49
],
[
78,
53
],
[
67,
55
],
[
73,
57
],
[
79,
64
],
[
76,
64
],
[
66,
67
],
[
69,
70
],
[
72,
73
],
[
75,
76
],
[
78,
79
]
] |
[
"N=int(input())\ns=list(input())\nt=list(input())\nf=s+t\nif s==t:\n print(len(s))\n exit()\nfor i in range(0,N):\n if s[-i:]==t[:i]:\n f=s+t[i:]\nprint(len(f))",
"N=int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s=list(input())",
"s",
"list(input())",
"list",
"input()",
"input",
"t=list(input())",
"t",
"list(input())",
"list",
"input()",
"input",
"f=s+t",
"f",
"s+t",
"s",
"t",
"if s==t:\n print(len(s))\n exit()",
"s==t",
"s",
"t",
"print(len(s))",
"print",
"len(s)",
"len",
"s",
"exit()",
"exit",
"for i in range(0,N):\n if s[-i:]==t[:i]:\n f=s+t[i:]",
"i",
"range(0,N)",
"range",
"0",
"N",
"if s[-i:]==t[:i]:\n f=s+t[i:]",
"s[-i:]==t[:i]",
"s[-i:]",
"s",
"-i:",
"-i",
"i",
"t[:i]",
"t",
":i",
"i",
"f=s+t[i:]",
"f",
"s+t[i:]",
"s",
"t[i:]",
"t",
"i:",
"i",
"print(len(f))",
"print",
"len(f)",
"len",
"f",
"s=list(input())",
"list(input())",
"s",
"N=int(input())",
"int(input())",
"N",
"t=list(input())",
"list(input())",
"t",
"f=s+t",
"s+t",
"f",
"f=s+t[i:]",
"s+t[i:]",
"f"
] |
N=int(input())
s=list(input())
t=list(input())
f=s+t
if s==t:
print(len(s))
exit()
for i in range(0,N):
if s[-i:]==t[:i]:
f=s+t[i:]
print(len(f))
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
2,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
18,
13,
39,
13,
18,
13,
39,
2,
13,
13,
0,
13,
2,
18,
13,
39,
13,
13,
0,
13,
17,
3,
14,
2,
13,
17,
4,
13,
4,
13,
13,
4,
13,
2,
17,
13,
10,
17,
13,
10,
17,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
79,
2
],
[
82,
8
],
[
85,
12
],
[
73,
16
],
[
83,
18
],
[
86,
19
],
[
67,
21
],
[
25,
24
],
[
80,
27
],
[
83,
31
],
[
86,
35
],
[
80,
38
],
[
24,
39
],
[
76,
41
],
[
83,
44
],
[
86,
47
],
[
70,
49
],
[
71,
54
],
[
68,
54
],
[
77,
60
],
[
74,
60
],
[
80,
65
],
[
67,
68
],
[
70,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
]
] |
[
"n=int(input())\ns=input()\nr=input()\nt=s+r\nf=0\nfor i in range(n):\n if(s[i:]==r[:n-i]):\n t=s[:i]+r\n f=1\n break\nif(f==1):\n print(len(t))\nelse:\n print(2*n)",
"n=int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s=input()",
"s",
"input()",
"input",
"r=input()",
"r",
"input()",
"input",
"t=s+r",
"t",
"s+r",
"s",
"r",
"f=0",
"f",
"0",
"for i in range(n):\n if(s[i:]==r[:n-i]):\n t=s[:i]+r\n f=1\n break",
"i",
"range(n)",
"range",
"n",
"if(s[i:]==r[:n-i]):\n t=s[:i]+r\n f=1\n break",
"s[i:]==r[:n-i]",
"s[i:]",
"s",
"i:",
"i",
"r[:n-i]",
"r",
":n-i",
"n-i",
"n",
"i",
"t=s[:i]+r",
"t",
"s[:i]+r",
"s[:i]",
"s",
":i",
"i",
"r",
"f=1",
"f",
"1",
"break",
"if(f==1):\n print(len(t))\nelse:\n print(2*n)",
"f==1",
"f",
"1",
"print(len(t))",
"print",
"len(t)",
"len",
"t",
"print(2*n)",
"print",
"2*n",
"2",
"n",
"f=0",
"0",
"f",
"f=1",
"1",
"f",
"t=s+r",
"s+r",
"t",
"t=s[:i]+r",
"s[:i]+r",
"t",
"n=int(input())",
"int(input())",
"n",
"s=input()",
"input()",
"s",
"r=input()",
"input()",
"r"
] |
n=int(input())
s=input()
r=input()
t=s+r
f=0
for i in range(n):
if(s[i:]==r[:n-i]):
t=s[:i]+r
f=1
break
if(f==1):
print(len(t))
else:
print(2*n)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
18,
4,
13,
13,
0,
13,
4,
18,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
14,
2,
18,
13,
39,
13,
13,
18,
13,
39,
17,
2,
13,
13,
0,
13,
2,
13,
18,
13,
39,
2,
13,
13,
13,
4,
13,
4,
13,
13,
3,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13
] |
[
[
60,
2
],
[
63,
8
],
[
69,
15
],
[
23,
22
],
[
61,
26
],
[
64,
31
],
[
70,
36
],
[
61,
40
],
[
22,
41
],
[
66,
43
],
[
64,
45
],
[
70,
47
],
[
61,
50
],
[
22,
51
],
[
67,
57
],
[
60,
61
],
[
63,
64
],
[
66,
67
],
[
69,
70
]
] |
[
"N = int(input())\ns = input().strip()\nt = input().strip()\nfor i in range(N+1):\n if s[i:N]==t[0:N-i]:\n x = s+t[N-i:N]\n print(len(x))\n break",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s = input().strip()",
"s",
"input().strip()",
"().strip",
"()",
"input",
"strip",
"t = input().strip()",
"t",
"input().strip()",
"().strip",
"()",
"input",
"strip",
"for i in range(N+1):\n if s[i:N]==t[0:N-i]:\n x = s+t[N-i:N]\n print(len(x))\n break",
"i",
"range(N+1)",
"range",
"N+1",
"N",
"1",
"if s[i:N]==t[0:N-i]:\n x = s+t[N-i:N]\n print(len(x))\n break",
"s[i:N]==t[0:N-i]",
"s[i:N]",
"s",
"i:N",
"i",
"N",
"t[0:N-i]",
"t",
"0:N-i",
"0",
"N-i",
"N",
"i",
"x = s+t[N-i:N]",
"x",
"s+t[N-i:N]",
"s",
"t[N-i:N]",
"t",
"N-i:N",
"N-i",
"N",
"i",
"N",
"print(len(x))",
"print",
"len(x)",
"len",
"x",
"break",
"N = int(input())",
"int(input())",
"N",
"s = input().strip()",
"input().strip()",
"s",
"x = s+t[N-i:N]",
"s+t[N-i:N]",
"x",
"t = input().strip()",
"input().strip()",
"t"
] |
N = int(input())
s = input().strip()
t = input().strip()
for i in range(N+1):
if s[i:N]==t[0:N-i]:
x = s+t[N-i:N]
print(len(x))
break
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
28,
13,
4,
13,
13,
14,
2,
18,
13,
39,
13,
18,
13,
39,
2,
13,
13,
3,
0,
13,
17,
4,
13,
2,
2,
17,
13,
2,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13
] |
[
[
46,
2
],
[
52,
8
],
[
49,
12
],
[
17,
16
],
[
47,
19
],
[
53,
23
],
[
50,
27
],
[
47,
30
],
[
16,
31
],
[
56,
31
],
[
55,
34
],
[
47,
43
],
[
46,
47
],
[
49,
50
],
[
52,
53
],
[
55,
56
]
] |
[
"N = int(input())\ns = input()\nt = input()\nfor i in range(N):\n if s[i:] == t[:N-i]:\n break\nelse:\n i += 1\nprint(2 * i + (N - i))",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"for i in range(N):\n if s[i:] == t[:N-i]:\n break\nelse:\n i += 1",
"i",
"range(N)",
"range",
"N",
"if s[i:] == t[:N-i]:\n break",
"s[i:] == t[:N-i]",
"s[i:]",
"s",
"i:",
"i",
"t[:N-i]",
"t",
":N-i",
"N-i",
"N",
"i",
"break",
"i += 1",
"i",
"1",
"print(2 * i + (N - i))",
"print",
"2 * i + (N - i)",
"2 * i",
"2",
"i",
"N - i",
"N",
"i",
"N = int(input())",
"int(input())",
"N",
"t = input()",
"input()",
"t",
"s = input()",
"input()",
"s",
"i += 1",
"1",
"i"
] |
N = int(input())
s = input()
t = input()
for i in range(N):
if s[i:] == t[:N-i]:
break
else:
i += 1
print(2 * i + (N - i))
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
0,
13,
17,
14,
2,
13,
13,
4,
13,
13,
28,
13,
4,
13,
13,
14,
2,
18,
13,
39,
2,
40,
13,
17,
18,
13,
39,
17,
2,
13,
17,
0,
13,
2,
13,
17,
4,
13,
2,
2,
13,
17,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13
] |
[
[
69,
2
],
[
63,
8
],
[
72,
14
],
[
75,
20
],
[
64,
24
],
[
73,
25
],
[
70,
28
],
[
31,
30
],
[
70,
33
],
[
64,
37
],
[
30,
41
],
[
73,
44
],
[
30,
48
],
[
66,
51
],
[
30,
53
],
[
70,
59
],
[
67,
61
],
[
76,
61
],
[
63,
64
],
[
66,
67
],
[
69,
70
],
[
72,
73
],
[
75,
76
]
] |
[
"n=int(input())\ns=str(input())\nt=str(input())\n \ncnt=0\n\nif s==t:\n print(n) \nelse:\n for i in range(n):\n if s[-i-1:]==t[0:i+1]:\n cnt=i+1\n \n print(n*2-cnt)",
"n=int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s=str(input())",
"s",
"str(input())",
"str",
"input()",
"input",
"t=str(input())",
"t",
"str(input())",
"str",
"input()",
"input",
"cnt=0",
"cnt",
"0",
"if s==t:\n print(n) \nelse:\n for i in range(n):\n if s[-i-1:]==t[0:i+1]:\n cnt=i+1\n \n print(n*2-cnt)",
"s==t",
"s",
"t",
"print(n)",
"print",
"n",
"for i in range(n):\n if s[-i-1:]==t[0:i+1]:\n cnt=i+1\n \n ",
"i",
"range(n)",
"range",
"n",
"if s[-i-1:]==t[0:i+1]:\n cnt=i+1\n \n ",
"s[-i-1:]==t[0:i+1]",
"s[-i-1:]",
"s",
"-i-1:",
"-i-1",
"-i",
"i",
"1",
"t[0:i+1]",
"t",
"0:i+1",
"0",
"i+1",
"i",
"1",
"cnt=i+1",
"cnt",
"i+1",
"i",
"1",
"print(n*2-cnt)",
"print",
"n*2-cnt",
"n*2",
"n",
"2",
"cnt",
"s=str(input())",
"str(input())",
"s",
"cnt=i+1",
"i+1",
"cnt",
"n=int(input())",
"int(input())",
"n",
"t=str(input())",
"str(input())",
"t",
"cnt=0",
"0",
"cnt"
] |
n=int(input())
s=str(input())
t=str(input())
cnt=0
if s==t:
print(n)
else:
for i in range(n):
if s[-i-1:]==t[0:i+1]:
cnt=i+1
print(n*2-cnt)
|
[
7,
0,
13,
4,
13,
4,
13,
41,
28,
13,
4,
13,
17,
4,
4,
13,
0,
13,
13,
13,
0,
13,
13,
28,
13,
4,
13,
13,
14,
2,
18,
13,
39,
13,
18,
13,
39,
2,
13,
13,
0,
13,
13,
3,
4,
13,
2,
13,
13,
10,
13,
13,
10,
13,
13,
10,
13,
13,
10,
4,
13,
10,
13,
13
] |
[
[
59,
2
],
[
10,
9
],
[
62,
17
],
[
62,
19
],
[
50,
21
],
[
60,
22
],
[
25,
24
],
[
60,
27
],
[
63,
31
],
[
54,
35
],
[
60,
38
],
[
24,
39
],
[
56,
41
],
[
24,
42
],
[
60,
47
],
[
57,
48
],
[
51,
48
],
[
60,
50
],
[
50,
51
],
[
62,
54
],
[
24,
56
],
[
56,
57
],
[
59,
60
],
[
62,
63
]
] |
[
"# A - Prefix and Suffix\n\nN = int(input())\ns, t = [input() for i in range(2)]\ndelta = N\n\nfor i in range(N):\n if s[i:] == t[:N-i]:\n delta = i\n break\n\nprint(N+delta)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"input() for i in range(2)",
"for i in range(2)",
"i",
"range(2)",
"range",
"2",
"for i in range(2)",
"input()",
"input",
"s, t = [input() for i in range(2)]",
"s",
"[input() for i in range(2)]",
"t",
"delta = N",
"delta",
"N",
"for i in range(N):\n if s[i:] == t[:N-i]:\n delta = i\n break",
"i",
"range(N)",
"range",
"N",
"if s[i:] == t[:N-i]:\n delta = i\n break",
"s[i:] == t[:N-i]",
"s[i:]",
"s",
"i:",
"i",
"t[:N-i]",
"t",
":N-i",
"N-i",
"N",
"i",
"delta = i",
"delta",
"i",
"break",
"print(N+delta)",
"print",
"N+delta",
"N",
"delta",
"delta = N",
"N",
"delta",
"t = [input() for i in range(2)]",
"[input() for i in range(2)]",
"t",
"delta = i",
"i",
"delta",
"N = int(input())",
"int(input())",
"N",
"s, t = [input() for i in range(2)]",
"[input() for i in range(2)]",
"s"
] |
# A - Prefix and Suffix
N = int(input())
s, t = [input() for i in range(2)]
delta = N
for i in range(N):
if s[i:] == t[:N-i]:
delta = i
break
print(N+delta)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
4,
13,
13,
14,
40,
18,
13,
39,
13,
8,
2,
13,
17,
18,
13,
39,
2,
40,
13,
17,
13,
0,
13,
17,
3,
4,
13,
2,
13,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
65,
2
],
[
59,
8
],
[
62,
12
],
[
53,
16
],
[
20,
19
],
[
60,
24
],
[
60,
28
],
[
19,
33
],
[
63,
36
],
[
19,
40
],
[
63,
42
],
[
56,
44
],
[
66,
50
],
[
57,
51
],
[
54,
51
],
[
53,
54
],
[
56,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
]
] |
[
"n = int(input())\ns = input()\nt = input()\n\ncount = 0\nfor i in range(len(s)):\n if s[i:] != (t[:~i+1] if i > 0 else t):\n count += 1\n else:\n break\n\nprint(n + count)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"count = 0",
"count",
"0",
"for i in range(len(s)):\n if s[i:] != (t[:~i+1] if i > 0 else t):\n count += 1\n else:\n break",
"i",
"range(len(s))",
"range",
"len(s)",
"len",
"s",
"if s[i:] != (t[:~i+1] if i > 0 else t):\n count += 1\n else:\n break",
"s[i:] != (t[:~i+1] if i > 0 else t)",
"s[i:]",
"s",
"i:",
"i",
"t[:~i+1] if i > 0 else t",
"i > 0",
"i",
"0",
"t[:~i+1]",
"t",
":~i+1",
"~i+1",
"~i",
"i",
"1",
"t",
"count += 1",
"count",
"1",
"break",
"print(n + count)",
"print",
"n + count",
"n",
"count",
"count = 0",
"0",
"count",
"count += 1",
"1",
"count",
"s = input()",
"input()",
"s",
"t = input()",
"input()",
"t",
"n = int(input())",
"int(input())",
"n"
] |
n = int(input())
s = input()
t = input()
count = 0
for i in range(len(s)):
if s[i:] != (t[:~i+1] if i > 0 else t):
count += 1
else:
break
print(n + count)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
14,
2,
13,
13,
4,
13,
4,
13,
13,
4,
13,
17,
0,
13,
17,
0,
13,
4,
13,
4,
13,
13,
4,
13,
13,
0,
13,
17,
42,
2,
13,
13,
0,
13,
18,
13,
39,
40,
2,
13,
17,
0,
13,
18,
13,
39,
2,
13,
17,
14,
2,
13,
13,
0,
13,
2,
13,
17,
0,
13,
17,
0,
13,
2,
2,
4,
13,
13,
4,
13,
13,
13,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
18,
13
] |
[
[
115,
2
],
[
94,
8
],
[
109,
12
],
[
95,
17
],
[
110,
18
],
[
95,
23
],
[
100,
28
],
[
103,
31
],
[
95,
36
],
[
110,
39
],
[
91,
41
],
[
101,
45
],
[
107,
45
],
[
104,
46
],
[
97,
48
],
[
95,
50
],
[
101,
54
],
[
107,
54
],
[
121,
57
],
[
110,
59
],
[
101,
62
],
[
107,
62
],
[
98,
66
],
[
122,
67
],
[
118,
69
],
[
101,
71
],
[
107,
71
],
[
106,
74
],
[
112,
77
],
[
95,
82
],
[
110,
85
],
[
119,
86
],
[
92,
86
],
[
113,
89
],
[
91,
92
],
[
94,
95
],
[
97,
98
],
[
100,
101
],
[
103,
104
],
[
106,
107
],
[
109,
110
],
[
112,
113
],
[
115,
116
],
[
118,
119
],
[
121,
122
]
] |
[
"n = int(input())\ns = input()\nt = input()\n\nif s == t:\n print(len(s))\n exit(0)\n\nind = 0\nmx = min(len(s), len(t))\nmx_len = 0\nwhile ind < mx:\n pre_i = s[-(ind + 1):]\n suf_i = t[:(ind + 1)]\n if pre_i == suf_i:\n mx_len = ind + 1\n\n ind += 1\n\nans = len(s) + len(t) - mx_len\nprint(ans)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"if s == t:\n print(len(s))\n exit(0)",
"s == t",
"s",
"t",
"print(len(s))",
"print",
"len(s)",
"len",
"s",
"exit(0)",
"exit",
"0",
"ind = 0",
"ind",
"0",
"mx = min(len(s), len(t))",
"mx",
"min(len(s), len(t))",
"min",
"len(s)",
"len",
"s",
"len(t)",
"len",
"t",
"mx_len = 0",
"mx_len",
"0",
"while ind < mx:\n pre_i = s[-(ind + 1):]\n suf_i = t[:(ind + 1)]\n if pre_i == suf_i:\n mx_len = ind + 1\n\n ind += 1",
"ind < mx",
"ind",
"mx",
"pre_i = s[-(ind + 1):]",
"pre_i",
"s[-(ind + 1):]",
"s",
"-(ind + 1):",
"-(ind + 1)",
"ind + 1",
"ind",
"1",
"suf_i = t[:(ind + 1)]",
"suf_i",
"t[:(ind + 1)]",
"t",
":(ind + 1)",
"ind + 1",
"ind",
"1",
"if pre_i == suf_i:\n mx_len = ind + 1\n\n ",
"pre_i == suf_i",
"pre_i",
"suf_i",
"mx_len = ind + 1",
"mx_len",
"ind + 1",
"ind",
"1",
"ind += 1",
"ind",
"1",
"ans = len(s) + len(t) - mx_len",
"ans",
"len(s) + len(t) - mx_len",
"len(s) + len(t)",
"len(s)",
"len",
"s",
"len(t)",
"len",
"t",
"mx_len",
"print(ans)",
"print",
"ans",
"mx_len = 0",
"0",
"mx_len",
"s = input()",
"input()",
"s",
"pre_i = s[-(ind + 1):]",
"s[-(ind + 1):]",
"pre_i",
"ind = 0",
"0",
"ind",
"mx = min(len(s), len(t))",
"min(len(s), len(t))",
"mx",
"ind += 1",
"1",
"ind",
"t = input()",
"input()",
"t",
"ans = len(s) + len(t) - mx_len",
"len(s) + len(t) - mx_len",
"ans",
"n = int(input())",
"int(input())",
"n",
"mx_len = ind + 1",
"ind + 1",
"mx_len",
"suf_i = t[:(ind + 1)]",
"t[:(ind + 1)]",
"suf_i"
] |
n = int(input())
s = input()
t = input()
if s == t:
print(len(s))
exit(0)
ind = 0
mx = min(len(s), len(t))
mx_len = 0
while ind < mx:
pre_i = s[-(ind + 1):]
suf_i = t[:(ind + 1)]
if pre_i == suf_i:
mx_len = ind + 1
ind += 1
ans = len(s) + len(t) - mx_len
print(ans)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
18,
13,
39,
2,
2,
13,
13,
17,
13,
0,
13,
18,
13,
39,
17,
2,
13,
17,
14,
2,
13,
13,
0,
13,
2,
2,
13,
17,
2,
13,
17,
14,
2,
13,
17,
0,
13,
2,
13,
17,
4,
13,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
18,
13,
10,
4,
13,
10,
18,
13
] |
[
[
87,
2
],
[
75,
8
],
[
78,
12
],
[
72,
16
],
[
20,
19
],
[
88,
22
],
[
84,
24
],
[
76,
26
],
[
88,
30
],
[
19,
31
],
[
90,
35
],
[
79,
37
],
[
19,
41
],
[
85,
45
],
[
91,
46
],
[
81,
48
],
[
88,
51
],
[
19,
54
],
[
82,
58
],
[
73,
58
],
[
69,
61
],
[
88,
63
],
[
70,
67
],
[
82,
67
],
[
73,
67
],
[
69,
70
],
[
72,
73
],
[
75,
76
],
[
78,
79
],
[
81,
82
],
[
84,
85
],
[
87,
88
],
[
90,
91
]
] |
[
"n = int(input())\ns = input()\nt = input()\nans = 0\nfor i in range(n):\n dum1 = s[n-i-1:n]\n dum2 = t[0:i+1]\n if dum1 == dum2:\n ans = n*2-((i+1))\nif ans == 0:\n ans = n*2\nprint(ans)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"ans = 0",
"ans",
"0",
"for i in range(n):\n dum1 = s[n-i-1:n]\n dum2 = t[0:i+1]\n if dum1 == dum2:\n ans = n*2-((i+1))",
"i",
"range(n)",
"range",
"n",
"dum1 = s[n-i-1:n]",
"dum1",
"s[n-i-1:n]",
"s",
"n-i-1:n",
"n-i-1",
"n-i",
"n",
"i",
"1",
"n",
"dum2 = t[0:i+1]",
"dum2",
"t[0:i+1]",
"t",
"0:i+1",
"0",
"i+1",
"i",
"1",
"if dum1 == dum2:\n ans = n*2-((i+1))",
"dum1 == dum2",
"dum1",
"dum2",
"ans = n*2-((i+1))",
"ans",
"n*2-((i+1))",
"n*2",
"n",
"2",
"i+1",
"i",
"1",
"if ans == 0:\n ans = n*2",
"ans == 0",
"ans",
"0",
"ans = n*2",
"ans",
"n*2",
"n",
"2",
"print(ans)",
"print",
"ans",
"ans = n*2",
"n*2",
"ans",
"ans = 0",
"0",
"ans",
"s = input()",
"input()",
"s",
"t = input()",
"input()",
"t",
"ans = n*2-((i+1))",
"n*2-((i+1))",
"ans",
"dum1 = s[n-i-1:n]",
"s[n-i-1:n]",
"dum1",
"n = int(input())",
"int(input())",
"n",
"dum2 = t[0:i+1]",
"t[0:i+1]",
"dum2"
] |
n = int(input())
s = input()
t = input()
ans = 0
for i in range(n):
dum1 = s[n-i-1:n]
dum2 = t[0:i+1]
if dum1 == dum2:
ans = n*2-((i+1))
if ans == 0:
ans = n*2
print(ans)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
28,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
13,
14,
40,
18,
13,
2,
13,
13,
18,
13,
13,
3,
4,
13,
2,
13,
13,
4,
13,
4,
13,
2,
13,
17,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
54,
2
],
[
51,
8
],
[
57,
12
],
[
17,
16
],
[
55,
19
],
[
22,
21
],
[
55,
25
],
[
16,
26
],
[
52,
30
],
[
16,
32
],
[
21,
33
],
[
58,
35
],
[
21,
36
],
[
16,
41
],
[
55,
42
],
[
55,
48
],
[
51,
52
],
[
54,
55
],
[
57,
58
]
] |
[
"N = int(input())\ns = input()\nt = input()\n\nfor i in range(N):\n for j in range(N - i):\n if s[i + j] != t[j]:\n break\n else:\n print(i + N)\n exit()\n\nprint(N * 2)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"for i in range(N):\n for j in range(N - i):\n if s[i + j] != t[j]:\n break\n else:\n print(i + N)\n exit()",
"i",
"range(N)",
"range",
"N",
"for j in range(N - i):\n if s[i + j] != t[j]:\n break\n else:\n print(i + N)\n exit()",
"j",
"range(N - i)",
"range",
"N - i",
"N",
"i",
"if s[i + j] != t[j]:\n break\n ",
"s[i + j] != t[j]",
"s[i + j]",
"s",
"i + j",
"i",
"j",
"t[j]",
"t",
"j",
"break",
"print(i + N)",
"print",
"i + N",
"i",
"N",
"exit()",
"exit",
"print(N * 2)",
"print",
"N * 2",
"N",
"2",
"s = input()",
"input()",
"s",
"N = int(input())",
"int(input())",
"N",
"t = input()",
"input()",
"t"
] |
N = int(input())
s = input()
t = input()
for i in range(N):
for j in range(N - i):
if s[i + j] != t[j]:
break
else:
print(i + N)
exit()
print(N * 2)
|
[
7,
12,
13,
14,
2,
13,
13,
14,
2,
13,
17,
0,
13,
2,
13,
17,
28,
13,
4,
13,
13,
14,
2,
18,
13,
39,
13,
18,
13,
39,
2,
13,
13,
0,
13,
4,
13,
18,
13,
39,
13,
3,
29,
13,
23,
13,
23,
13,
23,
13,
12,
13,
29,
12,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
4,
13,
4,
13,
13,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13
] |
[
[
47,
5
],
[
49,
6
],
[
45,
9
],
[
13,
12
],
[
45,
14
],
[
18,
17
],
[
45,
20
],
[
47,
24
],
[
49,
28
],
[
45,
31
],
[
17,
32
],
[
35,
34
],
[
47,
38
],
[
34,
43
],
[
12,
43
],
[
45,
45
],
[
47,
47
],
[
49,
49
],
[
57,
56
],
[
63,
62
],
[
67,
66
],
[
84,
72
],
[
56,
73
],
[
62,
74
],
[
66,
75
],
[
90,
81
]
] |
[
"def myAnswer(N:int,s:str,t:str) -> int:\n if(s == t): return N\n if(N == 1): return 2\n total = N * 2\n # sとtを比較して重なった文字数をtotalから引く\n for i in range(N):\n if(s[i:] == t[:N-i]):\n total -= len(s[i:])\n break\n return total\n\ndef modelAnswer():\n return\ndef main():\n N = int(input())\n s = input()\n t = input()\n print(myAnswer(N,s,t))\nif __name__ == '__main__':\n main()",
"def myAnswer(N:int,s:str,t:str) -> int:\n if(s == t): return N\n if(N == 1): return 2\n total = N * 2\n # sとtを比較して重なった文字数をtotalから引く\n for i in range(N):\n if(s[i:] == t[:N-i]):\n total -= len(s[i:])\n break\n return total",
"myAnswer",
"if(s == t): return N\n ",
"s == t",
"s",
"t",
"if(N == 1): return 2\n ",
"N == 1",
"N",
"1",
"total = N * 2",
"total",
"N * 2",
"N",
"2",
"for i in range(N):\n if(s[i:] == t[:N-i]):\n total -= len(s[i:])\n break\n ",
"i",
"range(N)",
"range",
"N",
"if(s[i:] == t[:N-i]):\n total -= len(s[i:])\n break\n ",
"s[i:] == t[:N-i]",
"s[i:]",
"s",
"i:",
"i",
"t[:N-i]",
"t",
":N-i",
"N-i",
"N",
"i",
"total -= len(s[i:])",
"total",
"len(s[i:])",
"len",
"s[i:]",
"s",
"i:",
"i",
"break",
"return total",
"total",
"N:int",
"N",
"s:str",
"s",
"t:str",
"t",
"def modelAnswer():\n return",
"modelAnswer",
"return",
"def main():\n N = int(input())\n s = input()\n t = input()\n print(myAnswer(N,s,t))",
"main",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"print(myAnswer(N,s,t))",
"print",
"myAnswer(N,s,t)",
"myAnswer",
"N",
"s",
"t",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def myAnswer(N:int,s:str,t:str) -> int:\n if(s == t): return N\n if(N == 1): return 2\n total = N * 2\n # sとtを比較して重なった文字数をtotalから引く\n for i in range(N):\n if(s[i:] == t[:N-i]):\n total -= len(s[i:])\n break\n return total",
"def myAnswer(N:int,s:str,t:str) -> int:\n if(s == t): return N\n if(N == 1): return 2\n total = N * 2\n # sとtを比較して重なった文字数をtotalから引く\n for i in range(N):\n if(s[i:] == t[:N-i]):\n total -= len(s[i:])\n break\n return total",
"myAnswer",
"def modelAnswer():\n return",
"def modelAnswer():\n return",
"modelAnswer",
"def main():\n N = int(input())\n s = input()\n t = input()\n print(myAnswer(N,s,t))",
"def main():\n N = int(input())\n s = input()\n t = input()\n print(myAnswer(N,s,t))",
"main"
] |
def myAnswer(N:int,s:str,t:str) -> int:
if(s == t): return N
if(N == 1): return 2
total = N * 2
# sとtを比較して重なった文字数をtotalから引く
for i in range(N):
if(s[i:] == t[:N-i]):
total -= len(s[i:])
break
return total
def modelAnswer():
return
def main():
N = int(input())
s = input()
t = input()
print(myAnswer(N,s,t))
if __name__ == '__main__':
main()
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
13,
14,
40,
18,
13,
13,
18,
13,
13,
0,
13,
17,
3,
0,
13,
17,
14,
40,
13,
0,
13,
2,
13,
13,
3,
4,
13,
2,
2,
4,
13,
13,
4,
13,
13,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13
] |
[
[
77,
2
],
[
89,
8
],
[
86,
12
],
[
92,
16
],
[
20,
19
],
[
78,
22
],
[
80,
24
],
[
95,
27
],
[
31,
30
],
[
19,
33
],
[
78,
34
],
[
90,
38
],
[
30,
39
],
[
87,
41
],
[
81,
42
],
[
72,
42
],
[
83,
44
],
[
71,
48
],
[
84,
52
],
[
96,
52
],
[
74,
54
],
[
78,
56
],
[
19,
57
],
[
90,
65
],
[
87,
68
],
[
75,
69
],
[
93,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
],
[
89,
90
],
[
92,
93
],
[
95,
96
]
] |
[
"N=int(input())\ns=input()\nt=input()\ncommon=0\n\nfor start in range(N):\n point=0\n check=False\n for i in range(start,N):\n if s[i] != t[point]:\n check=True\n break\n point+=1\n if not check:\n common=N-start\n break\n\nprint(len(s)+len(t)-common)",
"N=int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s=input()",
"s",
"input()",
"input",
"t=input()",
"t",
"input()",
"input",
"common=0",
"common",
"0",
"for start in range(N):\n point=0\n check=False\n for i in range(start,N):\n if s[i] != t[point]:\n check=True\n break\n point+=1\n if not check:\n common=N-start\n break",
"start",
"range(N)",
"range",
"N",
"point=0",
"point",
"0",
"check=False",
"check",
"False",
"for i in range(start,N):\n if s[i] != t[point]:\n check=True\n break\n point+=1\n ",
"i",
"range(start,N)",
"range",
"start",
"N",
"if s[i] != t[point]:\n check=True\n break\n ",
"s[i] != t[point]",
"s[i]",
"s",
"i",
"t[point]",
"t",
"point",
"check=True",
"check",
"True",
"break",
"point+=1",
"point",
"1",
"if not check:\n common=N-start\n break",
"not check",
"check",
"common=N-start",
"common",
"N-start",
"N",
"start",
"break",
"print(len(s)+len(t)-common)",
"print",
"len(s)+len(t)-common",
"len(s)+len(t)",
"len(s)",
"len",
"s",
"len(t)",
"len",
"t",
"common",
"point+=1",
"1",
"point",
"common=N-start",
"N-start",
"common",
"N=int(input())",
"int(input())",
"N",
"point=0",
"0",
"point",
"check=True",
"True",
"check",
"t=input()",
"input()",
"t",
"s=input()",
"input()",
"s",
"common=0",
"0",
"common",
"check=False",
"False",
"check"
] |
N=int(input())
s=input()
t=input()
common=0
for start in range(N):
point=0
check=False
for i in range(start,N):
if s[i] != t[point]:
check=True
break
point+=1
if not check:
common=N-start
break
print(len(s)+len(t)-common)
|
[
7,
15,
13,
13,
15,
15,
15,
15,
15,
15,
15,
15,
15,
15,
15,
12,
13,
12,
13,
12,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
12,
13,
23,
13,
4,
18,
13,
13,
2,
17,
17,
0,
13,
4,
13,
17,
0,
13,
2,
2,
17,
17,
17,
15,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
14,
2,
13,
13,
4,
13,
13,
4,
13,
28,
13,
4,
13,
17,
13,
14,
2,
18,
13,
39,
13,
18,
13,
39,
40,
13,
4,
13,
2,
2,
17,
13,
4,
13,
18,
13,
39,
13,
3,
4,
13,
2,
17,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13
] |
[
[
26,
25
],
[
123,
31
],
[
35,
35
],
[
125,
44
],
[
113,
49
],
[
128,
57
],
[
141,
59
],
[
116,
61
],
[
132,
63
],
[
134,
65
],
[
132,
67
],
[
117,
70
],
[
135,
71
],
[
129,
74
],
[
79,
78
],
[
129,
82
],
[
117,
86
],
[
135,
90
],
[
78,
93
],
[
129,
99
],
[
117,
103
],
[
129,
111
],
[
113,
114
],
[
116,
117
],
[
125,
126
],
[
128,
129
],
[
134,
135
]
] |
[
"import sys, re\nfrom collections import deque, defaultdict, Counter\nfrom math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees#, log2, log\nfrom itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby\nfrom operator import itemgetter, mul\nfrom copy import deepcopy\nfrom string import ascii_lowercase, ascii_uppercase, digits\nfrom bisect import bisect, bisect_left, insort, insort_left\nfrom fractions import gcd\nfrom heapq import heappush, heappop\nfrom functools import reduce\nfrom decimal import Decimal\ndef input(): return sys.stdin.readline().strip()\ndef INT(): return int(input())\ndef MAP(): return map(int, input().split())\ndef LIST(): return list(map(int, input().split()))\ndef ZIP(n): return zip(*(MAP() for _ in range(n)))\nsys.setrecursionlimit(10 ** 9)\nINF = float('inf')\nmod = 10**9 + 7\nfrom decimal import *\n\nN = INT()\ns = input()\nt = input()\n\nif s == t:\n\tprint(N)\n\texit()\n\nfor i in range(1, N):\n\tif s[i:] == t[:-i]:\n\t\tprint(2*N - len(s[i:]))\n\t\tbreak\nelse:\n\tprint(2*N)",
"import sys, re",
"sys",
"re",
"from collections import deque, defaultdict, Counter",
"from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees",
"from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby",
"from operator import itemgetter, mul",
"from copy import deepcopy",
"from string import ascii_lowercase, ascii_uppercase, digits",
"from bisect import bisect, bisect_left, insort, insort_left",
"from fractions import gcd",
"from heapq import heappush, heappop",
"from functools import reduce",
"from decimal import Decimal",
"def input(): return sys.stdin.readline().strip()",
"input",
"def INT(): return int(input())",
"INT",
"def MAP(): return map(int, input().split())",
"MAP",
"def LIST(): return list(map(int, input().split()))",
"LIST",
"MAP() for _ in range(n)",
"for _ in range(n)",
"_",
"range(n)",
"range",
"n",
"for _ in range(n)",
"MAP()",
"MAP",
"def ZIP(n): return zip(*(MAP() for _ in range(n)))",
"ZIP",
"n",
"n",
"sys.setrecursionlimit(10 ** 9)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10 ** 9",
"10",
"9",
"INF = float('inf')",
"INF",
"float('inf')",
"float",
"'inf'",
"mod = 10**9 + 7",
"mod",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"from decimal import *",
"N = INT()",
"N",
"INT()",
"INT",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"if s == t:\n\tprint(N)\n\texit()",
"s == t",
"s",
"t",
"print(N)",
"print",
"N",
"exit()",
"exit",
"for i in range(1, N):\n\tif s[i:] == t[:-i]:\n\t\tprint(2*N - len(s[i:]))\n\t\tbreak\nelse:\n\tprint(2*N)",
"i",
"range(1, N)",
"range",
"1",
"N",
"if s[i:] == t[:-i]:\n\t\tprint(2*N - len(s[i:]))\n\t\tbreak",
"s[i:] == t[:-i]",
"s[i:]",
"s",
"i:",
"i",
"t[:-i]",
"t",
":-i",
"-i",
"i",
"print(2*N - len(s[i:]))",
"print",
"2*N - len(s[i:])",
"2*N",
"2",
"N",
"len(s[i:])",
"len",
"s[i:]",
"s",
"i:",
"i",
"break",
"print(2*N)",
"print",
"2*N",
"2",
"N",
"mod = 10**9 + 7",
"10**9 + 7",
"mod",
"s = input()",
"input()",
"s",
"def ZIP(n): return zip(*(MAP() for _ in range(n)))",
"def ZIP(n): return zip(*(MAP() for _ in range(n)))",
"ZIP",
"def MAP(): return map(int, input().split())",
"def MAP(): return map(int, input().split())",
"MAP",
"INF = float('inf')",
"float('inf')",
"INF",
"N = INT()",
"INT()",
"N",
"def input(): return sys.stdin.readline().strip()",
"def input(): return sys.stdin.readline().strip()",
"input",
"t = input()",
"input()",
"t",
"def LIST(): return list(map(int, input().split()))",
"def LIST(): return list(map(int, input().split()))",
"LIST",
"def INT(): return int(input())",
"def INT(): return int(input())",
"INT"
] |
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees#, log2, log
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
from decimal import Decimal
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10**9 + 7
from decimal import *
N = INT()
s = input()
t = input()
if s == t:
print(N)
exit()
for i in range(1, N):
if s[i:] == t[:-i]:
print(2*N - len(s[i:]))
break
else:
print(2*N)
|
[
7,
15,
13,
0,
13,
18,
18,
13,
13,
13,
12,
13,
0,
13,
4,
13,
4,
18,
4,
13,
13,
0,
13,
4,
18,
4,
13,
13,
0,
13,
4,
18,
4,
13,
13,
29,
39,
13,
13,
13,
12,
13,
28,
13,
4,
13,
13,
17,
17,
0,
13,
2,
13,
13,
0,
13,
13,
14,
2,
18,
13,
39,
13,
18,
13,
39,
13,
29,
2,
2,
17,
13,
13,
29,
2,
17,
13,
23,
13,
23,
13,
23,
13,
14,
2,
13,
17,
0,
13,
4,
13,
4,
13,
2,
17,
4,
13,
31,
13,
10,
12,
13,
10,
18,
13,
10,
4,
13,
10,
12,
13
] |
[
[
103,
4
],
[
14,
13
],
[
104,
19
],
[
23,
22
],
[
104,
26
],
[
30,
29
],
[
104,
33
],
[
44,
43
],
[
78,
46
],
[
51,
50
],
[
78,
52
],
[
43,
53
],
[
56,
55
],
[
43,
56
],
[
80,
60
],
[
82,
64
],
[
78,
71
],
[
43,
72
],
[
78,
76
],
[
78,
78
],
[
80,
80
],
[
82,
82
],
[
106,
88
],
[
101,
90
],
[
110,
96
],
[
107,
98
],
[
103,
104
],
[
106,
107
]
] |
[
"import sys\ninput = sys.stdin.readline\n\n\ndef read():\n N = int(input().strip())\n s = input().strip()\n t = input().strip()\n return N, s, t\n\n\ndef solve(N, s, t):\n for i in range(N, 0, -1):\n sl = N - i\n tr = i\n if s[sl:] == t[:tr]:\n return 2 * N - i\n return 2 * N\n\n\nif __name__ == '__main__':\n inputs = read()\n print(\"%s\" % solve(*inputs))",
"import sys",
"sys",
"input = sys.stdin.readline",
"input",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"def read():\n N = int(input().strip())\n s = input().strip()\n t = input().strip()\n return N, s, t",
"read",
"N = int(input().strip())",
"N",
"int(input().strip())",
"int",
"input().strip()",
"().strip",
"()",
"input",
"strip",
"s = input().strip()",
"s",
"input().strip()",
"().strip",
"()",
"input",
"strip",
"t = input().strip()",
"t",
"input().strip()",
"().strip",
"()",
"input",
"strip",
"return N, s, t",
"return N, s, t",
"N",
"s",
"t",
"def solve(N, s, t):\n for i in range(N, 0, -1):\n sl = N - i\n tr = i\n if s[sl:] == t[:tr]:\n return 2 * N - i\n return 2 * N",
"solve",
"for i in range(N, 0, -1):\n sl = N - i\n tr = i\n if s[sl:] == t[:tr]:\n return 2 * N - i\n ",
"i",
"range(N, 0, -1)",
"range",
"N",
"0",
"-1",
"sl = N - i",
"sl",
"N - i",
"N",
"i",
"tr = i",
"tr",
"i",
"if s[sl:] == t[:tr]:\n return 2 * N - i\n ",
"s[sl:] == t[:tr]",
"s[sl:]",
"s",
"sl:",
"sl",
"t[:tr]",
"t",
":tr",
"tr",
"return 2 * N - i",
"2 * N - i",
"2 * N",
"2",
"N",
"i",
"return 2 * N",
"2 * N",
"2",
"N",
"N",
"N",
"s",
"s",
"t",
"t",
"if __name__ == '__main__':\n inputs = read()\n print(\"%s\" % solve(*inputs))",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"inputs = read()",
"inputs",
"read()",
"read",
"print(\"%s\" % solve(*inputs))",
"print",
"\"%s\" % solve(*inputs)",
"\"%s\"",
"solve(*inputs)",
"solve",
"*inputs",
"inputs",
"def read():\n N = int(input().strip())\n s = input().strip()\n t = input().strip()\n return N, s, t",
"def read():\n N = int(input().strip())\n s = input().strip()\n t = input().strip()\n return N, s, t",
"read",
"input = sys.stdin.readline",
"sys.stdin.readline",
"input",
"inputs = read()",
"read()",
"inputs",
"def solve(N, s, t):\n for i in range(N, 0, -1):\n sl = N - i\n tr = i\n if s[sl:] == t[:tr]:\n return 2 * N - i\n return 2 * N",
"def solve(N, s, t):\n for i in range(N, 0, -1):\n sl = N - i\n tr = i\n if s[sl:] == t[:tr]:\n return 2 * N - i\n return 2 * N",
"solve"
] |
import sys
input = sys.stdin.readline
def read():
N = int(input().strip())
s = input().strip()
t = input().strip()
return N, s, t
def solve(N, s, t):
for i in range(N, 0, -1):
sl = N - i
tr = i
if s[sl:] == t[:tr]:
return 2 * N - i
return 2 * N
if __name__ == '__main__':
inputs = read()
print("%s" % solve(*inputs))
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
2,
4,
13,
13,
4,
13,
13,
0,
13,
2,
28,
13,
4,
13,
4,
13,
13,
14,
40,
4,
13,
18,
13,
39,
13,
4,
13,
13,
0,
13,
4,
13,
18,
13,
39,
13,
14,
2,
40,
2,
13,
13,
13,
2,
18,
13,
39,
13,
18,
13,
39,
17,
13,
0,
13,
2,
13,
13,
3,
4,
13,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13
] |
[
[
86,
2
],
[
89,
8
],
[
92,
12
],
[
95,
16
],
[
90,
20
],
[
93,
23
],
[
95,
25
],
[
29,
28
],
[
90,
33
],
[
90,
39
],
[
93,
44
],
[
98,
46
],
[
90,
50
],
[
96,
57
],
[
99,
58
],
[
87,
59
],
[
90,
62
],
[
93,
66
],
[
80,
71
],
[
96,
73
],
[
99,
74
],
[
81,
78
],
[
84,
78
],
[
80,
81
],
[
95,
84
],
[
86,
87
],
[
89,
90
],
[
92,
93
],
[
95,
96
],
[
98,
99
]
] |
[
"N = int(input())\ns = input()\nt = input()\nans=maxlen=len(s)+len(t)\n\nfor i in range(len(s)):\n if len(s[i:]) <= len(t):\n complen = len(s[i:])\n if maxlen-complen>=N and s[i:] == t[0:complen]:\n ans=maxlen-complen\n break\n \n \nprint(ans)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"ans=maxlen=len(s)+len(t)",
"ans",
"len(s)+len(t)",
"len(s)",
"len",
"s",
"len(t)",
"len",
"t",
"=maxlen=len(s)+len(t)",
"maxlen",
"len(s)+len(t)",
"for i in range(len(s)):\n if len(s[i:]) <= len(t):\n complen = len(s[i:])\n if maxlen-complen>=N and s[i:] == t[0:complen]:\n ans=maxlen-complen\n break\n \n ",
"i",
"range(len(s))",
"range",
"len(s)",
"len",
"s",
"if len(s[i:]) <= len(t):\n complen = len(s[i:])\n if maxlen-complen>=N and s[i:] == t[0:complen]:\n ans=maxlen-complen\n break\n \n ",
"len(s[i:]) <= len(t)",
"len(s[i:])",
"len",
"s[i:]",
"s",
"i:",
"i",
"len(t)",
"len",
"t",
"complen = len(s[i:])",
"complen",
"len(s[i:])",
"len",
"s[i:]",
"s",
"i:",
"i",
"if maxlen-complen>=N and s[i:] == t[0:complen]:\n ans=maxlen-complen\n break\n \n ",
"maxlen-complen>=N and s[i:] == t[0:complen]",
"maxlen-complen>=N",
"maxlen-complen",
"maxlen",
"complen",
"N",
"s[i:] == t[0:complen]",
"s[i:]",
"s",
"i:",
"i",
"t[0:complen]",
"t",
"0:complen",
"0",
"complen",
"ans=maxlen-complen",
"ans",
"maxlen-complen",
"maxlen",
"complen",
"break",
"print(ans)",
"print",
"ans",
"ans=maxlen-complen",
"maxlen-complen",
"ans",
"ans=maxlen=len(s)+len(t)",
"len(s)+len(t)",
"ans",
"N = int(input())",
"int(input())",
"N",
"s = input()",
"input()",
"s",
"t = input()",
"input()",
"t",
"maxlen=len(s)+len(t)",
"len(s)+len(t)",
"maxlen",
"complen = len(s[i:])",
"len(s[i:])",
"complen"
] |
N = int(input())
s = input()
t = input()
ans=maxlen=len(s)+len(t)
for i in range(len(s)):
if len(s[i:]) <= len(t):
complen = len(s[i:])
if maxlen-complen>=N and s[i:] == t[0:complen]:
ans=maxlen-complen
break
print(ans)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
13,
28,
13,
4,
13,
2,
13,
17,
14,
2,
18,
13,
39,
13,
18,
13,
39,
13,
0,
13,
4,
13,
13,
4,
13,
18,
13,
39,
13,
4,
13,
2,
2,
13,
17,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13
] |
[
[
68,
2
],
[
71,
8
],
[
59,
12
],
[
65,
16
],
[
20,
19
],
[
69,
22
],
[
25,
24
],
[
69,
28
],
[
72,
33
],
[
60,
37
],
[
62,
41
],
[
66,
44
],
[
63,
44
],
[
72,
48
],
[
69,
55
],
[
63,
57
],
[
66,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
]
] |
[
"N = int(input())\ns = input()\nt = input()\n\ndupe = 0\nfor i in range(N):\n for j in range(N + 1):\n if s[i:] == t[:j]:\n dupe = max(dupe, len(s[i:]))\nprint(N * 2 - dupe)\n",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"dupe = 0",
"dupe",
"0",
"for i in range(N):\n for j in range(N + 1):\n if s[i:] == t[:j]:\n dupe = max(dupe, len(s[i:]))",
"i",
"range(N)",
"range",
"N",
"for j in range(N + 1):\n if s[i:] == t[:j]:\n dupe = max(dupe, len(s[i:]))",
"j",
"range(N + 1)",
"range",
"N + 1",
"N",
"1",
"if s[i:] == t[:j]:\n dupe = max(dupe, len(s[i:]))",
"s[i:] == t[:j]",
"s[i:]",
"s",
"i:",
"i",
"t[:j]",
"t",
":j",
"j",
"dupe = max(dupe, len(s[i:]))",
"dupe",
"max(dupe, len(s[i:]))",
"max",
"dupe",
"len(s[i:])",
"len",
"s[i:]",
"s",
"i:",
"i",
"print(N * 2 - dupe)",
"print",
"N * 2 - dupe",
"N * 2",
"N",
"2",
"dupe",
"t = input()",
"input()",
"t",
"dupe = max(dupe, len(s[i:]))",
"max(dupe, len(s[i:]))",
"dupe",
"dupe = 0",
"0",
"dupe",
"N = int(input())",
"int(input())",
"N",
"s = input()",
"input()",
"s"
] |
N = int(input())
s = input()
t = input()
dupe = 0
for i in range(N):
for j in range(N + 1):
if s[i:] == t[:j]:
dupe = max(dupe, len(s[i:]))
print(N * 2 - dupe)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
2,
13,
13,
28,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
13,
14,
40,
18,
13,
13,
18,
13,
2,
13,
13,
0,
13,
17,
3,
14,
13,
0,
13,
2,
18,
13,
39,
13,
13,
3,
4,
13,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13
] |
[
[
71,
2
],
[
77,
8
],
[
68,
12
],
[
80,
16
],
[
78,
18
],
[
69,
19
],
[
22,
21
],
[
72,
24
],
[
65,
26
],
[
30,
29
],
[
21,
32
],
[
72,
33
],
[
78,
37
],
[
29,
38
],
[
69,
40
],
[
29,
42
],
[
21,
43
],
[
83,
45
],
[
74,
51
],
[
78,
54
],
[
69,
57
],
[
75,
63
],
[
81,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
]
] |
[
"n = int(input())\ns = input()\nt = input()\n\nans = s + t\nfor i in range(n):\n is_same = True\n for j in range(i, n):\n if s[j] != t[j - i]:\n is_same = False\n break\n if is_same:\n ans = s[:i] + t\n break\n\nprint(len(ans))",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"ans = s + t",
"ans",
"s + t",
"s",
"t",
"for i in range(n):\n is_same = True\n for j in range(i, n):\n if s[j] != t[j - i]:\n is_same = False\n break\n if is_same:\n ans = s[:i] + t\n break",
"i",
"range(n)",
"range",
"n",
"is_same = True",
"is_same",
"True",
"for j in range(i, n):\n if s[j] != t[j - i]:\n is_same = False\n break\n ",
"j",
"range(i, n)",
"range",
"i",
"n",
"if s[j] != t[j - i]:\n is_same = False\n break\n ",
"s[j] != t[j - i]",
"s[j]",
"s",
"j",
"t[j - i]",
"t",
"j - i",
"j",
"i",
"is_same = False",
"is_same",
"False",
"break",
"if is_same:\n ans = s[:i] + t\n break",
"is_same",
"ans = s[:i] + t",
"ans",
"s[:i] + t",
"s[:i]",
"s",
":i",
"i",
"t",
"break",
"print(len(ans))",
"print",
"len(ans)",
"len",
"ans",
"is_same = True",
"True",
"is_same",
"t = input()",
"input()",
"t",
"n = int(input())",
"int(input())",
"n",
"ans = s[:i] + t",
"s[:i] + t",
"ans",
"s = input()",
"input()",
"s",
"ans = s + t",
"s + t",
"ans",
"is_same = False",
"False",
"is_same"
] |
n = int(input())
s = input()
t = input()
ans = s + t
for i in range(n):
is_same = True
for j in range(i, n):
if s[j] != t[j - i]:
is_same = False
break
if is_same:
ans = s[:i] + t
break
print(len(ans))
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
28,
13,
4,
13,
13,
14,
2,
18,
13,
39,
13,
18,
13,
39,
2,
13,
13,
4,
13,
2,
2,
17,
13,
2,
13,
13,
4,
13,
4,
13,
2,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
49,
2
],
[
55,
8
],
[
52,
12
],
[
17,
16
],
[
50,
19
],
[
56,
23
],
[
53,
27
],
[
50,
30
],
[
16,
31
],
[
50,
37
],
[
50,
39
],
[
16,
40
],
[
50,
47
],
[
49,
50
],
[
52,
53
],
[
55,
56
]
] |
[
"N = int(input())\ns = input()\nt = input()\nfor i in range(N):\n if s[i:] == t[:N-i]:\n print(2*N - (N-i))\n exit()\nprint(2*N)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"for i in range(N):\n if s[i:] == t[:N-i]:\n print(2*N - (N-i))\n exit()",
"i",
"range(N)",
"range",
"N",
"if s[i:] == t[:N-i]:\n print(2*N - (N-i))\n exit()",
"s[i:] == t[:N-i]",
"s[i:]",
"s",
"i:",
"i",
"t[:N-i]",
"t",
":N-i",
"N-i",
"N",
"i",
"print(2*N - (N-i))",
"print",
"2*N - (N-i)",
"2*N",
"2",
"N",
"N-i",
"N",
"i",
"exit()",
"exit",
"print(2*N)",
"print",
"2*N",
"2",
"N",
"N = int(input())",
"int(input())",
"N",
"t = input()",
"input()",
"t",
"s = input()",
"input()",
"s"
] |
N = int(input())
s = input()
t = input()
for i in range(N):
if s[i:] == t[:N-i]:
print(2*N - (N-i))
exit()
print(2*N)
|
[
7,
15,
13,
15,
13,
12,
13,
12,
13,
12,
13,
12,
13,
41,
28,
13,
4,
18,
4,
18,
4,
18,
18,
13,
13,
13,
13,
17,
17,
13,
4,
4,
13,
13,
12,
13,
12,
13,
23,
13,
14,
2,
13,
17,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
14,
2,
18,
18,
13,
39,
13,
13,
13,
18,
18,
13,
39,
2,
13,
13,
13,
0,
13,
4,
13,
13,
13,
4,
13,
2,
2,
17,
13,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
17,
13,
10,
12,
13,
10,
12,
13,
10,
17,
13,
10,
4,
13
] |
[
[
16,
15
],
[
15,
33
],
[
39,
39
],
[
105,
45
],
[
118,
47
],
[
114,
49
],
[
133,
51
],
[
123,
53
],
[
133,
55
],
[
126,
57
],
[
61,
60
],
[
106,
63
],
[
135,
65
],
[
69,
68
],
[
106,
72
],
[
60,
73
],
[
115,
78
],
[
68,
82
],
[
124,
85
],
[
106,
88
],
[
60,
89
],
[
68,
90
],
[
138,
92
],
[
127,
95
],
[
139,
95
],
[
136,
96
],
[
106,
102
],
[
139,
103
],
[
127,
103
],
[
105,
106
],
[
114,
115
],
[
123,
124
],
[
126,
127
],
[
135,
136
],
[
138,
139
]
] |
[
"import sys\nimport math\ndef I():return int(sys.stdin.readline().replace(\"\\n\",\"\"))\ndef I2():return map(int,sys.stdin.readline().replace(\"\\n\",\"\").split())\ndef S():return str(sys.stdin.readline().replace(\"\\n\",\"\"))\ndef L():return list(sys.stdin.readline().replace(\"\\n\",\"\"))\ndef Intl():return [int(k) for k in sys.stdin.readline().replace(\"\\n\",\"\").split()]\ndef Lx(k):return list(map(lambda x:int(x)*-k,sys.stdin.readline().replace(\"\\n\",\"\").split()))\n\nif __name__ == \"__main__\":\n n = I()\n s = S()\n t = S()\n cnt = 0\n for i in range(n):\n #print(s[i:n],t[:n-i])\n now = 0\n for j in range(n-i):\n if s[i:n][j] == t[:n-i][j]:now += 1\n cnt = max(cnt,now)\n print(2 * n - cnt)",
"import sys",
"sys",
"import math",
"math",
"def I():return int(sys.stdin.readline().replace(\"\\n\",\"\"))",
"I",
"def I2():return map(int,sys.stdin.readline().replace(\"\\n\",\"\").split())",
"I2",
"def S():return str(sys.stdin.readline().replace(\"\\n\",\"\"))",
"S",
"def L():return list(sys.stdin.readline().replace(\"\\n\",\"\"))",
"L",
"int(k) for k in sys.stdin.readline().replace(\"\\n\",\"\").split()",
"for k in sys.stdin.readline().replace(\"\\n\",\"\").split()",
"k",
"sys.stdin.readline().replace(\"\\n\",\"\").split()",
"sys.stdin.readline().replace(\"\\n\",\"\").split",
"sys.stdin.readline().replace(\"\\n\",\"\")",
"sys.stdin.readline().replace",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"replace",
"\"\\n\"",
"\"\"",
"split",
"for k in sys.stdin.readline().replace(\"\\n\",\"\").split()",
"int(k)",
"int",
"k",
"def Intl():return [int(k) for k in sys.stdin.readline().replace(\"\\n\",\"\").split()]",
"Intl",
"def Lx(k):return list(map(lambda x:int(x)*-k,sys.stdin.readline().replace(\"\\n\",\"\").split()))",
"Lx",
"k",
"k",
"if __name__ == \"__main__\":\n n = I()\n s = S()\n t = S()\n cnt = 0\n for i in range(n):\n #print(s[i:n],t[:n-i])\n now = 0\n for j in range(n-i):\n if s[i:n][j] == t[:n-i][j]:now += 1\n cnt = max(cnt,now)\n print(2 * n - cnt)",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"n = I()",
"n",
"I()",
"I",
"s = S()",
"s",
"S()",
"S",
"t = S()",
"t",
"S()",
"S",
"cnt = 0",
"cnt",
"0",
"for i in range(n):\n #print(s[i:n],t[:n-i])\n now = 0\n for j in range(n-i):\n if s[i:n][j] == t[:n-i][j]:now += 1\n cnt = max(cnt,now)\n ",
"i",
"range(n)",
"range",
"n",
"now = 0",
"now",
"0",
"for j in range(n-i):\n if s[i:n][j] == t[:n-i][j]:now += 1\n ",
"j",
"range(n-i)",
"range",
"n-i",
"n",
"i",
"if s[i:n][j] == t[:n-i][j]:now += 1\n ",
"s[i:n][j] == t[:n-i][j]",
"s[i:n][j]",
"[i:n]",
"s",
"i:n",
"i",
"n",
"j",
"t[:n-i][j]",
"[:n-i]",
"t",
":n-i",
"n-i",
"n",
"i",
"j",
"cnt = max(cnt,now)",
"cnt",
"max(cnt,now)",
"max",
"cnt",
"now",
"print(2 * n - cnt)",
"print",
"2 * n - cnt",
"2 * n",
"2",
"n",
"cnt",
"n = I()",
"I()",
"n",
"def Intl():return [int(k) for k in sys.stdin.readline().replace(\"\\n\",\"\").split()]",
"def Intl():return [int(k) for k in sys.stdin.readline().replace(\"\\n\",\"\").split()]",
"Intl",
"def L():return list(sys.stdin.readline().replace(\"\\n\",\"\"))",
"def L():return list(sys.stdin.readline().replace(\"\\n\",\"\"))",
"L",
"s = S()",
"S()",
"s",
"def I():return int(sys.stdin.readline().replace(\"\\n\",\"\"))",
"def I():return int(sys.stdin.readline().replace(\"\\n\",\"\"))",
"I",
"def I2():return map(int,sys.stdin.readline().replace(\"\\n\",\"\").split())",
"def I2():return map(int,sys.stdin.readline().replace(\"\\n\",\"\").split())",
"I2",
"t = S()",
"S()",
"t",
"cnt = 0",
"0",
"cnt",
"def Lx(k):return list(map(lambda x:int(x)*-k,sys.stdin.readline().replace(\"\\n\",\"\").split()))",
"def Lx(k):return list(map(lambda x:int(x)*-k,sys.stdin.readline().replace(\"\\n\",\"\").split()))",
"Lx",
"def S():return str(sys.stdin.readline().replace(\"\\n\",\"\"))",
"def S():return str(sys.stdin.readline().replace(\"\\n\",\"\"))",
"S",
"now = 0",
"0",
"now",
"cnt = max(cnt,now)",
"max(cnt,now)",
"cnt"
] |
import sys
import math
def I():return int(sys.stdin.readline().replace("\n",""))
def I2():return map(int,sys.stdin.readline().replace("\n","").split())
def S():return str(sys.stdin.readline().replace("\n",""))
def L():return list(sys.stdin.readline().replace("\n",""))
def Intl():return [int(k) for k in sys.stdin.readline().replace("\n","").split()]
def Lx(k):return list(map(lambda x:int(x)*-k,sys.stdin.readline().replace("\n","").split()))
if __name__ == "__main__":
n = I()
s = S()
t = S()
cnt = 0
for i in range(n):
#print(s[i:n],t[:n-i])
now = 0
for j in range(n-i):
if s[i:n][j] == t[:n-i][j]:now += 1
cnt = max(cnt,now)
print(2 * n - cnt)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
2,
17,
13,
28,
13,
4,
13,
13,
17,
17,
0,
13,
2,
18,
13,
39,
13,
13,
14,
2,
2,
18,
13,
39,
13,
13,
2,
18,
13,
39,
40,
13,
13,
0,
13,
4,
13,
4,
13,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13
] |
[
[
65,
2
],
[
74,
8
],
[
77,
12
],
[
71,
16
],
[
66,
19
],
[
22,
21
],
[
66,
24
],
[
62,
28
],
[
75,
31
],
[
78,
34
],
[
63,
39
],
[
75,
42
],
[
63,
45
],
[
66,
48
],
[
78,
49
],
[
68,
51
],
[
63,
56
],
[
72,
57
],
[
69,
57
],
[
69,
60
],
[
72,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
]
] |
[
"# from math import factorial,sqrt,ceil,gcd\n# from itertools import permutations as permus\n# from collections import deque,Counter\n# import re\n# from functools import lru_cache # 簡単メモ化 @lru_cache(maxsize=1000)\n# from decimal import Decimal, getcontext\n# # getcontext().prec = 1000\n# # eps = Decimal(10) ** (-100)\n\n# import numpy as np\n# import networkx as nx\n# from scipy.sparse.csgraph import shortest_path, dijkstra, floyd_warshall, bellman_ford, johnson\n# from scipy.sparse import csr_matrix\n# from scipy.special import comb\n\n# slist = \"abcdefghijklmnopqrstuvwxyz\"\nN = int(input())\nS = input()\nT = input()\nans = 2*N\nfor i in range(N,-1,-1):\n ST = S[:i] + T\n # print(ST,ST[:i],ST[i:])\n if ST[:N]==S and ST[-N:]==T:\n ans = min(len(ST),ans)\n\nprint(ans)\n# print(*ans) # unpackして出力。間にスペースが入る\n# for row in board:\n# print(*row,sep=\"\") #unpackして間にスペース入れずに出力する\n# print(\"{:.10f}\".format(ans))\n# print(\"{:0=10d}\".format(ans))",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"S = input()",
"S",
"input()",
"input",
"T = input()",
"T",
"input()",
"input",
"ans = 2*N",
"ans",
"2*N",
"2",
"N",
"for i in range(N,-1,-1):\n ST = S[:i] + T\n # print(ST,ST[:i],ST[i:])\n if ST[:N]==S and ST[-N:]==T:\n ans = min(len(ST),ans)",
"i",
"range(N,-1,-1)",
"range",
"N",
"-1",
"-1",
"ST = S[:i] + T",
"ST",
"S[:i] + T",
"S[:i]",
"S",
":i",
"i",
"T",
"if ST[:N]==S and ST[-N:]==T:\n ans = min(len(ST),ans)",
"ST[:N]==S and ST[-N:]==T",
"ST[:N]==S",
"ST[:N]",
"ST",
":N",
"N",
"S",
"ST[-N:]==T",
"ST[-N:]",
"ST",
"-N:",
"-N",
"N",
"T",
"ans = min(len(ST),ans)",
"ans",
"min(len(ST),ans)",
"min",
"len(ST)",
"len",
"ST",
"ans",
"print(ans)",
"print",
"ans",
"ST = S[:i] + T",
"S[:i] + T",
"ST",
"N = int(input())",
"int(input())",
"N",
"ans = min(len(ST),ans)",
"min(len(ST),ans)",
"ans",
"ans = 2*N",
"2*N",
"ans",
"S = input()",
"input()",
"S",
"T = input()",
"input()",
"T"
] |
# from math import factorial,sqrt,ceil,gcd
# from itertools import permutations as permus
# from collections import deque,Counter
# import re
# from functools import lru_cache # 簡単メモ化 @lru_cache(maxsize=1000)
# from decimal import Decimal, getcontext
# # getcontext().prec = 1000
# # eps = Decimal(10) ** (-100)
# import numpy as np
# import networkx as nx
# from scipy.sparse.csgraph import shortest_path, dijkstra, floyd_warshall, bellman_ford, johnson
# from scipy.sparse import csr_matrix
# from scipy.special import comb
# slist = "abcdefghijklmnopqrstuvwxyz"
N = int(input())
S = input()
T = input()
ans = 2*N
for i in range(N,-1,-1):
ST = S[:i] + T
# print(ST,ST[:i],ST[i:])
if ST[:N]==S and ST[-N:]==T:
ans = min(len(ST),ans)
print(ans)
# print(*ans) # unpackして出力。間にスペースが入る
# for row in board:
# print(*row,sep="") #unpackして間にスペース入れずに出力する
# print("{:.10f}".format(ans))
# print("{:0=10d}".format(ans))
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
14,
2,
13,
13,
4,
13,
13,
4,
13,
28,
13,
4,
13,
4,
13,
13,
0,
13,
2,
13,
18,
13,
39,
13,
14,
2,
4,
18,
13,
13,
13,
4,
18,
13,
13,
13,
4,
13,
4,
13,
13,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13
] |
[
[
65,
2
],
[
59,
8
],
[
62,
12
],
[
60,
17
],
[
63,
18
],
[
66,
21
],
[
26,
25
],
[
66,
30
],
[
68,
32
],
[
60,
34
],
[
63,
36
],
[
69,
43
],
[
60,
45
],
[
69,
48
],
[
63,
50
],
[
69,
55
],
[
59,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
]
] |
[
"n = int(input())\ns = input()\nt = input()\n\nif s == t:\n print(n)\n exit()\n\nfor i in reversed(range(n)):\n tmp = s + t[i:]\n if tmp.startswith(s) and tmp.endswith(t):\n print(len(tmp))\n exit()",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"if s == t:\n print(n)\n exit()",
"s == t",
"s",
"t",
"print(n)",
"print",
"n",
"exit()",
"exit",
"for i in reversed(range(n)):\n tmp = s + t[i:]\n if tmp.startswith(s) and tmp.endswith(t):\n print(len(tmp))\n exit()",
"i",
"reversed(range(n))",
"reversed",
"range(n)",
"range",
"n",
"tmp = s + t[i:]",
"tmp",
"s + t[i:]",
"s",
"t[i:]",
"t",
"i:",
"i",
"if tmp.startswith(s) and tmp.endswith(t):\n print(len(tmp))\n exit()",
"tmp.startswith(s) and tmp.endswith(t)",
"tmp.startswith(s)",
"tmp.startswith",
"tmp",
"startswith",
"s",
"tmp.endswith(t)",
"tmp.endswith",
"tmp",
"endswith",
"t",
"print(len(tmp))",
"print",
"len(tmp)",
"len",
"tmp",
"exit()",
"exit",
"s = input()",
"input()",
"s",
"t = input()",
"input()",
"t",
"n = int(input())",
"int(input())",
"n",
"tmp = s + t[i:]",
"s + t[i:]",
"tmp"
] |
n = int(input())
s = input()
t = input()
if s == t:
print(n)
exit()
for i in reversed(range(n)):
tmp = s + t[i:]
if tmp.startswith(s) and tmp.endswith(t):
print(len(tmp))
exit()
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
28,
13,
4,
13,
13,
14,
2,
18,
13,
39,
13,
18,
13,
39,
2,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
39,
2
],
[
33,
8
],
[
36,
12
],
[
17,
16
],
[
40,
19
],
[
34,
23
],
[
37,
27
],
[
40,
30
],
[
16,
31
],
[
33,
34
],
[
36,
37
],
[
39,
40
]
] |
[
"n=int(input())\nf=input()\nb=input()\nfor x in range(n):\n if f[x:]==b[:n-x]:print(n+x);break\nelse:print(n*2)",
"n=int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"f=input()",
"f",
"input()",
"input",
"b=input()",
"b",
"input()",
"input",
"for x in range(n):\n if f[x:]==b[:n-x]:print(n+x);break\nelse:print(n*2)",
"x",
"range(n)",
"range",
"n",
"if f[x:]==b[:n-x]:print(n+x);b",
"f[x:]==b[:n-x]",
"f[x:]",
"f",
"x:",
"x",
"b[:n-x]",
"b",
":n-x",
"n-x",
"n",
"x",
"f=input()",
"input()",
"f",
"b=input()",
"input()",
"b",
"n=int(input())",
"int(input())",
"n"
] |
n=int(input())
f=input()
b=input()
for x in range(n):
if f[x:]==b[:n-x]:print(n+x);break
else:print(n*2)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
2,
17,
13,
28,
13,
4,
13,
17,
2,
13,
17,
14,
2,
18,
13,
39,
40,
13,
18,
13,
39,
13,
0,
13,
2,
2,
17,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13
] |
[
[
53,
2
],
[
50,
8
],
[
59,
12
],
[
56,
16
],
[
54,
19
],
[
22,
21
],
[
54,
26
],
[
51,
31
],
[
21,
34
],
[
60,
36
],
[
62,
40
],
[
54,
44
],
[
21,
45
],
[
63,
48
],
[
57,
48
],
[
50,
51
],
[
53,
54
],
[
56,
57
],
[
59,
60
],
[
62,
63
]
] |
[
"N = int(input())\ns = input()\nt = input()\n\nanswer = 2*N\n\nfor x in range(1,N+1):\n if s[-x:] == t[:x]:\n answer = 2*N - x\n \nprint(answer)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"answer = 2*N",
"answer",
"2*N",
"2",
"N",
"for x in range(1,N+1):\n if s[-x:] == t[:x]:\n answer = 2*N - x\n ",
"x",
"range(1,N+1)",
"range",
"1",
"N+1",
"N",
"1",
"if s[-x:] == t[:x]:\n answer = 2*N - x\n ",
"s[-x:] == t[:x]",
"s[-x:]",
"s",
"-x:",
"-x",
"x",
"t[:x]",
"t",
":x",
"x",
"answer = 2*N - x",
"answer",
"2*N - x",
"2*N",
"2",
"N",
"x",
"print(answer)",
"print",
"answer",
"s = input()",
"input()",
"s",
"N = int(input())",
"int(input())",
"N",
"answer = 2*N",
"2*N",
"answer",
"t = input()",
"input()",
"t",
"answer = 2*N - x",
"2*N - x",
"answer"
] |
N = int(input())
s = input()
t = input()
answer = 2*N
for x in range(1,N+1):
if s[-x:] == t[:x]:
answer = 2*N - x
print(answer)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
13,
17,
17,
14,
2,
18,
13,
39,
40,
13,
18,
13,
39,
13,
0,
13,
13,
3,
4,
13,
2,
2,
17,
13,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13
] |
[
[
64,
2
],
[
55,
8
],
[
61,
14
],
[
52,
20
],
[
24,
23
],
[
65,
26
],
[
56,
32
],
[
23,
35
],
[
62,
37
],
[
58,
41
],
[
23,
42
],
[
65,
49
],
[
59,
50
],
[
53,
50
],
[
52,
53
],
[
55,
56
],
[
23,
58
],
[
58,
59
],
[
61,
62
],
[
64,
65
]
] |
[
"n = int(input())\ns = list(input())\nt = list(input())\ncount = 0\nfor i in range(n, 0, -1):\n if s[-i:] == t[:i]:\n count = i\n break\nprint(2 * n - count)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = list(input())",
"s",
"list(input())",
"list",
"input()",
"input",
"t = list(input())",
"t",
"list(input())",
"list",
"input()",
"input",
"count = 0",
"count",
"0",
"for i in range(n, 0, -1):\n if s[-i:] == t[:i]:\n count = i\n break",
"i",
"range(n, 0, -1)",
"range",
"n",
"0",
"-1",
"if s[-i:] == t[:i]:\n count = i\n break",
"s[-i:] == t[:i]",
"s[-i:]",
"s",
"-i:",
"-i",
"i",
"t[:i]",
"t",
":i",
"i",
"count = i",
"count",
"i",
"break",
"print(2 * n - count)",
"print",
"2 * n - count",
"2 * n",
"2",
"n",
"count",
"count = 0",
"0",
"count",
"s = list(input())",
"list(input())",
"s",
"count = i",
"i",
"count",
"t = list(input())",
"list(input())",
"t",
"n = int(input())",
"int(input())",
"n"
] |
n = int(input())
s = list(input())
t = list(input())
count = 0
for i in range(n, 0, -1):
if s[-i:] == t[:i]:
count = i
break
print(2 * n - count)
|
[
7,
12,
13,
28,
13,
4,
13,
2,
13,
17,
14,
2,
18,
13,
39,
13,
18,
13,
39,
2,
13,
13,
29,
2,
4,
13,
18,
13,
39,
13,
13,
29,
2,
17,
13,
23,
13,
23,
13,
23,
13,
12,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
4,
13,
4,
13,
13,
13,
13,
29,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
12,
13
] |
[
[
5,
4
],
[
36,
8
],
[
38,
13
],
[
40,
17
],
[
36,
20
],
[
4,
21
],
[
38,
27
],
[
36,
30
],
[
36,
34
],
[
36,
36
],
[
38,
38
],
[
40,
40
],
[
45,
44
],
[
51,
50
],
[
55,
54
],
[
73,
60
],
[
44,
61
],
[
50,
62
],
[
54,
63
],
[
76,
70
]
] |
[
"#!/usr/bin/env python3\n\ndef solve(n,s,t):\n for i in range(n+1):\n if s[i:] == t[:n-i]:\n return len(s[:i]) + n\n return 2*n\n\n\ndef main():\n N = int(input())\n s = input()\n t = input()\n print(solve(N,s,t))\n return\n\nif __name__ == '__main__':\n main()",
"def solve(n,s,t):\n for i in range(n+1):\n if s[i:] == t[:n-i]:\n return len(s[:i]) + n\n return 2*n",
"solve",
"for i in range(n+1):\n if s[i:] == t[:n-i]:\n return len(s[:i]) + n\n ",
"i",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"if s[i:] == t[:n-i]:\n return len(s[:i]) + n\n ",
"s[i:] == t[:n-i]",
"s[i:]",
"s",
"i:",
"i",
"t[:n-i]",
"t",
":n-i",
"n-i",
"n",
"i",
"return len(s[:i]) + n",
"len(s[:i]) + n",
"len(s[:i])",
"len",
"s[:i]",
"s",
":i",
"i",
"n",
"return 2*n",
"2*n",
"2",
"n",
"n",
"n",
"s",
"s",
"t",
"t",
"def main():\n N = int(input())\n s = input()\n t = input()\n print(solve(N,s,t))\n return",
"main",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"print(solve(N,s,t))",
"print",
"solve(N,s,t)",
"solve",
"N",
"s",
"t",
"return",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def solve(n,s,t):\n for i in range(n+1):\n if s[i:] == t[:n-i]:\n return len(s[:i]) + n\n return 2*n",
"def solve(n,s,t):\n for i in range(n+1):\n if s[i:] == t[:n-i]:\n return len(s[:i]) + n\n return 2*n",
"solve",
"def main():\n N = int(input())\n s = input()\n t = input()\n print(solve(N,s,t))\n return",
"def main():\n N = int(input())\n s = input()\n t = input()\n print(solve(N,s,t))\n return",
"main"
] |
#!/usr/bin/env python3
def solve(n,s,t):
for i in range(n+1):
if s[i:] == t[:n-i]:
return len(s[:i]) + n
return 2*n
def main():
N = int(input())
s = input()
t = input()
print(solve(N,s,t))
return
if __name__ == '__main__':
main()
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
14,
2,
13,
13,
4,
13,
13,
4,
13,
28,
13,
4,
13,
17,
2,
13,
17,
14,
2,
13,
2,
13,
18,
13,
39,
40,
13,
4,
13,
2,
13,
13,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
53,
2
],
[
50,
8
],
[
56,
12
],
[
57,
17
],
[
51,
18
],
[
54,
21
],
[
26,
25
],
[
54,
30
],
[
57,
34
],
[
51,
36
],
[
57,
38
],
[
25,
41
],
[
54,
45
],
[
25,
46
],
[
50,
51
],
[
53,
54
],
[
56,
57
]
] |
[
"N = int(input())\ns = input()\nt = input()\n\nif t in s:\n print(N)\n quit()\n\nfor i in range(1, N+1):\n if t in (s + t[-i:]):\n print(N+i)\n quit()",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"if t in s:\n print(N)\n quit()",
"t in s",
"t",
"s",
"print(N)",
"print",
"N",
"quit()",
"quit",
"for i in range(1, N+1):\n if t in (s + t[-i:]):\n print(N+i)\n quit()",
"i",
"range(1, N+1)",
"range",
"1",
"N+1",
"N",
"1",
"if t in (s + t[-i:]):\n print(N+i)\n quit()",
"t in (s + t[-i:])",
"t",
"s + t[-i:]",
"s",
"t[-i:]",
"t",
"-i:",
"-i",
"i",
"print(N+i)",
"print",
"N+i",
"N",
"i",
"quit()",
"quit",
"s = input()",
"input()",
"s",
"N = int(input())",
"int(input())",
"N",
"t = input()",
"input()",
"t"
] |
N = int(input())
s = input()
t = input()
if t in s:
print(N)
quit()
for i in range(1, N+1):
if t in (s + t[-i:]):
print(N+i)
quit()
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
2,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
14,
40,
18,
13,
2,
2,
2,
13,
13,
13,
17,
18,
13,
13,
0,
13,
17,
14,
13,
0,
13,
2,
13,
17,
4,
13,
2,
2,
17,
13,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13
] |
[
[
82,
2
],
[
70,
8
],
[
85,
12
],
[
79,
16
],
[
71,
18
],
[
86,
19
],
[
73,
21
],
[
25,
24
],
[
83,
27
],
[
91,
29
],
[
33,
32
],
[
24,
36
],
[
71,
41
],
[
83,
45
],
[
24,
46
],
[
32,
47
],
[
86,
50
],
[
32,
51
],
[
88,
53
],
[
76,
58
],
[
24,
60
],
[
83,
67
],
[
77,
68
],
[
74,
68
],
[
70,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
]
] |
[
"n = int(input())\ns = input()\nt = input()\n# print(s + t)\nst = s + t\nsame = 0\nfor i in range(n):\n ok = True\n for j in range(i+1):\n if s[n-i+j-1] != t[j]:\n ok = False\n # print(i, j, ok)\n if ok:\n same = i+1\n# print(same)\nprint(2*n - same)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"st = s + t",
"st",
"s + t",
"s",
"t",
"same = 0",
"same",
"0",
"for i in range(n):\n ok = True\n for j in range(i+1):\n if s[n-i+j-1] != t[j]:\n ok = False\n # print(i, j, ok)\n if ok:\n same = i+1\n# print(same)",
"i",
"range(n)",
"range",
"n",
"ok = True",
"ok",
"True",
"for j in range(i+1):\n if s[n-i+j-1] != t[j]:\n ok = False\n # print(i, j, ok)\n ",
"j",
"range(i+1)",
"range",
"i+1",
"i",
"1",
"if s[n-i+j-1] != t[j]:\n ok = False\n # print(i, j, ok)\n ",
"s[n-i+j-1] != t[j]",
"s[n-i+j-1]",
"s",
"n-i+j-1",
"n-i+j",
"n-i",
"n",
"i",
"j",
"1",
"t[j]",
"t",
"j",
"ok = False",
"ok",
"False",
"if ok:\n same = i+1\n# print(same)",
"ok",
"same = i+1",
"same",
"i+1",
"i",
"1",
"print(2*n - same)",
"print",
"2*n - same",
"2*n",
"2",
"n",
"same",
"s = input()",
"input()",
"s",
"same = 0",
"0",
"same",
"same = i+1",
"i+1",
"same",
"st = s + t",
"s + t",
"st",
"n = int(input())",
"int(input())",
"n",
"t = input()",
"input()",
"t",
"ok = False",
"False",
"ok",
"ok = True",
"True",
"ok"
] |
n = int(input())
s = input()
t = input()
# print(s + t)
st = s + t
same = 0
for i in range(n):
ok = True
for j in range(i+1):
if s[n-i+j-1] != t[j]:
ok = False
# print(i, j, ok)
if ok:
same = i+1
# print(same)
print(2*n - same)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
13,
28,
13,
4,
13,
13,
14,
2,
18,
13,
39,
13,
18,
13,
39,
2,
13,
13,
4,
13,
13,
4,
13,
0,
13,
17,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
4,
13
] |
[
[
50,
2
],
[
47,
8
],
[
59,
12
],
[
53,
16
],
[
51,
17
],
[
20,
19
],
[
51,
22
],
[
48,
26
],
[
60,
30
],
[
51,
33
],
[
19,
34
],
[
54,
37
],
[
57,
37
],
[
56,
41
],
[
57,
45
],
[
54,
45
],
[
47,
48
],
[
50,
51
],
[
51,
53
],
[
53,
54
],
[
56,
57
],
[
59,
60
]
] |
[
"N = int(input())\ns = input()\nt = input()\n\nans = N\nfor i in range(N):\n if s[i:] == t[:N-i]:\n print(ans)\n exit()\n else:\n ans += 1\n \nprint(ans)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"ans = N",
"ans",
"N",
"for i in range(N):\n if s[i:] == t[:N-i]:\n print(ans)\n exit()\n else:\n ans += 1\n ",
"i",
"range(N)",
"range",
"N",
"if s[i:] == t[:N-i]:\n print(ans)\n exit()\n else:\n ans += 1\n ",
"s[i:] == t[:N-i]",
"s[i:]",
"s",
"i:",
"i",
"t[:N-i]",
"t",
":N-i",
"N-i",
"N",
"i",
"print(ans)",
"print",
"ans",
"exit()",
"exit",
"ans += 1",
"ans",
"1",
"print(ans)",
"print",
"ans",
"s = input()",
"input()",
"s",
"N = int(input())",
"int(input())",
"N",
"ans = N",
"N",
"ans",
"ans += 1",
"1",
"ans",
"t = input()",
"input()",
"t"
] |
N = int(input())
s = input()
t = input()
ans = N
for i in range(N):
if s[i:] == t[:N-i]:
print(ans)
exit()
else:
ans += 1
print(ans)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
0,
13,
2,
13,
13,
28,
13,
4,
13,
13,
14,
2,
18,
13,
39,
13,
18,
13,
39,
2,
13,
13,
0,
13,
2,
13,
18,
13,
39,
2,
13,
13,
3,
4,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13
] |
[
[
67,
2
],
[
61,
8
],
[
70,
14
],
[
58,
20
],
[
62,
22
],
[
71,
23
],
[
26,
25
],
[
68,
28
],
[
62,
32
],
[
71,
36
],
[
68,
39
],
[
25,
40
],
[
64,
42
],
[
62,
44
],
[
71,
46
],
[
68,
49
],
[
25,
50
],
[
65,
56
],
[
59,
56
],
[
58,
59
],
[
61,
62
],
[
64,
65
],
[
67,
68
],
[
70,
71
]
] |
[
"n = int(input())\ns = str(input())\nt = str(input())\nz = s + t\nfor i in range(n):\n if s[i:] == t[:n-i]:\n z = s + t[n-i:]\n break\nprint(len(z))",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s = str(input())",
"s",
"str(input())",
"str",
"input()",
"input",
"t = str(input())",
"t",
"str(input())",
"str",
"input()",
"input",
"z = s + t",
"z",
"s + t",
"s",
"t",
"for i in range(n):\n if s[i:] == t[:n-i]:\n z = s + t[n-i:]\n break",
"i",
"range(n)",
"range",
"n",
"if s[i:] == t[:n-i]:\n z = s + t[n-i:]\n break",
"s[i:] == t[:n-i]",
"s[i:]",
"s",
"i:",
"i",
"t[:n-i]",
"t",
":n-i",
"n-i",
"n",
"i",
"z = s + t[n-i:]",
"z",
"s + t[n-i:]",
"s",
"t[n-i:]",
"t",
"n-i:",
"n-i",
"n",
"i",
"break",
"print(len(z))",
"print",
"len(z)",
"len",
"z",
"z = s + t",
"s + t",
"z",
"s = str(input())",
"str(input())",
"s",
"z = s + t[n-i:]",
"s + t[n-i:]",
"z",
"n = int(input())",
"int(input())",
"n",
"t = str(input())",
"str(input())",
"t"
] |
n = int(input())
s = str(input())
t = str(input())
z = s + t
for i in range(n):
if s[i:] == t[:n-i]:
z = s + t[n-i:]
break
print(len(z))
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
14,
4,
18,
13,
13,
18,
13,
39,
2,
13,
17,
0,
13,
2,
2,
13,
13,
17,
3,
4,
13,
2,
2,
17,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13
] |
[
[
53,
2
],
[
59,
8
],
[
56,
12
],
[
62,
16
],
[
20,
19
],
[
54,
24
],
[
57,
29
],
[
60,
32
],
[
19,
35
],
[
65,
38
],
[
54,
41
],
[
19,
42
],
[
54,
50
],
[
66,
51
],
[
63,
51
],
[
53,
54
],
[
56,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
]
] |
[
"N = int(input())\ns = input()\nt = input()\nd = 0\nfor i in range(1,N+1):\n if t.startswith(s[i-1:]):\n d = N - i + 1\n break\nprint(2*N - d)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"s = input()",
"s",
"input()",
"input",
"t = input()",
"t",
"input()",
"input",
"d = 0",
"d",
"0",
"for i in range(1,N+1):\n if t.startswith(s[i-1:]):\n d = N - i + 1\n break",
"i",
"range(1,N+1)",
"range",
"1",
"N+1",
"N",
"1",
"if t.startswith(s[i-1:]):\n d = N - i + 1\n break",
"t.startswith(s[i-1:])",
"t.startswith",
"t",
"startswith",
"s[i-1:]",
"s",
"i-1:",
"i-1",
"i",
"1",
"d = N - i + 1",
"d",
"N - i + 1",
"N - i",
"N",
"i",
"1",
"break",
"print(2*N - d)",
"print",
"2*N - d",
"2*N",
"2",
"N",
"d",
"N = int(input())",
"int(input())",
"N",
"t = input()",
"input()",
"t",
"s = input()",
"input()",
"s",
"d = 0",
"0",
"d",
"d = N - i + 1",
"N - i + 1",
"d"
] |
N = int(input())
s = input()
t = input()
d = 0
for i in range(1,N+1):
if t.startswith(s[i-1:]):
d = N - i + 1
break
print(2*N - d)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
0,
13,
4,
13,
28,
13,
4,
13,
2,
13,
17,
14,
2,
18,
13,
39,
13,
18,
13,
39,
2,
13,
13,
4,
13,
2,
13,
13,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] |
[
[
48,
2
],
[
42,
8
],
[
45,
12
],
[
17,
16
],
[
49,
20
],
[
43,
25
],
[
46,
29
],
[
49,
32
],
[
16,
33
],
[
49,
37
],
[
16,
38
],
[
42,
43
],
[
45,
46
],
[
48,
49
]
] |
[
"n=int(input())\ns=input()\nt=input()\n\nfor i in range(n+1):\n #print(s[i:],t[:n-i])\n if s[i:] == t[:n-i]:\n print(n+i)\n exit()",
"n=int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"s=input()",
"s",
"input()",
"input",
"t=input()",
"t",
"input()",
"input",
"for i in range(n+1):\n #print(s[i:],t[:n-i])\n if s[i:] == t[:n-i]:\n print(n+i)\n exit()",
"i",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"if s[i:] == t[:n-i]:\n print(n+i)\n exit()",
"s[i:] == t[:n-i]",
"s[i:]",
"s",
"i:",
"i",
"t[:n-i]",
"t",
":n-i",
"n-i",
"n",
"i",
"print(n+i)",
"print",
"n+i",
"n",
"i",
"exit()",
"exit",
"s=input()",
"input()",
"s",
"t=input()",
"input()",
"t",
"n=int(input())",
"int(input())",
"n"
] |
n=int(input())
s=input()
t=input()
for i in range(n+1):
#print(s[i:],t[:n-i])
if s[i:] == t[:n-i]:
print(n+i)
exit()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.