You are given an integer, $N$. Your task is to print an alphabet rangoli of size $N$.
(Rangoli is a form of Indian folk art based on creation of patterns.)

Different sizes of alphabet rangoli are shown below:

#size 3

----c----
--c-b-c--
c-b-a-b-c
--c-b-c--
----c----

#size 5

--------e--------
------e-d-e------
----e-d-c-d-e----
--e-d-c-b-c-d-e--
e-d-c-b-a-b-c-d-e
--e-d-c-b-c-d-e--
----e-d-c-d-e----
------e-d-e------
--------e--------

#size 10

------------------j------------------
----------------j-i-j----------------
--------------j-i-h-i-j--------------
------------j-i-h-g-h-i-j------------
----------j-i-h-g-f-g-h-i-j----------
--------j-i-h-g-f-e-f-g-h-i-j--------
------j-i-h-g-f-e-d-e-f-g-h-i-j------
----j-i-h-g-f-e-d-c-d-e-f-g-h-i-j----
--j-i-h-g-f-e-d-c-b-c-d-e-f-g-h-i-j--
j-i-h-g-f-e-d-c-b-a-b-c-d-e-f-g-h-i-j
--j-i-h-g-f-e-d-c-b-c-d-e-f-g-h-i-j--
----j-i-h-g-f-e-d-c-d-e-f-g-h-i-j----
------j-i-h-g-f-e-d-e-f-g-h-i-j------
--------j-i-h-g-f-e-f-g-h-i-j--------
----------j-i-h-g-f-g-h-i-j----------
------------j-i-h-g-h-i-j------------
--------------j-i-h-i-j--------------
----------------j-i-j----------------
------------------j------------------

The center of the rangoli has the first alphabet letter a, and the boundary has the $N^{th}$ alphabet letter (in alphabetical order).   

Function Description   

Complete the rangoli function in the editor below.   

rangoli has the following parameters:   

int size:  the size of the rangoli  

Returns   

string: a single string made up of each of the lines of the rangoli separated by a newline character (\n)

Input Format

Only one line of input containing $size$, the size of the rangoli.

Constraints

$0<size<27$

Sample Input
5

Sample Output
--------e--------
------e-d-e------
----e-d-c-d-e----
--e-d-c-b-c-d-e--
e-d-c-b-a-b-c-d-e
--e-d-c-b-c-d-e--
----e-d-c-d-e----
------e-d-e------
--------e--------

Difficulty: EASY
Tags: String algorithms

Starter code:

Solutions:
def rangoli(s, center, n):
	k = ''.join(s)
	print(''.join(s))
	if s[0] != '-':
		return
	temp = s
	i = n
	while i > 0:
		temp[center - i] = temp[center - i + 2]
		temp[center + i] = temp[center + i - 2]
		i -= 2
	temp[center] = chr(ord(temp[center - i + 2]) - 1)
	rangoli(temp, center, n + 2)
	print(k)
