pinter-8.A.1 multiplying permutations.md

8.A.1 - A Book of Abstract Algebra by Charles C. Pinter

using System;
using System.Collections.Generic;
using System.Linq;

using static System.Console;

namespace pinter_8.A._1_multiplying_permutations
{
    class Program
    {
        static List<List<int>> parse(string s)
        {
            var result = new List<List<int>>();

            foreach (var elt in s)
            {
                if (elt == '(') result.Add(new List<int>());

                if (Char.IsDigit(elt)) result.Last().Add(elt - '0');
            }

            return result;
        }
        
        static void display(Dictionary<int, int> f)
        {
            foreach (var key in f.Keys.OrderBy(elt => elt)) Write($"{key} "); WriteLine();
            foreach (var key in f.Keys.OrderBy(elt => elt)) Write($"{f[key]} "); WriteLine();
        }

        static void display(List<List<int>> cycles)
        {
            foreach (var cycle in cycles)
            {
                Write("(");
                foreach (var i in cycle) Write(i);
                Write(")");
            }

            WriteLine();
        }

        // ----------------------------------------------------------------------

        static int apply(List<int> cycle, int a) => 
            cycle.Contains(a) ? cycle[(cycle.IndexOf(a) + 1) % cycle.Count] : a;
        
        static int apply_multiple(List<List<int>> cycles, int a) => 
            cycles.Reverse<List<int>>().Aggregate(a, (elt, cycle) => apply(cycle, elt));

        static Dictionary<int, int> cycles_to_permutation(List<List<int>> cycles, int n) => 
            Enumerable.Range(1, n).ToDictionary(i => i, i => apply_multiple(cycles, i));
        
        static List<T> LS<T>(params T[] items) => new List<T>(items);

        static void display_cycles_as_permutation(List<List<int>> cycles, int n)
        {
            display(cycles);

            display(cycles_to_permutation(cycles, n));
        }

        static void display_cycles_as_permutation(string s, int n) => 
            display_cycles_as_permutation(parse(s), n);

        static void Main(string[] args)
        {
            display_cycles_as_permutation("(145)(37)(682)",      9); WriteLine();
            display_cycles_as_permutation("(17)(628)(9354)",     9); WriteLine();
            display_cycles_as_permutation("(71825)(36)(49)",     9); WriteLine();
            display_cycles_as_permutation("(12)(347)",           9); WriteLine();
            display_cycles_as_permutation("(147)(1678)(74132)",  9); WriteLine();
            display_cycles_as_permutation("(6148)(2345)(12493)", 9); WriteLine();
        }
    }
}