using ControlChars = Microsoft.VisualBasic.ControlChars;
using Encoding = System.Text.Encoding;
using StringBuilder = System.Text.StringBuilder;
using System;
using Xml = System.Xml;
 
namespace Tools
{
    class XmlUtil
    {
        /// <remarks>
        /// *****************************************************************
        /// Snippet Title: XML Beautifier
        /// Code's Author: Elektro
        /// Date Modified: 18-February-2015
        /// *****************************************************************
        /// </remarks>
        /// <summary>Beautifies the contents of an XML document.</summary>
        /// <param name="XMLText">
        /// The XML text content. 
        /// It can be an entire document or a fragment.
        /// </param>
        /// <param name="IndentChars">
        /// The string that is used to indent the XML. 
        /// Default value is: <see cref="Microsoft.VisualBasic.ControlChars.Tab"/>
        /// </param>
        /// <param name="IndentOnAttributes">
        /// If set to <c>true</c>, attributes will be separated by newlines.
        /// Default value is: <c>false</c>
        /// </param>
        /// <param name="TextEncoding">
        /// The XML text encoding to use. 
        /// Default value is: <see cref="System.Text.Encoding.Default"/>.
        /// </param>
        /// <returns>The beautified XML text.</returns>
        /// <exception cref="System.ArgumentNullException"></exception>
        public static string XmlBeautifier(string xmlText,
                                           string indentChars = null,
                                           bool indentOnAttributes = false,
                                           Encoding textEncoding = null)
        {
            if (string.IsNullOrEmpty(xmlText) || string.IsNullOrWhiteSpace(xmlText))
            {
                throw new ArgumentNullException(xmlText);
            }
 
            StringBuilder sb = new StringBuilder();
            Xml.XmlDocument doc = new Xml.XmlDocument();
            Xml.XmlWriterSettings settings = new Xml.XmlWriterSettings();
 
            settings.Indent = true;
            settings.CheckCharacters = true;
            settings.OmitXmlDeclaration = false;
            settings.ConformanceLevel = Xml.ConformanceLevel.Auto;
            settings.NamespaceHandling = Xml.NamespaceHandling.Default;
            settings.NewLineHandling = Xml.NewLineHandling.Replace;
            settings.NewLineChars = ControlChars.NewLine;
            settings.NewLineOnAttributes = indentOnAttributes;
            settings.IndentChars = indentChars != null ? indentChars : Convert.ToString(ControlChars.Tab);
            settings.Encoding = textEncoding != null ? textEncoding : Encoding.Default;
 
            using (Xml.XmlWriter writer = Xml.XmlWriter.Create(sb, settings))
            {
                doc.LoadXml(xmlText);
                doc.WriteContentTo(writer);
                writer.Flush();
            }
 
            return sb.ToString();
        }
 
    }
}

Encoding textEncoding = Encoding.Default;
 
string unformattedXmlDocument = File.ReadAllText("C:\\Unformatted Document.xml", textEncoding);
string formattedXmlDocument = XmlBeautifier(xmlText: unformattedXmlDocument, 
                                            indentChars: new string(' ', 2), 
                                            indentOnAttributes: true,
                                            textEncoding: textEncoding);
 
File.WriteAllText("C:\\Formatted Document.xml", formattedXmlDocument, textEncoding);

static int Fibonacci(int n)
        {
            if (n == 0) return 0;
            if (n == 1) return 1;
            return Fibonacci(n - 2) + Fibonacci(n - 1);
        }

static long[] fibonacci; //Para ir almacenando los valores de los términos calculados.
 
        static void Main(string[] args)
        {
            long n = long.Parse(Console.ReadLine());
            fibonacci = new long[n+1];
            Console.WriteLine(Fibonacci(n));
 
        }
 
        static long Fibonacci(long n)
        {
            if (fibonacci[n] != 0)
                return fibonacci[n];
            if (n == 1 || n==2)
                return 1;
            fibonacci[n - 2] = Fibonacci(n - 2);
            fibonacci[n - 1] = Fibonacci(n - 1);
            return fibonacci[n - 2] + fibonacci[n - 1];
        }