size = int(input())
s = ['-'] * (4 * size - 3)
s[(4 * size - 3) // 2] = chr(ord('a') + size - 1)
rangoli(s, (4 * size - 3) // 2, 2)


alphabet = 'abcdefghijklmnopqrstuvwxyz'
n = int(input())
for i in range(2 * n - 1):
	line = list('-' * (4 * n - 3))
	nb = n - abs(n - i - 1)
	for j in range(nb):
		line[2 * (n - 1 + j)] = alphabet[n - nb + j]
		line[2 * (n - 1 - j)] = alphabet[n - nb + j]
	print(''.join(line))


N = int(input())
alphabet = 'abcdefghijklmnopqrstuvwxyz'

def fun(i):
	dash = '-' * 2 * (N - i - 1)
	middle = '-'.join(alphabet[N - i - 1:N][::-1] + alphabet[N - i - 1:N][1:])
	print(dash + middle + dash)
for i in range(N):
	fun(i)
for i in range(N - 2, -1, -1):
	fun(i)


import string
N = int(input())
l = string.ascii_lowercase[:N]

def mirror(p):
	return p[::-1] + p[1:]
A = [mirror('-'.join(l[i:] + '-' * i)) for i in range(N)]
A = mirror(A)
print('\n'.join(A))


n = int(input())
for i in range(1, n + 1):
	x = n
	z = i * 2 - 1
	for j in range((n - i) * 2):
		print('-', end='')
	for j in range(z):
		if j <= z // 2:
			x -= 1
		else:
			x += 1
		print(chr(97 + x), end='')
		if j < z - 1:
			print('-', end='')
	for j in range((n - i) * 2):
		print('-', end='')
	print()
for i in range(n - 1, 0, -1):
	x = n
	z = i * 2 - 1
	for j in range((n - i) * 2):
		print('-', end='')
	for j in range(z):
		if j <= z // 2:
			x -= 1
		else:
			x += 1
		print(chr(97 + x), end='')
		if j < z - 1:
			print('-', end='')
	for j in range((n - i) * 2):
		print('-', end='')
	print()


N = int(input())
c = [chr(x) for x in range(97, 97 + N)]
r = [...] * N
for i in range(1, N + 1):
	s = '-'.join(c[-i:]) + '-' * 2 * (N - i)
	r[i - 1] = str(''.join(list(reversed(s[1:])))) + s
r += reversed(r[:N - 1])
print('\n'.join(r))


n = int(input())
copy = n
A = {1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e', 6: 'f', 7: 'g', 8: 'h', 9: 'i', 10: 'j', 11: 'k', 12: 'l', 13: 'm', 14: 'n', 15: 'o', 16: 'p', 17: 'q', 18: 'r', 19: 's', 20: 't', 21: 'u', 22: 'v', 23: 'w', 24: 'x', 25: 'y', 26: 'z'}
c = 4 * n - 3
r = 2 * n - 1
cnt = 1
vals = 1
s = []
ans = []
for i in range(0, r // 2 + 1):
	m = (c - vals) // 2
	lines = '-' * m
	center = ''
	s.append(A[n])
	r = s[:-1]
	f = r.copy()
	x = s.copy()
	x.sort()
	f.extend(x)
	center = '-'.join(f)
	n = n - 1
	cnt = cnt + 2
	vals = 2 * cnt - 1
	ans.append(lines + center + lines)
for i in ans:
	print(i)
ans = ans[::-1]
del ans[0]
for i in ans:
	print(i)


import string
N = int(input())
abc = list(string.ascii_lowercase[0:N])
for i in range(1, 2 * N):
	lini = list('-' * (4 * N - 3))
	k = 0
	for j in abc[abs(N - i):N]:
		lini[2 * N - 2 + k] = j
		lini[2 * N - 2 - k] = j
		k += 2
	print(''.join(lini))


tn = int(input())

def row(n, tn):
	return list(reversed(range(tn - n, tn + 1))) + list(range(tn - n + 1, tn + 1))

def formatted_row(n, tn):
	padding = '--' * (tn - n - 1)
	return padding + '-'.join(['%1s' % chr(ord('a') + x - 1) for x in row(n, tn)]) + padding
for i in range(tn):
	print(formatted_row(i, tn))
for i in range(tn - 2, -1, -1):
	print(formatted_row(i, tn))


__author__ = 'gauth_000'
n = int(input())
if n == 1:
	print('a')
else:
	rangoli = list(list())
	for i in range(2 * n - 1):
		line = list()
		for j in range(4 * n - 3):
			line.append('-')
		rangoli.append(line)
	n = len(rangoli)
	k = m = len(rangoli[0])
	l = 0
	for i in range(n // 2, n):
		c = 97 + l
		for j in range(m // 2, k, 2):
			rangoli[i][j] = chr(c)
			c += 1
		k -= 2
		l += 1
	for i in range(n // 2, n):
		rangoli[i][:m // 2] = rangoli[i][m // 2 + 1:][::-1]
	for i in range(n // 2 + 1, n):
		rangoli[n - i - 1] = rangoli[i]
	for i in range(n):
		for j in range(m):
			print(rangoli[i][j], end='')
		print()


N = int(input())
abc = 'abcdefghijklmnopqrstuvwxyz'
w = 4 * N - 3
h = 2 * N - 1
s = ''
for i in range(N - 1, -1, -1):
	s = ''
	for j in range(N - 1, i, -1):
		s += abc[j] + '-'
	s += abc[i]
	for j in range(i + 1, N):
		s += '-' + abc[j]
	print('{:-^{}}'.format(s, w))
for i in range(1, N):
	s = ''
	for j in range(N - 1, i, -1):
		s += abc[j] + '-'
	s += abc[i]
	for j in range(i + 1, N):
		s += '-' + abc[j]
	print('{:-^{}}'.format(s, w))


from string import ascii_lowercase
n = int(input())
dashes = 2 * (n - 1)
for i in range(n - 1, 0, -1):
	letters = []
	for j in range(n - 1, i, -1):
		letters.append(ascii_lowercase[j])
	for j in range(i, n):
		letters.append(ascii_lowercase[j])
	print('-' * dashes + '-'.join(letters) + '-' * dashes)
	dashes -= 2
for i in range(0, n):
	letters = []
	for j in range(n - 1, i, -1):
		letters.append(ascii_lowercase[j])
	for j in range(i, n):
		letters.append(ascii_lowercase[j])
	print('-' * dashes + '-'.join(letters) + '-' * dashes)
	dashes += 2


N = int(input())
for i in range(N):
	line = ''
	line += '--' * (N - i - 1)
	for k in range(i + 1):
		line += chr(N - k + 96)
		if k != i:
			line += '-'
	print(line, end='')
	print(line[:len(line) - 1][::-1])
for i in range(N - 2, -1, -1):
	line = ''
	line += '--' * (N - i - 1)
	for k in range(i + 1):
		line += chr(N - k + 96)
		if k != i:
			line += '-'
	print(line, end='')
	print(line[:len(line) - 1][::-1])


n = int(input())
letters = 'abcdefghijklmnopqrstuvwxyz'
for i in range(1, n + 1):
	print((n * 2 - 2 * i) * '-', end='')
	for j in range(n - 1, n - i - 1, -1):
		print(letters[j], end='')
		if j != n - i:
			print(end='-')
	for j in range(n - i + 1, n):
		print('-', end=letters[j])
	print((n * 2 - 2 * i) * '-', end='')
	print('')
for i in range(n, 1, -1):
	print((2 + n * 2 - 2 * i) * '-', end='')
	for j in range(n - 1, n - i, -1):
		print(letters[j], end='')
		if j != n - i + 1:
			print(end='-')
	for j in range(n - i + 2, n):
		print('-', end=letters[j])
	print((2 + n * 2 - 2 * i) * '-', end='')
	print('')


def left_side(seq_size, sec_size):
	return ''.join([chr(96 + seq_size - x) + '-' for x in range(sec_size // 2)])

def right_side(seq_size, sec_size):
	return ''.join(['-' + chr(97 + seq_size - x) for x in range(sec_size // 2, 0, -1)])

def mid_section(seq_size, sec_size):
	return left_side(seq_size, sec_size // 2) + chr(96 + seq_size - sec_size // 4) + right_side(seq_size, sec_size // 2)
size = int(input())
for x in range(size - 1):
	print((size * 2 - 2 - 2 * x) * '-', end='')
	print(mid_section(size, 4 * x * +1), end='')
	print((size * 2 - 2 - 2 * x) * '-')
print(mid_section(size, 4 * size - 3))
for x in range(1, size):
	print(2 * x * '-', end='')
	print(mid_section(size, 4 * size - 4 * x - 3), end='')
	print(2 * x * '-')


from string import ascii_lowercase
halfrow = lambda n, i: '-'.join(ascii_lowercase[i:n] + '-' * i)
row = lambda n, i: halfrow(n, i)[::-1][:-1] + halfrow(n, i)
N = int(input())
for i in range(N - 1, -1, -1):
	print(row(N, i))
for i in range(1, N):
	print(row(N, i))


import string
alpha = list(string.ascii_lowercase)
data = int(input())
chars_count = 2 * data - 1
count = int(chars_count / 2)
chars_count -= 1
for k in range(count + 1):
	for i in range(chars_count):
		print('-', end='', flush=True)
	for j in range(k + 1):
		print(alpha[data - j - 1], end='', flush=True)
		if k != 0:
			print('-', end='', flush=True)
	for j in range(k, 0, -1):
		print(alpha[data - j], end='', flush=True)
		if j != 1:
			print('-', end='', flush=True)
	for i in range(chars_count):
		print('-', end='', flush=True)
	chars_count -= 2
	print()
chars_count = 2 * data - 1
count = int(chars_count / 2)
chars_count = 2
for k in range(count, 0, -1):
	for i in range(chars_count):
		print('-', end='', flush=True)
	for j in range(k):
		print(alpha[data - j - 1], end='', flush=True)
		if k != 1:
			print('-', end='', flush=True)
	for j in range(k - 1, 0, -1):
		print(alpha[data - j], end='', flush=True)
		if j != 1:
			print('-', end='', flush=True)
	for i in range(chars_count):
		print('-', end='', flush=True)
	chars_count += 2
	print()


import sys
data = sys.stdin.read()
square = [[]]
letter = int(data) - 1
for i in range(0, int(data) * 2 - 1):
	for j in range(0, int(data) * 2 - 1):
		if abs(i - letter) + abs(j - letter) <= letter:
			print(chr(ord('a') + abs(i - letter) + abs(j - letter)), end='')
			letter = letter
		else:
			print('-', end='')
		if j != int(data) * 2 - 2:
			print('-', end='')
	print('')


n = int(input().strip())
w = (n - 1) * 2 + (n * 2 - 1)
for i in range(1, n, 1):
	number_of_letter = i * 2 - 1
	s = ''
	letter_value = 97 + n - 1
	for i in range(0, number_of_letter):
		if i != 0:
			s += '-'
		s += chr(letter_value)
		if i < (number_of_letter - 1) / 2:
			letter_value = letter_value - 1
		else:
			letter_value = letter_value + 1
	print(s.center(w, '-'))
for i in range(n, 0, -1):
	number_of_letter = i * 2 - 1
	s = ''
	letter_value = 97 + n - 1
	for i in range(0, number_of_letter):
		if i != 0:
			s += '-'
		s += chr(letter_value)
		if i < (number_of_letter - 1) / 2:
			letter_value = letter_value - 1
		else:
			letter_value = letter_value + 1
	print(s.center(w, '-'))


import string
N = int(input())
alph = list(string.ascii_lowercase)[:N]
A = []
for i in range(1, N + 1):
	dash = '-' * (N * 2 - i * 2)
	if i == 1:
		A.append(dash + alph[-i:][0] + dash)
	else:
		A.append(dash + '-'.join(alph[-(i - 1):][::-1] + alph[-i:]) + dash)
for i in A:
	print(i)
A.pop(N - 1)
for i in reversed(A):
	print(i)


import operator
import string

def read_f(f):
	return f(input())
n = read_f(int)
mid = n - 1
for row in range(n * 2 - 1):
	line = ''
	for col in range(n * 2 - 1):
		d = abs(row - mid) + abs(col - mid)
		if col > 0:
			line += '-'
		if d >= n:
			line += '-'
		else:
			line += string.ascii_lowercase[d]
	print(line)


import sys
N = int(sys.stdin.readline())
CENTER = N - 1
MAX = (N - 1) * 2

def absdiff(x, y):
	return abs(x - y)
for i in range(MAX + 1):
	for j in range(MAX + 1):
		d = absdiff(i, CENTER) + absdiff(j, CENTER)
		if d > N - 1:
			print('-', end='')
		else:
			print(chr(ord('a') + d), end='')
		if j != MAX:
			print('-', end='')
	print()


n = int(input())
m = n + 1
char = 1
ans = [0] * m
answer = ''
dash = (n - 1) * 2
character = 96 + n
for i in range(1, n + 1, 1):
	s = dash * '-'
	seq = chr(character)
	for j in range(char - 1):
		seq = chr(character + j + 1) + '-' + seq + '-' + chr(character + j + 1)
	s += seq
	s += dash * '-'
	ans[i] = s
	answer += s + '\n'
	dash -= 2
	char += 1
	character -= 1
for i in range(n - 1, 0, -1):
	answer += ans[i] + '\n'
print(answer)


__author__ = 'namii'

def inside_string(n, k=0):
	alphabets = 'abcdefghijklmnopqrstuvwxyz'
	alphabets = alphabets[k:]
	if n == 0:
		return alphabets[0]
	beg = '-'.join(reversed(alphabets[0:n + 1]))
	end = '-'.join(alphabets[1:n + 1])
	return '-'.join([beg, end])

def rangoli(n):

	def print_row(i):
		print('-' * (2 * i), inside_string(n - i - 1, i), '-' * (2 * i), sep='')
	for j in reversed(range(n)):
		print_row(j)
	for j in range(1, n):
		print_row(j)
N = int(input())
rangoli(N)


zero = ord('a') - 1

def ch(n):
	return chr(n + zero)

def recRang(n):
	if n < 1:
		return
	if n == 1:
		return [['a']]
	else:
		center = recRang(n - 1)
		top = ['-' for i in range(2 * (n - 1))] + [ch(n)] + ['-' for i in range(2 * (n - 1))]
		i = n - 2
		m = len(center) // 2
		while i > 0:
			center[m + i][2 * i - 2] = ch(n)
			center[m - i][-2 * i + 1] = ch(n)
			center[m - i][2 * i - 2] = ch(n)
			center[m + i][-2 * i + 1] = ch(n)
			i -= 1
		for j in range(len(center)):
			center[j] = ['-', '-'] + center[j] + ['-', '-']
		center[n - 2][0] = ch(n)
		center[n - 2][-1] = ch(n)
		return [top] + center + [top]
n = int(input())
res = recRang(n)
for line in res:
	line = ''.join(line)
	print(line)


import itertools
N = int(input())
M = [['-'] * N for _ in range(N)]
for row in range(N):
	for col in range(N - row):
		char = chr(ord('a') + col + row)
		M[row][col] = char
for line in reversed(M):
	print('-'.join(itertools.chain(reversed(line[1:]), line)))
for line in M[1:]:
	print('-'.join(itertools.chain(reversed(line[1:]), line)))


def get_nth_letter(n):
	return chr(n + 96)

def get_num_of_chars(line, size):
	if line == size:
		return size
	return size - line % size

def get_char(size, line, column):
	middle = (size - 1) * 2 + 1
	distance_to_middle = abs(middle - column) // 2
	if column % 2 == 0 or line < distance_to_middle + 1:
		return '-'
	else:
		if line <= size:
			char_to_get = size + (distance_to_middle - line + 1)
		else:
			vertical_distance = line - size
			char_to_get = vertical_distance + distance_to_middle + 1
			if char_to_get > size:
				char_to_get = 0
		if 0 < char_to_get < 27:
			return get_nth_letter(char_to_get)
		else:
			return '-'

def print_wo_nl(a_string):
	print(a_string, end='')
size = int(input())
lines = (size - 1) * 2 + 1
rangoli_size = (size - 1) * 4 + 1
for line in range(1, lines + 1):
	for column in range(1, rangoli_size + 1):
		print_wo_nl(get_char(size, line, column))
	print()


alphabet = 'abcdefghijklmnopqrstuvwxyz'
n = int(input())

def display(x, n):
	s = '-' * ((n - x) * 2)
	for l in range(n - 1, n - 1 - x, -1):
		s += alphabet[l] + '-'
	for l in range(n - x + 1, n):
		s += alphabet[l] + '-'
	c = 4 * n - 3
	s = s[:c]
	while len(s) < c:
		s = s + '-'
	print(s)
for r in range(1, n + 1):
	display(r, n)
for r in range(n - 1, 0, -1):
	display(r, n)


from math import *
n = int(input())
alpha = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
for i in range(n + n - 1):
	for j in range(n + n - 1):
		if abs(n - 1 - i) + abs(n - 1 - j) > n - 1:
			print('-', end='')
		else:
			print(alpha[abs(n - 1 - i) + abs(n - 1 - j)], end='')
		if j != n + n - 2:
			print('-', end='')
		j += 1
	print()


N = int(input().rstrip())
l = 'a'
for i in range(1, N):
	a = chr(ord('a') + i)
	l = a + '-' + l + '-' + a
lines = [l]
ll = len(l)
for i in range(1, int(N - 1 / 2) + 1):
	a = ['-' * i * 2 + l[:int(ll / 2 - i * 2)] + l[int(ll / 2 + i * 2):] + '-' * i * 2]
	lines = a + lines + a
print('\n'.join(lines))


import string
n = int(input())
alpha = list(string.ascii_lowercase)
l = ['-'] * (2 * (n - 1)) + [alpha[n - 1]]
lignes = [l]
for i in reversed(range(n - 1)):
	l = l[2:] + ['-', alpha[i]]
	lignes.append(l)
lignes = lignes + list(reversed(lignes[:len(lignes) - 1]))
for l in [''.join(l + list(reversed(l[:len(l) - 1]))) for l in lignes]:
	print(l)


import sys

def seq(n):
	return '-'.join(reversed([chr(c) for c in range(ord('a'), ord('a') + n)]))

def solve(n):
	s = seq(n)
	ans = []
	for i in range(1, n * 2):
		a = min(i, 2 * n - i)
		b = (n - a) * 2
		c = s[:a * 2 - 1]
		ans.append('-' * b + c + c[::-1][1:] + '-' * b)
	return '\n'.join(ans)
print(solve(int(sys.stdin.readline().strip())))


a = []
n = int(input())
for i in range(1, n + 1):
	s = '-' * (2 * (n - i))
	l = []
	for j in range(0, i):
		l.append(chr(ord('a') + n - 1 - j))
	s = s + '-'.join(l)
	s = s + s[:-1][::-1]
	a.append(s)
a = a + a[:-1][::-1]
for i in a:
	print(i)


n = int(input())
dim = 2 * n - 1
mat = [['-' for i in range(dim)] for j in range(dim)]
mid = dim // 2
for row in range(n):
	for col in range(mid, mid + row + 1):
		mat[row][col] = chr(97 + n - row - 1 + col - mid)
for row in range(n):
	for col in range(mid, dim):
		mat[row][dim - col - 1] = mat[row][col]
for row in range(n, 2 * n - 1):
	mat[row] = mat[2 * n - row - 2]
for row in mat:
	print('-'.join(row))


n = int(input())
i = 0
arr = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
while i < 2 * n - 1:
	j = 0
	while j < 4 * n - 3:
		if j + 2 * i < 2 * n - 2 or j + 2 * i > 6 * n - 6 or j - 2 * i > 2 * n - 2 or (2 * i - j > 2 * n - 2):
			print('-', end='')
		else:
			k = 0
			if j >= 2 * n - 2 and i < n:
				k = (j - 2 * i) / 2
			elif j < 2 * n - 2 and i < n:
				k = (4 * n - j - 2 * i - 4) / 2
			elif j >= 2 * n - 2 and i >= n:
				k = (j + 2 * i - 4 * n + 4) / 2
			else:
				k = (-j + 2 * i) / 2
			print(arr[int(k)], end='')
			if j != 4 * n - 4:
				print('-', end='')
				j += 1
		j += 1
	print('')
	i += 1


N = int(input())
num_dashes = (N - 1) * 2
high_char = chr(N + 96)
alpha_str = high_char
cached_lines = []
for i in range(0, num_dashes + 1, 2):
	new_str = '-' * (num_dashes - i) + alpha_str + '-' * (num_dashes - i)
	cached_lines.append(new_str)
	print(new_str)
	alpha_str = alpha_str[:len(alpha_str) // 2 + 1] + '-' + chr(ord(alpha_str[len(alpha_str) // 2]) - 1) + '-' + alpha_str[len(alpha_str) // 2:]
for i in range(len(cached_lines) - 2, -1, -1):
	print(cached_lines[i])


def printRow(row):
	for i in row:
		print(i, end='')
	print()
n = int(input())
alphabet = [chr(i) for i in range(97, 97 + n)]
size = n + n - 1 + (n - 1) * 2
length = n * 2 - 1
grid = [['-' for _ in range(size)] for _ in range(length)]
num_letters = 1
for row in range(length // 2 + 1):
	index1 = size // 2
	index2 = index1
	letters = alphabet[-num_letters:]
	for i in range(num_letters):
		letter = letters[i]
		grid[row][index1] = letter
		grid[row][index2] = letter
		index1 -= 2
		index2 += 2
	num_letters += 1
	grid[-(row + 1)] = grid[row]
for row in grid:
	printRow(row)


import sys
stdin = sys.stdin
n = int(stdin.readline())
for i in range(2 * n - 1):
	d = n - 1 - abs(n - 1 - i)
	for j in range(4 * n - 3):
		if j % 2 == 0 and abs((j - (2 * n - 2)) // 2) <= d:
			sys.stdout.write(chr(97 + n - 1 - (d - abs((j - (2 * n - 2)) // 2))))
		else:
			sys.stdout.write('-')
	sys.stdout.write('\n')


N = int(input())
for i in range(N):
	for j in range(2 * (N - 1) - 2 * i):
		print('-', end='')
	c = N - 1
	for k in range(N - 1 - i, N):
		print(chr(ord('a') + c), end='')
		if k != N - 1:
			print('-', end='')
		c -= 1
	k = ord('a') + N
	for j in range(i, 0, -1):
		print('-', end='')
		print(chr(k - j), end='')
	for k in range(2 * (N - 1) - 2 * i):
		print('-', end='')
	print('')
for i in range(N - 2, -1, -1):
	for j in range(2 * (N - 1) - 2 * i):
		print('-', end='')
	c = N - 1
	for k in range(N - 1 - i, N):
		print(chr(ord('a') + c), end='')
		if k != N - 1:
			print('-', end='')
		c -= 1
	k = ord('a') + N
	for j in range(i, 0, -1):
		print('-', end='')
		print(chr(k - j), end='')
	for k in range(2 * (N - 1) - 2 * i):
		print('-', end='')
	print('')


from string import ascii_lowercase as letters
N = int(input())
width = N * 4 - 3
for i in range(N * 2 - 1):
	letter_start = N
	letter_end = abs(N - i - 1)
	letter = letters[letter_end:letter_start]
	full_letters = list(map(str, reversed(letter[1:]))) + list(letter)
	split = '-'.join(full_letters)
	padding = (width - len(split)) // 2
	print('-' * padding + split + '-' * padding)


N = int(input())
if N == 1:
	print('a')
else:
	for i in range(N):
		print('-' * (2 * N - 2 - 2 * i), end='')
		for j in range(i + 1):
			print(chr(ord('a') - 1 + N - j) + '-', end='')
		for j in range(i - 1, 0, -1):
			print(chr(ord('a') - 1 + N - j) + '-', end='')
		if i != 0:
			print(chr(ord('a') - 1 + N), end='')
		print('-' * (2 * N - 2 - 2 * i - 1), end='')
		if i != 0 and i != N - 1:
			print('-', end='')
		print()
	for i in range(N - 2, -1, -1):
		print('-' * (2 * N - 2 - 2 * i), end='')
		for j in range(i + 1):
			print(chr(ord('a') - 1 + N - j) + '-', end='')
		for j in range(i - 1, 0, -1):
			print(chr(ord('a') - 1 + N - j) + '-', end='')
		if i != 0:
			print(chr(ord('a') - 1 + N), end='')
		print('-' * (2 * N - 2 - 2 * i - 1), end='')
		if i != 0 and i != N - 1:
			print('-', end='')
		print()


N = int(input())
next_val = ord('a') + (N - 1)
image = []
list_letters = []
for i in range(0, N):
	lineBack = '-'.join(reversed(list_letters))
	if lineBack:
		lineBack = '-' + lineBack
	list_letters.append(chr(next_val))
	next_val -= 1
	pad = (N - i - 1) * 2 * '-'
	line = pad + '-'.join(list_letters) + lineBack + pad
	image.append(line)
image.extend(reversed(image[:-1]))
for line in image:
	print(line)


from string import ascii_lowercase as lc
N = int(input())
letters = list(lc[0:N])
rev = letters[::-1]
seq = rev + letters[1:]
mat = []
for i in range(len(seq) // 2 + 1):
	mat.append(seq)
for (i, line) in enumerate(mat):
	mat[i] = line[0:i + 1]
	if i > 0:
		mat[i] = mat[i][0:i] + mat[i][::-1]
revs = mat[::-1]
revs = revs[1:]
mat.extend(revs)
for line in mat:
	st = ''
	for elem in line:
		st = elem + '-' + st
		st = st.rstrip('-')
	print('{:-^{n}}'.format(st, n=len(seq * 2) - 1))


import string

def rangoli(n):
	res = []
	for i in range((n - 1) * 2 + 1):
		cur = []
		length = ((n - 1) * 2 + 1) * 2 - 1
		for j in range(length):
			if j % 2 == 0 and j / 2 >= abs(n - 1 - i) and (j / 2 <= 2 * (n - 1) - abs(n - 1 - i)):
				cur.append(string.ascii_letters[abs(n - 1 - i) + abs(n - 1 - j // 2)])
			else:
				cur.append('-')
		res.append(cur)
	return res

def run():
	n = int(input())
	res = rangoli(n)
	print('\n'.join([''.join(item) for item in res]))
run()


n = int(input())
a = list(map(lambda x: chr(ord('a') + x), range(0, n)))
b = '-'.join(a)
c = b[::-1]
l = []
first = 1
t = 0
while n > 0:
	node = '-' * t + c + b[1:] + '-' * t
	l.append(node)
	if not first:
		l.insert(0, node)
	first = 0
	b = b[2:]
	c = c[:-2]
	n = n - 1
	t = t + 2
for x in l:
	print(x)


n = int(input())
out = ''
a = ord('a')
c = a + n - 1
for i in range(n):
	out = '-' * (n - i - 1) * 2
	for j in range(i + 1):
		out += chr(c - j) + '-'
	for j in range(i, 0, -1):
		out += chr(c - j + 1) + '-'
	out += '-' * (n - i - 1) * 2
	print(out[:-1])
for i in range(n - 1, 0, -1):
	out = '-' * (n - i) * 2
	for j in range(i - 1):
		out += chr(c - j) + '-'
	for j in range(i, 0, -1):
		out += chr(c - j + 1) + '-'
	out += '-' * (n - i) * 2
	print(out[:-1])


def getRangoli(n):
	r = []
	letters = [chr(ord('a') + x) for x in range(26)]
	hold = curr = n - 1
	for i in range(n):
		line = ''
		for j in range(2 * n - 1):
			if j % 2 == 1:
				line += '-'
			else:
				num = (2 * n - 2 - j) // 2 + curr
				if num <= hold:
					line += letters[num]
				else:
					line += '-'
		line = line + line[:-1][::-1]
		curr -= 1
		r.append(line)
	for i in range(n - 2, -1, -1):
		r.append(r[i][:])
	return r
n = int(input())
r = getRangoli(n)
for l in r:
	print(l)


def gen(n):
	for i in range(n * 2 - 1):
		yield (n - abs(i - n + 1))
n = int(input())
for i in gen(n):
	print('-'.join((chr(ord('a') + n - j) for j in gen(i))).center(n * 4 - 3, '-'))


import string
n = int(input())
nChars = n + n - 1
lineLen = nChars + nChars - 1
upperHalfLines = []
for i in range(n):
	line = list('-' * lineLen)
	pos = n + n - 1 - 1
	chPos = n - 1 - i
	cnt = 0
	while cnt <= i:
		line[pos] = string.ascii_lowercase[chPos]
		pos -= 2
		chPos += 1
		cnt += 1
	pos = n + n - 1 - 1 + 2
	chPos = n - 1 - i + 1
	cnt = 0
	while cnt < i:
		line[pos] = string.ascii_lowercase[chPos]
		pos += 2
		chPos += 1
		cnt += 1
	print(''.join(line))
	if i < n - 1:
		upperHalfLines.append(''.join(line))
for line in reversed(upperHalfLines):
	print(line)


from string import ascii_lowercase as ch

def rangoli(n):
	res = ['--' * i + '-'.join(ch[i + 1:n][::-1] + ch[i:n]) + '--' * i for i in range(n)]
	res = res[::-1]
	res += res[::-1][1:]
	return '\n'.join(res)
print(rangoli(int(input())))


n = int(input())
for i in range(0, n):
	for j in range(0, 2 * (n - 1) - 2 * i):
		print('-', end='')
	for j in range(0, i + 1):
		print(chr(ord('a') + n - j - 1), end='')
		if i != 0:
			print('-', end='')
	for j in range(0, i):
		print(chr(ord('a') + n - i + j), end='')
		if j != i - 1:
			print('-', end='')
	for j in range(0, 2 * (n - 1) - 2 * i):
		print('-', end='')
	print()
for i in range(1, n):
	for j in range(0, 2 * i):
		print('-', end='')
	for j in range(0, n - i - 1):
		print(chr(ord('a') + n - j - 1), end='')
		print('-', end='')
	for j in range(0, n - i):
		print(chr(ord('a') + i + j), end='')
		if j != n - i - 1:
			print('-', end='')
	for j in range(0, 2 * i):
		print('-', end='')
	print()


t = int(input())
arr = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
if t == 1:
	print('a')
else:
	for i in range(1, t + 1):
		y = 4 * i + 1
		u = 4 * t - 3
		for j in range(0, int((u - y) / 2) + 2):
			print('-', end='')
		for k in range(0, i):
			print(arr[t - k - 1], end='')
			print('-', end='')
		for k in range(i - 1, 0, -1):
			print(arr[t - k], end='')
			if k != 1:
				print('-', end='')
		if i == 1:
			for j in range(0, int((u - y) / 2) + 1):
				print('-', end='')
		else:
			for j in range(0, int((u - y) / 2) + 2):
				print('-', end='')
		print('')
	for i in range(t - 1, 0, -1):
		y = 4 * i + 1
		u = 4 * t - 3
		for j in range(0, int((u - y) / 2) + 2):
			print('-', end='')
		for k in range(0, i):
			print(arr[t - k - 1], end='')
			print('-', end='')
		for k in range(i - 1, 0, -1):
			print(arr[t - k], end='')
			if k != 1:
				print('-', end='')
		if i == 1:
			for j in range(0, int((u - y) / 2) + 1):
				print('-', end='')
		else:
			for j in range(0, int((u - y) / 2) + 2):
				print('-', end='')
		print('')


N = int(input())
alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
alpha = alphabet[0:N]
ralpha = alpha[::-1]
extended = []
extended += ralpha[:-1]
extended += alpha
w = 2 * (len(alpha) + len(ralpha)) - 3
for i in range(0, N):
	if i == N - 1:
		break
	elif i == 0:
		line = ralpha[0]
	else:
		line = ralpha[0:i + 1]
		line += alpha[-i:N]
	print('-'.join(line).center(w, '-'))
print('-'.join(extended).center(w, '-'))
for i in range(N):
	if i == 0:
		continue
	elif i == N - 1:
		line = ralpha[0]
	elif i == N:
		break
	else:
		line = ralpha[0:N - i]
		ww = len(line)
		line += alpha[-(ww - 1):]
	print('-'.join(line).center(w, '-'))


import string
size = int(input())
alphaslice = string.ascii_lowercase[:size][::-1]
out_lines = ['-' * (size * 2 - 1 + (size * 2 - 2))] * size
center = len(out_lines[0]) // 2
for i in range(1, size + 1):
	line_chars = alphaslice[:i]
	line_chars += line_chars[::-1][1:]
	start = center - 2 * (i - 1)
	pos = start
	for (j, char) in enumerate(line_chars):
		pos = start + 2 * j
		out_lines[i - 1] = out_lines[i - 1][:pos] + char + out_lines[i - 1][pos + 1:]
out_lines.extend(out_lines[:size - 1][::-1])
for line in out_lines:
	print(line)


import string
import copy

def alphabet_rangoli(N):
	alphabet = list(string.ascii_lowercase[:N])
	lines = alphabet_lines(alphabet)
	return '\n'.join([filled_line(line, N) for line in lines])

def filled_line(line, N):
	filled_line = '-'.join(line)
	line_size = 2 * (2 * N - 1) - 1
	dashes_per_side = (line_size - len(filled_line)) // 2
	dashes = '-' * dashes_per_side
	return dashes + filled_line + dashes

def alphabet_lines(alphabet):
	middle_line = line_for(alphabet)
	return upper_lines_for(alphabet[1:]) + [middle_line] + bottom_lines_for(alphabet[1:])

def upper_lines_for(alphabet):
	return bottom_lines_for(alphabet)[::-1]

def bottom_lines_for(alphabet):
	lines = []
	while len(alphabet) > 0:
		line = line_for(alphabet)
		lines.append(line)
		alphabet = alphabet[1:]
	return lines

def line_for(alphabet):
	middle = [alphabet[0]]
	right_side = alphabet[1:]
	left_side = right_side[::-1]
	return left_side + middle + right_side
N = int(input())
alphabet = list(string.ascii_lowercase[:N])
print(alphabet_rangoli(N))


n = int(input())
for i in range(n - 1, -1, -1):
	for j in range(i):
		print(end='--')
	for j in range(n - 1, i, -1):
		print(chr(j + 97), end='-')
	for j in range(i, n):
		if j != n - 1:
			print(chr(j + 97), end='-')
		else:
			print(chr(j + 97), end='')
	for j in range(2 * i):
		print(end='-')
	print()
for i in range(1, n):
	for j in range(i):
		print(end='--')
	for j in range(n - 1, i, -1):
		print(chr(j + 97), end='-')
	for j in range(i, n):
		if j != n - 1:
			print(chr(j + 97), end='-')
		else:
			print(chr(j + 97), end='')
	for j in range(2 * i):
		print(end='-')
	print()


n = int(input())
import sys
if n == 1:
	print('a')
	sys.exit()
for k in range(n):
	for j in range(n - k - 1):
		print('--', end='')
	for p in range(k + 1):
		print(chr(96 + n - p), end='')
		print('-', end='')
	for p in range(k):
		print(chr(97 + p + n - k), end='')
		if k == n - 1 and k - p == 1:
			pass
		else:
			print('-', end='')
	for j in range(n - k - 1):
		print('-', end='')
	for j in range(n - k - 2):
		print('-', end='')
	print()
for k in range(n - 1):
	for j in range(k + 1):
		print('--', end='')
	for p in range(n - k - 1):
		print(chr(96 + n - p), end='')
		print('-', end='')
	for q in range(n - k - 2):
		print(chr(97 + k + 2 + q), end='')
		print('-', end='')
	for j in range(k):
		print('-', end='')
	for j in range(k + 1):
		print('-', end='')
	print()


N = int(input())
from string import ascii_lowercase as letters
ans = []
l = 1
tot = N * 2 - 1
temp = N
while temp > 0:
	dash = tot - 2 * l + 1
	line = '-' * dash
	line += '-'.join(letters[N - l:N][::-1])
	line += line[-2::-1]
	ans.append(line)
	temp -= 1
	l += 1
for i in range(len(ans) - 1, 0, -1):
	ans.append(ans[i - 1])
for line in ans:
	print(line)


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

def uu(m):
	print('-' * (2 * (n - m)), end='')

def mm(m):
	end = n
	l = sorted(o[m:end], reverse=True)
	v = []
	v.extend(l)
	if l != []:
		l.pop()
	v.extend(sorted(l))
	print('-'.join(v), end='')
for m in range(n):
	uu(m + 1)
	mm(n - m - 1)
	uu(m + 1)
	print()
for m in range(n - 1):
	uu(n - m - 1)
	mm(m + 1)
	uu(n - m - 1)
	print()


base_letter = 96
N = int(input())

def center_letters(number, N):
	letters = []
	for k in range(number):
		letters.append(chr(base_letter + (N - k)))
	if len(letters) > 1:
		letters = letters + [l for l in reversed(letters[:-1])]
	dashes = ['-' for m in range(N - number)]
	return dashes + letters + dashes
for i in range(1, N):
	print('-'.join(map(str, center_letters(i, N))))
print('-'.join(map(str, center_letters(N, N))))
for j in range(N - 1, 0, -1):
	print('-'.join(map(str, center_letters(j, N))))


from string import ascii_lowercase as abc

def read_tests():
	N = int(input())
	return N

def solution(n):
	res = []
	k = 2 * n - 1
	for i in range(n):
		res.append(['-' if j + i < n - 1 else abc[k - i - j - 1] for j in range(n)])
	for (i, row) in enumerate(res):
		res[i] = row + row[-2::-1]
	res += res[-2::-1]
	return res
test = read_tests()
for row in solution(test):
	print('-'.join(list(row)))


count = int(input())

def test():
	s = 'abcdefghijklmnopqrstuvwxyz'
	l = []
	for i in range(count):
		ss = '-'.join((i for i in s[i + 1:count]))
		if i == 0:
			l.append(ss[::-1] + '-' + s[i] + '-' + ss)
		else:
			x = ss[::-1] + '-' + s[i] + '-' + ss
			c = len(l[0]) - len(x)
			l.append('-' * int(c / 2) + x + '-' * int(c / 2))
	print('\n'.join((line for line in l[::-1] + l[1:])))
if count == 1:
	print('a')
else:
	test()


import string
table = string.ascii_lowercase

def form_line(n, i, line):
	i1 = i2 = 2 * n - 2
	while i >= 0:
		line[i1] = table[n - i - 1]
		line[i2] = table[n - i - 1]
		i1 -= 2
		i2 += 2
		i -= 1
n = int(input())
half = [['-' for _ in range(4 * n - 3)] for _ in range(n)]
for i in range(n):
	form_line(n, i, half[i])
for i in half:
	print(''.join(i))
half = half[:-1]
for i in half[::-1]:
	print(''.join(i))


size = int(input())
last = chr(ord('a') + size - 1)
dashes = (size - 1) * 2

def print_letters(i):
	arr = list()
	letter = ord(last)
	while len(arr) < i:
		arr.append(chr(letter))
		letter -= 1
	letter += 1
	while letter < ord(last):
		letter += 1
		arr.append(chr(letter))
	print('-'.join(arr), end='')
for i in range(size):
	print('-' * dashes, end='')
	print_letters(i + 1)
	print('-' * dashes, end='\n')
	dashes -= 2
dashes = 2
for i in range(size - 1)[::-1]:
	print('-' * dashes, end='')
	print_letters(i + 1)
	print('-' * dashes, end='\n')
	dashes += 2


n = int(input())
count = 0
count1 = 0
v = n + 1
v1 = n
for i in range(0, n):
	for j in range(n - i - 1, 0, -1):
		print('--', end='')
	for j in range(n, n - i - 1, -1):
		if count == 0:
			print(chr(j + 96), end='')
			count = count + 1
		else:
			print(chr(j + 96), end='')
			print('-', end='')
	q = v
	for j in range(n, n - i, -1):
		print(chr(q + 96), end='')
		q = q + 1
		if q != n + 1:
			print('-', end='')
	v = v - 1
	for j in range(n - i - 1, 0, -1):
		print('--', end='')
	print()
for i in range(0, n - 1):
	for j in range(0, i + 1):
		print('--', end='')
	q = v1
	for j in range(0, n - i - 1):
		print(chr(q + 96), end='')
		if i < n - 2:
			print('-', end='')
		q = q - 1
	for j in range(i + 2, n):
		print(chr(j + 97), end='')
		if j < n - 1:
			print('-', end='')
	for j in range(0, i + 1):
		print('--', end='')
	print()


n = int(input())
letters = 'abcdefghijklmnopqrstuvwxyz'
letters = letters[:n]
startString = ''
first = True
for letter in letters[-1:0:-1] + letters:
	if first:
		startString += letter
		first = False
	else:
		startString += '-' + letter
output = [startString]
for i in range(n - 1):
	newLine = ''
	for letter in output[-1]:
		if letter == '-' or letter == letters[-1]:
			newLine += '-'
		else:
			newLine += chr(ord(letter) + 1)
	output.append(newLine)
for line in output[-1::-1]:
	print(line)
for line in output[1:]:
	print(line)


ascii = 'abcdefghijklmnopqrstuvwxyz'
rangoli = int(input(), 10)
k = 2
letter = rangoli - 1
for i in range(rangoli, 0, -1):
	for j in range(k, rangoli * 2):
		print('-', end='')
	for res in range(rangoli, letter, -1):
		print(ascii[res - 1], end='')
		if i != rangoli:
			print('-', end='')
	letter = letter - 1
	for res in range(letter + 2, rangoli):
		print(ascii[res], end='')
		if res + 1 != rangoli:
			print('-', end='')
	for j in range(0, rangoli * 2 - k):
		print('-', end='')
	print()
	k = k + 2
k = k - 1
stop = 2
for i in range(1, rangoli):
	for j in range(k, rangoli * 2, -1):
		print('-', end='')
	for res in range(rangoli, letter + 2, -1):
		if i != rangoli:
			print('-', end='')
		print(ascii[res - 1], end='')
	letter = letter + 1
	for res in range(letter + 2, rangoli):
		if res - 1 != rangoli:
			print('-', end='')
		print(ascii[res], end='')
	for j in range(0, stop):
		print('-', end='')
	stop = stop + 2
	print()
	k = k + 2


s = int(input())
ltrNumb = ord('a') + s - 1
w = 4 * s - 3
for i in range(s):
	cStr = chr(ltrNumb)
	nLtrNumb = ltrNumb
	for j in range(0, i):
		nLtrNumb += 1
		nLtr = chr(nLtrNumb)
		cStr = nLtr + '-' + cStr + '-' + nLtr
	ltrNumb -= 1
	print(cStr.center(w, '-'))
ltrNumb += 2
for i in range(s - 2, -1, -1):
	cStr = chr(ltrNumb)
	nLtrNumb = ltrNumb
	for j in range(0, i):
		nLtrNumb += 1
		nLtr = chr(nLtrNumb)
		cStr = nLtr + '-' + cStr + '-' + nLtr
	ltrNumb += 1
	print(cStr.center(w, '-'))


def f(n, len, grid):
	for i in range(n):
		ascci = 96 + n - i
		lIndex = int((len - 1) / 2)
		rIndex = int((len - 1) / 2)
		for j in range(i + 1):
			grid[i][lIndex] = chr(ascci)
			grid[i][rIndex] = chr(ascci)
			lIndex -= 2
			rIndex += 2
			ascci += 1
N = int(input())
len = 2 * (N + (N - 1)) - 1
grid = [['-' for i in range(len)] for j in range(N)]
f(N, len, grid)
index = 0
for i in range(2 * N - 1):
	if i < N - 1:
		for a in grid[index]:
			print(a, end='')
		print()
		index += 1
	else:
		for a in grid[index]:
			print(a, end='')
		print()
		index -= 1


abc = 'zyxwvutsrqponmlkjihgfedcba'
alfabet = []
n = int(input())
letr = 26 - n
for i in range(n):
	r = '-' * (n * 2 - (i + 1) * 2)
	r += '-'.join(abc[letr:letr + i + 1])
	r += r[-2::-1]
	print(r)
	alfabet.append(r)
for i in range(2, len(alfabet) + 1):
	print(alfabet[-i])


import string
n = int(input())
letters = string.ascii_lowercase[:n]
for i in letters[::-1] + letters[1:n]:
	row = '-'.join(list(letters[::-1][:n - letters.index(i) - 1] + letters[letters.index(i):n]))
	half = int((4 * n - 3 - len(row)) / 2)
	print(half * '-' + row + half * '-')


import string
n = int(input())
s = string.ascii_lowercase[:27]
for i in range(1, n + 1):
	for j1 in range(0, n - i):
		print('--', end='')
	for j in range(n - 1, n - i, -1):
		print(s[j] + '-', end='')
	print(s[n - i], end='')
	for j in range(n - i, n - 1):
		print('-' + s[j + 1], end='')
	for j1 in range(0, n - i):
		print('--', end='')
	print()
for i in range(n - 1, 0, -1):
	for j1 in range(0, n - i):
		print('--', end='')
	for j in range(n - 1, n - i, -1):
		print(s[j] + '-', end='')
	print(s[n - i], end='')
	for j in range(n - i, n - 1):
		print('-' + s[j + 1], end='')
	for j1 in range(0, n - i):
		print('--', end='')
	print()


c = []
for i in range(97, 123):
	c.append(chr(i))
n = int(input())
if n == 1:
	print('a')
else:
	k = 2 * n - 2
	for i in range(1, n + 1):
		q = 0
		print('-' * k, end='')
		q = k
		for j in range(0, i):
			print(c[n - j - 1], end='')
			q = q + 1
			print('-', end='')
			q = q + 1
			last = n - j
		for p in range(last, n):
			print(c[p], end='')
			q = q + 1
			if q < 4 * n - 3:
				print('-', end='')
				q = q + 1
		print('-' * (k - 1))
		k -= 2
	k = 2
	for i in range(n - 1, 0, -1):
		q = 0
		print('-' * k, end='')
		q = k
		for j in range(0, i):
			print(c[n - j - 1], end='')
			q = q + 1
			print('-', end='')
			q = q + 1
			last = n - j
		for p in range(last, n):
			print(c[p], end='')
			q = q + 1
			if q < 4 * n - 3:
				print('-', end='')
				q = q + 1
		print('-' * (k - 1))
		k += 2


n = int(input())
width = 4 * n - 3
mid = width // 2
for i in range(2 * n - 1):
	out = ''
	k = abs(i - (n - 1))
	for j in range(width):
		x = abs(j - mid) // 2
		if j % 2 == 0 and x < n - k:
			out += chr(ord('a') + k + x)
		else:
			out += '-'
	print(out)


n = int(input())
l = 2 * n - 1 + 2 * n - 2
for i in range(n - 1):
	a = []
	for j in range(i):
		a.append(chr(ord('a') + n - 1 - j))
	u = list(reversed(a))
	a.append(chr(ord('a') + n - 1 - i))
	a += u
	print('-'.join(a).center(l, '-'))
for i in range(n - 1, -1, -1):
	a = []
	for j in range(i):
		a.append(chr(ord('a') + n - 1 - j))
	u = list(reversed(a))
	a.append(chr(ord('a') + n - 1 - i))
	a += u
	print('-'.join(a).center(l, '-'))


import sys
n = int(sys.stdin.readline())

def letterList(n):
	return list(reversed([chr(ord('a') + i) for i in range(n)]))

def rowLetters(n):
	letterNums = letterList(n)
	letterPart = []
	for i in list(range(n)) + list(reversed(range(n - 1))):
		arrangement = list(range(i)) + list(reversed(range(i + 1)))
		letterPart = letterPart + ['-'.join([letterNums[x] for x in arrangement])]
	rowSize = max([len(row) for row in letterPart])
	for row in letterPart:
		paddN = int((rowSize - len(row)) / 2)
		padd = ''.join(['-'] * paddN)
		print(padd + row + padd)
rowLetters(n)


def main():
	n = int(input())
	if n == 0:
		print()
		return
	s = 'a'
	for i in range(1, n):
		s = chr(97 + i) + '-' + s + '-' + chr(97 + i)
	na = len(s)
	l = [s]
	for i in range(n - 1):
		k = '-' + chr(97 + i) + '-' + chr(97 + i + 1)
		s = s.replace(k, '')
		l.append(s)
	for k in reversed(l):
		a = (na - len(k)) // 2
		print('-' * a + k + '-' * a)
	for k in l[1:]:
		a = (na - len(k)) // 2
		print('-' * a + k + '-' * a)
main()


import sys
n = int(input())
if n == 1:
	print('a')
	sys.exit(0)
for i in range(n):
	sys.stdout.write('-' * (2 * (n - i - 1)))
	for j in range(0, i + 1):
		sys.stdout.write(chr(97 + n - 1 - j) + '-')
	for j in range(i - 1, -1, -1):
		if i == n - 1 and j == 0:
			sys.stdout.write(chr(97 + n - 1 - j))
		else:
			sys.stdout.write(chr(97 + n - 1 - j) + '-')
	if i == n - 1:
		sys.stdout.write('\n')
		None
	else:
		sys.stdout.write('-' * (2 * (n - i - 1) - 1) + '\n')
for i in range(n - 2, -1, -1):
	sys.stdout.write('-' * (2 * (n - i - 1)))
	for j in range(0, i + 1):
		sys.stdout.write(chr(97 + n - 1 - j) + '-')
	for j in range(i - 1, -1, -1):
		if i == 0:
			sys.stdout.write(chr(97 + n - 1 - j))
		else:
			sys.stdout.write(chr(97 + n - 1 - j) + '-')
	sys.stdout.write('-' * (2 * (n - i - 1) - 1) + '\n')


import string
n = int(input())
alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
lst = alphabet[:n]
res = []
j = 1
k = 2 * n - 2
ress = []
for i in range(n, 0, -1):
	res.append(lst[i - 1])
	size = len(res) - 1
	if i > 1:
		if size > 0:
			ress.append((2 * n - 1 - j) * '-' + '-'.join((str(x) for x in res)) + '-' + '-'.join((str(y) for y in reversed(res[:len(res) - 1]))) + (k - size * 2) * '-')
		else:
			ress.append((2 * n - 1 - j) * '-' + '-'.join((str(x) for x in res)) + '-'.join((str(y) for y in reversed(res[:len(res) - 1]))) + (k - size * 2) * '-')
	if size > 0:
		print((2 * n - 1 - j) * '-' + '-'.join((str(x) for x in res)) + '-' + '-'.join((str(y) for y in reversed(res[:len(res) - 1]))) + (k - size * 2) * '-')
	else:
		print((2 * n - 1 - j) * '-' + '-'.join((str(x) for x in res)) + '-'.join((str(y) for y in reversed(res[:len(res) - 1]))) + (k - size * 2) * '-')
	j += 2
print('\n'.join((str(x) for x in reversed(ress))))


alphabet = 'abcdefghijklmnopqrstuvwxyz'
size = int(input())
row = ''
for x in range(0, size):
	row += '-' * 2 * abs(size - 1 - x)
	for y in range(x, -(x + 1), -1):
		row += alphabet[abs(y) + (size - x - 1)] + '-'
	row += '--' * (size - x - 1)
	print(row[:-1])
	row = ''
for x in range(size - 2, -1, -1):
	row += '-' * 2 * abs(size - 1 - x)
	for y in range(x, -(x + 1), -1):
		row += alphabet[abs(y) + (size - x - 1)] + '-'
	row += '--' * (size - x - 1)
	print(row[:-1])
	row = ''


n = int(input())
s = n - 1
_ = n * 2 - 1
x = 1
f = 0
if n == 1:
	print('a')
else:
	for i in range(_):
		for j in range(s):
			print('-', end='-')
		for j in range(x):
			print(chr(96 + n - j), end='-')
		k = n - x
		for j in range(x - 1):
			print(chr(97 + k + 1), end='')
			k = k + 1
			if j == x - 2 and x == n:
				pass
			else:
				print('-', end='')
		for j in range(s - 1):
			print('-', end='-')
		if x != n:
			print('-', end='')
		if f == 0:
			s = s - 1
			x = x + 1
			if s == 0:
				f = 1
		else:
			s = s + 1
			x = x - 1
		print()


def quart(arr, n):
	for x in range(n):
		res = ''
		sides = arr[n - x:]
		res += '--' * (n - 1 - len(sides))
		if sides:
			res += '-'.join(reversed(sides)) + '-'
		res += '{}'.format(let[n - 1 - x])
		yield (res + res[-2::-1])
n = int(input())
let = [chr(x) for x in range(ord('a'), ord('z') + 1) if x < ord('a') + n]
cuad = quart(let, n)
for x in quart(let, n):
	print(x)
for x in reversed(list(quart(let, n))[:-1]):
	print(x)


n = int(input())
asc = [chr(ord('a') + j) for j in range(n)]
desc = asc[::-1]
lines = []
for i in range(n):
	dashes = '-' * (n * 2 - 2 - i * 2)
	rev = '-'.join(desc[:i + 1])
	content = rev + rev[-2::-1]
	line = dashes + content + dashes
	lines.append(line)
	print(line)
for line in lines[-2::-1]:
	print(line)


import string
n = int(input())
l = 2 * (2 * n - 1) - 1

def gen(k):
	return '-'.join(list(reversed(string.ascii_lowercase[n - k:n])) + list(string.ascii_lowercase[n - k + 1:n])).center(l, '-')
print('\n'.join([gen(i) for i in list(range(1, n + 1)) + list(reversed(range(1, n)))]))


import string
alphabets = list(string.ascii_lowercase)
size = int(input())
working_list = alphabets[:size]
working_list.reverse()
rangoli_segments = []
dash_length = (size - 1) * 2
for i in range(0, size):
	current_dashes = '-' * (dash_length - i * 2)
	current_segment = current_dashes
	inner_segment = ''
	for j in range(0, i + 1):
		inner_segment += working_list[j]
		inner_segment += '-'
	inner_segment = inner_segment[:-1]
	inner_segment += inner_segment[:-1][::-1]
	current_segment += inner_segment
	current_segment += current_dashes
	rangoli_segments.append(current_segment)
for segment in rangoli_segments:
	print(segment)
rangoli_segments.pop()
rangoli_segments.reverse()
for segment in rangoli_segments:
	print(segment)


t = int(input())
x = t * 2 + (t - 1) * 2 - 1
y = 1
for i in range(1, t + 1):
	dashes = ''.join(['-'] * ((x - y) // 2))
	str = ''
	for j in range(t, t - i, -1):
		str += chr(96 + j) + '-'
	for j in range(t - i + 1, t):
		str += chr(97 + j) + '-'
	y += 4
	print(dashes + str[:-1] + dashes)
y -= 8
for i in range(t - 1, 0, -1):
	str = ''
	dashes = ''.join(['-'] * ((x - y) // 2))
	for j in range(t, t - i, -1):
		str += chr(96 + j) + '-'
	for j in range(t - i + 1, t):
		str += chr(97 + j) + '-'
	y -= 4
	print(dashes + str[:-1] + dashes)


n = int(input())
for i in range(1, n + 1):
	k = 0
	for j in range(n * 2 - i * 2):
		print('-', end='')
	for j in range(i):
		if n == 1:
			print('%c' % chr(96 + n - j), end='')
		else:
			print('%c-' % chr(96 + n - j), end='')
		k = j
	for j in range(i - 1):
		if j == n - 2:
			print('%c' % chr(96 + n - k + j + 1), end='')
		else:
			print('%c-' % chr(96 + n - k + j + 1), end='')
	for j in range(n * 2 - i * 2 - 1):
		print('-', end='')
	print()
l = n
for i in range(1, n):
	k = 0
	for j in range(i * 2):
		print('-', end='')
	for j in range(l - 1):
		print('%c-' % chr(96 + n - j), end='')
		k = j
	for j in range(l - 2):
		print('%c-' % chr(96 + n - k + j + 1), end='')
	for j in range(i * 2 - 1):
		print('-', end='')
	print()
	l = l - 1


alph = [0, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']

def rangoli(n):
	rows = []
	for i in range(1, n + 1):
		letters = alph[n:n - i:-1] + alph[n - i + 2:n + 1]
		test = '-' * (n - i) * 2 + '-'.join(letters) + '-' * (n - i) * 2
		rows.append(test)
	return rows
j = rangoli(int(input()))
for i in j[0:-1]:
	print(i)
for k in j[::-1]:
	print(k)


from math import floor

class Rangoli:

	def __init__(self, n):
		self.n = n
		self.size = 1 + 4 * (n - 1)
		self.alphabets = [chr(x) for x in range(97, 97 + self.n)]
		self.alphabets.reverse()

	def construct_row(self, larr):
		row = ['-' for x in range(self.size)]
		mid = floor(self.size / 2)
		curr_center = larr[-1]
		row[mid] = curr_center
		next_dist = 0
		for x in reversed(larr[:-1]):
			next_dist += 2
			row[mid - next_dist] = x
			row[mid + next_dist] = x
		return row

	def rangoli(self):
		rangoli_arr = []
		for (i, alpha) in enumerate(self.alphabets):
			target_arr = self.alphabets[0:i + 1]
			rangoli_arr.append(''.join(self.construct_row(target_arr)))
		for row in reversed(rangoli_arr[:-1]):
			rangoli_arr.append(row)
		for row in rangoli_arr:
			print(row)
n = int(input())
alpha_rangoli = Rangoli(n)
alpha_rangoli.rangoli()


import string
N = int(input())
A = []
for i in range(N - 1, -1, -1):
	A.append('-'.join(list(string.ascii_lowercase[i:N])) + '-' * (i * 2))
for i in range(0, N):
	print(A[i][(N - 1) * 2:0:-1], end='')
	print(A[i])
for i in range(N - 2, -1, -1):
	print(A[i][(N - 1) * 2:0:-1], end='')
	print(A[i])


n = int(input())
for i in range(2 * n - 1):
	s = ''
	m = i
	if m > n - 1:
		m = 2 * n - 2 - i
	for j in range(m):
		l = n - 1 - j
		s = s + chr(ord('a') + l) + '-'
	k = n - 1 - i
	if k < 0:
		k *= -1
	print('--' * k + s + chr(ord('a') + n - 1 - m) + s[::-1] + k * '--')


size = int(input())
lst = size * 2 - 1
sub_lst = 4 * size - 3
stack = []
letrs = tuple([chr(i) for i in range(97, 97 + size)])
inc = 0
ci = -1
for x in range(size):
	pos = lst - 1 - inc
	c = ci
	min_stack = ['-'] * lst
	for j in range(lst - 1, pos - 1, -2):
		min_stack[j] = letrs[c]
		c += 1
	stack.append(min_stack)
	ci += -1
	inc += 2
for min_st in range(len(stack) - 2, -1, -1):
	stack.append(stack[min_st])
if size == 1:
	print('a')
else:
	for st in stack:
		print(''.join(st) + ''.join(st[len(st) - 2::-1]))


import sys, string

def print_next(N, k):
	if k == N:
		print('-'.join(letters_in_row(N, N)))
		return
	s = ''
	s += '-' * 2 * (N - k)
	s += '-'.join(letters_in_row(N, k))
	s += '-' * 2 * (N - k)
	print(s)
	print_next(N, k + 1)
	print(s)

def letters_in_row(N, row):
	s = []
	for i in reversed(range(N - row + 1, N)):
		s.append(alphabet[i])
	s.append(alphabet[N - row])
	for i in range(N - row + 1, N):
		s.append(alphabet[i])
	return s
N = int(sys.stdin.readline().rstrip())
alphabet = list(string.ascii_lowercase)
print_next(N, 1)


n = int(input())
if n == 1:
	print('a')
else:
	end = chr(ord('a') + n - 1)
	for i in range(n):
		for j in range(1, n + 1):
			print(chr(ord(end) - i + n - j) if j >= n - i else '-', end='')
			print('-', end='')
		for j in range(1, n):
			print(chr(ord(end) - i + j) if j <= i else '-', end='')
			if j < n - 1:
				print('-', end='')
		print('')
	for i in range(1, n):
		for j in range(1, n + 1):
			print(chr(ord(end) + i - j + 1) if j > i else '-', end='')
			print('-', end='')
		for j in range(1, n):
			print(chr(ord('a') + i + j) if j < n - i else '-', end='')
			if j < n - 1:
				print('-', end='')
		print('')


val = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
n = int(input())
rang = []
for i in range(1, n + 1):
	l1 = '-' * ((n - i) * 2)
	l2 = ''
	for j in range(i):
		l2 = l2 + val[n - 1 - j] + '-'
	l2 = l2[:len(l2)]
	m = l1 + l2
	ln = 2 * (n - 1) - 1
	m2 = m[:ln]
	s = m + m2[::-1]
	rang.append(s)
if n == 1:
	print('a')
else:
	for i in range(len(rang)):
		print(rang[i])
	i = n - 2
	while i >= 0:
		print(rang[i])
		i = i - 1


def one(i, lim):
	val = 'abcdefghijklmnopqrstuvwxyz'
	return val[i].center(lim, '-')

def row(i, size, lim):
	if i + 1 == size:
		return one(i, lim)
	val = 'abcdefghijklmnopqrstuvwxyz'
	s2 = '-'.join(list(val[i:size]))
	s1 = '-'.join(list(val[size - 1:i:-1]))
	return (s1 + '-' + s2).center(lim, '-')
nb = int(input())
bd = 4 * (nb - 1) + 1
for i in range(nb - 1, 0, -1):
	print(row(i, nb, bd))
for i in range(nb):
	print(row(i, nb, bd))


n = int(input())
k = 97
l = []
for i in range(n):
	l.append(chr(k))
	k += 1
q = list(reversed(l))
x = n - 1
j = 1
for i in range(n):
	print('-' * (x * 2) + str('-'.join(q[:j])), end='')
	if i != 0:
		print('-' + '-'.join(list(reversed(q[:j - 1]))) + '-' * (x * 2))
	else:
		print('-' * (x * 2))
	x = x - 1
	j += 1
x = 1
j = n - 1
for i in range(n - 1):
	print('-' * (x * 2) + str('-'.join(q[:j])), end='')
	if i != n - 2:
		print('-' + '-'.join(list(reversed(q[:j - 1]))) + '-' * (x * 2))
	else:
		print('-' * (x * 2))
	x = x + 1
	j -= 1


import sys
import string
import itertools

def printline(i, N):
	dashes = '-' * (N - i) * 2
	letters = string.ascii_lowercase[N - i:N]
	chars = [c for c in reversed(letters)] + list(letters[1:])
	chars = [x for x in itertools.chain.from_iterable(zip(chars, itertools.repeat('-')))]
	del chars[-1]
	print(dashes + ''.join(chars) + dashes)
N = int(sys.stdin.readline())
for i in range(1, N + 1):
	printline(i, N)
for i in range(N - 1, 0, -1):
	printline(i, N)


x = int(input())
a = ord('a') + (x - 1)
for i in range(0, x):
	for l in range(2 * i, 2 * (x - 1)):
		print(end='-')
	for k in range(0, i):
		print(chr(a - k), end='-')
	for j in range(i, 0, -1):
		print(chr(a - j), end='-')
	for j in range(0, -1, -1):
		print(chr(a - j), end='')
	for l in range(2 * i, 2 * (x - 1)):
		print(end='-')
	print()
for i in range(x - 1, 0, -1):
	for l in range(2 * x, 2 * i, -1):
		print(end='-')
	for k in range(0, i - 1):
		print(chr(a - k), end='-')
	for j in range(i - 1, 0, -1):
		print(chr(a - j), end='-')
	for j in range(0, -1, -1):
		print(chr(a - j), end='')
	for l in range(2 * x, 2 * i, -1):
		print(end='-')
	print()


import string
n = int(input())
k = n * 2 - 1
alphabet = list(string.ascii_lowercase)[0:n]
l = []
for i in range(n):
	s = list('-' * (k * 2 - 1))
	s[k - 1] = alphabet[n - i - 1]
	for j in range(0, i, 1):
		s[k - 1 - (j + 1) * 2] = alphabet[j - i]
		s[k - 1 + (j + 1) * 2] = alphabet[j - i]
	l.append(''.join(s))
print('\n'.join(l) + '\n' + '\n'.join(list(reversed(l[0:n - 1]))))