opQ 2, C# - rextester

Language: Layout:

//Rextester.Program.Main is the entry point for your code. Don't change it.
//Compiler version 4.0.30319.17929 for Microsoft (R) .NET Framework 4.5

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;

namespace Rextester
{
    public class Program
    {
        public static void Main(string[] args)
        {
            //Your code goes here
            Random Rand = new Random();
            string[] op = new string[] {"+", "-", "*", "/"};
            
            List<string> opQ = new List<string>();
            
           
            int result;
            
            for (int j = 0; j < 120; j++) {
                
            int[] n = new int[5];
                for (int i = 0; i<n.Length; i++) {
                    n[i] = Rand.Next(1,90);
                }
            
            int a = Rand.Next(0,1);
            int b = Rand.Next(0,1);
            int c = Rand.Next(0,4);
            int d = Rand.Next(0,4);
            // "+" 1st switch
            switch(op[a]) {                
                case "+":
                    // 2nd switch
                    switch(op[b]) {
                        case "+":
                            // 3rd switch
                            switch(op[c]) {
                                case "+":
                                    // 4th switch
                                    switch(op[d]) {
                                        case "+":
                                            result = n[0] + n[1] + n[2] + n[3] + n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" + "+n[3]+" + "+n[4]+" = "+result);
                                        break;
                                        case "-":
                                            result = n[0] + n[1] + n[2] + n[3] - n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" + "+n[3]+" - "+n[4]+" = "+result);
                                        break;
                                        case "*":
                                            result = n[0] + n[1] + n[2] + n[3] * n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" + "+n[3]+" * "+n[4]+" = "+result);
                                        break;
                                        case "/":
                                            double resultD = n[0] + n[1] + n[2] + ((double)n[3] /(double)n[4]);
                                            if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" + "+n[3]+" / "+n[4]+" = "+(int)resultD);
                                        break;
                                    }
                                break;
                                case "-": 
                                    switch(op[d]) {
                                        case "+":
                                            result = n[0] + n[1] + n[2] - n[3] + n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" - "+n[3]+" + "+n[4]+" = "+result);
                                        break;
                                        case "-":
                                        result = n[0] + n[1] + n[2] - n[3] - n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" - "+n[3]+" - "+n[4]+" = "+result);
                                        break;
                                        case "*":
                                            result = n[0] + n[1] + n[2] - n[3] * n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" - "+n[3]+" * "+n[4]+" = "+result);
                                        break;
                                        case "/":
                                        double resultD = n[0] + n[1] + n[2] - ((double) n[3] / (double)n[4]);
                                            if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" - "+n[3]+" / "+n[4]+" = "+(int)resultD);
                                        break;
                                    }
                                break;
                                case "*":
                                    switch(op[d]) {
                                        case "+":
                                            result = n[0] + n[1] + n[2] * n[3] + n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" * "+n[3]+" + "+n[4]+" = "+result);
                                        break;
                                        case "-":
                                        result = n[0] + n[1] + n[2] * n[3] - n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" * "+n[3]+" - "+n[4]+" = "+result);
                                        break;
                                        case "*":
                                        result = n[0] + n[1] + n[2] * n[3] * n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" * "+n[3]+" * "+n[4]+" = "+result);
                                        break;
                                        case "/":
                                        double resultD = n[0] + n[1] + ((double) n[2] * n[3] / (double)n[4]);
                                            if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" * "+n[3]+" / "+n[4]+" = "+(int)resultD);
                                        break;
                                    }
                                break;
                                case "/":
                                    switch(op[d]) {
                                        case "+":
                                        double resultD = n[0] + n[1] + ((double)n[2] /(double)n[3]) + n[4];
                                            if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" / "+n[3]+" + "+n[4]+" = "+resultD);
                                        break;
                                        case "-":
                                        resultD = n[0] + n[1] + ((double)n[2] /(double)n[3]) - n[4];
                                            if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" / "+n[3]+" - "+n[4]+" = "+resultD);
                                        break;
                                        case "*":
                                        resultD = n[0] + n[1] + ((double)n[2] /(double)n[3]) * n[4];
                                            if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" / "+n[3]+" * "+n[4]+" = "+resultD);
                                        break;
                                        case "/":
                                        resultD = n[0] + n[1] + ((double) n[2] / (double)n[3] /(double)n[4]);
                                            if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" / "+n[3]+" / "+n[4]+" = "+(int)resultD);
                                        break;
                                    }
                                break;
                            }
                        break;
                        case "-":
                            switch(op[c]) {
                                case "+":
                                    // 4th switch
                                    switch(op[d]) {
                                        case "+":
                                        result = n[0] + n[1] - n[2] + n[3] + n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" + "+n[3]+" + "+n[4]+" = "+result);
                                        break;
                                        case "-":
                                        result = n[0] + n[1] - n[2] + n[3] - n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" + "+n[3]+" - "+n[4]+" = "+result);
                                        break;
                                        case "*":
                                        result = n[0] + n[1] - n[2] + n[3] * n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" + "+n[3]+" * "+n[4]+" = "+result);
                                        break;
                                        case "/":
                                        double resultD = n[0] + n[1] - n[2] + ((double)n[3] / (double)n[4]);
                                            if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" / "+n[3]+" / "+n[4]+" = "+(int)resultD);
                                        break;
                                    }
                                break;
                                case "-": 
                                    switch(op[d]) {
                                        case "+":
                                        result = n[0] + n[1] - n[2] - n[3] + n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" - "+n[3]+" + "+n[4]+" = "+result);
                                        break;
                                        case "-":
                                        result = n[0] + n[1] - n[2] - n[3] - n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" - "+n[3]+" - "+n[4]+" = "+result);
                                        break;
                                        case "*":
                                        result = n[0] + n[1] - n[2] - n[3] * n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" - "+n[3]+" * "+n[4]+" = "+result);
                                        break;
                                        case "/":
                                        double resultD = n[0] + n[1] - n[2] - ((double)n[3] / (double)n[4]);
                                            if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" - "+n[3]+" / "+n[4]+" = "+(int)resultD);
                                        break;
                                    }
                                break;
                                case "*":
                                    switch(op[d]) {
                                        case "+":
                                        result = n[0] + n[1] - n[2] * n[3] + n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" * "+n[3]+" + "+n[4]+" = "+result);
                                        break;
                                        case "-":
                                        result = n[0] + n[1] - n[2] * n[3] - n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" * "+n[3]+" - "+n[4]+" = "+result);
                                        break;
                                        case "*":
                                        result = n[0] + n[1] - n[2] * n[3] * n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" * "+n[3]+" * "+n[4]+" = "+result);
                                        break;
                                        case "/":
                                        double resultD = n[0] + n[1] - ((double) (n[2] * n[3]) / (double)n[4]);
                                            if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" * "+n[3]+" / "+n[4]+" = "+(int)resultD);
                                        break;
                                    }
                                break;
                                case "/":
                                    switch(op[d]) {
                                        case "+":
                                        double resultD = n[0] + n[1] - ( (double)n[2] / (double)n[3]) + n[4];
                                            if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" / "+n[3]+" + "+n[4]+" = "+resultD);
                                        Console.WriteLine("+ - / +");
                                        break;
                                        case "-":
                                        resultD = n[0] + n[1] - ((double) n[2] /(double) n[3]) - n[4];
                                            if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" / "+n[3]+" - "+n[4]+" = "+resultD);
                                        Console.WriteLine("+ - / -");
                                        break;
                                        case "*":
                                        resultD = n[0] + n[1] - ((double) n[2] /(double) n[3] * n[4]);
                                            if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" / "+n[3]+" * "+n[4]+" = "+resultD);
                                        Console.WriteLine("+ - / *");
                                        break;
                                        case "/":
                                        resultD = n[0] + n[1] -  ((double)n[2] / (double)n[3] / (double)n[4]);
                                            if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" - "+n[2]+" / "+n[3]+" / "+n[4]+" = "+(int)resultD);
                                        Console.WriteLine("+ - / /");
                                        break;
                                    }
                                break;
                            }
                        break;
                        case "*":
                            switch(op[c]) {
                                case "+":
                                    // 4th switch
                                    switch(op[d]) {
                                        case "+":
                                        result = n[0] + n[1] * n[2] + n[3] + n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" + "+n[3]+" + "+n[4]+" = "+result);
                                        break;
                                        case "-":
                                        result = n[0] + n[1] * n[2] + n[3] - n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" + "+n[3]+" - "+n[4]+" = "+result);
                                        break;
                                        case "*":
                                        result = n[0] + n[1] * n[2] + n[3] * n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" + "+n[3]+" * "+n[4]+" = "+result);
                                        break;
                                        case "/":
                                        double resultD = (double) n[0] + n[1] * n[2] + n[3] / n[4];
                                            if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" + "+n[3]+" / "+n[4]+" = "+(int)resultD);
                                        break;
                                    }
                                break;
                                case "-": 
                                    switch(op[d]) {
                                        case "+":
                                        result = n[0] + n[1] * n[2] - n[3] + n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" - "+n[3]+" + "+n[4]+" = "+result);
                                        break;
                                        case "-":
                                        result = n[0] + n[1] * n[2] - n[3] - n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" - "+n[3]+" - "+n[4]+" = "+result);
                                        Console.WriteLine("+ * - -");
                                        break;
                                        case "*":
                                        result = n[0] + n[1] * n[2] - n[3] * n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" - "+n[3]+" * "+n[4]+" = "+result);
                                        Console.WriteLine("+ * - *");
                                        break;
                                        case "/":
                                        double resultD = (double) n[0] + n[1] * n[2] - n[3] / n[4];
                                            if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" - "+n[3]+" / "+n[4]+" = "+(int)resultD);
                                        Console.WriteLine("+ * - /");
                                        break;
                                    }
                                break;
                                case "*":
                                    switch(op[d]) {
                                        case "+":
                                        result = n[0] + n[1] * n[2] * n[3] + n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" * "+n[3]+" + "+n[4]+" = "+result);
                                        break;
                                        case "-":
                                        result = n[0] + n[1] * n[2] * n[3] - n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" * "+n[3]+" - "+n[4]+" = "+result);
                                        break;
                                        case "*":
                                        result = n[0] + n[1] * n[2] * n[3] * n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" * "+n[3]+" * "+n[4]+" = "+result);
                                        break;
                                        case "/":
                                        double resultD = (double) n[0] + n[1] * n[2] * n[3] / n[4];
                                            if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" * "+n[3]+" / "+n[4]+" = "+(int)resultD);
                                        Console.WriteLine("+ * * /");
                                        break;
                                    }
                                break;
                                case "/":
                                    switch(op[d]) {
                                        case "+":
                                        double resultD = n[0] + n[1] * n[2] / n[3] + n[4];
                                            if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" / "+n[3]+" + "+n[4]+" = "+resultD);
                                        Console.WriteLine("+ * / +");
                                        break;
                                        case "-":
                                        resultD = n[0] + n[1] * n[2] / n[3] - n[4];
                                            if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" / "+n[3]+" - "+n[4]+" = "+resultD);
                                        Console.WriteLine("+ * / -");
                                        break;
                                        case "*":
                                        resultD = n[0] + n[1] * n[2] / n[3] * n[4];
                                            if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" / "+n[3]+" * "+n[4]+" = "+resultD);
                                        Console.WriteLine("+ * / *");
                                        break;
                                        case "/":
                                        resultD = (double) n[0] + n[1] * n[2] / n[3] / n[4];
                                            if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" * "+n[2]+" / "+n[3]+" / "+n[4]+" = "+(int)resultD);
                                        Console.WriteLine("+ * / /");
                                        break;
                                    }
                                break;
                            }
                        break;
                        case "/":
                            switch(op[c]) {
                                case "+":
                                    // 4th switch
                                    switch(op[d]) {
                                        case "+":
                                        double resultD = n[0] + n[1] / n[2] + n[3] + n[4];
                                            if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" / "+n[2]+" + "+n[3]+" + "+n[4]+" = "+resultD);
                                        Console.WriteLine("+ / + +");
                                        break;
                                        case "-":
                                        resultD = n[0] + n[1] / n[2] + n[3] - n[4];
                                            if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" / "+n[2]+" + "+n[3]+" - "+n[4]+" = "+resultD);
                                        Console.WriteLine("+ / + -");
                                        break;
                                        case "*":
                                        resultD = n[0] + n[1] / n[2] + n[3] * n[4];
                                            if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" / "+n[2]+" + "+n[3]+" * "+n[4]+" = "+resultD);
                                        Console.WriteLine("+ / + *");
                                        break;
                                        case "/":
                                        resultD = (double) n[0] + n[1] / n[2] + n[3] / n[4];
                                            if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" / "+n[2]+" + "+n[3]+" / "+n[4]+" = "+(int)resultD);
                                        Console.WriteLine("+ / + /");
                                        break;
                                    }
                                break;
                                case "-": 
                                    switch(op[d]) {
                                        case "+":
                                        result = n[0] + n[1] + n[2] + n[3] + n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" + "+n[3]+" + "+n[4]+" = "+result);
                                        Console.WriteLine("+ / - +");
                                        break;
                                        case "-":
                                        result = n[0] + n[1] + n[2] + n[3] + n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" + "+n[3]+" + "+n[4]+" = "+result);
                                        Console.WriteLine("+ / - -");
                                        break;
                                        case "*":
                                        result = n[0] + n[1] + n[2] + n[3] + n[4];
                                            if (result<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" + "+n[3]+" + "+n[4]+" = "+result);
                                        Console.WriteLine("+ / - *");
                                        break;
                                        case "/":
                                        double resultD = (double) n[0] + n[1] + n[2] + n[3] / n[4];
                                            if (resultD%1==0 && resultD<100) Console.WriteLine(n[0]+" + "+n[1]+" + "+n[2]+" / "+n[3]+" / "+n[4]+" = "+(int)resultD);Console.WriteLine("+ / - /");
                                        break;
                                    }
                                break;
                                case "*":
                                    switch(op[d]) {
                                        case "+":
                                        Console.WriteLine("+ / * +");
                                        break;
                                        case "-":
                                        Console.WriteLine("+ / * -");
                                        break;
                                        case "*":
                                        Console.WriteLine("+ / * *");
                                        break;
                                        case "/":
                                        Console.WriteLine("+ / * /");
                                        break;
                                    }
                                break;
                                case "/":
                                    switch(op[d]) {
                                        case "+":
                                        Console.WriteLine("+ / / +");
                                        break;
                                        case "-":
                                        Console.WriteLine("+ / / -");
                                        break;
                                        case "*":
                                        Console.WriteLine("+ / / *");
                                        break;
                                        case "/":
                                        Console.WriteLine("+ / / /");
                                        break;
                                    }
                                break;
                            }
                        break; // 2nd switch break
                    }
                break; // 1st "+" switch break
                
                case "-":
                    // 2nd switch
                    switch(op[b]) {
                        case "+":
                            // 3rd switch
                            switch(op[c]) {
                                case "+":
                                Console.WriteLine("- + +");
                                break;
                                case "-":
                                Console.WriteLine("- + -");
                                break;
                                case "*":
                                Console.WriteLine("- + *");
                                break;
                                case "/":
                                Console.WriteLine("- + /");
                                break;
                            }
                        break;
                        case "-":
                            switch(op[c]) {
                                case "+":
                                Console.WriteLine("- - +");
                                break;
                                case "-":
                                Console.WriteLine("- - -");
                                break;
                                case "*":
                                Console.WriteLine("- - *");
                                break;
                                case "/":
                                Console.WriteLine("- - /");
                                break;
                            }
                        break;
                        case "*":
                            switch(op[c]) {
                                case "+":
                                Console.WriteLine("- * +");
                                break;
                                case "-":
                                Console.WriteLine("- * -");
                                break;
                                case "*":
                                Console.WriteLine("- * *");
                                break;
                                case "/":
                                Console.WriteLine("- * /");
                                break;
                            }
                        break;
                        case "/":
                            switch(op[c]) {
                                case "+":
                                Console.WriteLine("- / +");
                                break;
                                case "-":
                                Console.WriteLine("- / -");
                                break;
                                case "*":
                                Console.WriteLine("- / *");
                                break;
                                case "/":
                                Console.WriteLine("- / /");
                                break;
                            }
                        break; // 2nd switch break
                    }
                break; // 1st "-" switch break
                case "*":
                    // 2nd switch
                    switch(op[b]) {
                        case "+":
                            // 3rd switch
                            switch(op[c]) {
                                case "+":
                                Console.WriteLine("* + +");
                                break;
                                case "-":
                                Console.WriteLine("* + -");
                                break;
                                case "*":
                                Console.WriteLine("* + *");
                                break;
                                case "/":
                                Console.WriteLine("* + /");
                                break;
                            }
                        break;
                        case "-":
                            switch(op[c]) {
                                case "+":
                                Console.WriteLine("* - +");
                                break;
                                case "-":
                                Console.WriteLine("* - -");
                                break;
                                case "*":
                                Console.WriteLine("* - *");
                                break;
                                case "/":
                                Console.WriteLine("* - /");
                                break;
                            }
                        break;
                        case "*":
                            switch(op[c]) {
                                case "+":
                                Console.WriteLine("* * +");
                                break;
                                case "-":
                                Console.WriteLine("* * -");
                                break;
                                case "*":
                                Console.WriteLine("* * *");
                                break;
                                case "/":
                                Console.WriteLine("* * /");
                                break;
                            }
                        break;
                        case "/":
                            switch(op[c]) {
                                case "+":
                                Console.WriteLine("* / +");
                                break;
                                case "-":
                                Console.WriteLine("* / -");
                                break;
                                case "*":
                                Console.WriteLine("* / *");
                                break;
                                case "/":
                                Console.WriteLine("* / /");
                                break;
                            }
                        break; // 2nd switch break
                    }
                break; // 1st "*" switch break
                
                case "/":
                    // 2nd switch
                    switch(op[b]) {
                        case "+":
                            // 3rd switch
                            switch(op[c]) {
                                case "+":
                                Console.WriteLine("/ + +");
                                break;
                                case "-":
                                Console.WriteLine("/ + -");
                                break;
                                case "*":
                                Console.WriteLine("/ + *");
                                break;
                                case "/":
                                Console.WriteLine("/ + /");
                                break;
                            }
                        break;
                        case "-":
                            switch(op[c]) {
                                case "+":
                                Console.WriteLine("/ - +");
                                break;
                                case "-":
                                Console.WriteLine("/ - -");
                                break;
                                case "*":
                                Console.WriteLine("/ - *");
                                break;
                                case "/":
                                Console.WriteLine("/ - /");
                                break;
                            }
                        break;
                        case "*":
                            switch(op[c]) {
                                case "+":
                                Console.WriteLine("/ * +");
                                break;
                                case "-":
                                Console.WriteLine("/ * -");
                                break;
                                case "*":
                                Console.WriteLine("/ * *");
                                break;
                                case "/":
                                Console.WriteLine("/ * /");
                                break;
                            }
                        break;
                        case "/":
                            switch(op[c]) {
                                case "+":
                                Console.WriteLine("/ / +");
                                break;
                                case "-":
                                Console.WriteLine("/ / -");
                                break;
                                case "*":
                                Console.WriteLine("/ / *");
                                break;
                                case "/":
                                Console.WriteLine("/ / /");
                                break;
                            }
                        break; // 2nd switch break
                    }
                break; // 1st "/" switch break
                
            }
        }
        }
    }
}

Show compiler warnings [ + ] Show input
Compilation time: 0,16 sec, absolute running time: 0,11 sec, cpu time: 0,11 sec, average memory usage: 17 Mb, average nr of threads: 4