Esempio n. 1
0
    static void Main()
    {
        ulong input =ulong.Parse(Console.ReadLine());
        var sb =new StringBuilder();

        ulong currentByte = 0;

        ulong reminderIn26 = 0;
        do
        {
            currentByte = input % 256;

            reminderIn26 = currentByte % 26;
            sb.Insert(0,(char)(reminderIn26 + 'A'));

            if (currentByte > 25)
            {
                sb.Insert(0,(char)(currentByte/26 + 96));
            }

            input /= 256;

        } while (input > 0);

        Console.WriteLine(sb.ToString());
    }
Esempio n. 2
0
 public static void ConvertDecToBin(string line)
 {
     int dec = int.Parse(line);
     StringBuilder bin = new StringBuilder();
     if (dec == 0)
     {
         bin.Insert(0, '0');
     }
     else
     {
         int q = dec;
         while (q != 0)
         {
             if (q % 2 == 0)
             {
                 bin.Insert(0, '0');
             }
             else
             {
                 bin.Insert(0, '1');
             }
             q /= 2;
         }
     }
     if (dec < 0)
     {
         Console.WriteLine("-{0}", bin);
     }
     else
     {
         Console.WriteLine("{0}", bin);
     }
 }
Esempio n. 3
0
    public static string ToCostValue(int value)
    {
        StringBuilder stringBuilder = new StringBuilder ();

        if (value > 0) {
            int divide = 1000;
            int quotient = value;
            int remainder = 0;

            while (quotient > 0) {
                remainder = quotient % divide;
                quotient /= divide;
                if (quotient > 0) {
                    stringBuilder.Insert (0, string.Format ("{0:D3}", remainder));
                    stringBuilder.Insert (0, ",");
                } else {
                    stringBuilder.Insert (0, string.Format("{0:D}", remainder));
                }
            }
        } else {
            stringBuilder.Append ("0");
        }

        return stringBuilder.ToString ();
    }
Esempio n. 4
0
 static void Main(string[] args)
 {
     using (StreamReader reader = File.OpenText(args[0]))
         while (!reader.EndOfStream)
         {
             string line = reader.ReadLine();
             string[] numbers = { "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM", "M", "MM", "MMM" };
             int a = 1;
             StringBuilder sb = new StringBuilder();
             for (int i = line.Length - 1; i >= 0; i--)
             {
                 string t = line.Substring(i, 1);
                 int t1 = int.Parse(t) * a;
                 if (t1 < 10 && t1 > 0)
                     sb.Insert(0, numbers[t1 - 1]);
                 if (t1 >= 10 && t1 < 100)
                     sb.Insert(0, numbers[9 + (int.Parse(t) - 1)]);
                 if (t1 >= 100 && t1 < 1000)
                     sb.Insert(0, numbers[18 + (int.Parse(t) - 1)]);
                 if (t1 >= 1000)
                     sb.Insert(0, numbers[27 + (int.Parse(t) - 1)]);
                 a *= 10;
             }
             Console.WriteLine(sb.ToString());
         }
 }
    private static string DecToBaseD(long decNum, int baseD)
    {
        StringBuilder numberBaseD = new StringBuilder();

        while (decNum > 0)
        {
            int index = 0;
            char numberBaseDValue = '0';

            if (((decNum % baseD) >= 0) && ((decNum % baseD <= 9)))
            {
                numberBaseDValue = (char)((decNum % baseD) + 48);
                numberBaseD.Insert(index, numberBaseDValue);
            }
            else
            {
                numberBaseDValue = (char)((decNum % baseD) + 55);
                numberBaseD.Insert(index, numberBaseDValue);
            }
            decNum = decNum / baseD;
            index++;
        }

        string result = Convert.ToString(numberBaseD);
        return result;
    }
