efremovv

using System;
using System.Linq;

namespace efremov
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Write("Enter A: ");
            int A = int.Parse(Console.ReadLine());
            Console.Write("Enter B: ");
            int B = int.Parse(Console.ReadLine());

            Console.WriteLine("\t| Forward\t| Reverse\t| Additional\n" +
                "\t| \t\t| \t\t| \n" +
                $"A\t| {ToForward(A)}\t| {ToReverse(A)}\t| {ToAdditional(A)}\n" +
                $"B\t| {ToForward(B)}\t| {ToReverse(B)}\t| {ToAdditional(B)}\n" +
                $"-A\t| {ToForward(-A)}\t| {ToReverse(-A)}\t| {ToAdditional(-A)}\n" +
                $"-B\t| {ToForward(-B)}\t| {ToReverse(-B)}\t| {ToAdditional(-B)}\n" +
                $"---------------------------------------------------\n" +
                $"A * 2^-2| {ToShiftRightForForward(ToForward(A), 2)}\t| {ToShiftRightForReverse(ToReverse(A), 2)}\t| {ToShiftRightForAdditional(ToAdditional(A), 2)}\n" +
                $"A * 2^-3| {ToShiftRightForForward(ToForward(A), 3)}\t| {ToShiftRightForReverse(ToReverse(A), 3)}\t| {ToShiftRightForAdditional(ToAdditional(A), 3)}\n" +
                $"A * 2^3 | {ToShiftLeftForForward(ToForward(A), 3)}\t| {ToShiftLeftForReverse(ToReverse(A), 3)}\t| {ToShiftLeftForAdditional(ToAdditional(A), 3)}\n" +
                $"A * 2^4 | {ToShiftLeftForForward(ToForward(A), 4)}\t| {ToShiftLeftForReverse(ToReverse(A), 4)}\t| {ToShiftLeftForAdditional(ToAdditional(A), 4)}\n" +
                $"B * 2^-2| {ToShiftRightForForward(ToForward(B), 2)}\t| {ToShiftRightForReverse(ToReverse(B), 2)}\t| {ToShiftRightForAdditional(ToAdditional(B), 2)}\n" +
                $"B * 2^-3| {ToShiftRightForForward(ToForward(B), 3)}\t| {ToShiftRightForReverse(ToReverse(B), 3)}\t| {ToShiftRightForAdditional(ToAdditional(B), 3)}\n" +
                $"B * 2^3 | {ToShiftLeftForForward(ToForward(B), 3)}\t| {ToShiftLeftForReverse(ToReverse(B), 3)}\t| {ToShiftLeftForAdditional(ToAdditional(B), 3)}\n" +
                $"B * 2^4 | {ToShiftLeftForForward(ToForward(B), 4)}\t| {ToShiftLeftForReverse(ToReverse(B), 4)}\t| {ToShiftLeftForAdditional(ToAdditional(B), 4)}\n" +
                $"---------------------------------------------------\n" +
                $"A + B\t| {ToForward(A)}\t| {ToReverse(A)}\t| {ToAdditional(A)}\n" +
                $"\t|+ \t\t|+ \t\t|+\n" +
                $"\t| {ToForward(B)}\t| {ToReverse(B)}\t| {ToAdditional(B)}\n" +
                $"\t| ---------\t| ---------\t| ---------\n" +
                $"\t| {ToForward(A + B)}\t| {ToReverse(A + B)}\t| {ToAdditional(A + B)}\n" +
                $"---------------------------------------------------\n" +
                $"A - B\t| {ToForward(A)}\t| {ToReverse(A)}\t| {ToAdditional(A)}\n" +
                $"\t|+ \t\t|+ \t\t|+\n" +
                $"\t| {ToForward(-B)}\t| {ToReverse(-B)}\t| {ToAdditional(-B)}\n" +
                $"\t| ---------\t| ---------\t| ---------\n" +
                $"\t| {ToForward(A - B)}\t| {ToReverse(A - B)}\t| {ToAdditional(A - B)}\n" +
                $"---------------------------------------------------\n" +
                $"-A + B\t| {ToForward(-A)}\t| {ToReverse(-A)}\t| {ToAdditional(-A)}\n" +
                $"\t|+ \t\t|+ \t\t|+\n" +
                $"\t| {ToForward(B)}\t| {ToReverse(B)}\t| {ToAdditional(B)}\n" +
                $"\t| ---------\t| ---------\t| ---------\n" +
                $"\t| {ToForward(-A + B)}\t| {ToReverse(-A + B)}\t| {ToAdditional(-A + B)}\n" +
                $"---------------------------------------------------\n" +
                $"-A - B\t| { ToForward(-A)}\t| { ToReverse(-A)}\t| { ToAdditional(-A)}\n" +
                $"\t|+ \t\t|+ \t\t|+\n" +
                $"\t| {ToForward(-B)}\t| {ToReverse(-B)}\t| {ToAdditional(-B)}\n" +
                $"\t| ---------\t| ---------\t| ---------\n" +
                $"\t| {ToForward(-A + -B)}\t| {ToReverse(-A + -B)}\t| {ToAdditional(-A + -B)}\n" +
                $"---------------------------------------------------\n" +
                $"A * B\t| ");

            string[] rows = Multiply(A, B);

            for (int i = 0; i < rows.Length; ++i)
            {
                if (i != 0)
                    Console.Write("\t|  +\n");
                Console.WriteLine("\t|   " + rows[i]);
            }

            Console.WriteLine("\t| ---------\n\t| " + ToForward(A * B));

            Console.Write("\nWrite any key to continue...");
            Console.ReadKey();
        }

        static string GetBinaryWithImaginary(string binary, bool hasSign)
        {
            string imaginary = new string('0', 7 - binary.Length);
            return (hasSign) ? $"1.{imaginary}{binary}" : $"0.{imaginary}{binary}";
        }

        static string ToForward(int digit)
            => (digit >= 0) ? GetBinaryWithImaginary(Convert.ToString(digit, 2), false)
                : GetBinaryWithImaginary(Convert.ToString(Math.Abs(digit), 2), true);

        static string ToReverse(int digit)
        {
            if (digit >= 0)
                return GetBinaryWithImaginary(Convert.ToString(digit, 2), false);
            else
            {
                string binary = GetBinaryWithImaginary(Convert.ToString(Math.Abs(digit), 2), true);
                string[] leftAndRightParts = binary.Split('.');
                string reverseBinary = string.Empty;

                foreach (char bit in leftAndRightParts[1])
                    reverseBinary += (bit == '0') ? '1' : '0';

                return $"1.{reverseBinary}";
            }
        }

        static string ToAdditional(int digit)
        {
            if (digit >= 0)
                return GetBinaryWithImaginary(Convert.ToString(digit, 2), false);
            else
            {
                string binary = GetBinaryWithImaginary(Convert.ToString(Math.Abs(digit), 2), true);
                string[] leftAndRightParts = binary.Split('.');
                string reverseBinary = string.Empty;

                foreach (char bit in leftAndRightParts[1])
                    reverseBinary += (bit == '0') ? '1' : '0';

                digit = Convert.ToInt32(reverseBinary, 2) + 1;
                string additionalBinary = Convert.ToString(digit, 2);
                return GetBinaryWithImaginary(additionalBinary, true);
            }
        }

        static string ToShiftRightForForward(string binary, int move)
        {
            string[] leftAndRightParts = binary.Split('.');
            return leftAndRightParts[0] + "." + new string('0', move) + leftAndRightParts[1].Substring(0, 7 - move);
        }

        static string ToShiftRightForReverse(string binary, int move)
        {
            string[] leftAndRightParts = binary.Split('.');
            return (leftAndRightParts[0] == "0") ? ToShiftRightForForward(binary, move)
                : leftAndRightParts[0] + "." + new string('1', move) + leftAndRightParts[1].Substring(0, 7 - move);
        }

        static string ToShiftRightForAdditional(string binary, int move) => ToShiftRightForReverse(binary, move);

        static string ToShiftLeftForForward(string binary, int move)
        {
            string[] leftAndRightParts = binary.Split('.');

            string overflow = string.Empty;
            if (leftAndRightParts[1].Substring(0, move).Contains('1'))
                overflow = " (o)";

            return leftAndRightParts[0] + "." + leftAndRightParts[1].Substring(move, 7 - move) + new string('0', move) + overflow;
        }

        static string ToShiftLeftForReverse(string binary, int move)
        {
            string[] leftAndRightParts = binary.Split('.');

            if (leftAndRightParts[0] == "0")
                return ToShiftLeftForForward(binary, move);

            string overflow = string.Empty;
            if (leftAndRightParts[1].Substring(0, move).Contains('0'))
                overflow = " (o)";

            return leftAndRightParts[0] + "." + leftAndRightParts[1].Substring(move, 7 - move) + new string('1', move) + overflow;
        }

        static string ToShiftLeftForAdditional(string binary, int move)
        {
            string[] leftAndRightParts = binary.Split('.');

            if (leftAndRightParts[0] == "0")
                return ToShiftLeftForForward(binary, move);

            string overflow = string.Empty;
            if (leftAndRightParts[1].Substring(0, move).Contains('0'))
                overflow = " (o)";

            return leftAndRightParts[0] + "." + leftAndRightParts[1].Substring(move, 7 - move) + new string('0', move) + overflow;
        }

        static string[] Multiply(int A, int B)
        {
            string binaryA = Convert.ToString(A, 2);
            string binaryB = Convert.ToString(B, 2);

            int maxLength = (binaryA.Length > binaryB.Length) ? binaryA.Length : binaryB.Length;

            string reverseBinaryB = new(binaryB.Reverse().ToArray());

            string[] rows = new string[maxLength];

            for (int i = 0; i < maxLength; ++i)
                rows[i] = (reverseBinaryB[i] == '1') ? new string(' ', maxLength - 1 - i) + binaryA
                    : rows[i] = new string(' ', maxLength - i + 2) + '0';

            return rows;
        }
    }
}