public static string Reverse(string original)
        {
            string reverse = "";
            for (int i = original.Length-1; i >= 0; i--)
                reverse += original[i];
            return reverse;
        }

public static string DecimalABinario(int n)
        {
            if (n == 0) return "0";
            string a = "";
            while (true)
            {
                if (n / 2 == 1)
                {
                    a = n % 2 + a;
                    a = 1 + a;
                    break;
                }
                a = n % 2 + a;
                n = n / 2;
            }
            return a;
        }

/// <summary>
        /// Método portal
        /// </summary>
        public static string DecimalABinario(int dec)
        {
            return DecimalABinario(dec, ""); //Llamamos al método
        }
 
        private static string DecimalABinario(int dec, string result)
        {
            if (dec == 0)
                return "0" + result;
            if (dec == 1)
                return "1" + result;
            return DecimalABinario(dec / 2, (dec % 2) + result);
        }

 static int BinarioADecimal(string bin)
        {
            int dec = 0;
            for (int i = 0; i < bin.Length; i++)
                dec += (bin[i] - '0') * (int)Math.Pow(2, bin.Length - 1 - i);
            return dec;
        }

bin[i]-'0'

bin[i]

bin[i]-'0'

        /// <summary>
        /// Método portal
        /// </summary>
        static int BinarioADecimal(string bin)
        {
            return BinarioADecimal(bin, 0);
        }
 
        static int BinarioADecimal(string bin, int result)
        {
            if (bin.Length == 0)
                return result;
            return BinarioADecimal(bin.Remove(0, 1), result + (int)(Math.Pow(2, bin.Length - 1) * (bin[0] - '0')));
        }

/// <summary>
        /// Método portal
        /// </summary>
        static int PalindromInsertions(string line)
        {
            if (line.Length == null)
                throw new NullReferenceException("La cadena no puede ser null");
            if (line.Length == 1)
                return 0;
            return PalindromInsertions(line, 0, line.Length - 1);
        }
 
        static int PalindromInsertions(string line, int inf, int sup)
        {
            if (inf > sup)
                return 0;
            if (line[inf] == line[sup])
                return PalindromInsertions(line, inf + 1, sup - 1);
            else
                return Math.Min(1 + PalindromInsertions(line, inf + 1, sup), 
                    1 + PalindromInsertions(line, inf, sup - 1));
        }

public static void RotarDerecha(int[] a, int veces)
        {
            if (veces == a.Length || veces % a.Length == 0) return;
            int aMover = a[0];
            int posicion = 0;
            int contador = 0;
            while (contador < a.Length)
            {
                int proxPosicion = (posicion + veces) % a.Length; //Calculamos nueva posición
                int proxValor = a[proxPosicion]; //Guardamos el elemento que esta en esa nueva posición
                a[proxPosicion] = aMover; //Ponemos el elemento a mover en la nueva posición
                aMover = proxValor; //Asignamos a la variable del elemento a mover el valor que estaba en la nueva posición
                posicion = proxPosicion; //Guardamos la posición del nuevo elemento
                contador++; //Hicimos un movimiento
            }
        }

string[] valores = {"a", "b", "c", "d", "e"};

 //Variaciones con repetición de N elementos en M
        /// <summary>
        ///  Método portal
        /// </summary>
        static void VariacionesConRepeticion(string[] original, int size)
        {
            VariacionesConRepeticion(original, new string[size], 0);
        }
 
        static void VariacionesConRepeticion(string[] original, string[] variacion, int pos)
        {
            if (pos == variacion.Length)
            {
                Print(variacion); //Llama al método Print(), el cual lo que hace es imprimir un array en pantalla.
                Console.WriteLine();
            }
            else
            {
                for (int i = 0; i < original.Length; i++)
                {
                    variacion[pos] = original[i];
                    VariacionesConRepeticion(original, variacion, pos + 1);
                }
            }
        }

static void Print<T>(T[] array)
        {
            for (int i = 0; i < array.Length; i++)
            {
                if (i == array.Length - 1)
                    Console.Write(array[i]); //Imprimimos el elemento del array es el último elemento
                else
                    Console.Write(array[i] + " "); //Imprimimos el elemento del array más un espacio si no es el último elemento
            }
        }