Esempio n. 6
0
    public static string ConvertBase(string s, int b1, int b2)
    {
        char[] chars = s.ToUpper().ToCharArray();
        bool isNeg = (chars[0] == '-');
        int value = 0;

        // Get int value in base b1
        for (int i = (isNeg ? 1 : 0); i < chars.Length; ++i)
        {
            value *= b1;
            value += GetIntValue(chars[i]);
        }

        // Convert to string in base b2
        StringBuilder result = new StringBuilder();
        while (value > 0)
        {
            char n = GetBaseSymbol(value % b2);
            result.Insert(0, n);
            value /= b2;
        }

        if (isNeg)
        {
            result.Insert(0, '-');
        }

        return result.ToString();
    }
 public static void Main()
 {
     Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
     Console.Write("A floating-point with single precision, x = ");
     float x = float.Parse(Console.ReadLine());
     // float is a 32-bit floating-point number
     int n = 0;
     unsafe
     {
         int* ptr = (int*)&x;
         n = *ptr;
     }
     StringBuilder bin = new StringBuilder();
     // int is 32-bit signed integer
     for (int i = 0; i < 32; i++)
     {
         if ((n & 1) == 0)
         {
             bin.Insert(0, '0');
         }
         else
         {
             bin.Insert(0, '1');
         }
         n >>= 1;
     }
     Console.WriteLine(bin);
     string str = bin.ToString();
     Console.WriteLine("sign = {0}, exponent = {1}, mantissa = {2}", str[0], str.Substring(1, 8), str.Substring(9));
 }
Esempio n. 8
0
 static void Main()
 {
     byte n = byte.Parse(Console.ReadLine());
     StringBuilder carpet = new StringBuilder();
     carpet.Capacity = n + 2;
     carpet.Append('.', n/2 - 1);
     carpet.Append("/\\");
     carpet.Append('.', n/2 - 1);
     Console.WriteLine(carpet);
     for (byte i = 0; i < n/2 - 1; i++)
     {
         if((i & 1) == 0)
         {
             carpet.Insert(n/2, "  ");
         }
         else
         {
             carpet.Insert(n/2, "/\\");
         }
         carpet.Remove(n + 1, 1);
         carpet.Remove(0, 1);
         Console.WriteLine(carpet);
     }
     carpet.Replace('/','\\', 0, n/2);
     carpet.Replace('\\','/', n/2, n/2);
     Console.WriteLine(carpet);
     for (byte i = 0; i < n / 2 - 1; i++)
     {
         carpet.Remove(n / 2 - 1, 2);
         carpet.Append('.', 1);
         carpet.Insert(0, '.');
         Console.WriteLine(carpet);
     }
 }
Esempio n. 9
0
    public static void GotNewLetter(string letter)
    {
        int index = LetterSpawner.currentWordLettersLeft.IndexOf(letter);
        currentWordLetters[index] = letter;

        var aStringBuilder = new StringBuilder(currentWordLettersInString);

        if (index == 0)
        {
            aStringBuilder.Remove(1, 1);
            aStringBuilder.Insert(1, letter);
        }
        else
        {
            aStringBuilder.Remove(index * 2 + 1, 1);
            aStringBuilder.Insert(index * 2 + 1, letter);
        }

        currentWordLettersInString = aStringBuilder.ToString();

        LetterSpawner.currentWordLettersLeft[index] = "*";

        //for (int i = 0; i < LetterSpawner.currentWordLettersLeft.Count; i++)
        //    Debug.Log(LetterSpawner.currentWordLettersLeft[i]);
    }
