Polycarp is mad about coding, that is why he writes Sveta encoded messages. He calls the median letter in a word the letter which is in the middle of the word. If the word's length is even, the median letter is the left of the two middle letters. In the following examples, the median letter is highlighted: contest, info. If the word consists of single letter, then according to above definition this letter is the median letter. 

Polycarp encodes each word in the following way: he writes down the median letter of the word, then deletes it and repeats the process until there are no letters left. For example, he encodes the word volga as logva.

You are given an encoding s of some word, your task is to decode it. 


-----Input-----

The first line contains a positive integer n (1 ≤ n ≤ 2000) — the length of the encoded word.

The second line contains the string s of length n consisting of lowercase English letters — the encoding.


-----Output-----

Print the word that Polycarp encoded.


-----Examples-----
Input
5
logva

Output
volga

Input
2
no

Output
no

Input
4
abba

Output
baba



-----Note-----

In the first example Polycarp encoded the word volga. At first, he wrote down the letter l from the position 3, after that his word looked like voga. After that Polycarp wrote down the letter o from the position 2, his word became vga. Then Polycarp wrote down the letter g which was at the second position, the word became va. Then he wrote down the letter v, then the letter a. Thus, the encoding looked like logva.

In the second example Polycarp encoded the word no. He wrote down the letter n, the word became o, and he wrote down the letter o. Thus, in this example, the word and its encoding are the same.

In the third example Polycarp encoded the word baba. At first, he wrote down the letter a, which was at the position 2, after that the word looked like bba. Then he wrote down the letter b, which was at the position 2, his word looked like ba. After that he wrote down the letter b, which was at the position 1, the word looked like a, and he wrote down that letter a. Thus, the encoding is abba.

Difficulty: EASY
Tags: String algorithms

Implementation

Starter code:

Solutions:
def decode(s):
	res = '' + s[0]
	string = []
	for letter in s:
		string.append(letter)
	string = string[1:]
	while len(string) != 0:
		if len(string) % 2 == 0:
			res = str(string[0]) + res
		else:
			res += str(string[0])
		string = string[1:]
	return res
n = input()
arg = input()
print(decode(arg))