string[] valores = {"a", "b", "c", "d", "e"};

string[] valores = {"a", "b", "c", "d", "e"};

 static void Swap<T>(ref T a, ref T b)
        {
            T temp = a;
            a = b;
            b = temp;
        }

static void Main(string[] args)
{
     int numberOne = 1;
     Inc(ref numberOne);
     Console.WriteLine(numberOne); //El valor que se imprimirá será 2
}
 
public static void Inc(ref int number)
{
     number++;
}
 

//Variaciones sin repetición de N elementos en M
        /// <summary>
        ///  Método portal
        /// </summary>
        static void VariacionesSinRepeticion(string[] original, int size)
        {
            VariacionesSinRepeticion(original, size, 0);
        }
 
        static void VariacionesSinRepeticion(string[] original, int size, int pos)
        {
            if (pos == size)
            {
                Print(original, size);
                Console.WriteLine();
            }
            else
            {
 
                for (int i = pos; i < original.Length; i++)
                {
                    Swap(ref original[pos], ref original[i]);
                    VariacionesSinRepeticion(original, size, pos+1);
                    Swap(ref original[pos], ref original[i]);
                }
 
            }
 
        }

string[] letras = { "a", "b", "c" };

string[] destino = new string[size];
Array.Copy(original, destino, size);

string[] valores = {"a", "b", "c", "d", "e"};

        /// <summary>
        /// Método portal
        /// </summary>
        static void Combinaciones<T>(T[] letras, int m)
        {
            Combinaciones(letras, new T[m], 0, 0);
        }

static void Combinaciones<T>(T[] original, T[] combinacion,
            int posOriginal, int posCombinacion )
        {
            if (posCombinacion == combinacion.Length)
            {
                Print(combinacion); //Imprimimos la combinación
                Console.WriteLine(); //Hacemos un salto de linea en la consola
            }
            else if (posOriginal == original.Length)
                return;
            else
            {
                combinacion[posCombinacion] = original[posOriginal];
                Combinaciones(original, combinacion, posOriginal + 1, posCombinacion + 1);
                Combinaciones(original, combinacion, posOriginal + 1, posCombinacion);
            }
        }

string[] original = {"a", "b", "c", "d", "e"};

combinacion[posCombinacion] = original[posOriginal];

Combinaciones(original, combinacion, posOriginal + 1, posCombinacion + 1);

Combinaciones(original, combinacion, posOriginal + 1, posCombinacion);

combinacion[posCombinacion] = original[posOriginal];

'4' '2' '10' '+' '*' '5' '-' = '43'

static long EvalPosFixed(string[] exp)
        {
            Stack<long> values = new Stack<long>();
            long first, second = 0;
            for (int i = 0; i < exp.Length; i++)
            {
                switch (exp[i])
                {
                    case "+":
                        if (values.Count < 2)
                            throw new Exception("There are not enough arguments to operate");
                        second = values.Pop();
                        first = values.Pop();
                        values.Push(first + second);
                        break;
                    case "-":
                        if (values.Count < 2)
                            throw new Exception("There are not enough arguments to operate");
                        second = values.Pop();
                        first = values.Pop();
                        values.Push(first - second);
                        break;
                    case "*":
                        if (values.Count < 2)
                            throw new Exception("There are not enough arguments to operate");
                        second = values.Pop();
                        first = values.Pop();
                        values.Push(first * second);
                        break;
                    case "/":
                        if (values.Count < 2)
                            throw new Exception("There are not enough arguments to operate");
                        second = values.Pop();
                        if (second == 0)
                            throw new DivideByZeroException("Can't divide by 0");
                        first = values.Pop();
                        values.Push(first / second);
                        break;
                    default:
                        values.Push(long.Parse(exp[i]));
                        break;
                }
            }
            if (values.Count > 1)
                throw new Exception("The expression had more arguments than it should have");
            return values.Peek();
        }

string[] expresion = { "4", "2", "10", "+", "*", "5", "-"};