Esempio n. 10
0
    private String GetSelectedNodeFullPath(TreeNode node)
    {
        StringBuilder path = new StringBuilder();
        path.Append(node.Text);
        TreeNode parent = node.Parent;

        if (parent == null)
        {
            path.Insert(0, SecurityManager.ObjectPathDelimiter);
        }
        else
        {
            while (parent != null)
            {
                if (parent.Text == SecurityObjectGameServerGroups)
                {
                    break;
                }
                else
                {
                    path.Insert(0, SecurityManager.ObjectPathDelimiter);
                    path.Insert(0, parent.Text);

                    parent = parent.Parent;
                }
            }
        }

        return path.ToString();
    }
    static string ConvertDecToBin(int number)
    {
        int baseOutput = 2;

        if (number < 0)
        {
            number *= -1;
        }

        StringBuilder outputNumber = new StringBuilder();

        while (number > 0)
        {
            long reminder = number % baseOutput;
            if (reminder <= 9)
            {
                outputNumber.Insert(0, reminder);
            }
            else
            {
                outputNumber.Insert(0, ((char)(reminder + 55)));
            }

            number /= baseOutput;
        }

        return outputNumber.ToString();
    }
    static string Multiply(string numberOne, int numberTwo)
    {
        List<int> digits = GetDigits(numberOne);

        StringBuilder sb = new StringBuilder();
        int number = 0;

        for (int index = 0; index < digits.Count; index++)
        {
            int digitResult = digits[index] * numberTwo;
            digitResult += number;

            if (digitResult < 10)
            {
                sb.Insert(0, digitResult);
                number = 0;
            }
            else if (digitResult >= 10)
            {
                sb.Insert(0, digitResult % 10);
                number = digitResult / 10;
            }
        }

        if (number > 0)
        {
            sb.Insert(0, number);
        }
        string endResult = Convert.ToString(sb);
        return endResult;
    }
Esempio n. 13
0
    static void Main()
    {
        string sentence = Console.ReadLine();
        string[] words = sentence.Split(' ');
        StringBuilder sb = new StringBuilder();
        string finalWord="";
        char finalSymbol=' ';
        for (int i = words.Length-1; i>=0; i--)
        {

            //sbList.Add(new StringBuilder(words[i]));
            if (words[i].Contains('.') || words[i].Contains('!') || words[i].Contains('?'))
            {
                finalWord = words[i];
                finalSymbol = finalWord[finalWord.Length - 1];
                string final = Regex.Replace(words[i].ToString(), @"[^\w+]", "", RegexOptions.None);
                sb.Insert(0, final);
                sb.Insert(final.Length, ' ');
            }
            else
            {
                sb.Append(words[i]);
                sb.Append(' ');
            }
            if (i == 0)
            {
                sb.Remove(sb.Length - 1, 1);
                sb.Append(finalSymbol);
            }
        }
        Console.WriteLine(sb.ToString());
    }
Esempio n. 14
0
 public static void ConvertDecToHex(string line)
 {
     int dec = int.Parse(line);
     StringBuilder hex = new StringBuilder();
     if (dec == 0)
     {
         hex.Insert(0, '0');
     }
     else
     {
         int q = dec;
         while (q != 0)
         {
             int residual = Math.Abs(q % 16);
             if (residual < 10)
             {
                 hex.Insert(0, (char)(48 + residual));
             }
             else
             {
                 hex.Insert(0, (char)(65 + residual - 10));
             }
             q /= 16;
         }
     }
     if (dec < 0)
     {
         Console.WriteLine("-{0}", hex);
     }
     else
     {
         Console.WriteLine("{0}", hex);
     }
 }
