CHEATS for MODULE .NET 6 (.NET 5+)

TPRquest3AandB.cs

#region QUEST 3A
Console.WriteLine("\n\n3.A QUEST:\n");

table a_table = new();
a_table.rows = new()
{
    new row(Xtype.X1, Xtype.X1),
    new row(Xtype.X2, Xtype.X2),
    new row(Xtype.X3, Xtype.X3),
    new row(Xtype.X1X2, Xtype.X1),
    new row(Xtype.X1X3, Xtype.X1),
    new row(Xtype.X2X3, Xtype.X2),
    new row(Xtype.X1X2X3, Xtype.X1)
};

a_table.A_PrintTable();
a_table.A_Build_F_Table();
a_table.Print_F_Table();
a_table.Print_F();
#endregion QUEST 3A

#region QUEST 3B
Console.WriteLine("\n\n3.B QUEST:\n");

table b_table = new();
b_table.B_Set_F_Table(
    B2_B3_F1_Values: new List<int> { 0, 1, 0, 1 },
    B1_B3_F2_Values: new List<int> { 0, 0, 1, 1 },
    B1_B2_F3_Values: new List<int> { 1, 1, 1, 1 });
b_table.B_Build_Table_By_F_Table();
b_table.Print_F_Table();
b_table.B_PrintTable();
#endregion QUEST 3B

class table
{
    public List<row> rows = new();
    public List<b> B2_B3_F1 = new();
    public List<b> B1_B3_F2 = new();
    public List<b> B1_B2_F3 = new();
    public row this[int i]
    {
        get { return rows[i]; }
        set { rows[i] = value; }
    }

    public void B_PrintTable()
    {
        //header
        Console.WriteLine($"\n{"X",-7} {"B1",-2}|{"B2",-2}|{"B3",-2}|{"B1F1"} {"B2F2"} {"B3F3"}|{"C(x)",-2}\n");
        rows.ForEach(row =>
        {
            Console.WriteLine($"{row.X,-7}|{row.Get_C_X_Like_B1B2B3()}|{row.B_C_X,-2}|{row.B_C_X.GetAsXtype(),-2}");
        });
    }

    public void B_Build_Table_By_F_Table()
    {
        rows = new()
        {
            new row(Xtype.X1, Xtype.X1),
            new row(Xtype.X2, Xtype.X2),
            new row(Xtype.X3, Xtype.X3),
            new row(Xtype.X1X2, Xtype.X1X2),
            new row(Xtype.X1X3, Xtype.X1X3),
            new row(Xtype.X2X3, Xtype.X2X3),
            new row(Xtype.OMEGA, Xtype.OMEGA)
        };

        rows.ForEach(row =>
        {
            row.B_C_X.X1 = 0;
            row.B_C_X.X2 = 0;
            row.B_C_X.X3 = 0;
            B2_B3_F1.ForEach(BBF =>
            {
                if (BBF.X1 == row.B_X.X2 && BBF.X2 == row.B_X.X3)
                    row.B_C_X.X1 |= (BBF.X3 & row.B_X.X1);
            });
            B1_B3_F2.ForEach(BBF =>
            {
                if (BBF.X1 == row.B_X.X1 && BBF.X2 == row.B_X.X3)
                    row.B_C_X.X2 |= (BBF.X3 & row.B_X.X2);
            });
            B1_B2_F3.ForEach(BBF =>
            {
                if (BBF.X1 == row.B_X.X1 && BBF.X2 == row.B_X.X2)
                    row.B_C_X.X3 |= (BBF.X3 & row.B_X.X3);
            });
        });
    }

    public void B_Set_F_Table(List<int> B2_B3_F1_Values, List<int> B1_B3_F2_Values, List<int> B1_B2_F3_Values)
    {
        init_F_Tables();

        // default : B2_B3_F1.Count == B1_B3_F2.Count == B1_B2_F3.Count
        if (B2_B3_F1.Count == B2_B3_F1_Values.Count &&
            B1_B3_F2.Count == B1_B3_F2_Values.Count &&
            B1_B2_F3.Count == B1_B2_F3_Values.Count)
        {
            for (int i = 0; i < B2_B3_F1.Count; i++)
            {
                B2_B3_F1[i].X3 = B2_B3_F1_Values[i];
                B1_B3_F2[i].X3 = B1_B3_F2_Values[i];
                B1_B2_F3[i].X3 = B1_B2_F3_Values[i];
            }
        }
    }
    public void A_PrintTable()
    {
        //header
        Console.WriteLine($"\n{"X",-7} {"C(x)",-7} {"B(x)",-7} {"B(C(x))",-7}\n");
        rows.ForEach(row =>
        {
            Console.WriteLine($"{row.X,-7}|{row.C_X,-7}|{row.B_X,-7}|{row.B_C_X,-7}");
        });
    }
    public void Print_F_Table()
    {
        Console.WriteLine("\n F tables:");
        Console.WriteLine($"\n{"B2",-3} {"B3",-3} {"F1",-3} \n");
        B2_B3_F1.ForEach(row =>
        {
            Console.WriteLine($"{row.X1,-3}|{row.X2,-3}|{row.X3,-3}");
        });
        Console.WriteLine($"\n{"B1",-3} {"B3",-3} {"F2",-3} \n");
        B1_B3_F2.ForEach(row =>
        {
            Console.WriteLine($"{row.X1,-3}|{row.X2,-3}|{row.X3,-3}");
        });
        Console.WriteLine($"\n{"B1",-3} {"B2",-3} {"F3",-3} \n");
        B1_B2_F3.ForEach(row =>
        {
            Console.WriteLine($"{row.X1,-3}|{row.X2,-3}|{row.X3,-3}");
        });
    }
    public void Print_F()
    {
        Console.WriteLine("\n F values:");
        Console.Write("F1(B2,B3)= ");
        Print_F_template(B2_B3_F1, "B2", "B3");
        Console.WriteLine();

        Console.Write("F2(B1,B3)= ");
        Print_F_template(B1_B3_F2, "B1", "B3");
        Console.WriteLine();

        Console.Write("F3(B1,B2)= ");
        Print_F_template(B1_B2_F3, "B1", "B2");
        Console.WriteLine();
    }