n = int(input())
s = input()
s1 = ''
for i in range(len(s) - 1, -1, -1):
	s1 = s1[:len(s1) // 2] + s[i] + s1[len(s1) // 2:]
print(s1)


def main():
	n = int(input())
	sp = list(input())
	sp = sp[::-1]
	rez_sp = ''
	for el in sp:
		rez_sp = rez_sp[:len(rez_sp) // 2] + el + rez_sp[len(rez_sp) // 2:]
	print(rez_sp)
main()


n = int(input())
l = list(input())
l1 = [0] * n
(j, k) = (0, 0)
for i in range(len(l) - 2):
	if len(l) % 2 == 0:
		if i == 0:
			m = n // 2 - 1
			l1[m] = l[0]
		elif i % 2 != 0:
			j += 1
			l1[m + j] = l[i]
		else:
			k -= 1
			l1[m + k] = l[i]
	elif i == 0:
		m = n // 2
		l1[m] = l[0]
	elif i % 2 != 0:
		j += 1
		l1[m - j] = l[i]
	else:
		k += 1
		l1[m + k] = l[i]
l1[0] = l[n - 2]
l1[-1] = l[n - 1]
s = ''.join(l1)
print(s)


import math
import copy
n = int(input())
s = input()
S = [i for i in s]
s1 = copy.deepcopy(S)
if n % 2 == 0:
	x = n // 2
	s1[x - 1] = S[0]
else:
	x = math.ceil(n / 2)
	s1[x - 1] = S[0]
n -= 1
a = 1
b = 2
c = 0
while n > 0:
	if n % 2 == 0:
		s1[x - b] = S[a]
		a += 1
		b += 1
		n -= 1
	else:
		s1[x + c] = S[a]
		a += 1
		n -= 1
		c += 1
print(''.join(s1))


n = int(input())
s = input()
ans = ''
po = 0
for i in range(n):
	if i % 2 == 0:
		ans += s[i]
	else:
		ans = s[i] + ans
if n % 2 == 0:
	print(ans[::-1])
else:
	print(ans)


n = int(input())
s = input()
if n % 2 == 0:
	rule = 1
else:
	rule = 0
right = ''
left = ''
for x in range(n):
	if rule == 0:
		if x % 2 == 0:
			right += s[x]
		else:
			left = s[x] + left
	elif x % 2 == 0:
		left = s[x] + left
	else:
		right += s[x]
print(left + right)


from sys import stdin, stdout
return_word = ''
n = int(stdin.readline().rstrip())
return_word = stdin.readline().rstrip()
s = ''
while len(return_word) > 0:
	symb_index = int(len(s) / 2)
	s = s[:symb_index] + return_word[-1] + s[symb_index:]
	return_word = return_word[:-1]
stdout.write(s)


n = int(input())
A = [' ' for i in range(n)]
s = input()
(l, r) = (0, 0)
if n % 2 == 0:
	l = n // 2 - 1
	r = n // 2
	for i in range(n):
		if not i % 2:
			A[l] = s[i]
			l -= 1
		else:
			A[r] = s[i]
			r += 1
else:
	l = n // 2 - 1
	r = n // 2
	for i in range(n):
		if not i % 2:
			A[r] = s[i]
			r += 1
		else:
			A[l] = s[i]
			l -= 1
print(''.join(A))


def solve(n, s):
	left = True if n % 2 == 1 else False
	r = []
	for i in s:
		if left:
			r.insert(0, i)
		else:
			r.append(i)
		left = not left
	return ''.join(reversed(r))

def main():
	n = int(input())
	s = list(input())
	print(solve(n, s))
main()


n = input()
n = int(n.strip())
niz = input()
niz = niz.strip()
resitev = niz[-1]
for k in range(len(niz) - 2, -1, -1):
	dol = len(resitev)
	if dol % 2 == 0:
		resitev = resitev[:dol // 2] + niz[k] + resitev[dol // 2:]
	else:
		delim = (len(resitev) - 1) // 2
		resitev = resitev[:delim] + niz[k] + resitev[delim:]
print(resitev)


n = int(input())
s = list(input())
t = ['' for i in range(2001)]
p = 0
count = 0
while len(s) != 0:
	if len(s) % 2 != 0:
		t[n // 2 + p] = s[0]
		s.pop(0)
	else:
		t[n // 2 - p] = s[0]
		s.pop(0)
	count += 1
	if count % 2 != 0:
		p += 1
for i in range(len(t)):
	print(t[i], end='')


n = int(input())
string = input()
output = [0] * n
if n % 2 == 0:
	curr = n // 2 - 1
	output[n // 2 - 1] = string[0]
	for i in range(1, n):
		if i % 2 == 1:
			output[curr + i] = string[i]
			curr += i
		else:
			output[curr - i] = string[i]
			curr -= i
else:
	curr = n // 2
	output[n // 2] = string[0]
	for i in range(1, n):
		if i % 2 == 1:
			output[curr - i] = string[i]
			curr -= i
		else:
			output[curr + i] = string[i]
			curr += i
print(''.join(output))


import math
n = int(input())
s = input()
result = [None] * n
c = 0
median = math.ceil(n / 2) - 1
result[median] = s[0]
if n % 2 == 1:
	for i in range(1, median + 1):
		result[median - i] = s[i + c]
		result[median + i] = s[i + 1 + c]
		c += 1
else:
	for i in range(1, median + 1):
		result[median + i] = s[i + c]
		result[median - i] = s[i + 1 + c]
		c += 1
	result[n - 1] = s[n - 1]
for i in range(n):
	print(result[i], end='')


n = int(input())
s = input()
res = ''
index = 0
while n > 0:
	l = len(res)
	if l == 0:
		res = s[n - 1]
	else:
		res = res[:l // 2] + s[n - 1] + res[l // 2:]
	n -= 1
print(res)


n = int(input())
s = input()
if n % 2 == 1:
	bools = True
else:
	bools = False
ans = ''
for i in range(n):
	if bools:
		ans += s[i]
		bools = False
	else:
		ans = s[i] + ans
		bools = True
print(ans)


def io():
	n = int(input())
	s = input()
	s = s[::-1]
	return [n, s]

def solve():
	(n, s) = io()
	ans = ['0'] * n
	(j, k) = (1, 1)
	for i in range(len(s)):
		if i % 2 == 0:
			ans[-j] = s[i]
			j += 1
		else:
			ans[i - k] = s[i]
			k += 1
	print(''.join(ans))
solve()


import math
n = int(input())
message = input()
construct = ['\x00'] * n
median = n // 2 - 1
pos = median
rnd = 1
if n % 2:
	median += 1
	construct[median] = message[0]
	message = message[1:]
	rnd = 1
	for char in message:
		construct[pos] = char
		rnd += 1
		if rnd % 2 == 0:
			pos = median + math.ceil(rnd / 2)
		else:
			pos = median - math.ceil(rnd / 2)
else:
	for char in message:
		construct[pos] = char
		if rnd % 2:
			pos = median + math.ceil(rnd / 2)
		else:
			pos = median - math.ceil(rnd / 2)
		rnd += 1
print(''.join(construct))


def Main():
	n = int(input())
	A = []
	s = input()
	ss = ''
	if n % 2 == 1:
		for i in range(len(s)):
			if i % 2 == 0:
				ss = ss + s[i]
			else:
				ss = s[i] + ss
		print(ss)
	else:
		for i in range(len(s)):
			if i % 2 == 0:
				ss = s[i] + ss
			else:
				ss = ss + s[i]
		print(ss)
Main()


import os
import sys
from math import *
from collections import *
from bisect import *
from io import BytesIO, IOBase

def vsInput():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
ALPHA = 'abcdefghijklmnopqrstuvwxyz'
M = 10 ** 9 + 7
EPS = 1e-06

def Ceil(a, b):
	return a // b + int(a % b > 0)

def value():
	return tuple(map(int, input().split()))

def array():
	return [int(i) for i in input().split()]

def Int():
	return int(input())

def Str():
	return input()

def arrayS():
	return [i for i in input().split()]
n = Int()
s = input()
choose = 0
if n % 2:
	choose = 1
ans = []
for i in range(n):
	if choose:
		choose ^= 1
		ans.append(s[i])
	else:
		ans.insert(0, s[i])
		choose ^= 1
print(*ans, sep='')


import collections
n = int(input())
queue = collections.deque()
w = input()
if n % 2 == 0:
	i = 0
	while i < len(w):
		queue.appendleft(w[i])
		queue.append(w[i + 1])
		i = i + 2
else:
	queue.append(w[0])
	i = 1
	while i < len(w) - 1:
		queue.append(w[i + 1])
		queue.appendleft(w[i])
		i = i + 2
for k in queue:
	print(k, end='')
queue.clear()
print()


length = int(input())
word = input()
starter = word[length - 2]
finisher = word[length - 1]
left = ''
right = ''
length -= 2
if length == 0:
	print(starter + finisher)
elif length == -1:
	print(starter)
elif length == 2:
	left = word[0]
	right = word[1]
	print(starter + left + right + finisher)
elif length == 1:
	left += word[0]
	print(starter + left + finisher)
elif length % 2 == 0:
	for i in range(1, length, 2):
		right = right + word[i]
	for i in range(length - 2, -1, -2):
		left = left + word[i]
	print(starter + left + right + finisher)
else:
	for i in range(0, length, 2):
		right = right + word[i]
	for i in range(length - 2, 0, -2):
		left = left + word[i]
	print(starter + left + right + finisher)


n = int(input())
s = list(input())
ans = []
l = len(s)
if l % 2 == 0:
	for i in range(l):
		if i % 2 == 0:
			ans.insert(0, s[i])
		else:
			ans.append(s[i])
else:
	for i in range(l):
		if i % 2 == 0:
			ans.append(s[i])
		else:
			ans.insert(0, s[i])
print(''.join(ans))


n = input()
word = list(input())
if len(word) <= 2:
	print(''.join(word))
	exit()
decoded = list()
dlen = 0
izq = len(word) % 2 == 0
for c in word:
	if izq:
		decoded = [c] + decoded
	else:
		decoded.append(c)
	izq = not izq
print(''.join(decoded))


n = int(input())
s = input()
s1 = ''
for i in range(len(s)):
	if len(s) % 2 == 0:
		s1 = s1 + s[0]
	else:
		s1 = s[0] + s1
	s = s[1:]
s1 = s1[::-1]
print(s1)


n = int(input())
s = input()
sh = ''
ch = 0
for i in range(n):
	if ch == 0:
		sh = s[i] + sh
		ch = 1
	else:
		sh = sh + s[i]
		ch = 0

def reverse(string):
	string = string[::-1]
	return string
if n == 2:
	print(s)
elif n % 2 == 0:
	print(sh)
else:
	print(reverse(sh))


n = int(input())
a = input()
b = []
for i in range(n):
	if (n - i) % 2 == 0:
		b = b + [a[i]]
	else:
		b = [a[i]] + b
print(''.join(b[::-1]))


import sys
import math
import collections
import operator as op
from collections import deque
from math import gcd, inf, sqrt
from bisect import bisect_right, bisect_left
from functools import reduce
from sys import stdin, stdout, setrecursionlimit
setrecursionlimit(2 ** 20)

def factorial(n):
	if n == 0:
		return 1
	return n * factorial(n - 1)

def ncr(n, r):
	r = min(r, n - r)
	numer = reduce(op.mul, range(n, n - r, -1), 1)
	denom = reduce(op.mul, range(1, r + 1), 1)
	return numer // denom

def prime_factors(n):
	i = 2
	factors = []
	while i * i <= n:
		if n % i:
			i += 1
		else:
			n //= i
			factors.append(i)
	if n > 1:
		factors.append(n)
	return len(set(factors))

def isPowerOfTwo(x):
	return x and (not x & x - 1)

def factors(n):
	return list(set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0))))
MOD = 10 ** 9 + 7
T = 1
for _ in range(T):
	n = int(stdin.readline())
	s = str(stdin.readline().strip('\n'))
	ans = s[0]
	if n % 2 == 1:
		for i in range(1, n):
			if i % 2 == 1:
				ans = s[i] + ans
			else:
				ans = ans + s[i]
	else:
		for i in range(1, n):
			if i % 2 == 1:
				ans = ans + s[i]
			else:
				ans = s[i] + ans
	print(ans)


n = int(input())
s = input()
ss = []
if n % 2 == 0:
	a = -1
else:
	a = 1
for i in s:
	if a == 1:
		ss.append(i)
	else:
		ss.insert(0, i)
	a *= -1
print(''.join(ss))


n = int(input())
s = input()
wynik = ''
prawa = False
if n % 2 == 1:
	prawa = True
for i in s:
	if prawa:
		wynik += i
		prawa = False
	else:
		wynik = i + wynik
		prawa = True
print(wynik)


from sys import setrecursionlimit
WORD = str

def solve(*, word: WORD) -> WORD:

	def wrapper(*, remaining_word: WORD, encoded_word: WORD) -> WORD:
		if remaining_word == '':
			return encoded_word
		if len(remaining_word) & 1 == 1:
			return wrapper(remaining_word=remaining_word[1:], encoded_word=encoded_word + remaining_word[0])
		else:
			return wrapper(remaining_word=remaining_word[1:], encoded_word=remaining_word[0] + encoded_word)
	return wrapper(remaining_word=word, encoded_word='')
limit = int(input())
setrecursionlimit(limit + 99)
word = input()
result = solve(word=word)
print(result)


def f(n):
	c = ''
	d = ''
	for k in range(len(n)):
		if k % 2 == 0:
			c += n[k]
		else:
			d += n[k]
	c = c[::-1]
	return d + c
a = int(input())
b = input()
print(f(b[::-1]))


import math
n = int(input())
s = input()
ans_list = []
if n % 2 == 0:
	for i in range(n):
		if i % 2 != 0:
			ans_list.append(s[i])
		else:
			ans_list.insert(0, s[i])
else:
	for i in range(n):
		if i % 2 == 0:
			ans_list.append(s[i])
		else:
			ans_list.insert(0, s[i])
print(''.join(ans_list))


n = int(input())
s = input()
s1 = s[len(s) - 2:]
s = s[:len(s) - 2]
while len(s) > 0:
	s1 = s1[:len(s1) // 2] + s[-1] + s1[len(s1) // 2:]
	s = s[:len(s) - 1]
print(s1)


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


num = int(input())
new = input()

def big(x, n):
	raw = ['0' for i in range(n + 1)]
	count = 0
	for i in range(int(n / 2), 0, -1):
		raw[i] = x[count]
		raw[n + 1 - i] = x[count + 1]
		count += 2
	return ''.join(raw[1:])
if num % 2 == 0:
	print(big(new, num))
else:
	print(big(new[1:], num - 1)[0:int(num / 2)] + new[0] + big(new[1:], num - 1)[int(num / 2):])


def getPlainText(length, ciphertext):
	plainText = []
	plainText.insert(0, ciphertext[0])
	for i in range(1, length):
		if i % 2 == 0:
			plainText.append(ciphertext[i])
		else:
			plainText.insert(0, ciphertext[i])
	string = ''
	for char in plainText:
		string += char
	return string[::-1] if len(string) % 2 == 0 else string
cipher_length = int(input())
cipherText = input()
plainText = getPlainText(cipher_length, cipherText)
print(f'{plainText}')


n = int(input())
a = list(input())
b = ''
for i in range(n):
	if n % 2 == 0:
		if i % 2 == 0:
			b = a[i] + b
		else:
			b = b + a[i]
	elif i % 2 == 0:
		b = b + a[i]
	else:
		b = a[i] + b
print(b)


n = int(input())
s = input()
ans = ''
for i in range(n):
	ans = ans[:i // 2] + s[-1] + ans[i // 2:]
	s = s[:-1]
print(ans)


n = int(input())
s = list(input())
t = []
if len(s) % 2 == 1:
	for i in range(n):
		if i % 2 == 0:
			t.append(s[i])
		else:
			t.insert(0, s[i])
else:
	for i in range(n):
		if i % 2 == 1:
			t.append(s[i])
		else:
			t.insert(0, s[i])
for i in t:
	print(i, end='')


n = int(input())
a = input()
half1 = ''
half2 = ''
for i in range(n - 1, 0, -2):
	half2 = a[i] + half2
	half1 += a[i - 1]
if n % 2 == 1:
	print(half1 + a[0] + half2)
else:
	print(half1 + half2)


m = input('')
s = input('')
t = list(s)
t1 = []
l = len(t)
if l % 2 != 0:
	for i in range(l):
		if i % 2 == 0 or i == 0:
			t1.append(t[i])
		else:
			t1.insert(0, t[i])
else:
	for i in range(l):
		if i % 2 != 0:
			t1.append(t[i])
		else:
			t1.insert(0, t[i])
s1 = ''.join(t1)
print(s1)


from sys import stdin, stdout
from itertools import permutations

def read_int_from_line():
	return list(map(int, input().split()))

def solve():
	n = int(input())
	s = list(input())
	ans = ''
	start = 0
	if n % 2 == 1:
		start = 1
		n -= 1
		ans = ans + s[0]
	for i in range(n // 2):
		ans = s[start + 2 * i] + ans
		ans = ans + s[start + 2 * i + 1]
	print(ans)

def main():
	solve()
main()


from sys import stdin, stdout

def main():
	a = int(stdin.readline())
	b = stdin.readline()
	loop = True == a % 2
	ans = ''
	for i in b:
		if loop:
			ans = i + ans
		else:
			ans += i
		loop = not loop
	ans = ans[::-1]
	stdout.write(str(ans))
main()


from collections import deque
n = int(input())
s = input()
t = deque()
if n % 2 == 0:
	t.append(s[0])
	for i in range(1, len(s)):
		if i % 2 == 1:
			t.append(s[i])
		else:
			t.appendleft(s[i])
	print(''.join(t))
else:
	t.append(s[0])
	for i in range(1, len(s)):
		if i % 2 == 1:
			t.appendleft(s[i])
		else:
			t.append(s[i])
	print(''.join(t))


n = int(input())
s = input()
res = ''
for i in s:
	if n % 2 == 0:
		res = i + res
	else:
		res += i
	n -= 1
print(res)


n2 = int(input())
li = list()
l2 = list()
i = 0
while i < n2:
	li.append(i)
	l2.append('0')
	i = i + 1
i = 0
l = list(input())
while i < n2:
	mid = len(li) // 2
	if len(li) % 2 == 0:
		mid = mid - 1
	l2[li.pop(mid)] = l[i]
	mid = 0
	i = i + 1
print(''.join(l2))


(n, lst, new_list) = (int(input()), list(input()), [])
for i in range(n):
	if i % 2 == 0:
		if n % 2 != 0:
			new_list.append(lst[i])
		else:
			new_list.insert(0, lst[i])
	elif n % 2 != 0:
		new_list.insert(0, lst[i])
	else:
		new_list.append(lst[i])
print(''.join(new_list))


n = int(input())
nmod = n % 2
word = input()
result = []
for (i, c) in enumerate(word):
	if i % 2 != nmod:
		result = result + [c]
	else:
		result = [c] + result
print(''.join(result))


n = int(input())
s = input()
result = [0] * n
ind = (n - 1) // 2
t = 1 if n % 2 == 0 else -1
gap = 1
for c in s:
	result[ind] = c
	ind += gap * t
	t *= -1
	gap += 1
print(''.join(result))


def solution(n, s):
	ans = [' '] * n
	if n % 2 == 0:
		p = int(n / 2) - 1
		for i in range(n):
			if i % 2 == 0:
				ans[p - int(i / 2)] = s[i]
			else:
				ans[p + int((i + 1) / 2)] = s[i]
	else:
		p = int(n / 2)
		for i in range(n):
			if i % 2 == 0:
				ans[p + int(i / 2)] = s[i]
			else:
				ans[p - int((i + 1) / 2)] = s[i]
	return ''.join(ans)
n = int(input())
s = input()
print(solution(n, s))


n = int(input())
s = input()
if n == 1:
	print(s)
else:
	if n % 2 == 0:
		l = n // 2 - 1
		r = n // 2
		ans = ['a'] * n
		for i in range(0, n, 2):
			ans[l] = s[i]
			l = l - 1
		for i in range(1, n, 2):
			ans[r] = s[i]
			r += 1
	else:
		ans = ['a'] * n
		c = n // 2
		l = c - 1
		r = c + 1
		ans[c] = s[0]
		for i in range(1, n, 2):
			ans[l] = s[i]
			l -= 1
		for i in range(2, n, 2):
			ans[r] = s[i]
			r += 1
	s = ''.join(map(str, ans))
	print(s)


def main():
	n = int(input())
	s = [ch for ch in input()]
	s = s[::-1]
	decode = ['' for i in s]
	front = 0
	back = len(s) - 1
	alt = -1
	for l in s:
		if alt == -1:
			decode[back] = l
			back -= 1
		else:
			decode[front] = l
			front += 1
		alt *= -1
	print(''.join(decode))
main()


from collections import deque
n = int(input())
s = input()
res = deque([])
if len(s) % 2 != 0:
	res.append(s[0])
	l = 1
	r = 0
	for i in range(1, n):
		if l == 1:
			res.appendleft(s[i])
			l = 0
			r = 1
		else:
			res.append(s[i])
			l = 1
			r = 0
else:
	res.append(s[0])
	l = 0
	r = 1
	for i in range(1, n):
		if l == 1:
			res.appendleft(s[i])
			l = 0
			r = 1
		else:
			res.append(s[i])
			l = 1
			r = 0
print(''.join(res))


n = int(input())
s = input()
ans = ''
if n % 2:
	for i in range(n):
		if i % 2:
			ans = s[i] + ans
		else:
			ans += s[i]
else:
	for i in range(n):
		if i % 2:
			ans += s[i]
		else:
			ans = s[i] + ans
print(ans)


length = int(input())
string = input()
result = [0] * len(string)

def even(string):
	res = [0] * len(string)
	middle = len(string) // 2 - 1
	left = middle - 1
	right = middle + 1
	res[middle] = string[0]
	to_right = True
	for c in string[1:]:
		if to_right:
			res[right] = c
			right += 1
			to_right = False
		else:
			res[left] = c
			left -= 1
			to_right = True
	return res

def not_even(string):
	res = [0] * len(string)
	middle = len(string) // 2
	left = middle - 1
	right = middle + 1
	res[middle] = string[0]
	to_left = True
	for c in string[1:]:
		if to_left:
			res[left] = c
			left -= 1
			to_left = False
		else:
			res[right] = c
			right += 1
			to_left = True
	return res
if length == 1:
	print(string)
elif length % 2 == 0:
	print(''.join(even(string)))
else:
	print(''.join(not_even(string)))


n = int(input())
s = input()
res = 'a'
i = n - 2
while i >= 0:
	res += s[i]
	i -= 2
i = 1
if n & 1:
	i = 0
while i < n:
	res += s[i]
	i += 2
print(res[1:])


l = int(input())
s = input()
ans = ''
if l % 2 == 0:
	mid_el = s[0] + s[1]
	for i in range(l - 2, 1, -2):
		ans += s[i]
	ans += mid_el
	for j in range(3, l, 2):
		ans += s[j]
else:
	mid_el = s[0]
	for i in range(l - 2, 0, -2):
		ans += s[i]
	ans += mid_el
	for j in range(2, l, 2):
		ans += s[j]
print(ans)


n = int(input())
string = input()
t = ''
for i in range(n - 2, -1, -2):
	t += string[i]
for i in range(1 if n % 2 == 0 else 0, n, 2):
	t += string[i]
print(t)


n = int(input())
s = input()
ans = ''
for i in range(n // 2):
	ans = ans[:len(ans) // 2] + s[-2:] + ans[len(ans) // 2:]
	s = s[:-2]
ans = ans[:len(ans) // 2] + s + ans[len(ans) // 2:]
print(ans)


n = int(input())
string = input()
if len(string) == 1 or len(string) == 2:
	print(string)
else:
	arrayLeft = []
	arrright = []
	s = ''
	for i in range(n):
		if i % 2 == 0:
			arrright.append(string[i])
		else:
			arrayLeft.append(string[i])
	if n % 2 == 1:
		arrayLeft = arrayLeft[::-1]
		s = ''.join(arrayLeft) + ''.join(arrright)
	else:
		arrright = arrright[::-1]
		s = ''.join(arrright) + ''.join(arrayLeft)
	print(s)


import sys, math, string, fractions, functools, collections, copy
sys.setrecursionlimit(10 ** 7)
RI = lambda x=' ': list(map(int, input().rstrip().split(x)))
RS = lambda x=' ': input().rstrip().split(x)
dX = [-1, 1, 0, 0, -1, 1, -1, 1]
dY = [0, 0, -1, 1, 1, -1, -1, 1]
mod = int(1000000000.0 + 7)
eps = 1e-14
MAX = 1010
n = int(input())
s = input()
s = s[::-1]
ans = s[1::2] + s[::2][::-1]
print(ans)


from sys import stdin
a = int(stdin.readline())
b = stdin.readline().strip()
new_word = ['*' for y in range(a)]
word = ''
if a <= 2:
	new_word = b
else:
	for x in range(a):
		new_word[x] = b[int(len(b)) - 2]
		new_word[-x - 1] = b[int(len(b)) - 1]
		b = b[:int(len(b)) - 2]
		if len(b) == 0:
			break
word = ''.join((str(w) for w in new_word))
print(word)


n = int(input())
s = input()
if len(s) % 2 == 0:
	a = s[::2][::-1]
	b = s[1::2]
	print(a + b)
else:
	a = 'a' * n
	l = 1
	r = 0
	for i in range(len(s)):
		if i % 2 == 0:
			a = a[:int(n / 2) + r] + s[i] + a[int(n / 2) + r + 1:]
			r += 1
		else:
			a = a[:int(n / 2) - l] + s[i] + a[int(n / 2) - l + 1:]
			l += 1
	print(a)


n = int(input())
s = input()
x = ''
s1 = s[::-1]
if n % 2 != 0:
	i = 1
	while i < len(s1):
		x += s1[i]
		i += 2
	i = 0
	while i < len(s):
		x += s[i]
		i += 2
else:
	i = 1
	while i < len(s1):
		x += s1[i]
		i += 2
	i = 1
	while i < len(s):
		x += s[i]
		i += 2
print(x)


def prog():
	n = int(input())
	y = input()
	rez = {i: '' for i in range(n)}
	for (i, x) in enumerate(y):
		if n % 2 == 0:
			k = n // 2 - 1
		else:
			k = n // 2
		z = 0
		k += 1
		for (j, e) in enumerate(rez):
			if rez[e] == '':
				z += 1
				if k == z:
					rez[j] = x
					break
		n -= 1
	for (i, x) in enumerate(rez):
		print(rez[x], end='')
prog()


import copy

def solve(n):
	lst = []
	length = n - 1
	r = 0
	l = 0
	if n % 2 == 0:
		j = 0
		m = length // 2
		while m != n - 1:
			lst.append(m)
			l -= 1
			r += 1
			if j == l + 1:
				j = r
			elif j == r - 1:
				j = l
			m += j
		lst.append(n - 1)
	else:
		j = 0
		m = length // 2
		while m != n - 1:
			lst.append(m)
			l -= 1
			r += 1
			if j == r - 1:
				j = l
			elif j == l + 1:
				j = r
			m += j
		lst.append(n - 1)
	return lst
n = int(input())
s = input()
lst = []
for i in range(len(s)):
	lst.append('')
lst2 = solve(len(s))
for i in range(len(s)):
	lst[lst2[i]] = s[i]
print(''.join(lst))


def encrypt(s):
	if len(s) % 2:
		l = s[0]
		s = s[1:]
		s = s[::2][::-1] + s[1::2]
		s = s[:len(s) // 2] + l + s[len(s) // 2:]
		return s
	return s[::2][::-1] + s[1::2]
input()
print(encrypt(input()))


n = input()
string = input()

def decrypt(s):
	word_even = True
	if len(s) % 2 != 0:
		word_even = False
	if word_even:
		ev_str = s[-2::-2]
		naiv_str = s[1::2]
		print(ev_str + naiv_str)
	else:
		save = s[0]
		ev_str = s[-2::-2]
		naiv_str = s[2::2]
		print(ev_str + save + naiv_str)
decrypt(string)


n = int(input())
s = input()
if n % 2 == 0:
	mid = n // 2 - 1
	t = s[2::2]
	ans = t[::-1] + s[0] + s[1::2]
	print(ans)
else:
	mid = n + 1 // 2 - 1
	t = s[1::2]
	ans = t[::-1] + '' + s[::2]
	print(ans)


n = int(input())
l = list(input())
if n % 2 != 0:
	s = [l[0]]
	for i in range(1, n):
		if i % 2 != 0:
			s.insert(0, l[i])
		else:
			s.append(l[i])
else:
	s = [l[0]]
	for i in range(1, n):
		if i % 2 != 0:
			s.append(l[i])
		else:
			s.insert(0, l[i])
print(*s, sep='')


n = int(input())
s = input()
d = ''
st = s[::-1]
if n == 1:
	print(s)
elif n % 2 != 0:
	for i in range(n):
		if i % 2 != 0:
			d += st[i]
	for i in range(n):
		if i % 2 == 0:
			d += s[i]
else:
	c = 0
	x = n // 2
	k = 0
	for i in range(n):
		if i % 2 != 0:
			d += st[i]
	for i in range(n):
		if i % 2 != 0:
			d += s[i]
print(d)


from collections import deque
n = int(input())
s = deque(input())
decoded_message = [None] * n
if n % 2:
	k = n // 2
	k1 = k - 1
	k2 = k
else:
	k = n // 2 - 1
	k1 = k
	k2 = k + 1
while s:
	if len(s) % 2:
		e = s.popleft()
		decoded_message[k2] = e
		k2 += 1
	else:
		e = s.popleft()
		decoded_message[k1] = e
		k1 -= 1
print(''.join(decoded_message))


n = int(input())
s = input()
suma = False
pos = n // 2
if n % 2 == 0:
	suma = True
	pos -= 1
l = [None] * n
i = 0
while i < n:
	l[pos] = s[i]
	if suma:
		pos += i + 1
	else:
		pos -= i + 1
	suma = not suma
	i += 1
decoded = ''.join(l)
print(decoded)


n = int(input())
s = list(input())
s1 = []
for i in range(n):
	x = s.pop()
	s1.insert(int(len(s1) / 2), x)
print(''.join(s1))


n = int(input())
k = input()[:n]
y = 0
y1 = 1
l = ''
if len(k) % 2 != 0:
	for x in k:
		if y % 2 == 0:
			l += x
		else:
			l = x + l
		y += 1
	print(''.join(l))
else:
	for x in k:
		if y1 % 2 == 0:
			l += x
		else:
			l = x + l
		y1 += 1
	print(''.join(l))


n = int(input())
enco = input()
sol = ''
if n % 2 != 0:
	for i in range(n):
		if i % 2 == 0:
			sol += enco[i]
		else:
			sol = enco[i] + sol
if n % 2 == 0:
	for i in range(n):
		if i % 2 == 0:
			sol = enco[i] + sol
		else:
			sol += enco[i]
print(sol)


n = int(input())
t = input()
s = t[0]
ch = 1 if n % 2 == 0 else 0
if n == 1:
	print(t)
else:
	for i in range(1, n - 1):
		if ch == 0:
			if i % 2 == 0:
				s += t[i]
			else:
				s = t[i] + s
		elif i % 2 == 1:
			s += t[i]
		else:
			s = t[i] + s
	print(s + t[-1])


n = int(input())
s = list(input())
e = []
while len(s) > 0:
	if len(s) % 2:
		e.append(s[0])
	else:
		e.insert(0, s[0])
	s.pop(0)
print(''.join(e))


n = int(input())
s = input()
word = [0] * n
idx = 0
rev_idx = n - 1
c = 1
for i in range(n - 1, -1, -1):
	c *= -1
	if c == 1:
		word[idx] = s[i]
		idx += 1
	else:
		word[rev_idx] = s[i]
		rev_idx -= 1
print(''.join(word))


length = int(input(''))
orwd = input('')

def split(words):
	return [char for char in words]
orwd_array = split(orwd)
word_array = []
for i in range(length - 2, 0, -2):
	word_array.append(orwd_array[i])
	orwd_array.pop(i)
answer_array = word_array + orwd_array
answer_array = ''.join(answer_array)
print(answer_array)


n = int(input())
s = list(input())
ar = []
ar1 = []
if n % 2 == 1:
	for i in range(n):
		if n % 2 == 1 and i == 0:
			ar.append(s[i])
		elif i % 2 == 0:
			ar1.append(s[i])
		else:
			ar.append(s[i])
	print(''.join(ar[::-1]) + ''.join(ar1))
else:
	for i in range(n):
		if i % 2 == 0:
			ar.append(s[i])
		else:
			ar1.append(s[i])
	print(''.join(ar[::-1]) + ''.join(ar1))


def decoding(mystr):
	if mystr is None:
		return None
	if len(mystr) <= 2:
		return mystr
	res = ''
	for i in range(len(mystr)):
		if (len(mystr) - i) % 2 == 0:
			res = res + mystr[i]
		else:
			res = mystr[i] + res
	return res[::-1]
n = int(input())
my = str(input())
print(decoding(my))


a = int(input())
b = list(input())
v = []
if a % 2 == 0:
	x = 1
else:
	x = 0
for i in range(a):
	if x == 0:
		v.append(b[i])
		x = 1
	else:
		v.insert(0, b[i])
		x = 0
print(''.join(v))


def decode(s):
	n = len(s)
	if n == 0:
		return ('', '')
	elif n % 2 == 0:
		(l, r) = ('', '')
		for i in range(0, n, 2):
			l = s[i] + l
			r = r + s[i + 1]
		return (l, r)
	else:
		(l, r) = decode(s[1:])
		return (l + s[0], r)
n = int(input())
s = input()
(l, r) = decode(s)
print(l + r)


n = int(input())
word = input()
if n % 2 != 0:
	letter = word[0]
	for i in range(1, n, +2):
		letter = word[i] + letter
		letter = letter + word[i + 1]
else:
	first = ''
	second = ''
	for i in range(n, 0, -2):
		first += word[i - 2]
		second = word[i - 1] + second
	letter = first + second
print(letter)


def solution(n, s):
	ans = [' '] * n
	m = n - 2
	i = 0
	while m >= 0:
		ans[i] = s[m]
		m = m - 2
		i = i + 1
	m = 1 if n % 2 == 0 else 0
	while m < n:
		ans[i] = s[m]
		m = m + 2
		i = i + 1
	return ''.join(ans)
n = int(input())
s = input()
print(solution(n, s))


import math
n = int(input())
s = list(map(str, input()))
ans = [''] * n
pnt1 = 0
pnt2 = n - 1
last = True
for i in range(n - 1, -1, -1):
	if last == True:
		ans[pnt2] = s[i]
		pnt2 -= 1
		last = False
	else:
		ans[pnt1] = s[i]
		pnt1 += 1
		last = True
print(''.join(ans))


n = int(input())
s = list(input())
if n > 1:
	f = s[-2] + s[-1]
	k = n - 3
	while k > -1:
		e = len(f)
		f = f[:e // 2] + s[k] + f[e // 2:]
		k -= 1
	print(f)
else:
	print(*s)


n = int(input())
s = input()
answer = [0] * n
for i in range(0, n - 1, 2):
	k = n // 2 - 1 if n % 2 == 0 else n // 2
	while k >= 1:
		answer[k] = answer[k - 1]
		answer[-k - 1] = answer[-k]
		k -= 1
	if n % 2 == 0:
		answer[0] = s[i]
		answer[n - 1] = s[i + 1]
	else:
		answer[0] = s[i + 1]
		answer[n - 1] = s[i]
if n % 2 != 0:
	k = n // 2
	while k < n - 1:
		answer[k] = answer[k + 1]
		k += 1
	answer[n - 1] = s[n - 1]
print(''.join(answer))


n = int(input())
z = list(input())
r = n * [0]
p = str()
m = 0
g = 0
for i in range(n):
	if n % 2 == 0:
		if i % 2 == 0:
			r[len(z) // 2 - 1 - m] = z[i]
			m += 1
		else:
			g += 1
			r[len(z) // 2 - 1 + g] = z[i]
	elif i % 2 == 0:
		r[len(z) // 2 + m] = z[i]
		m += 1
	else:
		g += 1
		r[len(z) // 2 - g] = z[i]
for i in range(len(r)):
	p += r[i]
print(p)


def main():
	(n, s) = (int(input()), input())
	res = [None] * n
	sign = 1 if n & 1 else -1
	for (i, c) in enumerate(s, 1):
		res[(n + i * sign - 1) // 2] = c
		sign = -sign
	print(''.join(res))
main()


from itertools import product
from math import ceil, gcd, sqrt
import string
from decimal import Decimal

def binary_table(string_with_all_characters, length_to_make):
	return [''.join(x) for x in product(string_with_all_characters, repeat=length_to_make)]

def all_possible_substrings(string):
	return [int(string[i:j]) for i in range(len(string)) for j in range(i + 1, len(string) + 1)]

def number_of_substrings(length):
	return int(length * (length + 1) / 2)

def is_prime(num):
	for i in range(2, num):
		if num / i == int(num / i) and num != i:
			return False
	return True
num_of_letter = int(input())
encoded = list(input())
build = [''] * num_of_letter
if num_of_letter % 2:
	length = int(num_of_letter / 2)
	current_letter = length
	build[length] = encoded[0]
else:
	length = int(num_of_letter / 2) - 1
	build[length] = encoded[0]
	current_letter = length
del encoded[0]
if num_of_letter % 2:
	site = 1
else:
	site = 0
num_of_letter -= 1
left = 1
right = 1
while num_of_letter > 0:
	if site:
		build[current_letter - left] = encoded[0]
		left += 1
		site = 0
	else:
		build[current_letter + right] = encoded[0]
		right += 1
		site = 1
	del encoded[0]
	num_of_letter -= 1
print(*build, sep='')


from collections import defaultdict
import bisect
from itertools import accumulate
import os
import sys
import math
from decimal import *
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))

def input():
	return sys.stdin.readline().rstrip('\r\n')
input()
s = input()
a = ''
while s != '':
	a = a + s[0] if len(s) & 1 == 1 else s[0] + a
	s = s[1:]
print(a)


l = int(input())
s = input()
ans = ''
if l % 2 == 1:
	for i in range(0, l):
		if i % 2 == 0:
			ans = ans + s[i]
		else:
			ans = s[i] + ans
else:
	for i in range(0, l):
		if i % 2 == 1:
			ans = ans + s[i]
		else:
			ans = s[i] + ans
print(ans)


n = int(input())
s = input()[::-1]
out = [0] * n
k = 0
i = 0
while i < n and k < n and (out[k] == 0):
	out[k] = s[i]
	if i < n - 1:
		out[n - 1 - k] = s[i + 1]
	i += 2
	k += 1
print(''.join(out[::-1]))


n = int(input())
a = input()
if n % 2 == 0:
	print(a[-2::-2] + a[1::2])
else:
	b = a[1:]
	print(b[-2::-2] + a[0] + b[1::2])


n = int(input())
s = input()
answer = ''
a = s
if n % 2 != 0:
	answer += s[0]
	for i in range(1, n - 1, 2):
		answer = s[i] + answer + s[i + 1]
else:
	for i in range(1, n, 2):
		answer = s[i - 1] + answer + s[i]
print(answer)


def print_arr(arr):
	print(*arr, sep='')
(n, s) = (int(input()), input())
ans = []
if n % 2:
	ans.append(s[0])
for i in range(n % 2, n, 2):
	ans.insert(0, s[i])
	ans.append(s[i + 1])
print_arr(ans)


n = int(input())
s = input()
o = []
e = []
p = ''
for i in range(n):
	if i % 2 == 0:
		e.append(s[i])
	else:
		o.append(s[i])
if n % 2 == 0:
	e = e[::-1]
	print(p.join(e), end='')
	print(p.join(o))
else:
	o = o[::-1]
	print(p.join(o), end='')
	print(p.join(e))


from math import ceil
k = int(input())
l = input()
l = list(l)
m = list(l)
y = ceil(k / 2) - 1
for i in range(k):
	if i % 2 == 0:
		m[y - i] = l[i]
		y = y - i
	else:
		m[y + i] = l[i]
		y = y + i
if k % 2 != 0:
	print(*m[::-1], sep='')
else:
	print(*m, sep='')


n = eval(input())
s = input()
ss = ''
for i in range(n):
	if i % 2 == 0:
		ss = s[i] + ss
	else:
		ss = ss + s[i]
if n & 1:
	print(ss[::-1])
else:
	print(ss)


n = int(input())
s = input()
ans = ''
for (a, i) in enumerate(s):
	if a == 0:
		ans += i
	elif a % 2 == 0 and n % 2 == 1 or (a % 2 == 1 and n % 2 == 0):
		ans += i
	else:
		ans = i + ans
print(ans)


s_len = int(input())
s = input()
output_s = list()
if s_len % 2 != 0:
	for elem in range(0, s_len, 2):
		output_s.insert(0, s[elem])
		try:
			output_s.append(s[elem + 1])
		except:
			pass
else:
	for elem in range(0, s_len, 2):
		output_s.append(s[elem])
		try:
			output_s.insert(0, s[elem + 1])
		except:
			pass
print(''.join(output_s[::-1]))


n = int(input())
s = input()
a = s[-2::-2]
b = s[-1::-2][::-1]
print(a + b)


import math
n = int(input())
w = list(input())
e = []
if n % 2 == 0:
	s = 1
else:
	s = 0
for x in range(0, n):
	if s == 1:
		e.insert(math.floor(len(e) / 2) - x - x, w[x])
		s = 0
	elif s == 0:
		e.insert(math.floor(len(e) / 2) + x + x, w[x])
		s = 1
print(''.join(e))


t = int(input())
s = input()
a1 = []
a2 = []
for k in range(len(s) - 1, -1, -1):
	if len(a2) == len(a1):
		a2.insert(0, s[k])
	else:
		a1.append(s[k])
r = ''.join(a1) + ''.join(a2)
print(r)


n = int(input())
s = input()
print(s[n & 1::2][::-1] + s[abs((n & 1) - 1)::2])


def Decoding(n, s):
	C = ''
	if n % 2 == 0:
		for i in range(n - 2, -1, -2):
			C += s[i]
		for j in range(1, n, 2):
			C += s[j]
	else:
		for i in range(n - 2, 0, -2):
			C += s[i]
		for j in range(0, n, 2):
			C += s[j]
	return C
n = int(input())
s = str(input())
print(Decoding(n, s))


import math
n = input()
s = input()
res = ''
index = len(s) // 2
if len(s) % 2 == 0:
	for i in range(0, len(s), 2):
		res = s[i] + res + s[i + 1]
else:
	res = res + s[0]
	for i in range(1, len(s), 2):
		res = s[i] + res + s[i + 1]
print(res)


n = int(input())
text = input()
fl = n % 2
rez = ''
for i in text:
	if fl % 2:
		rez = rez + i
	else:
		rez = i + rez
	fl += 1
print(rez)


n = int(input())
s = input()
ans = ''
for (a, i) in enumerate(s):
	if (a + n) % 2:
		ans += i
	else:
		ans = i + ans
print(ans)


n = int(input())
s = input()
arr = [''] * n
if n % 2 != 0:
	i = n // 2
	arr[i] = s[0]
	j = 1
	x = 1
	while j < n:
		if i - x >= 0:
			arr[i - x] = s[j]
			j += 1
		if i + x < n:
			arr[i + x] = s[j]
			j += 1
		x += 1
	print(*arr, sep='')
else:
	i = n // 2
	j = 0
	x = 1
	while j < n:
		if i - x >= 0:
			arr[i - x] = s[j]
			j += 1
		if i + x - 1 < n:
			arr[i + x - 1] = s[j]
			j += 1
		x += 1
	print(*arr, sep='')


length = int(input())
encode = input()
st = []
if length % 2 == 0:
	flag = 0
else:
	flag = 1
for each in encode:
	if flag == 0:
		flag = 1
		st.insert(0, each)
	else:
		flag = 0
		st.append(each)
for each in st:
	print(each, end='')


n = int(input())
s = input()
res = ''
i = 0
while i < len(s):
	if (len(s) - i) % 2 == 1:
		res += s[i]
	else:
		res = s[i] + res
	i += 1
print(res)


n = int(input())
w = list(input())
s1 = ''
s2 = ''
for i in range(n - 1, -1, -2):
	s1 += w[i]
for i in range(n - 2, -1, -2):
	s2 += w[i]
print(s2 + s1[::-1])


def decode(string):
	length = len(string)
	new_string = [''] * length
	odd = 0
	even = -1
	if length % 2 == 0:
		for i in range(length):
			if i % 2 == 0:
				new_string[length // 2 + even] = string[i]
				even -= 1
			else:
				new_string[length // 2 + odd] = string[i]
				odd += 1
	else:
		for j in range(length):
			if j % 2 == 0:
				new_string[length // 2 + odd] = string[j]
				odd += 1
			else:
				new_string[length // 2 + even] = string[j]
				even -= 1
	return ''.join(new_string)
input()
print(decode(input()))


t = 1
for _ in range(t):
	n = int(input())
	s = input()
	ans = ''
	if n % 2:
		for i in range(n):
			if i % 2:
				ans = ans[::-1]
				ans += s[i]
				ans = ans[::-1]
			else:
				ans += s[i]
	else:
		ans = ''
		for i in range(n):
			if not i % 2:
				ans = ans[::-1]
				ans += s[i]
				ans = ans[::-1]
			else:
				ans += s[i]
	print(ans)


n = int(input())
s = input()
ans = [-1] * n
n1 = n
for i in range(n):
	val = s[i]
	median = 0
	if n1 % 2 == 0:
		median = int(n1 / 2)
	else:
		median = int(n1 / 2) + 1
	count = 0
	j = 0
	while j < n and count < median:
		if ans[j] == -1:
			if count + 1 == median:
				break
			count += 1
		j += 1
	ans[j] = val
	n1 -= 1
for i in ans:
	print(i, end='')


n = int(input())
s = list(input())
a = ''
b = ''
if n == 1:
	print(s[0])
	quit()
aa = s[0]
del s[0]
bb = s[len(s) - 1]
del s[len(s) - 1]
for i in reversed(range(len(s))):
	if n % 2 == 0:
		if i % 2 != 0:
			a += s[i]
		else:
			b += s[i]
	elif i % 2 == 0:
		a += s[i]
	else:
		b += s[i]
print(a + aa + b[::-1] + bb)


n = int(input())
string = str(input())
ret = ''
for i in range(0, len(string)):
	if len(string) % 2 == 0:
		if i % 2 == 0:
			ret = string[i] + ret
		else:
			ret += string[i]
	elif i % 2 == 0:
		ret += string[i]
	else:
		ret = string[i] + ret
print(ret)


n = input()
s = input()
s = s[::-1]
s1 = s[1::2]
s2 = s[0::2]
s2 = s2[::-1]
print(s1 + s2)


def decoder(size, word):
	result = ''
	for i in range(size):
		if i % 2 == 0:
			result = word[i] + result
		elif i % 2 != 0:
			result = result + word[i]
	if size % 2 == 0:
		return result
	else:
		return result[::-1]
size = input()
word = input()
print(decoder(int(size), word))


n = int(input())
p = n
liste = []
s = input()
liste1 = list(s)
for i in range(n):
	p += 1
	if p % 2 == 0:
		liste.append(liste1.pop(0))
	if p % 2 == 1:
		liste.insert(0, liste1.pop(0))
print(*liste, sep='')


n = int(input())
str = input()[:n]
print(str[-2::-2] + str[1 - n % 2::2])


n = int(input())
s = list(input())
if n % 2 != 0:
	for i in range(n - 2, 0, -2):
		print(s[i], end='')
	for i in range(0, n, 2):
		print(s[i], end='')
else:
	for i in range(n - 2, -1, -2):
		print(s[i], end='')
	for i in range(1, n, 2):
		print(s[i], end='')


n = int(input())
encoded = input()
left = True
if len(encoded) % 2 == 0:
	left = False
result = encoded[0]
encoded = encoded[1:]
while encoded:
	letter = encoded[0]
	if left:
		result = letter + result
	else:
		result = result + letter
	encoded = encoded[1:]
	left = not left
print(result)


c = input()
st = input()
ans = st[-1]
cn = 1
for i in range(len(st) - 2, -1, -1):
	ans = ans[:len(ans) // 2] + st[i] + ans[len(ans) // 2:]
print(ans)


import sys
n = int(sys.stdin.readline())
encrypted = sys.stdin.readline().strip()
decrypted = ''
pos = 0
for i in range(len(encrypted) - 2, -1, -2):
	decrypted += encrypted[i]
	pos += 1
for i in range((len(encrypted) + 1) % 2, len(encrypted), 2):
	decrypted += encrypted[i]
	pos += 1
print(decrypted)


n = int(input())
a = input()
A = [0] * len(a)
for j in range(len(a)):
	if j % 2 == 0:
		A[-(j // 2 + 1)] = a[len(a) - 1 - j]
	else:
		A[j // 2] = a[len(a) - 1 - j]
print(''.join(map(str, A)))


n = int(input())
s = input()
ans = ''
if n % 2 == 0:
	i = 0
	while i < n:
		if i % 2 == 0:
			ans = s[i] + ans
		else:
			ans += s[i]
		i += 1
else:
	i = 0
	while i < n:
		if i % 2 == 0:
			ans += s[i]
		else:
			ans = s[i] + ans
		i += 1
print(ans)


import sys
cin = sys.stdin.readline
cout = sys.stdout.write

def func(n, s):
	if n < 3:
		return s
	d = -1
	i = 0
	mid = n // 2
	if n & 1 == 0:
		st = [''] * (n + 1)
	else:
		st = [''] * n
		st[mid] = s[0]
		i = 1
	while abs(d) <= mid and i < n:
		st[mid + d] = s[i]
		i += 1
		if d >= 0:
			d += 1
		d *= -1
	return ''.join(st)

def main():
	n = int(cin())
	s = cin()
	cout(str(func(n, s)))
main()


(n, x, Decode) = (int(input()), input(), '')
if n % 2 == 0:
	for i in range(n):
		Decode = Decode + x[i] if i % 2 != 0 else x[i] + Decode
else:
	for i in range(n):
		Decode = Decode + x[i] if i % 2 == 0 else x[i] + Decode
print(Decode)


N = int(input())
L = list(input())
X = ['0'] * N
x = 0
i = N - 1
while i > 0:
	X[x] = L[i - 1]
	X[N - 1 - x] = L[i]
	x += 1
	i -= 2
if N % 2 != 0:
	X[x] = L[0]
print(''.join(X))


n = int(input())
s = ''
k = input()
if n % 2 != 0:
	for i in range(len(k)):
		if i % 2 == 0:
			s = s + k[i]
		else:
			s = k[i] + s
	print(s)
else:
	for i in range(len(k)):
		if i % 2 != 0:
			s = s + k[i]
		else:
			s = k[i] + s
	print(s)


n = int(input())
string = input()
array = [0 for i in range(n)]
array[n - 1] = string[n - 1]
for i in range(1, n // 2 + 1):
	array[i - 1] = string[n - 2 * i]
	if not float(n) / 2 == i:
		array[n - i - 1] = string[n - 2 * i - 1]
array = list(map(str, array))
print(''.join(array))


input()
s = input()
l = ['0' for i in range(len(s))]
if len(s) % 2 != 0:
	t = 1
	k = 1
	l[len(s) // 2] = s[0]
	for i in range(1, len(s)):
		if t == 1:
			l[len(s) // 2 - k] = s[i]
			t = 0
		else:
			l[len(s) // 2 + k] = s[i]
			t = 1
			k = k + 1
else:
	t = 1
	k = 1
	for i in range(len(s)):
		if t == 1:
			l[len(s) // 2 - k] = s[i]
			t = 0
		else:
			l[len(s) // 2 + k - 1] = s[i]
			t = 1
			k = k + 1
S = ''
for i in range(len(l)):
	S = S + l[i]
print(S)


n = int(input())
code = input().strip()
msg = ''
i = 0
while n > 0:
	if n % 2 == 0:
		msg = code[i] + msg
	else:
		msg = msg + code[i]
	i += 1
	n -= 1
print(msg)


n = int(input())
word = input()
l1 = []
for i in range(n):
	l1.append(' ')
if n % 2 == 1:
	l1[n // 2] = word[0]
	for i in range(1, n):
		if i % 2 == 1:
			l1[n // 2 - (i + 1) // 2] = word[i]
		else:
			l1[n // 2 + i // 2] = word[i]
else:
	l1[n // 2 - 1] = word[0]
	for i in range(1, n):
		if i % 2 == 1:
			l1[n // 2 + (i + 1) // 2 - 1] = word[i]
		else:
			l1[n // 2 - i // 2 - 1] = word[i]
print(''.join(l1))


def solve():
	n = int(input())
	encoded = input()
	res = [''] * n
	j = 1
	if n % 2 == 1:
		idx = n // 2
		res[idx] = encoded[0]
		for i in range(1, n // 2 + 1):
			res[idx - i] = encoded[j]
			res[idx + i] = encoded[j + 1]
			j += 2
	else:
		idx = n // 2 - 1
		res[idx] = encoded[0]
		for i in range(1, n // 2):
			res[idx - i] = encoded[j + 1]
			res[idx + i] = encoded[j]
			j += 2
		res[-1] = encoded[-1]
	print(''.join(res))
solve()


n = int(input())
s = input()
a = []
if n % 2 == 0:
	for i in range(n):
		if i % 2 == 0:
			a.insert(0, s[i])
		else:
			a.append(s[i])
else:
	for i in range(n):
		if i % 2 == 0:
			a.append(s[i])
		else:
			a.insert(0, s[i])
print(''.join(a))


import math
L = lambda : list(map(int, input().split()))
M = lambda : map(int, input().split())
I = lambda : int(input())
n = I()
a = input()
a = a[::-1]
x = ''
y = ''
for i in range(n):
	if i % 2 == 0:
		y += a[i]
	else:
		x += a[i]
print(x + y[::-1])


n = int(input())
s = input()
l = list(s)
a = list(s)
c = 0
if n % 2 == 1:
	i = n // 2
	j = n // 2
	a[i] = l[c]
	c = c + 1
	while i > 0 and j < n - 1:
		i = i - 1
		j = j + 1
		a[i] = l[c]
		c = c + 1
		a[j] = l[c]
		c = c + 1
else:
	i = n // 2 - 1
	j = n // 2
	a[i] = l[c]
	c = c + 1
	a[j] = l[c]
	c = c + 1
	while i > 0 and j < n - 1:
		i = i - 1
		j = j + 1
		a[i] = l[c]
		c = c + 1
		a[j] = l[c]
		c = c + 1
print(''.join(a))


input()
s = input()
s_r = reversed(s)
decoded = list(s)
(rp, lp) = (len(s) - 1, 0)
for (i, c_r) in enumerate(s_r):
	if i % 2 == 0:
		decoded[rp] = c_r
		rp -= 1
	else:
		decoded[lp] = c_r
		lp += 1
print(''.join(decoded))


n = int(input())
s = input()
side = n % 2 == 0
ans = ''
for c in s:
	if side:
		ans = c + ans
	else:
		ans += c
	side = not side
print(ans)


n = int(input())
s = input()
(f, l, i) = (0, n - 1, n - 1)
a = ['_' for _ in range(n)]
while f <= l:
	if f == l:
		a[f] = s[i]
		f += 1
	else:
		a[l] = s[i]
		i -= 1
		a[f] = s[i]
		l -= 1
		f += 1
		i -= 1
print(''.join(a))


n = int(input())
S = input()
x = len(S)
(l, r) = (x // 2 - 1, x // 2)
ans = ['x'] * x
ct = 0
while x > 0:
	if x % 2 == 1:
		ans[r] = S[ct]
		r += 1
	else:
		ans[l] = S[ct]
		l -= 1
	x -= 1
	ct += 1
print(''.join(ans))


n = int(input())
s = input()
a = ''
while len(s) != 0:
	if len(s) % 2 == 0:
		a = s[0] + a
	else:
		a = a + s[0]
	s = s[1:]
print(a)


n = int(input())
seq = list(range(n))
new = []
for i in range(0, n):
	m = int((len(seq) - 1) / 2)
	new.append(seq.pop(m))
s = input()
ns = [None] * n
for i in range(0, n):
	ns[new[i]] = s[i]
print(''.join(ns))


a = int(input())
b = input()
c = ''
for i in b:
	if a % 2 == 0:
		c = i + c
	else:
		c = c + i
	a -= 1
print(c)


n = int(input())
l = input()
o = l[0]
check = bool(n % 2)
for c in l[1:]:
	if check:
		o = c + o
		check = False
	else:
		o += c
		check = True
print(o)


x = int(input())
s = input()
l = ''
for i in range(x):
	if (x - i) % 2 == 1:
		l = l + s[i]
	else:
		l = s[i] + l
print(l)


n = int(input())
s = input()
l = ''
for i in s:
	if n % 2 == 1:
		l = l + i
	else:
		l = i + l
	n -= 1
print(l)


n = int(input())
s = input()
res = ''
for i in range(n - 1, -1, -1):
	p = len(res) // 2
	res = res[:p] + s[i] + res[p:]
print(res)


n = int(input())
s = input()
l = []
for i in range(0, n):
	l.append(0)
c = 0
st = ''
if n % 2 == 0:
	q = n // 2 - 1
	l[q] = s[0]
	st = s[1:]
	s = st
	(a, b) = (q - 1, q + 1)
	while len(s) != 0:
		if c % 2 == 0:
			l[b] = s[0]
			b = b + 1
		else:
			l[a] = s[0]
			a = a - 1
		c = c + 1
		st = s[1:]
		s = st
else:
	q = n // 2
	l[q] = s[0]
	st = s[1:]
	s = st
	(a, b) = (q - 1, q + 1)
	while len(s) != 0:
		if c % 2 != 0:
			l[b] = s[0]
			b = b + 1
		else:
			l[a] = s[0]
			a = a - 1
		c = c + 1
		st = s[1:]
		s = st
st = ''
for i in l:
	st = st + i
print(st)


import math
n = int(input())
s = input()
ans = ''
for i in range(n - 1, -1, -1):
	mid = math.ceil((len(ans) + 1) / 2)
	ans = ans[:mid - 1] + s[i] + ans[mid - 1:]
print(ans)


n = int(input())
m = input()
b = [0] * n
k = 0
h = ''
w = [0] * n
if n % 2 != 0:
	for i in range(n - 1, -1, -1):
		b[k] = m[i]
		k += 1
	k = n - 1
	for i in range(0, n, 2):
		w[k] = b[i]
		k -= 1
	for i in range(1, n, 2):
		w[k] = m[i]
		k -= 1
if n % 2 == 0:
	k = n - 1
	for i in range(n - 1, -1, -2):
		w[k] = m[i]
		k -= 1
	k = 0
	for i in range(n - 2, -1, -2):
		w[k] = m[i]
		k += 1
for i in range(n):
	h += w[i]
print(h)


a = int(input())
n = a
s2 = input().strip()
res = [a for a in range(0, a)]
s3 = [a for a in range(1, a + 1)]
coun = 0
r3 = []
while res:
	if len(res) % 2 == 0:
		r3.append([res[len(res) // 2 - 1], s2[coun]])
		res.pop(len(res) // 2 - 1)
	else:
		r3.append([res[len(res) // 2], s2[coun]])
		res.pop(len(res) // 2)
	coun += 1
r3.sort()
print(''.join((str(x[1]) for x in r3)))


n = int(input())
p = list(input())
p.reverse()
k = 1
d = ['0'] * n
i = 0
if n % 2 == 0:
	while i + 1 <= n:
		(d[-k], d[k - 1]) = (p[i], p[i + 1])
		k += 1
		i += 2
else:
	n = n - 1
	while i + 1 <= n:
		(d[-k], d[k - 1]) = (p[i], p[i + 1])
		k += 1
		i += 2
	n += -1
	d[n // 2 + n % 2] = p[-1]
d = ''.join(d)
print(d)


input()
scrambled = input().strip()
if len(scrambled) % 2:
	parity = 1
else:
	parity = 0
unscrambled = ''
while len(scrambled) > 0:
	if parity == 0:
		unscrambled = scrambled[0] + unscrambled
		parity = 1
	else:
		unscrambled += scrambled[0]
		parity = 0
	scrambled = scrambled[1:]
print(unscrambled)


size = int(input())
palabra = input()
palabra = list(palabra)
decoded = ''
es_par = True
if size % 2 == 0:
	es_par = True
else:
	es_par = False
odd = False
if size == 1:
	decoded = palabra[0]
elif es_par == True:
	for n in range(size):
		if not odd:
			decoded = palabra[n] + decoded
		else:
			decoded = decoded + palabra[n]
		odd = not odd
else:
	for n in range(size):
		if not odd:
			decoded = decoded + palabra[n]
		else:
			decoded = palabra[n] + decoded
		odd = not odd
print(decoded)


input()
a = input()
c = []
while len(a):
	if len(a) % 2:
		c.append(a[0])
		a = a[1:]
	else:
		c.insert(0, a[0])
		a = a[1:]
print(*c, sep='')


n = int(input())
m = input()
k = ''
if len(m) % 2 == 1:
	for i in range(n - 2, -1, -2):
		k += m[i]
	for i in range(0, n, 2):
		k += m[i]
else:
	for i in range(n - 2, -1, 2):
		k += m[i]
	for i in range(n - 2, -1, -2):
		k += m[i]
	for i in range(1, n, 2):
		k += m[i]
print(k)


input()
a = input()
res = ''
k = len(a) % 2
for i in range(len(a) - 1, -1, -1):
	if i % 2 == k:
		res += a[i]
for i in range(len(a)):
	if i % 2 == (k + 1) % 2:
		res += a[i]
print(res)


import sys
sys.setrecursionlimit(10000)

def encode(word, output):
	if len(word) == 1:
		output.insert(len(output), word[0])
		return
	word = list(word)
	m = 0
	if len(word) % 2 == 0:
		m = len(word) // 2
		m -= 1
	else:
		m = len(word) // 2
	output.insert(len(output), word[m])
	del word[m]
	encode(word, output)

def decode(word, output):
	if len(word) == 0:
		return
	word = list(word)
	m = len(output) // 2
	if len(word) == 1:
		output.insert(m, word[0])
		return
	if len(output) == 0:
		output.insert(m, word[len(word) - 1])
		del word[len(word) - 1]
	output.insert(m, word[len(word) - 1])
	del word[len(word) - 1]
	decode(word, output)
n = int(input())
s = input()
output = []
decode(s, output)
print(''.join(output))


input()
word = input()
result = ''
right = True
if len(word) % 2 == 0:
	right = False
for letter in word:
	if right:
		result = result + letter
	else:
		result = letter + result
	right = not right
print(result)


import math
import sys
import re
n = int(input())
s = input()
s1 = s[0]
if n % 2 != 0:
	for x in range(n - 1):
		if x % 2 == 0:
			s1 = s[x + 1] + s1
		else:
			s1 = s1 + s[x + 1]
else:
	for y in range(n - 1):
		if y % 2 == 0:
			s1 = s1 + s[y + 1]
		else:
			s1 = s[y + 1] + s1
print(s1)


(n,) = map(int, input().split())
s = input()
res = [None for _ in range(n)]
curr = (n - 1) // 2
step = 1
drc = -1 if n % 2 != 0 else 1
for c in s:
	res[curr] = c
	curr += step * drc
	drc *= -1
	step += 1
print(''.join(res))


from sys import stdin, stdout
from collections import defaultdict

def get_int():
	return int(stdin.readline().strip())

def get_ints():
	return map(int, stdin.readline().strip().split())

def get_array():
	return list(map(int, stdin.readline().strip().split()))

def get_string():
	return stdin.readline().strip()
n = get_int()
ans = []
s = get_string()
if n % 2 != 0:
	for i in range(n):
		if i % 2 == 0:
			ans.append(s[i])
		else:
			ans.insert(0, s[i])
else:
	for i in range(n):
		if i % 2 != 0:
			ans.append(s[i])
		else:
			ans.insert(0, s[i])
a = ''
for i in ans:
	a += i
print(a)


n = int(input())
st = input()
answer = [0 for i in range(len(st))]
if len(st) % 2 == 0:
	pos = (len(st) - 1) // 2
	nextright = pos + 1
	nextleft = pos - 1
	nextdir = 'r'
	answer[pos] = st[0]
	for i in range(1, len(st)):
		if nextdir == 'r':
			answer[nextright] = st[i]
			nextright += 1
			nextdir = 'l'
		else:
			answer[nextleft] = st[i]
			nextleft -= 1
			nextdir = 'r'
else:
	pos = len(st) // 2
	nextright = pos + 1
	nextleft = pos - 1
	nextdir = 'l'
	answer[pos] = st[0]
	for i in range(1, len(st)):
		if nextdir == 'r':
			answer[nextright] = st[i]
			nextright += 1
			nextdir = 'l'
		else:
			answer[nextleft] = st[i]
			nextleft -= 1
			nextdir = 'r'
print(''.join(answer))


s = int(input())
st = input()
nue = ''
if s % 2 == 0:
	for x in range(s):
		if x % 2 != 0:
			nue = nue + st[x]
		else:
			nue = st[x] + nue
else:
	for x in range(s):
		if x % 2 != 0:
			nue = st[x] + nue
		else:
			nue = nue + st[x]
print(nue)


n = int(input())
inp = input().strip(' ')
if len(inp) <= 2:
	print(inp)
else:
	s = list(inp[-2:])
	for i in range(len(inp) - 2):
		s.insert(int(len(s) / 2), inp[len(inp) - 3 - i])
	print(''.join(s))


n = int(input())
s = list(input())
new = ''
if n & 1:
	for i in range(n):
		if not i & 1:
			new += s[i]
		else:
			new = s[i] + new
else:
	for i in range(n):
		if i & 1:
			new += s[i]
		else:
			new = s[i] + new
print(new)


import sys

def main(n):
	elems = [None for _ in range(len(n))]
	med_pos = (0 + len(n) - 1) // 2
	elems[med_pos] = n[0]
	even = 1
	odd = 1
	for i in range(1, len(n)):
		if (len(n) - i) % 2 == 0:
			elems[med_pos - even] = n[i]
			even += 1
		else:
			elems[med_pos + odd] = n[i]
			odd += 1
	print(''.join(elems))
for (e, line) in enumerate(sys.stdin.readlines()):
	if e == 0:
		continue
	n = line.strip()
main(n)


import sys
n = int(sys.stdin.readline())
s = sys.stdin.readline().split()[0]
t = ''
while len(s) > 0:
	(a, s) = (s[0], s[1:])
	if n % 2 != 0:
		t = t + a
	else:
		t = a + t
	n = n - 1
print(t)


n = int(input())
s = input()
s1 = [' '] * n
if n % 2 != 0:
	mid = n // 2
	s1[mid] = s[0]
	for i in range(mid):
		s1[mid - i - 1] = s[2 * i + 1]
		s1[mid + i + 1] = s[2 * i + 2]
	print(''.join(s1))
else:
	mid = n // 2 - 1
	for i in range(mid + 1):
		s1[mid - i] = s[2 * i]
		s1[mid + i + 1] = s[2 * i + 1]
	print(''.join(s1))


n = int(input())
a = input()
ch = ''
if n % 2 == 0:
	for i in range(2, n + 1, 2):
		ch = ch + a[n - i]
	for i in range(1, n, 2):
		ch = ch + a[i]
else:
	for i in range(1, n, 2):
		ch = ch + a[n - 1 - i]
	for i in range(0, n, 2):
		ch = ch + a[i]
print(ch)


n = int(input())
noWord = str(input())
enWord = [None] * n
oddCount = 0
evenCount = n - 1
count = 0
for i in noWord[::-1]:
	if count % 2 == 0:
		enWord[evenCount] = i
		evenCount -= 1
	elif count % 2 > 0:
		enWord[oddCount] = i
		oddCount += 1
	count += 1
print(''.join(enWord))


n = int(input())
string = input()
seq = list(range(n))
newseq = []
while seq:
	m = (len(seq) - 1) // 2
	newseq.append(seq[m])
	for i in range(m, len(seq) - 1):
		(seq[i], seq[i + 1]) = (seq[i + 1], seq[i])
	seq.pop()
res = [0] * n
for i in range(n):
	res[newseq[i]] = string[i]
print(''.join(res))


n = int(input())
l = list(input())
ans = []
for i in range(n):
	if i % 2 == n % 2:
		ans = [l[i]] + ans
	else:
		ans += [l[i]]
print(''.join(ans))


def decode_string(n, encoded):
	if n <= 2:
		return encoded
	decoded = [''] * n
	if n % 2 == 0:
		decoded[n // 2 - 1] = encoded[0]
		decoded[n // 2] = encoded[1]
		start = 2
		left = n // 2 - 2
		right = n // 2 + 1
	else:
		decoded[n // 2] = encoded[0]
		start = 1
		left = n // 2 - 1
		right = n // 2 + 1
	while start < n - 1:
		decoded[left] = encoded[start]
		decoded[right] = encoded[start + 1]
		left -= 1
		right += 1
		start += 2
	return ''.join(decoded)
n = int(input())
encoded = input()
print(decode_string(n, encoded))


import math
x = int(input())
s = input()
output = [0] * x
n = math.ceil(x / 2)
for i in range(n):
	output[-1 - i] = s[len(s) - 1]
	s = s[:-1]
	if len(s) != 0:
		output[i] = s[len(s) - 1]
		s = s[:-1]
for i in output:
	print(i, end='')


n = int(input())
l = input()
s = list(l)
a = []
for i in range(n):
	if i % 2 == 0:
		a.append(s[i])
	else:
		a.insert(0, s[i])
b = ''.join(a)
if n % 2 == 0:
	print(b[::-1])
else:
	print(b)


n = int(input())
a = input()
a = a[::-1]
x = ''
y = ''
for i in range(n):
	if i % 2 == 0:
		y = a[i] + y
	else:
		x = x + a[i]
print(x + y)


def main():
	n = int(input())
	s = input()
	print(solver(s))

def solver(s):
	l = [None] * len(s)
	l[:len(s) // 2] = s[len(s) - 2::-2]
	if len(s) % 2 == 0:
		l[len(s) // 2:] = s[1::2]
	else:
		l[len(s) // 2:] = s[::2]
	return ''.join(l)
main()


n1 = int(input())
z = input()
n = z[:n1]
w = ''
q = ''
s = n[::-1]
for i in range(len(s)):
	if i % 2 == 0:
		w += s[i]
	else:
		q += s[i]
m = w + q[::-1]
print(m[::-1])


import sys, math
from collections import deque
import random
n = int(input())
s = input()
k = n
ans = ''
for i in range(n):
	if k % 2 == 1:
		ans += s[i]
	else:
		ans = s[i] + ans
	k -= 1
print(ans)


number = int(input())
data = list(input().strip())
(middle, first, last) = ('', [], [])
(fresult, lresult) = ('', '')
if number % 2 != 0:
	middle = data.pop(0)
	number -= 1
if number > 0:
	tem_number = int(number / 2)
	for m in range(tem_number):
		first.append('null')
		last.append('null')
	count = 0
	count2 = 0
	while count2 < tem_number:
		first[tem_number - count2 - 1] = data[count]
		last[count2] = data[count + 1]
		count += 2
		count2 += 1
	count = 0
	for n in first:
		fresult += n
	for n in last:
		lresult += n
print(fresult + middle + lresult)


from sys import argv

def rstr():
	return input()

def rint():
	return int(input())

def rints():
	return [int(i) for i in input().split(' ')]

def prnt(*args):
	if '-v' in argv:
		print(*args)

def decode(s, n):
	s2 = ['' for i in range(n)]
	if n % 2 == 0:
		index = int(n / 2) - 1
		diff = 1
		mod = 1
	else:
		index = int(n / 2)
		diff = 1
		mod = -1
	for i in range(n):
		s2[index] = s[i]
		index += diff * mod
		diff += 1
		mod *= -1
	return ''.join(s2)
n = rint()
s = rstr()
print(decode(s, n))


n = input()
string_output = input()
aux = ''
i = len(string_output) - 1
while i >= 0:
	l = len(aux)
	aux = aux[:l // 2] + string_output[i] + aux[l // 2:]
	i -= 1
print(aux)


n = input()
word = input()
first = ''
last = ''
while len(word) > 0:
	last = word[-1] + last
	if len(word) != 1:
		first += word[-2]
	word = word[:-2]
print(first + last)


n = int(input())
s1 = input()
x = n // 2
s = ''
if n % 2 == 1:
	k = n - 2
	l = []
	s = ''
	for i in range(k, 0, -2):
		s = s + s1[i]
	for i in range(0, n - 2, 2):
		s = s + s1[i]
	s = s + s1[-1]
	print(s)
else:
	k = n - 2
	s = ''
	for i in range(k, -1, -2):
		s = s + s1[i]
	for i in range(1, n, 2):
		s = s + s1[i]
	print(s)


n = input()
n = int(n)
code = input()
decode = ''
count = 0
for letter in code:
	if n % 2 == 1:
		if count % 2 == 0:
			decode = letter + decode
		else:
			decode += letter
	elif count % 2 == 0:
		decode += letter
	else:
		decode = letter + decode
	count += 1
print(decode[::-1])


n = int(input())
s = input()
word = ''
for i in range(n):
	if i % 2 == 1:
		word = s[i] + word
	else:
		word += s[i]
if n % 2 == 0:
	print(word[::-1])
else:
	print(word)


from collections import defaultdict
import sys, os, math

def __starting_point():
	n = int(input())
	s = input()
	ans = ''
	if len(s) % 2 == 1:
		ans += s[0]
		s = s[1:]
	for i in range(len(s)):
		if i % 2 == 0:
			ans = s[i] + ans
		else:
			ans = ans + s[i]
	print(ans)
__starting_point()


n = int(input())
s = input()
ans = [0] * n
addi = 1
if n % 2 == 0:
	idx = n // 2 - 1
	sign = 1
else:
	idx = n // 2
	sign = -1
for i in range(n):
	ans[idx] = s[i]
	idx += addi * sign
	addi += 1
	sign *= -1
print(''.join(ans))


def proB(st):
	arr = list(st)
	ans = [0] * len(arr)
	n = len(arr) - 1
	mid = n
	mid = mid // 2
	p = 1
	ans[mid] = arr[0]
	(l, r) = (mid - 1, mid + 1)
	n = n - 1
	while p <= len(arr) - 1:
		if n % 2 != 0:
			if 0 <= l:
				ans[l] = arr[p]
				l -= 1
			else:
				ans[r] = arr[p]
				r += 1
		elif r <= len(arr) - 1:
			ans[r] = arr[p]
			r += 1
		else:
			ans[l] = arr[p]
			l -= 1
		p += 1
		n -= 1
	return ''.join(ans)
t = int(input())
st = input()
print(proB(st))


def main():
	n = int(input())
	arr = [int(i) for i in input().split(' ')]
	arr_sum = sum(arr)
	zeros = len([i for i in arr if i == 0])
	if -1 * arr_sum == zeros:
		print(zeros + 1)
		return
	print(max(0, zeros))

def possible(arr):
	halfsum = sum(arr) // 2
	if halfsum in arr:
		return True
	for i in range(0, 4):
		for j in range(i + 1, 4):
			if arr[i] + arr[j] == halfsum:
				return True
	return False

def is_palin(string):
	if not string or len(string) == 1:
		return True
	n = len(string)
	for i in range(0, n // 2):
		pass
n = int(input())
string = input()
result = ''
start = 0
if n % 2 == 1:
	start = 1
	result = string[0]
flag = True
for i in range(start, n):
	if flag:
		result = string[i] + result
		flag = False
	else:
		result = result + string[i]
		flag = True
print(result)


n = int(input())
a = input()
b = [0] * n
i = 0
m = (n - 1) // 2
b[m] = a[i]
m1 = m
m2 = m
n -= 1
i = 1
while n != 0:
	if n % 2 == 0:
		m1 -= 1
		b[m1] = a[i]
	else:
		m2 += 1
		b[m2] = a[i]
	i += 1
	n -= 1
print(*b, sep='')


n = int(input())
a = input()
if n % 2 == 1:
	c = [0] * n
	c[n // 2] = a[0]
	i = n // 2 - 1
	j = n // 2 + 1
	k = 1
	while i >= 0:
		c[i] = a[k]
		c[j] = a[k + 1]
		i = i - 1
		j = j + 1
		k += 2
	print(''.join(c))
else:
	c = [0] * n
	i = n // 2 - 1
	j = n // 2
	k = 0
	while i >= 0:
		c[i] = a[k]
		c[j] = a[k + 1]
		i = i - 1
		j = j + 1
		k += 2
	print(''.join(c))


import os
import sys
from atexit import register
from io import BytesIO
n = int(input())
word = input()
left = 1
decoded = ''
if n % 2 == 1:
	left = 0
decoded = word[0]
for i in range(1, n):
	if left == 0:
		decoded = word[i] + decoded
	else:
		decoded = decoded + word[i]
	left = 1 - left
print(decoded)


n = int(input())
word = input()
char = list(word)
decodedword = ''
for i in char:
	if n % 2 == 0:
		decodedword = i + decodedword
	else:
		decodedword = decodedword + i
	n -= 1
print(decodedword)


import sys
import os

def get_int():
	return map(int, input().split())

def get_array():
	return list(map(int, input().split()))

def str_replacer(old_str, new_str, index):
	if index in range(len(old_str)):
		return old_str[:index] + new_str + old_str[index + 1:]
	else:
		return old_str
if os.environ.get('DEBUGSTER_PYTHON'):
	sys.stdin = open('in.txt', 'r')
	sys.stdout = open('out.txt', 'w')
n = int(input())
w = input()
if n % 2 == 1:
	out = w[0]
	s = 1
else:
	out = w[0:2]
	s = 2
for i in range(s, n, 2):
	out = w[i] + out
	out = out + w[i + 1]
print(out)


a = int(input())
b = list(input())
s = []
for i in range(a):
	if a % 2 != 0:
		if i % 2 == 0:
			s.append(b[i])
		else:
			s.insert(0, b[i])
	elif i % 2 != 0:
		s.append(b[i])
	else:
		s.insert(0, b[i])
for i in s:
	print(i, end='')


n = int(input())
arr = list(input())
if n % 2 != 0:
	output = []
	for i in range(0, len(arr)):
		if i % 2 == 0:
			output.append(arr[i])
		else:
			output.insert(0, arr[i])
	print(''.join(output))
else:
	output = []
	for i in range(0, len(arr)):
		if i % 2 == 0:
			output.insert(0, arr[i])
		else:
			output.append(arr[i])
	print(''.join(output))


n = int(input())
s = list(input())
o = []
if len(s) % 2 == 0:
	ei = True
else:
	ei = False
for c in s:
	if ei:
		o.insert(0, c)
	else:
		o.append(c)
	ei = not ei
print(''.join(o))


import collections as CL
n = int(input())
s = input()
l = list(s)
d = CL.deque()
ans = []
if len(l) % 2 != 0:
	F = True
	for i in range(len(l)):
		if F:
			d.append(l[i])
			F = False
		else:
			d.appendleft(l[i])
			F = True
	ans = list(d)
else:
	F = False
	for i in range(len(l)):
		if F:
			d.append(l[i])
			F = False
		else:
			d.appendleft(l[i])
			F = True
	ans = list(d)
sx = ''
for i in ans:
	sx += i
print(sx)


n = int(input())
a = list(input())
ans = [a[0]]
c = 0
if n % 2 == 0:
	for i in range(1, n):
		if c == 0:
			ans.append(a[i])
			c = 1
		else:
			ans.insert(0, a[i])
			c = 0
else:
	for i in range(1, n):
		if c == 0:
			ans.insert(0, a[i])
			c = 1
		else:
			ans.append(a[i])
			c = 0
print(*ans, sep='')


n = int(input())
c = input()
if n % 2 == 0:
	w = c[0]
	flag = 1
	for i in range(1, n):
		if flag == 1:
			w += c[i]
			flag = 0
		else:
			w = c[i] + w
			flag = 1
else:
	w = c[0]
	for i in range(1, n, 2):
		w = c[i] + w
		w = w + c[i + 1]
print(w)


from math import floor, ceil
n = int(input())
s = input()
s = list(s)
a = ''
b = ''
for i in range(n - 2, -1, -2):
	a += s[i]
if n % 2:
	for i in range(0, n, 2):
		a += s[i]
else:
	for i in range(1, n, 2):
		a += s[i]
print(a)


n = int(input(''))
coded = input('')
ans = ''
if n % 2 != 0:
	for i in range(n):
		if i % 2 != 0:
			ans = coded[i] + ans
		else:
			ans = ans + coded[i]
else:
	for i in range(n):
		if i % 2 != 0:
			ans = ans + coded[i]
		else:
			ans = coded[i] + ans
print(ans)


n = int(input())
str1 = input()
a = [0] * n
if n % 2 == 0:
	mid = n // 2 - 1
else:
	mid = n // 2
c = 0
c1 = 1
a[mid] = str1[c]
c += 1
if n % 2 != 0:
	for i in range(n - 1):
		if i % 2 == 0:
			a[mid - c1] = str1[c]
		else:
			a[mid + c1] = str1[c]
			c1 += 1
		c += 1
else:
	for i in range(n - 1):
		if i % 2 == 1:
			a[mid - c1] = str1[c]
			c1 += 1
		else:
			a[mid + c1] = str1[c]
		c += 1
for i in a:
	print(i, end='')


import sys

def main():
	n = int(sys.stdin.readline())
	s = sys.stdin.readline().rstrip()
	r = ['a'] * n
	if n % 2 == 1:
		p = n // 2
		r[p] = s[0]
		j = 1
		for i in range(1, n, 2):
			r[p - j] = s[i]
			r[p + j] = s[i + 1]
			j += 1
	else:
		p = n // 2 - 1
		j = 1
		for i in range(0, n, 2):
			r[p - j + 1] = s[i]
			r[p + j] = s[i + 1]
			j += 1
	print(''.join(r))
main()


import math
n = int(input())
numbers = []
for x in range(1, n + 1):
	numbers.append(math.ceil(x / 2) - 1)
string = input()
string = string[::-1]
decoded = []
for x in range(n):
	decoded.insert(numbers[x], string[x])
print(''.join(decoded))


from collections import deque
x = int(input())
s = input()
q = deque([])
if not x % 2:
	for i in range(0, x, 2):
		q.appendleft(s[i])
		q.append(s[i + 1])
else:
	q.append(s[0])
	for i in range(1, x, 2):
		q.appendleft(s[i])
		q.append(s[i + 1])
print(''.join(q))


n = int(input())
s = input()
if len(s) % 2 == 1:
	a = s[::2]
	b = s[::-1]
	b = b[1::2]
	print(str(b) + str(a))
else:
	a = s[::2]
	b = s[::-1]
	b = b[0::2]
	print((str(b) + str(a))[::-1])


n = int(input())
s = input()
ans = []
an = [0] * n
if n % 2 == 1:
	ans.append(n // 2)
for i in range(n // 2 - 1, -1, -1):
	ans.append(i)
	ans.append(n - i - 1)
for i in range(n):
	an[ans[i]] = s[i]
print(''.join(an))


n = int(input())
s = input()
ans = [' '] * n
m = int((n - 1) / 2)
ans[m] = s[0]
c1 = 0
c2 = 0
if n % 2 == 0 and n > 2:
	b = 1
	for i in range(1, n):
		if b == 1:
			ans[m + i - c2] = s[i]
			b = 0
			c1 += 1
		elif b == 0:
			ans[m - i + c1] = s[i]
			b = 1
			c2 += 1
elif n % 2 == 1 and n > 2:
	b = 0
	for i in range(1, n):
		if b == 1:
			ans[m + i - c2] = s[i]
			b = 0
			c1 += 1
		elif b == 0:
			ans[m - i + c1] = s[i]
			b = 1
			c2 += 1
elif n <= 2:
	print(s)
	exit()
result = ''.join(ans)
print(result)


a = int(input())
b = input()
ans = ''
if a % 2 == 0:
	ans = b[0]
	for i in range(1, len(b)):
		if i & 1:
			ans = ans + b[i]
		else:
			ans = b[i] + ans
else:
	ans = b[0]
	for i in range(1, len(b)):
		if i & 1:
			ans = b[i] + ans
		else:
			ans = ans + b[i]
print(ans)


from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip
from math import sqrt, floor, factorial, gcd
from collections import deque, Counter, defaultdict
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
from collections import deque
input = lambda : sys.stdin.readline().rstrip('\r\n')
read = lambda : list(map(int, input().split(' ')))

def func(arr):
	return sum([arr[i] for i in range(0, len(arr), 2)])

def solve():
	n = int(input())
	s = input()
	ans = ''
	if not n % 2:
		for i in range(n):
			if i % 2:
				ans = ans + s[i]
			else:
				ans = s[i] + ans
	else:
		for i in range(n):
			if i % 2:
				ans = s[i] + ans
			else:
				ans = ans + s[i]
	print(ans)
solve()


n = int(input().rstrip())
s = input().rstrip()
if len(s) % 2:
	t = list()
	for i in range(n):
		if i % 2:
			t.insert(0, s[i])
		else:
			t.append(s[i])
	print(''.join(t))
else:
	t = list()
	for i in range(n):
		if i % 2:
			t.append(s[i])
		else:
			t.insert(0, s[i])
	print(''.join(t))


from operator import itemgetter
n = int(input())
s = input()
num = 0
num2 = 0
if n % 2 == 0:
	num = 1
	num2 = n // 2 - 1
else:
	num = -1
	num2 = n // 2
s2 = [''] * n
for i in range(n):
	s2[num2] = s[i]
	num2 += num
	z = 1
	if num > 0:
		z = -1
	num = -num + z
print(''.join(s2))


n = int(input())
s = input()
if len(s) % 2 != 0:
	ans = s[0]
	for (i, j) in zip(s[1::2], s[2::2]):
		ans = i + ans
		ans = ans + j
else:
	ans = ''
	for (i, j) in zip(s[::2], s[1::2]):
		ans = i + ans
		ans = ans + j
print(ans)


n = int(input())
s = input()
a = [None] * n
if n % 2:
	x = n // 2
	for i in range(n):
		if i % 2:
			x -= i
		else:
			x += i
		a[x] = s[i]
else:
	x = n // 2 - 1
	for i in range(n):
		if i % 2:
			x += i
		else:
			x -= i
		a[x] = s[i]
z = ''
for i in a:
	z += i
print(z)


n = int(input())
s = input()
g = s
m = n
a = ''
k = 0
while len(s) > 0:
	if len(s) % 2 == 1:
		a = a + g[k]
		k = k + 1
		s = g[k:]
	else:
		a = g[k] + a
		k = k + 1
		s = g[k:]
	n = len(s)
print(a)


def decode(str):
	ans = ''
	while len(str) > 0:
		if len(str) % 2 == 0:
			ans = str[0] + ans
			str = str.replace(str[0], '', 1)
		else:
			ans = ans + str[0]
			str = str.replace(str[0], '', 1)
	return ans
n = int(input())
print(decode(input()))


import os
import sys
from io import BytesIO, IOBase

def main():
	n = int(input())
	a = input()
	ans = []
	if n % 2 == 0:
		chk = 1
		ans.append(a[0])
		for x in range(1, n):
			if chk == 1:
				ans.append(a[x])
				chk = 0
			else:
				ans.insert(0, a[x])
				chk = 1
	else:
		chk = 1
		for x in range(n):
			if chk == 1:
				ans.append(a[x])
				chk = 0
			else:
				ans.insert(0, a[x])
				chk = 1
	print(''.join(ans))
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


n1 = int(input())
n = input()[:n1]
n = list(n)
l = ''
while len(n) > 0:
	if len(n) % 2 == 0:
		l = n[0] + l
	else:
		l = l + n[0]
	n.remove(n[0])
print(l)


amount = int(input())
string = input()
reverse = string[0]
turn = True if amount % 2 == 0 else False
for i in range(1, len(string)):
	if turn:
		reverse += string[i]
	else:
		reverse = string[i] + reverse
	turn = not turn
print(reverse)


n = int(input())
word = input().strip()
newWord = ''
for j in range(n):
	if n % 2 == 1 and j % 2 == 0 or (n % 2 == 0 and j % 2 == 1):
		newWord = newWord + word[j]
	else:
		newWord = word[j] + newWord
print(newWord)


n = int(input())
word = list(input())
res = ''
for i in range(len(word)):
	if n % 2 == 0:
		if i % 2 == 0:
			res = word[i] + res
		else:
			res += word[i]
	elif i % 2 == 0:
		res += word[i]
	else:
		res = word[i] + res
print(res)


n = int(input())
s = input()
ans = str()
itr = 0
while n > 0:
	if n % 2 == 1:
		ans = ans + s[itr]
	else:
		ans = s[itr] + ans
	itr += 1
	n -= 1
print(ans)


length = int(input())
word = input()
newWord = word[0]
if length % 2 == 0:
	for i in range(1, length):
		if i % 2 != 0:
			newWord += word[i]
		if i % 2 == 0:
			newWord = word[i] + newWord
else:
	for i in range(1, length):
		if i % 2 != 0:
			newWord = word[i] + newWord
		if i % 2 == 0:
			newWord += word[i]
print(newWord)


from sys import stdin, stdout
from collections import deque
n = int(input())
string = input()
result = deque([])
if n & 1:
	result.append(string[0])
	left = 1
	right = 0
	for i in range(1, n):
		if left == 1:
			result.appendleft(string[i])
			left = 0
			right = 1
		elif right == 1:
			result.append(string[i])
			left = 1
			right = 0
else:
	result.append(string[0])
	left = 0
	right = 1
	for i in range(1, n):
		if left == 1:
			result.appendleft(string[i])
			left = 0
			right = 1
		elif right == 1:
			result.append(string[i])
			left = 1
			right = 0
result = list(result)
print(''.join(result))


n = int(input())
s = input()
som = n
ch = ''
while som != 0:
	if som % 2 == 1:
		ch = ch + s[n - som]
	else:
		ch = s[n - som] + ch
	som -= 1
print(ch)


def main():
	n = int(input())
	s = input()
	if n < 3:
		print(s)
	else:
		new_s = []
		for i in range(n - 2, -1, -2):
			new_s += s[i]
		for i in range((n - 1) % 2, n, 2):
			new_s += s[i]
		print(''.join(new_s))
main()


n = int(input())
t = input()
p = []
for i in t:
	if n % 2 != 0:
		p.append(i)
		n -= 1
	else:
		p.insert(0, i)
		n -= 1
print(''.join(p))


n = int(input())
code = input()
ans = []
for _ in range(0, n):
	ans.append('0')
if n % 2 != 0:
	middle = n // 2
	left = middle - 1
	right = middle + 1
	index = 0
	ans[middle] = code[index]
	index += 1
	while index < n:
		if index % 2 != 0:
			ans[left] = code[index]
			left -= 1
			index += 1
		elif index % 2 == 0:
			ans[right] = code[index]
			right += 1
			index += 1
else:
	middle = n // 2 - 1
	index = 0
	ans[middle] = code[0]
	index += 1
	left = middle - 1
	right = middle + 1
	while index < n:
		if index % 2 != 0 and right < n:
			ans[right] = code[index]
			right += 1
			index += 1
		elif index % 2 == 0 and left > -1:
			ans[left] = code[index]
			left -= 1
			index += 1
		if left < 0:
			while right < n:
				ans[right] = code[index]
				right += 1
				index += 1
		if right > n:
			while left > -1:
				ans[left] = code[index]
				left -= 1
				index += 1
result = ''.join((x for x in ans))
print(result)


x = int(input())
a = input()
k = ''
for i in range(x):
	if (x - i) % 2 == 1:
		k = k + a[i]
	else:
		k = a[i] + k
print(k)


from collections import deque

def main():
	d = deque()
	n = int(input())
	s = list(input())
	for i in s:
		if n % 2 == 0:
			d.appendleft(i)
		else:
			d.append(i)
		n -= 1
	print(''.join(d))
main()


n = int(input())
s = input()
soln = ''
flag = n % 2
for i in range(n):
	if flag == 1:
		soln = soln + s[i]
	else:
		soln = s[i] + soln
	flag = 1 - flag
print(soln)


a = int(input())
s = input()
ans = ''
if a % 2 == 0:
	cnt = 0
else:
	cnt = 1
for i in s:
	cnt += 1
	if cnt % 2 == 1:
		ans = i + ans
	else:
		ans = ans + i
print(ans)


n = int(input())
shifr = input()
stroka = shifr[0]
i = 1
x = n
while i < x:
	if (n - 1) % 2 == 0:
		stroka = shifr[i] + stroka
	else:
		stroka = stroka + shifr[i]
	n = n - 1
	i = i + 1
print(stroka)


import sys
lines = sys.stdin.readlines()
n = int(lines[0].strip())
string = lines[1].strip()
mid = n // 2
if n % 2 == 0:
	res = ''
	for i in range(n):
		if i % 2 == 0:
			res = string[i] + res
		else:
			res += string[i]
else:
	res = string[0]
	for i in range(1, n):
		if i % 2 == 1:
			res = string[i] + res
		else:
			res += string[i]
print(res)


n = int(input())
st = [x for x in input()]
data = []
k = 1
if len(st) & 1:
	for x in st:
		if k == 0:
			data.insert(0, x)
			k = 1
		else:
			data.append(x)
			k = 0
else:
	for x in st:
		if k == 1:
			data.insert(0, x)
			k = 0
		else:
			data.append(x)
			k = 1
print(''.join(data))


s = int(input())
q = input()
f = list(' ' * s)
i = 0
for k in q:
	if s % 2 == 0:
		i = int(s / 2)
	else:
		i = int((s + 1) / 2)
	while f[i - 1] != ' ':
		i += 1
	f[i - 1] = k
	s -= 1
print(''.join(f))


input()
s = input().strip()
if len(s) % 2:
	print(s[1::2][::-1] + s[0::2])
else:
	print(s[0::2][::-1] + s[1::2])


from sys import stdin
n = int(stdin.readline().strip())
string = stdin.readline().strip()
ans = ''
l = n
for i in range(n):
	if l % 2:
		ans += string[i]
	else:
		ans = string[i] + ans
	l -= 1
print(ans)


n = int(input())
s = input()
if n % 2 == 0:
	print(s[::2][::-1] + s[1::2])
else:
	print(s[1::2][::-1] + s[::2])


def solve():
	input()
	ls = [x for x in input()]
	return ''.join(ls[-2::-2] + ls[not len(ls) & 1::2])
print(solve())


a = int(input())
s = input()
ans = ''
if a % 2 == 0:
	counter = False
else:
	counter = True
while len(s) > 0:
	if counter:
		ans += s[0]
		counter = False
	else:
		ans = s[0] + ans
		counter = True
	s = s[1:]
print(ans)


nu = int(input())
n = input()
ans = ''
if len(n) % 2 == 0:
	f = '-1'
	for i in range(len(n)):
		if f == 'r':
			ans = ans + n[i]
			f = 'l'
		elif f == 'l':
			ans = n[i] + ans
			f = 'r'
		elif f == '-1':
			ans = ans + n[i]
			f = 'r'
if len(n) % 2 == 1:
	f = '-1'
	for i in range(len(n)):
		if f == 'r':
			ans = ans + n[i]
			f = 'l'
		elif f == 'l':
			ans = n[i] + ans
			f = 'r'
		elif f == '-1':
			ans = ans + n[i]
			f = 'l'
print(ans)


n = int(input())
string = input()
l = ''
i = 1
if n % 2 != 0:
	index = n // 2
	l = string[0]
	while i < len(string):
		if i >= 0:
			p = string[i] + l[0:]
			l = p
			i += 1
		nindex = index + i
		if i < len(string):
			p = l[0:] + string[i]
			l = p
		i += 1
else:
	l = string[0]
	while i < len(string):
		if i >= 0:
			p = l[0:] + string[i]
			l = p
			i += 1
		if i < len(string):
			p = string[i] + l[0:]
			l = p
		i += 1
print(l)


n = int(input())
w = input()
x = ''
p = n % 2
for i in range(n):
	if i % 2 == p:
		x = w[i] + x
	else:
		x = x + w[i]
print(x)


x = int(input())
y = input()
z = y[0:x - 1]
for i in z[::-2]:
	print(i, end='')
if x % 2 == 1:
	for i in y[::2]:
		print(i, end='')
else:
	for i in y[1::2]:
		print(i, end='')


n = int(input())
s = list(input())
x = list(range(n))
mmax = n - 1
mmin = 0
for i in range(n):
	if i % 2 == 0:
		x[mmax] = s[-1]
		mmax -= 1
		s.pop()
	else:
		x[mmin] = s[-1]
		mmin += 1
		s.pop()
print(*x, sep='')


n = int(input())
a = input()
print(a[-2::-2] + a[1 - n % 2::2])


n = int(input())
s = input()
res = [0] * n
i = j = (n - 1) // 2
ch = 1
res[i] = s[0]
i -= 1
j += 1
if n % 2 == 0:
	while ch < n and i >= 0 and (j < n):
		if ch < n:
			res[j] = s[ch]
			ch += 1
		if i >= 0:
			res[i] = s[ch]
			ch += 1
		i -= 1
		j += 1
	if j < n:
		res[j] = s[ch]
else:
	while ch < n and i >= 0 and (j < n):
		if i >= 0:
			res[i] = s[ch]
			ch += 1
		if ch < n:
			res[j] = s[ch]
			ch += 1
		i -= 1
		j += 1
print(''.join(res))


def single_integer():
	return int(input())

def multi_integer():
	return map(int, input().split())

def string():
	return input()

def multi_string():
	return input().split()
n = single_integer()
s = string()
ans = ''
while s:
	if len(s) % 2 == 0:
		ans = s[0] + ans
	else:
		ans = ans + s[0]
	if len(s) == 1:
		break
	else:
		s = s[1:]
print(ans)


n = int(input())
a = input()
z = list(a)
if n == 1 or n == 2:
	print(a)
else:
	c = []
	if n % 2 != 0:
		for i in range(1, n + 1):
			if i % 2 != 0:
				c.append(z[i - 1])
			else:
				c.insert(0, z[i - 1])
	else:
		for i in range(1, n + 1):
			if i % 2 != 0:
				c.insert(0, z[i - 1])
			else:
				c.append(z[i - 1])
	print(''.join(c))


input()
s = input().strip()
r = ''
l = len(s)
for i in s:
	if l % 2 == 0:
		r = i + r
	else:
		r = r + i
	l -= 1
print(r)


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


n = int(input())
word = list(input())
final_name = [0] * n
word1 = word.copy()
if n % 2 == 0:
	j = 0
	i = 0
	k = 0
	temp = int(n / 2) - 1 + k
	while n > 0:
		del final_name[temp]
		final_name.insert(temp, word1[j])
		j += 1
		i += 1
		k = i * (-1) ** (j + 1)
		temp = temp + k
		n -= 1
else:
	j = 0
	i = 0
	k = 0
	temp = int(n / 2) + k
	while n > 0:
		del final_name[temp]
		final_name.insert(temp, word1[j])
		j += 1
		i += 1
		k = i * (-1) ** j
		temp = temp + k
		n -= 1
print(''.join(final_name))


n = int(input())
s = input().strip()
assert len(s) == n
ans = [None] * n
i = 0
if n % 2 == 1:
	ans[n // 2] = s[0]
	i += 1
	left = n // 2 - 1
	right = n // 2 + 1
else:
	left = n // 2 - 1
	right = n // 2
is_left = True
while i < n:
	ans[left if is_left else right] = s[i]
	if is_left:
		left -= 1
	else:
		right += 1
	is_left = not is_left
	i += 1
print(''.join(ans))


leng = input()
word = input()
leng = int(leng)
decoded = ''
c = 0
if leng % 2 == 0:
	for i in range(leng):
		i += 1
		if i <= leng / 2:
			decoded += word[-(i * 2)]
		else:
			decoded += word[int(i - leng / 2 + c)]
			c += 1
else:
	for i in range(leng):
		i += 1
		if i <= int(leng / 2):
			decoded += word[-(i * 2)]
		else:
			decoded += word[int(i - int(leng / 2) - 1 + c)]
			c += 1
print(decoded)


size = int(input())
s = str(input())
if len(s) == 1:
	print(s)
else:
	str1 = ''
	str2 = ''
	for i in range(0, len(s), 2):
		str1 += s[i]
	for i in range(1, len(s), 2):
		str2 += s[i]
	str2 = str2[::-1]
	out = str2 + str1
	if len(s) % 2 == 0:
		print(out[::-1])
	else:
		print(out)


import math
n = int(input())
a = list(input())
if n == 2 or n == 1:
	print(''.join(a))
else:
	w = a[n - 2:]
	w.insert(1, a[-3])
	a = a[:n - 3]
	a = a[::-1]
	for i in range(len(a)):
		p = math.ceil((len(w) - 1) / 2)
		w.insert(p, a[i])
	print(''.join(w))


n = int(input())
s = input()
ans = ''
f = 0
even = n % 2 == 0
if even:
	for i in s:
		if f == 0:
			ans = i + ans
		else:
			ans = ans + i
		f = not f
else:
	for i in s:
		if f == 1:
			ans = i + ans
		else:
			ans = ans + i
		f = not f
print(ans)


from collections import deque
n = int(input())
s = input()
a = deque()
if n % 2 == 1:
	for i in range(n):
		if i % 2 == 0:
			a.append(s[i])
		else:
			a.appendleft(s[i])
else:
	for i in range(n):
		if i % 2 == 1:
			a.append(s[i])
		else:
			a.appendleft(s[i])
a = list(a)
print(''.join(a))


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def main():
	n = I()
	s = S()
	q = collections.deque()
	if n % 2 == 1:
		q.append(s[0])
		s = s[1:]
	for i in range(n // 2):
		q.appendleft(s[i * 2])
		q.append(s[i * 2 + 1])
	return ''.join(q)
print(main())


n = int(input())
s = input()
if n < 3:
	print(s)
else:
	x = list(s[-2:])
	for i in range(len(s) - 3, -1, -1):
		x.insert(len(x) // 2, s[i])
	print(''.join(x))


n = int(input())
s = input()
a = [0 for i in range(n)]
if n % 2 == 0:
	a[n // 2 - 1] = s[0]
	mid = n // 2 - 1
	(k, j) = (mid - 1, mid + 1)
	c = 1
	for i in range(1, len(s)):
		if c % 2 != 0 and j < n:
			a[j] = s[i]
			c += 1
			j += 1
		elif c % 2 == 0 and k >= 0:
			a[k] = s[i]
			c += 1
			k -= 1
	w = ''
	for i in a:
		w = w + i
	print(w)
else:
	a[n // 2] = s[0]
	mid = n // 2
	(k, j) = (mid - 1, mid + 1)
	c = 1
	for i in range(1, len(s)):
		if c % 2 != 0 and j < n:
			a[j] = s[i]
			c += 1
			j += 1
		elif c % 2 == 0 and k >= 0:
			a[k] = s[i]
			c += 1
			k -= 1
	w = ''
	for i in a:
		w = w + i
	w = w[::-1]
	print(w)


(n, s, ans) = (int(input()), input(), '')
for c in s:
	if n % 2 == 0:
		ans = c + ans if len(ans) % 2 == 0 else ans + c
	else:
		ans = ans + c if len(ans) % 2 == 0 else c + ans
print(ans)


n = int(input())
from collections import deque
d = deque()
x = 1
if n % 2 == 0:
	for i in list(input()):
		if x % 2 == 0:
			d.append(i)
		else:
			d.appendleft(i)
		x += 1
	print(''.join(list(d)))
else:
	x = 0
	for i in list(input()):
		if x % 2 == 0:
			d.append(i)
		else:
			d.appendleft(i)
		x += 1
	print(''.join(list(d)))


lent = int(input())
inp = input()
out = ''
if lent % 2 == 0:
	for i in range(lent - 2, -1, -2):
		out += inp[i]
	for i in range(1, lent, 2):
		out += inp[i]
else:
	for i in range(lent - 2, -1, -2):
		out += inp[i]
	for i in range(0, lent + 1, 2):
		out += inp[i]
print(out)


n = int(input())
w = list(input())
ans = []
for i in range(n - 1, -1, -1):
	ans.insert(int(len(ans) / 2), w[i])
print(''.join(ans))


n = int(input())
a = list(input())
b = ''
if n % 2 != 0:
	while n - 2 > 0:
		b = str(b) + str(a[0])
		a.remove(a[0])
		b = str(a[0]) + str(b)
		a.remove(a[0])
		n -= 2
	b = b + a[0]
else:
	while n - 2 >= 0:
		b = str(a[0]) + str(b)
		a.remove(a[0])
		b = str(b) + str(a[0])
		a.remove(a[0])
		n -= 2
print(b)


import math

def change_char(s, p, r):
	return s[:p] + r + s[p + 1:]
n = int(input())
name = input()
temp = ' ' * n
counter = 0
left = int((n - 1) / 2)
right = int((n - 1) / 2)
check = True
if len(name) % 2 is 0:
	check = True
	right += 1
else:
	left -= 1
	check = False
while counter < n:
	if check:
		temp = change_char(temp, left, name[counter])
		left = left - 1
		check = False
	else:
		temp = change_char(temp, right, name[counter])
		right = right + 1
		check = True
	counter = counter + 1
print(temp)


int(input())
d = input()
print(d[-2::-2] + d[-1::-2][::-1])


n = int(input())
word = input()
l = [0 for i in range(n)]
i = 0
j = n - 1
while len(word) != 0 and len(word) != 1:
	l[i] = word[-2]
	l[j] = word[-1]
	word = word[:-2]
	i += 1
	j -= 1
if len(word) == 1:
	l[n // 2] = word[0]
print(''.join(l))


(L, s) = (input(), input())
(f, b) = ([], [])
for (i, c) in enumerate(s[::-1]):
	if i & 1:
		f = f + [c]
	else:
		b = [c] + b
print(''.join(f) + ''.join(b))


n = int(input())
l = list(str(input()))
ans = ''
if n % 2 != 0:
	while l != []:
		ans = ans + l[0]
		if len(l) >= 2:
			ans = l[1] + ans
			l.remove(l[1])
		l.remove(l[0])
	print(ans)
else:
	while l != []:
		ans = l[0] + ans
		if len(l) >= 2:
			ans = ans + l[1]
			l.remove(l[1])
		l.remove(l[0])
	print(ans)


n = int(input())
s = input()
temp = ''
i = 1
if len(s) % 2 != 0:
	for ch in s:
		if i % 2 != 0:
			temp = temp + ch
		else:
			temp = ch + temp
		i += 1
else:
	for ch in s:
		if i % 2 != 0:
			temp = ch + temp
		else:
			temp = temp + ch
		i += 1
print(temp)


n = int(input())
word = input()
new_w = [0] * n
if n % 2 == 1:
	middle = n // 2
	new_w[middle] = word[0]
	for i in range(1, middle + 1):
		new_w[middle - i] = word[2 * i - 1]
		new_w[middle + i] = word[2 * i]
	print(''.join(new_w))
else:
	new_w.append('')
	middle = (n + 1) // 2
	new_w[middle] = ''
	for i in range(1, middle + 1):
		new_w[middle - i] = word[2 * i - 2]
		new_w[middle + i] = word[2 * i - 1]
	print(''.join(new_w))


n = int(input())
strArr = input()
resStr = strArr[0]
count = 0
strLen = n
if strLen % 2 == 0:
	strLen = strLen - 1
for i in range(1, strLen, 2):
	if n % 2 == 0:
		resStr = strArr[i + 1] + resStr + strArr[i]
	else:
		resStr = strArr[i] + resStr + strArr[i + 1]
if n % 2 == 0:
	resStr = resStr + strArr[-1]
print(resStr)


n = int(input())
l = input()
s = ''
x = []
for i in range(n):
	x.append(l[n - 1])
c = n
for i in range(n):
	if c % 2 != 0:
		x[n - int(c / 2) - 1] = l[i]
	if c % 2 == 0:
		x[int(c / 2) - 1] = l[i]
	c -= 1
for i in range(n):
	s += x[i]
print(s)


n = int(input())
word = input()
mid = (n - 1) // 2
left = mid - 1
right = mid + 1
leftside = bool(n % 2)
idx = [i for i in range(n)]
encoded_idx = [mid]
while left >= 0 or right <= n - 1:
	if leftside:
		if left >= 0:
			encoded_idx.append(idx[left])
			left -= 1
		else:
			encoded_idx.append(idx[right])
			right += 1
	elif right <= n - 1:
		encoded_idx.append(idx[right])
		right += 1
	else:
		encoded_idx.append(idx[left])
		left -= 1
	leftside = not leftside
decoded = list(word)
for i in range(len(encoded_idx)):
	decoded[encoded_idx[i]] = word[i]
print(''.join(decoded))


import math
n = int(input())
s = input()
if n == 2:
	r = s
elif n % 2 == 0:
	r = s[-2::-2] + s[1::2]
else:
	r = s[-2::-2] + s[::2]
print(r)


n = int(input())
encoding = input()

def decode(encoding):
	(decoded, beginning) = ('', True)
	if n % 2 == 1:
		(decoded, encoding) = (encoding[0], encoding[1:])
	for letter in encoding:
		decoded = letter + decoded if beginning else decoded + letter
		beginning = not beginning
	return decoded
print(decode(encoding))


n = int(input())
s = input()
s_ = s[::-1]
arrstr_d = []
arrstr_i = []
faux = True
for l in s_:
	if faux:
		arrstr_d.insert(0, l)
		faux = False
	else:
		arrstr_i.append(l)
		faux = True
print(''.join(arrstr_i) + ''.join(arrstr_d))


n = int(input())
slovo = input()
otvet = ''
while slovo != '':
	en = slovo[0]
	if len(slovo) % 2 == 1:
		otvet = otvet + en
	else:
		otvet = en + otvet
	slovo = slovo[1:]
print(otvet)


n = int(input())
letras = list(map(str, input()))
letras_copy = letras.copy()
index_letras = [i for i in range(n)]
decoding = []
while len(letras) != 0:
	decoding.append(index_letras[(len(letras) - 1) // 2])
	index_letras.pop((len(letras) - 1) // 2)
	letras.pop((len(letras) - 1) // 2)
ans = [(i, l) for (i, l) in zip(decoding, letras_copy)]
ans.sort(key=lambda i: i[0])
saida = [l for (i, l) in ans]
print(''.join(saida))


from math import sqrt

def main():
	n = int(input())
	d = input()
	if n % 2 == 0:
		s = d[0:2]
		for i in range(2, n):
			if i % 2 != 0:
				s += d[i]
			else:
				s = d[i] + s
	else:
		s = d[0:1]
		for i in range(1, n):
			if i % 2 == 0:
				s += d[i]
			else:
				s = d[i] + s
	print(s)
main()


n = int(input())
string = list(input())
newString = ''
if len(string) % 2 == 1:
	for char in string:
		if len(newString) % 2 == 0:
			newString += char
		else:
			newString = char + newString
else:
	for char in string:
		if len(newString) % 2 == 0:
			newString = char + newString
		else:
			newString += char
print(newString)


n = int(input())
s = input()
left = ''
right = ''
c = 1
for i in range(len(s) - 1, -1, -1):
	if c:
		right += s[i]
		c = 0
	else:
		left += s[i]
		c = 1
right = reversed(right)
rev = ''.join(right)
ans = left + rev
print(ans)


n = int(input())
slovo = input()
a = ''
z = 1 if n % 2 != 0 else -1
for i in range(n):
	if z > 0:
		a += slovo[0]
	else:
		a = slovo[0] + a
	slovo = slovo[1:]
	z *= -1
print(a)


n = int(input())
st = input()
decode = []
if n % 2:
	decode.append(st[0])
	st = st[1:]
turn = 0
for i in st:
	if turn == 0:
		decode = [i] + decode
		turn = 1
	else:
		decode.append(i)
		turn = 0
print(''.join(decode))


n = int(input())
s = input()
l = []
for i in s:
	l.append(i)
p = ''
i = 0
while l != []:
	if len(l) % 2 == 0:
		p += l.pop(i)
	else:
		p = l.pop(i) + p
print(p[::-1])


from __future__ import division, print_function
from sys import stdin, stdout
import itertools, os, sys, threading
from collections import deque, Counter, OrderedDict, defaultdict
import heapq
from math import ceil, floor, log, sqrt, factorial, pow, pi, gcd
from fractions import Fraction

def ii():
	return int(input())

def si():
	return str(input())

def mi():
	return map(int, input().split())

def li():
	return list(mi())

def fii():
	return int(stdin.readline())

def fsi():
	return str(stdin.readline())

def fmi():
	return map(int, stdin.readline().split())

def fli():
	return list(fmi())
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod = 1000000007
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def getKey(item):
	return item[0]

def sort2(l):
	return sorted(l, key=getKey)

def d2(n, m, num):
	return [[num for x in range(m)] for y in range(n)]

def isPowerOfTwo(x):
	return x and (not x & x - 1)

def decimalToBinary(n):
	return bin(n).replace('0b', '')

def ntl(n):
	return [int(i) for i in str(n)]

def powerMod(x, y, p):
	res = 1
	x %= p
	while y > 0:
		if y & 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x
graph = defaultdict(list)
visited = [0] * 1000000
col = [-1] * 1000000

def dfs(v, c):
	if visited[v]:
		if col[v] != c:
			print('-1')
			exit()
		return
	col[v] = c
	visited[v] = 1
	for i in graph[v]:
		dfs(i, c ^ 1)

def bfs(d, v):
	q = []
	q.append(v)
	visited[v] = 1
	while len(q) != 0:
		x = q[0]
		q.pop(0)
		for i in d[x]:
			if visited[i] != 1:
				visited[i] = 1
				q.append(i)
		print(x)

def make_graph(e):
	d = {}
	for i in range(e):
		(x, y) = mi()
		if x not in d.keys():
			d[x] = [y]
		else:
			d[x].append(y)
		if y not in d.keys():
			d[y] = [x]
		else:
			d[y].append(x)
	return d

def gr2(n):
	d = {}
	for i in range(n):
		(x, y) = mi()
		if x not in d.keys():
			d[x] = [y]
		else:
			d[x].append(y)
	return d

def connected_components(graph):
	seen = set()

	def dfs(v):
		vs = set([v])
		component = []
		while vs:
			v = vs.pop()
			seen.add(v)
			vs |= set(graph[v]) - seen
			component.append(v)
		return component
	ans = []
	for v in graph:
		if v not in seen:
			d = dfs(v)
			ans.append(d)
	return ans

def primeFactors(n):
	s = set()
	while n % 2 == 0:
		s.add(2)
		n = n // 2
	for i in range(3, int(sqrt(n)) + 1, 2):
		while n % i == 0:
			s.add(i)
			n = n // i
	if n > 2:
		s.add(n)
	return s

def find_all(a_str, sub):
	start = 0
	while True:
		start = a_str.find(sub, start)
		if start == -1:
			return
		yield start
		start += len(sub)
n = ii()
s = si()
t = [s[0]]
for i in range(1, n):
	if i % 2 == 0:
		t.append(s[i])
	else:
		t.insert(0, s[i])
t = ''.join(t)
if n % 2 == 0:
	print(t[::-1])
else:
	print(t)


import sys

def input():
	return sys.stdin.readline().rstrip('\r\n')

def List():
	return list(map(int, input().split()))

def Num():
	return int(input())
n = Num()
s = input()
if n & 1:
	(odd, even) = ('', '')
	for i in range(n):
		if i & 1:
			odd += s[i]
		else:
			even += s[i]
	print(odd[::-1] + even)
else:
	(first, second) = ('', '')
	for i in range(n):
		if i & 1:
			second += s[i]
		else:
			first = s[i] + first
	print(first + second)


n = int(input())
s = input()
new = s[0]
s = s[1:]
for i in range(n):
	t = len(s)
	if t == 0:
		print(new[::-1])
		break
	if t / 2 == t // 2:
		new = new + s[0]
		s = s[1:]
	else:
		new = s[0] + new
		s = s[1:]


(n, s) = (int(input()), input())
r = n * ['x']
r[(n - 1) // 2] = s[0]
if n % 2 == 0:
	r[n // 2] = s[1]
j = 1 if n % 2 else 2
for i in range((n - 1) // 2 - 1, -1, -1):
	r[i] = s[j]
	r[n - 1 - i] = s[j + 1]
	j += 2
print(''.join(r))


n = int(input())
ind = (n - 1) // 2
a = [0] * n
s = input()
inc = 1
t = -1
if n % 2 == 0:
	t = 1
for i in s:
	a[ind] = i
	ind += t * inc
	t *= -1
	inc += 1
print(''.join(a))


ln = int(input()) % 2
s = list(input())
ans = []
for i in s:
	if ln == 1:
		ans.append(i)
	else:
		ans.insert(0, i)
	ln ^= 1
print(''.join(ans))


a = int(input())
n = input()
l = list(n)
s = []
s.append(l[0])
if a % 2 != 0:
	for i in range(1, a):
		if i % 2 == 0:
			s.append(l[i])
		else:
			s.insert(0, l[i])
else:
	for i in range(1, a):
		if i % 2 != 0:
			s.append(l[i])
		else:
			s.insert(0, l[i])
for i in s:
	print(str(i), end='')


n = int(input())
a = input()
b = [0 for x in range(n)]
if n % 2 == 0:
	med = n // 2 - 1
	key = False
else:
	med = n // 2
	key = True
temp = med
counter = 1
for i in range(n):
	b[temp] = a[i]
	if key == True:
		temp -= counter
		key = False
	else:
		temp += counter
		key = True
	counter += 1
print(''.join(map(str, b)))


n = int(input())
crypted_word = input()
decrypted_word = ''
for i in range(-2, -n - (1 if not n % 2 else 0), -2):
	decrypted_word += crypted_word[i]
for i in range(0 if n % 2 else 1, n, 2):
	decrypted_word += crypted_word[i]
print(decrypted_word)


x = int(input())
y = list(input())
p = []
if x == 1 or x == 2:
	p = y
elif x % 2 == 0:
	a = 0
	b = 1
	p.append(''.join(y[0:2]))
	while len(p) != len(y) - 1:
		a += 2
		b += 2
		p.insert(0, y[a])
		p.append(y[b])
elif x % 2 != 0:
	p.append(y[0])
	a = 1
	b = 2
	while len(p) != len(y):
		p.insert(0, y[a])
		p.append(y[b])
		a += 2
		b += 2
print(''.join(p))


n = int(input())
x = input()
l = []
if len(x) % 2 != 0:
	for i in range(n):
		if i % 2 == 1:
			l.insert(0, x[i])
		else:
			l.append(x[i])
	print(''.join(l))
else:
	for i in range(n):
		if i % 2 == 0:
			l.insert(0, x[i])
		else:
			l.append(x[i])
	print(''.join(l))


n = int(input())
s = list(input())
ans = ''
if len(s) % 2 != 0:
	i = 0
	while len(s) != 0:
		if i % 2 == 0:
			ans = ans + s[0]
			s.pop(0)
		else:
			ans = s[0] + ans
			s.pop(0)
		i += 1
else:
	i = 0
	while len(s) != 0:
		if i % 2 == 0:
			ans = s[0] + ans
			s.pop(0)
		else:
			ans = ans + s[0]
			s.pop(0)
		i += 1
print(ans)


from collections import deque
n = int(input())
s = input()
result = deque(s[0])
right = n % 2 == 0
for i in range(1, n):
	if right:
		result.append(s[i])
		right = False
	else:
		result.appendleft(s[i])
		right = True
print(''.join(list(result)))


n = input()
s = input()
n = int(n)
s = list(s)
sans = []
sans.append(s[0])
s.pop(0)
l = 1
if n % 2 == 0:
	while l != n:
		sans.insert(l + 1, s[0])
		s.pop(0)
		l += 1
		if s != []:
			sans.insert(0, s[0])
			s.pop(0)
			l += 1
else:
	while l != n:
		sans.insert(0, s[0])
		s.pop(0)
		l += 1
		sans.insert(l + 1, s[0])
		s.pop(0)
		l += 1
for i in sans:
	print(i, end='')


(n, s) = (int(input()), input())
print(s[-2::-2] + s[n % 2 == 0::2])


n = int(input())
s = input()
if n % 2 == 1:
	x = ''.join(reversed(s[1:n:2]))
	x = x + s[0:n + 1:2]
	print(x)
else:
	x = ''.join(reversed(s[0:n:2]))
	x = x + s[1:n + 1:2]
	print(x)


n = int(input())
string = input()
state = n % 2
i = 0
new_string = ''
if state:
	while n > 0:
		if n % 2 == state:
			new_string = new_string + string[i]
		else:
			new_string = string[i] + new_string
		i += 1
		n -= 1
else:
	while n > 0:
		if n % 2 == state:
			new_string = string[i] + new_string
		else:
			new_string = new_string + string[i]
		i += 1
		n -= 1
print(new_string)


n = int(input())
encoded = list(input())
(left, right) = ('', '')
while True:
	try:
		right = encoded[-1] + right
		encoded.pop()
		left += encoded[-1]
		encoded.pop()
	except:
		break
print(left + right)


n = int(input())
str0 = input()
if n == 1 or n == 2:
	print(str0)
	exit(0)
L0 = list(str0)
L = []
L.append(L0[0])
L0.pop(0)
if n % 2 != 0:
	for i in range(n - 1):
		if i % 2 == 0:
			L.insert(0, L0[0])
			L0.pop(0)
		else:
			L.insert(n, L0[0])
			L0.pop(0)
else:
	for i in range(n - 1):
		if i % 2 != 0:
			L.insert(0, L0[0])
			L0.pop(0)
		else:
			L.insert(n, L0[0])
			L0.pop(0)
result = ''.join(L)
print(result)


n = int(input())
s = input()
x = ''
y = ''
if n % 2 == 0:
	a = s[::-1]
	x = a[1::2]
	y = s[1::2]
	print(x + y)
else:
	a = s[::-1]
	x = a[1::2]
	y = s[0::2]
	print(x + y)


a = int(input())
s = input()
t = ''
t1 = ''
while a > 0:
	if a == 1:
		t += s[0]
	else:
		t += s[a - 2]
		t1 = s[a - 1] + t1
	a -= 2
res = t + t1
print(res)


length = int(input())
word = list(input())
word.reverse()
newword = [None] * length
startpointer = 0
endpointer = length - 1
for (i, char) in enumerate(word):
	if i % 2 == 0:
		newword[endpointer] = char
		endpointer -= 1
	elif i % 2 == 1:
		newword[startpointer] = char
		startpointer += 1
print(''.join(newword))


n = int(input())
word = input()
res = [''] * n
c = 0
d = 1
for i in range(n):
	if n % 2 != 0:
		if i % 2 == 0:
			res[n // 2 + c] = word[i]
			c += 1
		else:
			res[n // 2 - d] = word[i]
			d += 1
	elif i % 2 == 0:
		res[n // 2 - 1 - c] = word[i]
		c += 1
	else:
		res[n // 2 - 1 + d] = word[i]
		d += 1
res = ''.join(res)
print(res)


q = int(input())
s = input()
d = ''
i = 0
while i < q:
	if i % 2 == 1:
		d = s[i] + d
	else:
		d += s[i]
	i += 1
print(d if q % 2 == 1 else d[::-1])


(n, s, t, k) = (int(input()), str(input()), '', True)
k = n % 2 == 1
for c in s:
	(t, k) = (t + c if k else c + t, not k)
print(t)


n = int(input())
code = str(input())
decode = str()
for i in range(n):
	if (n - i) % 2:
		decode = decode + code[i]
	else:
		decode = code[i] + decode
print(decode)


import math

def getOriginalString(s):
	n = len(s)
	arr = [0] * n
	count = 0
	for i in range(n):
		if (n - i) % 2 == 0:
			arr[int((n - i) / 2 - 1)] = s[i]
		else:
			arr[math.floor((n - i) / 2) + count] = s[i]
		count += 1
	return ''.join(arr)
n = input()
string = input()
print(getOriginalString(string))


n = int(input())
s = list(input())
med = s[len(s) // 2]
s0 = ''
if len(s) % 2 == 1:
	s0 += s.pop(0)
while len(s) != 0:
	s0 = s.pop(0) + s0
	s0 += s.pop(0)
print(s0)


n = int(input())
d = input()
a = ''
i = 0
while i < n:
	if (n - i) % 2 != 0:
		a = a + d[i]
	else:
		a = d[i] + a
	i += 1
print(a)


n = int(input())
x = input()
if n % 2 == 1:
	ans = x[0]
	for i in range(1, n):
		if i % 2 == 1:
			ans = x[i] + ans
		else:
			ans = ans + x[i]
	print(ans)
else:
	ans = x[:2]
	for i in range(2, n):
		if i % 2 == 0:
			ans = x[i] + ans
		else:
			ans = ans + x[i]
	print(ans)


n = int(input())
s = input().strip()
ans = ''
if n % 2 != 0:
	for i in range(0, len(s), 2):
		ans += s[i]
		if i + 1 < len(s):
			ans = s[i + 1] + ans
else:
	for i in range(0, len(s), 2):
		ans += s[i + 1]
		ans = s[i] + ans
print(ans)


N = int(input())
kata = input()
tamp = []
mun = len(kata) - 1
maj = 0
for i in range(N):
	tamp.append('')
if len(kata) % 2 == 0:
	for i in range(len(kata) - 1, -1, -1):
		if i % 2 == 1:
			tamp[mun] = kata[i]
			mun -= 1
		else:
			tamp[maj] = kata[i]
			maj += 1
else:
	for i in range(len(kata) - 1, -1, -1):
		if i % 2 == 0:
			tamp[mun] = kata[i]
			mun -= 1
		else:
			tamp[maj] = kata[i]
			maj += 1
for i in range(len(kata)):
	print(tamp[i], end='')


n = int(input())
s = input().rstrip()
result = [0] * n
mid = n // 2
j = 0
i = 0
if n % 2 == 0:
	mid -= 1
	while i < n:
		result[mid - j] = s[i]
		j += 1
		i += 1
		if mid + j >= n:
			break
		result[mid + j] = s[i]
		i += 1
	print(''.join(result))
	exit()
while i < n:
	if mid + j >= n:
		break
	result[mid + j] = s[i]
	i += 1
	j += 1
	if i == n or j == n:
		break
	result[mid - j] = s[i]
	i += 1
print(''.join(result))


n = int(input())
s = input()
if n == 1:
	print(s)
	exit()
r = ''
r = r + s[0]
s = s[1:]
while len(s) != 1:
	n = len(s)
	if n % 2 == 0:
		r = s[0] + r
	else:
		r = r + s[0]
	s = s[1:]
r = r + s[0]
print(r)


n = int(input())
s = str(input())
l = list(s)
s1 = []
for i in range(n):
	if (n + i) % 2 == 0:
		s1 = l[i:i + 1] + s1
	else:
		s1 = s1 + l[i:i + 1]
print(''.join(s1))


from collections import deque
input()
s = input()
reconstructed = deque()
for i in range(len(s)):
	if i % 2 == 0:
		reconstructed.append(s[i])
	else:
		reconstructed.appendleft(s[i])
if len(s) % 2 == 0:
	reconstructed.reverse()
print(''.join(reconstructed))


n = int(input())
s = input()
ans = [''] * len(s)
if n % 2:
	ans[n // 2] = s[0]
cur = n % 2
l = n // 2 - 1
r = n // 2 + n % 2
while l >= 0:
	(ans[l], ans[r]) = (s[cur], s[cur + 1])
	cur += 2
	(l, r) = (l - 1, r + 1)
print(''.join(ans))


import sys
n = int(sys.stdin.readline())
s = str(sys.stdin.read(n))
m = (n - 1) // 2
odd = n % 2 + 1
res = [''] * n
for (i, c) in enumerate(s):
	ni = m + (i + 1) // 2 * (-1) ** (i + odd)
	res[ni] = c
print(''.join(res))


n = int(input())
s = input()
s_o = ['' for _ in range(len(s))]
m = len(s) / 2
c = 0
if len(s) % 2 == 1:
	s_o[len(s) // 2] = s[0]
	c = 1
l = (len(s) - c) // 2 - 1
h = (len(s) - c) // 2 + (1 if len(s) % 2 == 1 else 0)
while l != -1 or h != len(s):
	if m - l <= h - m:
		s_o[l] = s[c]
		l -= 1
	else:
		s_o[h] = s[c]
		h += 1
	c += 1
s_o.reverse()
print(''.join(s_o))


import math
n = int(input())
s = str(input())
if len(s) == 1 or len(s) == 2:
	print(s)
else:
	l = [0] * len(s)
	n = len(s)
	j = 0
	s1 = list(s)
	mid = int(math.ceil(n / 2) - 1)
	while len(s1) > 2:
		if len(s1) % 2 == 0:
			i = int(len(s1) / 2) - 1
		else:
			i = int(math.ceil(len(s1) / 2) - 1)
		if l[i] == 0:
			l[i] = s1[0]
		else:
			l[n - i - 1] = s1[0]
		s1.remove(s1[0])
		j = j + 1
	l[0] = s1[0]
	l[n - 1] = s1[1]
	s = ''.join(map(str, l))
	print(str(s))


from math import ceil
n = int(input())
string = input()
res = []
to_end = n % 2
for i in string:
	if to_end:
		res.append(i)
	else:
		res.insert(0, i)
	to_end = not to_end
print(*res, sep='')


a = int(input())
s = str(input())
A = [0] * a
for i in range(a):
	A[i] = i
B = [' '] * a
for i in range(a):
	index = A[(len(A) - 1) // 2]
	A[(len(A) - 1) // 2] = s[i]
	B[index] = s[i]
	A.remove(s[i])
print(''.join(B))


(n, a, i) = (int(input()), list(input()), 0)
(b, n) = ([''] * n, n - 1)
while n >= i:
	b[n] = a.pop()
	if len(a) == 0:
		break
	b[i] = a.pop()
	(i, n) = (i + 1, n - 1)
print(*b, sep='')


n = int(input())
s = input()
d = {}
for i in range(1, n + 1):
	d[i] = ''
for i in s:
	m = n / 2
	n -= 1
	d[m] = i
ans = ''
for key in d.keys():
	ans += d[key]
print(ans)


x = int(input())
a = input()
b = '1' * x
c = list(b)
for i in range(x):
	c[b.find('1', (len(a) - 1) // 2)] = a[0]
	b = ''.join(c)
	a = a.replace(a[0], '', 1)
print(b)


n = int(input())
b = input()
c = b[0]
if n % 2 != 0:
	for i in range(1, n):
		if i % 2 == 0:
			c = c + b[i]
		else:
			c = b[i] + c
else:
	for i in range(1, n):
		if i % 2 == 0:
			c = b[i] + c
		else:
			c = c + b[i]
print(c)


input()
s = input().strip()
k = len(s) % 2
print(s[k::2][::-1] + s[k ^ 1::2])


import math

def get_seq(n):
	l = [0] * n
	r = 1
	center = (n - 1) // 2
	l[0] = center
	for i in range(2, n, 2):
		if n % 2 == 0:
			l[center - r] = i
			l[center + r] = i - 1
		else:
			l[center - r] = i - 1
			l[center + r] = i
		r += 1
	if n % 2 == 0:
		l[center + r] = n - 1
	return l
n = int(input())
s = input()
seq = get_seq(n)
res = [None] * n
for i in range(n):
	res[i] = s[seq[i]]
print(''.join(res))


n = int(input())
s = list(input())
r = [' '] * n
curr = (len(s) - 1) // 2
if n % 2 == 1:
	for i in range(n):
		r[curr] = s[i]
		if i % 2 == 0:
			curr -= i + 1
		else:
			curr += i + 1
else:
	for i in range(n):
		r[curr] = s[i]
		if i % 2 != 0:
			curr -= i + 1
		else:
			curr += i + 1
print(''.join(r))


(n, s) = (int(input()), input())
ans = [0] * n
mid = n // 2 - 1 if n % 2 == 0 else n // 2
jump = 1
i = 0
sign = 1 if n % 2 == 0 else -1
while mid >= 0 and mid < n:
	ans[mid] = s[i]
	i += 1
	mid += sign * jump
	jump += 1
	sign *= -1
print(*ans, sep='')


n = int(input())
s = list(input())
a = [''] * n
if n % 2 == 0:
	x = n // 2
	x -= 1
	for i in range(n // 2):
		q = s[2 * i]
		w = s[2 * i + 1]
		a[x - i] = q
		a[x + 1 + i] = w
else:
	x = n // 2
	a[x] = s[0]
	for i in range(1, x + 1):
		a[x - i] = s[2 * i - 1]
		a[x + i] = s[2 * i]
print(''.join(a))


n = int(input())
e = str(input())
s = []
for i in range(n):
	s.append(' ')
l = r = n // 2 - 1 if n % 2 == 0 else n // 2
s[l] = e[0]
for k in range(n - 1):
	if k % 2 == n % 2:
		s[r + 1] = e[k + 1]
		r += 1
	else:
		s[l - 1] = e[k + 1]
		l -= 1
print(''.join(s))


def solve():
	n = int(input())
	encoded = input()
	decoded = [''] * n
	is_even = n % 2 == 0
	mid = n // 2 - 1 if is_even else n // 2
	decoded[mid] = encoded[0]
	q = -1 if is_even else 1
	for i in range(1, mid + 1):
		decoded[mid - i * q] = encoded[2 * i - 1]
		decoded[mid + i * q] = encoded[2 * i]
	decoded[-1] = encoded[-1]
	print(''.join(decoded))
solve()


a = int(input())
b = input()

def midol(length, word):
	ret = ''
	if length % 2 == 0:
		for i in range(length):
			if i % 2 == 0:
				ret = word[i] + ret
			else:
				ret = ret + word[i]
	else:
		for i in range(length):
			if i % 2 != 0:
				ret = word[i] + ret
			else:
				ret = ret + word[i]
	return ret
print(midol(a, b))


import sys
import bisect
from collections import deque
RI = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()

def input():
	return sys.stdin.readline().strip()

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def INT():
	return int(input())

def MAP():
	return map(int, input().split())

def LIST(N=None):
	return list(MAP()) if N is None else [INT() for i in range(N)]

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('YES')

def NO():
	print('NO')
INF = 10 ** 18
MOD = 10 ** 9 + 7
n = int(ri())
s = ri()
ans = deque([])
start = 0
if n % 2 == 1:
	ans.append(s[0])
	start = 1
else:
	start = 0
while start < n:
	ans.appendleft(s[start])
	ans.append(s[start + 1])
	start += 2
print(''.join(ans))


x = int(input())
z = input()
h = len(z) - 1
n = ['.'] * x
f = x - 1
m = 0
if x % 2 != 0:
	while h >= 0:
		if h % 2 == 0:
			n[f] = z[h]
			f -= 1
		else:
			n[m] = z[h]
			m += 1
		h -= 1
	z = 0
	while z < len(n):
		print(n[z], end='')
		z += 1
else:
	while h >= 0:
		if h % 2 != 0:
			n[f] = z[h]
			f -= 1
		else:
			n[m] = z[h]
			m += 1
		h -= 1
	z = 0
	while z < len(n):
		print(n[z], end='')
		z += 1


input()
S = input()
Answer = ''
for i in range(S.__len__()):
	if S.__len__() % 2 != 0:
		Answer = Answer + S[i] if i % 2 == 0 else S[i] + Answer
	else:
		Answer = Answer + S[i] if i % 2 != 0 else S[i] + Answer
print(Answer)


n = int(input())
s = input()
f = bool(n % 2)
rt = []
lt = []
for i in s:
	if f:
		rt.append(i)
	else:
		lt.append(i)
	f = not f
print(''.join(lt[::-1]) + ''.join(rt))


n = int(input())
l = input()
if len(l) == 1:
	print(l)
	exit()
st = ''
fi = ''
if n % 2 == 0:
	st += l[0]
	fi += l[1]
	for i in range(2, len(l)):
		if i % 2 == 0:
			st += l[i]
		else:
			fi += l[i]
	print(st[::-1] + fi)
else:
	st += l[1]
	fi += l[0]
	for i in range(2, len(l)):
		if i % 2 != 0:
			st += l[i]
		else:
			fi += l[i]
	print(st[::-1] + fi)


import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
from collections import deque
import threading
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

class SegmentTree:

	def __init__(self, data, default=-10 ** 6, func=lambda a, b: max(a, b)):
		self._default = default
		self._func = func
		self._len = len(data)
		self._size = _size = 1 << (self._len - 1).bit_length()
		self.data = [default] * (2 * _size)
		self.data[_size:_size + self._len] = data
		for i in reversed(range(_size)):
			self.data[i] = func(self.data[i + i], self.data[i + i + 1])

	def __delitem__(self, idx):
		self[idx] = self._default

	def __getitem__(self, idx):
		return self.data[idx + self._size]

	def __setitem__(self, idx, value):
		idx += self._size
		self.data[idx] = value
		idx >>= 1
		while idx:
			self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
			idx >>= 1

	def __len__(self):
		return self._len

	def query(self, start, stop):
		if start == stop:
			return self.__getitem__(start)
		stop += 1
		start += self._size
		stop += self._size
		res = self._default
		while start < stop:
			if start & 1:
				res = self._func(res, self.data[start])
				start += 1
			if stop & 1:
				stop -= 1
				res = self._func(res, self.data[stop])
			start >>= 1
			stop >>= 1
		return res

	def __repr__(self):
		return 'SegmentTree({0})'.format(self.data)

class SegmentTree1:

	def __init__(self, data, default=10 ** 6, func=lambda a, b: min(a, b)):
		self._default = default
		self._func = func
		self._len = len(data)
		self._size = _size = 1 << (self._len - 1).bit_length()
		self.data = [default] * (2 * _size)
		self.data[_size:_size + self._len] = data
		for i in reversed(range(_size)):
			self.data[i] = func(self.data[i + i], self.data[i + i + 1])

	def __delitem__(self, idx):
		self[idx] = self._default

	def __getitem__(self, idx):
		return self.data[idx + self._size]

	def __setitem__(self, idx, value):
		idx += self._size
		self.data[idx] = value
		idx >>= 1
		while idx:
			self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
			idx >>= 1

	def __len__(self):
		return self._len

	def query(self, start, stop):
		if start == stop:
			return self.__getitem__(start)
		stop += 1
		start += self._size
		stop += self._size
		res = self._default
		while start < stop:
			if start & 1:
				res = self._func(res, self.data[start])
				start += 1
			if stop & 1:
				stop -= 1
				res = self._func(res, self.data[stop])
			start >>= 1
			stop >>= 1
		return res

	def __repr__(self):
		return 'SegmentTree({0})'.format(self.data)
MOD = 10 ** 9 + 7

class Factorial:

	def __init__(self, MOD):
		self.MOD = MOD
		self.factorials = [1, 1]
		self.invModulos = [0, 1]
		self.invFactorial_ = [1, 1]

	def calc(self, n):
		if n <= -1:
			print('Invalid argument to calculate n!')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		if n < len(self.factorials):
			return self.factorials[n]
		nextArr = [0] * (n + 1 - len(self.factorials))
		initialI = len(self.factorials)
		prev = self.factorials[-1]
		m = self.MOD
		for i in range(initialI, n + 1):
			prev = nextArr[i - initialI] = prev * i % m
		self.factorials += nextArr
		return self.factorials[n]

	def inv(self, n):
		if n <= -1:
			print('Invalid argument to calculate n^(-1)')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		p = self.MOD
		pi = n % p
		if pi < len(self.invModulos):
			return self.invModulos[pi]
		nextArr = [0] * (n + 1 - len(self.invModulos))
		initialI = len(self.invModulos)
		for i in range(initialI, min(p, n + 1)):
			next = -self.invModulos[p % i] * (p // i) % p
			self.invModulos.append(next)
		return self.invModulos[pi]

	def invFactorial(self, n):
		if n <= -1:
			print('Invalid argument to calculate (n^(-1))!')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		if n < len(self.invFactorial_):
			return self.invFactorial_[n]
		self.inv(n)
		nextArr = [0] * (n + 1 - len(self.invFactorial_))
		initialI = len(self.invFactorial_)
		prev = self.invFactorial_[-1]
		p = self.MOD
		for i in range(initialI, n + 1):
			prev = nextArr[i - initialI] = prev * self.invModulos[i % p] % p
		self.invFactorial_ += nextArr
		return self.invFactorial_[n]

class Combination:

	def __init__(self, MOD):
		self.MOD = MOD
		self.factorial = Factorial(MOD)

	def ncr(self, n, k):
		if k < 0 or n < k:
			return 0
		k = min(k, n - k)
		f = self.factorial
		return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
mod = 10 ** 9 + 7
omod = 998244353
prime = [True for i in range(200001)]
pp = [0] * 200001

def SieveOfEratosthenes(n=200000):
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
n = int(input())
s = input()
r = ''
if n % 2:
	for i in range(n):
		if i % 2 == 1:
			r = s[i] + r
		else:
			r += s[i]
else:
	for i in range(n):
		if i % 2 == 0:
			r = s[i] + r
		else:
			r += s[i]
print(r)


n = int(input())
s = list(input())
new = ''
val = n - 2
while val >= 0:
	new += s[val]
	val -= 2
if n % 2 == 0:
	val = 1
else:
	val = 0
while val < n:
	new += s[val]
	val += 2
print(new)


n = int(input())
s = input()
orgin = [0] * n
seq = [0]
if n % 2 == 0:
	medIndex = n // 2 - 1
	for i in range(1, n // 2):
		seq.append(i)
		seq.append(-i)
	seq.append(n // 2)
else:
	medIndex = n // 2
	for i in range(1, (n + 1) // 2):
		seq.append(-i)
		seq.append(i)
for i in range(n):
	orgin[medIndex + seq[i]] = s[i]
print(''.join(orgin))


n = int(input())
s = input()
o = ''

def insert(source_str, insert_str, pos):
	return source_str[:pos] + insert_str + source_str[pos:]
o += s[0]
for i in range(1, n):
	if i % 2 == 0:
		o += s[i]
	else:
		o = insert(o, s[i], 0)
if n % 2 == 0:
	print(o[::-1])
else:
	print(o)


n = int(input())
str = input()
output = str[0]
if n % 2:
	i = 1
	while i < n:
		if n - i == 1:
			output += str[i]
			i += 1
		else:
			output = str[i] + output
			output += str[i + 1]
			i += 2
else:
	flag = 'r'
	i = 1
	while i < n:
		if flag == 'r':
			output += str[i]
			flag = 'l'
			i += 1
		else:
			output = str[i] + output
			flag = 'r'
			i += 1
print(output)


n = int(input())
s = list(input())
word = []
flag = True if n % 2 == 1 else False
for l in s:
	if flag:
		word.append(l)
	else:
		word = [l] + word
	flag = not flag
print(''.join(word))


n = int(input())
s1 = list(input())
ans = []
while len(s1) > 0:
	if len(s1) % 2 == 0:
		ans.append(s1[0])
		s1.pop(0)
	else:
		ans.insert(0, s1[0])
		s1.pop(0)
ans = reversed(ans)
print(*ans, sep='')


def decode(code, n):
	if n > 2:
		(first_part, second_part) = (code[-2], code[-1])
		marker = 0
		for i in range(n - 3, -1, -1):
			if marker % 2 == 0:
				second_part = code[i] + second_part
			else:
				first_part += code[i]
			marker += 1
		return first_part + second_part
	return code
n = int(input())
code = input().rstrip()
print(decode(code, n))


from sys import stdin, stdout
n = int(stdin.readline())
s = stdin.readline().strip()
left = False
if n % 2 == 0:
	left = True
out = []
for i in range(n):
	if left:
		out.insert(0, s[i])
	else:
		out.append(s[i])
	left = not left
print(''.join(out))


r = int(input())
a = input()
f = ''
j = ''
for i in range(len(a)):
	if len(a) % 2 != 0:
		if i % 2 == 0:
			j += a[i]
		else:
			f += a[i]
	elif i % 2 != 0:
		j += a[i]
	else:
		f += a[i]
s = len(f) - 1
h = ''
while s >= 0:
	h += f[s]
	s -= 1
print(h + j)


from collections import deque
n = int(input())
s = list(input())
d = deque(maxlen=n)
for i in range(1, n + 1):
	d.insert(i // 2, s[-i])
d.reverse()
print(''.join(d))


class main:

	def __init__(self):
		a = int(input())
		b = input()
		c = ''
		while a > 0:
			if a % 2 == 0:
				c = b[0] + c
				b = b[1:]
			else:
				c += b[0]
				b = b[1:]
			a = len(b)
		print(c)
main()


n = int(input())
a = list(input())
x = []
if n % 2 == 0:
	x.extend(a[0:2])
	i = 2
	while i < n:
		if i % 2:
			x.append(a[i])
		else:
			x.insert(0, a[i])
		i += 1
else:
	x.append(a[0])
	i = 1
	while i < n:
		if i % 2 == 0:
			x.append(a[i])
		else:
			x.insert(0, a[i])
		i += 1
print(''.join(x))


n = int(input())
s = input()
if n == 1 or n == 2:
	print(s)
else:
	s = list(s)
	new = list(s)
	front = 0
	back = n - 1
	i = n - 1
	while i >= 0:
		new[back] = s[i]
		back = back - 1
		i = i - 1
		if i >= 0:
			new[front] = s[i]
			front = front + 1
			i = i - 1
	snew = ''.join(new)
	print(snew)


l = int(input())
crypted_word = list(input())
result = []
for step in reversed(range(l)):
	pos = (l - 1 - step) // 2
	result.insert(pos, crypted_word[step])
print(''.join(result))


n = int(input())
s = list(input())
s1 = s[1::2]
if n % 2 == 1:
	print(''.join(s1[::-1] + s[::2]))
else:
	st = s[::2][::-1]
	st1 = s[1::2]
	print(''.join(st + st1))


def translation():
	word_1 = input()
	word_2 = input()[::-1]
	print(['NO', 'YES'][word_1 == word_2])
	return

def anton_and_danik():
	games = int(input())
	wins = input()
	anton_wins = sum((i == 'A' for i in wins))
	if anton_wins * 2 > len(wins):
		print('Anton')
	elif anton_wins * 2 == len(wins):
		print('Friendship')
	else:
		print('Danik')
	return

def acoomodation():
	cnt = 0
	for _ in range(int(input())):
		(p, q) = map(int, input().split())
		if q - p >= 2:
			cnt += 1
	print(cnt)
	return

def juicer():
	(n, b, d) = map(int, input().split())
	sum_orange = 0
	cnt_empty = 0
	for orange in list(map(int, input().split())):
		if orange <= b:
			sum_orange += orange
			if sum_orange > d:
				cnt_empty += 1
				sum_orange = 0
	print(cnt_empty)
	return

def digit_game():
	for game in range(int(input())):
		breach_odd_cnt = 0
		breach_even_cnt = 0
		raze_odd_cnt = 0
		raze_even_cnt = 0
		n = int(input())
		number = input()
		breach_numbers = ''
		raze_numbers = ''
		len_number = len(number)
		idx = 1
		for digit in number:
			if idx % 2 == 0:
				breach_numbers += digit
				if digit in '13579':
					breach_odd_cnt += 1
				else:
					breach_even_cnt += 1
			else:
				raze_numbers += digit
				if digit in '13579':
					raze_odd_cnt += 1
				else:
					raze_even_cnt += 1
			idx += 1
		if len_number == 1:
			if int(number) % 2 == 0:
				print(2)
			else:
				print(1)
		elif len_number % 2 == 0:
			if breach_even_cnt >= 1:
				print(2)
			else:
				print(1)
		elif raze_odd_cnt >= 1:
			print(1)
		else:
			print(2)
	return

def modular_exponentiation():
	n = int(input())
	m = int(input())
	calc = m % int(1 << n)
	print(int(calc))
	return

def tricky_sum():
	for _ in range(int(input())):
		number = int(input())
		pow_two = 1
		while pow_two <= number:
			pow_two *= 2
			print(pow_two)
		sum_formula = number * (number + 1) // 2
		trick_sum = sum_formula - 2 * pow_two + 2
		print(trick_sum)
	return

def three_indices():
	for _ in range(int(input())):
		n = int(input())
		permutation = list(map(int, input().split()))
		(idx_i, idx_j, idx_k) = (1, 2, 3)
		(num_i, num_j, num_k) = (0, 0, 0)
		for idx in range(1, n - 1):
			if permutation[idx] > permutation[idx - 1] and permutation[idx] > permutation[idx + 1]:
				print('YES')
				print(idx, idx + 1, idx + 2)
				break
		else:
			print('NO')
	return

def three_friends():
	for test_cases in range(int(input())):
		coords = list(map(int, input().split()))
		coords_neu = sorted(coords)
		if coords_neu[2] - coords_neu[0] <= 2:
			print(0)
		else:
			print(2 * (coords_neu[2] - coords_neu[0]) - 4)
	return

def decoding():
	length = int(input())
	word = list(input())
	new_word = ''
	for i in range(1, length + 1, 1):
		if len(word) % 2 != 0:
			new_word = new_word + word[0]
		else:
			new_word = word[0] + new_word
		word.pop(0)
	print(new_word)
	return
decoding()


n = int(input())
s = input()
s = s[::-1]
f = True
ans = []
for i in s:
	if f:
		ans.insert((len(ans) + 1) // 2, i)
		f = False
	else:
		ans.insert(len(ans) // 2, i)
		f = True
print(''.join((str(i) for i in ans)))


import sys
input = sys.stdin.readline
n = int(input().strip())
s = input().strip()
ans = ''
for i in range(len(s)):
	if i % 2:
		ans = s[i] + ans
	else:
		ans += s[i]
if not n % 2:
	ans = ans[::-1]
print(ans)


a = int(input())
b = input()
c = [b[0]]
if a % 2 == 1:
	for x in range(1, a):
		if x % 2 == 1:
			c.insert(0, b[x])
		else:
			c.append(b[x])
else:
	for x in range(1, a):
		if x % 2 == 0:
			c.insert(0, b[x])
		else:
			c.append(b[x])
print(''.join(c))


_ = input()
word = input()
answer = word[:1]
word = word[1:]
for letter in word:
	if len(word) % 2 == 0:
		answer = word[:1] + answer
		word = word[1:]
	else:
		answer = answer + word[:1]
		word = word[1:]
print(answer)


n = int(input())
s = [i for i in input()]
d = []
r = []
c = ''
h = []
if n % 2 == 1:
	c = s[0]
s.reverse()
for i in range(0, n - 1, 2):
	r.append(s[i])
	d.append(s[i + 1])
if n % 2 == 1:
	d.append(c)
r.reverse()
for i in d:
	h.append(i)
for i in r:
	h.append(i)
print(''.join(h))


number = int(input(''))
slovo = input('')
decrypt = slovo[0]
count = 1
while count < len(slovo):
	if (len(slovo) - count) % 2 == 0:
		decrypt = str(slovo[count]) + str(decrypt)
		count += 1
	else:
		decrypt = decrypt + slovo[count]
		count += 1
print(decrypt)


import sys, threading, os.path
import string
import collections, heapq, math, bisect
sys.setrecursionlimit(10 ** 6)
threading.stack_size(2 ** 27)

def main():
	if os.path.exists('in.txt'):
		input = open('in.txt', 'r')
	else:
		input = sys.stdin
	n = int(input.readline())
	s = list(str(input.readline().rstrip('\n')))
	sol = collections.deque([])
	if len(s) % 2 == 0:
		for (i, x) in enumerate(s):
			if i % 2 == 1:
				sol.append(x)
			else:
				sol.appendleft(x)
	else:
		for (i, x) in enumerate(s):
			if i % 2 == 0:
				sol.append(x)
			else:
				sol.appendleft(x)
	output = ''.join(map(str, sol))
	if os.path.exists('out.txt'):
		open('out.txt', 'w').writelines(str(output))
	else:
		sys.stdout.write(str(output))
main()


from collections import deque
n = int(input())
word = input()
d = deque()
left = n
even = 0
for c in word:
	if left % 2 != 0:
		d.append(c)
	else:
		d.appendleft(c)
	left -= 1
print(''.join(d))


import sys
n = int(input().strip())
w = str(input().strip())
s = [''] * n
if n < 3:
	print(w)
	sys.exit()
if n % 2:
	s[n // 2] = w[0]
	n -= 1
	i = 1
	l = n // 2 - 1
	r = n // 2 + 1
else:
	i = 0
	l = n // 2 - 1
	r = n // 2
while i < n:
	s[l] = w[i]
	s[r] = w[i + 1]
	l -= 1
	r += 1
	i += 2
print(''.join(s))


n = int(input())
ch = input()
if n == 1 or n == 2:
	print(ch)
elif n % 2 == 1:
	l = ['*'] * (n // 2 + 1)
	m = ['*'] * (n // 2)
	j = 0
	k = 0
	for i in range(n):
		if i % 2 == 0:
			l[j] = ch[i]
			j = j + 1
		else:
			m[k] = ch[i]
			k = k + 1
	m.reverse()
	for x in m:
		print(x, end='')
	for x in l:
		print(x, end='')
else:
	l = ['*'] * (n // 2 + 1)
	m = ['*'] * (n // 2 - 1)
	l[0] = ch[0]
	l[1] = ch[1]
	j = 2
	k = 0
	for i in range(2, n):
		if i % 2 == 1:
			l[j] = ch[i]
			j = j + 1
		else:
			m[k] = ch[i]
			k = k + 1
	m.reverse()
	for x in m:
		print(x, end='')
	for x in l:
		print(x, end='')


n = int(input())
s = input()[::-1]
d1 = ''
d2 = ''
for i in range(n):
	if i % 2 == 0:
		d1 = d1 + s[i]
	else:
		d2 = d2 + s[i]
print(d2 + d1[::-1])


n = int(input())
s = input().rstrip()
s1 = s[-1 - n % 2::-2] + s[::2]
print(s1 if n % 2 else s1[::-1])


import sys
import math
import bisect
from math import sqrt

def input():
	return sys.stdin.readline().strip()

def iinput():
	return int(input())

def rinput():
	return map(int, sys.stdin.readline().strip().split())

def get_list():
	return list(map(int, sys.stdin.readline().strip().split()))
mod = int(1000000000.0) + 7
n = iinput()
s = input()
ans = ''
if n % 2 == 1:
	ans += s[0]
	for i in range(1, n, 2):
		ans = s[i] + ans + s[i + 1]
else:
	for i in range(0, n, 2):
		ans = s[i] + ans + s[i + 1]
print(ans)


n = input()
s = input()
if len(s) == 1:
	print(s)
	exit()
result = s[-2:]
for e in s[:-2][::-1]:
	l = len(result)
	result = result[:l // 2] + e + result[l // 2:]
print(result)


a = int(input())
s = input()
k = s

def foo(b):
	st = ''
	while len(b) != 0:
		if len(b) % 2 == 1:
			st += b[len(b) // 2]
			del b[len(b) // 2]
		else:
			st += b[len(b) // 2 - 1]
			del b[len(b) // 2 - 1]
	return st
while foo(list(s)) != k:
	s = foo(list(s))
print(s)


n = int(input())
p = input()
a = ''
for i in range(n):
	if n % 2:
		if i % 2 == 0:
			a = a + p[i]
		else:
			a = p[i] + a
	elif i % 2 == 0:
		a = p[i] + a
	else:
		a = a + p[i]
print(a)


n = int(input())
s = input()
l = [''] * n
nc = n
for i in range(1, n + 1):
	med = (nc - 1) // 2
	if nc % 2 == 0:
		med = nc // 2 - 1
	ct = 0
	for j in range(n):
		if l[j] == '':
			ct += 1
		if ct == med + 1 and l[j] == '':
			l[j] = s[i - 1]
	nc -= 1
print(''.join(l))


q = lambda : map(int, input().split())
qi = lambda : int(input())
qs = lambda : input().split()
n = qi()
a = input()
b = ''
for i in a:
	if n % 2:
		b = b + i
	else:
		b = i + b
	n -= 1
print(b)


y = int(input())
sq = input()
i = y % 2
s = ''
s += sq[0]
for j in range(1, y):
	if i == 0:
		s += sq[j]
	else:
		s = sq[j] + s
	i = 1 - i
print(s)


n = input()
word = list(input())
encoded = ''
while len(word) > 0:
	l = word[0]
	del word[0]
	if len(word) % 2:
		encoded = l + encoded
	else:
		encoded = encoded + l
print(encoded)


a = int(input())
st = input()
name = st[0]
if a == 2:
	print(st)
else:
	for i in range(1, a):
		if i % 2 != 0:
			name += st[i]
		else:
			name = st[i] + name
	if a % 2 != 0:
		print(name[::-1])
	else:
		print(name)


n = int(input())
s = list(input())
b = []
i = 0
n = len(s)
while i < n:
	if b == []:
		b.append(s.pop())
	elif len(b) % 2 != 0:
		b = b[:len(b) // 2 + 1] + [s.pop()] + b[len(b) // 2 + 1:]
	elif len(b) % 2 == 0:
		b = b[:len(b) // 2] + [s.pop()] + b[len(b) // 2:]
	i += 1
b.reverse()
a = ''.join(b)
print(a)


n = int(input())
s = input().strip()
b = ''
if n % 2 == 1:
	for i in range(n):
		if i % 2 == 0:
			b += s[i]
		else:
			b = s[i] + b
else:
	for i in range(n):
		if i % 2 == 1:
			b += s[i]
		else:
			b = s[i] + b
print(b)


n = int(input())
string1 = str(input())
lst = []
for item in string1:
	lst.append('')
num = n
if num % 2 == 0:
	max = int(n / 2)
else:
	max = int(n / 2) - 1
for item in string1:
	if n % 2 != 0:
		if lst[int(n / 2)] == '':
			lst[int(n / 2)] = item
		else:
			while lst[max] != '':
				max = max + 1
			lst[max] = item
	elif lst[int(n / 2) - 1] == '':
		lst[int(n / 2) - 1] = item
	else:
		while lst[max] != '':
			max = max + 1
		lst[max] = item
	n = n - 1
print(*lst, sep='')


n = int(input())
s = input()
ans = ''
for i in range(len(s)):
	if not i & 1:
		ans += s[i]
	else:
		ans = s[i] + ans
if len(s) & 1:
	print(ans)
else:
	print(ans[::-1])


n = int(input())
s = input()
decoded = ''
for i in range(n):
	if (n - i) % 2 == 1:
		decoded += s[i]
	else:
		decoded = s[i] + decoded
print(decoded)


__author__ = 'ActiveChooN Dusted'
n = int(input())
word = input()
wordMas = list()
if n % 2 == 1:
	i = 1
else:
	i = 0
for l in word:
	if i:
		wordMas.append(l)
		i = 0
	else:
		wordMas = list(l) + wordMas
		i = 1
print(''.join(wordMas))


n = int(input())
s = input()
res = ''
for i in range(n):
	if i == 0:
		res += s[i]
	elif len(s[i:]) % 2 == 0:
		res = s[i] + res
	else:
		res += s[i]
print(res)


n = int(input())
str = input()
ans = ''
for i in range(0, n):
	ans = ans[:i // 2] + str[-i - 1] + ans[i // 2:]
print(ans)


n = int(input())
str1 = input()
list1 = list(str1)
listA = []
listB = []
if len(list1) % 2 != 0:
	for i in range(1, len(list1)):
		if i % 2 != 0:
			listA.append(list1[i])
		else:
			listB.append(list1[i])
	listA.reverse()
	print(''.join(listA) + str1[0] + ''.join(listB))
else:
	for i in range(0, len(list1)):
		if i % 2 != 0:
			listA.append(list1[i])
		else:
			listB.append(list1[i])
	listB.reverse()
	print(''.join(listB) + ''.join(listA))


import sys
import math
import random
input = sys.stdin.readline

def inp():
	return int(input())

def inara():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
n = inp()
s = insr()
for i in range(n - 2, -1, -2):
	print(s[i], end='')
for i in range(1 - n % 2, n, 2):
	print(s[i], end='')


n = int(input())
encoded = input()
prefix = True
decoded = ''
start = 0
if n % 2 == 1:
	decoded = encoded[0]
	start = 1
for i in range(start, n):
	if prefix:
		decoded = encoded[i] + decoded
	else:
		decoded += encoded[i]
	prefix = not prefix
print(decoded)


def main():
	try:
		while True:
			n = int(input())
			s = input()
			result = ''
			for (m, c) in enumerate(reversed(s)):
				result = result[:m >> 1] + c + result[m >> 1:]
			print(result)
	except EOFError:
		pass
main()


n = int(input())
e = input()
s = ''
while n != 0:
	if n % 2 == 1:
		s = s + e[0]
	else:
		s = e[0] + s
	e = e[1:]
	n -= 1
print(s)


from sys import stdin, stdout
n = int(stdin.readline())
s = stdin.readline().strip()
f = ''
if len(s) % 2:
	f = s[0]
	s = s[1:]
ind = 0
for i in range(len(s) // 2):
	f = s[ind] + f + s[ind + 1]
	ind += 2
stdout.write(f)


def nextIndex(li, index):
	while li[index] != None:
		index += 1
	return index

def place(li, index, element):
	listIndex = nextIndex(li, 0)
	while index != 0:
		index -= 1
		listIndex += 1
		listIndex = nextIndex(li, listIndex)
	li[listIndex] = element
	return
n = int(input())
en = [i for i in input().strip()]
de = [None] * n
for i in range(len(en)):
	place(de, (n + 1) // 2 - 1, en[i])
	n -= 1
print(''.join(de))


n = int(input())
s = str(input())
s1 = ''
s2 = ''
s3 = ''
for i in range(0, len(s)):
	if i % 2 == 0:
		s1 += s[i]
	else:
		s2 += s[i]
for i in range(len(s1) - 1, -1, -1):
	s3 += s1[i]
s3 += s2
if n % 2 == 0:
	print(s3)
else:
	for i in range(len(s3) - 1, -1, -1):
		print(s3[i], end='')


import sys
import bisect
input = sys.stdin.readline
ins = lambda : input().rstrip()
ini = lambda : int(input().rstrip())
inm = lambda : map(int, input().rstrip().split())
inl = lambda : list(map(int, input().split()))
out = lambda x: print('\n'.join(map(str, x)))
n = ini()
s = ins()
ans = ''
if n % 2:
	for i in range(n):
		if i % 2:
			ans = s[i] + ans
		else:
			ans += s[i]
else:
	for i in range(n):
		if i % 2:
			ans += s[i]
		else:
			ans = s[i] + ans
print(ans)


n = int(input())
s = input()
ans = [None for _ in s]
for i in range(n):
	index = n - 1 - i // 2 if i % 2 == 0 else i // 2
	ans[index] = s[n - 1 - i]
print(''.join(ans))


n = int(input())
s = input()
res = ''
if n % 2 == 1:
	l = False
else:
	l = True
for i in range(len(s)):
	if l:
		res = s[i] + res
		l = False
	else:
		res = res + s[i]
		l = True
print(res)


n = int(input())
w = input()
out = ''
left = n % 2 == 0
for c in w:
	if left:
		out = c + out
	else:
		out = out + c
	left = not left
print(out)


def fun(n):
	if n % 2 == 0:
		return n // 2 - 1
	else:
		return n // 2
n = int(input())
s = input()
l = [''] * n
m = n
for i in range(n):
	k = fun(n - i)
	if k < m:
		l[k] = s[i]
		m = min(m, k)
	else:
		l[k + i] = s[i]
		m = min(m, k)
print(''.join(l))


def medi(s):
	ans = []
	s = list(s)
	if len(s) % 2 == 1:
		flag = True
		while s:
			if flag == True:
				ans.append(s.pop(0))
				flag = False
			elif flag == False:
				ans = [s.pop(0)] + ans
				flag = True
	else:
		flag = True
		while s:
			if flag == True:
				ans = [s.pop(0)] + ans
				flag = False
			elif flag == False:
				ans.append(s.pop(0))
				flag = True
	return ''.join(ans)
n = int(input())
s = input()
print(medi(s))


n = int(input())
a = list(input())
a.reverse()
b = ['*'] * n
if n % 2 == 1:
	i = 1
	k = a.pop()
	b[n // 2] = k
	while n // 2 - i >= 0:
		k = a.pop()
		b[n // 2 - i] = k
		k = a.pop()
		b[n // 2 + i] = k
		i = i + 1
if n % 2 == 0:
	i = 1
	while n // 2 - i >= 0:
		k = a.pop()
		b[n // 2 - i] = k
		k = a.pop()
		b[n // 2 + (i - 1)] = k
		i = i + 1
print(''.join(b))


n = int(input())
s = input()
s = list(s)
s2 = [''] * n
s = s[::-1]
i = 0
while len(s) >= 1:
	s2[i] = s.pop(0)
	if len(s) == 0:
		break
	s2[n - i - 1] = s.pop(0)
	if len(s) == 0:
		break
	i = i + 1
print(''.join(s2[::-1]))


n = int(input(''))
st = list(input(''))
if n == 1 or n == 2:
	print(''.join(st))
else:
	sol = [0] * n
	sol[0] = st[n - 2]
	sol[n - 1] = st[n - 1]
	cnt = 1
	sheshe = n - 2
	prothome = 1
	for i in range(n - 3, -1, -1):
		if cnt:
			sol[sheshe] = st[i]
			cnt = 0
			sheshe -= 1
		else:
			sol[prothome] = st[i]
			cnt = 1
			prothome += 1
	print(''.join(sol))


n = int(input())
s = input()
res = ''
for x in range(n - 1, -1, -2):
	res += s[x]
i = 1
if n % 2 == 0:
	i = 0
for x in range(i, n, 2):
	res += s[x]
print(res[::-1])


def odd_length(word, n):
	new = ''
	for x in range(len(word)):
		if x % 2 == 0:
			new += word[x]
		else:
			new = word[x] + new
	return new

def even_length(word, n):
	new = word[:2]
	for x in range(2, len(word)):
		if x % 2 == 1:
			new += word[x]
		else:
			new = word[x] + new
	return new
n = int(input())
word = input()
if n % 2 != 0:
	print(odd_length(word, n))
else:
	print(even_length(word, n))


n = int(input())
s = list(input())
final_string = []
i = 0
if n % 2 == 1:
	while i < n:
		if i % 2 == 0:
			final_string.append(s[i])
		else:
			final_string.insert(0, s[i])
		i += 1
else:
	final_string.append(s[0])
	s.remove(s[0])
	while i < n - 1:
		if i % 2 == 0:
			final_string.append(s[i])
		else:
			final_string.insert(0, s[i])
		i += 1
print(''.join(map(str, final_string)))


n = int(input())
s = str(input())
p1 = ''
p2 = ''
s = s[::-1]
for i in range(n):
	if i % 2 == 0:
		p2 += s[i]
	else:
		p1 += s[i]
print(p1 + p2[::-1])


n = int(input())
c = input()
t = [0] * n
for i in range(n):
	h = i // 2
	if i % 2 == 0:
		t[n - 1 - h] = c[n - 1 - i]
	else:
		t[h] = c[n - 1 - i]
r = ''.join(t)
print(r)


n = int(input())
d = list(input())
e = []
for i in range(n):
	if (i + n) % 2 == 1:
		e.append(d[i])
	else:
		e.insert(0, d[i])
print(*e, sep='')


n = int(input())
s = input()
s = reversed(s)
rs = ''
for i in s:
	rs = rs[:int(len(rs) / 2)] + i + rs[int(len(rs) / 2):]
print(rs)


(n, st) = (int(input()), input())
if n % 2 == 0:
	s = 1
else:
	s = 0
ans = ''
for i in st:
	if s == 0:
		ans = ans + i
	else:
		ans = i + ans
	s = 1 - s
print(ans)


n = int(input())
s = input()
s = s[::-1]
indexes = []
for i in reversed(range(n)):
	indexes.append(i // 2)
ans = []
j = 0
for i in reversed(indexes):
	ans.insert(i, s[j])
	j += 1
print(''.join(ans))


n = int(input())
x = list(input().strip())
ans = []
if n == 1:
	print(x[0])
	exit(0)
if n == 1:
	print(x[0] + x[1])
	exit(0)
if n % 2 != 0:
	for i in range(n - 2, -1, -2):
		ans.append(x[i])
	for i in range(0, n, 2):
		ans.append(x[i])
else:
	for i in range(n - 2, -1, -2):
		ans.append(x[i])
	for i in range(1, n, 2):
		ans.append(x[i])
print(''.join(ans))


import math
input()
s = input()
result = [' '] * len(s)
m = (len(s) - 1) // 2
d = 1
if len(s) % 2 == 1:
	for i in range(0, len(s)):
		result[m + d * ((i + 1) // 2)] = s[i]
		d = -d
else:
	d = -1
	for i in range(0, len(s)):
		result[m + d * ((i + 1) // 2)] = s[i]
		d = -d
s = ''
for c in result:
	s += c
print(s)


n = int(input())
word = input()
a = [''] * n
middle = n // 2 - 1 + n % 2
a[middle] = word[0]
if n % 2 != 0:
	k = -1
	for i in range(1, n):
		middle = middle + i * k
		a[middle] = word[i]
		k *= -1
else:
	k = 1
	for i in range(1, n):
		middle = middle + i * k
		a[middle] = word[i]
		k *= -1
print(''.join(a))


n = int(input())
s = input()
s = list(s)
a = []
for i in range(n - 2, 0, -2):
	a.append(s[i])
	s[i] = 0
for i in range(n):
	if s[i] != 0:
		a.append(s[i])
for i in range(n):
	print(a[i], end='')


n = int(input())
txt = input()
result = txt[n - 1]
for i in range(n - 2, -1, -1):
	thesi = int(len(result) / 2)
	result = result[:thesi] + txt[i] + result[thesi:]
print(result)


def pushBack(t, elem):
	global tail
	t[tail] = elem
	tail = (tail + 1) % n

def pushFront(t, elem):
	global head
	head = (head - 1 + n) % n
	t[head] = elem

def popFront(t):
	global head
	x = t[head]
	head = (head + 1) % n
	return x
n = int(input())
s = input()
t = ['-' for i in range(n)]
(head, tail) = (0, 0)
for i in range(n):
	if i % 2 == 0 and n % 2 != 0 or (i % 2 != 0 and n % 2 == 0):
		pushBack(t, s[i])
	elif i % 2 != 0 and n % 2 != 0 or (i % 2 == 0 and n % 2 == 0):
		pushFront(t, s[i])
for i in range(n):
	print(popFront(t), end='')


import sys
n = int(input())
str = input()
j = 0
k = 0
l = 1
arr = []
char = ''
if n % 2 == 0:
	for i in range(0, n):
		if i % 2 == 0:
			value = int(n / 2) - 1 - j
			j += 1
		else:
			value = int(n / 2) + k
			k += 1
		arr.append(value)
else:
	for i in range(0, n):
		if i % 2 == 0:
			value = int(n / 2) + j
			j += 1
		else:
			value = int(n / 2) - l
			l += 1
		arr.append(value)
for item in range(0, n):
	a = arr.index(item)
	char += str[a]
print(char)


n = int(input())
str1 = input()
s1 = ''
s2 = ''
if n & 1 == 1:
	for i in range(n):
		if i & 1 == 1:
			s1 = str1[i] + s1
		else:
			s2 += str1[i]
	print(s1 + s2)
else:
	for i in range(n):
		if i & 1 == 0:
			s1 = str1[i] + s1
		else:
			s2 += str1[i]
	print(s1 + s2)


l = int(input())
s = input()
decode = [0] * l
encode = []
for c in s:
	encode.append(c)
if l % 2 == 0:
	x = int(l / 2) - 1
	decode[x] = encode[0]
	k = 1
	for i in range(x + 1, l):
		decode[i] = encode[k]
		k += 2
	j = 2
	for i in range(x - 1, -1, -1):
		decode[i] = encode[j]
		j += 2
else:
	x = int(l / 2)
	decode[x] = encode[0]
	k = 2
	for i in range(x + 1, l):
		decode[i] = encode[k]
		k = k + 2
	j = 1
	for i in range(x - 1, -1, -1):
		decode[i] = encode[j]
		j += 2
s = ''
for i in range(l):
	s = s + decode[i]
print(s)


n = int(input())
encoded = list(input())
decoded = []
decoded.append(encoded[0])
index = 0
for x in range(1, len(encoded)):
	if n % 2 != 0:
		if len(decoded) % 2 != 0:
			decoded.insert(0, encoded[x])
		else:
			decoded.append(encoded[x])
	elif len(decoded) % 2 != 0:
		decoded.append(encoded[x])
	else:
		decoded.insert(0, encoded[x])
print(''.join(decoded))


import sys
input = sys.stdin.readline
read_tuple = lambda _type: map(_type, input().split(' '))
from collections import deque

def solve():
	n = int(input())
	s = list(input().replace('\n', ''))
	ans = deque()
	flag = n % 2 == 1
	for char in s:
		if flag:
			ans.append(char)
			flag = False
		else:
			ans.appendleft(char)
			flag = True
	print(''.join(ans))
solve()


n = int(input())
s = list(input())
if len(s) <= 2:
	print(''.join(s))
else:
	c_out = ''
	i = 0
	start = n - 2
	while start >= 0:
		c_out += s[start]
		start -= 2
	start = 1 - n % 2
	while start < len(s):
		c_out += s[start]
		start += 2
	print(c_out)


n = int(input())
s = input()
li = []
if n <= 2:
	print(s)
else:
	li.append(s[0])
	for i in range(1, n):
		if i & 1:
			li.insert(0, s[i])
		else:
			li.append(s[i])
	if n % 2 == 0:
		for i in reversed(li):
			print(i, end='')
	else:
		for i in li:
			print(i, end='')


n = int(input())
s = input()
ans = ''
for i in range(n - 2, -1, -2):
	ans += s[i]
start = 0
if n % 2 == 0:
	start = 1
while start < n:
	ans += s[start]
	start += 2
print(ans)


n = int(input())
s = list(input())
i = 0
f = []
while i < n:
	f.append('')
	i = i + 1
if n % 2 == 0:
	j = n // 2 - 1
	k = n // 2
	f[j] = s[0]
	f[k] = s[1]
	t = j - 1
	p = 2
	while t >= 0:
		f[t] = s[p]
		p = p + 2
		t = t - 1
	q = 3
	u = k + 1
	while u < n:
		f[u] = s[q]
		q = q + 2
		u = u + 1
else:
	k = n // 2
	f[k] = s[0]
	t = k - 1
	p = 1
	while t >= 0:
		f[t] = s[p]
		p = p + 2
		t = t - 1
	q = 2
	u = k + 1
	while u < n:
		f[u] = s[q]
		q = q + 2
		u = u + 1
print(''.join(f))


N = int(input())
string = str(input())
res = ['a' for _ in range(N)]
i = 0
if N % 2 != 0:
	end = (N - 1) // 2
	start = end - 1
	res[end] = string[i]
	i += 1
	end += 1
else:
	start = (N - 1) // 2
	end = start + 1
cnt = 0
while i < len(string):
	if cnt % 2 == 0:
		res[start] = string[i]
		start -= 1
	else:
		res[end] = string[i]
		end += 1
	i += 1
	cnt += 1
print(''.join(res))


n = int(input())
s = list(input())
ans = ''
for i in range(len(s)):
	if len(s) % 2:
		if i % 2 == 0:
			ans = ans + s[i]
		else:
			ans = s[i] + ans
	elif i % 2 == 0:
		ans = s[i] + ans
	else:
		ans = ans + s[i]
print(ans)


input()
b = input()
c = ''
d = ''
a = 0
for x in b[::-1]:
	if a == 0:
		c = x + c
		a = 1
	else:
		d = x + d
		a = 0
print(d[::-1] + c)


n = int(input())
s = input()
if not n % 2:
	print(s[::2][::-1] + s[1::2])
else:
	print(s[1::2][::-1] + s[::2])


from sys import stdin, stdout, exit
import math
from fractions import gcd

def sin():
	return stdin.readline().rstrip()

def listInput():
	return list(map(int, sin().split()))

def printBS(li):
	if not li:
		return
	for i in range(len(li) - 1):
		stdout.write('%d ' % li[i])
	stdout.write('%d\n' % li[-1])
n = int(sin())
s = sin()
ans = [' '] * n
i = n - 1
j = n - 1
while i >= 0:
	ans[j] = s[i]
	i -= 2
	j -= 1
i = n - 2
j = 0
while i >= 0:
	ans[j] = s[i]
	i -= 2
	j += 1
print(''.join(ans))


n = input()
s = input()
out = []
for i in range(len(s)):
	out.append('')
if len(s) % 2 == 0:
	r = len(s) // 2 - 1
	l = r
	for i in range(len(s)):
		if i % 2 == 0:
			out[l] = s[i]
			r += 1
		else:
			out[r] = s[i]
			l -= 1
else:
	r = len(s) // 2
	l = r
	for i in range(len(s)):
		if i % 2 != 0:
			out[l] = s[i]
			r += 1
		else:
			out[r] = s[i]
			l -= 1
for i in out:
	print(i, end='')


n = int(input())
st = input()
dir = 0
if n % 2 == 0:
	di = 0
else:
	di = 1
res = st[0]
for char in st[1:n]:
	if not di:
		res = res + char
	else:
		res = char + res
	di = di ^ 1
print(res)


import sys

def decode(s):
	l = len(s)
	result = l * [0]
	curr = (l - 1) // 2
	parity = (l + 1) % 2
	for i in range(l):
		curr = curr + i * (-1) ** (i + parity)
		result[curr] = s[i]
	return ''.join(result)
inp = sys.stdin.read()
inp = inp.strip().split()
print(decode(inp[1]))


L = int(input())
s = input()
res = s[0]
p = False
if (L - 1) % 2 == 0:
	p = True
for i in range(1, L):
	if p == True:
		res = s[i] + res
		p = False
	else:
		res += s[i]
		p = True
print(res)


n = int(input())
s = list(input())
ans = []
c = 0
if n % 2 == 0:
	ok = False
	for i in s:
		if ok == True:
			ans.append(i)
			ok = False
		else:
			ans.insert(0, i)
			ok = True
else:
	ok = True
	for i in s:
		if ok == True:
			ans.append(i)
			ok = False
		else:
			ans.insert(0, i)
			ok = True
print(''.join(ans))


from __future__ import division, print_function
from sys import stdin, stdout
import bisect
from bisect import bisect_left as bl
from bisect import bisect_right as br
import itertools
from collections import Counter
import collections
import math
import heapq
import re

def modinv(n, p):
	return pow(n, p - 2, p)

def cin():
	return map(int, sin().split())

def ain():
	return list(map(int, sin().split()))

def sin():
	return input()

def inin():
	return int(input())

def Divisors(n):
	l = []
	for i in range(1, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n // i == i:
				l.append(i)
			else:
				l.append(i)
				l.append(n // i)
	return l

def most_frequent(list):
	return max(set(list), key=list.count)

def GCD(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def ncr(n, r, p):
	t = fact[n] * (ifact[r] * ifact[n - r] % p) % p
	return t

def Convert(string):
	li = list(string.split(''))
	return li

def SieveOfEratosthenes(n):
	global prime
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	f = []
	for p in range(2, n):
		if prime[p]:
			f.append(p)
	return f
prime = []
q = []

def dfs(n, d, v, c):
	global q
	v[n] = 1
	x = d[n]
	q.append(n)
	j = c
	for i in x:
		if i not in v:
			f = dfs(i, d, v, c + 1)
			j = max(j, f)
	return j

def main():
	n = inin()
	s = list(sin())
	temp1 = ''
	temp2 = ''
	ans = ''
	for i in range(n // 2):
		temp1 += s[-2 * i - 1]
	for i in range(n // 2):
		temp2 += s[-2 * i - 2]
	if n & 1 == 0:
		ans = temp2 + temp1[::-1]
	else:
		ans = temp2 + s[0] + temp1[::-1]
	print(ans)
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.getvalue())
			(self.truncate(0), self.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			self.write = lambda s: self.buffer.write(s.encode('ascii'))
			self.read = lambda : self.buffer.read().decode('ascii')
			self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


n = int(input())
inp = list(input())
(f, l) = (0, n - 1)
res = ['a'] * n
for i in range(n):
	if f == l:
		res[f] = inp[0]
		break
	if len(inp) % 2 == 0:
		res[l] = inp.pop(len(inp) - 1)
		l -= 1
	else:
		res[f] = inp.pop(len(inp) - 2 if n % 2 == 1 else len(inp) - 1)
		f += 1
print(''.join(res))


n = int(input())
l = input()
ll = [''] * n
av = 0
okh = 0
if n % 2 == 0:
	ll[n // 2 - 1] = l[0]
	av = n // 2 - 1
	okh = av
else:
	ll[n // 2] = l[0]
	av = n // 2
	okh = av
n = n - 1
k = 1
while n > 0:
	if n % 2 == 0:
		av -= 1
		ll[av] = l[k]
	else:
		okh += 1
		ll[okh] = l[k]
	k += 1
	n -= 1
print(''.join(ll))


n = int(input())
line = input()
line2 = ''
line3 = ''
for i in range(n):
	if i % 2 != 0:
		line2 = line2 + line[i]
	else:
		line2 = line[i] + line2
for j in range(n):
	line3 = line3 + line2[n - j - 1]
if n % 2 == 0:
	print(line2)
else:
	print(line3)


n = int(input())
s = input()
l = []
for i in s:
	l.append(i)
res = []
j = 0
if len(l) % 2 == 1:
	for i in l:
		if j % 2 == 0:
			res.append(i)
		else:
			res.insert(0, i)
		j += 1
	print(''.join(res))
else:
	for i in l:
		if j % 2 == 0:
			res.insert(0, i)
		else:
			res.append(i)
		j += 1
	print(''.join(res))


n = int(input())
s = input()
s1 = []
s2 = []
c = 0
for i in range(n)[::-1]:
	if c % 2 == 0:
		s2 += [s[i]]
	else:
		s1 += [s[i]]
	c += 1
print(''.join(s1) + ''.join(s2[::-1]))


n = int(input())
s = input()
if n % 2 == 0:
	flag = 0
else:
	flag = 1
ss = s[0]
for i in range(1, n):
	if flag == 0:
		ss = ss + s[i]
		flag = 1
	else:
		ss = s[i] + ss
		flag = 0
print(ss)


lens = int(input())
encoded = input()
print(encoded[-2::-2] + encoded[-1::-2][::-1])


N = int(input())
L = list(input())
LE = list(range(0, len(L)))
cont = 0
i = 0
K = N - 1
for x in reversed(L):
	if cont % 2 == 0:
		LE[K] = x
		K -= 1
	else:
		LE[i] = x
		i += 1
	cont += 1
print(''.join(LE))


c = int(input())
s = list(input())
o = []
for i in range(c):
	o.append('')
i = 0
count = 0
if c % 2 != 0:
	i = 1
	count = 1
	o[int(c / 2)] = s[0]
while i < c:
	o[int(c / 2 - count + 0.5) - 1] = s[i]
	i += 1
	if i < c:
		o[int(c / 2 + count)] = s[i]
		i += 1
	count += 1
print(''.join(o))


n = int(input())
s = input()
a_left = ''
a_right = ''
for i in range((n - 1) // 2 + 1):
	s_new = s[-2:]
	a_left += s_new[0]
	if len(s) > 1:
		a_right += s_new[1]
	s = s[:-2]
print(a_left + a_right[::-1])


n = int(input())
s = list(map(str, input()))
result = [0] * n
for i in range(n - 1, -1, -1):
	if i % 2 == 0:
		result.reverse()
		result[result.index(0)] = s[i]
		result.reverse()
	else:
		result[result.index(0)] = s[i]
if n % 2 == 0:
	result.reverse()
print(*result, sep='')


import math
leng = input()
word = input()
leng = int(leng)
decoded = ''
c = 0
if leng % 2 == 0:
	for i in range(leng):
		i += 1
		if i <= leng / 2:
			decoded += word[-(i * 2)]
		else:
			decoded += word[int(i - leng / 2 + c)]
			c += 1
else:
	for i in range(leng):
		i += 1
		if i <= math.floor(leng / 2):
			decoded += word[-(i * 2)]
		else:
			decoded += word[int(i - math.floor(leng / 2) - 1 + c)]
			c += 1
print(decoded)


import sys
import math
get_string = lambda : sys.stdin.readline().strip()
get_int_list = lambda : list(map(int, sys.stdin.readline().strip().split()))
get_intList_from_str = lambda : list(map(int, list(sys.stdin.readline().strip())))
get_charList_from_str = lambda : list(sys.stdin.readline().strip())
get_char_list = lambda : sys.stdin.readline().strip().split()
get_int = lambda : int(sys.stdin.readline())
pt = lambda x: sys.stdout.write(str(x))
n = get_int()
s = get_string()
if n == 1:
	print(s)
else:
	if n % 2 == 0:
		ans = ''
		for i in range(n):
			if i % 2 == 0:
				ans = s[i] + ans
			else:
				ans = ans + s[i]
	else:
		ans = ''
		for i in range(n):
			if i % 2 == 0:
				ans = ans + s[i]
			else:
				ans = s[i] + ans
	print(ans)


n = int(input())
c = input()
l = len(c)
s = c[l - 2:l]
for i in range(1, n - 1):
	ll = len(s)
	s = s[0:i // 2 + i % 2] + c[l - 2 - i] + s[i // 2 + i % 2:ll]
print(s)


n = int(input())
l = []
(f, f1) = (0, [1, 0])
if n % 2 == 1:
	for x in input():
		if f == 0:
			l.append(x)
		else:
			l.insert(0, x)
		f = f1[f]
else:
	for y in input():
		if f == 1:
			l.append(y)
		else:
			l.insert(0, y)
		f = f1[f]
print(''.join(l))


a = int(input())
b = input()
s = ''
for i in range(a):
	if i % 2 == 0:
		s = b[i] + s
	else:
		s = s + b[i]
if a % 2 == 0:
	print(s)
else:
	print(s[::-1])


word_length = int(input())
word = input()
final_word = []
is_odd = word_length % 2
for (index, letter) in enumerate(word):
	if index % 2 == is_odd:
		final_word = [letter] + final_word
	else:
		final_word.append(letter)
final_word = ''.join(final_word)
print(final_word)


from math import *
n = int(input())
s = input()
center = ceil(n / 2)
tx = s[0]
if n % 2 == 0:
	f = False
else:
	f = True
for x in range(1, n):
	if f:
		tx = s[x] + tx
	else:
		tx = tx + s[x]
	f = not f
print(tx)


n = int(input())
s = input()
for i in range(n - 2, -1, -2):
	print(s[i], end='')
for i in range(1 - n % 2, n, 2):
	print(s[i], end='')


R = lambda : map(int, input().split())
n = int(input())
s = input()
print(s[-2::-2] + s[n % 2 == 0::2])


n = int(input())
s = input().rstrip()
answ = []
while len(s):
	if len(s) % 2 != 0:
		answ.append(s[0])
	else:
		answ.insert(0, s[0])
	s = s[1:]
print(''.join(answ))


from collections import deque
n = int(input())
s = list(input())
result = deque()
result.append(s[0])
n -= 1
i = 1
while n != 0:
	if n % 2 == 0:
		result.append(s[i])
	else:
		result.appendleft(s[i])
	i += 1
	n -= 1
t = ''
for i in result:
	t += i
print(t[::-1])


n = int(input())
l = list(input())
s = []
s.append(l[0])
if n % 2 != 0:
	for i in range(2, n, 2):
		s.append(l[i])
	s.reverse()
	for i in range(1, n, 2):
		s.append(l[i])
	s.reverse()
	z = ''.join(s)
	print(z)
else:
	for i in range(1, n, 2):
		s.append(l[i])
	s.reverse()
	for i in range(2, n, 2):
		s.append(l[i])
	s.reverse()
	z = ''.join(s)
	print(z)


import math
n = int(input())
s = input()
s = list(s)
s.reverse()
s1 = []
for i in s:
	if len(s1) % 2 == 0:
		s1.insert(len(s1) // 2, i)
	else:
		s1.insert(math.ceil(len(s1) / 2), i)
s1.reverse()
q = ''
for i in s1:
	q += i
print(q)


n = int(input())
s = input()
dup = ['0'] * n
if n % 2 == 0:
	initial = previous = n // 2 - 1
	f1 = 1
	f2 = 0
	for i in s:
		if f1:
			dup[initial] = i
			previous = initial
			initial = n - 1 - initial
			f1 = 0
			f2 = 1
		elif f2:
			dup[initial] = i
			initial = previous - 1
			f2 = 0
			f1 = 1
else:
	initial = previous = n // 2
	f1 = 1
	f2 = 0
	for i in s:
		if f1:
			dup[initial] = i
			previous = initial
			initial = n - 2 - initial
			f1 = 0
			f2 = 1
		elif f2:
			dup[initial] = i
			initial = previous + 1
			f2 = 0
			f1 = 1
print(''.join(dup))


def odd(str, n):
	rep = 0
	s = ''
	while rep < n:
		if rep % 2 != 0:
			s = str[rep] + s
		else:
			s += str[rep]
		rep += 1
	return s

def even(str, n):
	rep = 0
	s = ''
	while rep < n:
		if rep % 2 != 0:
			s += str[rep]
		else:
			s = str[rep] + s
		rep += 1
	return s
n = int(input())
str = input()
if n % 2 != 0:
	print(odd(str, n))
else:
	print(even(str, n))


import math
import itertools
import sys
from collections import *
from decimal import *
files = False
if files:
	name = 'cond'
	sys.stdout = open('%s.out' % name, mode='w')
	sys.stdin = open('%s.in' % name)
sz = int(input())
st = str(input())
res = ['0'] * sz
if sz % 2 == 0:
	cur = 0
	mid = sz // 2 - 1
	while cur * 2 < sz:
		res[mid - cur] = st[cur * 2]
		res[mid + cur + 1] = st[cur * 2 + 1]
		cur += 1
else:
	cur = 0
	mid = sz // 2
	res[mid] = st[0]
	st = st[1:]
	while cur * 2 < sz - 1:
		res[mid - cur - 1] = st[cur * 2]
		res[mid + cur + 1] = st[cur * 2 + 1]
		cur += 1
print(''.join(res))
sys.stdout.close()


n = int(input())
s = input()
op = ''
if n == 1:
	print(s)
else:
	if n % 2 == 0:
		for i in range(n - 2, -1, -2):
			op += s[i]
	else:
		for i in range(n - 2, 0, -2):
			op += s[i]
	if n % 2 == 0:
		for j in range(1, n, 2):
			op += s[j]
	else:
		for j in range(0, n, 2):
			op += s[j]
print(op)


a = int(input())
x = input()
if a == 1:
	print(x)
	exit()
word = []
word.append(x[a - 2])
word.append(x[a - 1])
for i in range(a - 3, -1, -1):
	if len(word) % 2 == 0:
		c = len(word) // 2
		word.insert(c, x[i])
	else:
		c = len(word) // 2
		word.insert(c, x[i])
print(''.join(word))


aux = ''
n = 0
s = ''
s2 = 0
mid = 0
i = 0
scann = input()
numbers = scann.split()
n = int(numbers[0])
scann = input()
numbers = scann.split()
s = numbers[0]
s2 = int(n)
mid = int(s2 / 2)
while n > 0:
	if n % 2 != 0:
		aux += s[i]
	else:
		aux = s[i] + aux
	n -= 1
	i += 1
print(aux)


n = int(input())
s = input()
if len(s) > 1:
	l = [s[-2], s[-1]]
	s = s[::-1][2:]
	for i in range(n - 2):
		l.insert(len(l) // 2, s[i])
	print(''.join(l))
else:
	print(s)


import math
length = int(input())
encoded = input()

def decode(string_to_decode):
	s = list(string_to_decode)
	stand_in = list(range(len(s)))
	result = [' ' for stand_in_char in range(len(s))]
	while len(stand_in) > 0:
		if len(stand_in) % 2 == 0:
			index = math.floor(len(stand_in) / 2) - 1
		else:
			index = math.floor(len(stand_in) / 2)
		result[stand_in[index]] = s[0]
		s.pop(0)
		stand_in.pop(index)
	return ''.join(result)
print(decode(encoded))


from collections import deque
n = int(input())
string = str(input())
encoded = [char for char in string]
temp = deque()
for i in range(len(encoded)):
	if len(encoded[i:]) % 2 == 0:
		temp.appendleft(encoded[i])
	else:
		temp.append(encoded[i])
temp = ''.join((x for x in temp))
print(temp)


from math import ceil
n = int(input())
string = input()
final = [' '] * n
if n <= 2:
	exit(print(string))
if n % 2 != 0:
	right = ceil(n / 2) - 1
	left = 0
	for i in range(0, n, 2):
		final[right] = string[i]
		right += 1
	for i in range(n - 2, 0, -2):
		final[left] = string[i]
		left += 1
	print(''.join(final))
else:
	left = int(n / 2) - 1
	right = left + 1
	for i in range(0, n, 2):
		final[left] = string[i]
		left -= 1
	for i in range(1, n, 2):
		final[right] = string[i]
		right += 1
	print(''.join(final))


n = int(input())
s = input()
mid = ''
if n % 2 != 0:
	mid = s[0]
	s = s[1:]
(even, odd) = (s[-2::-2], s[1::2])
print('{}{}{}'.format(even, mid, odd))


n = int(input())
s = list(input())
result = []
for i in range(n):
	if n % 2 == 0:
		if i % 2 == 0:
			result.insert(0, s[i])
		else:
			result.append(s[i])
	elif i % 2 == 0:
		result.append(s[i])
	else:
		result.insert(0, s[i])
print(''.join(result))


n = int(input())
k = input()
d = []
c = list(k)
for i in range(0, n // 2):
	d.append(c[n - 1 - (i * 2 + 1)])
if n % 2 == 0:
	for i in range(0, n // 2):
		d.append(c[i * 2 + 1])
else:
	for i in range(0, n // 2 + 1):
		d.append(c[i * 2])
ans = ''.join(d)
print(ans)


n = int(input())
s = input()
p1 = (n - 1) // 2 + 1
p2 = (n - 1) // 2 - 1
dirr = 1
if n % 2:
	dir = -1
ans = [''] * n
ans[(n - 1) // 2] = s[0]
for i in range(1, n):
	if dirr > 0:
		dirr = -1
		ans[p1] = s[i]
		p1 += 1
	else:
		dirr = 1
		ans[p2] = s[i]
		p2 -= 1
if n % 2:
	for i in range(n // 2):
		(ans[i], ans[n - i - 1]) = (ans[n - i - 1], ans[i])
print(''.join(ans))


import math
n = int(input())
s = input()
ls = [0] * n
start = math.ceil(n / 2) - 1
p = 1
if n % 2:
	p = 0
for i in range(n):
	ls[start] = s[i]
	start += (i + 1) * (-1) ** (i + 1 + p)
print(''.join((i for i in ls)))


n = int(input())
k = input()
h = ''
if n % 2:
	for i in range(0, n - 1, 2):
		h = k[i + 1] + h + k[i]
	print(h + k[-1])
else:
	for i in range(0, n - 1, 2):
		h = k[i] + h + k[i + 1]
	print(h)


n = int(input())
line = str(input())
rest = str()
flag = [True, False][n % 2]
for it in line:
	if flag:
		rest = it + rest
	else:
		rest += it
	flag = False if flag else True
print(rest)


n = int(input())
s = input()
ans1 = ''
ans2 = ''
for i in range(n):
	a = s[n - 1 - i]
	if i % 2 == 0:
		ans2 = a + ans2
	else:
		ans1 += a
print(ans1 + ans2)


n = int(input())
s = list(input())
s = s[::-1]
s1 = [''] * n
for i in range(n):
	s1[[i // 2, -1 - i // 2][i % 2 == 0]] = s[i]
print(''.join(s1))


n = int(input())
S = input()
K = ''
if n % 2 == 0:
	for i in range(n):
		if i % 2 == 0:
			K = S[i] + K
		else:
			K = K + S[i]
	print(K)
else:
	for i in range(n):
		if i % 2 == 0:
			K = K + S[i]
		else:
			K = S[i] + K
	print(K)


input()
s = input()
print(s[-2::-2] + s[-1::-2][::-1])


n = int(input())
s = input()
a = [0] * n
if n % 2 != 0:
	for i in range(n // 2 + 1):
		a[n // 2 + i] = s[2 * i]
	for j in range(1, n // 2 + 1):
		a[n // 2 - j] = s[2 * j - 1]
else:
	for i in range(1, n // 2 + 1):
		a[n // 2 - i] = s[2 * i - 2]
	for j in range(n // 2):
		a[n // 2 + j] = s[2 * j + 1]
print(''.join(a))


size = int(input())
encoded_word = input()
(pre_word, post_word) = ('', '')
count = 0
for i in encoded_word[::-1]:
	if count % 2 == 0:
		post_word += i
		count += 1
	else:
		pre_word += i
		count += 1
print(pre_word + post_word[::-1])


class CodeforcesTask746BSolution:

	def __init__(self):
		self.result = ''
		self.word = []

	def read_input(self):
		input()
		self.word = list(input())

	def process_task(self):
		decoded = ''
		left = not len(self.word) % 2
		while self.word:
			c = self.word.pop(0)
			if left:
				decoded = c + decoded
			else:
				decoded += c
			left = not left
		self.result = decoded

	def get_result(self):
		return self.result
Solution = CodeforcesTask746BSolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())


input()
word = input()
res = ''
for i in word[::-1]:
	res = res[0:len(res) // 2] + i + res[len(res) // 2:]
print(res)


n = int(input())
s = input()
r = ''
for i in range(n):
	if n % 2 != 0 and i % 2 == 0 or (n % 2 == 0 and i % 2 != 0):
		r += s[i]
	else:
		r = s[i] + r
print(r)


num = int(input())
word = input()
if num % 2 == 1:
	flag = True
else:
	flag = False
source_word = ''
if word != '':
	for s in word:
		if not flag:
			source_word = s + source_word
		else:
			source_word = source_word + s
		flag = not flag
	print(source_word)
else:
	print('')


n = int(input())
encoded = input()
decoded = list()
beg = 0
end = 0
for i in range(n - 1, -1, -1):
	decoded.insert(int((beg + end) / 2), encoded[i])
	end += 1
decodedStr = ''
for i in range(n):
	decodedStr += decoded[i]
print(decodedStr)


n = int(input())
s = str(input())
l = []

def medianPos(n):
	n += 1
	return 1 if n == 1 else n // 2 - 1 if n % 2 == 0 else n // 2
for c in reversed(list(s)):
	pos = medianPos(len(l))
	l.insert(pos, c)
print(''.join(l))


n = int(input())
l = list(input())
p = []
for i in range(n - 2, -1, -2):
	p.append(l[i])
	l.pop(i)
for i in range(len(l)):
	p.append(l[i])
s = ''.join(p)
print(s)


input()
word = input()
result = ''
right = len(word) % 2
for letter in word:
	result = result + letter if right else letter + result
	right = not right
print(result)


def list_num(number):
	lists = []
	while number > 0:
		if number % 2 == 1:
			lists.append(1)
			number -= 1
		else:
			lists.append(2)
			number -= 2
	return lists

def insertstr(str1, str2, n):
	str2 = list(str2)
	list_len = len(str2)
	str2.insert(list_len // 2, str1[-n:])
	return ''.join(str2)

def rest(strs, n):
	return strs[:-n]
while True:
	try:
		number = int(input())
		first = input()
		last = ''
		numlist = list_num(number)
		numlist.reverse()
		for i in numlist:
			last = insertstr(first, last, i)
			first = rest(first, i)
		print(last)
	except EOFError:
		break


inp = int(input())
inp1 = input()
s = inp1[0]
if inp % 2 != 0:
	for num in range(1, inp):
		if num % 2 != 0:
			s = inp1[num] + s
		else:
			s = s + inp1[num]
else:
	for num in range(1, inp):
		if num % 2 != 0:
			s = s + inp1[num]
		else:
			s = inp1[num] + s
print(s)


def encode(leng, word):
	if leng == 1:
		return word
	if leng % 2 == 1:
		return word[int(leng / 2)] + encode(leng - 1, word[:int(leng / 2)] + word[int(leng / 2) + 1:])
	else:
		return word[int(leng / 2) - 1] + encode(leng - 1, word[:int(leng / 2) - 1] + word[int(leng / 2):])

def decode(leng, code):
	if leng == 1:
		return code
	if leng % 2 == 1:
		return code[leng - 2:0:-2] + code[0:leng:2]
	else:
		return code[leng - 2:0:-2] + code[0] + code[1:leng:2]
leng = int(input())
word = str(input())
print(decode(leng, word))


n = int(input())
s = input()
if n == 1 or n == 2:
	(print(s, end=''),)
elif n % 2 == 1:
	for i in range(n - 1, -1, -1):
		if i % 2 != 0:
			print(s[i], end='')
	for i in range(0, n):
		if i % 2 == 0:
			print(s[i], end='')
else:
	for i in range(n - 1, -1, -1):
		if i % 2 == 0:
			print(s[i], end='')
	for i in range(0, n):
		if i % 2 != 0:
			print(s[i], end='')


def rev(s):
	result = ''
	for j in range(len(s) - 1, -1, -1):
		result += s[j]
	return result
n = int(input())
s = str(input())
(s1, s2) = ('', '')
for j in range(n):
	if n % 2 == 0:
		if j % 2 == 0:
			s1 += s[j]
		else:
			s2 += s[j]
	elif j % 2 == 0:
		s2 += s[j]
	else:
		s1 += s[j]
print(rev(s1) + s2)


n = input()
code = list(input())
even = len(code) % 2 == 0
word = [code[0]]
code.remove(code[0])
if not even:
	while len(code) != 0:
		char = code[0]
		elements = len(word)
		if elements % 2 == 0:
			word.append(char)
		else:
			word.insert(0, char)
		code.remove(char)
else:
	while len(code) != 0:
		char = code[0]
		elements = len(word)
		if elements % 2 == 0:
			word.insert(0, char)
		else:
			word.append(char)
		code.remove(char)
print(''.join(word))


import sys
import math
import bisect
import itertools
import random

def main():
	n = int(input())
	A = list(input())
	B = ['a'] * n
	index = 0
	if n % 2 == 1:
		for i in range((n - 1) // 2, -1, -1):
			j = n - 1 - i
			if j == i:
				B[i] = A[index]
				index += 1
			else:
				B[i] = A[index]
				index += 1
				B[j] = A[index]
				index += 1
	else:
		for i in range((n - 1) // 2, -1, -1):
			j = n - 1 - i
			B[i] = A[index]
			index += 1
			B[j] = A[index]
			index += 1
	print(''.join(B))
main()


r = int(input(''))
x = list(str(input('')))
k = ''
k = x[0]
if r % 2 == 0:
	for i in range(1, len(x)):
		if i % 2 != 0:
			k = k + x[i]
		else:
			k = x[i] + k
else:
	for i in range(1, len(x)):
		if i % 2 == 0:
			k = k + x[i]
		else:
			k = x[i] + k
print(k)


n = int(input())
l = list(input())
a = [''] * n
if n % 2 != 0:
	k = 1
	mid = n // 2
	a[mid] = l[0]
	for i in range(1, n):
		if i % 2 != 0:
			a[mid - k] = l[i]
		else:
			a[mid + k] = l[i]
			k += 1
	print(''.join(a))
else:
	k = 0
	t = 1
	mid = n // 2 - 1
	for i in range(0, n):
		if i % 2 == 0:
			a[mid - k] = l[i]
			k += 1
		else:
			a[mid + t] = l[i]
			t += 1
	print(''.join(a))


n = int(input())
data = input()
ans = list(data)
if n % 2 == 1:
	n = n >> 1
	i = 0
	for x in data:
		ans[n + i] = x
		if i == 0:
			i = -1
		else:
			i = -i if i < 0 else -i - 1
else:
	n = (n >> 1) - 1
	i = 0
	for x in data:
		ans[n + i] = x
		if i == 0:
			i = 1
		else:
			i = -i + 1 if i < 0 else -i
print(''.join(ans))


n = int(input())
s = input()
ans = ''
i = 0
if n == 1 or n == 2:
	print(s)
else:
	if n % 2 == 1:
		ans = s[0]
		i = 1
	else:
		ans = s[0] + s[1]
		i = 2
	for j in range(i, n, 2):
		ans = s[j] + ans + s[j + 1]
	print(ans)


(n, s) = (int(input()), input())
l = l1 = ''
if n % 2 != 0:
	for i in range(n):
		if (n - 1 - i) % 2 != 0:
			l += s[n - 1 - i]
		if i % 2 == 0:
			l1 += s[i]
elif n % 2 == 0:
	for i in range(n):
		if (n - 1 - i) % 2 == 0:
			l += s[n - 1 - i]
		if i % 2 != 0:
			l1 += s[i]
print(l + l1)


def pri(s, n):
	a = ''
	b = ''
	for i in range(0, n, 2):
		a += s[i]
	for i in range(n - 2, 0, -2):
		b += s[i]
	print(b + a)
n = int(input())
s = input()
if n & 1:
	pri(s, n)
else:
	a = ''
	b = ''
	for i in range(n - 2, -1, -2):
		a += s[i]
	for i in range(1, n, 2):
		b += s[i]
	print(a + b)


n = int(input())
m = (n - 1) // 2
s = input()
l = [''] * n
l[m] = s[0]
e = 1
for i in range(1, n):
	if n % 2 == 0:
		if i % 2 != 0:
			l[m + e] = s[i]
		else:
			l[m - e] = s[i]
			e += 1
	elif i % 2 != 0:
		l[m - e] = s[i]
	else:
		l[m + e] = s[i]
		e += 1
print(''.join(l))


t = int(input())
s1 = input()
s2 = ''
s2 = s2 + s1[0]
if t % 2 != 0:
	for i in range(1, len(s1)):
		if i % 2 != 0:
			s2 = s1[i] + s2
		else:
			s2 = s2 + s1[i]
else:
	for i in range(1, len(s1)):
		if i % 2 != 0:
			s2 = s2 + s1[i]
		else:
			s2 = s1[i] + s2
print(s2)


n = int(input())
r = ''
w = input()
if n % 2 == 0:
	for i in range(n):
		if i % 2 == 0:
			r = w[i] + r
		else:
			r = r + w[i]
else:
	for i in range(n):
		if i % 2 == 0:
			r = r + w[i]
		else:
			r = w[i] + r
print(r)


n = int(input())
s = input()
result = []
count = 1
for c in reversed(s):
	index = count // 2
	if count % 2 == 0:
		index -= 1
	result.insert(index, c)
	count += 1
print(''.join(result))


def decript(_str, t):
	ss = ''
	for i in range(1, t, 2):
		ss += _str[t - 1 - i]
	if t % 2 == 1:
		for i in range(0, t, 2):
			ss += _str[i]
		return ss
	else:
		for i in range(1, t, 2):
			ss += _str[i]
		return ss
t = int(input())
_str = input()
print(decript(_str, t))


n = int(input())
s = input()
ish_slovo = [0 for i in range(n)]
if n % 2 != 0:
	co = n // 2
	co2 = n // 2
	flag = False
	ish_slovo[n // 2] = s[0]
	for ch in s[1:]:
		if flag:
			co += 1
			ish_slovo[co] = ch
			flag = False
		else:
			co2 -= 1
			ish_slovo[co2] = ch
			flag = True
else:
	co = n // 2 - 1
	co2 = n // 2 - 1
	flag = False
	for ch in s:
		if flag:
			co += 1
			ish_slovo[co] = ch
			flag = False
		else:
			ish_slovo[co2] = ch
			flag = True
			co2 -= 1
print(''.join(ish_slovo))


from sys import stdin
n = int(stdin.readline().strip())
string = stdin.readline().strip()
ans = [-1] * n
l = n
first = n // 2
second = n // 2
if n % 2 == 0:
	first -= 1
	second -= 1
for i in range(n):
	if l % 2:
		if ans[second] != -1:
			second += 1
		ans[second] = string[i]
		second += 1
	else:
		if ans[first] != -1:
			first -= 1
		ans[first] = string[i]
		first -= 1
	l -= 1
print(''.join(ans))


n = int(input())
crypt = input()
word_list = [0 for i in range(n)]
for i in range(n):
	if i % 2 == 0:
		word_list[n - 1 - i // 2] = crypt[n - 1 - i]
	else:
		word_list[i // 2] = crypt[n - 1 - i]
answer = ''
for i in word_list:
	answer += i
print(answer)


import math
x = int(input())
txt = list(input())
txt1 = txt[::-1]
l1 = []
l1.insert(x - 1, txt1[0])
if x != 1:
	l1.insert(0, txt1[1])
	i = 2
	while i != x:
		if len(l1) % 2 == 0:
			n = math.floor(len(l1) / 2)
			l1.insert(n, txt1[i])
		else:
			m = math.floor(len(l1) / 2)
			l1.insert(m, txt1[i])
		i = i + 1
print(''.join(l1))


import sys
n = int(input())
s = input()
r = ''
if n % 2 == 1:
	for i in range(n - 2, 0, -2):
		r += s[i]
	r += s[0]
	for i in range(2, n, 2):
		r += s[i]
else:
	for i in range(n - 2, -1, -2):
		r += s[i]
	for i in range(1, n, 2):
		r += s[i]
print(r)


n = int(input())
s = input()
a = ''
if n % 2 != 0:
	a = s[0]
	s = s[1:]
	n -= 1
s1 = s2 = ''
for i in range(n):
	if i % 2 == 0:
		s1 = s[i] + s1
	else:
		s2 += s[i]
print(s1 + a + s2)


n = int(input())
s = input()
if n % 2 != 0:
	l = [0] * n
	l[n // 2] = s[0]
	lcounter = n // 2 - 1
	rcounter = n // 2 + 1
	for i in range(1, n):
		if i % 2 != 0:
			l[lcounter] = s[i]
			lcounter -= 1
		else:
			l[rcounter] = s[i]
			rcounter += 1
if n % 2 == 0:
	l = [0] * n
	l[n // 2 - 1] = s[0]
	l[n // 2] = s[1]
	lcounter = n // 2 - 2
	rcounter = n // 2 + 1
	for i in range(2, n):
		if i % 2 == 0:
			l[lcounter] = s[i]
			lcounter -= 1
		else:
			l[rcounter] = s[i]
			rcounter += 1
print(''.join(l))


input()
s = input()
a = ''
while s != '':
	a = a + s[0] if len(s) & 1 == 1 else s[0] + a
	s = s[1:]
print(a)


n = int(input())
s = input()
t = ''
i = 0
if n % 2 == 1:
	t = s[0]
	i = 1
while i < n:
	t = s[i] + t + s[i + 1]
	i += 2
print(t)


def main():
	from sys import stdin, stdout
	n = int(stdin.readline())
	s = stdin.readline().strip()
	if n & 1:
		target = s[0]
		s = s[1:]
	else:
		target = ''
	for i in range(len(s)):
		if i & 1:
			target += s[i]
		else:
			target = s[i] + target
	stdout.write(target)
main()


def decode(encoded):
	encoded_letters = list(encoded)
	decoded = ''
	for i in range(0, len(encoded)):
		if i % 2 == 0:
			decoded = decoded + encoded[i]
		else:
			decoded = encoded[i] + decoded
	return decoded if len(decoded) % 2 == 1 else decoded[::-1]
input()
data = input()
print(decode(data))


n = int(input())
s = input()
a = ''
for i in reversed(range(n & 1, n, 2)):
	a += s[i]
for i in range(not n & 1, n, 2):
	a += s[i]
print(a)


n = int(input())
s = list(input())
res = s[-2::-2] + list(reversed(s[-1::-2]))
print(''.join(res))


n = int(input())
s = input()
d = [0 for i in range(n)]
j = 1
mid = n // 2
if n % 2:
	d[mid] = s[0]
	for i in range(1, n):
		if i % 2:
			d[mid - j] = s[i]
		else:
			d[mid + j] = s[i]
			j += 1
else:
	for i in range(n):
		if not i % 2:
			d[mid - j] = s[i]
		else:
			d[mid + j - 1] = s[i]
			j += 1
print(''.join(d))


n = int(input())
s = input()
print(s[-2::-2], end='')
print(s[-1::-2][::-1])


import os
import re
import sys
from bisect import bisect, bisect_left, insort, insort_left
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from fractions import gcd
from io import BytesIO, IOBase
from itertools import accumulate, combinations, combinations_with_replacement, groupby, permutations, product
from math import acos, asin, atan, ceil, cos, degrees, factorial, hypot, log2, pi, radians, sin, sqrt, tan
from operator import itemgetter, mul
from string import ascii_lowercase, ascii_uppercase, digits

def inp():
	return int(input())

def inlist():
	return list(map(int, input().split()))

def instr():
	s = input()
	return list(s[:len(s)])

def invr():
	return map(int, input().split())

def main():
	n = inp()
	a = input()
	res = deque()
	if n % 2 != 0:
		for i in range(n):
			if i % 2 == 0:
				res.append(a[i])
			else:
				res.appendleft(a[i])
	else:
		for i in range(n):
			if i % 2 == 0:
				res.appendleft(a[i])
			else:
				res.append(a[i])
	for c in res:
		print(c, end='')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))

def input():
	return sys.stdin.readline().rstrip('\r\n')
main()


a = 0
z = int(input())
x = [0] * z
for i in input():
	if z % 2 == 0:
		x[z // 2 - 1] = i
	else:
		x[z // 2 + a] = i
	z -= 1
	a += 1
print(''.join(x))


n = int(input())
word = input()
rec = []
rec.append(word[0])
for x in range(1, n):
	if x % 2 == 0:
		rec.append(word[x])
	else:
		rec.insert(0, word[x])
if n % 2 == 0:
	print(''.join(reversed(rec)))
else:
	print(''.join(rec))


n = int(input())
s = input()
if len(s) == 1 or len(s) == 2:
	print(s)
else:
	s = list(s)
	endword = []
	if len(s) % 2 != 0:
		endword.append(s[0])
		del s[0]
	while s:
		endword.insert(0, s[0])
		del s[0]
		endword.append(s[0])
		del s[0]
	endword = ''.join(endword)
	print(endword)


import math, fractions, collections, string
n = int(input())
s = str(input())
flag = 1 if n & 1 else 0
q = collections.deque()
for x in s:
	if flag:
		q.append(x)
		flag = 0
	else:
		q.appendleft(x)
		flag = 1
print(''.join(q))


n = int(input())
s = input()
a = ['0' for i in range(n)]
if n % 2 == 0:
	j = n // 2 - 1
	for i in range(n):
		a[j + pow(-1, i + 1) * i] = s[i]
		j += pow(-1, i + 1) * i
	print(*a, sep='')
elif n % 2 != 0:
	j = n // 2
	for i in range(n):
		a[j + pow(-1, i) * i] = s[i]
		j += pow(-1, i) * i
	print(*a, sep='')


n = int(input())
w = input()
result = ''
for i in range(n - 1, -1, -1):
	l = len(result)
	result = result[:l // 2] + w[i] + result[l // 2:]
print(result)


input()
s = input()
if len(s) % 2 == 0:
	print(s[len(s) - 2::-2], s[1::2], sep='')
else:
	print(*((s[len(s) - 2::-2], s[0], s[2::2]) if len(s) > 1 else s), sep='')


n = int(input())
motChiffre = input()
mot = [''] * n
moitie = n // 2
for i in range(moitie):
	mot[n - i - 1] = motChiffre[n - 1 - 2 * i]
	mot[i] = motChiffre[n - 1 - 2 * i - 1]
if n % 2 == 1:
	mot[moitie] = motChiffre[0]
print(''.join(mot))


def decrypt(n, crypted_word):
	decrypted = []
	for letter in reversed(crypted_word):
		length = len(decrypted)
		if length == 0:
			decrypted.append(letter)
		else:
			middle_index = length // 2
			decrypted.insert(middle_index, letter)
	return ''.join(decrypted)
n = int(input())
crypted_word = input()
word = decrypt(n, crypted_word)
print(word)


(n, s, s_new) = (int(input()), input()[::-1], '')
for i in s:
	s_new = s_new[:len(s_new) // 2] + i + s_new[len(s_new) // 2:]
print(s_new)


n = int(input())
s = str(input())
left = True
if n % 2 == 1:
	left = False
d = ''
for i in range(n):
	if left:
		d = s[i] + d
	else:
		d += s[i]
	left = not left
print(d)


n = int(input())
s = input()
pos = [i for i in range(n)]
idx = []
for i in range(n):
	y = (len(pos) + 1) // 2 - 1
	x = pos.pop(y)
	idx.append(x)
res = [0] * n
for i in range(n):
	res[idx[i]] = s[i]
print(*res, sep='')


n = int(input())
s = input()
t = ''
while len(s) != 0:
	if len(s) % 2 != 0:
		t = t + s[0]
	else:
		t = s[0] + t
	s = s.replace(s[0], '', 1)
print(t)


n = int(input())
code = input()
encode = [None] * n
index = 0
multiplier = 1
for c in code:
	if n % 2 == 1:
		encode[int(n / 2) + multiplier * index] = c
	else:
		encode[int(n / 2) - 1 + multiplier * -1 * index] = c
	if multiplier >= 0:
		index += 1
	multiplier *= -1
retval = ''.join(encode)
print(retval)


N = int(input())
S = input()
if N == 1 or N == 2:
	print(S)
	exit()
ans = ''
for i in range(N - 2, -1, -2):
	ans += S[i]
st = 0 if N % 2 != 0 else 1
for i in range(st, N, 2):
	ans += S[i]
print(ans)


l = int(input())
s = input()
i = 0
ans = ''
while l > 0:
	ch = s[i]
	i += 1
	if l % 2 == 1:
		ans += ch
	else:
		ans = ch + ans
	l -= 1
print(ans)


z = input
mod = 10 ** 9 + 7
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)
n = int(z())
l = list(z())
t = l[::2]
t2 = l[1::2]
s = ''
if n % 2 == 0:
	print(''.join(t[::-1] + t2))
else:
	print(''.join(t2[::-1] + t))


n = input()
s = input()

def solve(n, s):
	ans = s[0]
	right = True
	if n % 2 != 0:
		right = False
	for i in range(n - 1):
		if right:
			ans = ans + s[i + 1]
			right = False
		else:
			right = True
			ans = s[i + 1] + ans
	return ans
print(solve(int(n), s))


n = int(input())
s = input()
Answer = ''
Right = Left = True
if n % 2 != 0:
	Right = False
else:
	Left = False
for i in s:
	if Left:
		Answer = Answer + i
		(Right, Left) = (Left, Right)
	else:
		Answer = i + Answer
		(Right, Left) = (Left, Right)
print(Answer)


n = int(input())
word = input()
s = ''
for l in word:
	if n % 2 == 0:
		s = l + s
	else:
		s = s + l
	word = word[1:]
	n -= 1
print(s)


t = int(input())
r = input()
bef = []
aft = []
if t % 2 == 1:
	tem = r[0]
	for i in range(1, t):
		if i % 2 == 1:
			bef.append(r[i])
		else:
			aft.append(r[i])
	for i in range(len(bef) - 1, -1, -1):
		print(bef[i], end='')
	print(tem, end='')
	for i in range(len(aft)):
		print(aft[i], end='')
else:
	for i in range(0, t):
		if i % 2 == 1:
			bef.append(r[i])
		else:
			aft.append(r[i])
	for i in range(len(aft) - 1, -1, -1):
		print(aft[i], end='')
	for i in range(len(bef)):
		print(bef[i], end='')


import sys

def main():
	pass

def binary(n):
	return bin(n).replace('0b', '')

def decimal(s):
	return int(s, 2)

def pow2(n):
	p = 0
	while n > 1:
		n //= 2
		p += 1
	return p

def isPrime(n):
	if n == 1:
		return False
	else:
		root = int(n ** 0.5)
		root += 1
		for i in range(2, root):
			if n % i == 0:
				return False
		return True

def lts(l):
	s = ''.join(map(str, l))
	return s

def stl(s):
	l = list(s)
	return l

def sq(a, target, arr=[]):
	s = sum(arr)
	if s == target:
		return arr
	if s >= target:
		return
	for i in range(len(a)):
		n = a[i]
		remaining = a[i + 1:]
		ans = sq(remaining, target, arr + [n])
		if ans:
			return ans
mod = int(1000000000.0) + 7

def ssinp():
	return sys.stdin.readline().strip()

def iinp():
	return int(input())

def nninp():
	return map(int, sys.stdin.readline().strip().split())

def llinp():
	return list(map(int, sys.stdin.readline().strip().split()))

def p(xyz):
	print(xyz)

def p2(a, b):
	print(a, b)
import math
from collections import OrderedDict
n = iinp()
s = ssinp()
flag = 0
ans = ''
for c in s:
	if ans == '' and n % 2 == 1:
		ans += c
	elif flag == 0:
		ans = c + ans
		flag = 1
	else:
		ans = ans + c
		flag = 0
p(ans)


n = int(input())
str = input()
ret = {}
if n % 2 == 0:
	ret[n // 2] = str[0]
	ret[n // 2 + 1] = str[1]
	l = n // 2 - 1
	r = n // 2 + 2
	k = 2
else:
	ret[n // 2] = str[0]
	l = n // 2 - 1
	r = n // 2 + 1
	k = 1
for i in range(k, n, 2):
	ret[l] = str[i]
	ret[r] = str[i + 1]
	l = l - 1
	r = r + 1
for i in sorted(ret.keys()):
	print(ret.get(i), end='')


n = int(input())
s = input()
sr = ''
nn = n
if n % 2 == 1:
	flag = True
else:
	flag = False
m = 0
while m < n:
	if flag:
		sr = sr + s[m]
	else:
		sr = s[m] + sr
	flag = not flag
	m += 1
print(sr)


n = int(input())
s = input()
t = ''
for i in range(n - 1, -1, -1):
	t = t[0:len(t) // 2] + s[i] + t[len(t) // 2:n]
print(t)


n = int(input())
s = input()
s1 = s[::2]
s2 = s[1::2][::-1]
if n % 2:
	print(s2 + s1)
else:
	print((s2 + s1)[::-1])


input()
a = input()
print(a[-2::-2] + a[-1::-2][::-1])


garbage = input()
z = input()
result = ''
while z:
	if len(z) % 2:
		result = result + z[0]
	else:
		result = z[0] + result
	z = z[1:]
print(result)


n = int(input())
word = str(input())
decoding = str()
flag = True
decoding = word[0]
if len(word) % 2 != 0:
	for i in range(1, n):
		if flag:
			decoding = word[i] + decoding
			flag = False
		else:
			decoding = decoding + word[i]
			flag = True
	print(decoding)
else:
	for i in range(1, n):
		if flag:
			decoding = decoding + word[i]
			flag = False
		else:
			decoding = word[i] + decoding
			flag = True
	print(decoding)


n = int(input())
s = list(input())
l = []
l.append(s.pop(0))
while len(s) != 0:
	if len(s) % 2 == 1:
		l.append(s.pop(0))
	else:
		l.insert(0, s.pop(0))
print(*l, sep='')


n = int(input())
s = list(input())
a = len(s)
b = []
c = 0
if a % 2 != 0:
	c = s[0]
	del s[0]
	b.append(c)
	a -= 1
k = 0
while a > 0:
	if a % 2 == 0:
		d = s[0]
		del s[0]
		b.insert(0, d)
		a -= 1
	else:
		d = s[0]
		del s[0]
		b.append(d)
		a -= 1
H = ''.join(b)
print(H)


from collections import deque
s = int(input())
q = input()
li = deque()
li.append(q[0])
for k in range(1, len(q)):
	if k % 2:
		li.appendleft(q[k])
	else:
		li.append(q[k])
if not s % 2:
	li.reverse()
print(''.join(li))


n = int(input())
m = n
s = list(input())
ns = []
i = 0
while n > 0:
	ns.insert(i, s[n - 1])
	i += 1
	n -= 1
	if n % 2 == 0:
		i -= 1
if m % 2 == 0:
	ns.reverse()
print(''.join(ns))


def codeforces(word):
	result = ''
	i = len(word) - 2
	while i >= 0:
		result += word[i]
		i -= 2
	if i == -2:
		i = 1
	else:
		i = 0
	while i <= len(word) - 1:
		result += word[i]
		i += 2
	return result
_ = input()
word = input()
print(codeforces(word))


import sys
n = int(input())
s1 = input()
s2 = s1
if n <= 2:
	print(s1)
	sys.exit()
if n % 2 == 0:
	r = int(n / 2 - 1)
	s2 = s2[:r] + s1[0] + s2[r + 1:]
	L = r - 1
	R = r + 1
	i = 1
	while i < n:
		if i % 2 == 0:
			s2 = s2[:L] + s1[i] + s2[L + 1:]
			L -= 1
		else:
			s2 = s2[:R] + s1[i] + s2[R + 1:]
			R += 1
		i += 1
else:
	k = int(n / 2)
	s2 = s2[:k] + s1[0] + s2[k + 1:]
	L = k - 1
	R = k + 1
	i = 1
	while i < n:
		if i % 2 == 0:
			s2 = s2[:R] + s1[i] + s2[R + 1:]
			R += 1
		else:
			s2 = s2[:L] + s1[i] + s2[L + 1:]
			L -= 1
		i += 1
print(s2)


n = int(input())
l = list(input())
m = l
k = []
s = ''
while len(k) != len(l):
	if len(m) % 2 != 0:
		s = s + l[0]
		l.remove(l[0])
	else:
		s = l[0] + s
		l.remove(l[0])
print(s)


i = input
i()
a = i()
print(a[-2::-2] + a[-1::-2][::-1])


n = int(input())
y = input()
f = {}
d = ''
if n == 2:
	print(y)
elif n % 2 == 1:
	for i in range(n - 2, 0, -2):
		d += y[i]
	for i in range(0, n, 2):
		d += y[i]
else:
	for i in range(n - 2, -1, -2):
		d += y[i]
	for i in range(1, n, 2):
		d += y[i]
print(d)


n = int(input())
cr = input()
arr = ['-'] * n
goLeft = True
if n % 2 == 1:
	goLeft = False
res = ''
for i in range(n):
	c = cr[i]
	if goLeft:
		res = c + res
	else:
		res = res + c
	goLeft = not goLeft
print(res)


def encode(l):
	count = len(l) // 2 if len(l) % 2 else len(l) // 2 - 1
	x = l[count]
	l.remove(x)
	return x
n = int(input())
s = input()
anchor = [str(i) for i in range(n)]
ans = [''] * n
res = []
for i in range(n):
	res.append(encode(anchor))
for (i, j) in zip(res, s):
	ans[int(i)] = j
print(''.join(ans))


length = int(input())
script = input()
scriptArr = []
for i in script:
	scriptArr.append(i)
word = scriptArr.copy()
falseElem = 0
trueElem = -1
end = True
for i in range(1, length + 1):
	if end:
		word[trueElem] = scriptArr[-i]
		trueElem = trueElem - 1
		end = False
	else:
		word[falseElem] = scriptArr[-i]
		falseElem = falseElem + 1
		end = True
answer = ''
for i in word:
	answer += i
print(answer)


(n, v) = (int(input()), '')
for (i, ch) in enumerate(input()):
	v = v + ch if n % 2 else ch + v
	n -= 1
print(v)


def solve():
	n = int(input())
	s = [i for i in input()]
	indexes = []
	for i in range(n, 0, -1):
		if i % 2 == 0:
			add = -1
		else:
			add = len(indexes)
		indexes.append(i // 2 + add)
	print(''.join([i[1] for i in sorted(zip(indexes, s))]))
solve()


n = int(input())
word = list(input())
ans = []
i = n - 1
while i >= 0:
	ans.append(word[i])
	i = i - 2
if i == -2:
	i = 1
else:
	i = i + 1
while i < n - 1:
	ans.append(word[i])
	i = i + 2
print(''.join(ans[::-1]))


n = int(input())
s = input()
arr = [''] * len(s)
j = len(s) - 1
for i in range(len(s) - 1, -1, -2):
	arr[j] = s[i]
	j -= 1
j = 0
for i in range(len(s) - 2, -1, -2):
	arr[j] = s[i]
	j += 1
print(''.join(arr))


n = int(input())
s = input()
ans = ''
for x in s[::-1]:
	if len(ans) < 2:
		ans = x + ans
	else:
		ans = ans[:len(ans) // 2] + x + ans[len(ans) // 2:]
print(ans)


from collections import deque
n = int(input())
s = input()
ans = deque()
for i in range(n):
	if i % 2 != n % 2:
		ans.append(s[i])
	else:
		ans.appendleft(s[i])
print(''.join(list(ans)))


n = int(input())
s = input()
ans = ''
ind = round(n / 2 - 1 + 0.1)
q = 1
while s:
	if (n - q) % 2 == 1:
		ans = s[0] + ans
	else:
		ans = ans + s[0]
	q += 1
	s = s[1:]
print(ans)


n = int(input())
s = input()
a = []
b = []
j = ''
j = s[0]
for i in range(1, n):
	if i % 2 != 0:
		q = s[i]
		q += j
		j = q
	else:
		j += s[i]
if n % 2 == 0:
	j = j[::-1]
print(j)


length = int(input())
list = list(input())
list2 = []
for i in range(length):
	list2.append(list[0])
	list.remove(list[0])
	list2.reverse()
list2.reverse()
print(''.join(list2))


n = int(input())
s1 = str(input())
s2 = ''
if n % 2 != 0:
	for i in range(n):
		if i % 2 == 0:
			s2 = s2 + s1[i]
		else:
			s2 = s1[i] + s2
else:
	for i in range(n):
		if i % 2 == 0:
			s2 = s1[i] + s2
		else:
			s2 = s2 + s1[i]
print(s2)


n = input()
s = input()
s_decoded = s[0]
s = s[1:]
while len(s) > 0:
	if len(s) % 2 == 0:
		s_decoded = s[0] + s_decoded
	else:
		s_decoded = s_decoded + s[0]
	s = s[1:]
print(s_decoded)


n = int(input())
s = input()
ans = [0] * n
if n % 2:
	m = n // 2
	ans[m] = s[0]
	j = 1
	for i in range(1, m + 1):
		ans[m - i] = s[j]
		j += 1
		ans[m + i] = s[j]
		j += 1
else:
	m1 = (n - 1) // 2
	m2 = m1 + 1
	j = 0
	for i in range(m2):
		ans[m1 - i] = s[j]
		j += 1
		ans[m2 + i] = s[j]
		j += 1
print(''.join(map(str, ans)))


hat = int(input())
encoded = input()
if hat == 1 or hat == 2:
	print(encoded)
	quit()
encoded = list(encoded)
new = [''] * hat
if hat % 2 == 1:
	j = int(hat / 2)
	counter = 1
	for i in range(hat):
		new[j] = encoded[i]
		if counter % 2 == 0:
			j += counter
		else:
			j -= counter
		counter += 1
else:
	new = [''] * hat
	j = int(hat / 2) - 1
	counter = 1
	for i in range(hat):
		new[j] = encoded[i]
		if counter % 2 == 0:
			j -= counter
		else:
			j += counter
		counter += 1
print(''.join(new), end='')


n = int(input())
s = input()
out = [''] * n
center = (n - 1) // 2
index = center
move = 1 if n % 2 == 0 else -1
(left, right) = (center, center)
for c in s:
	out[index] = c
	if move == 1:
		right += 1
		index = right
	else:
		left -= 1
		index = left
	move *= -1
print(''.join(out))


l = eval(input())
s = input()
c = 0
r = ''
if l % 2 != 0:
	r = s[0]
	c += 1
while len(r) < l:
	r = s[c] + r + s[c + 1]
	c += 2
print(r)


import math
import os
import random
import re
from sys import stdin, stdout
from collections import Counter
from itertools import permutations

def si():
	return str(stdin.readline())

def ii():
	return int(stdin.readline())

def mi():
	return map(int, stdin.readline().split())

def li():
	return list(mi())

def debug(x):
	return stdout.write(str(x))
a = ii()
s = si()
d = ''
for i in range(a):
	if i % 2 == 0:
		d = s[i] + d
	else:
		d += s[i]
if a % 2 == 0:
	print(d)
else:
	print(d[::-1])


input()
word = input()
result = ''
for (i, c) in enumerate(word):
	result = i % 2 != len(word) % 2 and result + c or c + result
print(result)


n = int(input())
s = input()
a = [''] * n
l = 1
b = 0
h = -1
for i in range(n - 1, -1, -1):
	if l % 2 == 1:
		b += 1
		a[n - b] = s[i]
	else:
		h += 1
		a[h] = s[i]
	l += 1
print(''.join(map(str, a)))


z = int(input())
ans = ['0'] * z
if z != 1:
	x = input()
	ans[0] = x[-2]
	ans[-1] = x[-1]
	if z % 2 == 0:
		a1 = z // 2 - 1
		ans[a1] = x[0]
	else:
		a1 = z // 2
		ans[a1] = x[0]
	e = len(x) - 3
	c = 1
	c1 = 1
	for i in range(1, z - 2):
		if e % 2 == 0:
			ans[a1 - c] = x[i]
			c += 1
		else:
			ans[a1 + c1] = x[i]
			c1 += 1
		e -= 1
	print(''.join(ans))
else:
	x = input()
	print(x)