Esempio n. 15
0
 static string AddNumbersAsArray(string firstNumber, string secondNumber)
 {
     if (firstNumber.Length > secondNumber.Length)
     {
         secondNumber = secondNumber.PadLeft(firstNumber.Length, '0');
     }
     if (secondNumber.Length > firstNumber.Length)
     {
         firstNumber = firstNumber.PadLeft(secondNumber.Length, '0');
     }
     int[] firstArray = CreateArrayFromString(firstNumber);
     int[] secondArray = CreateArrayFromString(secondNumber);
     StringBuilder result = new StringBuilder();
     int reminder = 0;
     for (int i = 0; i < firstArray.Length; i++)
     {
         result.Insert(0,(firstArray[i] + secondArray[i] + reminder) % 10);
         reminder = (firstArray[i] + secondArray[i] + reminder) / 10;
     }
     if (reminder>0)
     {
         result.Insert(0,reminder);
     }
     return result.ToString();
 }
    static void Main()
    {
        int n = int.Parse(Console.ReadLine());
        int f = int.Parse(Console.ReadLine());
        int r = int.Parse(Console.ReadLine());

        string nInBinary = Convert.ToString(n, 2).PadLeft(19, '0');
        StringBuilder bin = new StringBuilder(nInBinary);
        char charAtFPos = bin[bin.Length - 1 - f];
        bin.Remove(bin.Length - 1 - f, 1);

        for (int i = 0; i < r; i++)
        {
            char right = bin[bin.Length - 1];

            bin.Remove(bin.Length - 1, 1);
            bin.Insert(0, right);
        }

        bin.Insert(bin.Length - f, charAtFPos);

        int res = Convert.ToInt32(bin.ToString(), 2);

        Console.WriteLine(res);
    }
    static BigInteger SumOfTwoNumbers(int[] firstArray, int[] secondArray)
    {
        StringBuilder sumString = new StringBuilder();
        int reminder = 0;
        for (int i = 0; i < firstArray.Length; i++)
        {
            if (i == 0)
            {
                sumString.Insert(0, ((firstArray[i] + secondArray[i]) % 10));
                reminder = (firstArray[i] + secondArray[i]) / 10;
            }
            else if (i < secondArray.Length)
            {
                sumString.Insert(0, ((firstArray[i] + secondArray[i] + reminder) % 10));
                reminder = (firstArray[i] + secondArray[i] + reminder) / 10;
            }
            else
            {
                sumString.Insert(0, (firstArray[i] + reminder) % 10);
                reminder = (firstArray[i] + reminder) / 10;
            }
            if (i == firstArray.Length - 1)
            {
                sumString.Insert(0, (reminder));
            }
        }

        return BigInteger.Parse(sumString.ToString());

    }
Esempio n. 18
0
    public string GetPageTitle()
    {
        StringBuilder sb = new StringBuilder();

        SiteMapNode node = SiteMap.CurrentNode;
        do
        {
            SiteMapNode parentNode = node.ParentNode;

            // Exclude category names from title
            if (!string.IsNullOrEmpty(node.Url))
            {
                sb.Insert(0, node.Title);

                // Add dash between nodes
                if (parentNode != null)
                {
                    sb.Insert(0, "&nbsp;&mdash;&nbsp;");
                }
            }
            node = parentNode;
        }
        while (node != null);

        return sb.ToString();
    }
    static void Main()
    {
        int number = int.Parse(Console.ReadLine());

        List<int> bitsPositions = new List<int>();
        List<string> commands = new List<string>();

        while (true)
        {
            string bitPos = Console.ReadLine();

            if (bitPos == "quit")
            {
                break;
            }

            bitsPositions.Add(int.Parse(bitPos));

            string command = Console.ReadLine();
            commands.Add(command);
        }

        StringBuilder manipulate = new StringBuilder();
        string numberAsBits = Convert.ToString(number, 2).PadLeft(32, '0');
        manipulate.Append(numberAsBits);

        for (int i = 0; i < commands.Count; i++)
        {
            string currentCommand = commands[i];
            int pos = 31 - bitsPositions[i];

            switch (currentCommand)
            {
                case "flip":
                    if (manipulate[pos] == '0')
                    {
                        manipulate.Replace('0', '1', pos, 1);
                    }
                    else
                    {
                        manipulate.Replace('1', '0', pos, 1);
                    }
                    break;
                case "remove":
                    manipulate.Remove(pos, 1);
                    manipulate.Insert(0, '0');
                    break;
                case "insert":
                    manipulate.Remove(0, 1);
                    manipulate.Insert(pos, '1');
                    break;
            }
        }

        ulong result = Convert.ToUInt64(manipulate.ToString(), 2);
        Console.WriteLine(result);
    }
