Permutation Avoidance

def perm_to_str(perm_list):
    perm_str = str(perm_list)
    convert_str = perm_str + " -> " + perm_list.cycle_string(singletons = True)
    return convert_str

# Get the user input
n = int(input('Please enter the length of the permutation (Ex: 5)> '))

num_pats = int(input('Please enter the number of patterns to avoid (Ex: 3)> '))

pats = []

# Get each patterns
for i in range(num_pats):
    pats.append(input(f'Please enter pattern number {i + 1} (Ex: 132)> '))
print()

# Convert each pattern from a string into a list
def pat_to_list(pat):
    return [int(x) for x in str(pat)]

pat_lists = [pat_to_list(pat) for pat in pats]

p = Permutations(n, avoiding=pat_lists)

perm_per_cycle = {}

# Split the permutations into the number of cycles
for perm in p:
    num_cycles = len(perm.cycle_type())
    if num_cycles in perm_per_cycle.keys():
        perm_per_cycle[num_cycles].append(perm)
    else:
        perm_per_cycle[num_cycles] = [perm]

# Output the cycle types and number of permutations per cycle type
for k in sorted(perm_per_cycle):
    cycle_num = len(perm_per_cycle[k])
    print(f'Cycle Type: {k}\t Total Perms of Cycle Type {k}: {cycle_num}')
    for perm in perm_per_cycle[k]:
        print('\t' + perm_to_str(perm))

# Output the final count
print(f'\nTotal number of permutations avoiding the patterns: {len(p)}')

import numpy as np

def reverse_order_list(length, offset):
    rev_list = np.arange(1, length + 1, 1)[::-1]
    rev_list += offset
    return rev_list

def abc_to_perm(a, b, c):
    n = a + b + c

    a_list = reverse_order_list(a, n - a)
    b_list = reverse_order_list(b, 0)
    c_list = reverse_order_list(c, b)

    return Permutation(np.append(a_list, np.append(b_list, c_list)))

def abc_count_cycles(a, b, c):
    p = abc_to_perm(a, b, c)
    return len(p.cycle_type())

a, b, c = map(int, input('Please enter a, b, and c seperated by spaces (EX: 3 4 5)> ').split(' '))
print(f'The number of cycle in the permutation of form ({a}, {b}, {c}) is {abc_count_cycles(a, b, c)}')

from tabulate import tabulate
import math
from termcolor import colored

# table = [['col 1', 'col 2', 'col 3', 'col 4'], [1, 2222, 30, 500], [4, 55, 6777, 1]]
# print(tabulate(table, headers='firstrow', tablefmt='fancy_grid'))

def print_tables():
    for a in range(1, 11):
        result_table = []
        for b in range(1, 16):
            result_row = []
            for c in range(1, 16):
                result = abc_count_cycles(a, b, c)
                if a < ((a + b + c) / 2) and math.gcd(b, c) != 1:
                    result = '\x1b[2;37;41m  ' + str(result) + '  \x1b[0m'
                result_row.append(result)
            result_table.append(result_row)

        print(f'a = {a}')
        print(tabulate(result_table, headers=[1..15], tablefmt='fancy_grid', showindex=[1..15]))

print_tables()