    public void A_Build_F_Table()
    {
        init_F_Tables();
        for (int i = 0; i < 4; i++)
        {
            rows.ForEach(row =>
            {
                if (row.B_X.X2 == B2_B3_F1[i].X1 && row.B_X.X3 == B2_B3_F1[i].X2)
                    B2_B3_F1[i].X3 |= row.B_C_X.X1;
            });
            rows.ForEach(row =>
            {
                if (row.B_X.X1 == B1_B3_F2[i].X1 && row.B_X.X3 == B1_B3_F2[i].X2)
                    B1_B3_F2[i].X3 |= row.B_C_X.X2;
            });
            rows.ForEach(row =>
            {
                if (row.B_X.X1 == B1_B2_F3[i].X1 && row.B_X.X2 == B1_B2_F3[i].X2)
                    B1_B2_F3[i].X3 |= row.B_C_X.X3;
            });
        }
    }
    private void init_F_Tables()
    {
        for (int i = 0; i < 4; i++)
        {
            B2_B3_F1.Add(new b(i + 1 > 2 ? 1 : 0, i % 2, 0));
            B1_B3_F2.Add(new b(i + 1 > 2 ? 1 : 0, i % 2, 0));
            B1_B2_F3.Add(new b(i + 1 > 2 ? 1 : 0, i % 2, 0));
        }
    }
    private void Print_F_template(List<b> BBF, string B1, string B2)
    {
        bool inside = false;
        BBF.ForEach(row =>
        {
            if (row.X3 != 0)
            {
                if (inside)
                    Console.Write(" v ");

                Console.Write($"{(row.X1 == 0 ? $"!{B1}" : B1)} {(row.X2 == 0 ? $"!{B2}" : B2)}");
                inside = true;
            }
        });
    }
}
class row
{
    public Xtype X;
    public Xtype C_X;
    public b B_X;
    public b B_C_X;
    public row(Xtype x, Xtype c_X)
    {
        X = x;
        C_X = c_X;
        B_X = new(x);
        B_C_X = new(c_X);
    }
    public string Get_C_X_Like_B1B2B3() => Get_Xtype_Like_Triple_Column(C_X);
    public string Get_Xtype_Like_Triple_Column(Xtype tupe) => tupe switch
    {
        Xtype.EMPTY => $"{"0",-2}|{"0",-2}|{"0",-2}",
        Xtype.X1 => $"{"1",-2}|{"0",-2}|{"0",-2}",
        Xtype.X2 => $"{"0",-2}|{"1",-2}|{"0",-2}",
        Xtype.X3 => $"{"0",-2}|{"0",-2}|{"1",-2}",
        Xtype.X1X2 => $"{"1",-2}|{"1",-2}|{"0",-2}",
        Xtype.X1X3 => $"{"1",-2}|{"0",-2}|{"1",-2}",
        Xtype.X2X3 => $"{"0",-2}|{"1",-2}|{"1",-2}",
        Xtype.X1X2X3 or Xtype.OMEGA => $"{"1",-2}|{"1",-2}|{"1",-2}",
    };
}
class b
{
    public int X1 { get; set; }
    public int X2 { get; set; }
    public int X3 { get; set; }
    public b(int x1, int x2, int x3)
    {
        X1 = x1;
        X2 = x2;
        X3 = x3;
    }
    public b()
        : this(0, 0, 0) { }
    public b(Xtype tupe)
        : this(0, 0, 0)
    {
        switch (tupe)
        {
            case Xtype.X1:
                X1 = 1;
                break;
            case Xtype.X2:
                X2 = 1;
                break;
            case Xtype.X3:
                X3 = 1;
                break;
            case Xtype.X1X2:
                X1 = 1;
                X2 = 1;
                break;
            case Xtype.X1X3:
                X1 = 1;
                X3 = 1;
                break;
            case Xtype.X2X3:
                X2 = 1;
                X3 = 1;
                break;
            case Xtype.X1X2X3 or Xtype.OMEGA:
                X1 = 1;
                X2 = 1;
                X3 = 1;
                break;
            default:
                break;
        }
    }
    public Xtype GetAsXtype()
    {
        string v = $"{(X1 == 0 ? "" : "X1")}{(X2 == 0 ? "" : "X2")}{(X3 == 0 ? "" : "X3")}";
        if (v == "")
            v = "EMPTY";

        return (Xtype)Enum.Parse(typeof(Xtype), v);
    }
    public override string ToString() => $"({X1,-2},{X2,-2},{X3,-2})";
}
enum Xtype
{
    EMPTY = 0,
    X1 = 1,
    X2 = 2,
    X3 = 3,
    X1X2 = 4,
    X1X3 = 5,
    X2X3 = 6,
    X1X2X3 = 7,
    OMEGA = 8
}