Esempio n. 20
0
 public static void ConvertAnyToAny(string numberIn, int numeralSystemIn, int numeralSystemOut)
 {
     int dec = 0;
     foreach (char c in numberIn)
     {
         if (c >= '0' && c <= '0' + numeralSystemIn - 1)
         {
             dec *= numeralSystemIn;
             dec += (c - 48);
         }
         else if (c >= 'A' && c <= 'A' + numeralSystemIn - 11)
         {
             dec *= numeralSystemIn;
             dec += (c - 65 + 10);
         }
         else if (c >= 'a' && c <= 'a' + numeralSystemIn - 11)
         {
             dec *= numeralSystemIn;
             dec += (c - 97 + 10);
         }
         else if (c != '-')
         {
             throw new Exception(string.Format("Not a valid integer with base {0}!", numeralSystemIn));
         }
     }
     StringBuilder numberOut = new StringBuilder();
     if (dec == 0)
     {
         numberOut.Insert(0, '0');
     }
     else
     {
         int q = dec;
         while (q != 0)
         {
             int residual = Math.Abs(q % numeralSystemOut);
             if (residual < 10)
             {
                 numberOut.Insert(0, (char)(48 + residual));
             }
             else
             {
                 numberOut.Insert(0, (char)(65 + residual - 10));
             }
             q /= numeralSystemOut;
         }
     }
     if (numberIn[0] == '-')
     {
         Console.WriteLine("-{0}", numberOut);
     }
     else
     {
         Console.WriteLine("{0}", numberOut);
     }
 }
    static void Main()
    {
        /*  Problem 16. Decimal to Hexadecimal Number

            Using loops write a program that converts an integer number to its hexadecimal representation.
            The input is entered as long. The output should be a variable of type string.
            Do not use the built-in .NET functionality.
            Examples:

            decimal	        hexadecimal
            254	            FE
            6883	        1AE3
            338583669684	4ED528CBB4
        */

        Console.Title = "Decimal to Hexadecimal Number";

        Console.Write("Enter an integer number: ");
        long number = long.Parse(Console.ReadLine());

        StringBuilder binary = new StringBuilder();
        while (number > 0)
        {
            int index = 0;
            char hexValue = '0';
            long remainder = number % 16;
            if (remainder > 9)
            {
                switch (remainder)
                {
                    case 10: hexValue = 'A';
                        break;
                    case 11: hexValue = 'B';
                        break;
                    case 12: hexValue = 'C';
                        break;
                    case 13: hexValue = 'D';
                        break;
                    case 14: hexValue = 'E';
                        break;
                    case 15: hexValue = 'F';
                        break;
                    default: Console.WriteLine("Fail");
                        break;
                }
                binary.Insert(index, hexValue);
            }
            else
            {
                binary.Insert(index, remainder);
            }
            number /= 16;
            index++;
        }
        Console.WriteLine("The number in Hexadecimal is: {0}", binary);
    }
Esempio n. 22
0
    private static void CheckResult(StringBuilder builder, int tokens, List<string> allWords, int j)
    {
        if (builder.Length > tokens)
        {
            builder.Length--;
            Console.WriteLine(builder);
            builder.Clear();
            builder.Append(allWords[j] + " ");

        }
        else if (builder.Length == tokens && builder[builder.Length - 1] == ' ')
        {
            builder.Length--;
            int ind = builder.ToString().IndexOf(' ');
            if(ind > 0)
            builder.Insert(builder.ToString().IndexOf(' '), ' ');

            Console.WriteLine(builder);
            builder.Clear();
            builder.Append(allWords[j] + " ");
        }
        else if (builder.Length < tokens)
        {
            builder.Length--;

            int whitespaces = tokens - builder.Length;
            int startIndex = 0;
            int indOf = builder.ToString().IndexOf(" ", startIndex);
            if (indOf < 0)
            {
                whitespaces = 0;
            }

            while (whitespaces != 0)
            {
                builder.Insert(indOf, " ");
                startIndex = indOf;
                while (builder[startIndex] == ' ')
                {
                    startIndex++;
                }
                indOf = builder.ToString().IndexOf(" ", startIndex);
                if (indOf < 0)
                {
                    startIndex = 0;
                    indOf = builder.ToString().IndexOf(" ", startIndex);
                }
                whitespaces--;
            }

            Console.WriteLine(builder);
            builder.Clear();
            builder.Append(allWords[j] + " ");
        }
    }
Esempio n. 23
0
    static void Main()
    {
        ulong number = ulong.Parse(Console.ReadLine());
        StringBuilder str = new StringBuilder();

        if (number == 0)
        {
            Console.WriteLine("LON+");
        }

        while (number > 0)
        {
            ulong digit = number % 9;
            switch (digit)
            {
                case 0: str.Insert(0, "LON+");  break;
                case 1: str.Insert(0, "VK-");   break;
                case 2: str.Insert(0, "*ACAD"); break;
                case 3: str.Insert(0, "^MIM");  break;
                case 4: str.Insert(0, "ERIK|"); break;
                case 5: str.Insert(0, "SEY&");  break;
                case 6: str.Insert(0, "EMY>>"); break;
                case 7: str.Insert(0, "/TEL");  break;
                case 8: str.Insert(0, "<<DON"); break;
            }
            number /= 9;
        }
        
        Console.WriteLine(str.ToString());
    }
    public string FractionToDecimal(int numerator, int denominator)
    {
        // input corner cases
         		if (denominator == 0) return string.Empty;
         		if (numerator == 0) return "0";

         		StringBuilder result = new StringBuilder();

         		// negative input
         		if ((numerator < 0 && denominator > 0) || (numerator > 0 && denominator < 0))
         		{
         		    result.Append("-");
         		}

         		long x = Math.Abs((long) numerator);
         		long y = Math.Abs((long) denominator);

         		Dictionary<long, int> dividend = new Dictionary<long, int>();
         		int decimalPoint = 0;

         		do {
         			if (dividend.ContainsKey(x))
         			{
         				result.Insert(dividend[x], '(');
         				result.Append(')');
         				break;
         			}

         			if (x < y)
         			{
         				// this seems to be
         				result.Append("0");
         				dividend.Add(x, result.Length-1);
         				x *= 10;
         				if (decimalPoint == 0) decimalPoint = result.Length;
         			}
         			else
         			{
         				result.Append((x / y).ToString());
         				dividend.Add(x, result.Length-1);
         				x = x % y;
         				if (x > 0)
         				{
         				    x *= 10;
         				    if (decimalPoint == 0) decimalPoint = result.Length;
         				}
         			}
         		} while (x != 0);

         		if (decimalPoint > 0)
         		{
         			result.Insert(decimalPoint, '.');
         		}
         		return result.ToString();
    }
 static string BinaryString(short number, short sign)
 {
     StringBuilder bin = new StringBuilder();
     for (int i = 15; i > 0; i--)
     {
         bin.Insert(0, (sign ^ (number % 2)));
         number /= 2;
     }
     bin.Insert(0, sign);
     return bin.ToString();
 }
Esempio n. 26
0
    public string UserDatabaseString()
    {
        StringBuilder udbstring = new StringBuilder(UserName);
        udbstring.Insert(12, Password);
        udbstring.Insert(22, FirstName);
        udbstring.Insert(34, MiddleName);
        udbstring.Insert(56, LastName);
        udbstring.Insert(68, Status);
        udbstring.Append('\n');

        return udbstring.ToString();
    }
    static void Main()
    {
        int numbers = int.Parse(Console.ReadLine());
        int step = int.Parse(Console.ReadLine());
        StringBuilder numbersAsBits = new StringBuilder();

        for (int i = 0; i < numbers; i++)
        {
            int bits = int.Parse(Console.ReadLine());
            string b = Convert.ToString(bits, 2);

            if (b.Length < 8)
            {
                numbersAsBits.Insert(numbersAsBits.Length, "0", (8 - b.Length));
            }
            numbersAsBits.Append(b);
            
        }

        string[] bitsToProcess = new string[numbers * 8];
        for (int fill = 0; fill < bitsToProcess.Length; fill++)
        {
            bitsToProcess[fill] = numbersAsBits[fill].ToString();
        }

        for (int i = 1; i < bitsToProcess.Length; i+=step)
        {
            bitsToProcess[i] = null;
        }

        numbersAsBits.Clear();

        foreach (var bit in bitsToProcess)
        {
            if (bit != null)
            {
                numbersAsBits.Append(bit);
            }
        }

        if (numbersAsBits.Length % 8 != 0)
        {
            numbersAsBits.Insert(numbersAsBits.Length, "0", (8 -(numbersAsBits.Length % 8)));
        }

        for (int i = 0; i < numbersAsBits.Length; i+=8)
        {
            string temp = numbersAsBits.ToString().Substring(i, 8);
            int result = Convert.ToInt32(temp, 2);
            Console.WriteLine(result);
        }        
    }
Esempio n. 28
0
    public string CourseDatabaseString()
    {
        StringBuilder cdbstring = new StringBuilder(Term);
        cdbstring.Insert(5, Coursename);
        cdbstring.Insert(17, Coursetitle);
        cdbstring.Insert(34, Instructor);
        cdbstring.Insert(46, Credit.ToString());
        cdbstring.Insert(52, Seats.ToString());
        cdbstring.Insert(57, Times.Count);
        foreach (coursetime time in Times)
            cdbstring.Append(time.ToString() + "  ");

        return cdbstring.ToString();
    }
    static void Main()
    {
        uint number = uint.Parse(Console.ReadLine());
        string command = Console.ReadLine();

        string numAsBits = Convert.ToString(number, 2).PadLeft(32, '0');
        int newNumber = 0;

        do
        {
            StringBuilder tempNum = new StringBuilder();

            if (command == "Odd")
            {
                for (int i = numAsBits.Length - 1; i >= 0; i-=2)
                {
                    tempNum.Insert(0, numAsBits[i]);
                }

                newNumber = Convert.ToInt32(tempNum.ToString(), 2);
                numAsBits = Convert.ToString(newNumber, 2).PadLeft(16, '0');
            }
            else
            {
                for (int i = numAsBits.Length - 2; i >= 0; i-=2)
                {
                    tempNum.Insert(0, numAsBits[i]);
                }

                newNumber = Convert.ToInt32(tempNum.ToString(), 2);
                numAsBits = Convert.ToString(newNumber, 2).PadLeft(16, '0');
            }

            command = Console.ReadLine();
        } while (command != "Game Over!");

        int count = 0;

        int start = numAsBits.IndexOf('1');

        for (int i = start - 1; i < numAsBits.Length; i++)
        {
            if (numAsBits[i] == '1')
            {
                count++;
            }
        }

        Console.WriteLine("{0} -> {1}", newNumber, count);
    }
    static void Main()
    {
        StringBuilder line = new StringBuilder();
        string pattern = @"(?<![a-zA-Z])[A-Z]+(?![a-zA-Z])";
        Regex regex = new Regex(pattern);

        while (line.ToString() != "END")
        {          
            MatchCollection matches = regex.Matches(line.ToString());

            int offset = 0;
            foreach (Match match in matches)
            {
               string word = match.Value;
               string reversed = Reverse(word);
              
                if (reversed == word)
                {
                    reversed = DoubleEachLetter(reversed);
                }

                int index = match.Index;
                line = line.Remove(index + offset, word.Length);
                line = line.Insert(index + offset, reversed);
                offset += reversed.Length - word.Length;

            }

            Console.WriteLine(SecurityElement.Escape(line.ToString()));
            line = new StringBuilder(Console.ReadLine());
        }
    }